SparseBuildOctree.h

#pragma once
 
#include "Base.h"
#include "Context.h"
 
#include "Resources/Resources.h"
#include "Services/PropertiesManager.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
#include <vector>
 
namespace Cogs::Core::SparseOctree
{
  struct Parameterization
  {
    ModelHandle model;          
    float tolerance = 0;        
    float remesh = -1.f;        
    float remeshGridSpacing = 1.f / 8.f; 
    int remeshVolumeBlur = 0;   
    int remeshTriSoupBlur = 0;  
    float remeshSimplification = 0.1f; 
    float featureAngle = 0.7f;  
    float cullDiameter = -1.f;  
    float cullGeometry = -1.f;  
    float cullLeaf = -1.f;      
    float simplificationFactor = -1.f;  
    int simplificationMode = 0; 
    bool isLoaded = false;      
  };
 
  struct LevelInput
  {
    uint32_t parameterization = 0;  
    float reductionError = 0;       
    float cullingThreshold = 0;     
    float threshold = -1;           
  };
 
  struct EntityRef
  {
    uint32_t index = (uint32_t)-1;
    uint32_t parent = (uint32_t)-1;
 
    MeshHandle mesh;
    MaterialInstanceHandle material;
    uint32_t startIndex = 0;
    uint32_t vertexCount = (uint32_t)-1;
 
    Geometry::BoundingBox box;
    glm::vec3 span;
    float maxDim = 0;
    bool skip = false;
  };
 
  struct SceneInfo
  {
    ModelHandle model;
 
    Geometry::BoundingBox bounds;
 
    std::vector<EntityRef> entities;
 
    uint32_t geometries = 0;    
    //uint32_t leaves = 0;
 
    float maxGeometrySize = 0;  
  };
 
  // Mesh reference - mesh stored into a model file.
  struct MeshRef
  {
    std::string fileName;         
    uint32_t part = (uint32_t)-1; 
    Cogs::Geometry::BoundingBox bbox;
  };
 
  // Mesh record - mesh not yet packed into a model file.
  struct MeshRec
  {
    MeshHandle mesh;
    Cogs::Geometry::BoundingBox bbox;
  };
 
  struct Cell
  {
    uint32_t x = 0;
    uint32_t y = 0;
    uint32_t z = 0;
 
    Geometry::BoundingBox bbox;       
 
    std::vector<uint32_t> touches;    
 
    std::vector<MeshRef> meshRefs;    
    std::vector<MeshRec> meshRecs;    
 
    uint32_t vertexCount = 0;
    uint32_t sizeEstimate = 0;      
 
    MeshHandle mesh;
  };
 
  typedef size_t CellMapKey;
  typedef size_t CellIndex;
  struct Grid
  {
 
    // Number of cells along each direction
    glm::uvec3 dimensions;
    glm::vec3 origin;
    glm::vec3 cellSize;
 
    CellMapKey cellMapKey(const size_t i, const size_t j, const size_t k) const {
      assert(i < dimensions.x && j < dimensions.y && k < dimensions.z);
      return ((k * dimensions.y) + j) * dimensions.x + i;
    }
 
    std::unordered_map<CellMapKey, CellIndex> cellMap;
 
    // FIXME: Do something more clever with pages
    std::vector<Cell> cellStore;
 
  };
 
  enum struct LevelReducer
  {
    RationalReducerVertexCount,
    MeshOptimizerVertexCount,
    MeshOptimizerSloppyVertexCount
  };
 
  struct OctreeInfo
  {
    PropertyStore properties;
 
    std::string layer;
    std::string source;
    std::string name;
    std::string absolute;
    std::string directory;
    std::string layerDirectory;
    std::string filesDirectory;
    std::string assetFileNameStem;
    std::string layerAndName;
    std::string skipPattern;
 
    std::string keepList;             
 
    LevelReducer levelReducer = LevelReducer::RationalReducerVertexCount;
 
    bool discardOutliers = false;
    bool outputOutliers = false;
    bool colorizeLevels = false;      
    bool embedMeshBounds = true;      
    bool statistics = false;          
 
 
    uint32_t maxSubtreeSize = 0;  // FIXME: Disabled for now as AssetSystem appear to load all lods for sub-assets or something, needs to be fixed before this can be used.
 
    int maxMeshVertexCount = 80000;
 
    int maxModelVertexCount = 50000;
 
    int maxModelMeshCount = 20;
 
    int outlierMinVertexCount = 10'000;
    float outlierMaxVolume = 1.0f;
    float outlierMinVertexDensity = 10'000'000;
 
    int dropReductionLevelThreshold = 4;
    int dropReductionThreshold = 1000;
    int minReductionThreshold = 500;
 
    float edgeLengthWeight = 1.0f;
 
    glm::vec3 minBounds;
    glm::vec3 maxBounds;
    bool useMinBounds = false;
    bool useMaxBounds = false;
 
    bool isEmpty = false;
 
    bool useCompression = false;
    bool prettyPrint = false;
    int compressionLevel = 0;
 
 
 
    std::string taskFilter;
 
    std::string filter_rootEndsWith;
    std::string filter_rootIncludes;
    std::string filter_rootPattern;
    std::string filter_attributeName;
    std::string filter_attributeValue;
    std::vector<std::string> filter_excludeNodes;
  };
 
  struct Octree
  {
    Context * context;
 
    OctreeInfo info;
 
    uint32_t numLevels = 0;
    float minCellSize = 1.0f;
 
    std::vector<Parameterization> sources;
 
    std::vector<SceneInfo> scenes;            // One scene per level.
    std::vector<LevelInput> inputs;           // Specifies input to the level.
    std::vector<Grid> grids;                  // Dimension and store for cell for each level.
  };
 
  void distributeGeometryWithIds(Octree & octree, PropertyStore& properties, const size_t level);
 
  uint32_t clipTriangle(float* V_dst, float *N_dst, float *T_dst, const float (&clipBox)[6], const float *V_in, const float * N_in, const float *T_in);
  uint32_t clipTriangle(float* V_dst, float *N_dst, const float(&clipBox)[6], const float *V_in, const float * N_in);
}