OctComponent.h

#pragma once
 
 
#include "Resources/Resources.h"
#include "Components/Core/RenderComponent.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <set>
#include <vector>
 
namespace Cogs
{
  namespace Core
  {
    namespace Volumetric
    {
      typedef uint64_t TileKey;
 
      inline TileKey createTileKey(const glm::u16vec4& ix4, const glm::i16vec3& alignMinToZeroShift)
      {
        return (uint64_t(ix4.w) << 48)
          | (uint64_t(uint16_t((ix4.z << ix4.w) + alignMinToZeroShift.z)) << 32)
          | (uint64_t(uint16_t((ix4.y << ix4.w) + alignMinToZeroShift.y)) << 16)
          | uint64_t(uint16_t((ix4.x << ix4.w) + alignMinToZeroShift.x));
      }
 
      typedef uint64_t RegionKey;
 
 
      struct TileRequest
      {
        TileKey tileKey;
        unsigned staleness;
      };
 
      struct TileResponse
      {
        TileKey tileKey;
        size_t layoutHash;
        uint32_t timestamp;
        glm::vec3 min;                    
        glm::vec3 max;                    
        glm::uvec3 N;                     
        std::set<RegionKey> regionKeys;    
        Memory::TypedBuffer<glm::vec4> data0;
        Memory::TypedBuffer<float> data1;
        uint64_t clientData;              
      };
 
      struct Region
      {
        RegionKey regionKey; 
        glm::vec3 min;      
        glm::vec3 max;      
      };
 
      enum struct OctSource
      {
        Value,
        ValueAge
      };
 
 
      struct OctComponent : public ComponentModel::Component
      {
        bool forceWipe = false;                 
        float tolerance = 0.1f;                 
        glm::vec3 blockShift = glm::vec3(0.f);  
        glm::vec3 blockExtent = glm::vec3(1.f); 
 
 
        float valueMin = 0.f;
        float valueMax = 1.f;
        float turbidity = 100.f;
        float ageScale = 0.1f;
 
        uint32_t tileSize = 64u;
        uint32_t gpuCacheSize = 5u; // Number of tiles along one dimension.
 
        OctSource source = OctSource::Value;
 
        TextureHandle transferTexture;
 
        struct {
          float(*func)(void* data, uint64_t clientData) = nullptr;
          void* data = nullptr;
        } alphaCallback;
 
        bool clearAllRegions = false;
 
        bool drawDebug = false;
 
        std::vector<Region> regionsToAdd;
 
        std::vector<RegionKey> regionsToRemove;
 
        std::vector<TileRequest> tileRequests;
 
        TileResponse* initTileResponse(const TileRequest* req);
 
        void submitTileResponse(TileResponse* res, bool success);
 
 
        struct OctSystem* system;
 
        static void registerType();
 
      };
 
    }
  }
}
 
template<> inline Cogs::StringView getName<Cogs::Core::Volumetric::OctComponent>() { return "VolOctComponent"; }