InstancedMeshRenderSystem.h

#pragma once
 
#include "RenderSystem.h"
#include "Scene/GetBounds.h"
#include "Scene/RayPick.h"
 
#include "../../Components/Core/InstancedMeshRenderComponent.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
namespace Cogs::Core
{
  class Context;
 
  class InstancedMeshRenderSystem;
 
  class InstancedMeshRenderBounds final : public IGetBounds {
  public:
    explicit InstancedMeshRenderBounds(InstancedMeshRenderSystem* system) : system(system) {}
 
    virtual void getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds) override;
    virtual bool getBounds(Context* context, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const override;
 
  private:
    InstancedMeshRenderSystem* system = nullptr;
  };
 
  struct InstancedMeshPicker : MeshRayPickableBase
  {
    explicit InstancedMeshPicker(InstancedMeshRenderSystem* 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;
 
    InstancedMeshRenderSystem* system = nullptr;
  };
 
  // ----
 
  struct InstancedMeshRenderData
  {
    MeshRenderDataFlags flags = MeshRenderDataFlags::None;
    uint32_t cullingIndex = NoCullingIndex;
 
    uint16_t localBoundsGeneration = 0;
    uint16_t worldBoundsGeneration = 0;
    uint8_t meshBoundsGeneration = 0;
    uint8_t instanceMeshBoundsGeneration = 0;
 
    glm::mat4 localToWorld;
 
    ComponentModel::ComponentHandle meshComponent = ComponentModel::ComponentHandle::Empty();
    ComponentModel::ComponentHandle transformComponent = ComponentModel::ComponentHandle::Empty();
  };
 
  class InstancedMeshRenderSystem : public ComponentSystemWithDataPools<InstancedMeshRenderComponent, InstancedMeshRenderData, LocalBounds, WorldBounds>
  {
    using base_type = Cogs::Core::ComponentSystemWithDataPools<InstancedMeshRenderComponent, InstancedMeshRenderData, LocalBounds, WorldBounds>;
  public:
    InstancedMeshRenderSystem(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 InstancedMeshRenderComponent * component, const Geometry::BoundingBox & bbox)
    {
      getLocalBounds(component) = bbox;
      auto & data = getData<InstancedMeshRenderData>(component);
      data.flags |= MeshRenderDataFlags::LocalBoundsOverride;
      ++data.localBoundsGeneration;
    }
 
    Geometry::BoundingBox & getLocalBounds(const InstancedMeshRenderComponent * component)
    {
      return this->getData<LocalBounds>(component);
    }
 
    Geometry::BoundingBox & getWorldBounds(const InstancedMeshRenderComponent * 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<InstancedMeshRenderBounds> bounds;
    std::unique_ptr<InstancedMeshPicker> picker;
  };
}