<canvas id="webgl" width="500" height="1758"></canvas> 

<script id="vertexShader" type="x-shader/x-vertex">
  attribute vec4 a_position;
  
  uniform mat4 u_modelViewMatrix;
  uniform mat4 u_projectionMatrix;
  
  void main() {
    gl_Position = a_position;
  }
</script>
<script id="fragmentShader" type="x-shader/x-fragment">
 precision highp float;
  precision highp int;
  
  uniform vec2 u_resolution;
  uniform vec2 u_mouse;
  uniform float u_time;
  uniform sampler2D u_noise;
  
  // movement variables
  vec3 movement = vec3(.0);
  
  const int maxIterations = 128;
  const float stopThreshold = 0.001;
  const float stepScale = .1;
  const float eps = 0.005;
  const vec3 clipColour = vec3(0.);
  const vec3 fogColour = vec3(0.);
  
  struct Surface {
    int object_id;
    float distance;
    vec3 position;
    vec3 colour;
    float ambient;
    float spec;
  };
  
  float mod289(float 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 perm(vec4 x){return mod289(((x * 34.0) + 1.0) * x);}

  float noise(vec3 p){
      vec3 a = floor(p);
      vec3 d = p - a;
      d = d * d * (3.0 - 2.0 * d);

      vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
      vec4 k1 = perm(b.xyxy);
      vec4 k2 = perm(k1.xyxy + b.zzww);

      vec4 c = k2 + a.zzzz;
      vec4 k3 = perm(c);
      vec4 k4 = perm(c + 1.0);

      vec4 o1 = fract(k3 * (1.0 / 41.0));
      vec4 o2 = fract(k4 * (1.0 / 41.0));

      vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
      vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);

      return o4.y * d.y + o4.x * (1.0 - d.y);
  }
  
  mat2 rot;
  
  // This function describes the world in distances from any given 3 dimensional point in space
  float world(in vec3 position, inout int object_id) {
    position.xz *= rot;
    vec3 pos = floor(position * .5);
    float n = noise(position*20.);
    object_id = int(floor((pos.x + pos.y + pos.z)));
    // position = mod(position, 1.) - .5;
    return length(position) - .3 + n*.2;
  }
  float world(in vec3 position, inout int object_id, inout float n) {
    position.xz *= rot;
    vec3 pos = floor(position * .5);
    
    n = noise(position*20.)*.5;
    object_id = int(floor((pos.x + pos.y + pos.z)));
    // position = mod(position, 1.) - .5;
    return length(position) - .3 + n*.2;
  }
  float world(in vec3 position) {
    int dummy = 0;
    return world(position, dummy);
  }
  
  vec3 getObjectColour(int object_id) {
    float modid = mod(float(object_id), 5.);
    if(modid == 0.) {
      return vec3(.0, 0., 0.5);
    } else if(modid == 1.) {
      return vec3(.5, 0.5, 0.);
    } else if(modid == 2.) {
      return vec3(.5, 0.5, 0.5);
    } else if(modid == 3.) {
      return vec3(.0, 0.5, 0.5);
    } else if(modid == 4.) {
      return vec3(.0, 0.5, 0.);
    }
    return vec3(.5, 0., 0.);
  }
  
  Surface getSurface(int object_id, float rayDepth, vec3 sp) {
    return Surface(
      object_id, 
      rayDepth, 
      sp, 
      getObjectColour(object_id), 
      .5, 
      200.);
  }
  
  // Calculated the normal of any given point in space. Intended to be cast from the point of a surface
  vec3 calculate_normal(in vec3 position) {
    vec3 grad = vec3(
      world(vec3(position.x + eps, position.y, position.z)) - world(vec3(position.x - eps, position.y, position.z)),
      world(vec3(position.x, position.y + eps, position.z)) - world(vec3(position.x, position.y - eps, position.z)),
      world(vec3(position.x, position.y, position.z + eps)) - world(vec3(position.x, position.y, position.z - eps))
    );
    
    return normalize(grad);
  }
  
  // The raymarch loop
  Surface rayMarch(vec3 ro, vec3 rd, float start, float end, inout vec3 sceneColour) {
    float sceneDist = 1e4;
    float rayDepth = start;
    int object_id = 0;
    float density = 0.;
    float steps = 0.;
    for(int i = 0; i < maxIterations; i++) {
      vec3 pos = ro + rd * rayDepth;
      float n = 0.;
      sceneDist = world(pos, object_id, n);
      
      steps += 1.;
      
      if(sceneDist < .05) {
        float localDensity = min(1. / abs(sceneDist*sceneDist*60.), 1.) * .1;
        localDensity = abs(min(sceneDist, 0.) * .1);
        float weightedDensity = pow(localDensity, 2.5)*2.;

        // sceneColour += mix(vec3(1.), vec3(0.5, .2, .3)*2., sin(cos(pos*5.)*.2* (n*20.))) * weightedDensity;
        sceneColour += (localDensity*localDensity*1000.);
        density += localDensity;
      }
      
      if(rayDepth > end) {
        break;
      }
      
      if(sceneDist < stopThreshold) {
        rayDepth += .002;
      } else {
        rayDepth += sceneDist * stepScale;
      }
    }
    
    sceneColour = (sceneColour);
    // sceneColour = pow(1./sceneColour, vec3(1./steps));
    
    return getSurface(object_id, rayDepth, ro + rd * rayDepth);
  }
  
  vec3 path(float z) {
    return vec3(0,0,0.);
    return vec3(0,0,-100.+z);
  }

  void main() {
    vec2 uv = (gl_FragCoord.xy - 0.5 * u_resolution.xy) / min(u_resolution.y, u_resolution.x);
    
    float delta = u_time;
    if(abs(u_mouse.x) > 0. ) {
      delta = u_mouse.x * 10.;
    }
    
    float s = sin(delta);
    float c = cos(delta);
    rot = mat2(c, -s, s, c);
    
    // movement
    movement = path(u_time);
    
    // Camera and look-at
    vec3 cam = vec3(1,1,-2)*(1.-u_mouse.y*2.);
    vec3 lookAt = vec3(0,0,0);
    
    // add movement
    lookAt += movement;
    cam += movement;
    
    // Unit vectors
    vec3 forward = normalize(lookAt - cam);
    vec3 right = normalize(vec3(forward.z, 0., -forward.x));
    vec3 up = normalize(cross(forward, right));
    
    // FOV
    float FOV = .4;
    
    // Ray origin and ray direction
    vec3 ro = cam;
    vec3 rd = normalize(forward + FOV * uv.x * right + FOV * uv.y * up);
    
    // Ray marching
    const float clipNear = 0.;
    const float clipFar = 32.;
    vec3 sceneColour = vec3(0.);
    Surface objectSurface = rayMarch(ro, rd, clipNear, clipFar, sceneColour);
//     if(objectSurface.distance > clipFar) {
//       gl_FragColor = vec4(clipColour, 1.);
//       return;
//     }
    
//     vec3 sceneColour = lighting(objectSurface, cam);
    // vec3 sceneColour = vec3(dist*.1);
    
    gl_FragColor = vec4(sceneColour, 1.);
  }
  
</script>