PbrSurface.h

浏览该文件的文档.

#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include "common/Export.h"
#include "common/Result.h"
namespace eve::graphics {
class Texture;
enum class PbrNormalMode : uint32_t {
    TangentXYZ    = 0, 
    VegetationRG  = 1, 
    VegetationRAG = 2, 
    VegetationAG  = 3  
};
enum class PbrVegetationBackfaceNormalMode : uint32_t { Flip = 0, Mirror = 1, Same = 2 };
enum class PbrCullMode : uint32_t { Inherit = 0, None = 1, Back = 2, Front = 3 };
enum class PbrTextureSlot : uint32_t {
    BaseColor,
    MetallicRoughness,
    Normal,
    Occlusion,
    Emissive,
    Specular,
    SpecularColor,
    Anisotropy,
    Clearcoat,
    ClearcoatRoughness,
    ClearcoatNormal,
    Count
};
struct PbrTextureBinding {
    Texture*             texture    = nullptr;
    uint32_t             texcoord   = 0;
    bool                 srgbDecode = true;
    std::array<float, 2> offset{0, 0}, scale{1, 1};
    float                rotation = 0;
    uint32_t             wrapS = 10497, wrapT = 10497, minFilter = 9987, magFilter = 9729;
};
struct PbrTranslucency {
    std::array<float, 3> color{1, 1, 1};
    float                intensity = 0, strength = 1, normalDistortion = .5f, scattering = 2;
    float                direct = .9f, ambient = .1f, shadow = .5f, maskAmount = 0;
    float                globalIntensity = 1, overlay = 1;
    float maskMinimum = 0, maskMaximum = 0;
};
struct PbrVegetationColorStages {
    std::array<float, 4> fieldColor{1, 1, 1, 0};
    std::array<float, 3> overlayColor{1, 1, 1}, vertexOcclusionColor{1, 1, 1};
    float                overlay = 0, wetness = 0, overlayVariation = 0.5f, overlayProjection = 0.5f;
    float                vertexOcclusionAlpha = 0.5019608f, overlayNormalScale = .5f, wetnessNormalScale = .5f;
    float                overlaySmoothness = .5f, wetnessContrast = .5f, overlaySubsurface = .5f;
    float                colorsCoverage = 1, colorsIntensity = 1, colorsMask = 1, colorsVariation = .5f;
    float                globalColorMaskMinimum = .1f, globalColorMaskMaximum = .2f;
    float                globalOverlayMaskMinimum = .1f, globalOverlayMaskMaximum = .2f;
    float                globalAlphaThresholdOffset = 0;
    float                vertexOcclusionMinimum = 0, vertexOcclusionMaximum = 1;
    bool                 invertVertexOcclusion = false, invertVertexOcclusionColors = false;
    PbrVegetationBackfaceNormalMode backfaceNormalMode = PbrVegetationBackfaceNormalMode::Flip;
};
struct PbrVegetationDetail {
    std::array<PbrTextureBinding, 3> textures{};
    std::array<float, 4>             color{1, 1, 1, 1}, colorTwo{1, 1, 1, 1};
    std::array<float, 2>             uvScale{1, 1}, uvOffset{0, 0};
    float    value = 0, normalValue = 1, normalBlendValue = 1, albedoValue = 1, metallicValue = 0;
    float    occlusionValue = 1, smoothnessValue = 1;
    float    blendMinimum = 0, blendMaximum = 1, maskMinimum = 0, maskMaximum = 1;
    float    meshMinimum = 0, meshMaximum = 1;
    uint32_t uvMode = 0, colorMode = 0, blendMode = 0, alphaMode = 1;
    uint32_t maskMode = 0, meshMode = 0;
    bool     inverseUvScale = false;
};
struct PbrVegetationExtras {
    Texture*             texture = nullptr;
    std::array<float, 9> usage{};
    std::array<float, 4> fallback{1, 0, 0, 1};
    std::array<float, 4> coords{1, 1, 0, 0};
    uint32_t             layer            = 0;
    bool                 usePivotPosition = false;
};
struct PbrVegetationColors {
    Texture*             texture = nullptr;
    std::array<float, 9> usage{};
    std::array<float, 4> fallback{1, 1, 1, 0}, coords{1, 1, 0, 0};
    uint32_t             layer            = 0;
    bool                 usePivotPosition = false;
};
enum class PbrVegetationDeformationSource : uint32_t { RestMesh, CpuDeformed, GpuFields };
struct PbrVegetationVertex {
    Texture*                       texture = nullptr;
    std::array<float, 9>           usage{};
    std::array<float, 4>           fallback{0, 0, 0, 1}, coords{1, 1, 0, 0};
    float                          globalSize = 1, sizeFadeStart = 0, sizeFadeEnd = 100, distanceFadeBias = 1;
    uint32_t                       layer  = 0;
    PbrVegetationDeformationSource source = PbrVegetationDeformationSource::RestMesh;
};
enum class PbrVegetationMotionMode : uint32_t { Disabled, Object };
struct PbrVegetationMotion {
    Texture*                texture = nullptr;
    Texture*                noise   = nullptr;
    std::array<float, 9>    usage{};
    std::array<float, 4>    fallback{1, 0, .5f, 0}, coords{1, 1, 0, 0};
    std::array<float, 2>    globalDirection{1, 0};
    std::array<float, 3>    worldOrigin{0, 0, 0};
    double                  time        = 0;
    float                   dynamicMode = 0, rigidity = .5f, facing = .5f;
    float                   bending = .2f, bendingSpeed = 2, bendingScale = 1, bendingVariation = 0;
    float                   branch = .2f, rolling = .2f, branchSpeed = 6, branchScale = 3, branchVariation = 0;
    float                   flutter = .2f, flutterSpeed = 20, flutterScale = 10, flutterVariation = 0;
    float                   globalBending = 1, globalBranch = 1, globalFlutter = 1, noiseTiling = 1;
    float                   interaction = 1, interactionMask = 1, fadeDistance = 100;
    float                   perspectivePush = 0, perspectiveNoise = 0, perspectiveAngle = 1;
    uint32_t                layer = 0;
    PbrVegetationMotionMode mode  = PbrVegetationMotionMode::Disabled;
};
struct PbrVegetationAlpha {
    Texture* noise  = nullptr;
    float    global = 0, variation = 0;
    float    glancing = 0, camera = 1, constant = 0;
    float    cameraFadeMin = 0, cameraFadeMax = 100, noiseTiling = 1;
    bool     detailFade = false;
    bool     enabled    = false;
};
struct PbrVegetationEmission {
    float minimum = 0, maximum = 1, phase = 1, global = 1;
    bool  enabled = false;
};
struct PbrVegetationGradient {
    std::array<float, 3> colorOne{1, 1, 1}, colorTwo{1, 1, 1};
    float                minimum = 0, maximum = 1;
    bool                 enabled = false;
};
struct PbrSurface {
    std::array<PbrTextureBinding, std::size_t(PbrTextureSlot::Count)> textures{};
    std::array<float, 3>                                              emissive{0, 0, 0}, specularColor{1, 1, 1};
    float normalScale = 1, occlusionStrength = 1, emissiveStrength = 1;
    float specularFactor = 1, ior = 1.5f;
    float anisotropyStrength = 0, anisotropyRotation = 0;
    float clearcoatFactor = 0, clearcoatRoughness = 0, clearcoatNormalScale = 1;
    bool  unlit = false;
    bool                 colorMaskEnabled = false;
    std::array<float, 3> colorMaskSecondary{1, 1, 1};
    float                colorMaskMin = 0, colorMaskMax = 0;
    float albedoTextureStrength = 1;
    PbrNormalMode normalMode = PbrNormalMode::TangentXYZ;
    PbrCullMode   cullMode   = PbrCullMode::Inherit;
    bool alphaToCoverage = false;
    PbrTranslucency          translucency{};
    PbrVegetationColorStages vegetationColor{};
    PbrVegetationDetail      vegetationDetail{};
    PbrVegetationExtras      vegetationExtras{};
    PbrVegetationColors      vegetationColors{};
    PbrVegetationVertex      vegetationVertex{};
    PbrVegetationMotion      vegetationMotion{};
    PbrVegetationAlpha       vegetationAlpha{};
    PbrVegetationEmission    vegetationEmission{};
    PbrVegetationGradient    vegetationGradient{};
    std::array<float, 3> motionHighlightColor{0, 0, 0};
};
[[nodiscard]] EVENGINE_API_BACKENDS Result<void> validatePbrSurface(const PbrSurface& surface);
}  // namespace eve::graphics