EvpackImageLoader.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "asset/EvpackImageDecoder.h"
#include "graphics/IImageResourceFactory.h"
 
namespace eve::graphics {
class IResourceFactory;
}
 
namespace eve::asset_graphics {
 
using ImageAssetLoadLimits = asset::EvpackImageDecodeLimits;
 
struct LoadedGraphicsImage {
    AssetRef                      asset;
    graphics::Texture*            texture = nullptr;
    asset::EvpackVariantSelection variant;
};
 
class EVENGINE_API_WORLD GraphicsImageFactoryAdapter final : public graphics::IImageResourceFactory {
public:
    explicit GraphicsImageFactoryAdapter(graphics::IResourceFactory& factory) noexcept
        : factory_(factory) {}
 
    [[nodiscard]] Result<graphics::Texture*> uploadRgba8(
        std::uint32_t width, std::uint32_t height, const std::uint8_t* pixels,
        bool srgb) override;
 
    [[nodiscard]] Result<graphics::Texture*> uploadRgba8MipChain(uint32_t width, uint32_t height, uint32_t levels,
                                                                 std::span<const uint8_t> pixels) override;
 
    [[nodiscard]] Result<graphics::Texture*> uploadRgba8Volume(uint32_t width, uint32_t height, uint32_t depth,
                                                               std::span<const uint8_t> pixels) override;
 
    [[nodiscard]] Result<void> releaseImage(graphics::Texture* texture) override;
 
private:
    graphics::IResourceFactory& factory_;
};
 
class EVENGINE_API_WORLD EvpackImageLoader {
public:
    EvpackImageLoader(const asset::EvpackResourceReader& reader,
                      graphics::IImageResourceFactory& factory) noexcept
        : reader_(reader), factory_(factory) {}
 
    [[nodiscard]] Result<LoadedGraphicsImage> load(
        const AssetRef& image, const asset::EvpackCapabilities& capabilities,
        const ImageAssetLoadLimits& limits = {}) const;
 
private:
    const asset::EvpackResourceReader& reader_;
    graphics::IImageResourceFactory&   factory_;
};
 
struct VolumeTextureAssetLoadLimits {
    std::uint32_t maximumDimension    = 2048;
    std::uint64_t maximumVoxels       = 268'435'456;
    std::uint64_t maximumDecodedBytes = 1024ull * 1024ull * 1024ull;
};
 
struct LoadedGraphicsVolumeTexture {
    AssetRef                      asset;
    graphics::Texture*            texture = nullptr;
    asset::EvpackVariantSelection variant;
};
 
class EVENGINE_API_WORLD EvpackVolumeTextureLoader {
public:
    EvpackVolumeTextureLoader(const asset::EvpackResourceReader& reader,
                              graphics::IImageResourceFactory&   factory) noexcept
        : reader_(reader), factory_(factory) {}
 
    [[nodiscard]] Result<LoadedGraphicsVolumeTexture> load(const AssetRef&                     volume,
                                                           const asset::EvpackCapabilities&    capabilities,
                                                           const VolumeTextureAssetLoadLimits& limits = {}) const;
 
private:
    const asset::EvpackResourceReader& reader_;
    graphics::IImageResourceFactory&   factory_;
};
 
}  // namespace eve::asset_graphics