realityplayground-of/zoneb/bin/data/shaders/bound.frag

#ifdef GL_ES
precision mediump float;
#endif

uniform sampler2DRect   u_depth;
uniform sampler2DRect   u_ofcam;
uniform sampler2DRect   u_v4l2cam;
uniform sampler2DRect   u_buffer0;
uniform sampler2DRect   u_buffer1;

uniform vec2        u_resolution;
uniform vec2        u_mouse;
uniform float       u_time;

uniform bool        u_init;

varying vec2        v_texcoord;


vec3 random3(vec3 c) {
	float j = 4096.0*sin(dot(c,vec3(17.0, 59.4, 15.0)));
	vec3 r;
	r.z = fract(512.0*j);
	j *= .125;
	r.x = fract(512.0*j);
	j *= .125;
	r.y = fract(512.0*j);
	return r-0.5;
}

/* skew constants for 3d simplex functions */
const float F3 =  0.3333333;
const float G3 =  0.1666667;

/* 3d simplex noise */
float simplex3d(vec3 p) {
	 /* 1. find current tetrahedron T and it's four vertices */
	 /* s, s+i1, s+i2, s+1.0 - absolute skewed (integer) coordinates of T vertices */
	 /* x, x1, x2, x3 - unskewed coordinates of p relative to each of T vertices*/
	 
	 /* calculate s and x */
	 vec3 s = floor(p + dot(p, vec3(F3)));
	 vec3 x = p - s + dot(s, vec3(G3));
	 
	 /* calculate i1 and i2 */
	 vec3 e = step(vec3(0.0), x - x.yzx);
	 vec3 i1 = e*(1.0 - e.zxy);
	 vec3 i2 = 1.0 - e.zxy*(1.0 - e);
	 	
	 /* x1, x2, x3 */
	 vec3 x1 = x - i1 + G3;
	 vec3 x2 = x - i2 + 2.0*G3;
	 vec3 x3 = x - 1.0 + 3.0*G3;
	 
	 /* 2. find four surflets and store them in d */
	 vec4 w, d;
	 
	 /* calculate surflet weights */
	 w.x = dot(x, x);
	 w.y = dot(x1, x1);
	 w.z = dot(x2, x2);
	 w.w = dot(x3, x3);
	 
	 /* w fades from 0.6 at the center of the surflet to 0.0 at the margin */
	 w = max(0.6 - w, 0.0);
	 
	 /* calculate surflet components */
	 d.x = dot(random3(s), x);
	 d.y = dot(random3(s + i1), x1);
	 d.z = dot(random3(s + i2), x2);
	 d.w = dot(random3(s + 1.0), x3);
	 
	 /* multiply d by w^4 */
	 w *= w;
	 w *= w;
	 d *= w;
	 
	 /* 3. return the sum of the four surflets */
	 return dot(d, vec4(52.0));
}

/* const matrices for 3d rotation */
const mat3 rot1 = mat3(-0.37, 0.36, 0.85,-0.14,-0.93, 0.34,0.92, 0.01,0.4);
const mat3 rot2 = mat3(-0.55,-0.39, 0.74, 0.33,-0.91,-0.24,0.77, 0.12,0.63);
const mat3 rot3 = mat3(-0.71, 0.52,-0.47,-0.08,-0.72,-0.68,-0.7,-0.45,0.56);

/* directional artifacts can be reduced by rotating each octave */
float simplex3d_fractal(vec3 m) {
    return   0.5333333*simplex3d(m*rot1)
			+0.2666667*simplex3d(2.0*m*rot2)
			+0.1333333*simplex3d(4.0*m*rot3)
			+0.0666667*simplex3d(8.0*m);
}

float depthToSilhouette(float depth) {
  if(depth <= 0.4) return 0;
  // if(depth > 0.1) return 0;
  else return 1;
}

void main() {
  vec2 pixel = vec2(1.0);//./u_resolution;
  vec2 offset[9];
  offset[0] = pixel * vec2(-1.0,-1.0);
  offset[1] = pixel * vec2( 0.0,-1.0);
  offset[2] = pixel * vec2( 1.0,-1.0);

  offset[3] = pixel * vec2(-1.0,0.0);
  offset[4] = pixel * vec2( 0.0,0.0);
  offset[5] = pixel * vec2( 1.0,0.0);

  offset[6] = pixel * vec2(-1.0,1.0);
  offset[7] = pixel * vec2( 0.0,1.0);
  offset[8] = pixel * vec2( 1.0,1.0);

  vec2 st = v_texcoord;
  // st.y = 1.0 - st.y;


#ifdef BUFFER_0
  // PING BUFFER
  //
  //  Note: Here is where most of the action happens. But need's to read
  //  te content of the previous pass, for that we are making another buffer
  //  BUFFER_1 (u_buffer1)
  vec4 color = vec4(0,0,0,1);
  if(u_init) {
    int brightCount = 0;
    // for (int i=0; i < 9; i++){
    //   float tmp = texture(u_buffer1, st + offset[i]/40).r;
    //   if(depthToSilhouette(tmp) > 0) {
    //     brightCount++;
    //   }
    // }
    brightCount = 10;
    if(brightCount > 4) {
      vec3 tmpc = texture(u_ofcam, st).rgb;
      float tmp = tmpc.r;// + tmpc.g + tmpc.b;
      color.rgb = vec3(depthToSilhouette(tmp));
    }
  }
  else {

    float kernel[9];
    kernel[0] = 0.125;
    kernel[1] = 0.25;
    kernel[2] = 0.125;
    kernel[3] = 0.25;
    kernel[4] = 1.0;
    kernel[5] = 0.25;
    kernel[6] = 0.125;
    kernel[7] = 0.25;
    kernel[8] = 0.125;

    float lap = 0;

    for (int i=0; i < 9; i++){
      float tmp = texture(u_buffer1, st + offset[i]).r;
      lap += tmp * kernel[i] / 2.5;
    }
    color = vec4(vec3(lap * 2.0), 1.0);
  }

  gl_FragColor = color;

#elif defined( BUFFER_1 )
  // PONG BUFFER
  //
  //  Note: Just copy the content of the BUFFER0 so it can be 
  //  read by it in the next frame
  //
  gl_FragColor = texture(u_buffer0, st);
#else
  // Main Buffer
  vec2 st2 = st + vec2(simplex3d_fractal(vec3(st,0)/80), simplex3d_fractal(vec3(0,st.ts)/80)) * 16;
  vec3 dispColor = vec3(0, 0, 0);
  vec4 pointCloudColor = texture(u_ofcam, st); 

  float maxVal = 0;
  float minVal = 1;
  for (int i=0; i < 9; i++){
    float tmp = texture(u_buffer1, st2 + offset[i]/2).r > 0.5 ? 1 : 0;
    maxVal = max(maxVal, tmp);
    minVal = min(minVal, tmp);
  }

  if(maxVal - minVal >= 0.5) {
    dispColor.rgb = vec3(1);
  }

  gl_FragColor = vec4(dispColor, 1.0);
  gl_FragColor.rgb += pointCloudColor.rgb; // not good

#endif

}