ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/shaders/data/blur.glsl

@@ -0,0 +1,42 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture;
+uniform vec2 texOffset;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+void main(void) {
+  // Grouping texcoord variables in order to make it work in the GMA 950. See post #13
+  // in this thread:
+  // http://www.idevgames.com/forums/thread-3467.html
+  vec2 tc0 = vertTexCoord.st + vec2(-texOffset.s, -texOffset.t);
+  vec2 tc1 = vertTexCoord.st + vec2(         0.0, -texOffset.t);
+  vec2 tc2 = vertTexCoord.st + vec2(+texOffset.s, -texOffset.t);
+  vec2 tc3 = vertTexCoord.st + vec2(-texOffset.s,          0.0);
+  vec2 tc4 = vertTexCoord.st + vec2(         0.0,          0.0);
+  vec2 tc5 = vertTexCoord.st + vec2(+texOffset.s,          0.0);
+  vec2 tc6 = vertTexCoord.st + vec2(-texOffset.s, +texOffset.t);
+  vec2 tc7 = vertTexCoord.st + vec2(         0.0, +texOffset.t);
+  vec2 tc8 = vertTexCoord.st + vec2(+texOffset.s, +texOffset.t);
+
+  vec4 col0 = texture2D(texture, tc0);
+  vec4 col1 = texture2D(texture, tc1);
+  vec4 col2 = texture2D(texture, tc2);
+  vec4 col3 = texture2D(texture, tc3);
+  vec4 col4 = texture2D(texture, tc4);
+  vec4 col5 = texture2D(texture, tc5);
+  vec4 col6 = texture2D(texture, tc6);
+  vec4 col7 = texture2D(texture, tc7);
+  vec4 col8 = texture2D(texture, tc8);
+
+  vec4 sum = (1.0 * col0 + 2.0 * col1 + 1.0 * col2 +  
+              2.0 * col3 + 4.0 * col4 + 2.0 * col5 +
+              1.0 * col6 + 2.0 * col7 + 1.0 * col8) / 16.0;            
+  gl_FragColor = vec4(sum.rgb, 1.0) * vertColor;  
+}

data/samples/processing_app/topics/shaders/data/bwfrag.glsl

@@ -0,0 +1,23 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+const vec4 lumcoeff = vec4(0.299, 0.587, 0.114, 0);
+
+void main() {
+  vec4 col = texture2D(texture, vertTexCoord.st);
+  float lum = dot(col, lumcoeff);
+  if (0.5 < lum) {
+    gl_FragColor = vertColor;
+  } else {
+    gl_FragColor = vec4(0, 0, 0, 1);
+  }     
+}

data/samples/processing_app/topics/shaders/data/conway.glsl

@@ -0,0 +1,57 @@
+// Conway's game of life
+
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#define PROCESSING_COLOR_SHADER
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+uniform sampler2D buffer;
+
+vec4 live = vec4(0.5,1.0,0.7,1.);
+vec4 dead = vec4(0.,0.,0.,1.);
+vec4 blue = vec4(0.,0.,1.,1.);
+
+void main( void ) {
+	vec2 position = ( gl_FragCoord.xy / resolution.xy );
+	vec2 pixel = 1./resolution;
+
+	if (length(position-mouse) < 0.01) {
+		float rnd1 = mod(fract(sin(dot(position + time * 0.001, vec2(14.9898,78.233))) * 43758.5453), 1.0);
+		if (rnd1 > 0.5) {
+			gl_FragColor = live;
+		} else {
+			gl_FragColor = blue;
+		}
+	} else {
+		float sum = 0.;
+		sum += texture2D(buffer, position + pixel * vec2(-1., -1.)).g;
+		sum += texture2D(buffer, position + pixel * vec2(-1., 0.)).g;
+		sum += texture2D(buffer, position + pixel * vec2(-1., 1.)).g;
+		sum += texture2D(buffer, position + pixel * vec2(1., -1.)).g;
+		sum += texture2D(buffer, position + pixel * vec2(1., 0.)).g;
+		sum += texture2D(buffer, position + pixel * vec2(1., 1.)).g;
+		sum += texture2D(buffer, position + pixel * vec2(0., -1.)).g;
+		sum += texture2D(buffer, position + pixel * vec2(0., 1.)).g;
+		vec4 me = texture2D(buffer, position);
+
+		if (me.g <= 0.1) {
+			if ((sum >= 2.9) && (sum <= 3.1)) {
+				gl_FragColor = live;
+			} else if (me.b > 0.004) {
+				gl_FragColor = vec4(0., 0., max(me.b - 0.004, 0.25), 0.);
+			} else {
+				gl_FragColor = dead;
+			}
+		} else {
+			if ((sum >= 1.9) && (sum <= 3.1)) {
+				gl_FragColor = live;
+			} else {
+				gl_FragColor = blue;
+			}
+		}
+	}
+}

