added some more dope ass filters

Author: stringfromjava

.vscode/settings.json

@@ -31,6 +31,7 @@
     "NUMPADTHREE",
     "NUMPADTWO",
     "NUMPADZERO",
-    "openeditors"
+    "openeditors",
+    "Tiltshift"
   ]
 }

assets/shaders/grain.frag

@@ -0,0 +1,128 @@
+#pragma header
+
+/*
+Film Grain post-process shader v1.1
+Martins Upitis (martinsh) devlog-martinsh.blogspot.com
+2013
+
+--------------------------
+This work is licensed under a Creative Commons Attribution 3.0 Unported License.
+So you are free to share, modify and adapt it for your needs, and even use it for commercial use.
+I would also love to hear about a project you are using it.
+
+Have fun,
+Martins
+--------------------------
+
+Perlin noise shader by toneburst:
+http://machinesdontcare.wordpress.com/2009/06/25/3d-perlin-noise-sphere-vertex-shader-sourcecode/
+*/
+uniform float uTime;
+
+const float permTexUnit = 1.0/256.0;        // Perm texture texel-size
+const float permTexUnitHalf = 0.5/256.0;    // Half perm texture texel-size
+
+float width = openfl_TextureSize.x;
+float height = openfl_TextureSize.y;
+
+const float grainamount = 0.1; //grain amount
+bool colored = false; //colored noise?
+float coloramount = 0.6;
+float grainsize = 2.0; //grain particle size (1.5 - 2.5)
+
+//a random texture generator, but you can also use a pre-computed perturbation texture
+vec4 rnm(in vec2 tc)
+{
+    float noise =  sin(dot(tc + vec2(uTime,uTime),vec2(12.9898,78.233))) * 43758.5453;
+
+    float noiseR =  fract(noise)*2.0-1.0;
+    float noiseG =  fract(noise*1.2154)*2.0-1.0;
+    float noiseB =  fract(noise*1.3453)*2.0-1.0;
+    float noiseA =  fract(noise*1.3647)*2.0-1.0;
+
+    return vec4(noiseR,noiseG,noiseB,noiseA);
+}
+
+float fade(in float t) {
+    return t*t*t*(t*(t*6.0-15.0)+10.0);
+}
+
+float pnoise3D(in vec3 p)
+{
+    vec3 pi = permTexUnit*floor(p)+permTexUnitHalf; // Integer part, scaled so +1 moves permTexUnit texel
+    // and offset 1/2 texel to sample texel centers
+    vec3 pf = fract(p);     // Fractional part for interpolation
+
+    // Noise contributions from (x=0, y=0), z=0 and z=1
+    float perm00 = rnm(pi.xy).a ;
+    vec3  grad000 = rnm(vec2(perm00, pi.z)).rgb * 4.0 - 1.0;
+    float n000 = dot(grad000, pf);
+    vec3  grad001 = rnm(vec2(perm00, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
+    float n001 = dot(grad001, pf - vec3(0.0, 0.0, 1.0));
+
+    // Noise contributions from (x=0, y=1), z=0 and z=1
+    float perm01 = rnm(pi.xy + vec2(0.0, permTexUnit)).a ;
+    vec3  grad010 = rnm(vec2(perm01, pi.z)).rgb * 4.0 - 1.0;
+    float n010 = dot(grad010, pf - vec3(0.0, 1.0, 0.0));
+    vec3  grad011 = rnm(vec2(perm01, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
+    float n011 = dot(grad011, pf - vec3(0.0, 1.0, 1.0));
+
+    // Noise contributions from (x=1, y=0), z=0 and z=1
+    float perm10 = rnm(pi.xy + vec2(permTexUnit, 0.0)).a ;
+    vec3  grad100 = rnm(vec2(perm10, pi.z)).rgb * 4.0 - 1.0;
+    float n100 = dot(grad100, pf - vec3(1.0, 0.0, 0.0));
+    vec3  grad101 = rnm(vec2(perm10, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
+    float n101 = dot(grad101, pf - vec3(1.0, 0.0, 1.0));
+
+    // Noise contributions from (x=1, y=1), z=0 and z=1
+    float perm11 = rnm(pi.xy + vec2(permTexUnit, permTexUnit)).a ;
+    vec3  grad110 = rnm(vec2(perm11, pi.z)).rgb * 4.0 - 1.0;
+    float n110 = dot(grad110, pf - vec3(1.0, 1.0, 0.0));
+    vec3  grad111 = rnm(vec2(perm11, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
+    float n111 = dot(grad111, pf - vec3(1.0, 1.0, 1.0));
+
+    // Blend contributions along x
+    vec4 n_x = mix(vec4(n000, n001, n010, n011), vec4(n100, n101, n110, n111), fade(pf.x));
+
+    // Blend contributions along y
+    vec2 n_xy = mix(n_x.xy, n_x.zw, fade(pf.y));
+
+    // Blend contributions along z
+    float n_xyz = mix(n_xy.x, n_xy.y, fade(pf.z));
+
+    // We are done, return the final noise value.
+    return n_xyz;
+}
+
+//2d coordinate orientation thing
+vec2 coordRot(in vec2 tc, in float angle)
+{
+    float aspect = width/height;
+    float rotX = ((tc.x*2.0-1.0)*aspect*cos(angle)) - ((tc.y*2.0-1.0)*sin(angle));
+    float rotY = ((tc.y*2.0-1.0)*cos(angle)) + ((tc.x*2.0-1.0)*aspect*sin(angle));
+    rotX = ((rotX/aspect)*0.5+0.5);
+    rotY = rotY*0.5+0.5;
+    return vec2(rotX,rotY);
+}
+
+void main()
+{
+    vec2 texCoord = openfl_TextureCoordv.st;
+
+    vec3 rotOffset = vec3(1.425,3.892,5.835); //rotation offset values
+    vec2 rotCoordsR = coordRot(texCoord, uTime + rotOffset.x);
+    vec3 noise = vec3(pnoise3D(vec3(rotCoordsR*vec2(width/grainsize,height/grainsize),0.0)));
+
+    if (colored)
+    {
+        vec2 rotCoordsG = coordRot(texCoord, uTime + rotOffset.y);
+        vec2 rotCoordsB = coordRot(texCoord, uTime + rotOffset.z);
+        noise.g = mix(noise.r,pnoise3D(vec3(rotCoordsG*vec2(width/grainsize,height/grainsize),1.0)),coloramount);
+        noise.b = mix(noise.r,pnoise3D(vec3(rotCoordsB*vec2(width/grainsize,height/grainsize),2.0)),coloramount);
+    }
+
+    vec3 col = texture2D(bitmap, openfl_TextureCoordv).rgb;
+    col = col+noise*grainamount;
+
+    gl_FragColor =  vec4(col,1.0);
+}

assets/shaders/hq2x.frag

@@ -0,0 +1,22 @@
+#pragma header
+
+void main()
+{
+    float x = 1.0 / openfl_TextureSize.x;
+    float y = 1.0 / openfl_TextureSize.y;
+
+    vec4 color1 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(-x, -y));
+    vec4 color2 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(0.0, -y));
+    vec4 color3 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(x, -y));
+
+    vec4 color4 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(-x, 0.0));
+    vec4 color5 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(0.0, 0.0));
+    vec4 color6 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(x, 0.0));
+
+    vec4 color7 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(-x, y));
+    vec4 color8 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(0.0, y));
+    vec4 color9 = texture2D(bitmap, openfl_TextureCoordv.st + vec2(x, y));
+    vec4 avg = color1 + color2 + color3 + color4 + color5 + color6 + color7 + color8 + color9;
+
+    gl_FragColor = avg / 9.0;
+}

