PotreeSystem.h

#pragma once
 
#include "Scene/RayPick.h"
#include "Scene/GetBounds.h"
#include "Resources/DataFetcherManager.h"
#include "Resources/Resources.h"
#include "Systems/ComponentSystem.h"
 
#include "PotreeComponent.h"
#include "List.h"
 
#include "Rendering/Common.h"
#include "Rendering/VertexFormat.h"
#include "Resources/MeshStreamsLayout.h"
 
#include "Foundation/Collections/Pool.h"
#include "Foundation/Collections/SmallVector.h"
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <glm/glm.hpp>
 
namespace Cogs::Core
{
  struct CameraData;
}
 
namespace Cogs::Core
{
  struct PotreeRenderer;
  struct PotreeSystem;
 
  enum struct PotreeState {
    Uninitialized,
    Error,
    RequestedCloudJS,
    ParsedCloudJs,
    Running
  };
 
  enum struct PotreeeType
  {
    None,
    Double,
    Float,
    Int8,
    UInt8,
    Int16,
    UInt16,
    Int32,
    UInt32,
    Int64,
    UInt64,
  };
 
  enum struct PotreeEnconding
  {
    Default,
    ZStd,
    Brotli,
  };
 
  enum struct PotreeAttributes {
    POSITION_CARTESIAN = 0, // 3 x uint32 : x, y, z
    RGBA_PACKED,            // 4 x uint8  : r, g, b, a
    RGB_U8_PACKED,          // 3 x uint8  : r, g, b
    RGB_U16_PACKED,         // 3 x uint16
    NORMAL,                 // 3 x float32 : x, y, z
    NORMAL_SPHEREMAPPED,    // 2 x uint8
    NORMAL_OCT16,           // 2 x uint8
    INTENSITY_U16,          // 1 x uint16
    CLASSIFICATION,         // 1 x uint8
    FILLER_1B,              // 1 x uint8
    COUNT                   // Number of known attributes.
  };
 
  enum struct PotreeVertexLayout {
    POSITION,
    POSITION_COLOR,
    POSITION_NORMAL,
    POSITION_COLOR_NORMAL,
    POSITION_INTENSITY,
    POSITION_COLOR_INTENSITY,
    POSITION_NORMAL_INTENSITY,
    POSITION_COLOR_NORMAL_INTENSITY,
    POSITION_CLASSIFICATION,
    POSITION_COLOR_CLASSIFICATION,
    POSITION_NORMAL_CLASSIFICATION,
    POSITION_COLOR_NORMAL_CLASSIFICATION,
    POSITION_INTENSITY_CLASSIFICATION,
    POSITION_COLOR_INTENSITY_CLASSIFICATION,
    POSITION_NORMAL_INTENSITY_CLASSIFICATION,
    POSITION_COLOR_NORMAL_INTENSITY_CLASSIFICATION,
    COUNT
  };
 
  struct PotreeVertexLayoutInfo {
    unsigned positionOffset;
    unsigned colorOffset;
    unsigned normalOffset;
    unsigned intensityOffset;
    unsigned classOffset;
    unsigned stride;
    std::vector<Cogs::VertexElement> elements;
  };
 
  struct PotreeSubtree;
  struct PotreeData;
 
  struct PotreeCell
  {
    uint64_t byteOffset = 0;
    uint64_t byteCount = 0;
    ListNode subtreeNode;                   // List node used for membership in subtree.
    ListNode activeNode;                    // List node used for membership in list of active nodes.
    ListNode tmpNode;                       // List node used temporarily within a function.
    PotreeSubtree* owningSubtree = nullptr; // Pointer to subtree that owns the node.
    union {
      PotreeCell* children[8];              // Regular node: Child node.
      PotreeSubtree* linkedSubtree;         // Subtree link node: Pointer to subtree.
    };
 
    Cogs::BufferHandle boxParametersBuffer;
    VertexBufferHandle pointData;           // VBO with position and attribute data, see PotreeData for layout.
    Memory::TypedBuffer<glm::vec3> points;  // CPU side copy of point positions, used for picking.
 
    glm::vec3 tbmin, tbmax;                 // Tight bounding box for the points inside this cell. Origin is poData->tbCenter.
 
