danabr75-ashton 0.1.5

data/lib/ashton/shaders/include/noise2d.glsl

@@ -0,0 +1,70 @@
+//
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+// 
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x*34.0)+1.0)*x);
+}
+
+float snoise(vec2 v)
+  {
+  const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+                      0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+                     -0.577350269189626,  // -1.0 + 2.0 * C.x
+                      0.024390243902439); // 1.0 / 41.0
+// First corner
+  vec2 i  = floor(v + dot(v, C.yy) );
+  vec2 x0 = v -   i + dot(i, C.xx);
+
+// Other corners
+  vec2 i1;
+  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+  //i1.y = 1.0 - i1.x;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  // x0 = x0 - 0.0 + 0.0 * C.xx ;
+  // x1 = x0 - i1 + 1.0 * C.xx ;
+  // x2 = x0 - 1.0 + 2.0 * C.xx ;
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+// Permutations
+  i = mod289(i); // Avoid truncation effects in permutation
+  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+        + i.x + vec3(0.0, i1.x, 1.0 ));
+
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m ;
+  m = m*m ;
+
+// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+// Normalise gradients implicitly by scaling m
+// Approximation of: m *= inversesqrt( a0*a0 + h*h );
+  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
+
+// Compute final noise value at P
+  vec3 g;
+  g.x  = a0.x  * x0.x  + h.x  * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}

data/lib/ashton/shaders/include/noise3d.glsl

