RenderSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "Components/Core/MeshRenderComponent.h"
 
#include "Services/TaskManager.h"
 
#include "Scene/RayPick.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
namespace Cogs::Core
{
  class Context;
  class RenderSystem;
 
  enum struct MeshRenderDataFlags
  {
    None = 0,
    LocalBoundsOverride = 1 << 0,
    WorldBoundsOverride = 1 << 2,
  };
 
  ENABLE_ENUM_FLAGS(MeshRenderDataFlags)
 
  constexpr uint32_t NoCullingIndex = static_cast<uint32_t>(-1);
 
  struct MeshRenderData
  {
    MeshRenderDataFlags flags = MeshRenderDataFlags::None;
    uint32_t cullingIndex = NoCullingIndex;
 
    uint16_t localBoundsGeneration = 0;
    uint16_t worldBoundsGeneration = 0;
    uint8_t meshBoundsGeneration = 0;
 
    glm::mat4 localToWorld;
 
    ComponentModel::ComponentHandle meshComponent = ComponentModel::ComponentHandle::Empty();
    ComponentModel::ComponentHandle transformComponent = ComponentModel::ComponentHandle::Empty();
  };
 
  struct LocalBounds : public Geometry::BoundingBox
  {
 
  };
 
  struct WorldBounds : public Geometry::BoundingBox
  {
 
  };
 
  struct MeshRenderPicker : MeshRayPickableBase
  {
    explicit MeshRenderPicker(RenderSystem* system) : system(system) {}
 
  private:
    bool pickImpl(Context* context,
                  const glm::mat4& worldPickMatrix,
                  const glm::mat4& rawViewProjection,
                  const glm::mat4& viewMatrix,
                  const RayPicking::RayPickFilter& filter,
                  PickingFlags pickingFlags,
                  PicksReturned returnFlag,
                  std::vector<RayPicking::RayPickHit>& hits) override;
 
    RenderSystem* system = nullptr;
  };
 
  class RenderSystem : public ComponentSystemWithDataPools<MeshRenderComponent, MeshRenderData, LocalBounds, WorldBounds>
  {
    using base_type = ComponentSystemWithDataPools<MeshRenderComponent, MeshRenderData, LocalBounds, WorldBounds>;
  public:
    RenderSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPools(allocator, capacity) {}
 
    void initialize(Context * context) override;
    void update(Context * context) override;
    void postUpdate(Context * context) override;
    void cleanup(Context * context) override;
 
    ComponentHandle createComponent() override;
    void destroyComponent(ComponentHandle component) override;
 
    TaskId getTaskGroup() const { return geometryGroup; }
 
    void setLocalBounds(const MeshRenderComponent * component, const Geometry::BoundingBox & bbox)
    {
      getLocalBounds(component) = bbox;
      auto & data = getData<MeshRenderData>(component);
      data.flags |= MeshRenderDataFlags::LocalBoundsOverride;
      ++data.localBoundsGeneration;
    }
 
    Geometry::BoundingBox & getLocalBounds(const MeshRenderComponent * component)
    {
      return this->getData<LocalBounds>(component);
    }
 
    Geometry::BoundingBox & getWorldBounds(const MeshRenderComponent * component)
    {
      return this->getData<WorldBounds>(component);
    }
 
    void initializeCulling(struct CullingSource* cullSource);
 
    size_t getGeneration() const { return generation; }
 
    class TransformSystem * transformSystem = nullptr;
 
  private:
    bool needsPost = true;
    size_t generation = 0;
    TaskId geometryGroup = NoTask;
 
    std::unique_ptr<MeshRenderPicker> picker;
  };
}