assets/shaders/tiltshift.frag

@@ -0,0 +1,77 @@
+#pragma header
+
+// Modified version of a tilt shift shader from Martin Jonasson (http://grapefrukt.com/)
+// Read http://notes.underscorediscovery.com/ for context on shaders and this file
+// License : MIT
+    
+/*
+ * Take note that blurring in a single pass (the two for loops below) is more expensive than separating
+ * the x and the y blur into different passes. This was used where bleeding edge performance
+ * was not crucial and is to illustrate a point. 
+ * 
+ * The reason two passes is cheaper? "texture2D" is a fairly high cost call, sampling a texture.
+ * 
+ * So, in a single pass, like below, there are 3 steps, per x and y. 
+ *
+ * That means a total of 9 "taps", it touches the texture to sample 9 times.
+ *
+ * Now imagine we apply this to some geometry, that is equal to 16 pixels on screen (tiny)
+ * (16 * 16) * 9 = 2304 samples taken, for width * height number of pixels, * 9 taps
+ * Now, if you split them up, it becomes 3 for x, and 3 for y, a total of 6 taps
+ * (16 * 16) * 6 = 1536 samples
+ *
+ * That\'s on a *tiny* sprite, let\'s scale that up to 128x128 sprite...
+ * (128 * 128) * 9 = 147,456
+ * (128 * 128) * 6 =  98,304
+ *
+ * That\'s 33.33..% cheaper for splitting them up.
+ * That\'s with 3 steps, with higher steps (more taps per pass...)
+ *
+ * A really smooth, 6 steps, 6*6 = 36 taps for one pass, 12 taps for two pass
+ * You will notice, the curve is not linear, at 12 steps it\'s 144 vs 24 taps
+ * It becomes orders of magnitude slower to do single pass!
+ * Therefore, you split them up into two passes, one for x, one for y.
+ */
+    
+// I am hardcoding the constants like a jerk
+    
+const float bluramount  = 1.0;
+const float center      = 1.0;
+const float stepSize    = 0.004;
+const float steps       = 3.0;
+    
+const float minOffs     = (float(steps-1.0)) / -2.0;
+const float maxOffs     = (float(steps-1.0)) / +2.0;
+    
+void main() {
+    float amount;
+    vec4 blurred;
+        
+    // Work out how much to blur based on the mid point 
+    amount = pow((openfl_TextureCoordv.y * center) * 2.0 - 1.0, 2.0) * bluramount;
+        
+    // This is the accumulation of color from the surrounding pixels in the texture
+    blurred = vec4(0.0, 0.0, 0.0, 1.0);
+        
+    // From minimum offset to maximum offset
+    for (float offsX = minOffs; offsX <= maxOffs; ++offsX) {
+        for (float offsY = minOffs; offsY <= maxOffs; ++offsY) {
+    
+            // copy the coord so we can mess with it
+            vec2 temp_tcoord = openfl_TextureCoordv.xy;
+    
+            //work out which uv we want to sample now
+            temp_tcoord.x += offsX * amount * stepSize;
+            temp_tcoord.y += offsY * amount * stepSize;
+    
+            // accumulate the sample 
+            blurred += texture2D(bitmap, temp_tcoord);
+        }
+    } 
+        
+    // because we are doing an average, we divide by the amount (x AND y, hence steps * steps)
+    blurred /= float(steps * steps);
+    
+    // return the final blurred color
+    gl_FragColor = blurred;
+}

