mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
93 lines
5.9 KiB
Plaintext
93 lines
5.9 KiB
Plaintext
#version 450
|
|
// (hookshot) OoT's gameplay TAAU network (fd029a317a9a4b94) stood in for (vk_draw.cpp taau_stand_in): its input, the
|
|
// scene colour in RGB9E5 that its first passes made, sampled with a linear filter and written to its output at the
|
|
// output's size. The network's translation loses the blue channel (the yellow cast); this keeps the picture right at
|
|
// the cost of its temporal anti-aliasing.
|
|
//
|
|
// Against one-frame flashes: the picture before (`hist`, this pass's own last output) bounds each pixel, which may
|
|
// rise to 1.5x and fall to 0.6x of it in a frame (a light change or a camera cut settles over a few frames). Some
|
|
// frames' scene colour blows up to white across the picture (or a light term drops out for a frame); those frames
|
|
// came out as full-screen flashes. A NaN or infinite pixel takes the one before. pc.valid bit 0 = 0 (the first frame, a
|
|
// new size): no bound.
|
|
//
|
|
// Edges (pc.valid bit 1, the gameplay stand-in): FXAA (3.11, quality) on the input, in its perceptual encoding. The
|
|
// network smoothed them; a plain linear upscale left every edge stair-stepped, and hair, foliage and thin edges shimmer
|
|
// as they move. The network reads the scene colour alone (no motion, no depth), so a filter of one frame stands in for
|
|
// it: temporal accumulation without motion vectors smears everything that moves (see the clamp above).
|
|
layout(local_size_x = 8, local_size_y = 8) in;
|
|
layout(binding = 0) uniform sampler2D src;
|
|
layout(binding = 1, r11f_g11f_b10f) uniform writeonly image2D dst;
|
|
layout(binding = 2, r11f_g11f_b10f) uniform image2D hist;
|
|
layout(push_constant) uniform P { ivec2 size; int valid; } pc;
|
|
float luma(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }
|
|
// (FXAA 3.11's quality variant: the edge's orientation from the 3x3 neighbourhood, a search along it for its
|
|
// ends (12 steps at most), the pixel moved across the edge by its place on that span; and the sub-pixel blend, which
|
|
// softens the features thinner than a pixel (hair, twigs) that no span describes. On the input, at its texel size)
|
|
float L(vec2 uv) { return luma(textureLod(src, uv, 0.0).rgb); }
|
|
vec3 fxaa(vec2 uv, vec3 rgbM, out int moved) {
|
|
moved = 0;
|
|
const vec2 px = 1.0 / vec2(textureSize(src, 0));
|
|
const float m = luma(rgbM);
|
|
float n = L(uv + vec2(0.0, -px.y)), s = L(uv + vec2(0.0, px.y));
|
|
const float e = L(uv + vec2(px.x, 0.0)), w = L(uv + vec2(-px.x, 0.0));
|
|
const float hi = max(max(max(n, s), max(e, w)), m), lo = min(min(min(n, s), min(e, w)), m);
|
|
const float range = hi - lo;
|
|
// (FXAA's high-quality thresholds: with 0.125 / 0.0312 it also took the moss, cloth and leaf textures for edges and
|
|
// softened them)
|
|
if (range < max(0.0833, hi * 0.166)) return rgbM; // (no edge: flat areas and fine textures keep their plain sample)
|
|
const float nw = L(uv - px), se = L(uv + px), ne = L(uv + vec2(px.x, -px.y)), sw = L(uv + vec2(-px.x, px.y));
|
|
const float ns = n + s, we = w + e, nesw = ne + sw + nw + se;
|
|
const float edge_h = abs(-2.0 * w + nw + sw) + abs(-2.0 * m + ns) * 2.0 + abs(-2.0 * e + ne + se);
|
|
const float edge_v = abs(-2.0 * s + sw + se) + abs(-2.0 * m + we) * 2.0 + abs(-2.0 * n + nw + ne);
|
|
const bool horz = edge_h >= edge_v;
|
|
if (!horz) n = w, s = e;
|
|
float step = horz ? px.y : px.x;
|
|
const float grad_n = n - m, grad_s = s - m;
|
|
const bool pair_n = abs(grad_n) >= abs(grad_s);
|
|
const float grad = max(abs(grad_n), abs(grad_s)) * 0.25;
|
|
if (pair_n) step = -step;
|
|
const float edge_luma = (pair_n ? n + m : s + m) * 0.5;
|
|
vec2 pos = uv;
|
|
if (horz) pos.y += step * 0.5; else pos.x += step * 0.5;
|
|
const vec2 along = horz ? vec2(px.x, 0.0) : vec2(0.0, px.y);
|
|
vec2 pn = pos - along, pp = pos + along;
|
|
float end_n = L(pn) - edge_luma, end_p = L(pp) - edge_luma;
|
|
bool done_n = abs(end_n) >= grad, done_p = abs(end_p) >= grad;
|
|
const float q[11] = float[](1.5, 2.0, 2.0, 2.0, 2.0, 4.0, 8.0, 8.0, 8.0, 8.0, 8.0);
|
|
for (int i = 0; i < 11 && !(done_n && done_p); i++) {
|
|
if (!done_n) { pn -= along * q[i]; end_n = L(pn) - edge_luma; done_n = abs(end_n) >= grad; }
|
|
if (!done_p) { pp += along * q[i]; end_p = L(pp) - edge_luma; done_p = abs(end_p) >= grad; }
|
|
}
|
|
const float dn = horz ? uv.x - pn.x : uv.y - pn.y, dp = horz ? pp.x - uv.x : pp.y - uv.y;
|
|
const bool below = m - edge_luma < 0.0;
|
|
const bool good = dn < dp ? (end_n < 0.0) != below : (end_p < 0.0) != below;
|
|
const float span_off = good ? 0.5 - min(dn, dp) / (dn + dp) : 0.0;
|
|
const float sub = clamp(abs((ns * 2.0 + we * 2.0 + nesw) / 12.0 - m) / range, 0.0, 1.0);
|
|
const float sub_f = (-2.0 * sub + 3.0) * sub * sub;
|
|
const float sub_off = sub_f * sub_f * 0.5; // (half the blend of FXAA's default 0.75: textures stay sharper)
|
|
const float off = max(span_off, sub_off);
|
|
if (horz) uv.y += off * step; else uv.x += off * step;
|
|
moved = span_off >= 0.1 && span_off >= sub_off ? 1 : sub_off >= 0.1 ? 2 : 0; // (1: along an edge, 2: sub-pixel)
|
|
return textureLod(src, uv, 0.0).rgb;
|
|
}
|
|
void main() {
|
|
const ivec2 g = ivec2(gl_GlobalInvocationID.xy);
|
|
if (any(greaterThanEqual(g, pc.size))) return;
|
|
const vec2 uv = (vec2(g) + 0.5) / vec2(pc.size);
|
|
// (the input is the square root of the scene colour, the network's perceptual encoding, which its output undoes:
|
|
// 6637ac1d's means 0.58 0.50 0.27 -> 0.77 0.69 0.49)
|
|
vec3 s = textureLod(src, uv, 0.0).rgb;
|
|
int moved = 0;
|
|
if ((pc.valid & 2) != 0) s = fxaa(uv, s, moved);
|
|
// (RX_VK_TAAU_FXAA=2: the pixels it moved by a tenth of a texel or more: red along an edge, blue the sub-pixel blend)
|
|
if ((pc.valid & 4) != 0 && moved != 0) s = moved == 1 ? vec3(1.0, 0.0, 0.0) : vec3(0.0, 0.3, 1.0);
|
|
vec3 c = s * s;
|
|
if ((pc.valid & 1) != 0) {
|
|
const vec3 p = imageLoad(hist, g).rgb;
|
|
c = mix(c, p, bvec3(isnan(c.r) || isinf(c.r), isnan(c.g) || isinf(c.g), isnan(c.b) || isinf(c.b)));
|
|
c = clamp(c, p * 0.6, p * 1.5 + 0.01);
|
|
}
|
|
imageStore(dst, g, vec4(c, 1.0));
|
|
imageStore(hist, g, vec4(c, 1.0));
|
|
}
|