ReflectionProbeCapture.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::graphics {
 
class Camera3D;
class Canvas;
class Graphics;
class Mesh;
class ReflectionProbeRegistry;
class Texture;
 
class EVENGINE_API_BACKENDS ReflectionProbeCapture {
public:
    explicit ReflectionProbeCapture(Graphics *gfx);
    ~ReflectionProbeCapture();
 
    void configure(float x, float y, float z, int resolution = 128, float nearZ = 0.1f,
                   float farZ = 100.f);
 
    void requestCapture();
    void queueCapture();
 
    bool update(int faceBudget = 1);
 
    Canvas *getFaceCanvas(int face) const;
    bool isCapturePending() const { return pending_; }
    bool isRecaptureQueued() const { return recaptureAfterPublish_; }
    bool isCaptureComplete() const { return revision_ > 0 && !pending_; }
    uint32_t getRevision() const { return revision_; }
    bool stageCapturedFaces();
    Texture *getStagingCubemap() const { return stagingCubemap_; }
    uint32_t getStagedRevision() const { return stagedRevision_; }
    bool filterAndPublish(int sampleCount = 64);
    Texture *getActiveCubemap() const { return activeCubemap_; }
    uint32_t getPublishedRevision() const { return publishedRevision_; }
    void setUpdateMode(const std::string &mode);
    std::string getUpdateMode() const;
    void setRefreshInterval(int frames);
    int getRefreshInterval() const { return refreshInterval_; }
    void setCaptureMask(int mask);
    int getCaptureMask() const { return static_cast<int>(captureMask_); }
    void setEnvironmentLighting(Texture *environment, float intensity = 1.f);
    Texture *getEnvironmentLighting() const { return environmentLighting_; }
    float getEnvironmentLightingIntensity() const { return environmentLightingIntensity_; }
    void setSkyColor(float r, float g, float b, float intensity = 1.f);
    void setSkyFaceColor(int face, float r, float g, float b);
    void setSkyFaceTexture(int face, Texture *texture);
    Texture *getSkyFaceTexture(int face) const;
    void setSkyFaceTextureScale(int face, float scale);
    float getSkyFaceTextureScale(int face) const;
    float getSkyFaceColor(int face, int component) const;
    float getSkyR() const { return skyR_[0]; }
    float getSkyG() const { return skyG_[0]; }
    float getSkyB() const { return skyB_[0]; }
    float getSkyIntensity() const { return skyIntensity_; }
    int getPendingFaceCount() const { return pending_ ? 6 - nextFace_ : 0; }
    int getLastCapturedFaceCount() const { return lastCapturedFaceCount_; }
    uint32_t getTotalCapturedFaceCount() const { return totalCapturedFaceCount_; }
    int getLastFilterSampleCount() const { return lastFilterSampleCount_; }
    void setGpuBudgetMs(float milliseconds);
    float getGpuBudgetMs() const { return gpuBudgetMs_; }
    void reportGpuDurationMs(float milliseconds);
    float getSmoothedGpuDurationMs() const { return smoothedGpuDurationMs_; }
    int getAdaptiveFaceBudget() const { return adaptiveFaceBudget_; }
    int getAdaptiveFilterSamples() const { return adaptiveFilterSamples_; }
    bool tickAdaptive();
    bool tick(int faceBudget = 1, int filterSamples = 64);
    void configureInfluence(float extentX, float extentY, float extentZ, float intensity = 1.f,
                            float blendDistance = 1.f, int priority = 0);
    float getInfluenceExtentX() const { return influenceExtentX_; }
    float getInfluenceExtentY() const { return influenceExtentY_; }
    float getInfluenceExtentZ() const { return influenceExtentZ_; }
    float getInfluenceIntensity() const { return influenceIntensity_; }
    float getInfluenceBlendDistance() const { return influenceBlendDistance_; }
    int getInfluencePriority() const { return influencePriority_; }
    bool applyConfiguredToCamera(Camera3D *camera, int slot);
    bool applyToCamera(Camera3D *camera, int slot, float extentX, float extentY, float extentZ,
                       float intensity = 1.f, float blendDistance = 1.f, int priority = 0);
    int getResolution() const { return resolution_; }
    float getCenterX() const { return centerX_; }
    float getCenterY() const { return centerY_; }
    float getCenterZ() const { return centerZ_; }
    float getCaptureFarDistance() const { return farZ_; }
    void setCaptureLodDistanceScale(float scale);
    float getCaptureLodDistanceScale() const { return lodDistanceScale_; }
    void setCaptureTransparent(bool enabled);
    bool getCaptureTransparent() const { return captureTransparent_; }
    void setCaptureClusteredLighting(bool enabled);
    bool getCaptureClusteredLighting() const { return captureClusteredLighting_; }
 
private:
    friend class ReflectionProbeRegistry;
    void attachRegistry(ReflectionProbeRegistry *registry);
    void detachRegistry(ReflectionProbeRegistry *registry);
    void advanceRefreshPolicy();
    void requestCaptureAfterPublish();
    void ensureResources();
    void captureFace(int face);
 
    Graphics *gfx_ = nullptr;
    Camera3D *camera_ = nullptr;
    std::array<Canvas *, 6> faces_{};
    Mesh *skyQuad_ = nullptr;
    float centerX_ = 0.f;
    float centerY_ = 0.f;
    float centerZ_ = 0.f;
    float nearZ_ = 0.1f;
    float farZ_ = 100.f;
    int resolution_ = 128;
    int allocatedResolution_ = 0;
    int nextFace_ = 0;
    bool pending_ = true;
    uint32_t revision_ = 0;
    Texture *stagingCubemap_ = nullptr;
    int stagingResolution_ = 0;
    uint32_t stagedRevision_ = 0;
    Texture *activeCubemap_ = nullptr;
    uint32_t publishedRevision_ = 0;
    int activeResolution_ = 0;
    enum class UpdateMode { Static, OnDemand, TimeSliced, Realtime };
    UpdateMode updateMode_ = UpdateMode::OnDemand;
    int refreshInterval_ = 60;
    uint32_t captureMask_ = 0xffffffffu;
    Texture *environmentLighting_ = nullptr;
    float environmentLightingIntensity_ = 0.f;
    std::array<float, 6> skyR_{};
    std::array<float, 6> skyG_{};
    std::array<float, 6> skyB_{};
    std::array<float, 6> captureSkyR_{};
    std::array<float, 6> captureSkyG_{};
    std::array<float, 6> captureSkyB_{};
    std::array<Texture *, 6> skyFaceTextures_{};
    std::array<Texture *, 6> captureSkyFaceTextures_{};
    std::array<float, 6> skyFaceTextureScales_{{1.f, 1.f, 1.f, 1.f, 1.f, 1.f}};
    std::array<float, 6> captureSkyFaceTextureScales_{{1.f, 1.f, 1.f, 1.f, 1.f, 1.f}};
    float skyIntensity_ = 1.f;
    float captureSkyIntensity_ = 1.f;
    Texture *captureEnvironmentLighting_ = nullptr;
    float captureEnvironmentLightingIntensity_ = 0.f;
    bool recaptureAfterPublish_ = false;
    float lodDistanceScale_ = 1.f;
    float captureLodDistanceScale_ = 1.f;
    bool captureTransparent_ = true;
    bool snapshotCaptureTransparent_ = true;
    bool captureClusteredLighting_ = true;
    bool snapshotCaptureClusteredLighting_ = true;
    int framesSincePublish_ = 0;
    int lastCapturedFaceCount_ = 0;
    uint32_t totalCapturedFaceCount_ = 0;
    int lastFilterSampleCount_ = 0;
    float gpuBudgetMs_ = 1.5f;
    float smoothedGpuDurationMs_ = 0.f;
    int adaptiveFaceBudget_ = 1;
    int adaptiveFilterSamples_ = 64;
    int underBudgetReports_ = 0;
    float influenceExtentX_ = 1.f;
    float influenceExtentY_ = 1.f;
    float influenceExtentZ_ = 1.f;
    float influenceIntensity_ = 1.f;
    float influenceBlendDistance_ = 1.f;
    int influencePriority_ = 0;
    std::vector<ReflectionProbeRegistry *> registries_;
};
 
}  // namespace eve::graphics