Migrate all shaders to compiled qsb files.

app/shaders/burn_in.frag

@@ -0,0 +1,63 @@
+#version 440
+
+layout(location = 0) in vec2 qt_TexCoord0;
+layout(location = 0) out vec4 fragColor;
+
+layout(std140, binding = 0) uniform ubuf {
+    mat4 qt_Matrix;
+    float qt_Opacity;
+    float time;
+    vec4 fontColor;
+    vec4 backgroundColor;
+    float shadowLength;
+    vec2 virtualResolution;
+    float rasterizationIntensity;
+    int rasterizationMode;
+    float burnInLastUpdate;
+    float burnInTime;
+    float burnIn;
+    float staticNoise;
+    float screenCurvature;
+    float glowingLine;
+    float chromaColor;
+    vec2 jitterDisplacement;
+    float ambientLight;
+    float jitter;
+    float horizontalSync;
+    float horizontalSyncStrength;
+    float flickering;
+    float displayTerminalFrame;
+    vec2 scaleNoiseSize;
+    float screen_brightness;
+    float bloom;
+    float rbgShift;
+    float screenShadowCoeff;
+    float frameShadowCoeff;
+    vec4 frameColor;
+    vec2 margin;
+    float prevLastUpdate;
+};
+
+layout(binding = 1) uniform sampler2D txt_source;
+layout(binding = 2) uniform sampler2D burnInSource;
+
+float rgb2grey(vec3 v) {
+    return dot(v, vec3(0.21, 0.72, 0.04));
+}
+
+void main() {
+    vec2 coords = qt_TexCoord0;
+
+    vec3 txtColor = texture(txt_source, coords).rgb;
+    vec4 accColor = texture(burnInSource, coords);
+
+    float prevMask = accColor.a;
+    float currMask = rgb2grey(txtColor);
+
+    float blurDecay = clamp((burnInLastUpdate - prevLastUpdate) * burnInTime, 0.0, 1.0);
+    blurDecay = max(0.0, blurDecay - prevMask);
+    vec3 blurColor = accColor.rgb - vec3(blurDecay);
+    vec3 color = max(blurColor, txtColor);
+
+    fragColor = vec4(color, currMask) * qt_Opacity;
+}

app/shaders/passthrough.vert

@@ -0,0 +1,46 @@
+#version 440
+
+layout(location = 0) in vec4 qt_Vertex;
+layout(location = 1) in vec2 qt_MultiTexCoord0;
+
+layout(std140, binding = 0) uniform ubuf {
+    mat4 qt_Matrix;
+    float qt_Opacity;
+    float time;
+    vec4 fontColor;
+    vec4 backgroundColor;
+    float shadowLength;
+    vec2 virtualResolution;
+    float rasterizationIntensity;
+    int rasterizationMode;
+    float burnInLastUpdate;
+    float burnInTime;
+    float burnIn;
+    float staticNoise;
+    float screenCurvature;
+    float glowingLine;
+    float chromaColor;
+    vec2 jitterDisplacement;
+    float ambientLight;
+    float jitter;
+    float horizontalSync;
+    float horizontalSyncStrength;
+    float flickering;
+    float displayTerminalFrame;
+    vec2 scaleNoiseSize;
+    float screen_brightness;
+    float bloom;
+    float rbgShift;
+    float screenShadowCoeff;
+    float frameShadowCoeff;
+    vec4 frameColor;
+    vec2 margin;
+    float prevLastUpdate;
+};
+
+layout(location = 0) out vec2 qt_TexCoord0;
+
+void main() {
+    qt_TexCoord0 = qt_MultiTexCoord0;
+    gl_Position = qt_Matrix * qt_Vertex;
+}

app/shaders/terminal_dynamic.frag