data/samples/processing_app/topics/shaders/data/cubemapfrag.glsl

@@ -0,0 +1 @@
+uniform samplerCube cubemap;
  vec3 color = vec3(textureCube(cubemap, reflectDir));
  gl_FragColor = vec4(color, 1.0);      

data/samples/processing_app/topics/shaders/data/cubemapvert.glsl

@@ -0,0 +1 @@
+uniform mat4 transform;
  gl_Position = transform * vertex;
    
  vec3 ecNormal = normalize(normalMatrix * normal); // Vertex in eye coordinates
  vec3 ecVertex = vec3(modelview * vertex); // Normal vector in eye coordinates
  vec3 eyeDir = ecVertex.xyz;
  reflectDir = reflect(eyeDir, ecNormal);

data/samples/processing_app/topics/shaders/data/deform.glsl

@@ -0,0 +1,31 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture;
+
+uniform float time;
+uniform vec2 resolution;
+uniform vec2 mouse;
+
+void main(void) {
+  vec2 p = -1.0 + 2.0 * gl_FragCoord.xy / resolution.xy;
+  vec2 m = -1.0 + 2.0 * mouse.xy / resolution.xy;
+
+  float a1 = atan(p.y - m.y, p.x - m.x);
+  float r1 = sqrt(dot(p - m, p - m));
+  float a2 = atan(p.y + m.y, p.x + m.x);
+  float r2 = sqrt(dot(p + m, p + m));
+
+  vec2 uv;
+  uv.x = 0.2 * time + (r1 - r2) * 0.25;
+  uv.y = sin(2.0 * (a1 - a2));
+
+  float w = r1 * r2 * 0.8;
+  vec3 col = texture2D(texture, 0.5 - 0.495 * uv).xyz;
+
+  gl_FragColor = vec4(col / (0.1 + w), 1.0);
+}

data/samples/processing_app/topics/shaders/data/displaceFrag.glsl

@@ -0,0 +1,8 @@
+
+uniform sampler2D colorMap;
+
+varying vec4 vertTexCoord;
+
+void main() {
+  gl_FragColor = texture2D(colorMap, vertTexCoord.st);
+}

data/samples/processing_app/topics/shaders/data/displaceVert.glsl

