CameraSystem.cpp

#include "CameraSystem.h"
 
#include "Components/Core/TransformComponent.h"
 
#include "Renderer/CullingManager.h"
#include "Renderer/IRenderer.h"
#include "Renderer/RenderTexture.h"
 
#include "Resources/Texture.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/EnvironmentSystem.h"
 
#include "Scene/GetBounds.h"
 
#include "Platform/Instrumentation.h"
 
#include "Context.h"
#include "Engine.h"
 
#include "Rendering/IContext.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/ComponentModel/Component.h"
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Logging/Logger.h"
 
using namespace glm;
using namespace Cogs::Geometry;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("CameraSystem");
}
 
 
void Cogs::Core::RenderPassOptions::updateHash()
{
  hash = Cogs::fnv1a(reinterpret_cast<uint8_t*>(this), offsetof(RenderPassOptions, scissorRectangle));
}
 
ComponentHandle Cogs::Core::CameraSystem::createComponent()
{
  auto component = ComponentSystemWithDataPool::createComponent();
  auto & data = getData(component.resolveComponent<CameraComponent>());
  data.camera = component;
  return component;
}
 
void Cogs::Core::CameraSystem::postRender(const Context* context) {
  RenderResources*  resources = static_cast<RenderResources*>(context->renderer->getResources());
 
  for (auto& cameraComponent : pool) {
    RenderTexture*  sourceTexture = resources->getRenderTexture(cameraComponent.renderTexture);
    RenderTexture*  destTexture = resources->getRenderTexture(cameraComponent.resolveTarget);
 
    if (sourceTexture && destTexture) {
      IContext* gfxContext = context->device->getImmediateContext();
 
      assert(cameraComponent.renderTexture->description.width == cameraComponent.resolveTarget->description.width);
      assert(cameraComponent.renderTexture->description.height == cameraComponent.resolveTarget->description.height);
 
      if (cameraComponent.renderTexture->description.samples > 1) {
        gfxContext->resolveResource(sourceTexture->textureHandle, destTexture->textureHandle);
      }
      else {
        gfxContext->copyResource(destTexture->textureHandle, sourceTexture->textureHandle);
      }
    }
  }
}
 
void Cogs::Core::CameraSystem::update(Context * context)
{
 
  for (auto & cameraComponent : pool) {
    auto & cameraData = getData(&cameraComponent);
 
    if (!std::isfinite(cameraComponent.nearPlaneLimit) ||
        !std::isfinite(cameraComponent.farPlaneLimit) ||
        (cameraComponent.farDistance <= cameraComponent.nearPlaneLimit))
    {
      LOG_ERROR(logger, "Broken camera invariants, nearPlaneLimit=%f, setting to 1.0, farPlaneLimit=%f, setting to 100000.0",
                cameraComponent.nearPlaneLimit,
                cameraComponent.farPlaneLimit);
      cameraComponent.nearPlaneLimit = 1.f;
      cameraComponent.nearPlaneLimit = 100000.f;
    }
 
 
    if (cameraComponent.environment) {
      cameraData.environment = cameraComponent.environment->getComponentHandle<EnvironmentComponent>();
    } else if (auto * env = context->environmentSystem->getGlobalEnvironment(); env) {
      cameraData.environment = env->getComponentHandle<EnvironmentComponent>();
    }
    else {
      cameraData.environment = ComponentHandle::Empty();
    }
 
    if (cameraComponent.supportsPicking() && &cameraComponent != mainCamera.resolve()) {
      if (cameraData.rayPickId == -1) {
        cameraData.rayPickId = nextRayPickId++;
      }
    }
 
    auto transformComponent = cameraComponent.getContainer()->getComponent<TransformComponent>();
 
    if (!transformComponent) {
      LOG_ERROR(logger, "Camera %s missing transform component.", cameraComponent.getContainer()->getName().c_str());
      continue;
    }
 
    cameraData.exposure = cameraComponent.exposure;
    cameraData.layerMask = cameraComponent.layerMask;
    cameraData.lightingMask = cameraComponent.lightingMask;
    cameraData.viewportSize = cameraComponent.viewportSize;
    cameraData.viewportOrigin = cameraComponent.viewportOrigin;
    cameraData.viewMatrix = glm::inverse(context->transformSystem->getLocalToWorld(transformComponent));
    cameraData.inverseViewMatrix = context->transformSystem->getLocalToWorld(transformComponent);
 
    if ((cameraComponent.flags & CameraFlags::OverrideClearColor) == CameraFlags::OverrideClearColor) {
      cameraData.clearColor = cameraComponent.clearColor;
      cameraData.useClearColor = true;
    }
    else {
      cameraData.useClearColor = false;
    }
    if (cameraData.viewportSize.x == 0 && HandleIsValid(cameraComponent.renderTexture)) {
      auto cameraTexture = cameraComponent.renderTexture;
 
      cameraData.viewportSize = { cameraTexture->description.width, cameraTexture->description.height };
    }
 
    cameraData.discardThreshold = 4.f*(cameraComponent.discardThreshold) / (cameraData.viewportSize.x*cameraData.viewportSize.y);
    cameraData.keepThreshold = cameraComponent.keepThreshold;
  }
 
  for (auto & cameraComponent : pool) {
    updateClippingPlanes(context, cameraComponent, false);
    updateProjection(context, cameraComponent);
  }
 
}
 
