VectorFieldSystem.h

#pragma once
 
#include "Scene/GetBounds.h"
#include "Scene/RayPick.h"
#include "VectorFieldComponent.h"
#include "VectorFieldRenderer.h"
#include "Systems/ComponentSystem.h"
#include "Resources/VertexFormats.h"
#include "Resources/MeshStreamsLayout.h"
 
namespace Cogs::Core::VectorField
{
  struct InstanceData
  {
    glm::vec3 pos;
    uint32_t color;
    glm::quat rot;
    glm::vec4 scale;
  };
  class VectorFieldBounds : public IGetBounds
  {
  public:
    VectorFieldBounds(VectorFieldSystem *system, ComponentHandle handle) : system(system), handle(handle) {}
    void getBounds(Context * context, Cogs::Geometry::BoundingBox & bounds) final;
    bool getBounds(Context* context, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const final;
 
  private:
    bool getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const;
 
  private:
    VectorFieldSystem *system;
    ComponentHandle handle;
  };
  class VectorFieldPick : public IRayPickable
  {
  public:
 
    VectorFieldPick(VectorFieldSystem *system, ComponentHandle handle) : system(system), handle(handle) {}
    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;
  private:
    VectorFieldSystem *system;
    ComponentHandle handle;
  };
  struct VectorFieldData
  {
    VectorFieldSystem *system;
    ComponentHandle handle;
 
    Cogs::VertexElement pos_element;
    Cogs::VertexElement color_element;
    Cogs::VertexElement rot_element;
    Cogs::VertexElement scale_element;
    Cogs::VertexFormatHandle pos_format;
 
    size_t buffer_count;
    BufferHandle buffer_handle; // TODO double buffer???
    MeshStreamsLayout layout_cap;
    MeshStreamsLayout layout_base;
 
    std::unique_ptr<VectorFieldBounds> getBounds;
    std::unique_ptr<VectorFieldPick> rayPick;
 
    Geometry::BoundingBox bbox;
 
    float time;
 
    glm::mat4 worldMatrix;
    glm::vec3 cam_pos;
 
    std::vector<float> time_offset;
    std::vector<float> time_offset_speed;
    std::vector<glm::vec3> dither_offset;
    float ditherSize = 1.0f;
  };
  struct VectorFieldSystem: public ComponentSystemWithDataPool<VectorFieldComponent, VectorFieldData>
  {
  public:
    VectorFieldSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
    void initialize(Context * context) override;
    void update(Context * context) override;
    ComponentModel::ComponentHandle createComponent() override;
    void destroyComponent(ComponentHandle component) override;
 
    VectorFieldRenderer *vector_field_renderer;
    MaterialInstanceHandle material_instance_cap;
    MaterialInstanceHandle material_instance_base;
    ModelHandle model_cap;
    ModelHandle model_base;
  };
}// namespace ...