source/InitState.hx

@@ -1,27 +1,25 @@
 package;
 
-import flixel.input.keyboard.FlxKey;
-import starcore.backend.util.SaveUtil;
-import openfl.events.KeyboardEvent;
 import flixel.FlxG;
 import flixel.FlxState;
+import flixel.input.keyboard.FlxKey;
 import flixel.math.FlxMath;
 import flixel.system.FlxAssets;
 import flixel.tweens.FlxTween;
 import lime.app.Application;
 import openfl.Lib;
 import openfl.display.StageQuality;
 import openfl.display.StageScaleMode;
+import openfl.events.KeyboardEvent;
+import starcore.backend.api.DiscordClient;
 import starcore.backend.data.ClientPrefs;
 import starcore.backend.util.CacheUtil;
 import starcore.backend.util.FlixelUtil;
 import starcore.backend.util.LoggerUtil;
 import starcore.backend.util.PathUtil;
+import starcore.backend.util.SaveUtil;
 import starcore.menus.MainMenuState;
-import starcore.backend.api.DiscordClient;
-#if ADVANCED_SHADERS_ALLOWED
 import starcore.shaders.*;
-#end
 #if web
 import js.Browser;
 #end
@@ -101,9 +99,10 @@ class InitState extends FlxState
 
 		// Assign the shaders AFTER all assets have been loaded!
 		#if ADVANCED_SHADERS_ALLOWED
