ViewContext.cpp

#include "ViewContext.h"
 
#include "Components/Behavior/OrbitingCameraController.h"
#include "Input/InputManager.h"
#include "Platform/Gamepad.h"
#include "Renderer/IRenderer.h"
#include "Renderer/RenderResources.h"
#include "Renderer/RenderTexture.h"
#include "Services/DPIService.h"
#include "Resources/TextureManager.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ISwapChain.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("ViewContext");
}
 
 
Cogs::Core::ViewContext::ViewContext(Context* ctx, WindowData* windowData)
  : dpiService(std::make_unique<DPIService>())
  , gamepadHandler(std::make_unique<Platform::GamepadHandler>())
  , inputManager(std::make_unique<InputManager>(this))
  , context(ctx) {
  setWindowData(windowData);
}
 
Cogs::Core::ViewContext::~ViewContext() {
  if(texture) {
    CameraComponent* cameraComp = getCameraComponent();
 
    if (cameraComp) {
      cameraComp->renderTexture = TextureHandle::NoHandle;
    }
 
    EntityPtr cam = camera.lock();
    if (cam) {
      if (OrbitingCameraController* occ = cam->getComponent<OrbitingCameraController>(); occ) {
        occ->attachToView(nullptr);
        occ->setChanged();
      }
    }
 
    RenderResource* renderTexture = texture->getAttachedResource();
    if (renderTexture) {
      static_cast<RenderResources*>(context->renderer->getResources())->destroyResource(renderTexture);
      texture->attachResource(nullptr);
    }
  }
  if (swapChain && (swapChain != context->device->getDefaultSwapChain())) {
    context->device->deleteSwapChain(swapChain);
    swapChain = nullptr;
  }
}
 
bool Cogs::Core::ViewContext::initialize(const Cogs::Core::EntityPtr& renderCamera) {
  // For the default view, renderCamera is null because it will be set to the mainCamera after the scene is initialized.
  if (!renderCamera) {
    swapChain = context->device->getDefaultSwapChain();
  }
  else {
    swapChain = context->device->createSwapChain(refWindowData());
    if (!swapChain) {
      LOG_WARNING(logger, "Swapchain creation failed, falling back to the default one.");
      swapChain = context->device->getDefaultSwapChain();
    }
  }
 
  texture = context->textureManager->create();
  texture->description.flags = TextureFlags::Texture | TextureFlags::RenderTarget | TextureFlags::ExternalTexture;
  texture->description.format = context->device->getSettings().colorFormat;
 
  RenderTexture* renderTexture = static_cast<RenderResources*>(context->renderer->getResources())->createRenderTexture();
  renderTexture->setPersistent();
  renderTexture->setOwned();
  renderTexture->setResource(texture.resolve());
  renderTexture->swapChain = swapChain;
 
  texture->attachResource(renderTexture);
 
  if (renderCamera) {
    setCamera(renderCamera);
  }
 
  if(refWindowData()){
    inputManager->initialize();
 
    refGestures().setDisplayScale(dpiService->getScaleFactor());
    gamepadHandler->initialize(this);
  }
 
  return true;
}
 
void Cogs::Core::ViewContext::update() {
  if (refWindowData()) {
    inputManager->update();
  }
}
 
void Cogs::Core::ViewContext::preRender() {
  if (swapChain && texture) {
    texture->description.width = swapChain->getWidth();
    texture->description.height = swapChain->getHeight();
  }
}
 
void Cogs::Core::ViewContext::setCamera(const Cogs::Core::EntityPtr& renderCamera) {
  camera = renderCamera;
  texture->getAttachedResource()->setName("ViewTexture (" + renderCamera->getName() + ")");
 
  CameraComponent* cameraComp = getCameraComponent();
  cameraComp->renderTexture = texture;
  cameraComp->setChanged();
 
  if (OrbitingCameraController* occ = renderCamera->getComponent<OrbitingCameraController>(); occ) {
    occ->attachToView(this);
    occ->setChanged();
  }
}
 
void Cogs::Core::ViewContext::setSize(int newWidth, int newHeight) {
  if (context->engine->isReady()) {
    if (swapChain) {
      swapChain->setSize(newWidth, newHeight);
    }
    else if ((context->getDefaultView() == this) && context->device) {
      context->device->setSize(newWidth, newHeight);
    }
 
    glm::vec2 vpSize(newWidth, newHeight);
    Cogs::Core::CameraComponent* cameraComp = getCameraComponent();
 
    if (vpSize != cameraComp->viewportSize) {
      cameraComp->viewportSize = vpSize;
      cameraComp->setChanged();
 
      if (texture) {
        RenderResource* attachment = texture->getAttachedResource();
 
        if (attachment) {
          attachment->incrementGeneration();
        }
      }
    }
    for (ResizeCallback* cb : resizeCallbacks) {
      cb(this, newWidth, newHeight);
    }
  }
  context->engine->triggerUpdate();
}
 
void Cogs::Core::ViewContext::setDPI(int newDPI, float scaleFactor) {
  dpiService->set(newDPI, scaleFactor);
 
  context->engine->triggerUpdate();
}
 
glm::vec2 Cogs::Core::ViewContext::getSize() const {
  if (swapChain) {
    return glm::vec2(swapChain->getWidth(), swapChain->getHeight());
  }
  int width;
  int height;
 
  if (context->device->getSize(width, height)) {
    return glm::vec2(width, height);
  }
  return glm::vec2(0.0f);
}
 
Cogs::Core::EntityPtr Cogs::Core::ViewContext::getCamera() const
{
  return camera.lock();
}
 
Cogs::Core::CameraComponent* Cogs::Core::ViewContext::getCameraComponent() const {
  EntityPtr cam = camera.lock();
  return cam ? cam->getComponent<CameraComponent>() : context->cameraSystem->getMainCamera();
}
 
void Cogs::Core::ViewContext::addResizeCallback(ResizeCallback* callback) {
  auto  e = resizeCallbacks.end();
 
  if (std::find(resizeCallbacks.begin(), e, callback) == e) {
    resizeCallbacks.push_back(callback);
  }
}
 
void Cogs::Core::ViewContext::removeResizeCallback(ResizeCallback* callback) {
  auto e = resizeCallbacks.end();
  auto i = std::find(resizeCallbacks.begin(), e, callback);
 
  if (i != e) {
    resizeCallbacks.erase(i);
  }
}