TerrainMaterialAtlas.h

浏览该文件的文档.

#pragma once
 
#include "asset/EvpackImageDecoder.h"
#include "asset/procgen/EvpackTerrainMaterialLoader.h"
 
namespace eve::graphics {
class IResourceFactory;
class Shader;
class Texture;
}  // namespace eve::graphics
namespace eve::asset_procgen {
 
struct TerrainAtlasImage {
    std::uint32_t             width = 0, height = 0;
    std::vector<std::uint8_t> pixels;
};
 
struct TerrainMaterialAtlasGroup {
    std::uint32_t     firstLayer = 0, layerCount = 0, tileWidth = 0, tileHeight = 0;
    TerrainAtlasImage albedo, normal, mask, control;
};
 
struct TerrainMaterialAtlases {
    std::vector<TerrainMaterialAtlasGroup> groups;
    TerrainAtlasImage                      holes;
};
 
struct PackedTerrainMaterialAtlases {
    TerrainAtlasImage albedo, normal, mask, controls, parameters;
    std::uint32_t     layerCount = 0;
    bool              hasHoles   = false;
};
 
struct TerrainMaterialAtlasLimits {
    std::uint32_t                  maximumLayers        = 16;
    std::uint32_t                  maximumTileDimension = 4096;
    std::uint64_t                  maximumOutputBytes   = 1024ull * 1024ull * 1024ull;
    asset::EvpackImageDecodeLimits image{};
};
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<PackedTerrainMaterialAtlases> packTerrainMaterialAtlases(
    const TerrainMaterialAtlases& atlases, const LoadedTerrainMaterial& material,
    const TerrainMaterialAtlasLimits& limits = {});
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<TerrainMaterialAtlases> buildTerrainMaterialAtlases(
    const asset::EvpackResourceReader& reader, const LoadedTerrainMaterial& material,
    const asset::EvpackCapabilities& capabilities, const TerrainMaterialAtlasLimits& limits = {});
 
 
struct TerrainMaterialGpuGroup {
    graphics::Texture* albedo  = nullptr;
    graphics::Texture* normal  = nullptr;
    graphics::Texture* mask    = nullptr;
    graphics::Texture* control = nullptr;
};
 
struct TerrainMaterialGpuSet {
    std::vector<TerrainMaterialGpuGroup> groups;
    graphics::Texture*                   holes = nullptr;
};
 
struct PackedTerrainMaterialGpuSet {
    graphics::Texture* albedo     = nullptr;
    graphics::Texture* normal     = nullptr;
    graphics::Texture* mask       = nullptr;
    graphics::Texture* controls   = nullptr;
    graphics::Texture* parameters = nullptr;
    std::uint32_t      layerCount = 0;
    bool               hasHoles   = false;
};
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<TerrainMaterialGpuSet> uploadTerrainMaterialAtlases(
    graphics::IResourceFactory& factory, const TerrainMaterialAtlases& atlases);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<void> releaseTerrainMaterialAtlases(graphics::IResourceFactory& factory,
                                                                                    TerrainMaterialGpuSet&      set);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<PackedTerrainMaterialGpuSet> uploadPackedTerrainMaterialAtlases(
    graphics::IResourceFactory& factory, const PackedTerrainMaterialAtlases& atlases);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<void> releasePackedTerrainMaterialAtlases(
    graphics::IResourceFactory& factory, PackedTerrainMaterialGpuSet& set);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<void> bindPackedTerrainMaterial(graphics::Shader& shader,
                                                                                const PackedTerrainMaterialGpuSet& gpu);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION Result<void> bindTerrainMaterialGroup(graphics::Shader&            shader,
                                                                               const TerrainMaterialGpuSet& gpu,
                                                                               const LoadedTerrainMaterial& material,
                                                                               std::size_t                  groupIndex);
}  // namespace eve::asset_procgen