EvpackVegetationScene.h

浏览该文件的文档.

#pragma once
 
#include "asset/EvpackResourceReader.h"
#include "graphics/VegetationDetails.h"
#include "graphics/VegetationField.h"
#include "graphics/VegetationFieldGpu.h"
 
#include <array>
#include <map>
#include <glm/vec2.hpp>
#include <memory>
#include <vector>
#include <span>
 
namespace eve::asset_graphics {
 
struct VegetationSceneControl {
    float season = 2, globalAlpha = 1, globalOverlay = 0, globalWetness = 0, globalEmissive = 1;
    float globalSubsurface = 1, globalSize = 1, overlaySmoothness = .5f, overlayNormalScale = .5f;
    float overlaySubsurface = .5f, overlayScale = 1, wetnessContrast = .5f, wetnessNormalScale = .5f;
    float noiseTiling = 1, proximityFade = 1, distanceFadeBias = 1, defaultConformHeight = 0;
    std::array<float, 4> globalColor{.5f, .5f, .5f, 0}, overlayColor{1, 1, 1, 1};
    std::string overlayAlbedoGuid, overlayNormalGuid, noiseTextureGuid;
};
 
struct VegetationSceneMotion {
    float windPower = .5f, noiseTiling = 1, bending = 1, branch = 1, flutter = 1;
    float speed = 1, fadeDistance = 100;
    bool  animatedTime = true;
    std::array<float, 2> direction{-1, 0};
    std::string noiseTextureGuid;
};
 
struct VegetationSceneVolumeChannel {
    std::int32_t renderMode = 10;
    std::uint32_t width = 1024, height = 1024;
};
 
struct VegetationSceneVolume {
    float renderScale = 1, edgeFade = .75f;
    std::uint32_t visibility = 0, sorting = 0;
    std::array<VegetationSceneVolumeChannel, 4> channels{};
};
 
struct VegetationSceneElementProperty {
    std::string name, textureGuid, textureAsset;
    std::int32_t type = 0;
    std::array<float, 4> vector{};
    float value = 0;
};
 
struct VegetationSceneElement {
    std::int64_t sourceFileId = 0;
    std::string shaderGuid, kind, textureGuid, textureAsset;
    std::vector<VegetationSceneElementProperty> properties;
    std::uint32_t channel = 0;
    bool enabled = true, seasonal = false, invertDirection = false, volumeFade = false;
    std::int32_t visibility = -1, blendRgb = 0, blendAlpha = 0, directionMode = 20, motionMode = 15;
    std::uint16_t layers = 1;
    float intensity = 1, motionPower = 0;
    std::array<float, 3> position{}, scale{1, 1, 1};
    std::array<float, 4> rotation{0, 0, 0, 1}, value{1, 1, 1, 1};
    std::array<std::array<float, 4>, 4> seasons{};
    std::array<float, 6> remap{0, 1, 0, 1, 0, 0};
};
 
struct VegetationSceneElementPixelInput {
    glm::vec2 localUv{.5f};
    glm::vec4 mainSample{1.f};
    glm::vec4 elementParams{1.f};
    glm::vec4 vertexColor{1.f};
    glm::vec3 worldPosition{0.f};
    glm::vec3 worldNormal{0.f, 1.f, 0.f};
    glm::vec2 velocityDirection{0.f};
    glm::vec4 noiseSample{0.f};
    float terrainHeight = 0.f;
    float volumeFade = 1.f;
    float season = 2.f;
};
 
enum class VegetationScenePixelBlend : std::uint8_t { Alpha, Multiply, Add, Replace };
 
struct VegetationSceneElementPixel {
    glm::vec4 value{0.f};
    std::uint8_t colorMask = 15;
    std::int32_t blendRgb = 0, blendAlpha = 0;
    VegetationScenePixelBlend rgbOperation = VegetationScenePixelBlend::Alpha;
    VegetationScenePixelBlend alphaOperation = VegetationScenePixelBlend::Alpha;
};
 
struct LoadedVegetationScene {
    AssetRef                            asset;
    std::string                         sourceGuid;
    asset::EvpackVariantSelection      variant;
    graphics::VegetationDetailSettings details;
    VegetationSceneControl             control;
    VegetationSceneMotion              motion;
    VegetationSceneVolume              volume;
    std::vector<VegetationSceneElement> elements;
};
 
struct VegetationSceneProjection {
    graphics::PbrSurface       surface;
    graphics::VegetationMotion motion;
    VegetationSceneVolume      volume;
    float                      season = 2;
};
 
class EVENGINE_API_WORLD EvpackVegetationSceneLoader {
public:
    explicit EvpackVegetationSceneLoader(const asset::EvpackResourceReader& reader) noexcept : reader_(reader) {}
 
