CameraSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "Components/Core/CameraComponent.h"
 
#include "Services/TaskManager.h"
 
#include "Utilities/FrustumClassification.h"
 
#include "CullingData.h"
 
#include "Rendering/Common.h"
 
#include "Foundation/Collections/Pool.h"
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Geometry/Frustum.hpp"
 
namespace Cogs
{
  namespace Core
  {
    class Context;
    struct EnvironmentComponent;
 
    struct RenderPass
    {
      enum ERenderPass
      {
        Main = 0,
        Reflection,
        Refraction,
        Other
      };
    };
 
    struct RenderPassOptions
    {
      enum struct Flags : uint32_t {
        None = 0,
        NoDepthClip,
        ScissorTest
      };
      Flags flags = Flags::None;      // Part of hash
      float depthBias = 0.f;          // Part of hash
      float depthSlopedBias = 0.f;    // Part of hash
      float depthBiasClamp = 0.f;     // Part of hash
      uint32_t multiViews = 0;        // Part of hash. If non-zero, multi-view rendering is requested.
      glm::ivec4 scissorRectangle{};  // Not part of hash
 
      void setFlag(Flags flag) { flags = Flags(uint32_t(flags) | uint32_t(flag)); }
      void unsetFlag(Flags flag) { flags = Flags(uint32_t(flags) & ~uint32_t(flag)); }
      bool getFlag(Flags flag) const { return (uint32_t(flags) & uint32_t(flag)) != 0; }
 
      size_t hash = 0;
 
      COGSCORE_DLL_API void updateHash();
    };
 
    struct CameraData
    {
      CameraData() = default;
 
      CameraData(const CameraData & other) = delete;
 
      CameraData& operator=(const CameraData& other) = default;
 
      void (*bindRenderTargetCallback)(void* clientData) = nullptr;
      void* bindRenderTargetCallbackData = nullptr;
 
      RenderLayers layerMask = RenderLayers::Default;
      LightingLayers lightingMask = LightingLayers::Default;
 
      bool reflection = false;
      bool flipWindingOrder = false;
      bool useClearColor = false;
 
      glm::mat4 viewMatrix;
      glm::mat4 projectionMatrix;
 
      glm::mat4 viewProjection;
      glm::mat4 inverseViewMatrix;
      glm::mat4 inverseViewProjectionMatrix;
      glm::mat4 inverseProjectionMatrix;
      glm::mat4 viewFromViewportMatrix;
 
      glm::mat4 prevViewProjection;
 
      glm::vec2 viewportSize;
      glm::vec2 viewportOrigin;
      glm::vec4 clearColor;
 
      glm::uvec2 blueNoiseOffset;
 
      Geometry::Frustum frustum;
      Geometry::BoundingBox sceneBounds;
 
      RenderPassOptions* passOptions = nullptr;
 
      float nearDepthBounds = 0.f;
      float farDepthBounds = 0.f;
      float nearClipPlanes = 0.f;
      float farClipPlanes = 0.f;
 
      float nearDistance = 0.f;
      float farDistance = 0.f;
      float fieldOfView = 0.f;
      float depthClamp = 0.f;
      float discardThreshold = 0.f;
      float keepThreshold = 0.f;
      float exposure = 2.f;
 
      uint32_t clientFlags = 0;    // Custom client flags passed from the camera to the shaders.
 
      ComponentModel::ComponentHandle camera = ComponentModel::ComponentHandle::Empty();
      ComponentModel::ComponentHandle environment = ComponentModel::ComponentHandle::Empty();
      ComponentModel::ComponentHandle cameraArray = ComponentModel::ComponentHandle::Empty();
 
      glm::mat4 rawProjectionMatrix;
      glm::mat4 rawViewProjection;
      glm::mat4 rawViewCullMatrix;
 
      std::shared_ptr<CullingData> cullingData;
 
      RenderPass::ERenderPass renderPass = RenderPass::Main;
      int rayPickId = -1;
    };
 
    class CameraSystem : public ComponentSystemWithDataPool<CameraComponent, CameraData>
    {
      using base = ComponentSystemWithDataPool<CameraComponent, CameraData>;
    public:
      CameraSystem(Memory::Allocator * allocator, SizeType capacity) :
        ComponentSystemWithDataPool(allocator, capacity),
        cullingData(MemBlockType::CullingData)
      {}
 
      void update(Context * context) override;
 
      void postUpdate(Context * context) override;
 
      void updateProjection(Context * context, const CameraComponent & cameraComponent);
 
      bool updateClippingPlanes(Context * context, const CameraComponent & cameraComponent, bool secondPass);
 
      void setMainCamera(ComponentModel::ComponentHandle mainCamera) { this->mainCamera = mainCamera; }
 
      ComponentHandle createComponent() override;
 
      CameraComponent * getMainCamera() const { return mainCamera.resolveComponent<CameraComponent>(); }
 
      const CameraData & getMainCameraData() const { return getData(getMainCamera()); }
 
      void postRender(const Context* context);
 
      Collections::Pool<CullingData> cullingData;
 
    private:
      ComponentModel::ComponentHandle mainCamera = ComponentModel::ComponentHandle::Empty();
      int nextRayPickId = 1;
    };
  }
}