void Cogs::Core::CameraSystem::postUpdate(Context * context)
{
  context->cullingManager->initializeCulling();
 
  for (auto & cameraComponent : pool) {
    if (updateClippingPlanes(context, cameraComponent, true)) {
      updateProjection(context, cameraComponent);
    }
  }
 
  base::postUpdate(context);
}
 
void Cogs::Core::CameraSystem::updateProjection(Context * context, const CameraComponent & cameraComponent)
{
  auto & cameraData = getData(&cameraComponent);
 
  float aspect = cameraData.viewportSize.y == 0 ? 1.0f : cameraData.viewportSize.x / cameraData.viewportSize.y;
 
  if (cameraComponent.projectionMode == ProjectionMode::Orthographic) {
    const float height = cameraComponent.orthoHeight / 2.0f;
 
    cameraData.rawProjectionMatrix = glm::ortho(-height * aspect, height * aspect,
                                                -height, height,
                                                cameraData.nearDistance,
                                                cameraData.farDistance);
  } else {
    cameraData.fieldOfView = cameraComponent.fieldOfView;
    cameraData.rawProjectionMatrix = glm::perspective(cameraComponent.fieldOfView,
                                                      aspect,
                                                      cameraData.nearDistance,
                                                      cameraData.farDistance);
  }
 
  if (glm::any(glm::notEqual(cameraComponent.subsetMin, glm::vec2(0.f)) || glm::notEqual(cameraComponent.subsetMax, glm::vec2(1.f)))) {
    const auto& a = cameraComponent.subsetMin;
    const auto& b = cameraComponent.subsetMax;
    glm::vec2 s = glm::vec2(2.f) / (b - a);
    if (std::isfinite(s.x) && std::isfinite(s.y)) {
      glm::vec2 o = s * (glm::vec2(1) - 2.f * a) - glm::vec2(1);
      cameraData.rawProjectionMatrix = glm::mat4(s.x, 0.f, 0.f, 0.f,
                                                 0.f, s.y, 0.f, 0.f,
                                                 0.f, 0.f, 1.f, 0.f,
                                                 o.x, o.y, 0.f, 1.f) * cameraData.rawProjectionMatrix;
    }
    else {
      LOG_WARNING(logger, "Invalid camera frustum subset [%f,%f]x[%f,%f], ignoring.", a.x, a.y, b.x, b.y);
    }
  }
 
 
  if((cameraComponent.flags & CameraFlags::FlipY) != 0){
    static glm::mat4 flip(
      1, 0, 0, 0,
      0, -1, 0, 0,
      0, 0, 1, 0,
      0, 0, 0, 1
    );
    cameraData.flipWindingOrder = true;
    cameraData.rawProjectionMatrix = flip * cameraData.rawProjectionMatrix;
  }
  else {
    cameraData.flipWindingOrder = false;
  }
 
  cameraData.prevViewProjection = cameraData.viewProjection;
  cameraData.rawViewProjection = cameraData.rawProjectionMatrix * cameraData.viewMatrix;
  cameraData.rawViewCullMatrix = cameraData.rawViewProjection;
  cameraData.projectionMatrix = context->renderer->getProjectionMatrix(cameraData.rawProjectionMatrix);
  cameraData.viewProjection = cameraData.projectionMatrix * cameraData.viewMatrix;
  cameraData.inverseViewProjectionMatrix = glm::inverse(cameraData.viewProjection);
  cameraData.inverseProjectionMatrix = glm::inverse(cameraData.projectionMatrix);
  cameraData.viewFromViewportMatrix = context->renderer->getViewFromViewportMatrix(cameraData.inverseProjectionMatrix);
 
  cameraData.clientFlags = cameraComponent.clientFlags;
  cameraData.frustum = Geometry::calculateFrustum<Geometry::Frustum, glm::mat4>(cameraData.viewProjection);
}
 
