RenderSystem3D.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "common/Result.h"
#include "graphics/GpuDrivenTypes.h"
#include "graphics/Material.h"
#include "graphics/MeshInstanceRange.h"
#include "zeroerr/assert.h"
 
#include <array>
#include <cstdint>
#include <functional>
#include <glm/mat4x4.hpp>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::graphics {
 
class Canvas;
class Graphics;
class Mesh;
class Shader;
class Texture;
 
class EVENGINE_API_BACKENDS Camera3D : public ecs::Entity {
public:
    ENTITY(Camera3D, ecs::Entity)
 
    
    void release() override {}
 
    struct Data {
        static constexpr int kMaxReflectionProbes = 8;
        struct ReflectionProbe {
            Texture*  cubemap = nullptr;
            glm::vec3 center{0.f};
            glm::vec3 extent{0.f};
            float     intensity     = 0.f;
            float     blendDistance = 0.f;
            int       priority      = 0;
            bool      enabled       = false;
        };
        float eyeX = 0.f, eyeY = 0.f, eyeZ = 3.f;
        float targetX = 0.f, targetY = 0.f, targetZ = 0.f;
        float upX = 0.f, upY = 1.f, upZ = 0.f;
        float fovYDeg = 60.f, nearZ = 0.1f, farZ = 100.f;
        float aperture = 19.f, focalLength = 50.f;
        float lodBias = 1.f;
        std::array<float, 32> layerCullDistances{};
        std::array<float, 32>                             shadowLayerCullDistances{};
        bool                                              orthographic = false;
        float                                             orthoHeight  = 20.f;
        float                                             ambientR = 0.12f, ambientG = 0.12f, ambientB = 0.14f;
        Texture*                                          envMap       = nullptr;  // cubemap; nullptr → no IBL
        float                                             envIntensity = 1.f;
        glm::vec3                                         envProbeCenter{0.f};
        glm::vec3                                         envProbeExtent{0.f};  // any zero axis disables box projection
        std::array<ReflectionProbe, kMaxReflectionProbes> reflectionProbes{};
        float exposureEV = 0.f;  // exposure compensation in stops; 0 preserves legacy brightness
        bool autoExposure = false;
        float autoExposureMinEV = -8.f;
        float autoExposureMaxEV = 8.f;
        float bloomIntensity = 0.f;
        float bloomThreshold = 1.f;
        float dofFocusDistance = 0.f;
        float dofMaxBlurPx = 0.f;    // <= 0 disables DOF
        float dofFocusRange = 8.f;
        bool active = false;
        Camera3D *entity = nullptr;
        // Last screenToRay() result (origin = eye, dir normalized).
        float screenRayOx = 0.f, screenRayOy = 0.f, screenRayOz = 0.f;
        float screenRayDx = 0.f, screenRayDy = 0.f, screenRayDz = -1.f;
    };
 
    COMPONENT(Data, data)
 
    
    static Camera3D *createCamera() {
        Camera3D* c = Camera3D::create();
        ASSERT(c != nullptr);
        c->data()->entity = c;
        c->data()->active = true;
        return c;
    }
 