@@ -0,0 +1,201 @@
+
+#define PROCESSING_TEXLIGHT_SHADER
+
+uniform mat4 modelview;
+uniform mat4 transform;
+uniform mat3 normalMatrix;
+uniform mat4 texMatrix;
+
+uniform int lightCount;
+uniform vec4 lightPosition[8];
+uniform vec3 lightNormal[8];
+uniform vec3 lightAmbient[8];
+uniform vec3 lightDiffuse[8];
+uniform vec3 lightSpecular[8];
+uniform vec3 lightFalloff[8];
+uniform vec2 lightSpot[8];
+
+attribute vec4 vertex;
+attribute vec4 color;
+attribute vec3 normal;
+attribute vec2 texCoord;
+
+attribute vec4 ambient;
+attribute vec4 specular;
+attribute vec4 emissive;
+attribute float shininess;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+const float zero_float = 0.0;
+const float one_float = 1.0;
+const vec3 zero_vec3 = vec3(0);
+
+uniform float displaceStrength;
+uniform float time;
+
+float falloffFactor(vec3 lightPos, vec3 vertPos, vec3 coeff) {
+  vec3 lpv = lightPos - vertPos;
+  vec3 dist = vec3(one_float);
+  dist.z = dot(lpv, lpv);
+  dist.y = sqrt(dist.z);
+  return one_float / dot(dist, coeff);
+}
+
+float spotFactor(vec3 lightPos, vec3 vertPos, vec3 lightNorm, float minCos, float spotExp) {
+  vec3 lpv = normalize(lightPos - vertPos);
+  vec3 nln = -one_float * lightNorm;
+  float spotCos = dot(nln, lpv);
+  return spotCos <= minCos ? zero_float : pow(spotCos, spotExp);
+}
+
+float lambertFactor(vec3 lightDir, vec3 vecNormal) {
+  return max(zero_float, dot(lightDir, vecNormal));
+}
+
+float blinnPhongFactor(vec3 lightDir, vec3 vertPos, vec3 vecNormal, float shine) {
+  vec3 np = normalize(vertPos);
+  vec3 ldp = normalize(lightDir - np);
+  return pow(max(zero_float, dot(ldp, vecNormal)), shine);
+}
+
+// Source code for GLSL Perlin noise courtesy of:
+// https://github.com/ashima/webgl-noise/wiki
+
+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);
+}
+
+void main() {
+  // Calculating texture coordinates, with r and q set both to one
+  vertTexCoord = texMatrix * vec4(texCoord, 1.0, 1.0);
+
+  vec2 p = texCoord; // put coordinates into vec2 p for convenience
+  p.x += time; // add time to make the noise and the subsequent displacement move
+  float df = snoise( p ); // create displacement float value from shader-based 2D Perlin noise
+  vec4 newVertexPos = vertex + vec4(normal * df * displaceStrength, 0.0); // regular vertex position + direction * displacementMap * displaceStrength
+
+  // Vertex in clip coordinates
+  gl_Position = transform * newVertexPos;
+    
+  // Vertex in eye coordinates
+  vec3 ecVertex = vec3(modelview * vertex);
+  
+  // Normal vector in eye coordinates
+  vec3 ecNormal = normalize(normalMatrix * normal);
+  
+  if (dot(-one_float * ecVertex, ecNormal) < zero_float) {
+    // If normal is away from camera, choose its opposite.
+    // If we add backface culling, this will be backfacing
+    ecNormal *= -one_float;
+  }
+
+  // Light calculations
+  vec3 totalAmbient = vec3(0, 0, 0);
+  vec3 totalDiffuse = vec3(0, 0, 0);
+  vec3 totalSpecular = vec3(0, 0, 0);
+  for (int i = 0; i < 8; i++) {
+    if (lightCount == i) break;
+    
+    vec3 lightPos = lightPosition[i].xyz;
+    bool isDir = zero_float < lightPosition[i].w;
+    float spotCos = lightSpot[i].x;
+    float spotExp = lightSpot[i].y;
+    
+    vec3 lightDir;
+    float falloff;
+    float spotf;
+      
+    if (isDir) {
+      falloff = one_float;
+      lightDir = -one_float * lightNormal[i];
+    } else {
+      falloff = falloffFactor(lightPos, ecVertex, lightFalloff[i]);
+      lightDir = normalize(lightPos - ecVertex);
+    }
+  
+    spotf = spotExp > zero_float ? spotFactor(lightPos, ecVertex, lightNormal[i],
+                                              spotCos, spotExp)
+                                 : one_float;
+    
+    if (any(greaterThan(lightAmbient[i], zero_vec3))) {
+      totalAmbient += lightAmbient[i] * falloff;
+    }
+    
+    if (any(greaterThan(lightDiffuse[i], zero_vec3))) {
+      totalDiffuse += lightDiffuse[i] * falloff * spotf *
+                       lambertFactor(lightDir, ecNormal);
+    }
+    
+    if (any(greaterThan(lightSpecular[i], zero_vec3))) {
+      totalSpecular += lightSpecular[i] * falloff * spotf *
+                       blinnPhongFactor(lightDir, ecVertex, ecNormal, shininess);
+    }
+  }
+  
+  // Calculating final color as result of all lights (plus emissive term).
+  // Transparency is determined exclusively by the diffuse component.
+  vertColor = vec4(totalAmbient, 0) * ambient +
+              vec4(totalDiffuse, 1) * color +
+              vec4(totalSpecular, 0) * specular +
+              vec4(emissive.rgb, 0);
+              
+}

data/samples/processing_app/topics/shaders/data/edges.glsl