@@ -0,0 +1,163 @@
+#version 440
+
+layout(location = 0) in vec2 qt_TexCoord0;
+layout(location = 1) in float vBrightness;
+layout(location = 2) in float vDistortionScale;
+layout(location = 3) in float vDistortionFreq;
+
+layout(location = 0) out vec4 fragColor;
+
+layout(std140, binding = 0) uniform ubuf {
+    mat4 qt_Matrix;
+    float qt_Opacity;
+    float time;
+    vec4 fontColor;
+    vec4 backgroundColor;
+    float shadowLength;
+    vec2 virtualResolution;
+    float rasterizationIntensity;
+    int rasterizationMode;
+    float burnInLastUpdate;
+    float burnInTime;
+    float burnIn;
+    float staticNoise;
+    float screenCurvature;
+    float glowingLine;
+    float chromaColor;
+    vec2 jitterDisplacement;
+    float ambientLight;
+    float jitter;
+    float horizontalSync;
+    float horizontalSyncStrength;
+    float flickering;
+    float displayTerminalFrame;
+    vec2 scaleNoiseSize;
+    float screen_brightness;
+    float bloom;
+    float rbgShift;
+    float screenShadowCoeff;
+    float frameShadowCoeff;
+    vec4 frameColor;
+    vec2 margin;
+    float prevLastUpdate;
+};
+
+layout(binding = 0) uniform sampler2D noiseSource;
+layout(binding = 1) uniform sampler2D screenBuffer;
+layout(binding = 2) uniform sampler2D burnInSource;
+layout(binding = 3) uniform sampler2D frameSource;
+
+float min2(vec2 v) { return min(v.x, v.y); }
+float prod2(vec2 v) { return v.x * v.y; }
+float sum2(vec2 v) { return v.x + v.y; }
+float rgb2grey(vec3 v) { return dot(v, vec3(0.21, 0.72, 0.04)); }
+
+vec3 applyRasterization(vec2 screenCoords, vec3 texel, vec2 virtualRes, float intensity, int mode) {
+    if (intensity <= 0.0 || mode == 0) {
+        return texel;
+    }
+
+    const float INTENSITY = 0.30;
+    const float BRIGHTBOOST = 0.30;
+
+    if (mode == 1) { // scanline
+        vec3 pixelHigh = ((1.0 + BRIGHTBOOST) - (0.2 * texel)) * texel;
+        vec3 pixelLow  = ((1.0 - INTENSITY) + (0.1 * texel)) * texel;
+
+        vec2 coords = fract(screenCoords * virtualRes) * 2.0 - vec2(1.0);
+        float mask = 1.0 - abs(coords.y);
+
+        vec3 rasterizationColor = mix(pixelLow, pixelHigh, mask);
+        return mix(texel, rasterizationColor, intensity);
+    } else if (mode == 2) { // pixel
+        vec3 pixelHigh = ((1.0 + BRIGHTBOOST) - (0.2 * texel)) * texel;
+        vec3 pixelLow  = ((1.0 - INTENSITY) + (0.1 * texel)) * texel;
+
+        vec2 coords = fract(screenCoords * virtualRes) * 2.0 - vec2(1.0);
+        coords = coords * coords;
+        float mask = 1.0 - coords.x - coords.y;
+
+        vec3 rasterizationColor = mix(pixelLow, pixelHigh, mask);
+        return mix(texel, rasterizationColor, intensity);
+    } else if (mode == 3) { // subpixel
+        const float SUBPIXELS = 3.0;
+        vec3 offsets = vec3(3.141592654) * vec3(0.5, 0.5 - 2.0 / 3.0, 0.5 - 4.0 / 3.0);
+
+        vec2 omega = vec2(3.141592654) * vec2(2.0) * virtualRes;
+        vec2 angle = screenCoords * omega;
+        vec3 xfactors = (SUBPIXELS + sin(angle.x + offsets)) / (SUBPIXELS + 1.0);
+
+        vec3 result = texel * xfactors;
+        vec3 pixelHigh = ((1.0 + BRIGHTBOOST) - (0.2 * result)) * result;
+        vec3 pixelLow  = ((1.0 - INTENSITY) + (0.1 * result)) * result;
+
+        vec2 coords = fract(screenCoords * virtualRes) * 2.0 - vec2(1.0);
+        float mask = 1.0 - abs(coords.y);
+
+        vec3 rasterizationColor = mix(pixelLow, pixelHigh, mask);
+        return mix(texel, rasterizationColor, intensity);
+    }
+
+    return texel;
+}
+
+float randomPass(vec2 coords){
+    return fract(smoothstep(-120.0, 0.0, coords.y - (virtualResolution.y + 120.0) * fract(time * 0.00015)));
+}
+
+vec2 barrel(vec2 v, vec2 cc) {
+    float distortion = dot(cc, cc) * screenCurvature;
+    return (v - cc * (1.0 + distortion) * distortion);
+}
+
+vec3 convertWithChroma(vec3 inColor) {
+    vec3 outColor = fontColor.rgb * rgb2grey(inColor);
+    if (chromaColor != 0.0) {
+        outColor = fontColor.rgb * mix(vec3(rgb2grey(inColor)), inColor, chromaColor);
+    }
+    return outColor;
+}
+
+void main() {
+    vec2 cc = vec2(0.5) - qt_TexCoord0;
+    float distance = length(cc);
+
+    vec2 staticCoords = barrel(qt_TexCoord0, cc);
+    vec2 coords = qt_TexCoord0;
+
+    float dst = sin((coords.y + time * 0.001) * vDistortionFreq);
+    coords.x += dst * vDistortionScale;
+
+    vec4 noiseTexel = texture(noiseSource, scaleNoiseSize * coords + vec2(fract(time / 51.0), fract(time / 237.0)));
+
+    vec2 txt_coords = coords + (noiseTexel.ba - vec2(0.5)) * jitterDisplacement * jitter;
+
+    float color = 0.0001;
+    color += noiseTexel.a * staticNoise * (1.0 - distance * 1.3);
+    color += randomPass(coords * virtualResolution) * glowingLine;
+
+    vec3 txt_color = texture(screenBuffer, txt_coords).rgb;
+
+    if (burnIn > 0.0) {
+        vec4 txt_blur = texture(burnInSource, staticCoords);
+        float blurDecay = clamp((time - burnInLastUpdate) * burnInTime, 0.0, 1.0);
+        vec3 burnInColor = 0.65 * (txt_blur.rgb - vec3(blurDecay));
+        txt_color = max(txt_color, convertWithChroma(burnInColor));
+    }
+
+    txt_color += fontColor.rgb * vec3(color);
+    txt_color = applyRasterization(staticCoords, txt_color, virtualResolution, rasterizationIntensity, rasterizationMode);
+
+    vec3 finalColor = txt_color;
+    float brightness = mix(1.0, vBrightness, step(0.0, flickering));
+    finalColor *= brightness;
+
+    finalColor += vec3(ambientLight) * (1.0 - distance) * (1.0 - distance);
+
+    if (displayTerminalFrame > 0.0) {
+        vec4 frameColor = texture(frameSource, qt_TexCoord0);
+        finalColor = mix(finalColor, frameColor.rgb, frameColor.a);
+    }
+
+    fragColor = vec4(finalColor, qt_Opacity);
+}

