From 8f26d985e683c499c92327c629ca92cd1eeee9d3 Mon Sep 17 00:00:00 2001 From: hunterk Date: Wed, 6 Jun 2018 16:17:10 -0500 Subject: [PATCH] add curvature and moire compensation to crtglow --- crt/shaders/glow/resolve.slang | 289 +++++++++++++++++++++++++++++++-- 1 file changed, 274 insertions(+), 15 deletions(-) diff --git a/crt/shaders/glow/resolve.slang b/crt/shaders/glow/resolve.slang index 855fe96..f89ad5f 100644 --- a/crt/shaders/glow/resolve.slang +++ b/crt/shaders/glow/resolve.slang @@ -1,54 +1,313 @@ #version 450 +// Original bits by Themaister +// Moire mitigation bits by Timothy Lottes, added by hunterk + layout(push_constant) uniform Push { - float BLOOM_STRENGTH; - float OUTPUT_GAMMA; + float BLOOM_STRENGTH; + float OUTPUT_GAMMA; + float CURVATURE; + float moire_mitigation; + float warpX; + float warpY; + float shadowMask; + float maskDark; + float maskLight; } param; - + #pragma parameter BLOOM_STRENGTH "Glow Strength" 0.45 0.0 0.8 0.05 #pragma parameter OUTPUT_GAMMA "Monitor Gamma" 2.2 1.8 2.6 0.02 - +#pragma parameter CURVATURE "Curvature" 0.0 0.0 1.0 1.0 +#pragma parameter moire_mitigation "Moire:Noise Tradeoff" 4.0 1.0 10.0 1.0 +#pragma parameter warpX "Curvature X-Axis" 0.031 0.0 0.125 0.01 +#pragma parameter warpY "Curvature Y-Axis" 0.041 0.0 0.125 0.01 +#pragma parameter shadowMask "Mask Effect" 0.0 0.0 4.0 1.0 +#pragma parameter maskDark "maskDark" 0.5 0.0 2.0 0.1 +#pragma parameter maskLight "maskLight" 1.5 0.0 2.0 0.1 + +#define iTime mod(float(global.FrameCount) / 60.0, 600.0) +#define fragCoord (vTexCoord.xy * global.OutputSize.xy) + layout(std140, set = 0, binding = 0) uniform UBO { mat4 MVP; vec4 OutputSize; vec4 OriginalSize; vec4 SourceSize; - vec4 CRTPassSize; + vec4 CRTPassSize; + uint FrameCount; } global; - + #pragma stage vertex layout(location = 0) in vec4 Position; layout(location = 1) in vec2 TexCoord; layout(location = 0) out vec2 vTexCoord; - + void main() { gl_Position = global.MVP * Position; vTexCoord = TexCoord; } - + #pragma stage fragment layout(location = 0) in vec2 vTexCoord; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 1) uniform sampler2D Source; layout(set = 0, binding = 2) uniform sampler2D CRTPass; - + // For debugging #define BLOOM_ONLY 0 - + #define CRT_PASS CRTPass - + +// Convert from linear to sRGB. +//float Srgb(float c){return(c<0.0031308?c*12.92:1.055*pow(c,0.41666)-0.055);} +vec4 Srgb(vec4 c){return pow(c, vec4(1.0 / 2.2));} + +// Convert from sRGB to linear. +//float Linear(float c){return(c<=0.04045)?c/12.92:pow((c+0.055)/1.055,2.4);} +float Linear(float c){return pow(c, 2.2);} + +// +// Semi-Poor Quality Temporal Noise +// + +// Base. +// Ripped ad modified from: https://www.shadertoy.com/view/4djSRW +float Noise(vec2 p,float x){p+=x; + vec3 p3=fract(vec3(p.xyx)*10.1031); + p3+=dot(p3,p3.yzx+19.19); + return (fract((p3.x+p3.y)*p3.z)*2.0-1.0) / pow(2.0, 11.0 - param.moire_mitigation);} + +// Step 1 in generation of the dither source texture. +float Noise1(vec2 uv,float n){ + float a=1.0,b=2.0,c=-12.0,t=1.0; + return (1.0/max(a*4.0+b*4.0,-c))*( + Noise(uv+vec2(-1.0,-1.0)*t,n)*a+ + Noise(uv+vec2( 0.0,-1.0)*t,n)*b+ + Noise(uv+vec2( 1.0,-1.0)*t,n)*a+ + Noise(uv+vec2(-1.0, 0.0)*t,n)*b+ + Noise(uv+vec2( 0.0, 0.0)*t,n)*c+ + Noise(uv+vec2( 1.0, 0.0)*t,n)*b+ + Noise(uv+vec2(-1.0, 1.0)*t,n)*a+ + Noise(uv+vec2( 0.0, 1.0)*t,n)*b+ + Noise(uv+vec2( 1.0, 1.0)*t,n)*a+ + 0.0);} + +// Step 2 in generation of the dither source texture. +float Noise2(vec2 uv,float n){ + float a=1.0,b=2.0,c=-2.0,t=1.0; + return (1.0/(a*4.0+b*4.0))*( + Noise1(uv+vec2(-1.0,-1.0)*t,n)*a+ + Noise1(uv+vec2( 0.0,-1.0)*t,n)*b+ + Noise1(uv+vec2( 1.0,-1.0)*t,n)*a+ + Noise1(uv+vec2(-1.0, 0.0)*t,n)*b+ + Noise1(uv+vec2( 0.0, 0.0)*t,n)*c+ + Noise1(uv+vec2( 1.0, 0.0)*t,n)*b+ + Noise1(uv+vec2(-1.0, 1.0)*t,n)*a+ + Noise1(uv+vec2( 0.0, 1.0)*t,n)*b+ + Noise1(uv+vec2( 1.0, 1.0)*t,n)*a+ + 0.0);} + +// Compute temporal dither from integer pixel position uv. +float Noise3(vec2 uv){return Noise2(uv,fract(iTime));} + +// Energy preserving dither, for {int pixel pos,color,amount}. +vec2 Noise4(vec2 uv,vec2 c,float a){ + // Grain value {-1 to 1}. + vec2 g=vec2(Noise3(uv)*2.0); + // Step size for black in non-linear space. + float rcpStep=1.0/(256.0-1.0); + // Estimate amount negative which still quantizes to zero. + vec2 black=vec2(0.5*Linear(rcpStep)); + // Estimate amount above 1.0 which still quantizes to 1.0. + vec2 white=vec2(2.0-Linear(1.0-rcpStep)); + // Add grain. + return vec2(clamp(c+g*min(c+black,min(white-c,a)),0.0,1.0));} + +// +// Pattern +// + +// 4xMSAA pattern for quad given integer coordinates. +// +// . x . . | < pixel +// . . . x | +// x . . . +// . . x . +// +// 01 +// 23 +// +vec2 Quad4(vec2 pp){ + int q=(int(pp.x)&1)+((int(pp.y)&1)<<1); + if(q==0)return pp+vec2( 0.25,-0.25); + if(q==1)return pp+vec2( 0.25, 0.25); + if(q==2)return pp+vec2(-0.25,-0.25); + return pp+vec2(-0.25, 0.25);} + +// Rotate {0.0,r} by a {-1.0 to 1.0}. +vec2 Rot(float r,float a){return vec2(r*cos(a*3.14159),r*sin(a*3.14159));} + +// +// POOR QUALITY JITTERED +// + +// Jittered position. +vec2 Jit(vec2 pp){ + // Start with better baseline pattern. + pp=Quad4(pp); + // Very poor quality (clumping) move in disc around pixel. + float n=Noise(pp,fract(iTime)); + float m=Noise(pp,fract(iTime*0.333))*0.5+0.5; + m = sqrt(m) / 4.0; + return pp+Rot(0.707*0.5*m,n);} + +// +// POOR QUALITY JITTERED 4x +// + +// Gaussian filtered jittered tap. +void JitGaus4(inout vec2 sumC,inout vec2 sumW,vec2 pp,vec2 mm){ + vec2 jj=Jit(pp); + vec2 c=jj; + vec2 vv=mm-jj; + float w=exp2(-1.0*dot(vv,vv)); + sumC+=c*vec2(w); sumW+=vec2(w);} + +// Many tap gaussian from poor quality jittered 4/sample per pixel +// +// . x x x . +// x x x x x +// x x x x x +// x x x x x +// . x x x . +// +vec2 ResolveJitGaus4(vec2 pp){ + vec2 ppp=(pp); + vec2 sumC=vec2(0.0); + vec2 sumW=vec2(0.0); + JitGaus4(sumC,sumW,ppp+vec2(-1.0,-2.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 0.0,-2.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 1.0,-2.0),pp); + JitGaus4(sumC,sumW,ppp+vec2(-2.0,-1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2(-1.0,-1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 0.0,-1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 1.0,-1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 2.0,-1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2(-2.0, 0.0),pp); + JitGaus4(sumC,sumW,ppp+vec2(-1.0, 0.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 0.0, 0.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 1.0, 0.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 2.0, 0.0),pp); + JitGaus4(sumC,sumW,ppp+vec2(-2.0, 1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2(-1.0, 1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 0.0, 1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 1.0, 1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 2.0, 1.0),pp); + JitGaus4(sumC,sumW,ppp+vec2(-1.0, 2.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 0.0, 2.0),pp); + JitGaus4(sumC,sumW,ppp+vec2( 1.0, 2.0),pp); + return sumC/sumW;} + +vec2 moire_resolve(vec2 coord){ + vec2 pp = coord; + vec2 cc = vec2(0.0, 0.0); + + cc = ResolveJitGaus4(pp); + cc = Noise4(pp, cc, 1.0 / 32.0); + cc = (param.CURVATURE < 0.5) ? pp : cc + vec2(0.0105, 0.015); + + return cc; +} + +// Distortion of scanlines, and end of screen alpha. +vec2 Warp(vec2 pos) +{ + pos = pos*2.0-1.0; + pos *= vec2(1.0 + (pos.y*pos.y)*param.warpX, 1.0 + (pos.x*pos.x)*param.warpY); + + return pos*0.5 + 0.5; +} + +// Shadow mask. +vec3 Mask(vec2 pos) +{ + vec3 mask = vec3(param.maskDark, param.maskDark, param.maskDark); + + // Very compressed TV style shadow mask. + if (param.shadowMask == 1.0) + { + float line = param.maskLight; + float odd = 0.0; + + if (fract(pos.x*0.166666666) < 0.5) odd = 1.0; + if (fract((pos.y + odd) * 0.5) < 0.5) line = param.maskDark; + + pos.x = fract(pos.x*0.333333333); + + if (pos.x < 0.333) mask.r = param.maskLight; + else if (pos.x < 0.666) mask.g = param.maskLight; + else mask.b = param.maskLight; + mask*=line; + } + + // Aperture-grille. + else if (param.shadowMask == 2.0) + { + pos.x = fract(pos.x*0.333333333); + + if (pos.x < 0.333) mask.r = param.maskLight; + else if (pos.x < 0.666) mask.g = param.maskLight; + else mask.b = param.maskLight; + } + + // Stretched VGA style shadow mask (same as prior shaders). + else if (param.shadowMask == 3.0) + { + pos.x += pos.y*3.0; + pos.x = fract(pos.x*0.166666666); + + if (pos.x < 0.333) mask.r = param.maskLight; + else if (pos.x < 0.666) mask.g = param.maskLight; + else mask.b = param.maskLight; + } + + // VGA style shadow mask. + else if (param.shadowMask == 4.0) + { + pos.xy = floor(pos.xy*vec2(1.0, 0.5)); + pos.x += pos.y*3.0; + pos.x = fract(pos.x*0.166666666); + + if (pos.x < 0.333) mask.r = param.maskLight; + else if (pos.x < 0.666) mask.g = param.maskLight; + else mask.b = param.maskLight; + } + + return mask; +} + void main() { + vec2 pp = moire_resolve(vTexCoord.xy); + pp = (param.CURVATURE > 0.5) ? Warp(pp) : pp; + #if BLOOM_ONLY - vec3 source = BLOOM_STRENGTH * texture(Source, vTexCoord).rgb; + vec3 source = BLOOM_STRENGTH * texture(Source, pp).rgb; #else - - vec3 source = 1.15 * texture(CRT_PASS, vTexCoord).rgb; - vec3 bloom = texture(Source, vTexCoord).rgb; + + vec3 source = 1.15 * texture(CRT_PASS, pp).rgb; + vec3 bloom = texture(Source, pp).rgb; source += param.BLOOM_STRENGTH * bloom; #endif FragColor = vec4(pow(clamp(source, 0.0, 1.0), vec3(1.0 / param.OUTPUT_GAMMA)), 1.0); + /* TODO/FIXME - hacky clamp fix */ + if ( pp.x > 0.0106 && pp.x < 0.9999 && pp.y > 0.016 && pp.y < 0.9999) + FragColor.rgb = FragColor.rgb; + else +FragColor.rgb = vec3(0.0); +if (param.shadowMask > 0.0) + FragColor.rgb = pow(pow(FragColor.rgb, vec3(2.2)) * Mask(vTexCoord.xy * global.OutputSize.xy * 1.000001), vec3(1.0 / 2.2)); }