@@ -0,0 +1,40 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture;
+uniform vec2 texOffset;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+void main(void) {
+  // Grouping texcoord variables in order to make it work in the GMA 950. See post #13
+  // in this thread:
+  // http://www.idevgames.com/forums/thread-3467.html
+  vec2 tc0 = vertTexCoord.st + vec2(-texOffset.s, -texOffset.t);
+  vec2 tc1 = vertTexCoord.st + vec2(         0.0, -texOffset.t);
+  vec2 tc2 = vertTexCoord.st + vec2(+texOffset.s, -texOffset.t);
+  vec2 tc3 = vertTexCoord.st + vec2(-texOffset.s,          0.0);
+  vec2 tc4 = vertTexCoord.st + vec2(         0.0,          0.0);
+  vec2 tc5 = vertTexCoord.st + vec2(+texOffset.s,          0.0);
+  vec2 tc6 = vertTexCoord.st + vec2(-texOffset.s, +texOffset.t);
+  vec2 tc7 = vertTexCoord.st + vec2(         0.0, +texOffset.t);
+  vec2 tc8 = vertTexCoord.st + vec2(+texOffset.s, +texOffset.t);
+  
+  vec4 col0 = texture2D(texture, tc0);
+  vec4 col1 = texture2D(texture, tc1);
+  vec4 col2 = texture2D(texture, tc2);
+  vec4 col3 = texture2D(texture, tc3);
+  vec4 col4 = texture2D(texture, tc4);
+  vec4 col5 = texture2D(texture, tc5);
+  vec4 col6 = texture2D(texture, tc6);
+  vec4 col7 = texture2D(texture, tc7);
+  vec4 col8 = texture2D(texture, tc8);
+
+  vec4 sum = 8.0 * col4 - (col0 + col1 + col2 + col3 + col5 + col6 + col7 + col8); 
+  gl_FragColor = vec4(sum.rgb, 1.0) * vertColor;
+}

data/samples/processing_app/topics/shaders/data/java_args.txt

@@ -0,0 +1,2 @@
+-Djruby.ji.objectProxyCache=false -XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+

data/samples/processing_app/topics/shaders/data/landscape.glsl

