UniformGridSystem.h

#pragma once
 
#include "EntityDefinition.h"
#include "Resources/Resources.h"
#include "Systems/ComponentSystem.h"
#include "Services/TaskManager.h"
 
#include "../Components/UniformGridComponent.h"
 
#include <atomic>
#include <mutex>
#include <memory>
#include <unordered_map>
 
namespace Cogs::Core::EchoSounder
{
  struct UniformGridSampleData;
  struct UniformGridSystem;
 
  struct UniformGridConfig{
    uint32_t configId = 0;
    uint32_t coordSys = 0;
    uint32_t majorCount = 0;
    uint32_t minorCount = 0;
    uint32_t sampleCount = 0;
    float depthOffset = 0.0f;
    float depthStep = 0.0f;
    glm::vec3 transducerAlpha;
    glm::vec3 transducerOffset;
    std::vector<float> directionX;
    std::vector<float> directionY;
    std::vector<float> beamWidthX;
    std::vector<float> beamWidthY;
  };
  struct UniformGridPing{
    uint32_t configId = 0;
    int64_t timestamp = 0;
    glm::vec3 position;
    glm::quat orientation;
    Memory::MemoryBuffer storage;
  };
  typedef uint64_t TileKey;
  inline TileKey encodeTileKey(glm::uvec3 pos)
  {
    return (((TileKey)(pos.x&0xffff))<<0 |
            ((TileKey)(pos.y&0xffff))<<16 |
            ((TileKey)(pos.z&0xffff))<<32);
  }
  inline glm::uvec3 decodeTileKey(TileKey key)
  {
    return glm::uvec3((key>>0)&0xffff, (key>>16)&0xffff, (key>>32)&0xffff);
  }
  struct Tile
  {
    float *data = nullptr;
    // TODO: Age
    uint64_t ping_number = 0;
    float minValue = 0.0f;
    float maxValue = 0.0f;
    bool update = false;
    bool update_iso = false;
    EntityPtr visualizer;
    MeshHandle mesh;
  };
  struct UniformGridData{
    UniformGridSystem *system = nullptr;
    UniformGridComponent *component = nullptr;
    std::unordered_map<uint32_t ,std::shared_ptr<UniformGridConfig>> config;
 
    std::mutex mu;
    std::condition_variable cv;
 
    bool shutdown = false;
    bool change_sv = false;
    bool update_iso = false;
 
    std::mutex tiles_mu;
    std::unordered_map<TileKey, Tile> tiles;
    std::vector<Entity*> destroy;
 
    glm::uvec3 size;
    glm::vec3 scale;
 
    float decibelMin = 0.0f;
    float decibelMax = 0.0f;
 
    UniformGridSampleData *sample_data = nullptr;
    UniformGridSampleData *sample_data_backbuffer = nullptr;
 
    // Iso Surfaces
    ComputeType compute = ComputeType::Reference; // TODO Mutex
    std::vector<float> thresholds; // TODO Mutex
    std::vector<MaterialInstanceHandle> layerMaterialInstances;
    EntityPtr visualizer_group;
 
    // Outline
    glm::quat vesselOrientationGlobal;
    glm::vec3 vesselPositionGlobal;
    std::unordered_map<uint32_t, EntityPtr> boundingFrustum;
 
    uint64_t ping_number = 0;
    uint64_t pings_handled = 0;
    uint64_t pings_droped = 0;
 
    uint64_t evict_number = 0;
 
    unsigned runs = 0;
    struct {
      std::atomic<uint32_t> us = 0;
      std::atomic<uint32_t> N = 0;
    } sample_intersecting;
 
    struct {
      std::atomic<uint32_t> us = 0;
      std::atomic<uint32_t> N = 0;
    } sample_inside;
 
    struct {
      std::atomic<uint32_t> analyze = 0;
      std::atomic<uint32_t> vtx = 0;
      std::atomic<uint32_t> idx = 0;
      std::atomic<uint32_t> N = 0;  // number of non-empty cells.
    } isoSurf;
 
    bool update_isosurface();
    MeshHandle createIsoSurfaces(Tile & tile, Cogs::Memory::MemoryBuffer& scratch, const glm::vec3 minCorner);
  };
  struct UniformGridSampleData{
    UniformGridSampleData(Context *context, UniformGridSystem *system, UniformGridComponent *component, UniformGridData &data, UniformGridPing &ping, uint64_t ping_number);
    void cull_tiles();
    void evict_tiles();
    Tile GenTile();
    void gen_tiles();
    void sample_intersecting(size_t start, size_t end);
    void sample_inside(size_t start, size_t end);
    void filter_ping();
    void sample_ref(float *data, const float *v, uint32_t z, uint32_t y, uint32_t x, float r2, glm::vec3 q);
    void sample_sn90_ref(float *data, const float *v, uint32_t z, uint32_t y, uint32_t x, float r2, glm::vec3 q);
 
    Context* context;
    UniformGridSystem *system;
    UniformGridComponent *component;
    UniformGridData &data;
    std::shared_ptr<UniformGridConfig> config;
 
    TaskId linear_group;
    ComputeType compute;
 
    float average_alpha;
 
    float filter_width;
    float filter_falloff;
 
    // Ping Data
    uint64_t ping_number;
 
    glm::quat vesselOrientationGlobal;
    glm::vec3 vesselPositionGlobal;
    glm::quat arrayOrientationGlobal;
    glm::vec3 arrayPositionGlobal;
    glm::quat inverseOrientation;
 
    float minDistance;
    float maxDistance;
    float minDistanceSquared;
    float maxDistanceSquared;
 
    glm::vec4 frustum[6]; // TODO 4
 
    glm::uvec3 maxIndices;
    glm::vec3 polarShift;
    glm::vec3 polarScale;
 
    // Group Data
    uint32_t majorCount;
    uint32_t minorCount;
 
    std::vector<glm::ivec3> tiles_intersecting;
    std::vector<glm::ivec3> tiles_inside;
    Memory::MemoryBuffer decibel;
    Memory::TypedBuffer<float> linear;
  };
  struct UniformGridSystem: public ComponentSystemWithDataPool<UniformGridComponent, UniformGridData>
  {
    UniformGridSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
    void initialize(Context * context) override;
    //void cleanup(Context * context) override;
 
    void preUpdate(Context * context) override;
 
    ComponentHandle createComponent() override;
    void destroyComponent(ComponentHandle component) override;
 
    void dispatch(Context *context, UniformGridComponent *component);
 
    void config(UniformGridComponent *component, UniformGridConfig &config);
    void clear(UniformGridComponent *component);
    void addPing(Context * context, UniformGridComponent *component, UniformGridPing &ping);
 
    void update_outline(Context * context, UniformGridComponent *component);
 
    bool has_sse41;
    bool has_avx2;
 
    MaterialHandle point_material;
    MaterialInstanceHandle point_instance;
 
    TaskQueueId Queue;
 
    // Reduce point visualization count
    int viz_x_div = 2;
    int viz_y_div = 2;
    int viz_z_div = 2;
  };
}