@@ -0,0 +1,102 @@
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex 
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+// 
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 mod289(vec4 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 permute(vec4 x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+
+vec4 taylorInvSqrt(vec4 r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+float snoise(vec3 v)
+  { 
+  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
+  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
+
+// First corner
+  vec3 i  = floor(v + dot(v, C.yyy) );
+  vec3 x0 =   v - i + dot(i, C.xxx) ;
+
+// Other corners
+  vec3 g = step(x0.yzx, x0.xyz);
+  vec3 l = 1.0 - g;
+  vec3 i1 = min( g.xyz, l.zxy );
+  vec3 i2 = max( g.xyz, l.zxy );
+
+  //   x0 = x0 - 0.0 + 0.0 * C.xxx;
+  //   x1 = x0 - i1  + 1.0 * C.xxx;
+  //   x2 = x0 - i2  + 2.0 * C.xxx;
+  //   x3 = x0 - 1.0 + 3.0 * C.xxx;
+  vec3 x1 = x0 - i1 + C.xxx;
+  vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+  vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
+
+// Permutations
+  i = mod289(i); 
+  vec4 p = permute( permute( permute( 
+             i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+           + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
+           + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
+
+// Gradients: 7x7 points over a square, mapped onto an octahedron.
+// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+  float n_ = 0.142857142857; // 1.0/7.0
+  vec3  ns = n_ * D.wyz - D.xzx;
+
+  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)
+
+  vec4 x_ = floor(j * ns.z);
+  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)
+
+  vec4 x = x_ *ns.x + ns.yyyy;
+  vec4 y = y_ *ns.x + ns.yyyy;
+  vec4 h = 1.0 - abs(x) - abs(y);
+
+  vec4 b0 = vec4( x.xy, y.xy );
+  vec4 b1 = vec4( x.zw, y.zw );
+
+  //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+  //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+  vec4 s0 = floor(b0)*2.0 + 1.0;
+  vec4 s1 = floor(b1)*2.0 + 1.0;
+  vec4 sh = -step(h, vec4(0.0));
+
+  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
+  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
+
+  vec3 p0 = vec3(a0.xy,h.x);
+  vec3 p1 = vec3(a0.zw,h.y);
+  vec3 p2 = vec3(a1.xy,h.z);
+  vec3 p3 = vec3(a1.zw,h.w);
+
+//Normalise gradients
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+
+// Mix final noise value
+  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+  m = m * m;
+  return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 
+                                dot(p2,x2), dot(p3,x3) ) );
+  }

data/lib/ashton/shaders/include/noise4d.glsl

@@ -0,0 +1,128 @@
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex 
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+// 
+
+vec4 mod289(vec4 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0; }
+
+float mod289(float x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0; }
+
+vec4 permute(vec4 x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+
+float permute(float x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+
+vec4 taylorInvSqrt(vec4 r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+float taylorInvSqrt(float r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+vec4 grad4(float j, vec4 ip)
+  {
+  const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0);
+  vec4 p,s;
+
+  p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0;
+  p.w = 1.5 - dot(abs(p.xyz), ones.xyz);
+  s = vec4(lessThan(p, vec4(0.0)));
+  p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www; 
+
+  return p;
+  }
+						
+// (sqrt(5) - 1)/4 = F4, used once below
+#define F4 0.309016994374947451
+
+float snoise(vec4 v)
+  {
+  const vec4  C = vec4( 0.138196601125011,  // (5 - sqrt(5))/20  G4
+                        0.276393202250021,  // 2 * G4
+                        0.414589803375032,  // 3 * G4
+                       -0.447213595499958); // -1 + 4 * G4
+
+// First corner
+  vec4 i  = floor(v + dot(v, vec4(F4)) );
+  vec4 x0 = v -   i + dot(i, C.xxxx);
+
+// Other corners
+
+// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+  vec4 i0;
+  vec3 isX = step( x0.yzw, x0.xxx );
+  vec3 isYZ = step( x0.zww, x0.yyz );
+//  i0.x = dot( isX, vec3( 1.0 ) );
+  i0.x = isX.x + isX.y + isX.z;
+  i0.yzw = 1.0 - isX;
+//  i0.y += dot( isYZ.xy, vec2( 1.0 ) );
+  i0.y += isYZ.x + isYZ.y;
+  i0.zw += 1.0 - isYZ.xy;
+  i0.z += isYZ.z;
+  i0.w += 1.0 - isYZ.z;
+
+  // i0 now contains the unique values 0,1,2,3 in each channel
+  vec4 i3 = clamp( i0, 0.0, 1.0 );
+  vec4 i2 = clamp( i0-1.0, 0.0, 1.0 );
+  vec4 i1 = clamp( i0-2.0, 0.0, 1.0 );
+
+  //  x0 = x0 - 0.0 + 0.0 * C.xxxx
+  //  x1 = x0 - i1  + 1.0 * C.xxxx
+  //  x2 = x0 - i2  + 2.0 * C.xxxx
+  //  x3 = x0 - i3  + 3.0 * C.xxxx
+  //  x4 = x0 - 1.0 + 4.0 * C.xxxx
+  vec4 x1 = x0 - i1 + C.xxxx;
+  vec4 x2 = x0 - i2 + C.yyyy;
+  vec4 x3 = x0 - i3 + C.zzzz;
+  vec4 x4 = x0 + C.wwww;
+
+// Permutations
+  i = mod289(i); 
+  float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);
+  vec4 j1 = permute( permute( permute( permute (
+             i.w + vec4(i1.w, i2.w, i3.w, 1.0 ))
+           + i.z + vec4(i1.z, i2.z, i3.z, 1.0 ))
+           + i.y + vec4(i1.y, i2.y, i3.y, 1.0 ))
+           + i.x + vec4(i1.x, i2.x, i3.x, 1.0 ));
+
+// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+  vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ;
+
+  vec4 p0 = grad4(j0,   ip);
+  vec4 p1 = grad4(j1.x, ip);
+  vec4 p2 = grad4(j1.y, ip);
+  vec4 p3 = grad4(j1.z, ip);
+  vec4 p4 = grad4(j1.w, ip);
+
+// Normalise gradients
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+  p4 *= taylorInvSqrt(dot(p4,p4));
+
+// Mix contributions from the five corners
+  vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0);
+  vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4)            ), 0.0);
+  m0 = m0 * m0;
+  m1 = m1 * m1;
+  return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))
+               + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;
+
+  }