@@ -0,0 +1,352 @@
+// Elevated shader
+// https://www.shadertoy.com/view/MdX3Rr by inigo quilez
+
+// Created by inigo quilez - iq/2013
+// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+
+// Processing port by Raphaël de Courville.
+
+#ifdef GL_ES
+precision highp float;
+#endif
+
+// Type of shader expected by Processing
+#define PROCESSING_COLOR_SHADER
+
+// Processing specific input
+uniform float time;
+uniform vec2 resolution;
+uniform vec2 mouse;
+
+// Layer between Processing and Shadertoy uniforms
+vec3 iResolution = vec3(resolution,0.0);
+float iGlobalTime = time;
+vec4 iMouse = vec4(mouse,0.0,0.0); // zw would normally be the click status
+
+// ------- Below is the unmodified Shadertoy code ----------
+// Created by inigo quilez - iq/2013
+// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+
+//stereo thanks to Croqueteer
+//#define STEREO 
+
+mat3 m = mat3( 0.00,  0.80,  0.60,
+              -0.80,  0.36, -0.48,
+              -0.60, -0.48,  0.64 );
+
+float hash( float n )
+{
+    return fract(sin(n)*43758.5453123);
+}
+
+
+float noise( in vec3 x )
+{
+    vec3 p = floor(x);
+    vec3 f = fract(x);
+
+    f = f*f*(3.0-2.0*f);
+
+    float n = p.x + p.y*57.0 + 113.0*p.z;
+
+    float res = mix(mix(mix( hash(n+  0.0), hash(n+  1.0),f.x),
+                        mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y),
+                    mix(mix( hash(n+113.0), hash(n+114.0),f.x),
+                        mix( hash(n+170.0), hash(n+171.0),f.x),f.y),f.z);
+    return res;
+}
+
+
+
+
+vec3 noised( in vec2 x )
+{
+    vec2 p = floor(x);
+    vec2 f = fract(x);
+
+    vec2 u = f*f*(3.0-2.0*f);
+
+    float n = p.x + p.y*57.0;
+
+    float a = hash(n+  0.0);
+    float b = hash(n+  1.0);
+    float c = hash(n+ 57.0);
+    float d = hash(n+ 58.0);
+	return vec3(a+(b-a)*u.x+(c-a)*u.y+(a-b-c+d)*u.x*u.y,
+				30.0*f*f*(f*(f-2.0)+1.0)*(vec2(b-a,c-a)+(a-b-c+d)*u.yx));
+
+}
+
+float noise( in vec2 x )
+{
+    vec2 p = floor(x);
+    vec2 f = fract(x);
+
+    f = f*f*(3.0-2.0*f);
+
+    float n = p.x + p.y*57.0;
+
+    float res = mix(mix( hash(n+  0.0), hash(n+  1.0),f.x),
+                    mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y);
+
+    return res;
+}
+
+float fbm( vec3 p )
+{
+    float f = 0.0;
+
+    f += 0.5000*noise( p ); p = m*p*2.02;
+    f += 0.2500*noise( p ); p = m*p*2.03;
+    f += 0.1250*noise( p ); p = m*p*2.01;
+    f += 0.0625*noise( p );
+
+    return f/0.9375;
+}
+
+mat2 m2 = mat2(1.6,-1.2,1.2,1.6);
+	
+float fbm( vec2 p )
+{
+    float f = 0.0;
+
+    f += 0.5000*noise( p ); p = m2*p*2.02;
+    f += 0.2500*noise( p ); p = m2*p*2.03;
+    f += 0.1250*noise( p ); p = m2*p*2.01;
+    f += 0.0625*noise( p );
+
+    return f/0.9375;
+}
+
+float terrain( in vec2 x )
+{
+	vec2  p = x*0.003;
+    float a = 0.0;
+    float b = 1.0;
+	vec2  d = vec2(0.0);
+    for(int i=0;i<5; i++)
+    {
+        vec3 n = noised(p);
+        d += n.yz;
+        a += b*n.x/(1.0+dot(d,d));
+		b *= 0.5;
+        p=mat2(1.6,-1.2,1.2,1.6)*p;
+    }
+
+    return 140.0*a;
+}
+
+float terrain2( in vec2 x )
+{
+	vec2  p = x*0.003;
+    float a = 0.0;
+    float b = 1.0;
+	vec2  d = vec2(0.0);
+    for(int i=0;i<14; i++)
+    {
+        vec3 n = noised(p);
+        d += n.yz;
+        a += b*n.x/(1.0+dot(d,d));
+		b *= 0.5;
+        p=m2*p;
+    }
+
+    return 140.0*a;
+}
+
+
+float map( in vec3 p )
+{
+	float h = terrain(p.xz);
+	
+	float ss = 0.03;
+	float hh = h*ss;
+	float fh = fract(hh);
+	float ih = floor(hh);
+	fh = mix( sqrt(fh), fh, smoothstep(50.0,140.0,h) );
+	h = (ih+fh)/ss;
+	
+    return p.y - h;
+}
+
+float map2( in vec3 p )
+{
+	float h = terrain2(p.xz);
+
+	
+	float ss = 0.03;
+	float hh = h*ss;
+	float fh = fract(hh);
+	float ih = floor(hh);
+	fh = mix( sqrt(fh), fh, smoothstep(50.0,140.0,h) );
+	h = (ih+fh)/ss;
+	
+    return p.y - h;
+}
+
+bool jinteresct(in vec3 rO, in vec3 rD, out float resT )
+{
+    float h = 0.0;
+    float t = 0.0;
+	for( int j=0; j<120; j++ )
+	{
+        //if( t>2000.0 ) break;
+		
+	    vec3 p = rO + t*rD;
+if( p.y>300.0 ) break;
+        h = map( p );
+
+		if( h<0.1 )
+		{
+			resT = t; 
+			return true;
+		}
+		t += max(0.1,0.5*h);
+
+	}
+
+	if( h<5.0 )
+    {
+	    resT = t;
+	    return true;
+	}
+	return false;
+}
+
+float sinteresct(in vec3 rO, in vec3 rD )
+{
+    float res = 1.0;
+    float t = 0.0;
+	for( int j=0; j<50; j++ )
+	{
+        //if( t>1000.0 ) break;
+	    vec3 p = rO + t*rD;
+
+        float h = map( p );
+
+		if( h<0.1 )
+		{
+			return 0.0;
+		}
+		res = min( res, 16.0*h/t );
+		t += h;
+
+	}
+
+	return clamp( res, 0.0, 1.0 );
+}
+
+vec3 calcNormal( in vec3 pos, float t )
+{
+	float e = 0.001;
+	e = 0.001*t;
+    vec3  eps = vec3(e,0.0,0.0);
+    vec3 nor;
+    nor.x = map2(pos+eps.xyy) - map2(pos-eps.xyy);
+    nor.y = map2(pos+eps.yxy) - map2(pos-eps.yxy);
+    nor.z = map2(pos+eps.yyx) - map2(pos-eps.yyx);
+    return normalize(nor);
+}
+
+vec3 camPath( float time )
+{
+    vec2 p = 600.0*vec2( cos(1.4+0.37*time), 
+                         cos(3.2+0.31*time) );
+
+	return vec3( p.x, 0.0, p.y );
+}
+
+void main(void)
+{
+    vec2 xy = -1.0 + 2.0*gl_FragCoord.xy / iResolution.xy;
+
+	vec2 s = xy*vec2(1.75,1.0);
+
+	#ifdef STEREO
+	float isCyan = mod(gl_FragCoord.x + mod(gl_FragCoord.y,2.0),2.0);
+    #endif
+	
+    float time = iGlobalTime*.15;
+
+	vec3 light1 = normalize( vec3(  0.4, 0.22,  0.6 ) );
+	vec3 light2 = vec3( -0.707, 0.000, -0.707 );
+
+
+	vec3 campos = camPath( time );
+	vec3 camtar = camPath( time + 3.0 );
+	campos.y = terrain( campos.xz ) + 15.0;
+	camtar.y = campos.y*0.5;
+
+	float roll = 0.1*cos(0.1*time);
+	vec3 cw = normalize(camtar-campos);
+	vec3 cp = vec3(sin(roll), cos(roll),0.0);
+	vec3 cu = normalize(cross(cw,cp));
+	vec3 cv = normalize(cross(cu,cw));
+	vec3 rd = normalize( s.x*cu + s.y*cv + 1.6*cw );
+
+	#ifdef STEREO
+	campos += 2.0*cu*isCyan; // move camera to the right - the rd vector is still good
+    #endif
+
+	float sundot = clamp(dot(rd,light1),0.0,1.0);
+	vec3 col;
+    float t;
+    if( !jinteresct(campos,rd,t) )
+    {
+     	col = 0.9*vec3(0.97,.99,1.0)*(1.0-0.3*rd.y);
+		col += 0.2*vec3(0.8,0.7,0.5)*pow( sundot, 4.0 );
+	}
+	else
+	{
+		vec3 pos = campos + t*rd;
+
+        vec3 nor = calcNormal( pos, t );
+
+		float dif1 = clamp( dot( light1, nor ), 0.0, 1.0 );
+		float dif2 = clamp( 0.2 + 0.8*dot( light2, nor ), 0.0, 1.0 );
+		float sh = 1.0;
+		if( dif1>0.001 ) 
+			sh = sinteresct(pos+light1*20.0,light1);
+		
+		vec3 dif1v = vec3(dif1);
+		dif1v *= vec3( sh, sh*sh*0.5+0.5*sh, sh*sh );
+
+		float r = noise( 7.0*pos.xz );
+
+        col = (r*0.25+0.75)*0.9*mix( vec3(0.10,0.05,0.03), vec3(0.13,0.10,0.08), clamp(terrain2( vec2(pos.x,pos.y*48.0))/200.0,0.0,1.0) );
+		col = mix( col, 0.17*vec3(0.5,.23,0.04)*(0.50+0.50*r),smoothstep(0.70,0.9,nor.y) );
+        col = mix( col, 0.10*vec3(0.2,.30,0.00)*(0.25+0.75*r),smoothstep(0.95,1.0,nor.y) );
+  	    col *= 0.75;
+         // snow
+        #if 1
+		float h = smoothstep(55.0,80.0,pos.y + 25.0*fbm(0.01*pos.xz) );
+        float e = smoothstep(1.0-0.5*h,1.0-0.1*h,nor.y);
+        float o = 0.3 + 0.7*smoothstep(0.0,0.1,nor.x+h*h);
+        float s = h*e*o;
+        s = smoothstep( 0.1, 0.9, s );
+        col = mix( col, 0.4*vec3(0.6,0.65,0.7), s );
+        #endif
+
+		
+		vec3 brdf  = 2.0*vec3(0.17,0.19,0.20)*clamp(nor.y,0.0,1.0);
+		     brdf += 6.0*vec3(1.00,0.95,0.80)*dif1v;
+		     brdf += 2.0*vec3(0.20,0.20,0.20)*dif2;
+
+		col *= brdf;
+		
+		float fo = 1.0-exp(-pow(0.0015*t,1.5));
+		vec3 fco = vec3(0.7) + 0.6*vec3(0.8,0.7,0.5)*pow( sundot, 4.0 );
+		col = mix( col, fco, fo );
+	}
+
+	col = sqrt(col);
+
+	vec2 uv = xy*0.5+0.5;
+	col *= 0.7 + 0.3*pow(16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y),0.1);
+	
+    #ifdef STEREO	
+    col *= vec3( isCyan, 1.0-isCyan, 1.0-isCyan );	
+	#endif
+	
+	gl_FragColor=vec4(col,1.0);
+}