OceanSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "OceanComponent.h"
#include "ExtensionRegistry.h"
 
#include "RenderContext.h"
 
#include "Resources/Resources.h"
#include "Resources/MeshStreamsLayout.h"
 
namespace Cogs
{
  namespace Core
  {
    class TerrainSystem;
    class ViewContext;
 
    class OceanPicker : public IRayPickable
    {
    public:
      OceanPicker(OceanComponent * oceanComponent, OceanData * oceanData);
 
      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;
 
    protected:
      OceanComponent * oceanComponent;
      OceanData * oceanData;
    };
 
    class OceanBounds : public IGetBounds
    {
    public:
      OceanBounds(OceanComponent * oceanComponent, OceanData * oceanData) : oceanComponent(oceanComponent), oceanData(oceanData) {}
 
      void getBounds(Context * context, Cogs::Geometry::BoundingBox & bounds, float& nearPlaneLimit) final;
 
      void getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds) final;
 
    protected:
      OceanComponent * oceanComponent;
      OceanData * oceanData;
    };
 
    struct OceanData
    {
      OceanComponent * oceanComponent;
 
      bool initialized = false;
      bool first = true;
 
      MaterialHandle oceanMaterial;
 
      MeshStreamsLayout streamsLayout;
      MaterialInstanceHandle material;
 
      TextureHandle reflectionTexture;
      TextureHandle skyDomeTexture;
 
      EntityPtr reflectionCamera;
 
      TerrainData * terrainData;
 
      std::unique_ptr<OceanPicker> rayPick;
      std::unique_ptr<OceanBounds> bounds;
 
      Geometry::BoundingBox bbox;
    };
 
    class OceanSystem final : public ComponentSystemWithDataPool<OceanComponent, OceanData>
    {
    public:
      OceanSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
      void initialize(Context * context) override;
      void update(Context * context) override;
 
      void destroyComponent(ComponentHandle component) override;
 
      TerrainSystem * terrainSystem;
      Cogs::VertexFormatHandle oceanFormat;
 
 
    };
  }
}