EVEngine/Exposure_8cpp_source.html

#include "graphics/Exposure.h"


#include <algorithm>

#include <string>

#include <utility>

#include <vector>


#include "common/Exception.h"

#include "graphics/BlendMode.h"

#include "graphics/Canvas.h"

#include "graphics/Color.h"

#include "graphics/Graphics.h"

#include "graphics/Shader.h"

#include "graphics/Texture.h"

#include "graphics/shaders/PostProcessWgsl.h"

#include "graphics/shaders/exposure_adapt_frag_spv.inc"

#include "graphics/shaders/exposure_apply_frag_spv.inc"

#include "graphics/shaders/exposure_meter_frag_spv.inc"


namespace eve::graphics {

namespace {


std::vector<uint32_t> copySpv(const uint32_t *data, size_t count) {

    return std::vector<uint32_t>(data, data + count);

}


Shader *newPostShader(Graphics *gfx, const uint32_t *spv, size_t count, const char *wgsl) {

    Shader *shader = gfx->getBackendName() == "webgpu"

                         ? gfx->newShaderFromWgsl({}, std::string(shaders::kPostCommon) + wgsl)

                         : gfx->newShaderFromSpv({}, copySpv(spv, count));

    if (!shader || !shader->gpuHandle) throw eve::Exception("Exposure: failed to create shader");

    return shader;

}


}  // namespace


Exposure::Exposure(Graphics *gfx) : gfx_(gfx) {

    if (!gfx_) throw eve::Exception("Exposure: null graphics");

    meterShader_ = newPostShader(gfx_, exposure_meter_frag_spv, exposure_meter_frag_spv_count,

                                 shaders::kExposureMeter);

    meterShader_->declareFloat("minEV");

    meterShader_->declareFloat("maxEV");


    adaptShader_ = newPostShader(gfx_, exposure_adapt_frag_spv, exposure_adapt_frag_spv_count,

                                 shaders::kExposureAdapt);

    adaptShader_->declareFloat("deltaSeconds");

    adaptShader_->declareFloat("darkSpeed");

    adaptShader_->declareFloat("brightSpeed");

    adaptShader_->declareFloat("resetHistory");


    applyShader_ = newPostShader(gfx_, exposure_apply_frag_spv, exposure_apply_frag_spv_count,

                                 shaders::kExposureApply);

    applyShader_->declareFloat("manualExposure");

    applyShader_->declareFloat("automatic");

    applyShader_->declareFloat("colorFilterR");

    applyShader_->declareFloat("colorFilterG");

    applyShader_->declareFloat("colorFilterB");

    applyShader_->declareFloat("vignette");

    applyShader_->declareFloat("lensDistortion");

    applyShader_->declareFloat("liftR");

    applyShader_->declareFloat("liftG");

    applyShader_->declareFloat("liftB");

    applyShader_->declareFloat("inverseGammaR");

    applyShader_->declareFloat("inverseGammaG");

    applyShader_->declareFloat("inverseGammaB");

    applyShader_->declareFloat("gainR");

    applyShader_->declareFloat("gainG");

    applyShader_->declareFloat("gainB");

    applyShader_->declareFloat("vignetteSmoothness");

    applyShader_->declareFloat("lensScale");

}


void Exposure::ensureTargets(int width, int height) {

    width = std::max(width, 1);

    height = std::max(height, 1);

    if (!meter_) {

        meter_ = gfx_->newHDRCanvas(1, 1);

        historyA_ = gfx_->newHDRCanvas(1, 1);

        historyB_ = gfx_->newHDRCanvas(1, 1);

        historyRead_ = historyA_;

        historyWrite_ = historyB_;

    }

    if (!output_ || width_ != width || height_ != height) {

        output_ = gfx_->newHDRCanvas(width, height);

        width_ = width;

        height_ = height;

        historyValid_ = false;

    }

    if (!meter_ || !historyRead_ || !historyWrite_ || !output_)

        throw eve::Exception("Exposure: failed to allocate HDR targets");

}


Texture *Exposure::apply(Texture *source, float manualExposure, bool automatic, float minEV,

                         float maxEV, const glm::vec3& colorFilter, const glm::vec3& lift,

                         const glm::vec3& inverseGamma, const glm::vec3& gain, float vignette,

                         float vignetteSmoothness, float lensDistortion, float lensScale,

                         Texture *meterSource,

                         float deltaSeconds) {

    if (!source) throw eve::Exception("Exposure.apply: null source");

    ensureTargets(source->getWidth(), source->getHeight());

    Canvas *previousCanvas = gfx_->getCanvas();

    Texture *exposureTexture = source;

    if (!meterSource) meterSource = source;


    if (automatic) {

        meterShader_->sendFloat("minEV", std::min(minEV, maxEV));

        meterShader_->sendFloat("maxEV", std::max(minEV, maxEV));

        meter_->clear(Color(0.f, 0.f, 0.f, 1.f), {}, {});

        gfx_->setCanvas(meter_);

        gfx_->drawTexturedRectShaderUV(meterSource, meterShader_, 0.f, 0.f, 1.f, 1.f, 0.f, 0.f,

                                       1.f, 1.f, Color(1.f, 1.f, 1.f, 1.f), false,

                                       BlendMode::Opaque);


        adaptShader_->sendFloat("deltaSeconds", std::clamp(deltaSeconds, 0.f, 0.25f));

        adaptShader_->sendFloat("darkSpeed", 1.5f);

        adaptShader_->sendFloat("brightSpeed", 3.f);

        adaptShader_->sendFloat("resetHistory", historyValid_ ? 0.f : 1.f);

        historyWrite_->clear(Color(1.f, 0.f, 0.f, 1.f), {}, {});

        gfx_->setCanvas(historyWrite_);

        Texture *meterTexture = meter_->getTexture();

        Texture *previousExposure = historyValid_ ? historyRead_->getTexture() : meterTexture;

        gfx_->drawTexturedRectShaderDepthMotion(meterTexture, previousExposure, meterTexture,

                                                adaptShader_, 0.f, 0.f, 1.f, 1.f,

                                                Color(1.f, 1.f, 1.f, 1.f));

        exposureTexture = historyWrite_->getTexture();

        historyValid_ = true;

        std::swap(historyRead_, historyWrite_);

    }


    applyShader_->sendFloat("manualExposure", std::max(manualExposure, 0.f));

    applyShader_->sendFloat("automatic", automatic ? 1.f : 0.f);

    applyShader_->sendFloat("colorFilterR", std::max(colorFilter.r, 0.f));

    applyShader_->sendFloat("colorFilterG", std::max(colorFilter.g, 0.f));

    applyShader_->sendFloat("colorFilterB", std::max(colorFilter.b, 0.f));

    applyShader_->sendFloat("vignette", std::clamp(vignette, 0.0F, 1.0F));

    applyShader_->sendFloat("lensDistortion", std::clamp(lensDistortion, 0.0F, 1.0F));

    applyShader_->sendFloat("liftR", lift.r);

    applyShader_->sendFloat("liftG", lift.g);

    applyShader_->sendFloat("liftB", lift.b);

    applyShader_->sendFloat("inverseGammaR", std::max(inverseGamma.r, 0.001F));

    applyShader_->sendFloat("inverseGammaG", std::max(inverseGamma.g, 0.001F));

    applyShader_->sendFloat("inverseGammaB", std::max(inverseGamma.b, 0.001F));

    applyShader_->sendFloat("gainR", gain.r);

    applyShader_->sendFloat("gainG", gain.g);

    applyShader_->sendFloat("gainB", gain.b);

    applyShader_->sendFloat("vignetteSmoothness", std::clamp(vignetteSmoothness, 0.01F, 1.0F));

    applyShader_->sendFloat("lensScale", std::clamp(lensScale, 0.01F, 5.0F));

    output_->clear(Color(0.f, 0.f, 0.f, 0.f), {}, {});

    gfx_->setCanvas(output_);

    gfx_->drawTexturedRectShaderDepthMotion(source, exposureTexture, source, applyShader_, 0.f, 0.f,

                                            float(width_), float(height_),

                                            Color(1.f, 1.f, 1.f, 1.f));

    gfx_->setCanvas(previousCanvas);

    Texture *result = output_->getTexture();

    if (!result) throw eve::Exception("Exposure: output texture missing");

    return result;

}


}  // namespace eve::graphics

