ohzi-core 5.13.2 → 5.14.2

package/src/shaders/median_filter/median_filter.frag

@@ -0,0 +1,134 @@
+/*
+3x3 Median
+
+GLSL 1.0
+Morgan McGuire and Kyle Whitson, 2006
+Williams College
+http://graphics.cs.williams.edu
+
+Copyright (c) Morgan McGuire and Williams College, 2006
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+// Input texture
+uniform sampler2D _SourceTex;
+uniform vec2 _SourceTexSize;
+varying vec2 vUv;
+// Change these 2 defines to change precision
+#define vec vec4
+#define toVec(x) x.rgba
+
+#define s2(a, b)        temp = a; a = min(a, b); b = max(temp, b);
+#define t2(a, b)        s2(v[a], v[b]);
+#define t24(a, b, c, d, e, f, g, h)     t2(a, b); t2(c, d); t2(e, f); t2(g, h); 
+#define t25(a, b, c, d, e, f, g, h, i, j)   t24(a, b, c, d, e, f, g, h); t2(i, j);
+
+#define s2(a, b)        temp = a; a = min(a, b); b = max(temp, b);
+#define mn3(a, b, c)      s2(a, b); s2(a, c);
+#define mx3(a, b, c)      s2(b, c); s2(a, c);
+
+#define mnmx3(a, b, c)      mx3(a, b, c); s2(a, b);                                   // 3 exchanges
+#define mnmx4(a, b, c, d)   s2(a, b); s2(c, d); s2(a, c); s2(b, d);                   // 4 exchanges
+#define mnmx5(a, b, c, d, e)  s2(a, b); s2(c, d); mn3(a, c, e); mx3(b, d, e);           // 6 exchanges
+#define mnmx6(a, b, c, d, e, f) s2(a, d); s2(b, e); s2(c, f); mn3(a, b, c); mx3(d, e, f); // 7 exchanges
+
+
+void main() {
+  vec2 inv_size = vec2(1.0/_SourceTexSize.x, 1.0/_SourceTexSize.y);
+
+
+  #ifdef kernel5x5
+    vec v[25];
+
+    // Add the pixels which make up our window to the pixel array.
+    for(int dX = -2; dX <= 2; ++dX) {
+      for(int dY = -2; dY <= 2; ++dY) {   
+        vec2 offset = vec2(float(dX), float(dY));
+          
+        // If a pixel in the window is located at (x+dX, y+dY), put it at index (dX + R)(2R + 1) + (dY + R) of the
+        // pixel array. This will fill the pixel array, with the top left pixel of the window at pixel[0] and the
+        // bottom right pixel of the window at pixel[N-1].
+        v[(dX + 2) * 5 + (dY + 2)] = toVec(texture2D(_SourceTex, vUv + offset * inv_size));
+      }
+    }
+
+    vec temp;
+
+    t25(0, 1,     3, 4,   2, 4,   2, 3,   6, 7);
+    t25(5, 7,     5, 6,   9, 7,   1, 7,   1, 4);
+    t25(12, 13,   11, 13,   11, 12,   15, 16,   14, 16);
+    t25(14, 15,   18, 19,   17, 19,   17, 18,   21, 22);
+    t25(20, 22,   20, 21,   23, 24,   2, 5,   3, 6);
+    t25(0, 6,     0, 3,   4, 7,   1, 7,   1, 4);
+    t25(11, 14,   8, 14,    8, 11,    12, 15,   9, 15);
+    t25(9, 12,    13, 16,   10, 16,   10, 13,   20, 23);
+    t25(17, 23,   17, 20,   21, 24,   18, 24,   18, 21);
+    t25(19, 22,   8, 17,    9, 18,    0, 18,    0, 9);
+    t25(10, 19,   1, 19,    1, 10,    11, 20,   2, 20);
+    t25(2, 11,    12, 21,   3, 21,    3, 12,    13, 22);
+    t25(4, 22,    4, 13,    14, 23,   5, 23,    5, 14);
+    t25(15, 24,   6, 24,    6, 15,    7, 16,    7, 19);
+    t25(3, 11,    5, 17,    11, 17,   9, 17,    4, 10);
+    t25(6, 12,    7, 14,    4, 6,   4, 7,   12, 14);
+    t25(10, 14,   6, 7,   10, 12,   6, 10,    6, 17);
+    t25(12, 17,   7, 17,    7, 10,    12, 18,   7, 12);
+    t24(10, 18,   12, 20,   10, 20,   10, 12);
+    gl_FragColor = v[12];
+  #endif
+
+  #ifdef kernel3x3
+    vec v[9];
+
+    // Add the pixels which make up our window to the pixel array.
+    for(int dX = -1; dX <= 1; ++dX) {
+      for(int dY = -1; dY <= 1; ++dY) {   
+        vec2 offset = vec2(float(dX), float(dY));
+          
+        // If a pixel in the window is located at (x+dX, y+dY), put it at index (dX + R)(2R + 1) + (dY + R) of the
+        // pixel array. This will fill the pixel array, with the top left pixel of the window at pixel[0] and the
+        // bottom right pixel of the window at pixel[N-1].
+        v[(dX + 1) * 3 + (dY + 1)] = toVec(texture2D(_SourceTex, vUv + offset * inv_size));
+      }
+    }
+
+    vec temp;
+
+    // Starting with a subset of size 6, remove the min and max each time
+    mnmx6(v[0], v[1], v[2], v[3], v[4], v[5]);
+    mnmx5(v[1], v[2], v[3], v[4], v[6]);
+    mnmx4(v[2], v[3], v[4], v[7]);
+    mnmx3(v[3], v[4], v[8]);
+    toVec(gl_FragColor) = v[4];
+  #endif
+
+
+    // if(vUv.x > 0.5)
+    //   gl_FragColor = vec4(1.0);
+    // else
+    //   gl_FragColor = vec4(0.0);
+}
+
+

package/src/shaders/normal/normal.frag

@@ -0,0 +1,6 @@
+varying vec3 v_normal;
+
+void main()
+{
+    gl_FragColor = vec4(v_normal * 0.5 + vec3(0.5), 1.0);
+}

package/src/shaders/normal/normal.vert

@@ -0,0 +1,6 @@
+varying vec3 v_normal;
+void main()
+{
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    v_normal = (modelMatrix * vec4(normal, 0.0)).xyz;
+}

package/src/shaders/sdf_text/sdf_screen_text.frag

@@ -0,0 +1,51 @@
+uniform sampler2D _Texture;
+varying vec2 vUv;
+
+uniform vec2 _AtlasSize;
+varying vec4 v_glyph_bounds;
+varying vec4 v_color;
+
+
+float median(float r, float g, float b) {
+    return max(min(r, g), min(max(r, g), b));
+}
+
+void main()
+{
+
+
+
+  float left  = v_glyph_bounds.x / _AtlasSize.x;
+  float right = v_glyph_bounds.y / _AtlasSize.x;
+
+  float top     = v_glyph_bounds.z / _AtlasSize.y;
+  float bottom  = v_glyph_bounds.w / _AtlasSize.y;
+
+
+  float width = abs(right - left);
+  float height = abs(top - bottom);
+
+  vec2 coord = vec2(vUv.x * width + left, vUv.y * height + top - height);
+
+  vec4 col = texture2D(_Texture, coord);
+
+  float sig_dist = median(col.r, col.g, col.b);
+
+
+  float _Cutoff = 0.5;
+  float dist = (_Cutoff - sig_dist);
+
+  // sdf distance per pixel (gradient vector)
+  vec2 ddist = vec2(dFdx(dist), dFdy(dist));
+
+  // distance to edge in pixels (scalar)
+  float pixelDist = dist / length(ddist);
+
+  float opacity = clamp(0.5 - pixelDist, 0.0, 1.0);
+
+  // float w = fwidth(sig_dist);
+  // opacity = smoothstep(0.5 - w, 0.5 + w, sig_dist);
+
+
+  gl_FragColor = vec4(v_color.rgb, opacity * v_color.a);
+}

package/src/shaders/sdf_text/sdf_screen_text.vert

@@ -0,0 +1,42 @@
+
+attribute vec4 transformsCol0;
+attribute vec4 transformsCol1;
+attribute vec4 transformsCol2;
+attribute vec4 transformsCol3;
+
+attribute vec4 glyph_bounds;
+attribute vec4 plane_bounds;
+
+attribute vec4 color;
+
+
+varying vec2 vUv;
+varying vec4 v_glyph_bounds;
+varying vec4 v_color;
+
+void main()
+{
+  vec4 pos = vec4(position, 1.0);
+  pos.x *= plane_bounds.z;
+  pos.y *= plane_bounds.w;
+
+  pos.x += plane_bounds.x;
+  pos.y += plane_bounds.y;
+
+
+  mat4 offset_matrix = mat4(
+      transformsCol0,
+      transformsCol1,
+      transformsCol2,
+      transformsCol3
+  );
+
+
+
+
+
+  gl_Position = projectionMatrix * viewMatrix * offset_matrix * pos;
+  vUv = uv;
+  v_glyph_bounds = glyph_bounds;
+  v_color = color;
+}

package/src/shaders/sdf_text/sdf_text.frag

@@ -0,0 +1,53 @@
+uniform sampler2D _Texture;
+uniform float _Boldness;
+
+varying vec2 vUv;
+
+uniform vec2 _AtlasSize;
+varying vec4 v_glyph_bounds;
+varying vec4 v_color;
+
+
+float median(float r, float g, float b) {
+    return max(min(r, g), min(max(r, g), b));
+}
+
+void main()
+{
+
+
+
+  float left  = v_glyph_bounds.x / _AtlasSize.x;
+  float right = v_glyph_bounds.y / _AtlasSize.x;
+
+  float top     = v_glyph_bounds.z / _AtlasSize.y;
+  float bottom  = v_glyph_bounds.w / _AtlasSize.y;
+
+
+  float width = abs(right - left);
+  float height = abs(top - bottom);
+
+  vec2 coord = vec2(vUv.x * width + left, vUv.y * height + top - height);
+
+  vec4 col = texture2D(_Texture, coord);
+
+  float sig_dist = median(col.r, col.g, col.b);
+
+
+  float _Cutoff = _Boldness;
+  float dist = (_Cutoff - sig_dist);
+
+  // sdf distance per pixel (gradient vector)
+  vec2 ddist = vec2(dFdx(dist), dFdy(dist));
+
+  // distance to edge in pixels (scalar)
+  float pixelDist = dist / length(ddist);
+
+  float opacity = clamp(0.5 - pixelDist, 0.0, 1.0);
+
+  // float w = fwidth(sig_dist);
+  // opacity = smoothstep(0.5 - w, 0.5 + w, sig_dist);
+
+
+  gl_FragColor = vec4(v_color.rgb, opacity * v_color.a);
+}

package/src/shaders/sdf_text/sdf_text.vert

@@ -0,0 +1,42 @@
+
+attribute vec4 transformsCol0;
+attribute vec4 transformsCol1;
+attribute vec4 transformsCol2;
+attribute vec4 transformsCol3;
+
+attribute vec4 glyph_bounds;
+attribute vec4 plane_bounds;
+
+attribute vec4 color;
+
+
+varying vec2 vUv;
+varying vec4 v_glyph_bounds;
+varying vec4 v_color;
+
+void main()
+{
+  vec4 pos = vec4(position, 1.0);
+  pos.x *= plane_bounds.z;
+  pos.y *= plane_bounds.w;
+
+  pos.x += plane_bounds.x;
+  pos.y += plane_bounds.y;
+
+
+  mat4 offset_matrix = mat4(
+      transformsCol0,
+      transformsCol1,
+      transformsCol2,
+      transformsCol3
+  );
+
+
+
+
+
+  gl_Position = projectionMatrix * viewMatrix * offset_matrix * pos;
+  vUv = uv;
+  v_glyph_bounds = glyph_bounds;
+  v_color = color;
+}

package/src/shaders/ssao/hbao.frag

@@ -0,0 +1,264 @@
+uniform sampler2D _MainTex;
+uniform mat4 _InverseProjMatrix;
+uniform mat4 _InverseViewMatrix;
+
+uniform float _Bias;
+uniform float _Radius;
+
+uniform vec2 _TargetResolution;
+uniform float _FarPlane;
+
+
+varying vec2 vUv;
+varying vec4 vRay;
+
+
+uniform vec3 _SampleKernel[64];
+uniform sampler2D _RandomRotation;
+uniform mat4 _ProjectionMatrix;
+
+vec3 decode_normal (vec4 enc)
+{
+    float scale = 1.7777;
+    vec3 nn =
+        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
+        vec3(-scale,-scale,1.0);
+    float g = 2.0 / dot(nn.xyz,nn.xyz);
+    vec3 n;
+    n.xy = g*nn.xy;
+    n.z = g-1.0;
+    return n;
+}
+
+float DecodeFloatRG( vec2 enc )
+{
+    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
+    return dot( enc, kDecodeDot );
+}
+
+vec3 DecodeNormal(vec2 uv)
+{
+  // vec2 encoded_normal = texture2D(_MainTex, uv).zw;
+  // vec3 normalValue = normalize(decode_normal(vec4(encoded_normal, 0., 0.)));
+  // return normalize(normalValue);
+  return normalize(texture2D(_MainTex, uv).xyz * 2.0 - vec3(1.0));
+}
+
+
+vec3 DecodeViewPos(vec2 uv)
+{
+  float depth = texture2D(_MainTex, uv).w;
+
+  float x = uv.x * 2.0 - 1.0;
+  float y = uv.y * 2.0 - 1.0;
+  vec4 inv_proj = _InverseProjMatrix * vec4(x,y, 1.0, 1.0);
+
+  return (inv_proj.xyz / inv_proj.w) * depth;
+}
+
+float fast_length(vec3 V)
+{
+	return dot(V,V);
+}
+
+vec3 MinDiff(vec3 P, vec3 Pr, vec3 Pl)
+{
+    vec3 V1 = Pr - P;
+    vec3 V2 = P - Pl;
+    return (fast_length(V1) < fast_length(V2)) ? V1 : V2;
+}
+
+
+
+
+#define PI 3.14
+#define PI_OVER_2 1.5707963
+#define PI_OVER_4 0.785398
+#define EPSILON 0.000001
+
+// Maps a unit square in [-1, 1] to a unit disk in [-1, 1]. Shirley 97 "A Low Distortion Map Between Disk and Square"
+// Inputs: cartesian coordinates
+// Return: new circle-mapped polar coordinates (radius, angle)
+vec2 UnitSquareToUnitDiskPolar(float a, float b) {
+    float radius, angle;
+    if (abs(a) > abs(b)) { // First region (left and right quadrants of the disk)
+        radius = a;
+        angle = b / (a + EPSILON) * PI_OVER_4;
+    } else { // Second region (top and botom quadrants of the disk)
+        radius = b;
+        angle = PI_OVER_2 - (a / (b + EPSILON) * PI_OVER_4);
+    }
+    if (radius < 0.0) { // Always keep radius positive
+        radius *= -1.0;
+        angle += PI;
+    }
+    return vec2(radius, angle);
+}
+
+// Maps a unit square in [-1, 1] to a unit disk in [-1, 1]
+// Inputs: cartesian coordinates
+// Return: new circle-mapped cartesian coordinates
+vec2 SquareToDiskMapping(float a, float b) {
+    vec2 PolarCoord = UnitSquareToUnitDiskPolar(a, b);
+    return vec2(PolarCoord.x * cos(PolarCoord.y), PolarCoord.x * sin(PolarCoord.y));
+}
+
+
+
+
+
+// // Retrieves the occlusion factor for a particular sample
+// // uv: the centre coordinate of the kernel
+// // frustumVector: The frustum vector of the sample point
+// // centerViewPos: The view space position of the centre point
+// // centerNormal: The normal of the centre point
+// // tangent: The tangent vector in the sampling direction at the centre point
+// // topOcclusion: The maximum cos(angle) found so far, will be updated when a new occlusion segment has been found
+// float GetSampleOcclusion(vec2 uv, vec3 centerViewPos, vec3 centerNormal, vec3 tangent, inout float topOcclusion)
+// {
+// 	// reconstruct sample's view space position based on depth buffer and interpolated frustum vector
+// 	vec3 sampleViewPos = DecodeViewPos(uv);
+
+// 	// get occlusion factor based on candidate horizon elevation
+// 	vec3 horizonVector = sampleViewPos - centerViewPos;
+// 	float horizonVectorLength = length(horizonVector);
+
+// 	float occlusion;
+
+// 	// If the horizon vector points away from the tangent, make an estimate
+// 	if (dot(tangent, horizonVector) < 0.0)
+// 		return 0.5;
+// 	else
+// 		occlusion = dot(centerNormal, horizonVector) / horizonVectorLength;
+
+// 	// this adds occlusion only if angle of the horizon vector is higher than the previous highest one without branching
+// 	float diff = max(occlusion - topOcclusion, 0.0);
+// 	topOcclusion = max(occlusion, topOcclusion);
+
+// 	// attenuate occlusion contribution using distance function 1 - (d/f)^2
+//   float fallOff = 2.0;
+// 	float distanceFactor = saturate(horizonVectorLength / fallOff);
+// 	distanceFactor = 1.0 - distanceFactor * distanceFactor;
+// 	return diff * distanceFactor;
+// }
+
+
+#define MAX_DIRECTIONS 8
+#define MAX_DIRECTIONS_F 8.0
+#define MAX_STEPS 8
+#define MAX_STEPS_F 8.0
+#define KERNEL_SIZE 8
+#define KERNEL_SIZE_F 8.0
+#define MAX_TAPS (KERNEL_SIZE*KERNEL_SIZE)
+#define MAX_TAPS_F (KERNEL_SIZE_F*KERNEL_SIZE_F)
+
+float InvLength(vec2 V)
+{
+	return inversesqrt(dot(V,V));
+}
+vec2 viewToScreen(vec3 viewPos)
+{
+  vec4 P_screen = _ProjectionMatrix * vec4(viewPos, 1.0);
+  P_screen.xyz/= P_screen.w;
+  P_screen.xy = P_screen.xy * 0.5 + vec2(0.5, 0.5);
+  return P_screen.xy;
+}
+
+float BiasedTangent(vec3 V)
+{
+	return V.z / length(V.xy) + _Bias;
+}
+
+float TanToSin(float x)
+{
+	return x * inversesqrt(x*x + 1.0);
+}
+
+float Tangent(vec3 V)
+{
+	return V.z * InvLength(V.xy);
+}
+
+
+float Tangent(vec3 P, vec3 S)
+{
+    return -(P.z - S.z) * InvLength(S.xy - P.xy);
+}
+
+void main()
+{
+  vec2 half_pixel = vec2(0.5/_TargetResolution.x, 0.5/_TargetResolution.y);
+  vec2 pixel_size = vec2(1.0/_TargetResolution.x, 1.0/_TargetResolution.y);
+
+  vec2 uv = vUv;
+
+  vec3 P         = DecodeViewPos(uv);
+  vec3 normal    = DecodeNormal(uv);
+
+
+  vec2 P_s = viewToScreen(P);
+
+  // float radius = 0.5;
+  vec2 P1_s = viewToScreen(P +  vec3(0.0, _Radius, 0.0));
+
+  float step_size_px = length(P1_s - P_s);
+
+
+
+  // vec3 Pt = DecodeViewPos(uv + vec2(0.0, pixel_size.y));
+  // vec3 Pb = DecodeViewPos(uv + vec2(0.0, -pixel_size.y));
+
+  // vec3 Pl = DecodeViewPos(uv + vec2(-pixel_size.x, 0.0));
+  // vec3 Pr = DecodeViewPos(uv + vec2(pixel_size.x, 0.0));
+
+  // vec3 dPv = normalize(MinDiff(P, Pt, Pb));
+  // vec3 dPh = normalize(MinDiff(P, Pr, Pl));
+
+  // gl_FragColor.rgb = normalize(cross(dPh, dPv))* 0.5 + vec3(0.5,0.5,0.5);
+
+  float alpha = (2.0 * PI) / MAX_DIRECTIONS_F;
+  float accum = 0.0;
+  for(int i=0; i< MAX_DIRECTIONS; i++)
+  {
+    float theta = alpha * float(i);
+    // Apply noise to the direction
+    vec2 dir = vec2(cos(theta), sin(theta)) * (step_size_px/MAX_DIRECTIONS_F);
+    float max_angle = 0.0;
+
+
+    for(int j=1; j< MAX_STEPS; j++)
+    {
+      vec2 uv_offset = dir * float(j);
+
+      vec3 sample = DecodeViewPos(vUv + uv_offset);
+
+
+      vec3 dir = sample - P;
+      vec3 tangent = cross(normalize(dir), normal);
+      tangent = cross(normal, tangent);
+
+      float sin_t = TanToSin(BiasedTangent(tangent)); //sin(t)
+
+      float horizon_angle = Tangent(P, sample);
+      if(length(dir) < _Radius &&  horizon_angle > max_angle)
+      {
+        float sin_h = TanToSin(horizon_angle);
+        accum += sin_h - sin_t;
+        max_angle = horizon_angle;
+      }
+    }
+  }
+
+  gl_FragColor.rgb = vec3(accum/MAX_DIRECTIONS_F);
+
+  // gl_FragColor.rgb = vec3(sin(abs(max_angle)));
+  // gl_FragColor.rgb = normalize(dPv+dPh) * 0.5 + vec3(0.5);
+  // gl_FragColor.rgb = vec3(sample_length);
+
+  gl_FragColor.a = 1.0;
+
+}
+
+
+
+

package/src/shaders/ssao/ssao.frag

@@ -0,0 +1,95 @@
+uniform sampler2D _MainTex;
+uniform mat4 _InverseProjMatrix;
+
+uniform float _Bias;
+uniform float _Radius;
+
+uniform vec2 _Resolution;
+uniform float _FarPlane;
+
+
+varying vec2 vUv;
+varying vec4 vRay;
+
+
+uniform vec3 _SampleKernel[64];
+uniform sampler2D _RandomRotation;
+uniform mat4 _ProjectionMatrix;
+
+vec3 decode_normal (vec4 enc)
+{
+    float scale = 1.7777;
+    vec3 nn =
+        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
+        vec3(-scale,-scale,1.0);
+    float g = 2.0 / dot(nn.xyz,nn.xyz);
+    vec3 n;
+    n.xy = g*nn.xy;
+    n.z = g-1.0;
+    return n;
+}
+
+float DecodeFloatRG( vec2 enc )
+{
+    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
+    return dot( enc, kDecodeDot );
+}
+
+vec3 DecodeNormal(vec2 uv)
+{
+  vec2 encoded_normal = texture2D(_MainTex, uv).zw;
+  vec3 normalValue = normalize(decode_normal(vec4(encoded_normal, 0., 0.)));
+  return normalize(normalValue);
+}
+vec3 DecodeViewPos(vec2 uv)
+{
+  vec2 depth = texture2D(_MainTex, uv).xy;
+  vec4 inv_proj = _InverseProjMatrix * vec4(vUv * 2.0 - 1.0, 1.0, 1.0);
+  return DecodeFloatRG(depth) * (vRay.xyz/vRay.w);
+  
+}
+
+
+
+
+void main()
+{
+
+  vec2 noiseScale = vec2(_Resolution.x/4.0,_Resolution.y/4.0); // noise texture 4x4
+
+  vec3 fragPos   = DecodeViewPos(vUv);
+  vec3 normal    = DecodeNormal(vUv);
+  vec3 randomVec = texture2D(_RandomRotation, vUv * noiseScale).xyz;
+  randomVec = vec3(randomVec.xy * 2.0 - 1.0, 0);
+  randomVec = normalize(randomVec);
+
+
+  vec3 tangent   = normalize(randomVec - normal * dot(randomVec, normal));
+  vec3 bitangent = normalize(cross(normal, tangent));
+  mat3 TBN       = mat3(tangent, bitangent, normal); 
+
+
+  float occlusion = 0.0;
+  const int kernelSize = 64;
+
+
+  for(int i = 0; i < kernelSize; ++i)
+  {
+      // get sample position
+      vec3 sample = TBN * _SampleKernel[i]; // From tangent to view-space
+      sample = fragPos + sample * _Radius; 
+      vec4 projPos = _ProjectionMatrix * vec4(sample, 1.0);
+      vec2 screenPos = projPos.xy / projPos.w;
+      screenPos = screenPos * 0.5 +0.5;
+
+      float sampled_depth = DecodeViewPos(screenPos).z;
+      float rangeCheck = smoothstep(0.0, 1.0, _Radius / abs(fragPos.z - sampled_depth));
+      occlusion += step(sample.z+_Bias, sampled_depth) * rangeCheck;         
+      
+  } 
+  occlusion = (occlusion / float(kernelSize));
+  gl_FragColor.rgb = vec3(occlusion,occlusion,occlusion); 
+  gl_FragColor.a = 1.0; 
+
+
+}

package/src/shaders/ssao/ssao.vert

@@ -0,0 +1,11 @@
+varying vec2 vUv;
+varying vec4 vRay;
+
+uniform mat4 _InverseProjMatrix;
+
+void main()
+{
+	gl_Position = vec4(uv * 2.0 - 1.0, 1.0, 1.0);
+	vRay = _InverseProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
+	vUv = uv;
+}