Add subpixels rasterization and improve existing ones.

app/qml/ApplicationSettings.qml

@@ -89,6 +89,7 @@ QtObject{
     readonly property int no_rasterization: 0
     readonly property int scanline_rasterization: 1
     readonly property int pixel_rasterization: 2
+    readonly property int subpixel_rasterization: 3
 
     property int rasterization: no_rasterization
 
@@ -113,6 +114,8 @@ QtObject{
             State { when: rasterization == scanline_rasterization
                 PropertyChanges {target: fontManager; source: "FontScanlines.qml" } },
             State { when: rasterization == pixel_rasterization;
+                PropertyChanges {target: fontManager; source: "FontPixels.qml" } },
+            State { when: rasterization == subpixel_rasterization;
                 PropertyChanges {target: fontManager; source: "FontPixels.qml" } }
         ]
 

app/qml/SettingsScreenTab.qml

@@ -33,7 +33,7 @@ Tab{
                 id: rasterizationBox
                 property string selectedElement: model[currentIndex]
                 anchors.fill: parent
-                model: [qsTr("Default"), qsTr("Scanlines"), qsTr("Pixels")]
+                model: [qsTr("Default"), qsTr("Scanlines"), qsTr("Pixels"), qsTr("Subpixels")]
                 currentIndex: appSettings.rasterization
                 onCurrentIndexChanged: {
                     appSettings.rasterization = currentIndex

app/qml/ShaderTerminal.qml

@@ -27,6 +27,7 @@ ShaderEffect {
     property ShaderEffectSource source
     property ShaderEffectSource blurredSource
     property ShaderEffectSource bloomSource
+    property ShaderEffectSource rasterizationSource
 
     property color fontColor: appSettings.fontColor
     property color backgroundColor: appSettings.backgroundColor
@@ -58,12 +59,6 @@ ShaderEffect {
 
     property real screen_brightness: appSettings.brightness * 1.5 + 0.5
 
-    // This is the average value of the abs(sin) function. Needed to avoid aliasing.
-    readonly property real absSinAvg: 0.63661828335466886
-    property size rasterizationSmooth: Qt.size(
-                                           Utils.clamp(2.0 * virtual_resolution.width / (width * devicePixelRatio), 0.0, 1.0),
-                                           Utils.clamp(2.0 * virtual_resolution.height / (height * devicePixelRatio), 0.0, 1.0))
-
     property real dispX
     property real dispY
     property size virtual_resolution
@@ -165,10 +160,12 @@ ShaderEffect {
         uniform lowp float screen_brightness;
 
         uniform highp vec2 virtual_resolution;
-        uniform highp vec2 rasterizationSmooth;
         uniform highp float dispX;
         uniform highp float dispY;" +
 
+        (appSettings.rasterization != appSettings.no_rasterization ?
+            "uniform lowp sampler2D rasterizationSource;" : "") +
+
         (bloom !== 0 ? "
             uniform highp sampler2D bloomSource;
             uniform lowp float bloom;" : "") +
@@ -207,20 +204,7 @@ ShaderEffect {
                 return fract(smoothstep(-120.0, 0.0, coords.y - (virtual_resolution.y + 120.0) * fract(time * 0.00015)));
             }" : "") +
 
-        "highp float getScanlineIntensity(vec2 coords) {
+        "float min2(vec2 v) {
-            highp float result = 1.0;" +
-
-           (appSettings.rasterization != appSettings.no_rasterization ?
-               "float val = abs(sin(coords.y * virtual_resolution.y * "+Math.PI+"));
-                result *= mix(val, " + absSinAvg + ", rasterizationSmooth.y);" : "") +
-           (appSettings.rasterization == appSettings.pixel_rasterization ?
-               "val = abs(sin(coords.x * virtual_resolution.x * "+Math.PI+"));
-                result *= mix(val, " + absSinAvg + ", rasterizationSmooth.x);" : "") + "
-
-           return result;
-        }
-
-        float min2(vec2 v) {
             return min(v.x, v.y);
         }
 
@@ -310,7 +294,9 @@ ShaderEffect {
             :
                 "vec3 finalColor = mix(backgroundColor.rgb, fontColor.rgb, greyscale_color);") +
 
-            "finalColor *= getScanlineIntensity(coords);" +
+            (appSettings.rasterization != appSettings.no_rasterization ? "
+                finalColor *= texture2D(rasterizationSource, staticCoords * (virtual_resolution)).rgb;
+            " : "") +
 
             (bloom !== 0 ?
                 "vec4 bloomFullColor = texture2D(bloomSource, coords);

app/qml/TerminalContainer.qml

@@ -69,64 +69,70 @@ ShaderTerminal{
 
     bloomSource: bloomSourceLoader.item
 
-    // This shader might be useful in the future. Since we used it only for a couple
+    Loader {
-    // of calculations is probably best to move those in the main shader. If in the future
+        id: rasterizationEffectLoader
-    // we need to store another fullScreen channel this might be handy.
+        active: appSettings.rasterization != appSettings.no_rasterization
+        asynchronous: true
+        sourceComponent: ShaderEffect {
+            id: rasterizationEffect
+            width: 16
+            height: 16
 
-//    ShaderEffect {
+            blending: false
-//        id: rasterizationEffect
-//        width: parent.width
-//        height: parent.height
-//        property real outColor: 0.0
-//        property real dispX: (5 / width) * appSettings.windowScaling
-//        property real dispY: (5 / height) * appSettings.windowScaling
-//        property size virtual_resolution: terminal.virtualResolution
 
-//        blending: false
+            fragmentShader:
+                "uniform lowp float qt_Opacity;" +
 
-//        fragmentShader:
+                "varying highp vec2 qt_TexCoord0;
-//            "uniform lowp float qt_Opacity;" +
 
-//            "varying highp vec2 qt_TexCoord0;
+                 highp float getScanlineIntensity(vec2 coords) {
-//             uniform highp vec2 virtual_resolution;
+                     highp float result = 1.0;" +
-//             uniform highp float dispX;
-//             uniform highp float dispY;
-//             uniform mediump float outColor;
 
-//             highp float getScanlineIntensity(vec2 coords) {
+                    (appSettings.rasterization == appSettings.scanline_rasterization ?
-//                 highp float result = 1.0;" +
+                        "result *= (smoothstep(0.0, 0.5, coords.y) - smoothstep(0.5, 1.0, coords.y));" : "") +
 
-//                (appSettings.rasterization != appSettings.no_rasterization ?
+                    (appSettings.rasterization == appSettings.pixel_rasterization ?
-//                    "result *= abs(sin(coords.y * virtual_resolution.y * "+Math.PI+"));" : "") +
+                       "result *= (smoothstep(0.0, 0.25, coords.y) - smoothstep(0.75, 1.0, coords.y));
-//                (appSettings.rasterization == appSettings.pixel_rasterization ?
+                        result *= (smoothstep(0.0, 0.25, coords.x) - smoothstep(0.75, 1.0, coords.x));" : "") +
-//                    "result *= abs(sin(coords.x * virtual_resolution.x * "+Math.PI+"));" : "") + "
 
-//                return result;
+                    (appSettings.rasterization == appSettings.subpixel_rasterization ?
-//             }" +
+                       "result *= (smoothstep(0.0, 0.25, coords.y) - smoothstep(0.75, 1.0, coords.y));" : "") + "
 
-//            "void main() {" +
+                    return result;
-//                "highp float color = getScanlineIntensity(qt_TexCoord0);" +
+                 }" +
 
-//                "float distance = length(vec2(0.5) - qt_TexCoord0);" +
+                "void main() {" +
-//                "color = mix(color, 0.0, 1.2 * distance * distance);" +
 
-//                "color *= outColor + smoothstep(0.00, dispX, qt_TexCoord0.x) * (1.0 - outColor);" +
+                    (appSettings.rasterization == appSettings.subpixel_rasterization ?
-//                "color *= outColor + smoothstep(0.00, dispY, qt_TexCoord0.y) * (1.0 - outColor);" +
+                        "highp vec3 color = vec3(0.0);
-//                "color *= outColor + (1.0 - smoothstep(1.00 - dispX, 1.00, qt_TexCoord0.x)) * (1.0 - outColor);" +
+                        color += vec3(1.0, 0.25, 0.25) * (step(0.0, qt_TexCoord0.x) - step(1.0/3.0, qt_TexCoord0.x));
-//                "color *= outColor + (1.0 - smoothstep(1.00 - dispY, 1.00, qt_TexCoord0.y)) * (1.0 - outColor);" +
+                        color += vec3(0.25, 1.0, 0.25) * (step(1.0/3.0, qt_TexCoord0.x) - step(2.0/3.0, qt_TexCoord0.x));
+                        color += vec3(0.25, 0.25, 1.0) * (step(2.0/3.0, qt_TexCoord0.x) - step(3.0/3.0, qt_TexCoord0.x));"
+                    :
+                        "highp vec3 color = vec3(1.0);" ) +
 
-//                "gl_FragColor.a = color;" +
+                    "color *= getScanlineIntensity(qt_TexCoord0);
-//            "}"
+                     gl_FragColor = vec4(color, 1.0);" +
+                "}"
 
-//        onStatusChanged: if (log) console.log(log) //Print warning messages
+            onStatusChanged: if (log) console.log(log) //Print warning messages
-//    }
+        }
+    }
 
-//    rasterizationSource: ShaderEffectSource{
+    Loader {
-//        id: rasterizationEffectSource
+        id: rasterizationSourceLoader
-//        sourceItem: rasterizationEffect
+        active: appSettings.rasterization != appSettings.no_rasterization
-//        hideSource: true
+        asynchronous: true
-//        smooth: true
+
-//        wrapMode: ShaderEffectSource.ClampToEdge
+        sourceComponent: ShaderEffectSource {
-//        visible: false
+            sourceItem: rasterizationEffectLoader.item
-//    }
+            hideSource: true
+            smooth: true
+            wrapMode: ShaderEffectSource.Repeat
+            visible: false
+            mipmap: true
+        }
+    }
+
+    rasterizationSource: rasterizationSourceLoader.item
 }