EvpackGraphicsLoader.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "asset/CanonicalMesh.h"
#include "asset/EvpackResourceReader.h"
#include "graphics/IMeshResourceFactory.h"
 
namespace eve::graphics {
class IResourceFactory;
class Mesh;
}  // namespace eve::graphics
 
namespace eve::asset_graphics {
 
struct LoadedGraphicsMesh {
    AssetRef                      asset;
    graphics::Mesh*               mesh = nullptr;
    asset::EvpackVariantSelection variant;
    std::uint32_t texcoordSet = 0;
    std::vector<std::uint32_t> availableTexcoordSets;
    std::map<std::string, asset::CanonicalMeshAttribute> attributes;
};
 
struct GraphicsAssetLoadLimits {
    std::uint32_t maximumVertices = 4'000'000;
    std::uint32_t maximumIndices = 12'000'000;
    std::uint64_t maximumDecodedBytes = 512ull * 1024ull * 1024ull;
};
 
class EVENGINE_API_WORLD GraphicsMeshFactoryAdapter final : public graphics::IMeshResourceFactory {
public:
    explicit GraphicsMeshFactoryAdapter(graphics::IResourceFactory& factory) noexcept
        : factory_(factory) {}
 
    [[nodiscard]] Result<graphics::Mesh*> uploadMesh(
        const float* posXYZ, const float* nrmXYZ, const float* uvST, int vertexCount,
        const std::uint32_t* indices, int indexCount) override;
 
    [[nodiscard]] Result<graphics::Mesh*> uploadMeshColored(
        const float* posXYZ, const float* nrmXYZ, const float* uvST, const float* colorRGBA,
        int vertexCount, const std::uint32_t* indices, int indexCount) override;
 
    [[nodiscard]] Result<void> releaseMesh(graphics::Mesh* mesh) override;
 
    [[nodiscard]] Result<void> setMeshTexcoords(graphics::Mesh* mesh, std::uint32_t set,
                                                std::span<const float> values) override;
    [[nodiscard]] Result<void> setMeshTangentFrame(graphics::Mesh* mesh, std::span<const float> tangents,
                                                   std::span<const float> bitangents) override;
 
private:
    graphics::IResourceFactory& factory_;
};
 
class EVENGINE_API_WORLD EvpackGraphicsLoader {
public:
    EvpackGraphicsLoader(const asset::EvpackResourceReader& reader,
                         graphics::IMeshResourceFactory& factory) noexcept
        : reader_(reader), factory_(factory) {}
 
    [[nodiscard]] Result<LoadedGraphicsMesh> loadMesh(const AssetRef&                  asset,
                                                      const asset::EvpackCapabilities& capabilities,
                                                      const GraphicsAssetLoadLimits&   limits      = {},
                                                      std::uint32_t                    texcoordSet = 0,
                                                      bool preserveAllTexcoords                    = false) const;
 
private:
    const asset::EvpackResourceReader& reader_;
    graphics::IMeshResourceFactory&    factory_;
};
 
}  // namespace eve::asset_graphics