app/shaders/terminal_dynamic.vert

@@ -0,0 +1,61 @@
+#version 440
+
+layout(location = 0) in vec4 qt_Vertex;
+layout(location = 1) in vec2 qt_MultiTexCoord0;
+
+layout(std140, binding = 0) uniform ubuf {
+    mat4 qt_Matrix;
+    float qt_Opacity;
+    float time;
+    vec4 fontColor;
+    vec4 backgroundColor;
+    float shadowLength;
+    vec2 virtualResolution;
+    float rasterizationIntensity;
+    int rasterizationMode;
+    float burnInLastUpdate;
+    float burnInTime;
+    float burnIn;
+    float staticNoise;
+    float screenCurvature;
+    float glowingLine;
+    float chromaColor;
+    vec2 jitterDisplacement;
+    float ambientLight;
+    float jitter;
+    float horizontalSync;
+    float horizontalSyncStrength;
+    float flickering;
+    float displayTerminalFrame;
+    vec2 scaleNoiseSize;
+    float screen_brightness;
+    float bloom;
+    float rbgShift;
+    float screenShadowCoeff;
+    float frameShadowCoeff;
+    vec4 frameColor;
+    vec2 margin;
+    float prevLastUpdate;
+};
+
+layout(binding = 0) uniform sampler2D noiseSource;
+
+layout(location = 0) out vec2 qt_TexCoord0;
+layout(location = 1) out float vBrightness;
+layout(location = 2) out float vDistortionScale;
+layout(location = 3) out float vDistortionFreq;
+
+void main() {
+    qt_TexCoord0 = qt_MultiTexCoord0;
+
+    vec2 coords = vec2(fract(time / 2048.0), fract(time / 1048576.0));
+    vec4 initialNoiseTexel = texture(noiseSource, coords);
+
+    vBrightness = 1.0 + (initialNoiseTexel.g - 0.5) * flickering;
+
+    float randval = horizontalSyncStrength - initialNoiseTexel.r;
+    vDistortionScale = step(0.0, randval) * randval * horizontalSyncStrength * horizontalSync;
+    vDistortionFreq = mix(4.0, 40.0, initialNoiseTexel.g) * step(0.0, horizontalSync);
+
+    gl_Position = qt_Matrix * qt_Vertex;
+}

