OctProviderSystem.h

#pragma once
 
#include "EntityDefinition.h"
#include "Scene/GetBounds.h"
#include "Systems/ComponentSystem.h"
 
#include "../Components/OctProviderComponent.h"
#include "../Systems/DataSetSystem.h"
 
#include "Rendering/Common.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <unordered_map>
#include <memory.h>
#include <glm/glm.hpp>
 
namespace Cogs
{
  namespace Core
  {
    namespace Volumetric
    {
      struct TileResponse;
    }
 
    namespace EchoSounder
    {
 
      inline uint64_t encodeKey2(const uint32_t source, const uint32_t slice)
      {
        return (uint64_t(source) << 32u) | uint64_t(slice);
      }
 
 
      inline void decodeKey2(uint32_t& source, uint32_t& slice, const uint64_t regionKey)
      {
        source = uint32_t(regionKey >> 32u);
        slice = uint32_t(regionKey);
      }
 
 
      struct CachedPing
      {
        int64_t timestamp = 0;
        PingMetaData metaPing;
        uint32_t beamCount = 0;
        uint32_t sampleCount = 0;
        float depthOffset = 0;
        float depthStep = 0;
        glm::vec3 transducerAlpha;
        glm::vec3 transducerOffset;
 
        uint32_t age = 0;
        bool linearized = false;
        Memory::TypedBuffer<float> decibel;
        Memory::TypedBuffer<float> linear;
        Memory::TypedBuffer<float> bottomDepths;
 
      };
 
      struct CachedBeamGroup
      {
        uint32_t dataId = 0;
        uint32_t majorCount = 0;
        uint32_t minorCount = 0;
        std::vector<float> directionX;
        std::vector<float> directionY;
        float minDirectionX = 0.0f;
        float maxDirectionX = 0.0f;
        float minDirectionY = 0.0f;
        float maxDirectionY = 0.0f;
        float maxBeamWidthX = 0.0f;
        float maxBeamWidthY = 0.0f;
      };
 
 
      struct OctProviderPersistent
      {
        Context * context = nullptr;
 
        std::vector<unsigned> taskCount;
 
        std::vector<Volumetric::TileResponse*> responses;
 
        std::vector<CachedBeamGroup> groupCache;
 
        std::unordered_map<uint64_t, std::unique_ptr<CachedPing>> pingCache;
        std::vector<std::unique_ptr<CachedPing>> pingCacheUnused;
 
        std::vector<CachedPing*> needsLinearization;
 
        bool tasksRunning = false;
 
        bool tainted = false;
      };
 
      struct OctProviderSource
      {
        EntityPtr entity;
        uint32_t grpGen = 0;
        uint32_t dataGen = 0;
        uint32_t sliceBegin = 0;
        uint32_t sliceCount = 0;
        bool sane = false;
      };
 
 
      struct OctProviderData
      {
        uint64_t mostRecentTimestamp = 0;
 
        unsigned history = 1;
        std::shared_ptr<OctProviderPersistent> persistent;
 
        std::vector<OctProviderSource> sources;
        unsigned callbackCount = 0;
 
        bool doFlush = true;
      };
 
      struct OctProviderSystem
        : public ComponentSystemWithDataPool<OctProviderComponent, OctProviderData>
      {
        OctProviderSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
        void callback(Context* context, OctProviderComponent * comp);
 
        static float alphaCallback(void* data, uint64_t clientData);
 
        void preUpdate(Context * context) override;
 
        void update(Context * context) override;
      };
 
    }
  }
}