data/lib/ashton/shaders/include/rand.glsl

@@ -0,0 +1,5 @@
+// Random number generator (not brilliant, but it is quick).
+
+float rand(vec2 co) {
+	return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}

data/lib/ashton/shaders/lighting/distort.frag

@@ -0,0 +1,57 @@
+#version 110
+
+// Based on Catalin Zima's shader based dynamic shadows system.
+// http://www.catalinzima.com/2010/07/my-technique-for-the-shader-based-dynamic-2d-shadows/
+
+// Distort the input (square) texture into sight-lines, then reduce horizontally into a 2-pixel wide shadow-map texture.
+
+const float MIN_ALPHA_TO_CAST_SHADOW = 0.3; // Ignore mostly transparent pixels.
+
+uniform sampler2D in_Texture; // Texture containing shadow-casting shapes.
+uniform int in_TextureWidth; // Texture must be square, but can be any size divisible by 2.
+
+varying vec2 var_TexCoord; // Pixel to process on this pass.
+
+vec4 distort(in vec2 coord)
+{
+    // Translate u and v into [-1 , 1] domain
+    float u0 = coord.x * 2.0 - 1.0;
+    float v0 = (1.0 - coord.y) * 2.0 - 1.0; // Inverted because Gosu Y-coordinate is "inverted".
+
+    // Then, as u0 approaches 0 (the center), v should also approach 0
+    v0 = v0 * abs(u0);
+
+    // Convert back from [-1,1] domain to [0,1] domain
+    v0 = (v0 + 1.0) / 2.0;
+
+    v0 = 1.0 - v0;
+
+    // We now have the coordinates for reading from the initial image
+    vec2 newCoords = vec2(coord.x, v0);
+
+    // Read for both horizontal and vertical direction and store them in separate channels
+    float horizontal = texture2D(in_Texture, newCoords).a;
+    float distanceH = (horizontal > MIN_ALPHA_TO_CAST_SHADOW ? length(newCoords - 0.5) : 1.0);
+
+    float vertical = texture2D(in_Texture, newCoords.yx).a;
+    float distanceV = (vertical > MIN_ALPHA_TO_CAST_SHADOW ? length(newCoords - 0.5) : 1.0);
+
+    return vec4(distanceH, distanceV, 0.0, 1.0);
+}
+
+void main()
+{
+    float pixel_width = 1.0 / float(in_TextureWidth);
+    int half_width = in_TextureWidth / 2;
+
+    // Get the left-most pixel.
+    gl_FragColor = distort(var_TexCoord);
+
+    // Grab each pixel to the right in turn and min it with the previous one.
+    for(int i = 1; i < half_width; i++)
+    {
+        vec2 color = distort(var_TexCoord + vec2(pixel_width * float(i), 0)).rg;
+
+        gl_FragColor.rg = min(gl_FragColor.rg, color.rg);
+    }
+}

data/lib/ashton/shaders/lighting/draw_shadows.frag

