MeshAsset.hpp

#pragma once
 
#include "mathtypes.hpp"
#include "Ref.hpp"
#include "Common3D.hpp"
#include "Manager.hpp"
#include "Filesystem.hpp"
#include "Debug.hpp"
#include <span>
#if !RVE_SERVER
    #include <RGL/Types.hpp>
#endif
#include "MeshAllocation.hpp"
#include "Mesh.hpp"
#include "MaterialShared.hpp"
 
struct aiMesh;
struct aiScene;
 
namespace RavEngine{
 
struct MeshAssetOptions{
    bool keepInSystemRAM = false;
    bool uploadToGPU = true;
};
 
class MeshAsset {
public:
 
    MeshAsset(const MeshAsset&) = delete;
    MeshAsset(MeshAsset&&) = delete;
 
    auto GetAttributes() const {
        return attributes;
    }
    
protected:
    MeshAsset() {};     // SkinnedMesh needs this
 
    size_t totalVerts = 0, totalIndices = 0;
    Bounds bounds;
    float radius = 0;
    MeshAttributes attributes;
 
    friend class RenderEngine;
#if !RVE_SERVER
    MeshRange meshAllocation;
#endif
    
    void InitializeFromMeshPartFragments(const  RavEngine::Vector<MeshPart>& mp, const MeshAssetOptions& options = MeshAssetOptions());
    
    void InitializeFromRawMesh(const MeshPart& mp, const MeshAssetOptions& options = MeshAssetOptions());
    void InitializeFromRawMeshView(const MeshPartView& mp, const MeshAssetOptions& options = MeshAssetOptions());
    
    // optionally stores a copy of the mesh in system memory
    MeshPart systemRAMcopy;
 
    MeshPart DeserializeMesh(const std::istream& stream);
    std::pair<MeshPart,uint32_t> DeserializeMeshFromMemory(const std::span<uint8_t> mem);
 
    friend class RenderEngine;
    
public:
 
    auto GetRadius() const {
        return radius;
    }
#if !RVE_SERVER
    auto GetAllocation() const {
        return meshAllocation;
    }
#endif
    
    struct Manager : public GenericWeakReadThroughCache<std::string,MeshAsset>{};
    
    MeshAsset(const std::string& path, const MeshAssetOptions& options = MeshAssetOptions());
    
    MeshAsset(const Filesystem::Path& pathOnDisk, const MeshAssetOptions& options = MeshAssetOptions());
 
    MeshAsset(const RavEngine::Vector<MeshPart>& rawMeshData, const MeshAssetOptions& options = MeshAssetOptions()){
        InitializeFromMeshPartFragments(rawMeshData, options);
    }
    
    MeshAsset(const MeshPart& mesh, const MeshAssetOptions& options = MeshAssetOptions()){
        InitializeFromRawMesh(mesh, options);
    }
    
    MeshAsset(const MeshPartView& mesh, const MeshAssetOptions& options = MeshAssetOptions()){
        InitializeFromRawMeshView(mesh,options);
    }
    
    constexpr inline const decltype(bounds)& GetBounds() const{
        return bounds;
    }
    
    virtual ~MeshAsset();
 
    constexpr inline const decltype(totalVerts) GetNumVerts() const {
        return totalVerts;
    }
 
    constexpr inline const decltype(totalIndices) GetNumIndices() const {
        return totalIndices;
    }
    
    constexpr inline decltype(systemRAMcopy)& GetSystemCopy(){
        return systemRAMcopy;
    }
    
    inline bool hasSystemRAMCopy() const{
        return systemRAMcopy.positions.size() > 0;
    }
    
    inline void DeallocSystemCopy(){
        systemRAMcopy = MeshPart{};
    }
};
 
}