SeaCurrentsSystem.h

#pragma once
 
#include "SeaCurrentsComponent.h"
 
#include "Resources/Resources.h"
#include "Resources/MeshStreamsLayout.h"
#include "Systems/ComponentSystem.h"
#include "Scene/GetBounds.h"
 
#include "Rendering/VertexFormat.h"
#include "Foundation/Geometry/Glm.hpp"
 
namespace Cogs {
  namespace Core {
    class Context;
    class SeaCurrentsRenderer;
    class SeaCurrentsSystem;
 
    struct InstanceData {
      glm::vec4   pos;        // x,y = position. z = scale. w = angle.
      uint32_t    colour = 0;
    };
 
    class SeaCurrentsBounds final : public IGetBounds {
    public:
      explicit SeaCurrentsBounds(SeaCurrentsSystem* seaCurrentSystem) : seaCurrentSystem(seaCurrentSystem) {}
 
      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:
      SeaCurrentsSystem* seaCurrentSystem = nullptr;
    };
 
    struct SeaCurrentsData {
      SeaCurrentsSystem* mSystem = nullptr;
      std::vector<InstanceData>   mData;
      BufferHandle                mBufferHandle;
      size_t                      mBufferSize = 0;
      Cogs::Geometry::BoundingBox mBounds;
      Cogs::Geometry::BoundingBox mTransformedBounds;
      glm::mat4                   mWorldMatrix;
    };
 
    class SeaCurrentsSystem : public ComponentSystemWithDataPool<SeaCurrentsComponent, SeaCurrentsData> {
      using base_type = Cogs::Core::ComponentSystemWithDataPool<SeaCurrentsComponent, SeaCurrentsData>;
    public:
      SeaCurrentsSystem(Memory::Allocator* allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
     
      float minScale = 0.2f; // The minimum speed related arrow scaling factor
      float maxScale = 1.0f; // The maximum speed related arrow scaling factor
      float lowestSpeed = 0.01f; // The lowest speed used for arrow scaling
      float highestSpeed = 13.0f; // The highest speed used for arrow scaling
 
      virtual void                          initialize(Context* context) override;
      virtual void                          update(Context* /*context*/) override;
      virtual void                          cleanup(Context* context) override;
 
      virtual ComponentHandle createComponent() override;
      virtual void destroyComponent(ComponentHandle component) override;
 
      const MeshHandle& getArrowMesh() const { return mArrowMesh; }
      const VertexFormat& getVertexFormat() const { return mVertexFormat; }
      const VertexFormatHandle& getVertexFormatHandle() const { return mVertexFormatHandle; }
      const MaterialInstanceHandle& getMaterialHandle() const { return mMaterial; }
      const MeshStreamsLayout& getArrowInstancesStreamsLayout() const { return arrowInstancesStreamsLayout; }
 
      Cogs::Geometry::BoundingBox getWorldBounds(const SeaCurrentsComponent& seaCurrentsComponent, bool ignoreVisibility) const;
 
    private:
      MeshStreamsLayout arrowInstancesStreamsLayout;
      MeshHandle                    mArrowMesh;
      VertexFormat                  mVertexFormat = {};
      VertexFormatHandle            mVertexFormatHandle;
      MaterialInstanceHandle        mMaterial;
      SeaCurrentsRenderer* mRenderer = nullptr;
      std::unique_ptr<SeaCurrentsBounds> bounds;
    };
  }
}