    void setEye(float x, float y, float z);
    float getEyeX();
    float getEyeY();
    float getEyeZ();
    void  setTarget(float x, float y, float z);
    float getTargetX();
    float getTargetY();
    float getTargetZ();
    void  setUp(float x, float y, float z);
    void  setFov(float fovYDeg);
    float getFov();
    void setOrthographic(float height);
    void setPerspective();
    void setClipPlanes(float nearZ, float farZ);
    void setLayerCullDistance(int layer, float distance);
    float getLayerCullDistance(int layer);
    void setShadowLayerCullDistance(int layer, float distance);
    float getShadowLayerCullDistance(int layer);
    void  setActive(bool active);
    void  setAmbient(float r, float g, float b);
    void setEnvMap(Texture* cube);
    void setEnvIntensity(float intensity);
    void setExposure(float ev);
    float getExposure();
    void setAutoExposure(bool enabled, float minEV = -8.f, float maxEV = 8.f);
    bool isAutoExposure();
    void setBloom(float intensity, float threshold = 1.f);
    float getBloomIntensity();
    float getBloomThreshold();
    void setDepthOfField(float focusDistance, float maxBlurPx, float focusRange = 8.f);
    void clearDepthOfField();
    float getDofFocusDistance();
    float getDofMaxBlur();
    float getDofFocusRange();
    void setEnvProbe(float centerX, float centerY, float centerZ, float extentX, float extentY, float extentZ);
    void clearEnvProbe();
    bool  hasEnvProbe();
    float getEnvProbeCenterX();
    float getEnvProbeCenterY();
    float getEnvProbeCenterZ();
    float getEnvProbeExtentX();
    float getEnvProbeExtentY();
    float getEnvProbeExtentZ();
    void setReflectionProbe(int slot, Texture* cubemap, float centerX, float centerY, float centerZ, float extentX,
                            float extentY, float extentZ, float intensity = 1.f, float blendDistance = 1.f,
                            int priority = 0);
    void clearReflectionProbe(int slot);
    int getReflectionProbeCount();
 
    void  screenToRay(float screenX, float screenY, float viewW, float viewH);
    float getScreenRayOriginX();
    float getScreenRayOriginY();
    float getScreenRayOriginZ();
    float getScreenRayDirX();
    float getScreenRayDirY();
    float getScreenRayDirZ();
};
 
class EVENGINE_API_BACKENDS Renderable3D : public ecs::Entity {
public:
    ENTITY(Renderable3D, ecs::Entity)
 
    
    void release() override {}
 
    struct Transform3D {
        float x = 0, y = 0, z = 0;
        float yaw = 0, pitch = 0, roll = 0;  // radians
        float sx = 1, sy = 1, sz = 1;
    };
 
    struct MeshRenderer {
        static constexpr int kMaxLodLevels = 4;
        static constexpr int kMaxParts     = Material::kMaxPartsHint;
 
        Mesh*    mesh             = nullptr;
        Texture* texture          = nullptr;
        Texture* normalTexture    = nullptr;  // nullptr → flat normal in default PBR path
        bool     packedNormalMask = false;    // RG normal XY, B AO, A smoothness
        Texture *heightTexture = nullptr;  // nullptr → no parallax height (R = height)
        Shader *shader = nullptr;          // nullptr → default mesh3d PBR pipeline
        std::optional<MeshInstanceRange> instances;
        Material* material = nullptr;
        Shader*  xrayShader    = nullptr;
        bool     xrayHighlight = false;
        float    r = 1, g = 1, b = 1, a = 1;
        float    metallic              = 0.f;
        float    roughness             = 0.45f;
        float    texBombScale          = 4.f;  // cells per UV unit
        float    texBombStrength       = 0.f;  // 0 = off (default, preserves tiling)
        float    texBombRot            = 1.f;  // 0..1 per-cell rotation amount
        float    parallaxScale         = 0.f;  // 0 = off (default)
        float    parallaxMinLayers     = 8.f;
        float    parallaxMaxLayers     = 32.f;
        bool     visible               = true;
        int      layer                 = 0;
        uint32_t reflectionCaptureMask = 1u;
        bool     receiveLight          = true;
        bool     castShadow            = true;
        bool     receiveShadow         = true;
        bool     castOcclusion         = true;  // volumetric occlusion (screen-space shafts)
        bool     customLightProbe      = false;
        std::array<glm::vec4, 9> customLightProbeSh{};
        bool      isHair = false;
        Camera3D* camera = nullptr;
 
        int       partCount        = 0;
        ModelPart parts[kMaxParts] = {};
 
        int   lodCount                        = 0;
        Mesh* lodMeshes[kMaxLodLevels]        = {};
        float lodDistances[kMaxLodLevels - 1] = {25.f, 60.f, 120.f};
        float lodCullDistance = 0.f;
        struct LodRendererState {
            bool configured = false;
            int  skinQuality = 0;
            int  shadowCastingMode = 1;
            bool receiveShadows = true;
            int  motionVectorMode = 1;
            bool skinnedMotionVectors = true;
            int  lightProbeUsage = 1;
            int  reflectionProbeUsage = 1;
        };
        LodRendererState lodRendererStates[kMaxLodLevels] = {};
        float lodFadeWidths[kMaxLodLevels] = {};
        int   lodFadeMode = 0;
        bool  lodAnimateCrossFading = false;
        float lodCrossFadeDuration = 0.5f;
        int   lodAnimatedCurrent = -2;
        int   lodAnimatedPrevious = -2;
        float lodAnimatedProgress = 1.f;
 