BlendMode.h

Canvas.h

Color.h

Exception.h

Exposure.h

Graphics.h

height
std::uint32_t height
Definition ImageImporter.cpp:14

width
std::uint32_t width
Definition ImageImporter.cpp:13

PostProcessWgsl.h

shader
Shader * shader
Definition RenderSystem3D.cpp:679

Shader.h

count
std::uint32_t count
Definition SourceTiff.cpp:24

Texture.h

source
const UnitySourceAsset & source
Definition UnityVegetationPreset.cpp:29

eve::Exception
EVENGINE_API_FOUNDATION public API.
Definition Exception.h:13

eve::graphics::Canvas
Canvas public API.
Definition Canvas.h:17

eve::graphics::Canvas::clear
virtual void clear(std::optional< Color > color, std::optional< int > stencil, std::optional< double > depth)=0
Clears .

eve::graphics::Canvas::getTexture
virtual Texture * getTexture()=0
Sampleable color buffer; screen Canvas returns nullptr.

eve::graphics::Exposure::apply
Texture * apply(Texture *source, float manualExposure, bool automatic, float minEV, float maxEV, const glm::vec3 &colorFilter, const glm::vec3 &lift, const glm::vec3 &inverseGamma, const glm::vec3 &gain, float vignette, float vignetteSmoothness, float lensDistortion, float lensScale, Texture *meterSource=nullptr, float deltaSeconds=1.f/60.f)
Apply manual and optional automatic exposure to a linear HDR source.
Definition Exposure.cpp:93

