feat(taa): Overhaul TAA implementation for improved quality and upscaling (#9573)

This commit introduces a significant rework of the Temporal Anti-Aliasing (TAA) system, focusing on improving reconstruction quality, robustness, and introducing flexible upscaling.

Core TAA Algorithm improvements:
- Replaced the Catmull-Rom filter with a more efficient 5-tap Lanczos filter for history sampling, which includes deringing to reduce artifacts.
- The input color buffer is now properly "unjittered" using a Lanczos reconstruction filter.
- Improved the history rejection algorithm by skipping the expensive accurate clipping when the history sample is already within the neighborhood's color gamut.
- Added a new `hdr` option to properly handle HDR content by tonemapping colors before blending and untonemapping the result.
- Removed the ineffective `VARIANCE` only history rejection method.
- Added protection against negative numbers in `sqrt()` for increased stability.

TAA Upscaling:
- Replaced the boolean `upscaling` flag with a float factor, allowing for variable upscaling ratios (e.g., 1.5x, 2x).
- Upscaling now correctly adjusts viewport and projection settings.
- The TAA shader now receives viewport and resolution information to correctly handle upscaled rendering.

API and Configuration Changes:
- Deprecated the `filterWidth` TAA option as it no longer has an effect.
- Introduced the `upscaling` float property to `TemporalAntiAliasingOptions`.
- Added the `hdr` boolean property to `TemporalAntiAliasingOptions`.

Other Changes:
- Updated UI elements in the viewer and material sandbox to reflect the new TAA options.
- Updated Javascript bindings and TypeScript definitions for the new TAA settings.
- Refactored shader code for clarity and performance.
This commit is contained in:
Mathias Agopian
2026-01-07 15:25:38 -08:00
committed by GitHub
parent f33a779668
commit 85ebd67a28
14 changed files with 328 additions and 208 deletions
@@ -2041,10 +2041,6 @@ public class View {
* use an AABB neighborhood
*/
AABB,
/**
* use the variance of the neighborhood (not recommended)
*/
VARIANCE,
/**
* use both AABB and variance
*/
@@ -2075,7 +2071,7 @@ public class View {
}
/**
* reconstruction filter width typically between 1 (sharper) and 2 (smoother)
* @deprecated has no effect.
*/
public float filterWidth = 1.0f;
/**
@@ -2095,9 +2091,9 @@ public class View {
*/
public boolean enabled = false;
/**
* 4x TAA upscaling. Disables Dynamic Resolution. [BETA]
* Upscaling factor. Disables Dynamic Resolution. [BETA]
*/
public boolean upscaling = false;
public float upscaling = 1.0f;
/**
* whether to filter the history buffer
*/
@@ -2110,6 +2106,10 @@ public class View {
* whether to use the YcoCg color-space for history rejection
*/
public boolean useYCoCg = false;
/**
* set to true for HDR content
*/
public boolean hdr = true;
/**
* type of color gamut box
*/
+3 -3
View File
@@ -489,16 +489,15 @@ struct MultiSampleAntiAliasingOptions {
* @see setTemporalAntiAliasingOptions()
*/
struct TemporalAntiAliasingOptions {
float filterWidth = 1.0f; //!< reconstruction filter width typically between 1 (sharper) and 2 (smoother)
float filterWidth = 1.0f; //!< @deprecated has no effect.
float feedback = 0.12f; //!< history feedback, between 0 (maximum temporal AA) and 1 (no temporal AA).
float lodBias = -1.0f; //!< texturing lod bias (typically -1 or -2)
float sharpness = 0.0f; //!< post-TAA sharpen, especially useful when upscaling is true.
bool enabled = false; //!< enables or disables temporal anti-aliasing
bool upscaling = false; //!< 4x TAA upscaling. Disables Dynamic Resolution. [BETA]
float upscaling = 1.0f; //!< Upscaling factor. Disables Dynamic Resolution. [BETA]
enum class BoxType : uint8_t {
AABB, //!< use an AABB neighborhood
VARIANCE, //!< use the variance of the neighborhood (not recommended)
AABB_VARIANCE //!< use both AABB and variance
};
@@ -519,6 +518,7 @@ struct TemporalAntiAliasingOptions {
bool filterHistory = true; //!< whether to filter the history buffer
bool filterInput = true; //!< whether to apply the reconstruction filter to the input
bool useYCoCg = false; //!< whether to use the YcoCg color-space for history rejection
bool hdr = true; //!< set to true for HDR content
BoxType boxType = BoxType::AABB; //!< type of color gamut box
BoxClipping boxClipping = BoxClipping::ACCURATE; //!< clipping algorithm
JitterPattern jitterPattern = JitterPattern::HALTON_23_X16; //! Jitter Pattern
+38 -55
View File
@@ -2911,11 +2911,12 @@ void PostProcessManager::configureTemporalAntiAliasingMaterial(
FMaterial* const ma = getPostProcessMaterial("taa").getMaterial(mEngine);
bool dirty = false;
setConstantParameter(ma, "upscaling", taaOptions.upscaling, dirty);
setConstantParameter(ma, "upscaling", taaOptions.upscaling > 1.0f, dirty);
setConstantParameter(ma, "historyReprojection", taaOptions.historyReprojection, dirty);
setConstantParameter(ma, "filterHistory", taaOptions.filterHistory, dirty);
setConstantParameter(ma, "filterInput", taaOptions.filterInput, dirty);
setConstantParameter(ma, "useYCoCg", taaOptions.useYCoCg, dirty);
setConstantParameter(ma, "hdr", taaOptions.hdr, dirty);
setConstantParameter(ma, "preventFlickering", taaOptions.preventFlickering, dirty);
setConstantParameter(ma, "boxType", int32_t(taaOptions.boxType), dirty);
setConstantParameter(ma, "boxClipping", int32_t(taaOptions.boxClipping), dirty);
@@ -2984,6 +2985,8 @@ FMaterialInstance* PostProcessManager::configureColorGradingMaterial(
FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
FrameGraphId<FrameGraphTexture> input,
FrameGraphId<FrameGraphTexture> const depth,
filament::Viewport const& xvp,
filament::Viewport const& vp,
FrameHistory& frameHistory,
FrameHistoryEntry::TemporalAA FrameHistoryEntry::*pTaa,
TemporalAntiAliasingOptions const& taaOptions,
@@ -3013,9 +3016,9 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
auto const& taaPass = fg.addPass<TAAData>("TAA",
[&](FrameGraph::Builder& builder, auto& data) {
auto desc = fg.getDescriptor(input);
if (taaOptions.upscaling) {
desc.width *= 2;
desc.height *= 2;
if (taaOptions.upscaling > 1.0f) {
desc.width *= taaOptions.upscaling;
desc.height *= taaOptions.upscaling;
}
data.color = builder.sample(input);
data.depth = builder.sample(depth);
@@ -3047,55 +3050,15 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
0, 0, 0, 1
}};
constexpr float2 sampleOffsets[9] = {
{ -1.0f, -1.0f }, { 0.0f, -1.0f }, { 1.0f, -1.0f }, { -1.0f, 0.0f },
{ 0.0f, 0.0f },
{ 1.0f, 0.0f }, { -1.0f, 1.0f }, { 0.0f, 1.0f }, { 1.0f, 1.0f },
};
constexpr float2 subSampleOffsets[4] = {
{ -0.25f, 0.25f },
{ 0.25f, 0.25f },
{ 0.25f, -0.25f },
{ -0.25f, -0.25f }
};
UTILS_UNUSED
auto const lanczos = [](float const x, float const a) -> float {
if (x <= std::numeric_limits<float>::epsilon()) {
return 1.0f;
}
if (std::abs(x) <= a) {
return (a * std::sin(f::PI * x) * std::sin(f::PI * x / a))
/ ((f::PI * f::PI) * (x * x));
}
return 0.0f;
};
float const filterWidth = std::clamp(taaOptions.filterWidth, 1.0f, 2.0f);
float4 sum = 0.0;
float4 weights[9];
// this doesn't get vectorized (probably because of exp()), so don't bother
// unrolling it.
UTILS_NOUNROLL
for (size_t i = 0; i < 9; i++) {
float2 const o = sampleOffsets[i];
for (size_t j = 0; j < 4; j++) {
float2 const subPixelOffset = taaOptions.upscaling ? subSampleOffsets[j] : float2{ 0 };
float2 const d = (o - (current.jitter - subPixelOffset)) / filterWidth;
weights[i][j] = lanczos(length(d), filterWidth);
}
sum += weights[i];
}
for (auto& w : weights) {
w /= sum;
}
auto out = resources.getRenderPassInfo();
auto color = resources.getTexture(data.color);
auto depth = resources.getTexture(data.depth);
auto history = resources.getTexture(data.history);
auto const color = resources.getTexture(data.color);
auto const depth = resources.getTexture(data.depth);
auto const history = resources.getTexture(data.history);
auto const& colorDesc = resources.getDescriptor(data.color);
auto const& historyDesc = resources.getDescriptor(data.history);
auto const& material = getPostProcessMaterial("taa");
PostProcessVariant const variant = colorGradingConfig.translucent ?
@@ -3106,17 +3069,37 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
FMaterialInstance* mi = getMaterialInstance(ma);
mi->setParameter("color", color, SamplerParams{}); // nearest
mi->setParameter("depth", depth, SamplerParams{}); // nearest
mi->setParameter("alpha", taaOptions.feedback);
mi->setParameter("history", history, SamplerParams{
.filterMag = SamplerMagFilter::LINEAR,
.filterMin = SamplerMinFilter::LINEAR
});
mi->setParameter("filterWeights", weights, 9);
mi->setParameter("jitter", current.jitter);
mi->setParameter("alpha", taaOptions.feedback);
// jitter is negated here because the material wants the sample jitter offset
// not the projection matrix offset
mi->setParameter("jitter", -current.jitter);
mi->setParameter("scale", taaOptions.upscaling);
mi->setParameter("reprojection",
mat4f{ historyProjection * inverse(current.projection) } *
normalizedToClip);
mi->setParameter("colorViewport",
float4{
float(xvp.left) / colorDesc.width,
float(xvp.bottom) / colorDesc.height,
float(xvp.width) / colorDesc.width,
float(xvp.height) / colorDesc.height,
});
mi->setParameter("colorResolution",
float4{ colorDesc.width, colorDesc.height,
1.0f / colorDesc.width, 1.0f / colorDesc.height });
mi->setParameter("historyResolution",
float4{ historyDesc.width, historyDesc.height,
1.0f / historyDesc.width, 1.0f / historyDesc.height });
mi->commit(driver, getUboManager());
mi->use(driver);
+2
View File
@@ -235,6 +235,8 @@ public:
FrameGraphId<FrameGraphTexture> taa(FrameGraph& fg,
FrameGraphId<FrameGraphTexture> input,
FrameGraphId<FrameGraphTexture> depth,
Viewport const& xvp,
Viewport const& vp,
FrameHistory& frameHistory,
FrameHistoryEntry::TemporalAA FrameHistoryEntry::*pTaa,
TemporalAntiAliasingOptions const& taaOptions,
+22 -10
View File
@@ -263,7 +263,9 @@ std::pair<float, float2> FRenderer::prepareUpscaler(float2 const scale,
if (taaOptions.enabled) {
bias += taaOptions.lodBias;
if (taaOptions.upscaling) {
derivativesScale = 0.5f;
if (taaOptions.upscaling > 1.0f) {
derivativesScale = 1.0f / taaOptions.upscaling;
}
}
}
return { bias, derivativesScale };
@@ -688,13 +690,13 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
// This configures post-process materials by setting constant parameters
if (taaOptions.enabled) {
ppm.configureTemporalAntiAliasingMaterial(taaOptions);
if (taaOptions.upscaling) {
if (taaOptions.upscaling > 1.0f) {
// for now TAA upscaling is incompatible with regular dsr
dsrOptions.enabled = false;
// also, upscaling doesn't work well with quater-resolution SSAO
aoOptions.resolution = 1.0;
// Currently we only support a fixed TAA upscaling ratio
scale = 0.5f;
scale = 1.0f / taaOptions.upscaling;
}
}
}
@@ -781,14 +783,14 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
// Without post-processing, we usually draw directly into
// the SwapChain, and we might want to keep it this way.
auto round = [](uint32_t const x) {
auto ceil16 = [](uint32_t const x) {
constexpr uint32_t rounding = 16u;
return (x + (rounding - 1u)) & ~(rounding - 1u);
};
// compute the new rendering width and height, multiple of 16.
const float width = float(round(svp.width )) + 2.0f * guardBand;
const float height = float(round(svp.height)) + 2.0f * guardBand;
const float width = float(ceil16(svp.width )) + 2.0f * guardBand;
const float height = float(ceil16(svp.height)) + 2.0f * guardBand;
// scale the field-of-view up, so it covers exactly the extra pixels
const float3 clipSpaceScaling{
@@ -1309,16 +1311,26 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
// TAA for color pass
if (taaOptions.enabled) {
input = ppm.taa(fg, input, depth, view.getFrameHistory(), &FrameHistoryEntry::taa,
input = ppm.taa(fg, input, depth, xvp, vp,
view.getFrameHistory(), &FrameHistoryEntry::taa,
taaOptions, colorGradingConfig);
if (taaOptions.upscaling) {
if (taaOptions.upscaling > 1.0f) {
scale = 1.0f;
scaled = false;
// xvp = vp;
// xvp.left = xvp.bottom = 0;
// svp = xvp;
UTILS_UNUSED_IN_RELEASE auto const& inputDesc = fg.getDescriptor(input);
svp.width = inputDesc.width;
svp.height = inputDesc.height;
xvp.width *= 2;
xvp.height *= 2;
// FIXME: this rounds xvp incorrectly
xvp.left *= taaOptions.upscaling;
xvp.bottom *= taaOptions.upscaling;
xvp.width *= taaOptions.upscaling;
xvp.height *= taaOptions.upscaling;
}
}
+3 -3
View File
@@ -320,9 +320,9 @@ float2 FView::updateScale(FEngine& engine,
// relative scaling ("velocity" control)
const float scale = mScale.x * mScale.y * command;
const float w = float(mViewport.width);
const float h = float(mViewport.height);
if (scale < 1.0f && !options.homogeneousScaling) {
const float w = float(mViewport.width);
const float h = float(mViewport.height);
// figure out the major and minor axis
const float major = std::max(w, h);
const float minor = std::min(w, h);
@@ -351,7 +351,7 @@ float2 FView::updateScale(FEngine& engine,
const auto s = mScale;
mScale = clamp(s, options.minScale, options.maxScale);
// disable the integration term when we're outside the controllable range
// Disable the integration term when we're outside the controllable range
// (i.e. we clamped). This help not to have to wait too long for the Integral term
// to kick in after a clamping event.
mPidController.setIntegralInhibitionEnabled(mScale != s);
+236 -117
View File
@@ -12,13 +12,18 @@ material {
filterable: false
},
{
type : float,
name : alpha
type : float4,
name : colorViewport,
precision: high
},
{
type : sampler2d,
name : history
},
{
type : float,
name : alpha
},
{
type : mat4,
name : reprojection,
@@ -30,8 +35,19 @@ material {
precision: high
},
{
type : float4[9],
name : filterWeights
type : float,
name : scale,
precision: high
},
{
type : float4,
name : colorResolution,
precision: high
},
{
type : float4,
name : historyResolution,
precision: high
}
],
constants : [
@@ -75,6 +91,11 @@ material {
name : preventFlickering,
default : false
},
{
type : bool,
name : hdr,
default : true
},
{
type : float,
name : varianceGamma,
@@ -91,7 +112,13 @@ material {
vertex {
void postProcessVertex(inout PostProcessVertexInputs postProcess) {
postProcess.vertex.xy = uvToRenderTargetUV(postProcess.normalizedUV);
highp vec2 uv = postProcess.normalizedUV;
// input UVs
//postProcess.vertex.xy = uvToRenderTargetUV(
// materialParams.colorViewport.xy + uv * materialParams.colorViewport.zw);
postProcess.vertex.xy = uvToRenderTargetUV(uv);
// history UVs
postProcess.vertex.zw = uvToRenderTargetUV(uv);
}
}
@@ -101,10 +128,8 @@ fragment {
// min/max neighborhood
#define BOX_TYPE_AABB 0
// Variance based neighborhood
#define BOX_TYPE_VARIANCE 1
// uses both min/max and variance
#define BOX_TYPE_AABB_VARIANCE 2
#define BOX_TYPE_AABB_VARIANCE 1
/* Clipping algorithm */
@@ -127,9 +152,8 @@ float lumaYCoCg(const vec3 c) {
return c.x;
}
float luma(const vec3 c) {
return (materialConstants_useYCoCg && materialConstants_boxClipping != BOX_CLIPPING_NONE) ?
lumaYCoCg(c) : lumaRGB(c);
float luma(const vec3 c, const bool isYcoCg) {
return isYcoCg ? lumaYCoCg(c) : lumaRGB(c);
}
vec3 tonemap(const vec3 c) {
@@ -153,6 +177,28 @@ vec3 untonemap(const vec3 c) {
return c * rcp(max(epsilon, 1.0 - max3(c)));
}
// 1-D Lanczos-2 approximation, input is squared and must be [-4, 4]
float lanczos2_SquaredInputApproximate(highp float x2) {
highp float wA = x2 - 4.0;
highp float wB = x2 * wA - wA;
wA *= wA;
wB *= wA;
return wB * (1.0 / 64.0);
}
// 1-D Lanczos-2 filter, input must be [-2, 2]
float lanczos2(float v) {
return lanczos2_SquaredInputApproximate(v * v);
}
// 1-D Lanczos-2 filter, input must be [-2, 2]
float lanczos2(float v, float scale) {
if (materialConstants_upscaling) {
v = clamp(v * scale, -2.0, 2.0);
}
return lanczos2(v);
}
vec3 RGB_YCoCg(const vec3 c) {
float Y = dot(c.rgb, vec3( 1, 2, 1) * 0.25);
float Co = dot(c.rgb, vec3( 2, 0, -2) * 0.25);
@@ -176,12 +222,15 @@ vec4 clipToBox(const int quality,
const float epsilon = 0.0001;
if (quality == BOX_CLIPPING_ACCURATE) {
vec4 r = c - h;
vec3 ir = 1.0 / (epsilon + r.rgb);
vec3 rmax = (boxmax - h.rgb) * ir;
vec3 rmin = (boxmin - h.rgb) * ir;
vec3 imin = min(rmax, rmin);
return h + r * saturate(max3(imin));
// don't clip if we're already in the box
if (any(lessThan(h.rgb, boxmin)) || any(greaterThan(h.rgb, boxmax))) {
vec4 r = c - h;
vec3 ir = 1.0 / (epsilon + r.rgb);
vec3 rmax = (boxmax - h.rgb) * ir;
vec3 rmin = (boxmin - h.rgb) * ir;
vec3 imin = min(rmax, rmin);
return h + r * saturate(max3(imin));
}
} else if (quality == BOX_CLIPPING_CLAMP) {
return vec4(clamp(h.rgb, boxmin, boxmax), h.a);
}
@@ -190,17 +239,23 @@ vec4 clipToBox(const int quality,
// Samples a texture with Catmull-Rom filtering, using 9 texture fetches instead of 16.
// https://therealmjp.github.io/
//
// Some optimizations from here:
// http://vec3.ca/bicubic-filtering-in-fewer-taps/ for more details
//
// Optimized to 5 taps by removing the corner samples
// And modified for mediump support
vec4 sampleTextureCatmullRom(const sampler2D tex, const highp vec2 uv, const highp vec2 texSize) {
// Jorge Jimenez, SIGGRAPH 2016, Filmic SMAA
// http://advances.realtimerendering.com/s2016/Filmic%20SMAA%20v7.pptx
//
// And modified for mediump support + deringing
//
vec4 sampleTextureCatmullRom(const sampler2D tex, const highp vec2 uv, const highp vec4 texSize) {
// We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate.
// We'll do this by rounding down the sample location to get the exact center of our "starting"
// texel. The starting texel will be at location [1, 1] in the grid, where [0, 0] is the
// top left corner.
highp vec2 samplePos = uv * texSize;
highp vec2 samplePos = uv * texSize.xy;
highp vec2 texPos1 = floor(samplePos - 0.5) + 0.5;
// Compute the fractional offset from our starting texel to our original sample location,
@@ -226,7 +281,7 @@ vec4 sampleTextureCatmullRom(const sampler2D tex, const highp vec2 uv, const hig
highp vec2 texPos3 = texPos1 + vec2(2.0);
highp vec2 texPos12 = texPos1 + w2 / w12;
highp vec2 invTexSize = 1.0 / texSize;
highp vec2 invTexSize = texSize.zw;
texPos0 *= invTexSize;
texPos3 *= invTexSize;
texPos12 *= invTexSize;
@@ -252,14 +307,28 @@ vec4 sampleTextureCatmullRom(const sampler2D tex, const highp vec2 uv, const hig
result *= rcp(k0 + k1 + k2 + k3 + k4);
// we could end-up with negative values
result = max(vec4(0), result);
// deringing...
vec4 boxmin = min(min(min(s[0], s[1]), min(s[2], s[3])), s[4]);
vec4 boxmax = max(max(max(s[0], s[1]), max(s[2], s[3])), s[4]);
result = clamp(result, boxmin, boxmax);
return result;
}
const vec2 kInputFilterSampleOffsets[9] = vec2[9](
vec2( 0, 0),
vec2( 0, -1), vec2(-1, 0), vec2( 1, 0), vec2( 0, 1),
vec2(-1, -1), vec2( 1, -1), vec2(-1, 1), vec2( 1, 1)
);
void postProcess(inout PostProcessInputs postProcess) {
highp vec4 uv = variable_vertex.xyxy; // interpolated to pixel center
const bool isColorYCoCg = materialConstants_useYCoCg &&
materialConstants_boxClipping != BOX_CLIPPING_NONE;
const bool isHistoryYCoCg = materialConstants_useYCoCg &&
materialConstants_boxClipping != BOX_CLIPPING_NONE;
// destination uv interpolated to pixel center
highp vec4 uv = variable_vertex;
if (materialConstants_historyReprojection) {
// read the depth buffer center sample for reprojection
@@ -274,133 +343,183 @@ void postProcess(inout PostProcessInputs postProcess) {
// read center color and history samples
vec4 history;
if (materialConstants_filterHistory) {
history = sampleTextureCatmullRom(materialParams_history, uv.zw,
vec2(textureSize(materialParams_history, 0)));
history = sampleTextureCatmullRom(materialParams_history, uv.zw, materialParams.historyResolution);
} else {
history = textureLod(materialParams_history, uv.zw, 0.0);
}
highp vec2 size = vec2(textureSize(materialParams_color, 0));
highp vec2 p = (floor(uv.xy * size) + 0.5) / size;
highp vec2 inputSize = materialParams.colorResolution.xy;
highp vec2 inputPixelSize = materialParams.colorResolution.zw;
// +----------+----------+--
// | | |
// | o | o |
// | | |
// +----------p----------+--
// | | |
// | o | o |
// | | x |
// +----------+----------+-
// | | |
// o: reconstructed sample
// x: jittered sample
// p: texture coordinate of the closest jittered sample from the reconstructed sample
highp vec2 reconstructedFragmentPos = uv.xy * inputSize;
highp vec2 closestInputSamplePos = floor(reconstructedFragmentPos - materialParams.jitter) + 0.5;
highp vec2 p = closestInputSamplePos * inputPixelSize;
highp vec2 samplePos = closestInputSamplePos + materialParams.jitter;
vec2 dcenter = samplePos - reconstructedFragmentPos;
vec4 filtered = textureLod(materialParams_color, p, 0.0);
vec3 s[9];
if (materialConstants_filterInput || materialConstants_boxClipping != BOX_CLIPPING_NONE) {
s[0] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1, -1)).rgb;
s[1] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 0, -1)).rgb;
s[2] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1, -1)).rgb;
s[3] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1, 0)).rgb;
s[4] = filtered.rgb;
s[5] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1, 0)).rgb;
s[6] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1, 1)).rgb;
s[7] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 0, 1)).rgb;
s[8] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1, 1)).rgb;
}
int j = 0;
float confidence = 1.0;
if (materialConstants_upscaling) {
highp vec2 subPixelOffset = (p - uv.xy) * size; // +/- [0.25, 0.25]
// we reduce the contribution of a sample based on the distance
// to the high resolution pixel center
const float cutoff = 0.5;
highp float l = length(materialParams.jitter - subPixelOffset) / cutoff;
confidence = saturate(1.0 - l * l);
if (materialConstants_filterInput ||
materialConstants_boxClipping != BOX_CLIPPING_NONE) {
vec3 s[9];
s[0] = filtered.rgb;
s[1] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 0, -1)).rgb;
s[2] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1, 0)).rgb;
s[3] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1, 0)).rgb;
s[4] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 0, 1)).rgb;
s[5] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1, -1)).rgb;
s[6] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1, -1)).rgb;
s[7] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1, 1)).rgb;
s[8] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1, 1)).rgb;
// the box can be used for deringing or history correction
vec3 box5min = min(s[0], min(min(s[1], s[2]), min(s[3], s[4])));
vec3 box5max = max(s[0], max(max(s[1], s[2]), max(s[3], s[4])));
vec3 box9min = min(box5min, min(min(s[5], s[6]), min(s[7], s[8])));
vec3 box9max = max(box5max, max(max(s[5], s[6]), max(s[7], s[8])));
if (materialConstants_filterInput) {
int jxp = subPixelOffset.y > 0.0 ? 1 : 2;
int jxn = subPixelOffset.y > 0.0 ? 0 : 3;
j = subPixelOffset.x > 0.0 ? jxp : jxn;
}
}
// reconstruct the sample at the center of the current pixel from 3x3 input samples
// using Lanczos filter. The input sample positions are jittered, so this can also be
// thought of as "unjittering" the input sample.
// The distance (in input texels) from the reconstructed sample (uv) to the filter's center sample
// is given by:
// p: texture coordinate of the center input sample
// dcenter = (p * inputSize - jitter) - uv * inputSize
if (materialConstants_filterInput) {
// unjitter/filter input
filtered = vec4(vec3(0), filtered.a);
for (int i = 0; i < 9; i++) {
float w = materialParams.filterWeights[i][j];
filtered.rgb += s[i] * w;
}
filtered.rgb = max(filtered.rgb, vec3(0));
}
filtered = vec4(vec3(0), filtered.a);
if (materialConstants_upscaling) {
// the weigths act as a blending factor because they acount only for a part of the
// reconstruction filter (for this frame). If the max weight is 0, it doesn't mean we must
// accumulate black into the history, but it means that these samples have little effect on the
// final reconstruction.
confidence = 0.0;
}
// build the history clamping box
if (materialConstants_boxClipping != BOX_CLIPPING_NONE) {
if (materialConstants_useYCoCg) {
history.rgb = RGB_YCoCg(history.rgb);
filtered.rgb = RGB_YCoCg(filtered.rgb);
for (int i = 0; i < 9; i++) {
s[i] = RGB_YCoCg(s[i]);
// The 2D application of the lanczos filter as a separable filter, which is the correct application
// of lanczos, however it is not isotropic.
float w0 = lanczos2(dcenter.x - 1.0, materialParams.scale);
float w1 = lanczos2(dcenter.x, materialParams.scale);
float w2 = lanczos2(dcenter.x + 1.0, materialParams.scale);
float w3 = lanczos2(dcenter.y - 1.0, materialParams.scale);
float w4 = lanczos2(dcenter.y, materialParams.scale);
float w5 = lanczos2(dcenter.y + 1.0, materialParams.scale);
highp float wx = w0 + w1 + w2;
highp float wy = w3 + w4 + w5;
float sum = wx * wy;
vec3 f;
f = s[5] * w0;
f += s[1] * w1;
f += s[6] * w2;
filtered.rgb += f * w3;
f = s[2] * w0;
f += s[0] * w1;
f += s[3] * w2;
filtered.rgb += f * w4;
f = s[7] * w0;
f += s[4] * w1;
f += s[8] * w2;
filtered.rgb += f * w5;
// Deringing must happen in RGB, because clamping in YCoCg can produce out-of-gamut colors
filtered.rgb *= (1.0 / sum);
filtered.rgb = clamp(filtered.rgb, box9min, box9max);
if (materialConstants_upscaling) {
confidence = sum;
}
}
vec3 boxmin;
vec3 boxmax;
if (materialConstants_boxType == BOX_TYPE_AABB ||
materialConstants_boxType == BOX_TYPE_AABB_VARIANCE) {
boxmin = min(s[4], min(min(s[1], s[3]), min(s[5], s[7])));
boxmax = max(s[4], max(max(s[1], s[3]), max(s[5], s[7])));
vec3 box9min = min(boxmin, min(min(s[0], s[2]), min(s[6], s[8])));
vec3 box9max = max(boxmax, max(max(s[0], s[2]), max(s[6], s[8])));
// round the corners of the 3x3 box, giving less importance to the corner samples
boxmin = (boxmin + box9min) * 0.5;
boxmax = (boxmax + box9max) * 0.5;
}
if (materialConstants_boxType == BOX_TYPE_VARIANCE ||
materialConstants_boxType == BOX_TYPE_AABB_VARIANCE) {
// "An Excursion in Temporal Supersampling" by Marco Salvi
highp vec3 m0 = s[4];// conversion to highp
highp vec3 m1 = m0 * m0;
// we use only 5 samples instead of all 9
for (int i = 1; i < 9; i+=2) {
highp vec3 c = s[i];// conversion to highp
m0 += c;
m1 += c * c;
// build the history clamping box
if (materialConstants_boxClipping != BOX_CLIPPING_NONE) {
if (materialConstants_useYCoCg) {
history.xyz = RGB_YCoCg(history.rgb);
filtered.xyz = RGB_YCoCg(filtered.rgb);
for (int i = 0; i < 9; i++) {
s[i] = RGB_YCoCg(s[i]);
}
// recompute the correction box in YCoCg
box5min = min(s[0], min(min(s[1], s[2]), min(s[3], s[4])));
box5max = max(s[0], max(max(s[1], s[2]), max(s[3], s[4])));
box9min = min(box5min, min(min(s[5], s[6]), min(s[7], s[8])));
box9max = max(box5max, max(max(s[5], s[6]), max(s[7], s[8])));
}
highp vec3 a0 = m0 * (1.0 / 5.0);
highp vec3 a1 = m1 * (1.0 / 5.0);
highp vec3 sigma = sqrt(a1 - a0 * a0);
if (materialConstants_boxType == BOX_TYPE_VARIANCE) {
boxmin = a0 - materialConstants_varianceGamma * sigma;
boxmax = a0 + materialConstants_varianceGamma * sigma;
} else {
// give more or less importance to the corner samples by lerp'ing between the two boxes
vec3 boxmin = mix(box5min, box9min, 0.5);
vec3 boxmax = mix(box5max, box9max, 0.5);
if (materialConstants_boxType == BOX_TYPE_AABB_VARIANCE) {
// "An Excursion in Temporal Supersampling" by Marco Salvi
highp vec3 m0 = s[0];// conversion to highp
highp vec3 m1 = m0 * m0;
// we use only 5 samples instead of all 9
const int count = 5; // 5 or 9
for (int i = 1; i < count; i++) {
highp vec3 c = s[i];// conversion to highp
m0 += c;
m1 += c * c;
}
highp vec3 a0 = m0 * (1.0 / float(count));
highp vec3 a1 = m1 * (1.0 / float(count));
// stdDev is never < 0, but we enforce it with abs(), which is free, to account for fp math
highp vec3 stdDev = sqrt(abs(a1 - a0 * a0));
// intersect both bounding boxes
boxmin = max(boxmin, a0 - materialConstants_varianceGamma * sigma);
boxmax = min(boxmax, a0 + materialConstants_varianceGamma * sigma);
boxmin = max(boxmin, a0 - materialConstants_varianceGamma * stdDev);
boxmax = min(boxmax, a0 + materialConstants_varianceGamma * stdDev);
}
// history clamping
history = clipToBox(materialConstants_boxClipping, boxmin, boxmax, filtered, history);
}
// history clamping
history = clipToBox(materialConstants_boxClipping, boxmin, boxmax, filtered, history);
}
float alpha = materialParams.alpha * confidence;
if (materialConstants_preventFlickering) {
// [Lottes] prevents flickering by modulating the blend weight by the difference in luma
float lumaColor = luma(filtered.rgb);
float lumaHistory = luma(history.rgb);
float lumaColor = luma(filtered.rgb, isColorYCoCg);
float lumaHistory = luma(history.rgb, isHistoryYCoCg);
float diff = 1.0 - abs(lumaColor - lumaHistory) / (0.001 + max(lumaColor, lumaHistory));
alpha *= diff * diff;
}
// go back to RGB space before tonemapping
if (materialConstants_boxClipping != BOX_CLIPPING_NONE) {
if (materialConstants_useYCoCg) {
filtered.rgb = YCoCg_RGB(filtered.rgb);
history.rgb = YCoCg_RGB(history.rgb);
}
if (isColorYCoCg) {
filtered.rgb = YCoCg_RGB(filtered.rgb);
}
if (isHistoryYCoCg) {
history.rgb = YCoCg_RGB(history.rgb);
}
// tonemap before mixing
filtered.rgb = tonemap(filtered.rgb);
history.rgb = tonemap(history.rgb);
if (materialConstants_hdr) {
// tonemap before mixing
filtered.rgb = tonemap(filtered.rgb);
history.rgb = tonemap(history.rgb);
}
// combine history and current frame
vec4 result = mix(history, filtered, alpha);
// untonemap result
result.rgb = untonemap(result.rgb);
if (materialConstants_hdr) {
// untonemap result
result.rgb = untonemap(result.rgb);
}
#if POST_PROCESS_OPAQUE
// kill the work performed above
+4 -3
View File
@@ -717,7 +717,6 @@ std::ostream& operator<<(std::ostream& out, const MultiSampleAntiAliasingOptions
int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, TemporalAntiAliasingOptions::BoxType* out) {
if (0 == compare(tokens[i], jsonChunk, "AABB")) { *out = TemporalAntiAliasingOptions::BoxType::AABB; }
else if (0 == compare(tokens[i], jsonChunk, "VARIANCE")) { *out = TemporalAntiAliasingOptions::BoxType::VARIANCE; }
else if (0 == compare(tokens[i], jsonChunk, "AABB_VARIANCE")) { *out = TemporalAntiAliasingOptions::BoxType::AABB_VARIANCE; }
else {
slog.w << "Invalid TemporalAntiAliasingOptions::BoxType: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
@@ -728,7 +727,6 @@ int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, TemporalAntiAli
std::ostream& operator<<(std::ostream& out, TemporalAntiAliasingOptions::BoxType in) {
switch (in) {
case TemporalAntiAliasingOptions::BoxType::AABB: return out << "\"AABB\"";
case TemporalAntiAliasingOptions::BoxType::VARIANCE: return out << "\"VARIANCE\"";
case TemporalAntiAliasingOptions::BoxType::AABB_VARIANCE: return out << "\"AABB_VARIANCE\"";
}
return out << "\"INVALID\"";
@@ -800,6 +798,8 @@ int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, TemporalAntiAli
i = parse(tokens, i + 1, jsonChunk, &out->filterInput);
} else if (compare(tok, jsonChunk, "useYCoCg") == 0) {
i = parse(tokens, i + 1, jsonChunk, &out->useYCoCg);
} else if (compare(tok, jsonChunk, "hdr") == 0) {
i = parse(tokens, i + 1, jsonChunk, &out->hdr);
} else if (compare(tok, jsonChunk, "boxType") == 0) {
i = parse(tokens, i + 1, jsonChunk, &out->boxType);
} else if (compare(tok, jsonChunk, "boxClipping") == 0) {
@@ -831,10 +831,11 @@ std::ostream& operator<<(std::ostream& out, const TemporalAntiAliasingOptions& i
<< "\"lodBias\": " << (in.lodBias) << ",\n"
<< "\"sharpness\": " << (in.sharpness) << ",\n"
<< "\"enabled\": " << to_string(in.enabled) << ",\n"
<< "\"upscaling\": " << to_string(in.upscaling) << ",\n"
<< "\"upscaling\": " << (in.upscaling) << ",\n"
<< "\"filterHistory\": " << to_string(in.filterHistory) << ",\n"
<< "\"filterInput\": " << to_string(in.filterInput) << ",\n"
<< "\"useYCoCg\": " << to_string(in.useYCoCg) << ",\n"
<< "\"hdr\": " << to_string(in.hdr) << ",\n"
<< "\"boxType\": " << (in.boxType) << ",\n"
<< "\"boxClipping\": " << (in.boxClipping) << ",\n"
<< "\"jitterPattern\": " << (in.jitterPattern) << ",\n"
+3 -3
View File
@@ -820,13 +820,13 @@ void ViewerGui::updateUserInterface() {
}
if (ImGui::CollapsingHeader("TAA Options")) {
ImGui::Checkbox("Upscaling", &mSettings.view.taa.upscaling);
ImGui::SliderFloat("Upscaling", &mSettings.view.taa.upscaling, 1.0f, 3.0f);
ImGui::Checkbox("History Reprojection", &mSettings.view.taa.historyReprojection);
ImGui::SliderFloat("Feedback", &mSettings.view.taa.feedback, 0.0f, 1.0f);
ImGui::Checkbox("Filter History", &mSettings.view.taa.filterHistory);
ImGui::Checkbox("Filter Input", &mSettings.view.taa.filterInput);
ImGui::SliderFloat("FilterWidth", &mSettings.view.taa.filterWidth, 0.2f, 2.0f);
ImGui::SliderFloat("LOD bias", &mSettings.view.taa.lodBias, -8.0f, 0.0f);
ImGui::Checkbox("HDR", &mSettings.view.taa.hdr);
ImGui::Checkbox("Use YCoCg", &mSettings.view.taa.useYCoCg);
ImGui::Checkbox("Prevent Flickering", &mSettings.view.taa.preventFlickering);
int jitterSequence = (int)mSettings.view.taa.jitterPattern;
@@ -834,7 +834,7 @@ void ViewerGui::updateUserInterface() {
int boxType = (int)mSettings.view.taa.boxType;
ImGui::Combo("Jitter Pattern", &jitterSequence, "RGSS x4\0Uniform Helix x4\0Halton x8\0Halton x16\0Halton x32\0\0");
ImGui::Combo("Box Clipping", &boxClipping, "Accurate\0Clamp\0None\0\0");
ImGui::Combo("Box Type", &boxType, "AABB\0Variance\0Both\0\0");
ImGui::Combo("Box Type", &boxType, "AABB\0Variance\0\0");
ImGui::SliderFloat("Variance Gamma", &mSettings.view.taa.varianceGamma, 0.75f, 1.25f);
ImGui::SliderFloat("RCAS", &mSettings.view.taa.sharpness, 0.0f, 1.0f);
mSettings.view.taa.boxClipping = (TemporalAntiAliasingOptions::BoxClipping)boxClipping;
-1
View File
@@ -717,7 +717,6 @@ static void gui(filament::Engine* engine, filament::View*) {
if (params.taaOptions.enabled) {
ImGui::Indent();
ImGui::SliderFloat("feedback", &params.taaOptions.feedback, 0.0f, 1.0f);
ImGui::SliderFloat("filter", &params.taaOptions.filterWidth, 0.02f, 2.0f);
ImGui::Unindent();
}
ImGui::Checkbox("FXAA", &params.fxaa);
+2 -1
View File
@@ -157,10 +157,11 @@ Filament.loadGeneratedExtensions = function() {
lodBias: -1.0,
sharpness: 0.0,
enabled: false,
upscaling: false,
upscaling: 1.0,
filterHistory: true,
filterInput: true,
useYCoCg: false,
hdr: true,
boxType: Filament.View$TemporalAntiAliasingOptions$BoxType.AABB,
boxClipping: Filament.View$TemporalAntiAliasingOptions$BoxClipping.ACCURATE,
jitterPattern: Filament.View$TemporalAntiAliasingOptions$JitterPattern.HALTON_23_X16,
+7 -4
View File
@@ -1705,7 +1705,6 @@ export interface View$MultiSampleAntiAliasingOptions {
export enum View$TemporalAntiAliasingOptions$BoxType {
AABB, // use an AABB neighborhood
VARIANCE, // use the variance of the neighborhood (not recommended)
AABB_VARIANCE, // use both AABB and variance
}
@@ -1736,7 +1735,7 @@ export enum View$TemporalAntiAliasingOptions$JitterPattern {
*/
export interface View$TemporalAntiAliasingOptions {
/**
* reconstruction filter width typically between 1 (sharper) and 2 (smoother)
* @deprecated has no effect.
*/
filterWidth?: number;
/**
@@ -1756,9 +1755,9 @@ export interface View$TemporalAntiAliasingOptions {
*/
enabled?: boolean;
/**
* 4x TAA upscaling. Disables Dynamic Resolution. [BETA]
* Upscaling factor. Disables Dynamic Resolution. [BETA]
*/
upscaling?: boolean;
upscaling?: number;
/**
* whether to filter the history buffer
*/
@@ -1771,6 +1770,10 @@ export interface View$TemporalAntiAliasingOptions {
* whether to use the YcoCg color-space for history rejection
*/
useYCoCg?: boolean;
/**
* set to true for HDR content
*/
hdr?: boolean;
/**
* type of color gamut box
*/
+1
View File
@@ -138,6 +138,7 @@ value_object<View::TemporalAntiAliasingOptions>("View$TemporalAntiAliasingOption
.field("filterHistory", &View::TemporalAntiAliasingOptions::filterHistory)
.field("filterInput", &View::TemporalAntiAliasingOptions::filterInput)
.field("useYCoCg", &View::TemporalAntiAliasingOptions::useYCoCg)
.field("hdr", &View::TemporalAntiAliasingOptions::hdr)
.field("boxType", &View::TemporalAntiAliasingOptions::boxType)
.field("boxClipping", &View::TemporalAntiAliasingOptions::boxClipping)
.field("jitterPattern", &View::TemporalAntiAliasingOptions::jitterPattern)
-1
View File
@@ -40,7 +40,6 @@ enum_<View::AmbientOcclusionOptions::AmbientOcclusionType>("View$AmbientOcclusio
enum_<View::TemporalAntiAliasingOptions::BoxType>("View$TemporalAntiAliasingOptions$BoxType")
.value("AABB", View::TemporalAntiAliasingOptions::BoxType::AABB)
.value("VARIANCE", View::TemporalAntiAliasingOptions::BoxType::VARIANCE)
.value("AABB_VARIANCE", View::TemporalAntiAliasingOptions::BoxType::AABB_VARIANCE)
;