app/shaders/terminal_frame.frag

@@ -0,0 +1,77 @@
+#version 440
+
+layout(location = 0) in vec2 qt_TexCoord0;
+layout(location = 0) out vec4 fragColor;
+
+layout(std140, binding = 0) uniform ubuf {
+    mat4 qt_Matrix;
+    float qt_Opacity;
+    float time;
+    vec4 fontColor;
+    vec4 backgroundColor;
+    float shadowLength;
+    vec2 virtualResolution;
+    float rasterizationIntensity;
+    int rasterizationMode;
+    float burnInLastUpdate;
+    float burnInTime;
+    float burnIn;
+    float staticNoise;
+    float screenCurvature;
+    float glowingLine;
+    float chromaColor;
+    vec2 jitterDisplacement;
+    float ambientLight;
+    float jitter;
+    float horizontalSync;
+    float horizontalSyncStrength;
+    float flickering;
+    float displayTerminalFrame;
+    vec2 scaleNoiseSize;
+    float screen_brightness;
+    float bloom;
+    float rbgShift;
+    float screenShadowCoeff;
+    float frameShadowCoeff;
+    vec4 frameColor;
+    vec2 margin;
+    float prevLastUpdate;
+};
+
+float min2(vec2 v) { return min(v.x, v.y); }
+float max2(vec2 v) { return max(v.x, v.y); }
+float prod2(vec2 v) { return v.x * v.y; }
+float sum2(vec2 v) { return v.x + v.y; }
+
+vec2 distortCoordinates(vec2 coords){
+    vec2 cc = (coords - vec2(0.5));
+    float dist = dot(cc, cc) * screenCurvature;
+    return (coords + cc * (1.0 + dist) * dist);
+}
+
+vec2 positiveLog(vec2 x) {
+    return clamp(log(x), vec2(0.0), vec2(100.0));
+}
+
+void main() {
+    vec2 staticCoords = qt_TexCoord0;
+    vec2 coords = distortCoordinates(staticCoords) * (vec2(1.0) + margin * 2.0) - margin;
+
+    vec2 vignetteCoords = staticCoords * (1.0 - staticCoords.yx);
+    float vignette = pow(prod2(vignetteCoords) * 15.0, 0.25);
+
+    vec3 color = frameColor.rgb * vec3(1.0 - vignette);
+    float alpha = 0.0;
+
+    float frameShadow = max2(positiveLog(-coords * frameShadowCoeff + vec2(1.0)) + positiveLog(coords * frameShadowCoeff - (vec2(frameShadowCoeff) - vec2(1.0))));
+    frameShadow = max(sqrt(frameShadow), 0.0);
+    color *= frameShadow;
+    alpha = sum2(1.0 - step(vec2(0.0), coords) + step(vec2(1.0), coords));
+    alpha = clamp(alpha, 0.0, 1.0);
+    alpha *= mix(1.0, 0.9, frameShadow);
+
+    float screenShadow = 1.0 - prod2(positiveLog(coords * screenShadowCoeff + vec2(1.0)) * positiveLog(-coords * screenShadowCoeff + vec2(screenShadowCoeff + 1.0)));
+    alpha = max(0.8 * screenShadow, alpha);
+
+    fragColor = vec4(color * alpha, alpha) * qt_Opacity;
+}

app/shaders/terminal_static.frag