    uint32_t hierarchyNumPoints = 0;        // Number from hrc files, is _not_ number of points in cell, maybe in hierarchy below.
    uint32_t pointCount = 0;                // Number of points in pointData
    uint32_t prefix = 0;                    // Path to this node within this subtree.
    uint16_t texOffset = static_cast<uint16_t>(~0u);  // Current position in texture.
    uint8_t i = 0;                          // Cell position within this subtree.
    uint8_t j = 0;                          // Cell position within this subtree.
    uint8_t k = 0;                          // Cell position within this subtree.
    uint8_t l = 0;                          // Cell level within this subtree.
    uint8_t scaleFactor = 100;              // pointsize is scaled with exp2(10.0 - (25.5 * data_.w + level)),
                                            // 100 implies just level scale: exp2(10 - 25.5(100.0/255.0)) = exp2(10 - 10) = exp2(0) = 1.
 
    enum struct Kind : uint8_t
    {
      RegularNode,
      SubtreeLink
    } kind = Kind::RegularNode;
    enum struct State : uint8_t
    {
      None,
      Issued,
      Ready,
      Failed
    } state = State::None;
    enum struct Flags : uint8_t
    {
      None = 0,
      Active = 1 << 0,
    } flags = Flags::None;
    DataFetcherManager::FetchId fetch_id = DataFetcherManager::NoFetchId;
 
    inline bool isRootNode() const;  // declared further down, needs subtree defined
    bool isActive() const { return unsigned(flags) & unsigned(Flags::Active); }
    void setActive() { flags = Flags(unsigned(flags) | unsigned(Flags::Active)); }
    void setInactive() { flags = Flags(unsigned(flags) & ~unsigned(Flags::Active)); }
 
    void appendDescendSteps(std::string& path) const;
 
    void fetchData(Context* context, PotreeSystem* poSystem, const PotreeComponent* poComp, PotreeData* poData);
 
    void releaseData(Context* context, PotreeData* poData);
 
  };
  ENABLE_ENUM_FLAGS(PotreeCell::Flags);
 
  struct PotreeSubtree
  {
    enum struct State {
      None,
      Issued,
      Ready,
      Failed
    } state = State::None;
    DataFetcherManager::FetchId fetch_id = DataFetcherManager::NoFetchId;
 
    ListNode member;
    PotreeCell* containingCell = nullptr;   // Pointer to PoNode that links to this subtree.
    std::string path;               // URL prefix of this subtree.
    std::string prefix;
    List<PotreeCell, offsetof(PotreeCell, subtreeNode)> cells;
    uint32_t subtreeId = 0;
    uint32_t i = 0;                 // Global position of subtree node.
    uint32_t j = 0;                 // Global position of subtree node.
    uint32_t k = 0;                 // Global position of subtree node.
    uint32_t l = 0;                 // Global position of subtree node.
 
    void fetchLayoutAndInitialize(Context* context, PotreeSystem* poSystem, const PotreeComponent* poComp, PotreeData* poData, PotreeCell* containingCell);
 
    void release(Context* context, PotreeData* poData);
  };
 
  bool PotreeCell::isRootNode() const { return l == 0 && owningSubtree->containingCell == nullptr; }
 
  struct PotreeNodeHeapItem
  {
    PotreeCell* cell = nullptr;
    float priority = 0.f;
  };
 
  struct PotreeData {
    PotreeCell* root = nullptr;
 
    std::vector<PotreeNodeHeapItem> lodHeap;  
 
    std::string jsonPath;   
    std::string rootPath;   
    std::string octreeDir;  
    std::string suffix = ".bin";
    Collections::SmallVector<PotreeAttributes, 4> attributes;
    static constexpr size_t MaxClipPlanes = 6u; 
    glm::vec4 clipPlanes[MaxClipPlanes];
    size_t clipPlaneCount = 0;
 
    PotreeNotification potreeNotificationState = PotreeNotification::None;
 
    uint32_t requestsInFlight = 0U;
 
    struct {
      float val = 1.f;          
      float min = 1.f;          
      float max = 1.f;          
    } pointSize;
 
    // Transforms from octtree native frame
    struct {
      glm::dvec3 positionInEntityFrame;       // Position of octtree frame in entity frame (defined by transformcomponent)
      glm::vec3 currentPositionInEntityFrame; // current position in entity frame (adjusted by originPolicy)
 
      glm::vec3 toBBoxShift;    // Shifts a point from octtree frame to frame where bounding box min corner is origin
      glm::vec3 fullBBoxSize;   // Size of full bounding box
      float     fullBBoxDiagonal;
 
      glm::vec3 fullBBoxMin;    // Full bounding box min corner in octtree frame
      glm::vec3 fullBBoxMax;    // Full bounding box max corner in octtree frame
 
      glm::vec3 tightBBoxMin;   // Tight bounding box min corner in octtree frame
      glm::vec3 tightBBoxMax;   // Tight bounding box max corner in octtree frame
    } octtreeFrame;
 