bool Cogs::Core::CameraSystem::updateClippingPlanes(Context * context, const CameraComponent & cameraComponent, bool secondPass)
{
  CpuInstrumentationScope(SCOPE_SYSTEMS, "CameraSystem::updateClippingPlanes");
 
  bool tightEstimate = context->variables->get("camera.tightBounds", false);
  auto & cameraData = getData(&cameraComponent);
 
  cameraData.sceneBounds = Geometry::BoundingBox();
 
  if (cameraComponent.enableClippingPlaneAdjustment) {
    context->bounds->getSceneBounds(context, reinterpret_cast<float *>(&cameraData.sceneBounds), cameraComponent.layerMask & ~RenderLayers::Sky);
    cameraData.sceneBounds = Bounds::getTransformedBounds(cameraData.sceneBounds, cameraData.viewMatrix);
 
    float nearDist = std::numeric_limits<float>::max();
    float farDist = -std::numeric_limits<float>::max();
 
    if (tightEstimate && secondPass) {
      CpuInstrumentationScope(SCOPE_SYSTEMS, "CameraSystem::getCameraDepthBounds");
      context->bounds->getCameraDepthBounds(context, nearDist, farDist, cameraComponent);
    } else if (!isEmpty(cameraData.sceneBounds)) {
      context->bounds->getClipPlanes(context, nearDist, farDist, cameraComponent, cameraData.viewMatrix);
      nearDist = std::max(nearDist, cameraComponent.nearPlaneLimit);
    }
 
    const float kMinRangeFactor = 0.0001f;
 
    if(nearDist == std::numeric_limits<float>::max() && farDist == -std::numeric_limits<float>::max()){
      nearDist = cameraComponent.nearPlaneLimit;
      farDist = cameraComponent.farPlaneLimit;
    }
 
    nearDist = glm::clamp(nearDist, cameraComponent.nearPlaneLimit, cameraComponent.farPlaneLimit * (1 - kMinRangeFactor));
    farDist = glm::clamp(farDist, glm::max(nearDist * (1 + kMinRangeFactor), nearDist + 1), cameraComponent.farPlaneLimit);
 
    assert(nearDist < farDist);
 
    const float calculationSlack = 0.001f;
 
    const float newNearPlane = nearDist * (1.0f - calculationSlack);
    const float newFarPlane = farDist * (1.0f + calculationSlack);
 
    if (newNearPlane != cameraData.nearDistance || newFarPlane != cameraData.farDistance) {
      cameraData.nearDistance = newNearPlane;
      cameraData.farDistance = newFarPlane;
 
      // TODO change camera system to only update clipping planes in one pass?
      if (tightEstimate && secondPass){
        if(cameraData.nearDepthBounds != newNearPlane || cameraData.farDepthBounds != newFarPlane){
          context->engine->setDirty();
          cameraData.nearDepthBounds = newNearPlane;
          cameraData.farDepthBounds = newFarPlane;
        }
      }
      else{
        if(cameraData.nearClipPlanes != newNearPlane || cameraData.farClipPlanes != newFarPlane){
          context->engine->setDirty();
          cameraData.nearClipPlanes = newNearPlane;
          cameraData.farClipPlanes = newFarPlane;
        }
      }
      return true;
    }
  } else {
    if (cameraComponent.nearDistance != cameraData.nearDistance || cameraComponent.farDistance != cameraData.farDistance) {
      cameraData.nearDistance = cameraComponent.nearDistance;
      cameraData.farDistance = cameraComponent.farDistance;
 
      context->engine->setDirty();
      return true;
    }
  }
 
  return false;
}