SpriteRenderSystem.h

#pragma once
 
#include "Scene/RayPick.h"
#include "Systems/ComponentSystem.h"
 
#include "Components/Core/SpriteRenderComponent.h"
 
#include "Resources/Resources.h"
#include "Resources/MaterialOptions.h"
#include "Resources/VertexFormats.h"
 
#include "Renderer/RenderList.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
#include <span>
 
 
namespace Cogs::Core
{
  using SpriteBatchIndex = size_t;
  const SpriteBatchIndex NoBatchIndex = static_cast<SpriteBatchIndex>(-1);
 
  using SpriteIndex = size_t;
  const SpriteIndex NoSpriteIndex = static_cast<SpriteIndex>(-1);
 
  struct SpriteRenderData
  {
    SpriteBatchIndex batchIndex = NoBatchIndex;
    SpriteIndex spriteIndex = NoSpriteIndex;
 
    glm::vec3 position;
    glm::vec2 offset;
    glm::vec2 size;
 
    Geometry::BoundingBox boundingBox;
  };
 
  struct SpriteMaterial
  {
    MaterialHandle material;
    VariableKey colorKey = NoProperty;
    VariableKey alwaysOnTopKey = NoProperty;
    VariableKey textureKey = NoProperty;
 
    std::vector<MaterialInstanceHandle> freeInstances;
    std::vector<MaterialInstanceHandle> frameInstances;
  };
 
  using SpriteMaterialKey = size_t;
  const SpriteMaterialKey NoSpriteMaterial = static_cast<SpriteMaterialKey>(-1);
  const SpriteMaterialKey DefaultSpriteMaterial = 0;
 
  struct SpriteBatch
  {
    SpriteBatchIndex index = NoBatchIndex;
    MaterialInstanceHandle material;
    MeshHandle mesh = MeshHandle::NoHandle;
    BlendMode blendMode = BlendMode::Blend;
    glm::mat4 transform = glm::mat4(1.0f);
    glm::vec3 worldPosition = glm::vec3(0, 0, 0);
    Geometry::BoundingBox bbox;
    PositionMode positionMode = PositionMode::World;
    SizeMode sizeMode = SizeMode::Pixels;
    RenderComponent::LodData lod;
    size_t start = 0;
    size_t count = 0;
    float depth = -1;
    RenderItemFlags flags = RenderItemFlags::Sprite;
    bool expanded = false;
  };
 
  struct SpriteVertex
  {
    glm::vec4 position;
    glm::vec4 parameters;
    glm::vec4 texCoords;
 
    static VertexFormatHandle getVertexFormat()
    {
      return VertexFormats::Pos4fNorm4fTex4f;
    }
  };
 
  class SpritePicker;
 
  const size_t kMinBatchSize = 256 / sizeof(SpriteVertex);
 
  class COGSCORE_DLL_API SpriteRenderSystem : public ComponentSystemWithDataPool<SpriteRenderComponent, SpriteRenderData>
  {
    using base = ComponentSystemWithDataPool<SpriteRenderComponent, SpriteRenderData>;
 
  public:
    SpriteRenderSystem(Memory::Allocator * allocator, SizeType capacity);
 
    void initialize(Context * context) override;
    void preUpdate(Context * context) override;
    void postUpdate(Context * context) override;
    ComponentHandle createComponent() override;
    void destroyComponent(ComponentHandle component) override;
 
    SpriteMaterialKey registerSpriteMaterial(MaterialHandle material);
 
    SpriteBatch * begin(SpriteMaterialKey material, const StringView & permutation, TextureHandle texture, glm::vec4 color, bool alwaysOnTop = false);
 
    SpriteBatch * begin(SpriteMaterialKey material,
      const StringView & postfix,
      PositionMode positionMode,
      SizeMode sizeMode,
      TextureHandle texture,
      glm::vec4 color,
      bool alwaysOnTop = false);
 
    SpriteBatch * begin(SpriteMaterialKey material, TextureHandle texture, glm::vec4 color);
    SpriteBatch * begin(TextureHandle texture, glm::vec4 color);
 
    void addSprite(SpriteRenderComponent * spriteRenderer, glm::vec3 position, glm::vec2 size, glm::vec4 texCoords);
    void addSprite(SpriteRenderComponent * spriteRenderer, glm::vec3 position, glm::vec2 offset, glm::vec2 size, glm::vec4 texCoords);
 
    const SpriteBatch * getSpriteBatch(SpriteBatchIndex index) const;
    std::span<const SpriteBatch> getSpriteBatches() const;
 
    static StringView getPermutation(PositionMode positionMode, SizeMode sizeMode);
 
  private:
    void updateBatchMesh();
 
    std::vector<SpriteBatch> spriteBatches;
 
    MaterialHandle spriteMaterial;
    std::vector<SpriteMaterial> materials;
 
    SpriteBatch * currentBatch = nullptr;
 
    std::vector<MeshHandle> frameMeshes;
    std::vector<MeshHandle> freeMeshes;
 
    bool expandSpriteGeometry = true;
 
    SpritePicker* picker = nullptr;
  };
 
 
  class SpritePicker : public IRayPickable
  {
  public:
    explicit SpritePicker(SpriteRenderSystem* spriteSystem);
 
    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;
 
    SpriteRenderSystem* spriteSystem = nullptr;
  };
}