Add files via upload

post_processing/node/children/Bloom.tscn

@@ -10,6 +10,7 @@ shader_parameter/blur_radius = 1.0
 shader_parameter/blur_direction = Vector2(1, 1)
 
 [node name="Bloom" type="CanvasLayer"]
+layer = 100
 
 [node name="ColorRect" type="ColorRect" parent="."]
 material = SubResource("ShaderMaterial_s3kyv")

post_processing/node/children/ChromaticAberration.tscn

@@ -4,9 +4,10 @@
 
 [sub_resource type="ShaderMaterial" id="ShaderMaterial_ke5y5"]
 shader = ExtResource("1_qxjen")
-shader_parameter/offset = 5.0
+shader_parameter/offset = 50.0
 
 [node name="ChromaticAberration" type="CanvasLayer"]
+layer = 102
 
 [node name="data" type="ColorRect" parent="."]
 material = SubResource("ShaderMaterial_ke5y5")

post_processing/node/children/blur.tscn

@@ -4,9 +4,10 @@
 
 [sub_resource type="ShaderMaterial" id="ShaderMaterial_efbmf"]
 shader = ExtResource("1_6v1pv")
-shader_parameter/lod = 1.0
+shader_parameter/lod = 1.287
 
 [node name="Blur" type="CanvasLayer"]
+layer = 101
 
 [node name="data" type="ColorRect" parent="."]
 material = SubResource("ShaderMaterial_efbmf")

post_processing/node/children/fish_eye.tscn

@@ -0,0 +1,18 @@
+[gd_scene load_steps=3 format=3 uid="uid://c5qv7q54m4xn6"]
+
+[ext_resource type="Shader" path="res://addons/post_processing/shaders/fish_eye.gdshader" id="1_eks6e"]
+
+[sub_resource type="ShaderMaterial" id="ShaderMaterial_v56sw"]
+shader = ExtResource("1_eks6e")
+shader_parameter/effect_amount = 1.635
+
+[node name="FishEye" type="CanvasLayer"]
+layer = 103
+
+[node name="data" type="ColorRect" parent="."]
+material = SubResource("ShaderMaterial_v56sw")
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+grow_horizontal = 2
+grow_vertical = 2

post_processing/node/children/glitch.tscn

@@ -0,0 +1,22 @@
+[gd_scene load_steps=3 format=3 uid="uid://dwioerk4ps6rr"]
+
+[ext_resource type="Shader" path="res://addons/post_processing/shaders/glitch.gdshader" id="1_3euvy"]
+
+[sub_resource type="ShaderMaterial" id="ShaderMaterial_gdr74"]
+shader = ExtResource("1_3euvy")
+shader_parameter/range = 0.055
+shader_parameter/noiseQuality = 250.0
+shader_parameter/noiseIntensity = 0.0088
+shader_parameter/offsetIntensity = 0.03
+shader_parameter/colorOffsetIntensity = 1.3
+
+[node name="Glitch" type="CanvasLayer"]
+layer = 104
+
+[node name="data" type="ColorRect" parent="."]
+material = SubResource("ShaderMaterial_gdr74")
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+grow_horizontal = 2
+grow_vertical = 2

post_processing/node/children/kaleidoscope.gdshader

