ArtifactProvider.h

浏览该文件的文档.

#pragma once
 
#include "common/ArtifactPublication.h"
#include "common/RuntimeHandle.h"
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::graphics {
 
class Graphics;
class Mesh;
 
struct GraphicsArtifactHandleTag {};
using GraphicsArtifactHandle = eve::RuntimeHandle<GraphicsArtifactHandleTag>;
 
struct GraphicsArtifactDescriptor {
    eve::PersistentId id;
    std::string       buildKey;
    std::string       role;
    std::size_t       vertexCount = 0;
    std::size_t       indexCount  = 0;
    std::uint64_t     checksum    = 0;
    std::uint32_t backendVertexStride = 0;
    std::uint32_t backendIndexElementSize = 0;
 
    friend bool operator==(const GraphicsArtifactDescriptor&, const GraphicsArtifactDescriptor&) = default;
};
 
struct GraphicsArtifactResource {
    eve::PersistentId          id;
    std::string                buildKey;
    GraphicsArtifactHandle     handle;
    std::string                role;
    std::vector<float>         positions;
    std::vector<float>         normals;
    std::vector<float>         uvs;
    std::vector<std::uint32_t> indices;
    std::string backendName = "cpu";
    std::string uploadState = "not-attempted";
    bool gpuResident = false;
    std::uint32_t backendVertexStride = 0;
    std::uint32_t backendIndexElementSize = 0;
};
 
class EVENGINE_API_BACKENDS WebGpuArtifactDescriptorAdapter final {
public:
    [[nodiscard]] static std::optional<GraphicsArtifactDescriptor> describe(
        const eve::artifact::PublicationView& publication);
};
 
class EVENGINE_API_BACKENDS GraphicsArtifactProvider final : public eve::artifact::IGraphicsArtifactAdapter {
public:
    [[nodiscard]] eve::Result<std::unique_ptr<eve::artifact::PreparedPublication>> prepare(
        const eve::artifact::PublicationView& publication) override;
    [[nodiscard]] eve::Result<eve::Value> snapshotState() const override;
    [[nodiscard]] eve::Result<void> restoreState(const eve::Value& state) override;
    [[nodiscard]] bool emptyState() const noexcept override { return resources_.empty(); }
    void clearState() noexcept override { clear(); }
 
    [[nodiscard]] const GraphicsArtifactResource* find(eve::PersistentId id) const noexcept;
    [[nodiscard]] std::size_t size() const noexcept { return resources_.size(); }
    [[nodiscard]] std::uint64_t checksum(eve::PersistentId id) const noexcept;
    [[nodiscard]] std::optional<GraphicsArtifactDescriptor> descriptor(eve::PersistentId id) const;
    [[nodiscard]] bool isGpuResident(eve::PersistentId id) const noexcept;
    void clear() noexcept;
    void setPrepareFailure(bool enabled) noexcept { failPrepare_ = enabled; }
 
    void bindGraphics(Graphics* graphics) noexcept;
    void detachGraphics(Graphics* graphics) noexcept;
 
private:
    friend class GraphicsArtifactStage;
    struct RuntimeResource {
        GraphicsArtifactResource descriptor;
        Mesh*                    uploadedMesh = nullptr;
    };
    static void                  uploadIfAvailable(Graphics* graphics, RuntimeResource& resource) noexcept;
    void                         commit(RuntimeResource resource) noexcept;
    void                         release(RuntimeResource& resource) noexcept;
    std::vector<RuntimeResource> resources_;
    Graphics*                    graphics_    = nullptr;
    std::uint32_t                nextIndex_   = 0;
    bool                         failPrepare_ = false;
};
 
[[nodiscard]] EVENGINE_API_BACKENDS GraphicsArtifactProvider& graphicsArtifactProvider() noexcept;
EVENGINE_API_BACKENDS void registerGraphicsArtifactProvider(Graphics* graphics = nullptr);
void detachGraphicsArtifactProvider(Graphics* graphics) noexcept;
 
}  // namespace eve::graphics