        Mesh *meshForDistance(float distance) const {
            if (lodCullDistance > 0.f && distance >= lodCullDistance) return nullptr;
            if (lodCount <= 0) return mesh;
            int level = 0;
            while (level + 1 < lodCount && distance >= lodDistances[level]) ++level;
            Mesh* picked = lodMeshes[level];
            return picked ? picked : mesh;
        }
 
        int lodLevelForDistance(float distance) const {
            if (lodCullDistance > 0.f && distance >= lodCullDistance) return -1;
            if (lodCount <= 0) return 0;
            int level = 0;
            while (level + 1 < lodCount && distance >= lodDistances[level]) ++level;
            return level;
        }
 
        void lodBlendForDistance(float distance, int& primary, int& secondary, float& secondaryWeight) const;
 
        bool usesParts() const { return partCount > 0; }
 
        bool effectiveHair() const {
            if (material) return material->isTransparentHair();
            return isHair;
        }
 
        bool effectiveCastShadow() const {
            if (material) return material->getCastShadow();
            return castShadow;
        }
    };
 
    COMPONENT(Transform3D, transform)
    COMPONENT(MeshRenderer, meshRenderer)
 
    void setPosition(float x, float y, float z);
    uint32_t getEntityId() const { return id; }
    uint32_t getEntityGeneration() const { return generation; }
    void setRotation(float yaw, float pitch, float roll);
    void setYaw(float yaw);
    float getYaw();
    void setScale(float sx, float sy, float sz);
    void setMesh(Mesh *mesh);
    [[nodiscard]] Result<void> setInstanceRange(const MeshInstanceRange &range);
    void clearInstanceRange();
    Mesh *getMesh();
    void  setTexture(Texture* texture);
    void  setNormalTexture(Texture* texture);
    void setPackedNormalMask(bool enabled);
    void setHeightTexture(Texture* texture);
    void setShader(Shader* shader);
    void      setMaterial(Material* material);
    Material *getMaterial();
    void    setXRayShader(Shader* shader);
    Shader *getXRayShader();
    void setXRayHighlight(bool on);
    bool getXRayHighlight();
    void setPart(int index, const std::string& name, Mesh* mesh, Material* material);
    void setPartSortPriority(int index, int priority);
    void clearPartSortPriority(int index);
    int         getPartSortPriority(int index);
    void        clearParts();
    int         getPartCount();
    std::string getPartName(int index);
    Mesh*       getPartMesh(int index);
    Material*   getPartMaterial(int index);
    void        setHair(bool hair);
    bool        getHair();
    void        setTint(float r, float g, float b, float a = 1.f);
    float getTintR() { return meshRenderer()->r; }
    float getTintG() { return meshRenderer()->g; }
    float getTintB() { return meshRenderer()->b; }
    float getRoughness() { return meshRenderer()->roughness; }
    void  setMetallic(float metallic);
    void  setRoughness(float roughness);
    void  setTexCellBomb(float cellScale, float strength, float rotAmount = 1.f);
    float getTexCellBombScale();
    float getTexCellBombStrength();
    float getTexCellBombRotation();
    void  setParallax(float scale, float minLayers = 8.f, float maxLayers = 32.f);
    float getParallaxScale();
    float getParallaxMinLayers();
    float getParallaxMaxLayers();
    void  setVisible(bool visible);
    bool getVisible() { return meshRenderer()->visible; }
    void setLayer(int layer);
    int getLayer();
    void setReflectionCaptureMask(int mask);
    int  getReflectionCaptureMask();
    void setReceiveLight(bool receive);
    [[nodiscard]] Result<void> setCustomLightProbe(float r, float g, float b);
    [[nodiscard]] Result<void> setCustomLightProbeCoefficient(int coefficient, float r, float g, float b);
    void clearCustomLightProbe();
    void setCastShadow(bool cast);
    void setReceiveShadow(bool receive);
    void setCastOcclusion(bool cast);
    bool getCastOcclusion();
    void setCamera(Camera3D* camera);
 