    // Transform from encoded point positions to octtree Frame.
    struct {
      glm::vec3  scale;
      glm::vec3  shift;
    } positionDecode;
 
    // Original extents as given in metadata.json or cloud.js
    struct {
      glm::dvec3 bbmin, bbmax; // Octree extent
 
      // Actual bounding box for points (might be smaller than octree extent)
      // v1.x: Taken from cloud.js:tightBoundingBox.
      // v2.x: Taken from metadata.json:attrobutes.position.min|max.
      glm::dvec3 tbmin = glm::vec3(0.f);
      glm::dvec3 tbmax = glm::vec3(0.f);
 
      // v1.x: Taken from cloud.js:scale (scalar)
      // v2.x: Taken from cloud.js:scale (vec3)
      glm::vec3 scale = glm::vec3(1.f);
 
      // v2.x: Taken from metadata.offset
      glm::dvec3 offset = glm::vec3(0.f);
 
    } metadata;
 
    // controls behaviour of density-based scaling
    struct {
      float scale = 25.5f;    // scale for density value
      float bias = 10.f;      // offset before density and level takes hold on sizing
      float levelScale = 1.f; // Strength of hierarchy depth on scaling
    } densitySized;
 
    PotreeOriginPolicy originPolicy = PotreeOriginPolicy::None;
    PotreeEnconding encoding = PotreeEnconding::Default;
    uint32_t firstChunkSize = 0;      // v2: Size of root node hierarchy data.
    uint32_t hierarchyStepSize = 0;
    uint32_t hierarchyDepth = 0;      // v2: Max depth of octtree.
 
    float spacing = 1.f;  // Minimum distance between point at root level.
 
    float modelSpaceRadius = 1.f;
    float tolerance = std::numeric_limits<float>::infinity();     // Maximum cell screen diagonal in pixels before refinement.
    float rootTolerance = std::numeric_limits<float>::infinity(); // Maximum root cell screen diagonal in pixels before refinement.
 
    unsigned versionMajor = 0;
    unsigned versionMinor = 0;
 
    bool hasColor = false;
    bool hasNormal = false;
    bool hasIntensity = false;
    bool hasClassification = false;
 
    bool supportPicking = true;
 
    PotreeState state = PotreeState::Uninitialized;
    DataFetcherManager::FetchId fetch_id = DataFetcherManager::NoFetchId;
    PotreeVertexLayout layout = PotreeVertexLayout::COUNT;
 
    MeshStreamsLayout streamsLayout;
 
    Cogs::BufferHandle pointParametersBuffer;
 
    Cogs::TextureHandle octtreeTexture;
    Memory::TypedBuffer<glm::u8vec4> octtreeTextureData;
 
    uint32_t instanceId = 0;
    PotreeDebugBoxes debugBoxes = PotreeDebugBoxes::None;
 
    glm::mat4 worldFromOcttreeFrame;
 
    // List of loaded subtrees. Root is always the first subtree.
    List<PotreeSubtree, offsetof(PotreeSubtree, member)> subtrees;
 
    // List of cells flagged as active.
    List<PotreeCell, offsetof(PotreeCell, activeNode)> activeCells;
 
    Memory::MemoryBuffer tmpVertexData;
    Memory::TypedBuffer<PotreeCell*> tmpCellPointers;
 
    static constexpr size_t occupancyGridDim = 32;
    std::vector<uint8_t> occupancyTmpData;
 
    Collections::Pool<PotreeCell> cellStore;
    Collections::Pool<PotreeSubtree> subtreeStore;
 
    struct {
      MaterialInstanceHandle instance;
      VariableKey scale = NoProperty;
      VariableKey offset = NoProperty;
    } boxMaterial;
 
    struct {
      MaterialInstanceHandle instance;
      VariableKey pointSize = NoProperty;
      VariableKey shadingIntensity = NoProperty;
      VariableKey octTexScale = NoProperty;
      VariableKey minPointSize = NoProperty;
      VariableKey maxPointSize = NoProperty;
      VariableKey baseColor = NoProperty;
      VariableKey outlineColor = NoProperty;
      VariableKey outlineSize = NoProperty;
      VariableKey invShift = NoProperty;
      VariableKey invScale = NoProperty;
      VariableKey gradient = NoProperty;
    } pointMaterial;
 
    glm::mat4 frustum;  // transform unit cube to frustum used when updating lod, used for debug viz.
 
    glm::dvec3 boundsMin = glm::dvec3(std::numeric_limits<double>::max());
    glm::dvec3 boundsMax = glm::dvec3(-std::numeric_limits<double>::max());
  };
 