-		CacheUtil.vcrBorderFilter = new VCRBorderShader();
-		CacheUtil.vcrMario85Filter = new VCRMario85Shader();
+		CacheUtil.vcrBorderShader = new VCRBorderShader();
+		CacheUtil.vcrMario85Shader = new VCRMario85Shader();
 		#end
+		CacheUtil.grainShader = new GrainShader();
 	}
 
 	function addBackgroundProcesses():Void
@@ -112,12 +111,13 @@ class InitState extends FlxState
 		LoggerUtil.log('Adding background processes');
 		// Update the shaders that need to
 		// constantly be reset
-		#if ADVANCED_SHADERS_ALLOWED
 		FlxG.signals.postUpdate.add(() ->
 		{
-			CacheUtil.vcrMario85Filter.update(FlxG.elapsed);
+			#if ADVANCED_SHADERS_ALLOWED
+			CacheUtil.vcrMario85Shader.update(FlxG.elapsed);
+			#end
+			CacheUtil.grainShader.update(FlxG.elapsed);
 		});
-		#end
 	}
 
 	function addEventListeners():Void

source/starcore/backend/data/ClientPrefs.hx

@@ -14,9 +14,9 @@ import haxe.Exception;
  */
 enum ShaderModeType
 {
-	DEFAULT; // All shaders applied
-	FAST; // Only the VCRMario85 and Scanline shaders enabled
-	MINIMAL; // Only scanline shader enabled
+	DEFAULT; // All shaders applied (excluding Scanline)
+	FAST; // Grain, Scanline, Hq2x and Tiltshift shaders are applied
+	MINIMAL; // Grain, Scanline and Hq2x shaders are applied
 	NONE; // No shaders at all
 }
 

source/starcore/backend/data/Constants.hx

@@ -49,7 +49,7 @@ final class Constants
 		#if !web
 		'shaderMode' => ShaderModeType.DEFAULT,
 		#else
-		'shaderMode' => ShaderModeType.MINIMAL,
+		'shaderMode' => ShaderModeType.FAST,
 		#end
 		// Misc.
 		'discordRPC' => true,

source/starcore/backend/util/CacheUtil.hx

@@ -43,17 +43,22 @@ final class CacheUtil
 	/**
 	 * VCR border shader for Starcore.
 	 */
-	public static var vcrBorderFilter:VCRBorderShader;
+	public static var vcrBorderShader:VCRBorderShader;
 
 	/**
 	 * VCR Mario 85 shader for Starcore.
 	 */
-	public static var vcrMario85Filter:VCRMario85Shader;
+	public static var vcrMario85Shader:VCRMario85Shader;
+
+	/**
+	 * Grain shader for Starcore.
+	 */
+	public static var grainShader:GrainShader;
 
 	/**
 	 * Is caps lock enabled?
 	 */
-	public static var capsLockEnabled:Bool = false; // TODO: Find a better way to do this.
+	public static var capsLockEnabled:Bool = false; // TODO: Find a better way to do this...
 
 	function new() {}
 }