TerrainSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "TerrainComponent.h"
#include "Resources/Resources.h"
#include "Resources/MeshStreamsLayout.h"
#include "Scene/RayPick.h"
#include "Scene/GetBounds.h"
 
#include "RenderContext.h"
#include "Rendering/VertexFormat.h"
 
namespace Cogs
{
  struct TerrainContext;
 
  namespace Core
  {
    struct TerrainData;
    class TerrainSystem;
 
    class TerrainPicker : public IRayPickable
    {
    public:
      TerrainPicker(TerrainSystem* terrainSystem) : terrainSystem(terrainSystem) {}
 
      bool pickCamera(Context* context,
                      const CameraComponent& camera,
                      const glm::vec2& normPosition,
                      float /*rayLength*/,
                      float /*radius*/,
                      PickingFlags pickingFlags,
                      PicksReturned returnFlag,
                      const RayPicking::RayPickFilter& filter,
                      std::vector<RayPicking::RayPickHit>& hits) override;
 
      TerrainSystem* terrainSystem = nullptr;
    };
 
    class TerrainBounds : public IGetBounds
    {
    public:
      TerrainBounds(TerrainComponent * terrain, TerrainData * terrainData) : terrain(terrain), terrainData(terrainData) {}
 
      void getBounds(Context * context, Cogs::Geometry::BoundingBox & bounds, float& nearPlaneLimit) final;
 
      void getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds) final { float ignored = 0.f; getBounds(context, bounds, ignored); }
 
    private:
      TerrainComponent * terrain;
      TerrainData * terrainData;
    };
 
    struct TerrainData
    {
      TerrainData() = default;
      TerrainData(const TerrainData &) = delete;
 
      bool initialized = false;
      bool visible = true;
 
      glm::dvec3 offset;
 
      TerrainContext * context = nullptr;
 
      int maxTilesPerFrame = 16;
 
      RenderContext renderContext;
 
      MeshStreamsLayout terrainStreamsLayout;
 
      MaterialInstanceHandle material;
      MaterialInstanceHandle depthMaterial;
 
      std::string customComputeColor;
 
      std::unique_ptr<TerrainBounds> getBounds;
 
      Geometry::BoundingBox bbox;
 
      float nearPlaneLimit = 0.0f;
 
      struct OceanData * oceanData = nullptr;
 
      bool viewportFromTarget = true; // TODO set this somehow
    };
 
    class TerrainSystem final : public ComponentSystemWithDataPool<TerrainComponent, TerrainData>
    {
    public:
      TerrainSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
      void initialize(Context * context) override;
      void update(Context * context) override;
      void cleanup(Context* context) override;
 
      ComponentModel::ComponentHandle createComponent() override;
      void destroyComponent(ComponentHandle component) override;
 
    private:
      class TerrainRenderer * terrainRenderer = nullptr;
 
      Cogs::VertexFormatHandle terrainFormat;
 
      TerrainPicker* picker = nullptr;
    };
  }
}