  // PoData contains lists that don't support to be memmoved, and component data
  // might be memmoved, so we keep them in a separate block.
  struct PotreeDataHolder
  {
    std::unique_ptr<PotreeData> poData;
  };
 
  struct PointParameters{
    glm::vec4 pointControl[2];
    glm::vec4 passControl[1+PotreeData::MaxClipPlanes];
  };
 
  struct BoxParameters{
    glm::vec4 boxControl[3];
  };
 
  struct PotreeSystem;
 
 
  struct PotreeDecodeOutData
  {
    Memory::MemoryBuffer vertexData;
    size_t pointCount = 0;
 
    size_t nonEmptyCells = 0;
    glm::vec3 lo = glm::vec3(std::numeric_limits<float>::max());
    glm::vec3 hi = glm::vec3(-std::numeric_limits<float>::max());
 
    Memory::TypedBuffer<uint8_t> occupancyTmpData;
    Memory::TypedBuffer<glm::vec3> points;
 
    enum struct State {
      NoData,
      DecodingFailed,
      Success
    } state = State::Success;
  };
 
  struct PotreeDecodeInData
  {
    const PotreeVertexLayoutInfo& layoutInfo;
    Cogs::Collections::SmallVector<PotreeAttributes, 4> attributes;
    glm::uvec4 cellPos;
    glm::vec3 posScale;
    glm::vec3 posShift;
    PotreeEnconding encoding;
    size_t occGridDim;
    glm::vec3 fullBBoxMin;
    glm::vec3 fullBBoxSize;
  };
 
  void decodePotreeBin(PotreeDecodeOutData& out, const PotreeDecodeInData& in, const Cogs::FileContents& inData);
 
  struct PotreePicker : IRayPickable
  {
    PotreePicker(PotreeSystem* poSystem) : poSystem(poSystem) {}
 
    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;
 
    bool pickRay(Context* /*context*/,
                 const glm::vec3& startPos,
                 const glm::quat& rot,
                 float rayLength,
                 float radius,
                 PickingFlags pickingFlags,
                 PicksReturned returnFlag,
                 const RayPicking::RayPickFilter& filter,
                 std::vector<RayPicking::RayPickHit>& hits) override;
 
    PotreeSystem* poSystem = nullptr;
  };
 
  class PotreeBounds final : public IGetBounds {
  public:
    explicit PotreeBounds(PotreeSystem* poSystem) : poSystem(poSystem) {}
 
    void getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds) override;
 
    bool getBounds(Context* context, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const override;
 
  private:
    bool getBounds(Context* context, const PotreeComponent& poComp, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const;
 
  private:
    PotreeSystem* poSystem = nullptr;
  };
 
  struct PotreeSystem : public ComponentSystemWithDataPool<PotreeComponent, PotreeDataHolder>
  {
    PotreeSystem(Memory::Allocator* allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
    void initialize(Context* context) override;
    void cleanup(Context* context) override;
 
    void preUpdate(Context* context) override;
 
    void update(Context* context) override;
 
    ComponentHandle createComponent() override;
    void destroyComponent(ComponentHandle component) override;
 
    // Make sure that poComp hasn't died or changed significantly since request was issued
    static bool lookupAndCheckForStaleness(Context* context, PotreeSystem*& potreeSystem, PotreeData*& poData, PotreeComponent*& poComp, const uint32_t componentId);
 
    static bool lookupAndCheckForStaleness(Context* context, PotreeSystem*& potreeSystem, PotreeData*& poData, PotreeComponent*& poComp, PotreeSubtree*& subtree, const uint32_t componentId, const uint32_t subtreeId);
 
    void issueSubtreeFetch(Context* context, const PotreeComponent* poComp, PotreeData* poData, PotreeCell* parent);
 
    // Implementation in ManageLodLevels.cpp
    void updateLodLevels(Context* context);
 
    void updateOcttreeFrame(Context* context, PotreeData& poData, const PotreeComponent& poComp);
 
    static void startFetch(Context* context, const PotreeComponent* poComp, PotreeData* poData);
 
    static void endFetch(Context* context, const PotreeComponent* poComp, PotreeData* poData);
 
  public:
    unsigned requestsInFlight = 0;
    bool materialLoaded = false;
 
    MaterialHandle defaultBoxMaterial;
    MaterialHandle defaultPointMaterial;
 
 
    PotreeRenderer* renderer = nullptr;
    TextureHandle defaultGradient;
 
    PotreeBounds* bounds = nullptr;
    PotreePicker* picker = nullptr;
 
 
    static PotreeVertexLayoutInfo vertexLayoutInfo[static_cast<size_t>(PotreeVertexLayout::COUNT)];
 
  };
 
}