From f497bb4b44c4487972822b204b257ec0109023b8 Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Sat, 1 Dec 2018 21:10:08 +0100
Subject: [PATCH 1/8] First wrong framebuffer implementation.

---
 app/qml/NewTerminalFrame.qml  |   5 -
 app/qml/ShaderTerminal.qml    | 285 ++++++++++++++++++++++++++--------
 app/qml/TerminalContainer.qml |  10 +-
 3 files changed, 223 insertions(+), 77 deletions(-)

diff --git a/app/qml/NewTerminalFrame.qml b/app/qml/NewTerminalFrame.qml
index 965dede..bbf5b80 100644
--- a/app/qml/NewTerminalFrame.qml
+++ b/app/qml/NewTerminalFrame.qml
@@ -53,7 +53,6 @@ ShaderEffect {
             float alpha = 0.0;
 
             float outShadowLength = shadowLength;
-            float inShadowLength = 0.5 * shadowLength;
 
             float outShadow = max2(1.0 - smoothstep(vec2(-outShadowLength), vec2(0.0), coords) + smoothstep(vec2(1.0), vec2(1.0 + outShadowLength), coords));
             outShadow = clamp(0.0, 1.0, outShadow);
@@ -61,10 +60,6 @@ ShaderEffect {
             alpha = sum2(1.0 - step(0.0, coords) + step(1.0, coords));
             alpha = clamp(alpha, 0.0, 1.0) * mix(1.0, 0.9, sqrt(outShadow));
 
-            float inShadow = min2(step(vec2(0.0), coords) - step(vec2(1.0), coords));
-            inShadow -= min2(smoothstep(0.0, inShadowLength, coords) - smoothstep(1.0 - inShadowLength, 1.0, coords));
-            alpha += 0.35 * inShadow;
-
             gl_FragColor = vec4(color * alpha, alpha);
         }
     "
diff --git a/app/qml/ShaderTerminal.qml b/app/qml/ShaderTerminal.qml
index 067dfbe..75ff66b 100644
--- a/app/qml/ShaderTerminal.qml
+++ b/app/qml/ShaderTerminal.qml
@@ -28,6 +28,8 @@ ShaderEffect {
     property BurnInEffect burnInEffect
     property ShaderEffectSource bloomSource
 
+    property ShaderEffectSource screenBuffer: frameBuffer
+
     property color fontColor: appSettings.fontColor
     property color backgroundColor: appSettings.backgroundColor
     property real bloom: appSettings.bloom * 2.5
@@ -60,6 +62,8 @@ ShaderEffect {
 
     property real ambientLight: appSettings.ambientLight * 0.2
 
+    property real shadowLength: 0.25 * screenCurvature * Utils.lint(0.50, 1.5, ambientLight)
+
     property size virtual_resolution
 
     property real time: timeManager.time
@@ -146,7 +150,7 @@ ShaderEffect {
             precision mediump float;
         #endif
 
-        uniform sampler2D source;
+        uniform sampler2D screenBuffer;
         uniform highp float qt_Opacity;
         uniform highp float time;
         varying highp vec2 qt_TexCoord0;
@@ -154,12 +158,10 @@ ShaderEffect {
         uniform highp vec4 fontColor;
         uniform highp vec4 backgroundColor;
         uniform lowp float screen_brightness;
+        uniform lowp float shadowLength;
 
         uniform highp vec2 virtual_resolution;" +
 
-        (bloom !== 0 ? "
-            uniform highp sampler2D bloomSource;
-            uniform lowp float bloom;" : "") +
         (burnIn !== 0 ? "
             uniform sampler2D burnInSource;
             uniform highp float burnInLastUpdate;
@@ -178,8 +180,6 @@ ShaderEffect {
             uniform lowp float chromaColor;" : "") +
         (jitter !== 0 ? "
             uniform lowp vec2 jitterDisplacement;" : "") +
-        (rbgShift !== 0 ? "
-            uniform lowp float rbgShift;" : "") +
         (ambientLight !== 0 ? "
             uniform lowp float ambientLight;" : "") +
 
@@ -202,30 +202,36 @@ 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 result = 1.0;" +
-
-           (appSettings.rasterization != appSettings.no_rasterization ?
-               "float val = 0.0;
-                vec2 rasterizationCoords = fract(coords * virtual_resolution);
-                val += smoothstep(0.0, 0.5, rasterizationCoords.y);
-                val -= smoothstep(0.5, 1.0, rasterizationCoords.y);
-                result *= mix(0.5, 1.0, val);" : "") +
-           (appSettings.rasterization == appSettings.pixel_rasterization ?
-               "val = 0.0;
-                val += smoothstep(0.0, 0.5, rasterizationCoords.x);
-                val -= smoothstep(0.5, 1.0, rasterizationCoords.x);
-                result *= mix(0.5, 1.0, val);" : "") + "
-
-           return result;
-        }
-
-        float min2(vec2 v) {
+        "float min2(vec2 v) {
             return min(v.x, v.y);
         }
 
         float rgb2grey(vec3 v){
             return dot(v, vec3(0.21, 0.72, 0.04));
+        }
+
+        float isInScreen(vec2 v) {
+            return min2(step(0.0, v) - step(1.0, v));
+        }
+
+        vec2 barrel(vec2 v, vec2 cc) {" +
+
+            (screenCurvature !== 0 ? "
+                float distortion = dot(cc, cc) * screenCurvature;
+                return (v - cc * (1.0 + distortion) * distortion);"
+            :
+                "return v;") +
+        "}" +
+
+        "vec3 convertWithChroma(vec3 inColor) {
+           vec3 outColor = inColor;" +
+
+            (chromaColor !== 0 ?
+                "outColor = fontColor.rgb * mix(vec3(rgb2grey(inColor)), inColor, chromaColor);"
+            :
+                "outColor = fontColor.rgb * rgb2grey(inColor);") +
+
+        "  return outColor;
         }" +
 
         "void main() {" +
@@ -252,19 +258,22 @@ ShaderEffect {
                 float noise = staticNoise;" : "") +
 
             (screenCurvature !== 0 ? "
-                float distortion = dot(cc, cc) * screenCurvature;
-                vec2 curvatureCoords = (qt_TexCoord0 - cc * (1.0 + distortion) * distortion);
-                vec2 staticCoords = - 2.0 * curvatureCoords + 3.0 * step(vec2(0.0), curvatureCoords) * curvatureCoords - 3.0 * step(vec2(1.0), curvatureCoords) * curvatureCoords;"
+                vec2 curvatureCoords = barrel(qt_TexCoord0, cc);
+                float staticInScreen = min2(step(0.0, curvatureCoords) - step(1.0, curvatureCoords));
+                vec2 staticCoords = curvatureCoords;"
             :"
-                vec2 staticCoords = qt_TexCoord0;") +
+                vec2 staticCoords = qt_TexCoord0;
+                float staticInScreen = 1.0;") +
 
-            "vec2 coords = staticCoords;" +
+            "vec2 coords = qt_TexCoord0;" +
 
             (horizontalSync !== 0 ? "
                 float dst = sin((coords.y + time * 0.001) * distortionFreq);
                 coords.x += dst * distortionScale;" +
+
                 (staticNoise ? "
                     noise += distortionScale * 7.0;" : "")
+
             : "") +
 
             (jitter !== 0 || staticNoise !== 0 || rbgShift !== 0 ?
@@ -285,49 +294,21 @@ ShaderEffect {
             (glowingLine !== 0 ? "
                 color += randomPass(coords * virtual_resolution) * glowingLine;" : "") +
 
-            "vec3 txt_color = texture2D(source, txt_coords).rgb;" +
-
-            (rbgShift !== 0 ? "
-                vec2 displacement = vec2(12.0, 0.0) * rbgShift * (0.6 * constantNoise.r + 0.4);
-                vec3 rightColor = texture2D(source, txt_coords + displacement).rgb;
-                vec3 leftColor = texture2D(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_coords = mix(qt_TexCoord0, txt_coords, staticInScreen);
+             float inScreen2 = isInScreen(barrel(txt_coords, cc));
+             vec3 origTxtColor = texture2D(screenBuffer, txt_coords).rgb;
+             vec3 txt_color = origTxtColor * inScreen2 + backgroundColor.rgb * (1.0 - inScreen2);" +
 
             (burnIn !== 0 ? "
                 vec4 txt_blur = texture2D(burnInSource, staticCoords);
                 float blurDecay = clamp((time - burnInLastUpdate) * burnInTime, 0.0, 1.0);
-                txt_color = max(txt_color, 0.5 * (txt_blur.rgb - vec3(blurDecay)));"
+                vec3 burnInColor = 0.5 * (txt_blur.rgb - vec3(blurDecay));
+                txt_color = max(txt_color, convertWithChroma(burnInColor));"
             : "") +
 
-             "txt_color *= getScanlineIntensity(coords);" +
+             "txt_color += fontColor.rgb * vec3(color);" +
 
-             "txt_color += vec3(color);" +
-             "float greyscale_color = rgb2grey(txt_color);" +
-
-            (chromaColor !== 0 ?
-                "vec3 foregroundColor = mix(fontColor.rgb, txt_color * fontColor.rgb / greyscale_color, chromaColor);
-                 vec3 finalColor = mix(backgroundColor.rgb, foregroundColor, greyscale_color);"
-            :
-                "vec3 finalColor = mix(backgroundColor.rgb, fontColor.rgb, greyscale_color);") +
-
-            (bloom !== 0 ?
-                "vec4 bloomFullColor = texture2D(bloomSource, coords);
-                 vec3 bloomColor = bloomFullColor.rgb;
-                 float bloomAlpha = bloomFullColor.a;" +
-                (chromaColor !== 0 ?
-                    "bloomColor = fontColor.rgb * mix(vec3(rgb2grey(bloomColor)), bloomColor, chromaColor);"
-                :
-                    "bloomColor = fontColor.rgb * rgb2grey(bloomColor);") +
-                "finalColor += clamp(bloomColor * bloom * bloomAlpha, 0.0, 0.5);"
-            : "") +
-
-            (screenCurvature !== 0 ? "
-                vec2 curvatureMask = step(vec2(0.0), curvatureCoords) - step(vec2(1.0), curvatureCoords);
-                finalColor *= clamp(0.0, 1.0, curvatureMask.x + curvatureMask.y);"
-            :"") +
+            "vec3 finalColor = txt_color;" +
 
             (flickering !== 0 ? "
                 finalColor *= brightness;" : "") +
@@ -336,7 +317,11 @@ ShaderEffect {
                 finalColor += vec3(ambientLight) * (1.0 - distance) * (1.0 - distance);" : "") +
 
 
-            "gl_FragColor = vec4(finalColor * screen_brightness, qt_Opacity);" +
+            "float inShadow = 1.0 - min2(smoothstep(0.0, shadowLength, staticCoords) - smoothstep(1.0 - shadowLength, 1.0, staticCoords));
+             finalColor = mix(finalColor, vec3(0.0), 0.35 * inShadow);
+
+             finalColor = mix(origTxtColor, finalColor, staticInScreen);
+             gl_FragColor = vec4(finalColor * screen_brightness, qt_Opacity);" +
         "}"
 
      onStatusChanged: {
@@ -349,4 +334,170 @@ ShaderEffect {
             fallBack = true;
          }
      }
+
+     ShaderEffect {
+         id: frame
+
+         anchors.fill: parent
+
+         property ShaderEffectSource source: parent.source
+         property ShaderEffectSource bloomSource: parent.bloomSource
+
+         property color fontColor: parent.fontColor
+         property color backgroundColor: parent.backgroundColor
+         property real bloom: parent.bloom
+
+         property real screenCurvature: appSettings.screenCurvature * appSettings.screenCurvatureSize
+
+         property real chromaColor: appSettings.chromaColor;
+
+         property real rbgShift: (appSettings.rbgShift / width) * appSettings.totalFontScaling
+
+         property int rasterization: appSettings.rasterization
+
+         property real screen_brightness: Utils.lint(0.5, 1.5, appSettings.brightness)
+
+         property real ambientLight: appSettings.ambientLight * 0.2
+
+         property size virtual_resolution: parent.virtual_resolution
+
+         blending: false
+
+         //Print the number with a reasonable precision for the shader.
+         function str(num){
+             return num.toFixed(8);
+         }
+
+         fragmentShader: "
+             #ifdef GL_ES
+                 precision mediump float;
+             #endif
+
+             uniform sampler2D source;
+             uniform highp float qt_Opacity;
+             varying highp vec2 qt_TexCoord0;
+
+             uniform highp vec4 fontColor;
+             uniform highp vec4 backgroundColor;
+             uniform lowp float screen_brightness;
+
+             uniform highp vec2 virtual_resolution;" +
+
+             (bloom !== 0 ? "
+                 uniform highp sampler2D bloomSource;
+                 uniform lowp float bloom;" : "") +
+
+             (screenCurvature !== 0 ? "
+                 uniform highp float screenCurvature;" : "") +
+
+             (chromaColor !== 0 ? "
+                 uniform lowp float chromaColor;" : "") +
+
+             (rbgShift !== 0 ? "
+                 uniform lowp float rbgShift;" : "") +
+
+             (ambientLight !== 0 ? "
+                 uniform lowp float ambientLight;" : "") +
+
+             "highp float getScanlineIntensity(vec2 coords) {
+                 float result = 1.0;" +
+
+                (appSettings.rasterization != appSettings.no_rasterization ?
+                    "float val = 0.0;
+                     vec2 rasterizationCoords = fract(coords * virtual_resolution);
+                     val += smoothstep(0.0, 0.5, rasterizationCoords.y);
+                     val -= smoothstep(0.5, 1.0, rasterizationCoords.y);
+                     result *= mix(0.5, 1.0, val);" : "") +
+
+                (appSettings.rasterization == appSettings.pixel_rasterization ?
+                    "val = 0.0;
+                     val += smoothstep(0.0, 0.5, rasterizationCoords.x);
+                     val -= smoothstep(0.5, 1.0, rasterizationCoords.x);
+                     result *= mix(0.5, 1.0, val);" : "") + "
+
+                return result;
+             }
+
+             float min2(vec2 v) {
+                 return min(v.x, v.y);
+             }
+
+             float rgb2grey(vec3 v){
+                 return dot(v, vec3(0.21, 0.72, 0.04));
+             }" +
+
+             "vec3 convertWithChroma(vec3 inColor) {
+                vec3 outColor = inColor;" +
+
+                 (chromaColor !== 0 ?
+                     "outColor = fontColor.rgb * mix(vec3(rgb2grey(inColor)), inColor, chromaColor);"
+                 :
+                     "outColor = fontColor.rgb * rgb2grey(inColor);") +
+
+             "  return outColor;
+             }" +
+
+
+             "void main() {" +
+                 "vec2 cc = vec2(0.5) - qt_TexCoord0;" +
+
+                 (screenCurvature !== 0 ? "
+                     float distortion = dot(cc, cc) * screenCurvature;
+                     vec2 curvatureCoords = (qt_TexCoord0 - cc * (1.0 + distortion) * distortion);
+                     vec2 txt_coords = - 2.0 * curvatureCoords + 3.0 * step(vec2(0.0), curvatureCoords) * curvatureCoords - 3.0 * step(vec2(1.0), curvatureCoords) * curvatureCoords;"
+                 :"
+                     vec2 txt_coords = qt_TexCoord0;") +
+
+                 "vec3 txt_color = texture2D(source, txt_coords).rgb;" +
+
+                 (rbgShift !== 0 ? "
+                     vec2 displacement = vec2(12.0, 0.0) * rbgShift;
+                     vec3 rightColor = texture2D(source, txt_coords + displacement).rgb;
+                     vec3 leftColor = texture2D(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 *= getScanlineIntensity(txt_coords);" +
+
+                  "txt_color += vec3(0.0001);" +
+                  "float greyscale_color = rgb2grey(txt_color);" +
+
+                 (chromaColor !== 0 ?
+                     "vec3 foregroundColor = mix(fontColor.rgb, txt_color * fontColor.rgb / greyscale_color, chromaColor);
+                      vec3 finalColor = mix(backgroundColor.rgb, foregroundColor, greyscale_color);"
+                 :
+                     "vec3 finalColor = mix(backgroundColor.rgb, fontColor.rgb, greyscale_color);") +
+
+                     (bloom !== 0 ?
+                         "vec4 bloomFullColor = texture2D(bloomSource, txt_coords);
+                          vec3 bloomColor = bloomFullColor.rgb;
+                          float bloomAlpha = bloomFullColor.a;
+                          bloomColor = convertWithChroma(bloomColor);
+                          finalColor += clamp(bloomColor * bloom * bloomAlpha, 0.0, 0.5);"
+                     : "") +
+
+                 (screenCurvature !== 0 ? "
+                     vec2 curvatureMask = step(vec2(0.0), curvatureCoords) - step(vec2(1.0), curvatureCoords);
+                     finalColor *= clamp(0.0, 1.0, curvatureMask.x + curvatureMask.y);"
+                 :"") +
+
+                 "gl_FragColor = vec4(finalColor * screen_brightness, qt_Opacity);" +
+             "}"
+
+         NewTerminalFrame {
+             anchors.fill: parent
+             blending: true
+         }
+     }
+
+     ShaderEffectSource {
+         id: frameBuffer
+
+         anchors.fill: parent
+         visible: false
+         sourceItem: frame
+         hideSource: true
+     }
 }
diff --git a/app/qml/TerminalContainer.qml b/app/qml/TerminalContainer.qml
index 430edf4..1be51fb 100644
--- a/app/qml/TerminalContainer.qml
+++ b/app/qml/TerminalContainer.qml
@@ -56,11 +56,11 @@ ShaderTerminal {
 
     bloomSource: bloomSourceLoader.item
 
-    NewTerminalFrame {
-        id: terminalFrame
-        anchors.fill: parent
-        blending: true
-    }
+//    NewTerminalFrame {
+//        id: terminalFrame
+//        anchors.fill: parent
+//        blending: true
+//    }
 
     // This shader might be useful in the future. Since we used it only for a couple
     // of calculations is probably best to move those in the main shader. If in the future

From da6795f0027d56ea3da7684974e7b9677ae7c2c8 Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Mon, 3 Dec 2018 12:42:11 +0100
Subject: [PATCH 2/8] Use window scaling parameter for framebuffer size.

---
 app/qml/ApplicationSettings.qml | 2 +-
 app/qml/ShaderTerminal.qml      | 5 ++---
 app/qml/TerminalContainer.qml   | 2 +-
 app/qml/main.qml                | 9 ++-------
 4 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/app/qml/ApplicationSettings.qml b/app/qml/ApplicationSettings.qml
index f9c9f4d..69fea91 100644
--- a/app/qml/ApplicationSettings.qml
+++ b/app/qml/ApplicationSettings.qml
@@ -155,7 +155,7 @@ QtObject{
         if (index === undefined) return;
 
         fontManager.item.selectedFontIndex = index;
-        fontManager.item.scaling = totalFontScaling * windowScaling;
+        fontManager.item.scaling = totalFontScaling;
 
         var fontSource = fontManager.item.source;
         var pixelSize = fontManager.item.pixelSize;
diff --git a/app/qml/ShaderTerminal.qml b/app/qml/ShaderTerminal.qml
index 75ff66b..5ae04b3 100644
--- a/app/qml/ShaderTerminal.qml
+++ b/app/qml/ShaderTerminal.qml
@@ -338,7 +338,8 @@ ShaderEffect {
      ShaderEffect {
          id: frame
 
-         anchors.fill: parent
+         width: parent.width * appSettings.windowScaling
+         height: parent.height * appSettings.windowScaling
 
          property ShaderEffectSource source: parent.source
          property ShaderEffectSource bloomSource: parent.bloomSource
@@ -494,8 +495,6 @@ ShaderEffect {
 
      ShaderEffectSource {
          id: frameBuffer
-
-         anchors.fill: parent
          visible: false
          sourceItem: frame
          hideSource: true
diff --git a/app/qml/TerminalContainer.qml b/app/qml/TerminalContainer.qml
index 1be51fb..00696d2 100644
--- a/app/qml/TerminalContainer.qml
+++ b/app/qml/TerminalContainer.qml
@@ -36,7 +36,7 @@ ShaderTerminal {
         height: parent.height * appSettings.bloomQuality
 
         sourceComponent: FastBlur{
-            radius: Utils.lint(16, 64, appSettings.bloomQuality * appSettings.windowScaling);
+            radius: Utils.lint(16, 64, appSettings.bloomQuality);
             source: terminal.mainSource
             transparentBorder: true
         }
diff --git a/app/qml/main.qml b/app/qml/main.qml
index 5165c25..99d8522 100644
--- a/app/qml/main.qml
+++ b/app/qml/main.qml
@@ -137,13 +137,8 @@ ApplicationWindow{
     TerminalContainer{
         id: terminalContainer
         y: appSettings.showMenubar ? 0 : -2 // Workaroud to hide the margin in the menubar.
-        width: parent.width * appSettings.windowScaling
-        height: (parent.height + Math.abs(y)) * appSettings.windowScaling
-
-        transform: Scale {
-            xScale: 1 / appSettings.windowScaling
-            yScale: 1 / appSettings.windowScaling
-        }
+        width: parent.width
+        height: (parent.height + Math.abs(y))
     }
     SettingsWindow{
         id: settingswindow

From e9ddd7d3b82bb06d1625d9683c4595e8c9541a31 Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Mon, 3 Dec 2018 13:32:08 +0100
Subject: [PATCH 3/8] Split effects into static (cached) and dynamic computed
 at every frame.

---
 app/qml/ShaderTerminal.qml    | 586 +++++++++++++++++-----------------
 app/qml/TerminalContainer.qml |   2 -
 2 files changed, 292 insertions(+), 296 deletions(-)

diff --git a/app/qml/ShaderTerminal.qml b/app/qml/ShaderTerminal.qml
index 5ae04b3..ada73ef 100644
--- a/app/qml/ShaderTerminal.qml
+++ b/app/qml/ShaderTerminal.qml
@@ -23,320 +23,310 @@ import QtGraphicalEffects 1.0
 
 import "utils.js" as Utils
 
-ShaderEffect {
+Item {
     property ShaderEffectSource source
     property BurnInEffect burnInEffect
     property ShaderEffectSource bloomSource
 
-    property ShaderEffectSource screenBuffer: frameBuffer
-
     property color fontColor: appSettings.fontColor
     property color backgroundColor: appSettings.backgroundColor
-    property real bloom: appSettings.bloom * 2.5
-
-    property ShaderEffectSource burnInSource: burnInEffect.source
-    property real burnIn: appSettings.burnIn
-    property real burnInLastUpdate: burnInEffect.lastUpdate
-    property real burnInTime: burnInEffect.burnInFadeTime
-
-    property real jitter: appSettings.jitter
-    property size jitterDisplacement: Qt.size(0.007 * jitter, 0.002 * jitter)
-
-    property real staticNoise: appSettings.staticNoise
-    property size scaleNoiseSize: Qt.size((width) / (noiseTexture.width * appSettings.windowScaling * appSettings.totalFontScaling),
-                                          (height) / (noiseTexture.height * appSettings.windowScaling * appSettings.totalFontScaling))
 
     property real screenCurvature: appSettings.screenCurvature * appSettings.screenCurvatureSize
-    property real glowingLine: appSettings.glowingLine * 0.2
 
-    property real chromaColor: appSettings.chromaColor;
-
-    property real rbgShift: (appSettings.rbgShift / width) * appSettings.totalFontScaling
-
-    property real flickering: appSettings.flickering
-    property real horizontalSync: appSettings.horizontalSync * 0.5
-
-    property int rasterization: appSettings.rasterization
-
-    property real screen_brightness: Utils.lint(0.5, 1.5, appSettings.brightness)
+    property real chromaColor: appSettings.chromaColor
 
     property real ambientLight: appSettings.ambientLight * 0.2
 
-    property real shadowLength: 0.25 * screenCurvature * Utils.lint(0.50, 1.5, ambientLight)
-
     property size virtual_resolution
 
-    property real time: timeManager.time
-    property ShaderEffectSource noiseSource: noiseShaderSource
+     ShaderEffect {
+         id: dynamicShader
 
-    // If something goes wrong activate the fallback version of the shader.
-    property bool fallBack: false
+         property ShaderEffectSource screenBuffer: frameBuffer
+         property ShaderEffectSource burnInSource: burnInEffect.source
 
-    blending: false
+         property color fontColor: parent.fontColor
+         property color backgroundColor: parent.backgroundColor
+         property real screenCurvature: parent.screenCurvature
+         property real chromaColor: parent.chromaColor
+         property real ambientLight: parent.ambientLight
 
-    //Smooth random texture used for flickering effect.
-    Image{
-        id: noiseTexture
-        source: "images/allNoise512.png"
-        width: 512
-        height: 512
-        fillMode: Image.Tile
-        visible: false
-    }
-    ShaderEffectSource{
-        id: noiseShaderSource
-        sourceItem: noiseTexture
-        wrapMode: ShaderEffectSource.Repeat
-        visible: false
-        smooth: true
-    }
+         property real flickering: appSettings.flickering
+         property real horizontalSync: appSettings.horizontalSync * 0.5
+         property real glowingLine: appSettings.glowingLine * 0.2
+         property real burnIn: appSettings.burnIn
+         property real burnInLastUpdate: burnInEffect.lastUpdate
+         property real burnInTime: burnInEffect.burnInFadeTime
+         property real jitter: appSettings.jitter
+         property size jitterDisplacement: Qt.size(0.007 * jitter, 0.002 * jitter)
+         property real shadowLength: 0.25 * screenCurvature * Utils.lint(0.50, 1.5, ambientLight)
+         property real staticNoise: appSettings.staticNoise
+         property size scaleNoiseSize: Qt.size((width) / (noiseTexture.width * appSettings.windowScaling * appSettings.totalFontScaling),
+                                               (height) / (noiseTexture.height * appSettings.windowScaling * appSettings.totalFontScaling))
 
-    //Print the number with a reasonable precision for the shader.
-    function str(num){
-        return num.toFixed(8);
-    }
+         property size virtual_resolution: parent.virtual_resolution
 
-    vertexShader: "
-        uniform highp mat4 qt_Matrix;
-        uniform highp float time;
+         property real time: timeManager.time
+         property ShaderEffectSource noiseSource: noiseShaderSource
 
-        attribute highp vec4 qt_Vertex;
-        attribute highp vec2 qt_MultiTexCoord0;
+         // If something goes wrong activate the fallback version of the shader.
+         property bool fallBack: false
 
-        varying highp vec2 qt_TexCoord0;" +
+         anchors.fill: parent
+         blending: false
 
-        (!fallBack ? "
-            uniform sampler2D noiseSource;" : "") +
-
-        (!fallBack && rbgShift !== 0.0 ?"
-            varying lowp vec4 constantNoise;" : "") +
-
-        (!fallBack && flickering !== 0.0 ?"
-            varying lowp float brightness;
-            uniform lowp float flickering;" : "") +
-
-        (!fallBack && horizontalSync !== 0.0 ?"
-            uniform lowp float horizontalSync;
-            varying lowp float distortionScale;
-            varying lowp float distortionFreq;" : "") +
-
-        "
-        void main() {
-            qt_TexCoord0 = qt_MultiTexCoord0;
-            vec2 coords = vec2(fract(time/(1024.0*2.0)), fract(time/(1024.0*1024.0)));" +
-
-            (!fallBack && (flickering !== 0.0 || horizontalSync !== 0.0 || rbgShift !== 0) ?
-                "vec4 initialNoiseTexel = texture2D(noiseSource, coords);"
-            : "") +
-
-            (!fallBack && rbgShift !== 0.0 ?"
-                constantNoise = initialNoiseTexel;" : "") +
-
-            (!fallBack && flickering !== 0.0 ? "
-                brightness = 1.0 + (initialNoiseTexel.g - 0.5) * flickering;"
-            : "") +
-
-            (!fallBack && horizontalSync !== 0.0 ? "
-                float randval = horizontalSync - initialNoiseTexel.r;
-                distortionScale = step(0.0, randval) * randval * horizontalSync;
-                distortionFreq = mix(4.0, 40.0, initialNoiseTexel.g);"
-            : "") +
-
-            "gl_Position = qt_Matrix * qt_Vertex;
-        }"
-
-    fragmentShader: "
-        #ifdef GL_ES
-            precision mediump float;
-        #endif
-
-        uniform sampler2D screenBuffer;
-        uniform highp float qt_Opacity;
-        uniform highp float time;
-        varying highp vec2 qt_TexCoord0;
-
-        uniform highp vec4 fontColor;
-        uniform highp vec4 backgroundColor;
-        uniform lowp float screen_brightness;
-        uniform lowp float shadowLength;
-
-        uniform highp vec2 virtual_resolution;" +
-
-        (burnIn !== 0 ? "
-            uniform sampler2D burnInSource;
-            uniform highp float burnInLastUpdate;
-            uniform highp float burnInTime;" : "") +
-        (staticNoise !== 0 ? "
-            uniform highp float staticNoise;" : "") +
-        (((staticNoise !== 0 || jitter !== 0 || rbgShift)
-          ||(fallBack && (flickering || horizontalSync))) ? "
-            uniform lowp sampler2D noiseSource;
-            uniform highp vec2 scaleNoiseSize;" : "") +
-        (screenCurvature !== 0 ? "
-            uniform highp float screenCurvature;" : "") +
-        (glowingLine !== 0 ? "
-            uniform highp float glowingLine;" : "") +
-        (chromaColor !== 0 ? "
-            uniform lowp float chromaColor;" : "") +
-        (jitter !== 0 ? "
-            uniform lowp vec2 jitterDisplacement;" : "") +
-        (ambientLight !== 0 ? "
-            uniform lowp float ambientLight;" : "") +
-
-        (fallBack && horizontalSync !== 0 ? "
-            uniform lowp float horizontalSync;" : "") +
-        (fallBack && flickering !== 0.0 ?"
-            uniform lowp float flickering;" : "") +
-        (!fallBack && flickering !== 0 ? "
-            varying lowp float brightness;"
-        : "") +
-        (!fallBack && horizontalSync !== 0 ? "
-            varying lowp float distortionScale;
-            varying lowp float distortionFreq;" : "") +
-
-        (!fallBack && rbgShift !== 0.0 ?"
-            varying lowp vec4 constantNoise;" : "") +
-
-        (glowingLine !== 0 ? "
-            float randomPass(vec2 coords){
-                return fract(smoothstep(-120.0, 0.0, coords.y - (virtual_resolution.y + 120.0) * fract(time * 0.00015)));
-            }" : "") +
-
-        "float min2(vec2 v) {
-            return min(v.x, v.y);
-        }
-
-        float rgb2grey(vec3 v){
-            return dot(v, vec3(0.21, 0.72, 0.04));
-        }
-
-        float isInScreen(vec2 v) {
-            return min2(step(0.0, v) - step(1.0, v));
-        }
-
-        vec2 barrel(vec2 v, vec2 cc) {" +
-
-            (screenCurvature !== 0 ? "
-                float distortion = dot(cc, cc) * screenCurvature;
-                return (v - cc * (1.0 + distortion) * distortion);"
-            :
-                "return v;") +
-        "}" +
-
-        "vec3 convertWithChroma(vec3 inColor) {
-           vec3 outColor = inColor;" +
-
-            (chromaColor !== 0 ?
-                "outColor = fontColor.rgb * mix(vec3(rgb2grey(inColor)), inColor, chromaColor);"
-            :
-                "outColor = fontColor.rgb * rgb2grey(inColor);") +
-
-        "  return outColor;
-        }" +
-
-        "void main() {" +
-            "vec2 cc = vec2(0.5) - qt_TexCoord0;" +
-            "float distance = length(cc);" +
-
-            //FallBack if there are problems
-            (fallBack && (flickering !== 0.0 || horizontalSync !== 0.0 || rbgShift !== 0.0) ?
-                "vec2 initialCoords = vec2(fract(time/(1024.0*2.0)), fract(time/(1024.0*1024.0)));
-                 vec4 initialNoiseTexel = texture2D(noiseSource, initialCoords);"
-            : "") +
-            (fallBack && flickering !== 0.0 ? "
-                float brightness = 1.0 + (initialNoiseTexel.g - 0.5) * flickering;"
-            : "") +
-            (fallBack && horizontalSync !== 0.0 ? "
-                float randval = horizontalSync - initialNoiseTexel.r;
-                float distortionScale = step(0.0, randval) * randval * horizontalSync;
-                float distortionFreq = mix(4.0, 40.0, initialNoiseTexel.g);"
-            : "") +
-            (fallBack && rbgShift !== 0.0 ?"
-                lowp vec4 constantNoise = initialNoiseTexel;" : "") +
-
-            (staticNoise ? "
-                float noise = staticNoise;" : "") +
-
-            (screenCurvature !== 0 ? "
-                vec2 curvatureCoords = barrel(qt_TexCoord0, cc);
-                float staticInScreen = min2(step(0.0, curvatureCoords) - step(1.0, curvatureCoords));
-                vec2 staticCoords = curvatureCoords;"
-            :"
-                vec2 staticCoords = qt_TexCoord0;
-                float staticInScreen = 1.0;") +
-
-            "vec2 coords = qt_TexCoord0;" +
-
-            (horizontalSync !== 0 ? "
-                float dst = sin((coords.y + time * 0.001) * distortionFreq);
-                coords.x += dst * distortionScale;" +
-
-                (staticNoise ? "
-                    noise += distortionScale * 7.0;" : "")
-
-            : "") +
-
-            (jitter !== 0 || staticNoise !== 0 || rbgShift !== 0 ?
-                "vec4 noiseTexel = texture2D(noiseSource, scaleNoiseSize * coords + vec2(fract(time / 51.0), fract(time / 237.0)));"
-            : "") +
-
-            (jitter !== 0 ? "
-                vec2 offset = vec2(noiseTexel.b, noiseTexel.a) - vec2(0.5);
-                vec2 txt_coords = coords + offset * jitterDisplacement;"
-            :  "vec2 txt_coords = coords;") +
-
-            "float color = 0.0001;" +
-
-            (staticNoise !== 0 ? "
-                float noiseVal = noiseTexel.a;
-                color += noiseVal * noise * (1.0 - distance * 1.3);" : "") +
-
-            (glowingLine !== 0 ? "
-                color += randomPass(coords * virtual_resolution) * glowingLine;" : "") +
-
-            "txt_coords = mix(qt_TexCoord0, txt_coords, staticInScreen);
-             float inScreen2 = isInScreen(barrel(txt_coords, cc));
-             vec3 origTxtColor = texture2D(screenBuffer, txt_coords).rgb;
-             vec3 txt_color = origTxtColor * inScreen2 + backgroundColor.rgb * (1.0 - inScreen2);" +
-
-            (burnIn !== 0 ? "
-                vec4 txt_blur = texture2D(burnInSource, staticCoords);
-                float blurDecay = clamp((time - burnInLastUpdate) * burnInTime, 0.0, 1.0);
-                vec3 burnInColor = 0.5 * (txt_blur.rgb - vec3(blurDecay));
-                txt_color = max(txt_color, convertWithChroma(burnInColor));"
-            : "") +
-
-             "txt_color += fontColor.rgb * vec3(color);" +
-
-            "vec3 finalColor = txt_color;" +
-
-            (flickering !== 0 ? "
-                finalColor *= brightness;" : "") +
-
-            (ambientLight !== 0 ? "
-                finalColor += vec3(ambientLight) * (1.0 - distance) * (1.0 - distance);" : "") +
-
-
-            "float inShadow = 1.0 - min2(smoothstep(0.0, shadowLength, staticCoords) - smoothstep(1.0 - shadowLength, 1.0, staticCoords));
-             finalColor = mix(finalColor, vec3(0.0), 0.35 * inShadow);
-
-             finalColor = mix(origTxtColor, finalColor, staticInScreen);
-             gl_FragColor = vec4(finalColor * screen_brightness, qt_Opacity);" +
-        "}"
-
-     onStatusChanged: {
-         // Print warning messages
-         if (log)
-             console.log(log);
-
-         // Activate fallback mode
-         if (status == ShaderEffect.Error) {
-            fallBack = true;
+         //Smooth random texture used for flickering effect.
+         Image{
+             id: noiseTexture
+             source: "images/allNoise512.png"
+             width: 512
+             height: 512
+             fillMode: Image.Tile
+             visible: false
          }
+         ShaderEffectSource{
+             id: noiseShaderSource
+             sourceItem: noiseTexture
+             wrapMode: ShaderEffectSource.Repeat
+             visible: false
+             smooth: true
+         }
+
+         //Print the number with a reasonable precision for the shader.
+         function str(num){
+             return num.toFixed(8);
+         }
+
+         vertexShader: "
+             uniform highp mat4 qt_Matrix;
+             uniform highp float time;
+
+             attribute highp vec4 qt_Vertex;
+             attribute highp vec2 qt_MultiTexCoord0;
+
+             varying highp vec2 qt_TexCoord0;" +
+
+             (!fallBack ? "
+                 uniform sampler2D noiseSource;" : "") +
+
+             (!fallBack && flickering !== 0.0 ?"
+                 varying lowp float brightness;
+                 uniform lowp float flickering;" : "") +
+
+             (!fallBack && horizontalSync !== 0.0 ?"
+                 uniform lowp float horizontalSync;
+                 varying lowp float distortionScale;
+                 varying lowp float distortionFreq;" : "") +
+
+             "
+             void main() {
+                 qt_TexCoord0 = qt_MultiTexCoord0;
+                 vec2 coords = vec2(fract(time/(1024.0*2.0)), fract(time/(1024.0*1024.0)));" +
+
+                 (!fallBack && (flickering !== 0.0 || horizontalSync !== 0.0 || rbgShift !== 0) ?
+                     "vec4 initialNoiseTexel = texture2D(noiseSource, coords);"
+                 : "") +
+
+                 (!fallBack && flickering !== 0.0 ? "
+                     brightness = 1.0 + (initialNoiseTexel.g - 0.5) * flickering;"
+                 : "") +
+
+                 (!fallBack && horizontalSync !== 0.0 ? "
+                     float randval = horizontalSync - initialNoiseTexel.r;
+                     distortionScale = step(0.0, randval) * randval * horizontalSync;
+                     distortionFreq = mix(4.0, 40.0, initialNoiseTexel.g);"
+                 : "") +
+
+                 "gl_Position = qt_Matrix * qt_Vertex;
+             }"
+
+         fragmentShader: "
+             #ifdef GL_ES
+                 precision mediump float;
+             #endif
+
+             uniform sampler2D screenBuffer;
+             uniform highp float qt_Opacity;
+             uniform highp float time;
+             varying highp vec2 qt_TexCoord0;
+
+             uniform highp vec4 fontColor;
+             uniform highp vec4 backgroundColor;
+             uniform lowp float shadowLength;
+
+             uniform highp vec2 virtual_resolution;" +
+
+             (burnIn !== 0 ? "
+                 uniform sampler2D burnInSource;
+                 uniform highp float burnInLastUpdate;
+                 uniform highp float burnInTime;" : "") +
+             (staticNoise !== 0 ? "
+                 uniform highp float staticNoise;" : "") +
+             (((staticNoise !== 0 || jitter !== 0 || rbgShift)
+               ||(fallBack && (flickering || horizontalSync))) ? "
+                 uniform lowp sampler2D noiseSource;
+                 uniform highp vec2 scaleNoiseSize;" : "") +
+             (screenCurvature !== 0 ? "
+                 uniform highp float screenCurvature;" : "") +
+             (glowingLine !== 0 ? "
+                 uniform highp float glowingLine;" : "") +
+             (chromaColor !== 0 ? "
+                 uniform lowp float chromaColor;" : "") +
+             (jitter !== 0 ? "
+                 uniform lowp vec2 jitterDisplacement;" : "") +
+             (ambientLight !== 0 ? "
+                 uniform lowp float ambientLight;" : "") +
+
+             (fallBack && horizontalSync !== 0 ? "
+                 uniform lowp float horizontalSync;" : "") +
+             (fallBack && flickering !== 0.0 ?"
+                 uniform lowp float flickering;" : "") +
+             (!fallBack && flickering !== 0 ? "
+                 varying lowp float brightness;"
+             : "") +
+             (!fallBack && horizontalSync !== 0 ? "
+                 varying lowp float distortionScale;
+                 varying lowp float distortionFreq;" : "") +
+
+             (glowingLine !== 0 ? "
+                 float randomPass(vec2 coords){
+                     return fract(smoothstep(-120.0, 0.0, coords.y - (virtual_resolution.y + 120.0) * fract(time * 0.00015)));
+                 }" : "") +
+
+             "float min2(vec2 v) {
+                 return min(v.x, v.y);
+             }
+
+             float rgb2grey(vec3 v){
+                 return dot(v, vec3(0.21, 0.72, 0.04));
+             }
+
+             float isInScreen(vec2 v) {
+                 return min2(step(0.0, v) - step(1.0, v));
+             }
+
+             vec2 barrel(vec2 v, vec2 cc) {" +
+
+                 (screenCurvature !== 0 ? "
+                     float distortion = dot(cc, cc) * screenCurvature;
+                     return (v - cc * (1.0 + distortion) * distortion);"
+                 :
+                     "return v;") +
+             "}" +
+
+             "vec3 convertWithChroma(vec3 inColor) {
+                vec3 outColor = inColor;" +
+
+                 (chromaColor !== 0 ?
+                     "outColor = fontColor.rgb * mix(vec3(rgb2grey(inColor)), inColor, chromaColor);"
+                 :
+                     "outColor = fontColor.rgb * rgb2grey(inColor);") +
+
+             "  return outColor;
+             }" +
+
+             "void main() {" +
+                 "vec2 cc = vec2(0.5) - qt_TexCoord0;" +
+                 "float distance = length(cc);" +
+
+                 //FallBack if there are problems
+                 (fallBack && (flickering !== 0.0 || horizontalSync !== 0.0 || rbgShift !== 0.0) ?
+                     "vec2 initialCoords = vec2(fract(time/(1024.0*2.0)), fract(time/(1024.0*1024.0)));
+                      vec4 initialNoiseTexel = texture2D(noiseSource, initialCoords);"
+                 : "") +
+                 (fallBack && flickering !== 0.0 ? "
+                     float brightness = 1.0 + (initialNoiseTexel.g - 0.5) * flickering;"
+                 : "") +
+                 (fallBack && horizontalSync !== 0.0 ? "
+                     float randval = horizontalSync - initialNoiseTexel.r;
+                     float distortionScale = step(0.0, randval) * randval * horizontalSync;
+                     float distortionFreq = mix(4.0, 40.0, initialNoiseTexel.g);"
+                 : "") +
+
+                 (staticNoise ? "
+                     float noise = staticNoise;" : "") +
+
+                 (screenCurvature !== 0 ? "
+                     vec2 curvatureCoords = barrel(qt_TexCoord0, cc);
+                     float staticInScreen = min2(step(0.0, curvatureCoords) - step(1.0, curvatureCoords));
+                     vec2 staticCoords = curvatureCoords;"
+                 :"
+                     vec2 staticCoords = qt_TexCoord0;
+                     float staticInScreen = 1.0;") +
+
+                 "vec2 coords = qt_TexCoord0;" +
+
+                 (horizontalSync !== 0 ? "
+                     float dst = sin((coords.y + time * 0.001) * distortionFreq);
+                     coords.x += dst * distortionScale;" +
+
+                     (staticNoise ? "
+                         noise += distortionScale * 7.0;" : "")
+
+                 : "") +
+
+                 (jitter !== 0 || staticNoise !== 0 || rbgShift !== 0 ?
+                     "vec4 noiseTexel = texture2D(noiseSource, scaleNoiseSize * coords + vec2(fract(time / 51.0), fract(time / 237.0)));"
+                 : "") +
+
+                 (jitter !== 0 ? "
+                     vec2 offset = vec2(noiseTexel.b, noiseTexel.a) - vec2(0.5);
+                     vec2 txt_coords = coords + offset * jitterDisplacement;"
+                 :  "vec2 txt_coords = coords;") +
+
+                 "float color = 0.0001;" +
+
+                 (staticNoise !== 0 ? "
+                     float noiseVal = noiseTexel.a;
+                     color += noiseVal * noise * (1.0 - distance * 1.3);" : "") +
+
+                 (glowingLine !== 0 ? "
+                     color += randomPass(coords * virtual_resolution) * glowingLine;" : "") +
+
+                 "txt_coords = mix(qt_TexCoord0, txt_coords, staticInScreen);
+                  float inScreen2 = isInScreen(barrel(txt_coords, cc));
+                  vec3 origTxtColor = texture2D(screenBuffer, txt_coords).rgb;
+                  vec3 txt_color = mix(backgroundColor.rgb, origTxtColor, inScreen2);" +
+
+                 (burnIn !== 0 ? "
+                     vec4 txt_blur = texture2D(burnInSource, staticCoords);
+                     float blurDecay = clamp((time - burnInLastUpdate) * burnInTime, 0.0, 1.0);
+                     vec3 burnInColor = 0.5 * (txt_blur.rgb - vec3(blurDecay));
+                     txt_color = max(txt_color, convertWithChroma(burnInColor));"
+                 : "") +
+
+                  "txt_color += fontColor.rgb * vec3(color);" +
+
+                 "vec3 finalColor = txt_color;" +
+
+                 (flickering !== 0 ? "
+                     finalColor *= brightness;" : "") +
+
+                 (ambientLight !== 0 ? "
+                     finalColor += vec3(ambientLight) * (1.0 - distance) * (1.0 - distance);" : "") +
+
+
+                 "float inShadow = 1.0 - min2(smoothstep(0.0, shadowLength, staticCoords) - smoothstep(1.0 - shadowLength, 1.0, staticCoords));
+                  finalColor = mix(finalColor, vec3(0.0), 0.45 * inShadow * inShadow);
+
+                  finalColor = mix(origTxtColor, finalColor, staticInScreen);
+                  gl_FragColor = vec4(finalColor, qt_Opacity);" +
+             "}"
+
+          onStatusChanged: {
+              // Print warning messages
+              if (log)
+                  console.log(log);
+
+              // Activate fallback mode
+              if (status == ShaderEffect.Error) {
+                 fallBack = true;
+              }
+          }
      }
 
      ShaderEffect {
-         id: frame
+         id: staticShader
 
          width: parent.width * appSettings.windowScaling
          height: parent.height * appSettings.windowScaling
@@ -346,23 +336,24 @@ ShaderEffect {
 
          property color fontColor: parent.fontColor
          property color backgroundColor: parent.backgroundColor
-         property real bloom: parent.bloom
+         property real bloom: appSettings.bloom * 2.5
 
-         property real screenCurvature: appSettings.screenCurvature * appSettings.screenCurvatureSize
+         property real screenCurvature: parent.screenCurvature
 
          property real chromaColor: appSettings.chromaColor;
 
-         property real rbgShift: (appSettings.rbgShift / width) * appSettings.totalFontScaling
+         property real rbgShift: (appSettings.rbgShift / width) * appSettings.totalFontScaling // TODO FILIPPO width here is wrong.
 
          property int rasterization: appSettings.rasterization
 
          property real screen_brightness: Utils.lint(0.5, 1.5, appSettings.brightness)
 
-         property real ambientLight: appSettings.ambientLight * 0.2
+         property real ambientLight: parent.ambientLight
 
          property size virtual_resolution: parent.virtual_resolution
 
          blending: false
+         visible: false
 
          //Print the number with a reasonable precision for the shader.
          function str(num){
@@ -479,24 +470,31 @@ ShaderEffect {
                           finalColor += clamp(bloomColor * bloom * bloomAlpha, 0.0, 0.5);"
                      : "") +
 
+                 "finalColor *= screen_brightness;" +
+
                  (screenCurvature !== 0 ? "
                      vec2 curvatureMask = step(vec2(0.0), curvatureCoords) - step(vec2(1.0), curvatureCoords);
                      finalColor *= clamp(0.0, 1.0, curvatureMask.x + curvatureMask.y);"
                  :"") +
 
-                 "gl_FragColor = vec4(finalColor * screen_brightness, qt_Opacity);" +
+                 "gl_FragColor = vec4(finalColor, qt_Opacity);" +
              "}"
 
          NewTerminalFrame {
              anchors.fill: parent
              blending: true
          }
+
+         onStatusChanged: {
+             // Print warning messages
+             if (log) console.log(log);
+         }
      }
 
      ShaderEffectSource {
          id: frameBuffer
          visible: false
-         sourceItem: frame
+         sourceItem: staticShader
          hideSource: true
      }
 }
diff --git a/app/qml/TerminalContainer.qml b/app/qml/TerminalContainer.qml
index 00696d2..ea390ab 100644
--- a/app/qml/TerminalContainer.qml
+++ b/app/qml/TerminalContainer.qml
@@ -10,8 +10,6 @@ ShaderTerminal {
     id: mainShader
     opacity: appSettings.windowOpacity * 0.3 + 0.7
 
-    blending: false
-
     source: terminal.mainSource
     burnInEffect: terminal.burnInEffect
     virtual_resolution: terminal.virtualResolution

From fd2e5ce71ef5d6f33f5854eb90e2c5fe5ab089b0 Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Mon, 3 Dec 2018 16:06:48 +0100
Subject: [PATCH 4/8] Reduce default fps to 20. It looks good with new burnin
 and saves some gpu.

---
 app/qml/ApplicationSettings.qml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/qml/ApplicationSettings.qml b/app/qml/ApplicationSettings.qml
index 69fea91..1a0e1da 100644
--- a/app/qml/ApplicationSettings.qml
+++ b/app/qml/ApplicationSettings.qml
@@ -48,7 +48,7 @@ QtObject{
     property bool showTerminalSize: true
     property real windowScaling: 1.0
 
-    property real fps: 24
+    property real fps: 20
     property bool verbose: false
 
     property real bloomQuality: 0.5

From 41413d4712b787fb6da282b47e0ed305bec974a4 Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Mon, 3 Dec 2018 16:39:20 +0100
Subject: [PATCH 5/8] Rearrange settings window.

---
 app/qml/SettingsEffectsTab.qml  | 138 +++++++++++++++++++-------------
 app/qml/SettingsScreenTab.qml   |  67 ----------------
 app/qml/SettingsTerminalTab.qml |  17 +++-
 app/qml/SettingsWindow.qml      |   8 +-
 app/qml/resources.qrc           |   1 -
 5 files changed, 100 insertions(+), 131 deletions(-)
 delete mode 100644 app/qml/SettingsScreenTab.qml

diff --git a/app/qml/SettingsEffectsTab.qml b/app/qml/SettingsEffectsTab.qml
index 643e27f..5ca521b 100644
--- a/app/qml/SettingsEffectsTab.qml
+++ b/app/qml/SettingsEffectsTab.qml
@@ -23,62 +23,92 @@ import QtQuick.Controls 1.1
 import QtQuick.Layouts 1.1
 
 Tab{
-    GroupBox{
-        title: qsTr("Effects")
+    ColumnLayout{
         anchors.fill: parent
-        ColumnLayout{
-            anchors.fill: parent
-            spacing: 2
-            CheckableSlider{
-                name: qsTr("Bloom")
-                onNewValue: appSettings.bloom = newValue
-                value: appSettings.bloom
+        spacing: 2
+
+        GroupBox{
+            title: qsTr("Effects")
+            Layout.fillWidth: true
+
+            ColumnLayout {
+                anchors.fill: parent
+
+                CheckableSlider{
+                    name: qsTr("Bloom")
+                    onNewValue: appSettings.bloom = newValue
+                    value: appSettings.bloom
+                }
+                CheckableSlider{
+                    name: qsTr("BurnIn")
+                    onNewValue: appSettings.burnIn = newValue
+                    value: appSettings.burnIn
+                }
+                CheckableSlider{
+                    name: qsTr("Static Noise")
+                    onNewValue: appSettings.staticNoise = newValue
+                    value: appSettings.staticNoise
+                }
+                CheckableSlider{
+                    name: qsTr("Jitter")
+                    onNewValue: appSettings.jitter = newValue
+                    value: appSettings.jitter
+                }
+                CheckableSlider{
+                    name: qsTr("Glow Line")
+                    onNewValue: appSettings.glowingLine = newValue;
+                    value: appSettings.glowingLine
+                }
+                CheckableSlider{
+                    name: qsTr("Screen Curvature")
+                    onNewValue: appSettings.screenCurvature = newValue;
+                    value: appSettings.screenCurvature;
+                }
+                CheckableSlider{
+                    name: qsTr("Ambient Light")
+                    onNewValue: appSettings.ambientLight = newValue;
+                    value: appSettings.ambientLight
+                    enabled: appSettings.framesIndex !== 0
+                }
+                CheckableSlider{
+                    name: qsTr("Flickering")
+                    onNewValue: appSettings.flickering = newValue;
+                    value: appSettings.flickering;
+                }
+                CheckableSlider{
+                    name: qsTr("Horizontal Sync")
+                    onNewValue: appSettings.horizontalSync = newValue;
+                    value: appSettings.horizontalSync;
+                }
+                CheckableSlider{
+                    name: qsTr("RGB Shift")
+                    onNewValue: appSettings.rbgShift = newValue;
+                    value: appSettings.rbgShift;
+                }
             }
-            CheckableSlider{
-                name: qsTr("BurnIn")
-                onNewValue: appSettings.burnIn = newValue
-                value: appSettings.burnIn
-            }
-            CheckableSlider{
-                name: qsTr("Static Noise")
-                onNewValue: appSettings.staticNoise = newValue
-                value: appSettings.staticNoise
-            }
-            CheckableSlider{
-                name: qsTr("Jitter")
-                onNewValue: appSettings.jitter = newValue
-                value: appSettings.jitter
-            }
-            CheckableSlider{
-                name: qsTr("Glow Line")
-                onNewValue: appSettings.glowingLine = newValue;
-                value: appSettings.glowingLine
-            }
-            CheckableSlider{
-                name: qsTr("Screen Curvature")
-                onNewValue: appSettings.screenCurvature = newValue;
-                value: appSettings.screenCurvature;
-            }
-            CheckableSlider{
-                name: qsTr("Ambient Light")
-                onNewValue: appSettings.ambientLight = newValue;
-                value: appSettings.ambientLight
-                enabled: appSettings.framesIndex !== 0
-            }
-            CheckableSlider{
-                name: qsTr("Flickering")
-                onNewValue: appSettings.flickering = newValue;
-                value: appSettings.flickering;
-            }
-            CheckableSlider{
-                name: qsTr("Horizontal Sync")
-                onNewValue: appSettings.horizontalSync = newValue;
-                value: appSettings.horizontalSync;
-            }
-            CheckableSlider{
-                name: qsTr("RGB Shift")
-                onNewValue: appSettings.rbgShift = newValue;
-                value: appSettings.rbgShift;
+        }
+
+        GroupBox{
+            title: qsTr("Lights")
+            Layout.fillWidth: true
+            GridLayout{
+                anchors.fill: parent
+                columns: 2
+                Label{ text: qsTr("Brightness") }
+                SimpleSlider{
+                    onValueChanged: appSettings.brightness = value
+                    value: appSettings.brightness
+                }
+                Label{ text: qsTr("Contrast") }
+                SimpleSlider{
+                    onValueChanged: appSettings.contrast = value
+                    value: appSettings.contrast
+                }
+                Label{ text: qsTr("Opacity") }
+                SimpleSlider{
+                    onValueChanged: appSettings.windowOpacity = value
+                    value: appSettings.windowOpacity
+                }
             }
         }
     }
diff --git a/app/qml/SettingsScreenTab.qml b/app/qml/SettingsScreenTab.qml
deleted file mode 100644
index 683f09e..0000000
--- a/app/qml/SettingsScreenTab.qml
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2013 "Filippo Scognamiglio"
-* https://github.com/Swordfish90/cool-retro-term
-*
-* This file is part of cool-retro-term.
-*
-* cool-retro-term is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*******************************************************************************/
-
-import QtQuick 2.2
-import QtQuick.Controls 1.1
-import QtQuick.Layouts 1.1
-import QtQuick.Dialogs 1.1
-
-Tab{
-    ColumnLayout{
-        anchors.fill: parent
-        GroupBox{
-            title: qsTr("Rasterization Mode")
-            Layout.fillWidth: true
-            ComboBox {
-                id: rasterizationBox
-                property string selectedElement: model[currentIndex]
-                anchors.fill: parent
-                model: [qsTr("Default"), qsTr("Scanlines"), qsTr("Pixels")]
-                currentIndex: appSettings.rasterization
-                onCurrentIndexChanged: {
-                    appSettings.rasterization = currentIndex
-                }
-            }
-        }
-        GroupBox{
-            title: qsTr("Lights")
-            Layout.fillWidth: true
-            GridLayout{
-                anchors.fill: parent
-                columns: 2
-                Label{ text: qsTr("Brightness") }
-                SimpleSlider{
-                    onValueChanged: appSettings.brightness = value
-                    value: appSettings.brightness
-                }
-                Label{ text: qsTr("Contrast") }
-                SimpleSlider{
-                    onValueChanged: appSettings.contrast = value
-                    value: appSettings.contrast
-                }
-                Label{ text: qsTr("Opacity") }
-                SimpleSlider{
-                    onValueChanged: appSettings.windowOpacity = value
-                    value: appSettings.windowOpacity
-                }
-            }
-        }
-    }
-}
diff --git a/app/qml/SettingsTerminalTab.qml b/app/qml/SettingsTerminalTab.qml
index 141f066..8cefdb8 100644
--- a/app/qml/SettingsTerminalTab.qml
+++ b/app/qml/SettingsTerminalTab.qml
@@ -27,13 +27,26 @@ import "Components"
 Tab{
     ColumnLayout{
         anchors.fill: parent
+
         GroupBox{
-            property var rasterization: [qsTr("Default"), qsTr("Scanlines"), qsTr("Pixels")][appSettings.rasterization]
-            title: qsTr("Font " + "(" + rasterization + ")")
+            title: qsTr("Font")
             Layout.fillWidth: true
             GridLayout{
                 anchors.fill: parent
                 columns: 2
+                Label { text: qsTr("Rasterization") }
+                ComboBox {
+                    id: rasterizationBox
+
+                    property string selectedElement: model[currentIndex]
+
+                    Layout.fillWidth: true
+                    model: [qsTr("Default"), qsTr("Scanlines"), qsTr("Pixels")]
+                    currentIndex: appSettings.rasterization
+                    onCurrentIndexChanged: {
+                        appSettings.rasterization = currentIndex
+                    }
+                }
                 Label{ text: qsTr("Name") }
                 ComboBox{
                     id: fontChanger
diff --git a/app/qml/SettingsWindow.qml b/app/qml/SettingsWindow.qml
index 247c2e5..7995ec3 100644
--- a/app/qml/SettingsWindow.qml
+++ b/app/qml/SettingsWindow.qml
@@ -28,7 +28,7 @@ Window {
     id: settings_window
     title: qsTr("Settings")
     width: 580
-    height: 400
+    height: 500
 
     property int tabmargins: 15
 
@@ -42,12 +42,6 @@ Window {
             anchors.fill: parent
             anchors.margins: tabmargins
         }
-        SettingsScreenTab{
-            id: screenTab
-            title: qsTr("Screen")
-            anchors.fill: parent
-            anchors.margins: tabmargins
-        }
         SettingsTerminalTab{
             id: terminalTab
             title: qsTr("Terminal")
diff --git a/app/qml/resources.qrc b/app/qml/resources.qrc
index b776365..6132447 100644
--- a/app/qml/resources.qrc
+++ b/app/qml/resources.qrc
@@ -32,7 +32,6 @@
         <file>fonts/modern-pro-font-win-tweaked/ProFontWindows.ttf</file>
         <file>fonts/modern-hermit/Hermit-medium.otf</file>
         <file>fonts/modern-inconsolata/Inconsolata.otf</file>
-        <file>SettingsScreenTab.qml</file>
         <file>fonts/modern-fixedsys-excelsior/FSEX301-L2.ttf</file>
         <file>../icons/32x32/cool-retro-term.png</file>
         <file>Components/SizedLabel.qml</file>

From 5b3297f916acfc905260ca283515615dda92bf02 Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Mon, 3 Dec 2018 16:55:44 +0100
Subject: [PATCH 6/8] Tweak some shader constants.

---
 app/qml/ShaderTerminal.qml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/app/qml/ShaderTerminal.qml b/app/qml/ShaderTerminal.qml
index ada73ef..1d93f59 100644
--- a/app/qml/ShaderTerminal.qml
+++ b/app/qml/ShaderTerminal.qml
@@ -291,7 +291,7 @@ Item {
                  (burnIn !== 0 ? "
                      vec4 txt_blur = texture2D(burnInSource, staticCoords);
                      float blurDecay = clamp((time - burnInLastUpdate) * burnInTime, 0.0, 1.0);
-                     vec3 burnInColor = 0.5 * (txt_blur.rgb - vec3(blurDecay));
+                     vec3 burnInColor = 0.65 * (txt_blur.rgb - vec3(blurDecay));
                      txt_color = max(txt_color, convertWithChroma(burnInColor));"
                  : "") +
 
@@ -307,7 +307,8 @@ Item {
 
 
                  "float inShadow = 1.0 - min2(smoothstep(0.0, shadowLength, staticCoords) - smoothstep(1.0 - shadowLength, 1.0, staticCoords));
-                  finalColor = mix(finalColor, vec3(0.0), 0.45 * inShadow * inShadow);
+                  inShadow = pow(inShadow, 100.0) + 0.35 * inShadow * inShadow;  // Inner shadow and antialiasing when screen background is bright.
+                  finalColor = mix(finalColor, vec3(0.0), inShadow);
 
                   finalColor = mix(origTxtColor, finalColor, staticInScreen);
                   gl_FragColor = vec4(finalColor, qt_Opacity);" +

From 44a63d4aaa59f8b16166b5e49c59734be4eb5fdc Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Mon, 3 Dec 2018 17:12:41 +0100
Subject: [PATCH 7/8] Change default curvature values.

---
 app/qml/ApplicationSettings.qml | 20 ++++++++++----------
 app/qml/ShaderTerminal.qml      |  8 ++++----
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/app/qml/ApplicationSettings.qml b/app/qml/ApplicationSettings.qml
index 1a0e1da..f286184 100644
--- a/app/qml/ApplicationSettings.qml
+++ b/app/qml/ApplicationSettings.qml
@@ -73,7 +73,7 @@ QtObject{
     property color backgroundColor: Utils.mix(Utils.strToColor(_backgroundColor), Utils.strToColor(saturatedColor), 0.7 + (contrast * 0.3))
 
     property real staticNoise: 0.12
-    property real screenCurvature: 0.2
+    property real screenCurvature: 0.3
     property real glowingLine: 0.2
     property real burnIn: 0.25
     property real bloom: 0.55
@@ -384,7 +384,7 @@ QtObject{
                   "rasterization": 0,
                   "rbgShift": 0,
                   "saturationColor": 0.2483,
-                  "screenCurvature": 0.1997,
+                  "screenCurvature": 0.3,
                   "staticNoise": 0.1198,
                   "windowOpacity": 1
                 }'
@@ -411,7 +411,7 @@ QtObject{
                   "rasterization": 0,
                   "rbgShift": 0,
                   "saturationColor": 0.0,
-                  "screenCurvature": 0.1997,
+                  "screenCurvature": 0.3,
                   "staticNoise": 0.1198,
                   "windowOpacity": 1
                 }'
@@ -438,7 +438,7 @@ QtObject{
                   "rasterization": 1,
                   "rbgShift": 0,
                   "saturationColor": 0.5,
-                  "screenCurvature": 0.2,
+                  "screenCurvature": 0.3,
                   "staticNoise": 0.15,
                   "windowOpacity": 1
                 }'
@@ -466,7 +466,7 @@ QtObject{
                   "rbgShift": 0,
                   "saturationColor": 0,
                   "screenCurvature": 0,
-                  "staticNoise": 0.1545,
+                  "staticNoise": 0.15,
                   "windowOpacity": 1
                 }'
             builtin: true
@@ -492,7 +492,7 @@ QtObject{
                   "rasterization": 1,
                   "rbgShift": 0,
                   "saturationColor": 0,
-                  "screenCurvature": 0.8976,
+                  "screenCurvature": 0.5,
                   "staticNoise": 0.099,
                   "windowOpacity": 1
                 }'
@@ -519,7 +519,7 @@ QtObject{
                   "rasterization": 1,
                   "rbgShift": 0.2969,
                   "saturationColor": 0,
-                  "screenCurvature": 0.3003,
+                  "screenCurvature": 0.5,
                   "staticNoise": 0.2969,
                   "windowOpacity": 1
                 }'
@@ -546,7 +546,7 @@ QtObject{
                   "rasterization": 0,
                   "rbgShift": 0.3524,
                   "saturationColor": 0,
-                  "screenCurvature": 0.401,
+                  "screenCurvature": 0.4,
                   "staticNoise": 0.0503,
                   "windowOpacity": 1
                 }'
@@ -573,7 +573,7 @@ QtObject{
                   "rasterization": 0,
                   "rbgShift": 0,
                   "saturationColor": 0,
-                  "screenCurvature": 0.1997,
+                  "screenCurvature": 0.2,
                   "staticNoise": 0,
                   "windowOpacity": 1
                 }'
@@ -600,7 +600,7 @@ QtObject{
                   "rasterization": 0,
                   "rbgShift": 0,
                   "saturationColor": 0.4983,
-                  "screenCurvature": 0.05,
+                  "screenCurvature": 0,
                   "staticNoise": 0.0955,
                   "windowOpacity": 0.7
                 }'
diff --git a/app/qml/ShaderTerminal.qml b/app/qml/ShaderTerminal.qml
index 1d93f59..ff1547a 100644
--- a/app/qml/ShaderTerminal.qml
+++ b/app/qml/ShaderTerminal.qml
@@ -123,7 +123,7 @@ Item {
                  qt_TexCoord0 = qt_MultiTexCoord0;
                  vec2 coords = vec2(fract(time/(1024.0*2.0)), fract(time/(1024.0*1024.0)));" +
 
-                 (!fallBack && (flickering !== 0.0 || horizontalSync !== 0.0 || rbgShift !== 0) ?
+                 (!fallBack && (flickering !== 0.0 || horizontalSync !== 0.0) ?
                      "vec4 initialNoiseTexel = texture2D(noiseSource, coords);"
                  : "") +
 
@@ -162,7 +162,7 @@ Item {
                  uniform highp float burnInTime;" : "") +
              (staticNoise !== 0 ? "
                  uniform highp float staticNoise;" : "") +
-             (((staticNoise !== 0 || jitter !== 0 || rbgShift)
+             (((staticNoise !== 0 || jitter !== 0)
                ||(fallBack && (flickering || horizontalSync))) ? "
                  uniform lowp sampler2D noiseSource;
                  uniform highp vec2 scaleNoiseSize;" : "") +
@@ -230,7 +230,7 @@ Item {
                  "float distance = length(cc);" +
 
                  //FallBack if there are problems
-                 (fallBack && (flickering !== 0.0 || horizontalSync !== 0.0 || rbgShift !== 0.0) ?
+                 (fallBack && (flickering !== 0.0 || horizontalSync !== 0.0) ?
                      "vec2 initialCoords = vec2(fract(time/(1024.0*2.0)), fract(time/(1024.0*1024.0)));
                       vec4 initialNoiseTexel = texture2D(noiseSource, initialCoords);"
                  : "") +
@@ -265,7 +265,7 @@ Item {
 
                  : "") +
 
-                 (jitter !== 0 || staticNoise !== 0 || rbgShift !== 0 ?
+                 (jitter !== 0 || staticNoise !== 0 ?
                      "vec4 noiseTexel = texture2D(noiseSource, scaleNoiseSize * coords + vec2(fract(time / 51.0), fract(time / 237.0)));"
                  : "") +
 

From 77dc82a38143cc0baf6e999db057e5740b5a9a07 Mon Sep 17 00:00:00 2001
From: Filippo Scognamiglio <flscogna@gmail.com>
Date: Mon, 3 Dec 2018 19:28:50 +0100
Subject: [PATCH 8/8] Unload frame when not needed.

---
 app/qml/NewTerminalFrame.qml | 2 --
 app/qml/ShaderTerminal.qml   | 8 ++++++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/app/qml/NewTerminalFrame.qml b/app/qml/NewTerminalFrame.qml
index bbf5b80..22ee386 100644
--- a/app/qml/NewTerminalFrame.qml
+++ b/app/qml/NewTerminalFrame.qml
@@ -13,8 +13,6 @@ ShaderEffect {
     property real screenCurvature: appSettings.screenCurvature * appSettings.screenCurvatureSize
     property real shadowLength: 0.5 * screenCurvature * Utils.lint(0.50, 1.5, _ambientLight)
 
-    visible: screenCurvature != 0
-
     fragmentShader: "
         #ifdef GL_ES
             precision mediump float;
diff --git a/app/qml/ShaderTerminal.qml b/app/qml/ShaderTerminal.qml
index ff1547a..3e53baa 100644
--- a/app/qml/ShaderTerminal.qml
+++ b/app/qml/ShaderTerminal.qml
@@ -481,9 +481,13 @@ Item {
                  "gl_FragColor = vec4(finalColor, qt_Opacity);" +
              "}"
 
-         NewTerminalFrame {
+         Loader {
              anchors.fill: parent
-             blending: true
+             active: screenCurvature !== 0
+
+             sourceComponent: NewTerminalFrame {
+                 blending: true
+             }
          }
 
          onStatusChanged: {