@@ -0,0 +1,104 @@
+#version 440
+
+layout(location = 0) in vec2 qt_TexCoord0;
+layout(location = 0) out vec4 fragColor;
+
+layout(std140, binding = 0) uniform ubuf {
+    mat4 qt_Matrix;
+    float qt_Opacity;
+    float time;
+    vec4 fontColor;
+    vec4 backgroundColor;
+    float shadowLength;
+    vec2 virtualResolution;
+    float rasterizationIntensity;
+    int rasterizationMode;
+    float burnInLastUpdate;
+    float burnInTime;
+    float burnIn;
+    float staticNoise;
+    float screenCurvature;
+    float glowingLine;
+    float chromaColor;
+    vec2 jitterDisplacement;
+    float ambientLight;
+    float jitter;
+    float horizontalSync;
+    float horizontalSyncStrength;
+    float flickering;
+    float displayTerminalFrame;
+    vec2 scaleNoiseSize;
+    float screen_brightness;
+    float bloom;
+    float rbgShift;
+    float screenShadowCoeff;
+    float frameShadowCoeff;
+    vec4 frameColor;
+    vec2 margin;
+    float prevLastUpdate;
+};
+
+layout(binding = 1) uniform sampler2D source;
+layout(binding = 2) uniform sampler2D bloomSource;
+
+float sum2(vec2 v) { return v.x + v.y; }
+float rgb2grey(vec3 v) { return dot(v, vec3(0.21, 0.72, 0.04)); }
+
+vec3 convertWithChroma(vec3 inColor) {
+    vec3 outColor = fontColor.rgb * rgb2grey(inColor);
+    if (chromaColor != 0.0) {
+        outColor = fontColor.rgb * mix(vec3(rgb2grey(inColor)), inColor, chromaColor);
+    }
+    return outColor;
+}
+
+void main() {
+    vec2 cc = vec2(0.5) - qt_TexCoord0;
+
+    vec2 txt_coords = qt_TexCoord0;
+    if (screenCurvature != 0.0) {
+        float distortion = dot(cc, cc) * screenCurvature;
+        vec2 curvatureCoords = (qt_TexCoord0 - cc * (1.0 + distortion) * distortion);
+        txt_coords = -2.0 * curvatureCoords + 3.0 * step(vec2(0.0), curvatureCoords) * curvatureCoords - 3.0 * step(vec2(1.0), curvatureCoords) * curvatureCoords;
+    }
+
+    vec3 txt_color = texture(source, txt_coords).rgb;
+
+    if (rbgShift != 0.0) {
+        vec2 displacement = vec2(12.0, 0.0) * rbgShift;
+        vec3 rightColor = texture(source, txt_coords + displacement).rgb;
+        vec3 leftColor = texture(source, txt_coords - displacement).rgb;
+        txt_color.r = leftColor.r * 0.10 + rightColor.r * 0.30 + txt_color.r * 0.60;
+        txt_color.g = leftColor.g * 0.20 + rightColor.g * 0.20 + txt_color.g * 0.60;
+        txt_color.b = leftColor.b * 0.30 + rightColor.b * 0.10 + txt_color.b * 0.60;
+    }
+
+    txt_color += vec3(0.0001);
+    float greyscale_color = rgb2grey(txt_color);
+
+    float reflectionMask = 1.0;
+    if (screenCurvature != 0.0) {
+        float distortion = dot(cc, cc) * screenCurvature;
+        vec2 curvatureCoords = (qt_TexCoord0 - cc * (1.0 + distortion) * distortion);
+        reflectionMask = sum2(step(vec2(0.0), curvatureCoords) - step(vec2(1.0), curvatureCoords));
+        reflectionMask = clamp(reflectionMask, 0.0, 1.0);
+    }
+
+    vec3 finalColor;
+    if (chromaColor != 0.0) {
+        vec3 foregroundColor = mix(fontColor.rgb, txt_color * fontColor.rgb / greyscale_color, chromaColor);
+        finalColor = mix(backgroundColor.rgb, foregroundColor, greyscale_color * reflectionMask);
+    } else {
+        finalColor = mix(backgroundColor.rgb, fontColor.rgb, greyscale_color * reflectionMask);
+    }
+
+    if (bloom != 0.0) {
+        vec4 bloomFullColor = texture(bloomSource, txt_coords);
+        vec3 bloomColor = convertWithChroma(bloomFullColor.rgb);
+        float bloomAlpha = bloomFullColor.a;
+        finalColor += clamp(bloomColor * bloom * bloomAlpha, 0.0, 0.5);
+    }
+
+    finalColor *= screen_brightness;
+    fragColor = vec4(finalColor, qt_Opacity);
+}