colour grading proof-of-concept on postprocessing

src/net/torvald/terrarum/App.java

@@ -236,7 +236,6 @@ public class App implements ApplicationListener {
     public static ShaderProgram shaderHicolour;
     public static ShaderProgram shaderDebugDiff;
     public static ShaderProgram shaderPassthruRGBA;
-    public static ShaderProgram shaderDitherRGBA;
     public static ShaderProgram shaderColLUT;
     public static ShaderProgram shaderReflect;
     public static ShaderProgram shaderGhastlyWhite;
@@ -444,7 +443,6 @@ public class App implements ApplicationListener {
         shaderHicolour = loadShaderFromClasspath("shaders/default.vert", "shaders/hicolour.frag");
         shaderDebugDiff = loadShaderFromClasspath("shaders/default.vert", "shaders/diff.frag");
         shaderPassthruRGBA = SpriteBatch.createDefaultShader();
-        shaderDitherRGBA = loadShaderFromClasspath("shaders/default.vert", "shaders/float_to_disp_dither.frag"); // always load the shader regardless of config because the config may cange
         shaderColLUT = loadShaderFromClasspath("shaders/default.vert", "shaders/passthrurgb.frag");
         shaderReflect = loadShaderFromClasspath("shaders/default.vert", "shaders/reflect.frag");
         shaderGhastlyWhite = loadShaderFromClasspath("shaders/default.vert", "shaders/ghastlywhite.frag");
@@ -592,6 +590,8 @@ public class App implements ApplicationListener {
 
         KeyToggler.INSTANCE.update(currentScreen instanceof TerrarumIngame);
 
+
+
         // nested FBOs are just not a thing in GL!
         FrameBufferManager.end();
 

src/net/torvald/terrarum/ColorLimiterTest.kt

@@ -38,7 +38,7 @@ object ColorLimiterTest : ApplicationAdapter() {
     override fun create() {
         ShaderProgram.pedantic = false
 
-        shader4096 = ShaderProgram(Gdx.files.internal("assets/shaders/default.vert"), Gdx.files.internal("assets/shaders/float_to_disp_dither.frag"))
+        shader4096 = ShaderProgram(Gdx.files.internal("assets/shaders/default.vert"), Gdx.files.internal("assets/shaders/postproc_dither.frag"))
         shader4096.bind()
         shader4096.setUniformf("rcount", 4f)
         shader4096.setUniformf("gcount", 4f)

src/net/torvald/terrarum/PostProcessor.kt

@@ -41,6 +41,11 @@ object PostProcessor : Disposable {
 
     private val functionRowHelper = Texture(Gdx.files.internal("assets/graphics/function_row_help.png"))
 
+
+    private val shaderPostDither = App.loadShaderFromClasspath("shaders/default.vert", "shaders/postproc_dither.frag")
+    private val shaderPostNoDither = App.loadShaderFromClasspath("shaders/default.vert", "shaders/postproc_nodither.frag")
+
+
     private val shaderQuant = mapOf(
             8 to 255f,
             10 to 1023f,
@@ -62,6 +67,8 @@ object PostProcessor : Disposable {
             lutTex.dispose()
         }
         catch (e: UninitializedPropertyAccessException) { }
+        shaderPostDither.dispose()
+        shaderPostNoDither.dispose()
     }
 
     fun draw(projMat: Matrix4, fbo: FrameBuffer) {
@@ -138,26 +145,23 @@ object PostProcessor : Disposable {
 
     private fun postShader(projMat: Matrix4, fbo: FrameBuffer) {
 
-        if (App.getConfigBoolean("fx_dither")) {
+        val shader = if (App.getConfigBoolean("fx_dither"))
-            App.getCurrentDitherTex().bind(1)
+            shaderPostDither
-            fbo.colorBufferTexture.bind(0)
+        else
+            shaderPostNoDither
 
-            App.shaderDitherRGBA.bind()
-            App.shaderDitherRGBA.setUniformMatrix("u_projTrans", projMat)
-            App.shaderDitherRGBA.setUniformi("u_texture", 0)
-            App.shaderDitherRGBA.setUniformi("rnd", rng.nextInt(8192), rng.nextInt(8192))
-            App.shaderDitherRGBA.setUniformi("u_pattern", 1)
-            App.shaderDitherRGBA.setUniformf("quant", shaderQuant[App.getConfigInt("displaycolourdepth")] ?: 255f)
-            App.fullscreenQuad.render(App.shaderDitherRGBA, GL20.GL_TRIANGLES)
-        }
-        else {
-            fbo.colorBufferTexture.bind(0)
 
-            App.shaderPassthruRGBA.bind()
+        App.getCurrentDitherTex().bind(1)
-            App.shaderPassthruRGBA.setUniformMatrix("u_projTrans", projMat)
+        fbo.colorBufferTexture.bind(0)
-            App.shaderPassthruRGBA.setUniformi("u_texture", 0)
+
-            App.fullscreenQuad.render(App.shaderPassthruRGBA, GL20.GL_TRIANGLES)
+        shader.bind()
-        }
+        shader.setUniformMatrix("u_projTrans", projMat)
+        shader.setUniformi("u_texture", 0)
+        shader.setUniformi("rnd", rng.nextInt(8192), rng.nextInt(8192))
+        shader.setUniformi("u_pattern", 1)
+        shader.setUniformf("quant", shaderQuant[App.getConfigInt("displaycolourdepth")] ?: 255f)
+        App.fullscreenQuad.render(shader, GL20.GL_TRIANGLES)
+
 
 
         Gdx.gl.glActiveTexture(GL20.GL_TEXTURE0) // so that batch that comes next will bind any tex to it

src/shaders/postproc_dither.frag

@@ -0,0 +1,75 @@
+/**
+ * Blue Noise texture created by Christoph Peters, released under CC0
+ * http://momentsingraphics.de/BlueNoise.html
+ */
+
+#version 130
+#ifdef GL_ES
+    precision mediump float;
+#endif
+
+
+vec4 gammaIn(vec4 col) {
+    return pow(col, vec4(2.2));
+}
+
+vec4 gammaOut(vec4 col) {
+    return pow(col, vec4(1.0 / 2.2));
+}
+
+varying vec4 v_color; // unused!
+varying vec2 v_texCoords;
+uniform sampler2D u_texture;
+uniform sampler2D u_pattern;
+uniform ivec2 rnd = ivec2(0,0);
+
+uniform float quant = 255.0; // 64 steps -> 63.0; 256 steps -> 255.0
+
+vec2 boolean = vec2(0.0, 1.0);
+vec4 halfvec = vec4(0.5);
+
+vec2 patternsize = vec2(1.0/512.0, 1.0/512.0);
+
+mat4 rgb_to_ycocg = mat4(
+    0.25,  1.0, -0.5, 0.0,
+    0.5,  0.0,  1.0, 0.0,
+    0.25, -1.0, -0.5, 0.0,
+    0.0,  0.0,  0.0, 1.0
+);
+
+mat4 ycocg_to_rgb = mat4(
+     1.0, 1.0,  1.0, 0.0,
+     0.5, 0.0, -0.5, 0.0,
+    -0.5, 0.5, -0.5, 0.0,
+     0.0, 0.0,  0.0, 1.0
+);
+
+
+vec4 nearestColour(vec4 inColor) {
+    return floor(vec4(quant) * inColor + halfvec) * vec4(1.0 / quant);
+}
+
+vec4 getDitherredDot(vec4 inColor) {
+    vec4 bayerThreshold = vec4(texture2D(u_pattern, (gl_FragCoord.xy + rnd) * patternsize) - 0.5);
+    return nearestColour(bayerThreshold * vec4(1.0 / quant) + inColor);
+}
+
+
+uniform vec4 vibrancy = vec4(1.0);//vec4(1.0, 1.4, 1.2, 1.0);
+
+void main(void) {
+    // convert input RGB into YCoCg
+    vec4 incolour = texture2D(u_texture, v_texCoords);
+    vec4 yog = rgb_to_ycocg * incolour; // vec4(Y, Co, Cg, A) where Y,A=[0,1]; Co,Cg=[-1,1]
+
+    // Do colour-grading magic
+    vec4 sgn = sign(yog);
+    vec4 absval = abs(yog);
+    vec4 raised = pow(absval, boolean.yyyy / vibrancy);
+    vec4 newColour = sgn * raised;
+
+    // Dither the output
+    vec4 graded = ycocg_to_rgb * newColour;
+    vec4 selvec = getDitherredDot(graded);
+    gl_FragColor = selvec * boolean.yyyx + boolean.xxxy; // use quantised RGB but not the A
+}

src/shaders/postproc_nodither.frag

@@ -5,7 +5,7 @@
 
 #version 130
 #ifdef GL_ES
-    precision mediump float;
+precision mediump float;
 #endif
 
 
@@ -17,7 +17,7 @@ vec4 gammaOut(vec4 col) {
     return pow(col, vec4(1.0 / 2.2));
 }
 
-varying vec4 v_color;
+varying vec4 v_color; // unused!
 varying vec2 v_texCoords;
 uniform sampler2D u_texture;
 uniform sampler2D u_pattern;
@@ -30,6 +30,21 @@ vec4 halfvec = vec4(0.5);
 
 vec2 patternsize = vec2(1.0/512.0, 1.0/512.0);
 
+mat4 rgb_to_ycocg = mat4(
+0.25,  1.0, -0.5, 0.0,
+0.5,  0.0,  1.0, 0.0,
+0.25, -1.0, -0.5, 0.0,
+0.0,  0.0,  0.0, 1.0
+);
+
+mat4 ycocg_to_rgb = mat4(
+1.0, 1.0,  1.0, 0.0,
+0.5, 0.0, -0.5, 0.0,
+-0.5, 0.5, -0.5, 0.0,
+0.0, 0.0,  0.0, 1.0
+);
+
+
 vec4 nearestColour(vec4 inColor) {
     return floor(vec4(quant) * inColor + halfvec) * vec4(1.0 / quant);
 }
@@ -40,11 +55,20 @@ vec4 getDitherredDot(vec4 inColor) {
 }
 
 
-void main(void) {
+uniform vec4 vibrancy = vec4(1.0);//vec4(1.0, 1.4, 1.2, 1.0);
-    // create texture coordinates based on pixelSize //
-    vec4 inColor = v_color * texture2D(u_texture, v_texCoords);
-    vec4 selvec = getDitherredDot(inColor);
 
-//    gl_FragColor = inColor * boolean.yyyx + boolean.xxxy;
+void main(void) {
-    gl_FragColor = selvec * boolean.yyyx + inColor * boolean.xxxy; // use quantised RGB but not the A
+    // convert input RGB into YCoCg
+    vec4 incolour = texture2D(u_texture, v_texCoords);
+    vec4 yog = rgb_to_ycocg * incolour; // vec4(Y, Co, Cg, A) where Y,A=[0,1]; Co,Cg=[-1,1]
+
+    // Do colour-grading magic
+    vec4 sgn = sign(yog);
+    vec4 absval = abs(yog);
+    vec4 raised = pow(absval, boolean.yyyy / vibrancy);
+    vec4 newColour = sgn * raised;
+
+    // Dither the output
+    vec4 graded = ycocg_to_rgb * newColour;
+    gl_FragColor = graded * boolean.yyyx + boolean.xxxy; // use quantised RGB but not the A
 }

src/shaders/ycocg_grading.frag

@@ -8,17 +8,17 @@ varying vec2 v_texCoords;
 uniform sampler2D u_texture;
 
 mat4 rgb_to_ycocg = mat4(
-     0.25, 0.5,  0.25, 1.0,
+    0.25,  1.0, -0.5, 0.0,
-     1.0,  0.0, -1.0,  1.0,
+    0.5,  0.0,  1.0, 0.0,
-    -0.5,  1.0, -0.5,  1.0,
+    0.25, -1.0, -0.5, 0.0,
-     0.0,  0.0,  0.0,  1.0
+    0.0,  0.0,  0.0, 1.0
 );
 
 mat4 ycocg_to_rgb = mat4(
-    1.0,  0.5, -0.5, 1.0,
+     1.0, 1.0,  1.0, 0.0,
-    1.0,  0.0,  0.5, 1.0,
+     0.5, 0.0, -0.5, 0.0,
-    1.0, -0.5, -0.5, 1.0,
+    -0.5, 0.5, -0.5, 0.0,
-    0.0,  0.0,  0.0, 1.0
+     0.0, 0.0,  0.0, 1.0
 );
 
 vec2 boolean = vec2(0.0, 1.0);
@@ -27,5 +27,7 @@ void main() {
     vec4 incolour = texture2D(u_texture, v_texCoords);
     vec4 yog = rgb_to_ycocg * incolour; // vec4(Y, Co, Cg, A) where Y,A=[0,1]; Co,Cg=[-1,1]
 
-    gl_FragColor = ycocg_to_rgb * yog;
+    vec4 scalar = vec4(1.0, 2.0, 2.0, 1.0);
+
+    gl_FragColor = ycocg_to_rgb * (yog * scalar);
 }