    void setMeshLod(int index, Mesh* mesh, float switchDistance = 0.f);
    [[nodiscard]] Result<void> setMeshLodRendererState(int index, int skinQuality, int shadowCastingMode,
                                                       bool receiveShadows, int motionVectorMode,
                                                       bool skinnedMotionVectors, int lightProbeUsage,
                                                       int reflectionProbeUsage);
    int getMeshLodRendererState(int index, int field);
    [[nodiscard]] Result<void> setMeshLodFadeWidth(int index, float width);
    [[nodiscard]] Result<void> setMeshLodFadePolicy(int mode, bool animate, float duration);
    [[nodiscard]] Result<void> advanceMeshLodTransition(float distance, float dt);
    int getMeshLodSecondaryLevelAtDistance(float distance);
    float getMeshLodSecondaryWeightAtDistance(float distance);
    void setMeshLodCullDistance(float distance);
    float getMeshLodCullDistance();
    void clearMeshLod();
    int  getMeshLodCount();
    int  getMeshLodLevelAtDistance(float distance);
};
 
class EVENGINE_API_BACKENDS RenderSystem3D {
public:
    static void render(Graphics& gfx);
 
    static void renderToCanvas(Graphics& gfx, Canvas* target, Camera3D* camera,
                               uint32_t reflectionCaptureMask = 0xffffffffu, float lodDistanceScale = 1.f,
                               bool includeTransparent = true, bool useClusteredLighting = true,
                               Texture* skyFaceTexture = nullptr, Mesh* skyQuad = nullptr,
                               float skyFaceTextureScale = 1.f);
 
    using CaptureExtraDrawer = std::function<void(Graphics& gfx, const Camera3D::Data& cam, const glm::mat4& viewProj,
                                                  float aspect, uint32_t reflectionCaptureMask)>;
 
    static uint64_t addCaptureExtraDrawer(uint32_t reflectionCaptureMask, CaptureExtraDrawer drawer);
 
    static void removeCaptureExtraDrawer(uint64_t token);
 
    using ForwardExtraDrawer =
        std::function<void(Graphics& gfx, const Camera3D::Data& cam, const glm::mat4& viewProj, float aspect)>;
 
    [[nodiscard]] static uint64_t addForwardExtraDrawer(ForwardExtraDrawer drawer);
 
    static void removeForwardExtraDrawer(uint64_t token);
 
    using GpuOpaqueCollector =
        std::function<void(Graphics& gfx, const Camera3D::Data& cam, const glm::mat4& viewProj, float aspect,
                           std::vector<GpuInstance>& instances)>;
 
    [[nodiscard]] static uint64_t addGpuOpaqueCollector(GpuOpaqueCollector collector);
 
    static void removeGpuOpaqueCollector(uint64_t token);
 
    using GBufferExtraDrawer =
        std::function<void(Graphics& gfx, const Camera3D::Data& cam, const glm::mat4& viewProj, float aspect)>;
    static void addGBufferExtraDrawer(GBufferExtraDrawer drawer);
 
    using DecalExtraDrawer =
        std::function<void(Graphics& gfx, const Camera3D::Data& cam, const glm::mat4& viewProj, float aspect)>;
    static void addDecalExtraDrawer(DecalExtraDrawer drawer);
 
    using ShadowExtraDrawer =
        std::function<void(Graphics &gfx, const glm::mat4 &lightVP,
                           const Camera3D::Data &cam)>;
    [[nodiscard]] static uint64_t addShadowExtraDrawer(ShadowExtraDrawer drawer);
 
    static void removeShadowExtraDrawer(uint64_t token);
 
    static void setDirectionalLight(float dx, float dy, float dz, float r, float g, float b);
};
 
}  // namespace eve::graphics