    [[nodiscard]] Result<LoadedVegetationScene> load(const AssetRef& asset,
                                                     const asset::EvpackCapabilities& capabilities,
                                                     std::uint64_t maximumDecodedBytes = 1024 * 1024) const;
 
private:
    const asset::EvpackResourceReader& reader_;
};
 
[[nodiscard]] EVENGINE_API_WORLD Result<VegetationSceneProjection> projectVegetationScene(
    const graphics::PbrSurface& baseSurface, const graphics::VegetationMotion& baseMotion,
    const LoadedVegetationScene& scene);
 
[[nodiscard]] EVENGINE_API_WORLD Result<std::map<std::string, graphics::VegetationMask>>
loadVegetationSceneElementMasks(const asset::EvpackResourceReader& reader, const LoadedVegetationScene& scene,
                                const asset::EvpackCapabilities& capabilities,
                                std::uint64_t                    maximumDecodedBytes = 256 * 1024 * 1024);
 
[[nodiscard]] EVENGINE_API_WORLD Result<VegetationSceneElementPixel> evaluateVegetationSceneElementPixel(
    const VegetationSceneElement& element, const VegetationSceneElementPixelInput& input);
 
[[nodiscard]] EVENGINE_API_WORLD glm::vec4 composeVegetationSceneElementPixel(
    glm::vec4 destination, const VegetationSceneElementPixel& source) noexcept;
 
[[nodiscard]] EVENGINE_API_WORLD Result<graphics::VegetationAtlas> bakeVegetationSceneElements(
    const LoadedVegetationScene& scene, const std::map<std::string, graphics::VegetationMask>& masks,
    const graphics::VegetationAtlas& base, std::array<std::uint8_t, 4> layers = {},
    std::span<const glm::vec3> worldNormals = {}, std::span<const float> terrainHeights = {},
    std::span<const glm::vec4> noiseSamples = {});
 
[[nodiscard]] Result<graphics::VegetationChannelAtlas> bakeVegetationSceneChannel(
    const LoadedVegetationScene& scene, const std::map<std::string, graphics::VegetationMask>& masks,
    graphics::VegetationChannel channel, const graphics::VegetationChannelAtlas& base, std::uint8_t layer = 0,
    std::span<const glm::vec3> worldNormals = {}, std::span<const float> terrainHeights = {},
    std::span<const glm::vec4> noiseSamples = {});
 
[[nodiscard]] EVENGINE_API_WORLD Result<graphics::VegetationAtlas> convertVegetationSceneAtlasToNative(
    const graphics::VegetationAtlas& tveAtlas);
 
[[nodiscard]] Result<graphics::VegetationChannelAtlas> convertVegetationSceneChannelToNative(
    graphics::VegetationChannel channel, const graphics::VegetationChannelAtlas& tveAtlas);
 
struct VegetationSceneChannelGpuBuild {
    std::array<graphics::VegetationChannelAtlas, 9> baseLayers;
    std::span<const glm::vec3> worldNormals{};
    std::span<const float> terrainHeights{};
    std::span<const glm::vec4> noiseSamples{};
};
 
struct VegetationSceneGpuBuild {
    std::array<VegetationSceneChannelGpuBuild, 4> channels;
    graphics::VegetationGpuRuntime runtime;
    std::uint64_t sourceRevision = 0;
};
 
struct VegetationSceneGpuPublication {
    std::uint64_t revision = 0;
    std::size_t deferredReleaseCount = 0;
};
 
class EVENGINE_API_WORLD VegetationSceneGpuRuntime final {
public:
    [[nodiscard]] static Result<std::unique_ptr<VegetationSceneGpuRuntime>> create(
        graphics::IResourceFactory& factory, const graphics::PbrSurface& baseSurface,
        const graphics::VegetationMotion& baseMotion, const LoadedVegetationScene& scene,
        const std::map<std::string, graphics::VegetationMask>& masks, const VegetationSceneGpuBuild& build);
 
    ~VegetationSceneGpuRuntime();
    VegetationSceneGpuRuntime(const VegetationSceneGpuRuntime&) = delete;
    VegetationSceneGpuRuntime& operator=(const VegetationSceneGpuRuntime&) = delete;
 
    [[nodiscard]] const graphics::PbrSurface& surface() const noexcept { return projection_.surface; }
    [[nodiscard]] const graphics::VegetationMotion& motion() const noexcept { return projection_.motion; }
    [[nodiscard]] std::uint64_t sourceRevision() const noexcept { return sourceRevision_; }
    [[nodiscard]] std::size_t deferredReleaseCount() const noexcept { return retiredFields_.size(); }
    [[nodiscard]] Result<VegetationSceneGpuPublication> replace(
        std::uint64_t expectedRevision, const graphics::PbrSurface& baseSurface,
        const graphics::VegetationMotion& baseMotion, const LoadedVegetationScene& scene,
        const std::map<std::string, graphics::VegetationMask>& masks, const VegetationSceneGpuBuild& build);
    [[nodiscard]] Result<void> release();
 
private:
    explicit VegetationSceneGpuRuntime(graphics::IResourceFactory& factory) noexcept : factory_(&factory) {}
 
    graphics::IResourceFactory* factory_ = nullptr;
    graphics::VegetationGpuFieldSet fields_;
    std::vector<graphics::VegetationGpuFieldSet> retiredFields_;
    VegetationSceneProjection projection_;
    std::uint64_t sourceRevision_ = 0;
};
 
}  // namespace eve::asset_graphics