@@ -0,0 +1,309 @@
+shader_type canvas_item;
+
+// CC0: Truchet + Kaleidoscope FTW
+//  Bit of experimenting with kaleidoscopes and truchet turned out nice
+//  Quite similar to an earlier shader I did but I utilized a different truchet pattern this time
+
+uniform float animate_speed = 0.25;
+uniform float resolution = 1.0;
+
+// License: Unknown, author: Unknown, found: don't remember
+vec4 alphaBlend(vec4 back, vec4 front) {
+  float w = front.w + back.w*(1.0-front.w);
+  vec3 xyz = (front.xyz*front.w + back.xyz*back.w*(1.0-front.w))/w;
+  return w > 0.0 ? vec4(xyz, w) : vec4(0.0);
+
+}
+mat2 ROT(float a){
+	return mat2(vec2(cos(a),sin(a)),vec2(-sin(a),cos(a)));
+}
+float PCOS(float x){
+	return 0.5+0.5*cos(x);
+}
+
+// License: Unknown, author: Unknown, found: don't remember
+vec3 alphaBlend34(vec3 back, vec4 front) {
+  return mix(back, front.xyz, front.w);
+}
+
+// License: Unknown, author: Unknown, found: don't remember
+float hashf(float co) {
+  return fract(sin(co*12.9898) * 13758.5453);
+}
+
+// License: Unknown, author: Unknown, found: don't remember
+float hashv(vec2 p) {
+  float a = dot(p, vec2 (127.1, 311.7));
+  return fract(sin (a)*43758.5453123);
+}
+
+// License: Unknown, author: Unknown, found: don't remember
+float tanh_approx(float x) {
+  //  Found this somewhere on the interwebs
+  //  return tanh(x);
+  float x2 = x*x;
+  return clamp(x*(27.0 + x2)/(27.0+9.0*x2), -1.0, 1.0);
+}
+
+// License: MIT, author: Inigo Quilez, found: https://www.iquilezles.org/www/articles/smin/smin.htm
+float pmin(float a, float b, float k) {
+  float h = clamp(0.5+0.5*(b-a)/k, 0.0, 1.0);
+  return mix(b, a, h) - k*h*(1.0-h);
+}
+
+// License: MIT, author: Inigo Quilez, found: https://www.iquilezles.org/www/index.htm
+vec3 postProcess(vec3 col, vec2 q) {
+  col = clamp(col, 0.0, 1.0);
+  col = pow(col, vec3(1.0/2.2));
+  col = col*0.6+0.4*col*col*(3.0-2.0*col);
+  col = mix(col, vec3(dot(col, vec3(0.33))), -0.4);
+  col *=0.5+0.5*pow(19.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.7);
+  return col;
+}
+
+float pmax(float a, float b, float k) {
+  return -pmin(-a, -b, k);
+}
+
+float pabs(float a, float k) {
+  return pmax(a, -a, k);
+}
+
+vec2 toPolar(vec2 p) {
+  return vec2(length(p), atan(p.y, p.x));
+}
+
+vec2 toRect(vec2 p) {
+  return vec2(p.x*cos(p.y), p.x*sin(p.y));
+}
+
+// License: MIT OR CC-BY-NC-4.0, author: mercury, found: https://mercury.sexy/hg_sdf/
+float modMirror1(inout float p, float size) {
+  float halfsize = size*0.5;
+  float c = floor((p + halfsize)/size);
+  p = mod(p + halfsize,size) - halfsize;
+  p *= mod(c, 2.0)*2.0 - 1.0;
+  return c;
+}
+
+float smoothKaleidoscope(inout vec2 p, float sm, float rep) {
+  vec2 hp = p;
+
+  vec2 hpp = toPolar(hp);
+  float rn = modMirror1(hpp.y, 2.0*PI/rep);
+
+  float sa = PI/rep - pabs(PI/rep - abs(hpp.y), sm);
+  hpp.y = sign(hpp.y)*(sa);
+
+  hp = toRect(hpp);
+
+  p = hp;
+
+  return rn;
+}
+
+// The path function
+vec3 offset(float z) {
+  float a = z;
+  vec2 p = -0.075*(vec2(cos(a), sin(a*sqrt(2.0))) + vec2(cos(a*sqrt(0.75)), sin(a*sqrt(0.5))));
+  return vec3(p, z);
+}
+
+// The derivate of the path function
+//  Used to generate where we are looking
+vec3 doffset(float z) {
+  float eps = 0.1;
+  return 0.5*(offset(z + eps) - offset(z - eps))/eps;
+}
+
+// The second derivate of the path function
+//  Used to generate tilt
+vec3 ddoffset(float z) {
+  float eps = 0.1;
+  return 0.125*(doffset(z + eps) - doffset(z - eps))/eps;
+}
+
+vec2 cell_df(float r, vec2 np, vec2 mp, vec2 off) {
+
+  vec2 n0 = normalize(vec2(1.0, 1.0));
+  vec2 n1 = normalize(vec2(1.0, -1.0));
+
+  np += off;
+  mp -= off;
+
+  float hh = hashv(np);
+  float h0 = hh;
+
+  vec2  p0 = mp;  
+  p0 = abs(p0);
+  p0 -= 0.5;
+  float d0 = length(p0);
+  float d1 = abs(d0-r); 
+
+  float dot0 = dot(n0, mp);
+  float dot1 = dot(n1, mp);
+
+  float d2 = abs(dot0);
+  float t2 = dot1;
+  d2 = abs(t2) > sqrt(0.5) ? d0 : d2;
+
+  float d3 = abs(dot1);
+  float t3 = dot0;
+  d3 = abs(t3) > sqrt(0.5) ? d0 : d3;
+
+
+  float d = d0;
+  d = min(d, d1);
+  if (h0 > .85)
+  {
+    d = min(d, d2);
+    d = min(d, d3);
+  }
+  else if(h0 > 0.5)
+  {
+    d = min(d, d2);
+  }
+  else if(h0 > 0.15)
+  {
+    d = min(d, d3);
+  }
+
+  return vec2(d, (d0-r));
+}
+
+vec2 truchet_df(float r, vec2 p) {
+  vec2 np = floor(p+0.5);
+  vec2 mp = fract(p+0.5) - 0.5;
+  return cell_df(r, np, mp, vec2(0.0));
+}
+
+vec4 plane(vec3 ro, vec3 rd, vec3 pp, vec3 off, float aa, float n) {
+  float h_ = hashf(n);
+  float h0 = fract(1777.0*h_);
+  float h1 = fract(2087.0*h_);
+  float h2 = fract(2687.0*h_);
+  float h3 = fract(3167.0*h_);
+  float h4 = fract(3499.0*h_);
+
+  float l = length(pp - ro);
+
+  vec3 hn;
+  vec2 p = (pp-off*vec3(1.0, 1.0, 0.0)).xy;
+  p *= ROT(0.5*(h4 - 0.5)*TIME);
+  float rep = 2.0*round(mix(5.0, 30.0, h2));
+  float sm = 0.05*20.0/rep;
+  float sn = smoothKaleidoscope(p, sm, rep);
+  p *= ROT(2.0*PI*h0+0.025*TIME);
+  float z = mix(0.2, 0.4, h3);
+  p /= z;
+  p+=0.5+floor(h1*1000.0);
+  float tl = tanh_approx(0.33*l);
+  float r = mix(0.30, 0.45, PCOS(0.1*n));
+  vec2 d2 = truchet_df(r, p);
+  d2 *= z;
+  float d = d2.x;
+  float lw =0.025*z; 
+  d -= lw;
+
+  vec3 col = mix(vec3(1.0), vec3(0.0), smoothstep(aa, -aa, d));
+  col = mix(col, vec3(0.0), smoothstep(mix(1.0, -0.5, tl), 1.0, sin(PI*100.0*d)));
+//  float t0 = smoothstep(aa, -aa, -d2.y-lw);
+  col = mix(col, vec3(0.0), step(d2.y, 0.0));
+  //float t = smoothstep(3.0*lw, 0.0, -d2.y);
+//  float t = smoothstep(aa, -aa, -d2.y-lw);
+  float t = smoothstep(aa, -aa, -d2.y-3.0*lw)*mix(0.5, 1.0, smoothstep(aa, -aa, -d2.y-lw));
+  return vec4(col, t);
+}
+
+vec3 skyColor(vec3 ro, vec3 rd) {
+  float d = pow(max(dot(rd, vec3(0.0, 0.0, 1.0)), 0.0), 20.0);
+  return vec3(d);
+}
+
+
+vec3 color(vec3 ww, vec3 uu, vec3 vv, vec3 ro, vec2 p){
+  float lp = length(p);
+  vec2 np = p + 1.0/vec2(1920.0*resolution,1080.0*resolution) ;
+  float rdd = (2.0+1.0*tanh_approx(lp));
+//  float rdd = 2.0;
+  vec3 rd = normalize(p.x*uu + p.y*vv + rdd*ww);
+  vec3 nrd = normalize(np.x*uu + np.y*vv + rdd*ww);
+
+   float planeDist = 1.0-0.25;
+   int furthest = 6;
+   int fadeFrom = max(furthest-5, 0);
+
+  float fadeDist = planeDist*float(furthest - fadeFrom);
+  float nz = floor(ro.z / planeDist);
+
+  vec3 skyCol = skyColor(ro, rd);
+
+
+  vec4 acol = vec4(0.0);
+  float cutOff = 0.95;
+  bool cutOut = false;
+
+  // Steps from nearest to furthest plane and accumulates the color 
+  for (int i = 1; i <= furthest; ++i) {
+    float pz = planeDist*nz + planeDist*float(i);
+
+    float pd = (pz - ro.z)/rd.z;
+
+    if (pd > 0.0 && acol.w < cutOff) {
+      vec3 pp = ro + rd*pd;
+      vec3 npp = ro + nrd*pd;
+
+      float aa = 3.0*length(pp - npp);
+
+      vec3 off = offset(pp.z);
+
+      vec4 pcol = plane(ro, rd, pp, off, aa, nz+float(i));
+
+      float nz1 = pp.z-ro.z;
+      float fadeIn = smoothstep(planeDist*float(furthest), planeDist*float(fadeFrom), nz1);
+      float fadeOut = smoothstep(0.0, planeDist*0.1, nz1);
+      pcol.xyz = mix(skyCol, pcol.xyz, fadeIn);
+      pcol.w *= fadeOut;
+      pcol = clamp(pcol, 0.0, 1.0);
+
+      acol = alphaBlend(pcol, acol);
+    } else {
+      cutOut = true;
+      break;
+    }
+
+  }
+
+  vec3 col = alphaBlend34(skyCol, acol);
+// To debug cutouts due to transparency  
+//  col += cutOut ? vec3(1.0, -1.0, 0.0) : vec3(0.0);
+  return col;
+}
+vec3 effect(vec2 p, vec2 q) {
+  float tm  = TIME*animate_speed;
+  vec3 ro   = offset(tm);
+  vec3 dro  = doffset(tm);
+  vec3 ddro = ddoffset(tm);
+
+  vec3 ww = normalize(dro);
+  vec3 uu = normalize(cross(normalize(vec3(0.0,1.0,0.0)+ddro), ww));
+  vec3 vv = normalize(cross(ww, uu));
+
+  vec3 col = color(ww, uu, vv, ro, p);
+
+  return col;
+}
+void fragment(){
+
+
+
+  vec2 q = FRAGCOORD.xy/(1.0 / SCREEN_PIXEL_SIZE).xy;
+  vec2 p = -1. + 2. * q;
+  p.x *= (1.0 / SCREEN_PIXEL_SIZE).x/(1.0 / SCREEN_PIXEL_SIZE).y;
+
+  vec3 col = effect(p, q);
+  col *= smoothstep(0.0, 4.0, TIME);
+  col = postProcess(col, q);
+
+  COLOR = vec4(col, 1.0);
+}