uniform sampler2D map;

uniform float width;
uniform float height;
uniform float nearClipping, farClipping;

uniform float pointSize;
uniform float boxSize;
uniform float cameraIndex;

uniform float numCameras;

uniform mat4 c2wm;
uniform mat4 prjm;

varying vec2 vUv;
varying vec2 vUv1pxOffset;
varying float paintfordiscard;

mat4 unity_to_opengl(mat4 U) {
    return mat4(
         1., 0., 0., 0.,
         0., 1., 0., 0.,
         0., 0.,-1., 0.,
         0., 0., 0., 1.
    ) * U;
}
// mat4 swapHandedness(mat4 sM) {
//     return mat4(
//         sM[0][0], sM[0][1], sM[0][2], sM[3][0],
//         sM[1][0], sM[1][1], sM[1][2], sM[3][1],
//         sM[2][0], sM[2][1], sM[2][2], sM[3][2],
//         sM[0][3], sM[1][3], sM[2][3], sM[3][3]); 
// }
// mat4 fuckAroundAndFindOut(mat4 sM) {
//     // return mat4(
//     //     sM[0][0], sM[1][0], sM[2][0], sM[0][3],
//     //     sM[0][1], sM[1][1], sM[2][1], sM[1][3],
//     //     sM[0][2], sM[1][2], sM[2][2], sM[2][3],
//     //     sM[3][0], sM[3][1], sM[3][2], sM[3][3]); 
//     return mat4(
//         -sM[0][0], -sM[0][1], -sM[0][2], -sM[0][3],
//         sM[1][0], sM[1][1], sM[1][2], sM[1][3],
//         -sM[2][0], -sM[2][1], -sM[2][2], -sM[2][3],
//         sM[3][0], sM[3][1], sM[3][2], sM[3][3]); 
//     // return mat4(
//     //     sM[0][0], sM[1][0], sM[0][2], sM[0][3],
//     //     sM[0][1], sM[1][1], sM[1][2], sM[1][3],
//     //     sM[2][0], sM[2][1], sM[2][2], sM[2][3],
//     //     sM[3][0], sM[3][1], sM[3][2], sM[3][3]); 
//     // return mat4(
//     //     sM[0][0], sM[0][1], sM[2][0], sM[0][3],
//     //     sM[1][0], sM[1][1], sM[2][1], sM[1][3],
//     //     sM[0][2], sM[1][2], sM[2][2], sM[2][3],
//     //     sM[3][0], sM[3][1], sM[3][2], sM[3][3]); 
//     // return mat4(
//     //     sM[0][0], sM[0][1], -sM[0][2], sM[0][3],
//     //     sM[1][0], sM[1][1], sM[1][2], sM[1][3],
//     //     -sM[2][0], sM[2][1], sM[2][2], sM[2][3],
//     //     sM[3][0], sM[3][1], sM[3][2], sM[3][3]); 

// }

void main() {

    vUv = vec2( position.x / width, position.y / height );  
    vUv1pxOffset = vec2( 1.0 / width, 1.0 / height ) * 2.0;

    int skipctr = 0;
    int skipthreshold = 1;

    for (float xoff = -1.0; xoff < 2.0; xoff++) {
        for (float yoff = -1.0; yoff < 2.0; yoff++) {
            vec2 thisUv = vUv + (vec2(xoff, yoff) * vUv1pxOffset);
            vec4 color = texture2D(map, thisUv*vec2(1.0/numCameras,(1.0/3.0))+vec2(cameraIndex/numCameras,(1.0/3.0)));
            float depth = ( color.r + color.g + color.b ) / 3.0;
            if (depth < 0.01) {
                skipctr++;
            }
        }
    }

    paintfordiscard = float(skipctr > skipthreshold);
    //vec4 color = texture2D( map, vUv*vec2(0.5,(1.0/3.0))+vec2(0,(1.0/3.0)));
    vec4 color = texture2D( map, vUv*vec2(1.0/numCameras,(1.0/3.0))+vec2(cameraIndex/numCameras,(1.0/3.0)));

    float depth = ( color.r + color.g + color.b ) / 3.0;

    // (original) Projection code by @kcmic

    // instead of building a matrix and multiplying by the matrix, math is being done to
    // guess the projection.
    // Undoes the perspective division
    //float z = depth * (farClipping-nearClipping) + nearClipping;
    // float z = depth;
    
    // vec4 pos = vec4(
    //     ( position.x / width - 0.5 )*boxSize,
    //     ( position.y / height - 0.5 )*boxSize,
    //     z*boxSize*0.5, // we had applied a (-1.0) multiplier to try to flip element [2,2] 
    //     1.0);

    vec4 pos = vec4(
        2.*(position.x / float(width))  - 1., 
        2.*(position.y / float(height)) - 1., 
        mix(1., -1., depth), 
        1.0
    );
    //vec4 pos2 = pos;

    // First undo projection, then undo view, then below model is undone; flip the Y and Z vectors since WebGL is right handed
    vec4 pos2 = unity_to_opengl(c2wm) * inverse(prjm) * pos; // order matters here! Parentheses do not

    pos2.xyz *= boxSize;
    // pos2 = pos2 * vec4(20000., 20000., 20000., 20000.); // bad idea! the last point needs to be 1 for translation to work
    // pos2 = pos2 * boxSize;
    //vec4 pos2 = inverse(c2wm) * pos;
// float(cameraIndex)
    gl_PointSize = pointSize;
    gl_Position = projectionMatrix * modelViewMatrix * pos2;
    if (depth  <.01 || (paintfordiscard != 0.0))  { // move this point out of the view box if the depth is nearly zero
        gl_Position = vec4(-1., -1., -1., -1.);
    }
}