eve::graphics::Exposure::Exposure
Exposure(Graphics *gfx)
Create cross-backend exposure shaders and 1x1 history targets.
Definition Exposure.cpp:37

eve::graphics::Graphics
Definition Graphics.h:125

eve::graphics::Graphics::drawTexturedRectShaderUV
virtual void drawTexturedRectShaderUV(Texture *texture, Shader *shader, float x, float y, float w, float h, float u0, float v0, float u1, float v1, const Color &color, bool rotatedUV=false, BlendMode blend=BlendMode::Alpha)=0
UV draw with an explicit Shader (nullptr = default textured pipeline).

eve::graphics::Graphics::getCanvas
virtual Canvas * getCanvas() const =0
Returns the canvas.

eve::graphics::Graphics::setCanvas
virtual void setCanvas(Canvas *canvas)=0
nullptr or this → screen. Switching flushes pending draws to the previous target.

eve::graphics::Graphics::drawTexturedRectShaderDepthMotion
virtual void drawTexturedRectShaderDepthMotion(Texture *color, Texture *depth, Texture *motion, Shader *shader, float x, float y, float w, float h, const Color &tint)=0
Post draw with color, depth/history and motion/reactive textures.

eve::graphics::Graphics::newHDRCanvas
virtual Canvas * newHDRCanvas(int width, int height)=0
Create an engine-internal linear RGBA16F post-process target.

eve::graphics::Shader::sendFloat
void sendFloat(const std::string &name, float x)
Definition Shader.cpp:95

eve::graphics::Shader::gpuHandle
void * gpuHandle
Definition Shader.h:145

eve::graphics::Shader::declareFloat
int declareFloat(const std::string &name)
Reserve sequential float slots in the push-constant block. Returns start index.
Definition Shader.cpp:43

eve::graphics::Texture
GPU texture created via Graphics::newTexture. Owns GPU resources through an opaque backend handle.
Definition Texture.h:18

eve::asset::EvpackChunkKind::Shader
@ Shader

eve::graphics::shaders::kExposureMeter
constexpr const char * kExposureMeter
Definition PostProcessWgsl.h:43

eve::graphics::shaders::kPostCommon
constexpr const char * kPostCommon
Definition PostProcessWgsl.h:6

eve::graphics::shaders::kExposureAdapt
constexpr const char * kExposureAdapt
Definition PostProcessWgsl.h:49

eve::graphics::shaders::kExposureApply
constexpr const char * kExposureApply
Definition PostProcessWgsl.h:54

eve::graphics
卡牌游戏 UI 工具模块：工厂 + 脚本绑定入口。 功能参考 ycarowr/UiCard：扇形手牌布局、抽牌/洗牌、悬浮放大、拖拽到落牌区、 敌方手牌（背面/偷看）、费用不足置灰，以及可实时调节的布局...
Definition Animation.h:25

eve::graphics::Color
eve::Color Color
RGBA color used by every graphics draw call. Lives inside eve::graphics so including a graphics heade...
Definition Color.h:13

eve::BlendMode::Opaque
@ Opaque