VegetationPreset.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "asset/CanonicalMesh.h"
#include "asset/import/AssetImporter.h"
#include "common/Result.h"
#include "common/Value.h"
 
#include <array>
#include <cstdint>
#include <map>
#include <optional>
#include <set>
#include <span>
#include <string>
#include <vector>
 
namespace eve::asset_import {
 
struct VegetationPresetCommand {
    std::string              domain;
    std::string              operation;
    std::vector<std::string> arguments;
    std::string              sourcePath;
};
 
struct VegetationPresetContext {
    std::set<std::string>         outputOptions;
    std::string                   shaderName;
    std::string                   materialName;
    std::string                   shaderPipeline;
    std::map<std::string, double> materialFloats;
    std::set<std::string>         materialProperties;
    std::set<std::string>         materialTextures;
    std::set<std::string>         materialKeywords;
};
 
struct VegetationTextureChannelRecipe {
    std::string selector;
    std::string sourceProperty;
    std::string action;
};
 
struct VegetationTexturePackRecipe {
    std::string                                   targetProperty;
    std::string                                   importType = "DEFAULT";
    std::string                                   transformSpace;
    std::array<VegetationTextureChannelRecipe, 4> channels;
};
 
struct VegetationPresetImage {
    std::uint32_t             width  = 0;
    std::uint32_t             height = 0;
    std::vector<std::uint8_t> pixels;
};
 
struct VegetationConversionCandidate {
    std::map<std::string, double>                   materialFloats;
    std::map<std::string, std::array<double, 4>>    materialVectors;
    std::map<std::string, std::array<double, 4>>    materialColors;
    std::map<std::string, std::string>              materialTextures;
    std::map<std::string, std::array<double, 4>>    materialTextureTransforms;
    std::set<std::string>                           materialKeywords;
    std::set<std::string>                           lockedMaterialProperties;
    std::set<std::string>                           firstValidTextureDestinations;
    std::string                                     materialShader;
    std::string                                     materialLighting;
    bool                                            materialInstancing = false;
    std::map<std::string, std::vector<std::string>> meshRules;
    std::vector<VegetationTexturePackRecipe>        texturePacks;
    std::map<std::string, std::vector<std::string>> outputDirectives;
    std::map<std::string, std::string>              shaderAliases;
    std::vector<std::string>                        utilityModes;
};
 
enum class VegetationMeshOutputMode : std::uint8_t { Off, Default, Custom };
enum class VegetationMaterialOutputMode : std::uint8_t { Off, Default };
enum class VegetationTextureOutputEncoding : std::uint8_t { Png, Tga, Exr, UnityAsset };
enum class VegetationTransformOutputMode : std::uint8_t { KeepOriginal, TransformToWorldSpace };
 
struct VegetationConversionResult {
    VegetationConversionCandidate                candidate;
    std::optional<asset::CanonicalMeshData>      mesh;
    std::map<std::string, VegetationPresetImage> textures;
    std::optional<std::array<float, 3>>          meshBoundsMinimum;
    std::optional<std::array<float, 3>>          meshBoundsMaximum;
    bool                                         meshCpuReadable = false;
    VegetationMeshOutputMode                     meshOutput      = VegetationMeshOutputMode::Default;
    VegetationMaterialOutputMode                 materialOutput  = VegetationMaterialOutputMode::Default;
    VegetationTextureOutputEncoding              textureOutput   = VegetationTextureOutputEncoding::Png;
    VegetationTransformOutputMode                transformOutput = VegetationTransformOutputMode::TransformToWorldSpace;
};
 
struct UnityVegetationConversionRequest {
    std::vector<std::uint8_t>                    materialYaml;
    std::string                                  sourcePath;
    std::string                                  shaderName;
    std::string                                  materialName;
    std::string                                  shaderPipeline;
    std::set<std::string>                        outputOptions;
    std::map<std::string, Value>                 presetDefinitions;
    std::string                                  rootPreset;
    std::optional<asset::CanonicalMeshData>      mesh;
    std::map<std::string, VegetationPresetImage> textures;
    std::optional<std::array<float, 16>>         sourceToWorld;
    std::optional<std::array<float, 9>>          sourceDirectionToWorld;
    float                                        variationSeed        = 1.f;
    std::uint64_t                                maximumMaterialBytes = 16ull * 1024ull * 1024ull;
};
 
struct UnityVegetationAssetImportRequest {
    ImportPackageIdentity                            package;
    UnityVegetationConversionRequest                 conversion;
    std::string                                      materialGuid;
    std::string                                      outputKey;
    std::map<std::string, std::vector<std::uint8_t>> sourceFiles;
    AssetImportLimits                                limits;
};
 
struct UnityVegetationBatchImportRequest {
    ImportPackageIdentity                          package;
    std::vector<UnityVegetationAssetImportRequest> objects;
    AssetImportLimits                              limits;
};
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<VegetationConversionCandidate> decodeUnityVegetationConversionCandidate(
    std::span<const std::uint8_t> yaml, std::string sourcePath, std::uint64_t maximumBytes = 16ull * 1024ull * 1024ull);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<std::vector<std::uint8_t>> encodeUnityVegetationConversionMaterial(
    const VegetationConversionCandidate& candidate, std::uint64_t maximumBytes = 16ull * 1024ull * 1024ull);
 
[[nodiscard]] EVENGINE_API_PLATFORM VegetationPresetContext makeVegetationPresetContext(
    const VegetationConversionCandidate& candidate, std::string shaderName, std::string materialName,
    std::string shaderPipeline, std::set<std::string> outputOptions = {});
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<std::vector<VegetationPresetCommand>> evaluateVegetationPreset(
    const std::map<std::string, Value>& definitions, std::string_view root, const VegetationPresetContext& context);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<VegetationConversionCandidate> applyVegetationPreset(
    VegetationConversionCandidate source, const std::vector<VegetationPresetCommand>& commands);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<std::map<std::string, VegetationPresetImage>> executeVegetationTexturePacks(
    const VegetationConversionCandidate& candidate, const std::map<std::string, VegetationPresetImage>& sources,
    std::uint64_t maximumPixels = 16ull * 1024ull * 1024ull);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<std::map<std::string, VegetationPresetImage>> executeVegetationTexturePacks(
    const VegetationConversionCandidate& candidate, const std::map<std::string, VegetationPresetImage>& sources,
    const asset::CanonicalMeshData& mesh, std::uint64_t maximumPixels = 16ull * 1024ull * 1024ull);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<asset::CanonicalMeshData> executeVegetationMeshRules(
    const VegetationConversionCandidate& candidate, asset::CanonicalMeshData source, float variationSeed = 1.f);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<asset::CanonicalMeshData> executeVegetationMeshRules(
    const VegetationConversionCandidate& candidate, asset::CanonicalMeshData source,
    const std::map<std::string, VegetationPresetImage>& textures, float variationSeed = 1.f);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<VegetationConversionResult> executeVegetationConversion(
    VegetationConversionCandidate source, const std::vector<VegetationPresetCommand>& commands,
    std::optional<asset::CanonicalMeshData> mesh, const std::map<std::string, VegetationPresetImage>& textures,
    float variationSeed = 1.f, const std::optional<std::array<float, 16>>& sourceToWorld = {},
    const std::optional<std::array<float, 9>>& sourceDirectionToWorld = {});
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<VegetationConversionResult> executeUnityVegetationConversion(
    const UnityVegetationConversionRequest& request);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<PreparedAssetImport> prepareUnityVegetationConversionImport(
    const UnityVegetationAssetImportRequest& request);
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<PreparedAssetImport> prepareUnityVegetationConversionBatch(
    const UnityVegetationBatchImportRequest& request);
 
}  // namespace eve::asset_import