@@ -0,0 +1,60 @@
+#version 110
+
+// Based on Catalin Zima's shader based dynamic shadows system.
+// http://www.catalinzima.com/2010/07/my-technique-for-the-shader-based-dynamic-2d-shadows/
+
+uniform sampler2D in_Texture; // Shadow map texture.
+
+uniform int in_TextureWidth;
+
+varying vec2 var_TexCoord; // Pixel to process on this pass.
+
+// coord x and y should be inverted when reading vertical distortion.
+vec4 GetShadowDistances(in vec2 coord)
+{
+		float u = coord.x;
+		float v = coord.y;
+		
+		u = abs(u - 0.5) * 2.0;
+		v = v * 2.0 - 1.0;
+		float v0 = v / u;
+		v0 = (v0 + 1.0) / 2.0;
+		
+		vec2 newCoords = vec2(coord.x, v0);
+
+		return texture2D(in_Texture, newCoords);
+}
+
+void main()
+{
+	  // Distance of this pixel from the center.
+	  float distance = length(var_TexCoord - 0.5);
+
+	  // Apply a 2-pixel bias, so we can see the edge of shadow-caster.
+	  distance -= 2.0 / float(in_TextureWidth);
+
+	  //distance stored in the shadow map
+	  float shadowMapDistance;
+
+	  // Coords in [-1,1]
+	  float nY = 2.0 * (var_TexCoord.y - 0.5);
+	  float nX = 2.0 * (var_TexCoord.x - 0.5);
+
+	  // We use these to determine which quadrant we are in.
+	  if(abs(nY) < abs(nX))
+	  {
+	    // Horizontal distance was stored in the Red component.
+		shadowMapDistance = GetShadowDistances(var_TexCoord).r;
+	  }
+	  else
+	  {
+	    // Vertical distance was stored in the Green component.
+	    shadowMapDistance = GetShadowDistances(var_TexCoord.yx).g;
+	  }
+
+	  // If distance to this pixel is lower than distance from shadowMap,
+	  // then we are not in shadow.
+	  float light = (distance < shadowMapDistance) ? 1.0 : 0.0;
+
+	  gl_FragColor = vec4(vec2(light), length(var_TexCoord - 0.5), 1.0);
+}

data/lib/ashton/shaders/lighting/shadow_blur.frag

@@ -0,0 +1,60 @@
+#version 110
+
+// Based on Catalin Zima's shader based dynamic shadows system.
+// http://www.catalinzima.com/2010/07/my-technique-for-the-shader-based-dynamic-2d-shadows/
+
+
+const float minBlur = 0.0;
+const float maxBlur = 5.0; // TODO: Make this a uniform?
+const int blurSamples = 13;
+
+uniform sampler2D in_Texture; // Original texture.
+uniform int in_TextureWidth;
+
+varying vec2 var_TexCoord; // Pixel to process on this pass.
+
+void main()
+{
+    vec2 offsetAndWeight[blurSamples];
+
+    offsetAndWeight[0] = vec2( 0.0, 0.199471);
+    offsetAndWeight[1] = vec2( 1.0, 0.176033);
+    offsetAndWeight[2] = vec2( 2.0, 0.120985);
+    offsetAndWeight[3] = vec2( 3.0, 0.064759);
+    offsetAndWeight[4] = vec2( 4.0, 0.026995);
+    offsetAndWeight[5] = vec2( 5.0, 0.008764);
+    offsetAndWeight[6] = vec2( 6.0, 0.002216);
+
+    vec4 color = texture2D(in_Texture, var_TexCoord);
+    float distance = color.b;
+    float pixel_width = 1.0 / float(in_TextureWidth);
+
+    // Take a reading from the center pixel once,
+    // but multiply since it would be added twice in the loop.
+    float sum = color.r * offsetAndWeight[0].y * 2.0;
+
+    for (int i = 1; i < blurSamples; i++)
+    {
+        float offset = offsetAndWeight[i].x;
+        float weight = offsetAndWeight[i].y;
+
+        offset *= pixel_width * mix(minBlur, maxBlur, distance);
+
+        // Take colour from above, below, left and right at once.
+        float effect = texture2D(in_Texture, var_TexCoord + vec2( offset,     0.0)).r +
+                       texture2D(in_Texture, var_TexCoord + vec2(-offset,     0.0)).r +
+                       texture2D(in_Texture, var_TexCoord + vec2(    0.0,  offset)).r +
+                       texture2D(in_Texture, var_TexCoord + vec2(    0.0, -offset)).r;
+
+        sum += effect * weight;
+    }
+
+    // Halve the sum, since we have applied horizontal and vertical at once.
+    sum *= 0.5;
+
+    // Light is brighter at the center.
+    float d = 2.0 * length(var_TexCoord - 0.5);
+    float attenuation = clamp(1.0 - d, 0.0, 1.0);
+
+    gl_FragColor = vec4(vec3(sum * attenuation), 1.0);
+}