     //vec3 col = render( ro, rd );
 
     // castRay(ro, rd)
-    float tmin = .2;
-    float mat = -1.;
+    float tmin = .2, mat = -1.;
     for( float i=-32.; i<32.; i++ ) { // 64 = maxIterations
       vec2 rayRes = map( ro+rd*tmin );
       //float precis = .000001*tmin;

// time variable (seconds)
uniform float a;

/*
float calcPlasma(float x, float y, float z, float t) {
  // horizontal sinusoid
  float sine1 = sin(x * 10. + t * 2.);

  // rotating sinusoid
  float sine2 = sin(10. * (x * sin(t / 2.) + z * cos(t / 3.)) + t);

  // circular sinusoid
  float cx = x + .5 * sin(t / 5.);
  float cy = y + .5 * cos(t / 3.);
  float sine3 = sin(sqrt(100. * (cx * cx + cy * cy) + 1.) + t);

  float blend = sine1 + sine2 + sine3;

  //blend *= 1.0 + sin(t / 4.0) * 2.0;

  //blend *= 3.0;
  //blend = sin(blend * 3.14 / 2.) / 2. + .5;
  // =>
  blend = sin(5. * blend) / 2.;

  //blend = pow(blend, 2.0);

  return blend;
}
*/

/*
float calcPlasma(vec3 p) {
  return sin(5. *
    // horizontal sinusoid
    sin(p.x * 10. + a * 2.) +
    // rotating sinusoid
    sin(10. * (p.x * sin(a / 2.) + p.z * cos(a / 3.)) + a) +
    // circular sinusoid
    sin(sqrt(100. * (
      // cx
      pow(p.x + .5 * sin(a / 5.), 2.) +
      // cy
      pow(p.y + .5 * cos(a / 3.), 2.)
    ) + 1.) + a)
  ) / 2.;
}
*/

// t = time to start transition
// tt = transition length
// vec2 opMorph( vec2 d1, vec2 d2, float t, float tt ) {
//   float k = (a - t) / tt;
//
//   /*
//   k = min(1., k);
//   k = max(0., k);
//   */
//
//   k = clamp(0., k, 1.);
//
//   return vec2(
//     d1.x * (1. - k) + d2.x * k,
//     d1.y * (1. - k) + d2.y * k
//   );
// }

vec2 opU(vec2 d1, vec2 d2) {
  return d1.x<d2.x ? d1 : d2;
}

// float sdPlane(vec3 p) {
//   return p.y;
// }

// float sdSphere(vec3 p, float s) {
//   return length(p)-s;
// }

// float sdPlasmaSphere(vec3 p, float s) {
//   float plasma = calcPlasma(p);
//
//   return length(p)-s + plasma * sin(a / 100.0);
// }

// vec2 plasmaSphere(vec3 p) {
//   float plasma = calcPlasma(p);
//   plasma += 1.;
//   float hue = sin(plasma) * 100.0 + a;
//   // return vec2(sdPlasmaSphere(p, 0.5), hue);
//   return vec2(length(p)-.5 + plasma * sin(a / 100.0), hue);
// }

// vec2 plane(vec3 p) {
//   return vec2(sdPlane(p), 0.);
// }

// float sdPlasma(vec3 p) {
//   float plasma = calcPlasma(p.x, p.y, p.z, a / 10.0);
//   return plasma;
// }

// float sdTunnelThingPlasma(vec3 p) {
//   return (cos(p.x) + sin(p.y) + sin(p.z)) / 20.0 * (sin(a / 10.0) + 2.0);
// }

// vec2 fullScreenPlasma(vec3 p) {
//   // Full screen cool plasma thing (works best with tunnel thing at hue 0.0)
//   // works best with tmin = 0.2?
//   float plasma3 = calcPlasma(p.x, p.y, p.z, a);
//   float hue = sin(plasma3) * 100.0 + a * 100.0;
//   vec2 res = vec2(
//     sdTunnelThingPlasma(p),
//     hue / 3.0
//   );
//   return opU(res,
//     vec2(sdPlasma(p), hue)
//   );
// }

// SCENES
// vec2 scene0(vec3 pos) {
//   return opU(
//     float plasma = calcPlasma(p);
//     plasma += 1.;
//     float hue = sin(plasma) * 100.0 + a;
//     // return vec2(sdPlasmaSphere(p, 0.5), hue);
//     return vec2(length(p)-.5 + plasma * sin(a / 100.0), hue);
//     plasmaSphere(pos),
//     // plane
//     vec2(pos.y + .5, 0.)
//   );
// }

// vec2 scene1(vec3 pos) {
//   return fullScreenPlasma(pos);
// }

vec2 map(vec3 p) {
  float plasma = sin(5. *

      pow(p.y + .5 * cos(a / 3.), 2.)
    ) + 1.) + a)
  ) / 2.;

  return opU(
    // plasma sphere
