SubMeshRenderSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Services/TaskManager.h"
#include "Scene/RayPick.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
namespace Cogs::Core
{
  class Context;
  class SubMeshRenderSystem;
 
  struct SubMeshRenderData
  {
    glm::mat4 localToWorld;
 
    uint16_t localBoundsGeneration = 0;
    uint16_t worldBoundsGeneration = 0;
    uint8_t meshBoundsGeneration = 0;
 
    uint32_t cullingIndex = (uint32_t)-1;
 
    uint32_t flags = 0;
 
    ComponentModel::ComponentHandle meshComponent = ComponentModel::ComponentHandle::Empty();
    ComponentModel::ComponentHandle transformComponent = ComponentModel::ComponentHandle::Empty();
  };
 
  struct SubMeshLocalBounds : public Geometry::BoundingBox
  {
 
  };
 
  struct SubMeshWorldBounds : public Geometry::BoundingBox
  {
 
  };
 
  struct SubMeshPicker : MeshRayPickableBase
  {
    explicit SubMeshPicker(SubMeshRenderSystem* 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;
 
    SubMeshRenderSystem* system = nullptr;
  };
 
  class SubMeshRenderSystem : public ComponentSystemWithDataPools<SubMeshRenderComponent, SubMeshRenderData, SubMeshLocalBounds, SubMeshWorldBounds>
  {
    using base_type = Cogs::Core::ComponentSystemWithDataPools<SubMeshRenderComponent, SubMeshRenderData, SubMeshLocalBounds, SubMeshWorldBounds>;
  public:
    SubMeshRenderSystem(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; }
 
    Geometry::BoundingBox & getLocalBounds(const SubMeshRenderComponent * component)
    {
      return this->getData<SubMeshLocalBounds>(component);
    }
 
    Geometry::BoundingBox & getWorldBounds(const SubMeshRenderComponent * component)
    {
      return this->getData<SubMeshWorldBounds>(component);
    }
 
    void setBounds(const SubMeshRenderComponent * component, Geometry::BoundingBox & box, const glm::mat4 & worldTransform)
    {
      getWorldBounds(component) = box;
      auto & data = getData<SubMeshRenderData>(component);
      data.localToWorld = worldTransform;
      data.flags = 1;
    }
 
    void initializeCulling(struct CullingSource * cullData);
 
  private:
    bool needsPost = true;
    TaskId geometryGroup = NoTask;
 
    std::unique_ptr<SubMeshPicker> picker;
  };
}