OctSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "../Components/OctComponent.h"
#include "../Renderers/OctAtlas.h"
 
#include "Rendering/Common.h"
 
#include "Foundation/Collections/Pool.h"
 
#include <glm/glm.hpp>
 
#include <unordered_map>
#include <set>
#include <memory.h>
 
namespace Cogs
{
  namespace Core
  {
    class CameraComponent;
    class TransformComponent;
    struct CameraData;
 
    namespace Volumetric
    {
      struct OctSystem;
 
      typedef uint64_t BaseBlockKey;
 
      inline BaseBlockKey createBaseBlockKey(int x, int y, int z)
      {
        return uint64_t(uint16_t(z)) << 32 | uint64_t(uint16_t(y)) << 16 | uint64_t(uint16_t(x));
      }
 
      struct OctBaseBlock
      {
        uint32_t timestamp;             
        glm::i16vec3 ix3;               
        std::set<RegionKey> regionKeys; 
      };
 
      struct NodeBlock
      {
        uint64_t ix;
        uint32_t timestamp;             
        glm::u16vec4 ix4;               
        glm::u16vec3 extentMin;
        glm::u16vec3 extentMax;
        union {
          uint32_t children[8];
          OctBaseBlock* baseBlock;
        };
      };
 
      struct OctRegionData
      {
        RegionKey regionKey;
        glm::vec3 min;                    
        glm::vec3 max;                    
        std::vector<uint64_t> baseBlocks; 
      };
 
      struct OctData
      {
        ~OctData();
 
        OctComponent* comp;
 
        std::unordered_map<BaseBlockKey, OctBaseBlock*> baseBlocks;
        Collections::Pool<OctBaseBlock> baseBlockPool;
 
        std::unordered_map<uint64_t, OctRegionData*> knownRegions;
        Collections::Pool<OctRegionData> knownRegionPool;
 
        std::vector<TileResponse*> tileResponses;
        std::vector<TileResponse*> tileResponsesStash;
 
        std::vector<NodeBlock> nodes;
 
        glm::i16vec3 alignMinToZeroShift;   
 
        std::vector<uint32_t> stack;
 
        std::vector<uint32_t> front;
        std::vector<uint32_t> frontTmp;
 
        uint32_t currentTimestamp = 0;
 
        float tolerance = 0.1f;
        unsigned maxFrontSize = 1; // Updated by OctTreeRenderSystem::preUpdate.
 
        //std::unordered_map<uint64_t, std::set<uint64_t>> baseBlocksByRegion;
 
        size_t layoutHash = 0;
 
        bool gpuCacheWipe = true;
 
        VertexBufferHandle instanceBufferHandle;
        MaterialInstanceHandle materialInstance;
 
        OctSource source = OctSource::Value;
 
        unsigned instanceCount = 0;
 
        OctAtlas atlas;
      };
 
      struct OctSystem
        : public ComponentSystemWithDataPool<OctComponent, OctData>
      {
        static const unsigned maxResponses = 5;
        static const unsigned skirtSize = 1;
      public:
        OctSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
        void initialize(Context * context) override;
        void update(Context * context) override;
 
        ComponentModel::ComponentHandle createComponent() override;
 
        static glm::mat4 LocalFromIndexSpaceTransform(const OctComponent& octComp, const OctData& octData);
        static glm::mat4 IndexSpaceFromLocalTransform(const OctComponent& octComp, const OctData& octData);
 
        struct OctBounds* bounds = nullptr;
        struct OctRenderer* renderer = nullptr;
 
        MaterialHandle material;
        VariableKey transferTexKey;
        VariableKey volumeTexKey;
 
        Cogs::EffectHandle effectHandle;
        Cogs::InputLayoutHandle inputLayoutHandle;
 
        void buildTree(Context * context, OctComponent& octComp, OctData& octData);
 
        void adaptiveSubset(Context * context, OctComponent& octComp, OctData& octData, const TransformComponent& transComp, const CameraComponent& camComp, const CameraData& camData);
      };
 
    }
  }
}