VirtualTextureBlend.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
#include "image/ImageData.h"
 
#include <cstddef>
#include <cstdint>
#include <list>
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace eve::graphics {
 
struct VirtualTextureBlendConfig {
    int         width                = 1024;
    int         height               = 1024;
    int         tileSize             = 128;
    int         borderSize           = 2;
    std::size_t residentPageCapacity = 64;
};
 
struct VirtualTextureBlendLayer {
    std::shared_ptr<const image::ImageData> albedo;
    std::shared_ptr<const image::ImageData> normal;
    std::shared_ptr<const image::ImageData> weight;
    float                                   uvScale        = 1.f;
    float                                   constantWeight = 1.f;
    float                                   heightContrast = 0.f;
};
 
struct VirtualTextureBlendStats {
    std::size_t   residentPages = 0;
    std::uint64_t pageHits      = 0;
    std::uint64_t pageMisses    = 0;
    std::uint64_t pageEvictions = 0;
};
 
struct VirtualTexturePageId {
    int  x                                                   = 0;
    int  y                                                   = 0;
    bool operator==(const VirtualTexturePageId& other) const = default;
};
 
struct VirtualTextureResidentSet {
    std::unique_ptr<image::ImageData> albedoAtlas;
    std::unique_ptr<image::ImageData> normalAtlas;
    std::unique_ptr<image::ImageData> pageTable;
    int                               atlasSlotsX    = 0;
    int                               atlasSlotsY    = 0;
    int                               pageExtent     = 0;
    float                             borderFraction = 0.f;
    std::size_t                       residentPages  = 0;
};
 
class EVENGINE_API_BACKENDS VirtualTextureBlend {
public:
    [[nodiscard]] static eve::Result<std::unique_ptr<VirtualTextureBlend>> create(
        const VirtualTextureBlendConfig& config);
 
    [[nodiscard]] eve::Result<std::uint32_t> addLayer(const VirtualTextureBlendLayer& layer);
 
    [[nodiscard]] eve::Result<std::shared_ptr<const image::ImageData>> requestAlbedoPage(int pageX, int pageY,
                                                                                         int mipLevel);
 
    [[nodiscard]] eve::Result<std::shared_ptr<const image::ImageData>> requestNormalPage(int pageX, int pageY,
                                                                                         int mipLevel);
 
    [[nodiscard]] eve::Result<std::unique_ptr<image::ImageData>> bakeAlbedo();
 
    [[nodiscard]] eve::Result<std::unique_ptr<image::ImageData>> bakeNormal();
 
    [[nodiscard]] eve::Result<VirtualTextureResidentSet> buildResidentSet(
        const std::vector<VirtualTexturePageId>& residentPages);
 
    void invalidate();
 
    VirtualTextureBlendStats stats() const;
 
    int                              pageCountX(int mipLevel = 0) const;
    int                              pageCountY(int mipLevel = 0) const;
    const VirtualTextureBlendConfig& config() const { return config_; }
 
private:
    enum class Attribute : std::uint8_t { Albedo, Normal };
    struct PageKey {
        int       x                                      = 0;
        int       y                                      = 0;
        int       mip                                    = 0;
        Attribute attribute                              = Attribute::Albedo;
        bool      operator==(const PageKey& other) const = default;
    };
    struct PageKeyHash {
        std::size_t operator()(const PageKey& key) const noexcept;
    };
    struct CacheEntry {
        std::shared_ptr<const image::ImageData> image;
        std::list<PageKey>::iterator            lru;
    };
 
    explicit VirtualTextureBlend(VirtualTextureBlendConfig config) : config_(config) {}
    [[nodiscard]] eve::Result<std::shared_ptr<const image::ImageData>> requestPage(PageKey key);
    std::shared_ptr<const image::ImageData>                            composePage(const PageKey& key) const;
    [[nodiscard]] eve::Result<std::unique_ptr<image::ImageData>>       bakeAttribute(Attribute attribute);
 
    VirtualTextureBlendConfig                            config_;
    std::vector<VirtualTextureBlendLayer>                layers_;
    std::list<PageKey>                                   lru_;
    std::unordered_map<PageKey, CacheEntry, PageKeyHash> cache_;
    std::uint64_t                                        hits_      = 0;
    std::uint64_t                                        misses_    = 0;
    std::uint64_t                                        evictions_ = 0;
};
 
}  // namespace eve::graphics