<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../../../resources/js-test.js"></script>
<script src="resources/webgl-test.js"></script>
<script src="resources/webgl-test-utils.js"></script>
<title>WebGL WEBGL_depth_texture Conformance Tests</title>
</head>
<body>
<script id="vshader" type="x-shader/x-vertex">
attribute vec4 a_position;
void main()
{
    gl_Position = a_position;
}
</script>

<script id="fshader" type="x-shader/x-fragment">
precision mediump float;
uniform sampler2D u_texture;
uniform vec2 u_resolution;
void main()
{
    vec2 texcoord = gl_FragCoord.xy / u_resolution;
    gl_FragColor = texture2D(u_texture, texcoord);
}
</script>
<div id="description"></div>
<div id="console"></div>
<canvas id="canvas" width="8" height="8" style="width: 8px; height: 8px;"></canvas>
<script>
if (window.initNonKhronosFramework) {
    window.initNonKhronosFramework(false);
}
description("This test verifies the functionality of the WEBGL_depth_texture extension, if it is available.");

debug("");

if (window.internals)
    window.internals.settings.setWebGLErrorsToConsoleEnabled(false);

var wtu = WebGLTestUtils;
var canvas = document.getElementById("canvas");
var gl = wtu.create3DContext(canvas, {antialias: false});
var program = wtu.setupTexturedQuad(gl);
var ext = null;
var vao = null;
var tex;
var name;
var supportedFormats;

if (!gl) {
    testFailed("WebGL context does not exist");
} else {
    testPassed("WebGL context exists");

    // Run tests with extension disabled
    runTestDisabled();

    // Query the extension and store globally so shouldBe can access it
    ext = gl.getExtension("WEBGL_depth_texture");
    if (!ext) {
        testPassed("No WEBGL_depth_texture support -- this is legal");
        runSupportedTest(false);
    } else {
        testPassed("Successfully enabled WEBGL_depth_texture extension");

        runSupportedTest(true);
        runTestExtension();
    }
}

function runSupportedTest(extensionEnabled) {
    var name = wtu.getSupportedExtensionWithKnownPrefixes(gl, "WEBGL_depth_texture");
    if (name !== undefined) {
        if (extensionEnabled) {
            testPassed("WEBGL_depth_texture listed as supported and getExtension succeeded");
        } else {
            testFailed("WEBGL_depth_texture listed as supported but getExtension failed");
        }
    } else {
        if (extensionEnabled) {
            testFailed("WEBGL_depth_texture not listed as supported but getExtension succeeded");
        } else {
            testPassed("WEBGL_depth_texture not listed as supported and getExtension failed -- this is legal");
        }
    }
}


function runTestDisabled() {
    debug("Testing binding enum with extension disabled");

    var tex = gl.createTexture();
    gl.bindTexture(gl.TEXTURE_2D, tex);
    shouldGenerateGLError(gl, gl.INVALID_ENUM, 'gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT, 1, 1, 0, gl.DEPTH_COMPONENT, gl.UNSIGNED_SHORT, null)');
    shouldGenerateGLError(gl, gl.INVALID_ENUM, 'gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT, 1, 1, 0, gl.DEPTH_COMPONENT, gl.UNSIGNED_INT, null)');
}


function dumpIt(gl, res, msg) {
  return;  // comment out to debug
  debug(msg);
  var actualPixels = new Uint8Array(res * res * 4);
  gl.readPixels(0, 0, res, res, gl.RGBA, gl.UNSIGNED_BYTE, actualPixels);

  for (var yy = 0; yy < res; ++yy) {
    var strs = [];
    for (var xx = 0; xx < res; ++xx) {
      var actual = (yy * res + xx) * 4;
      strs.push("(" + actualPixels[actual] + "," + actualPixels[actual+1] + "," + actualPixels[actual + 2] + "," + actualPixels[actual + 3] + ")");
    }
    debug(strs.join(" "));
  }
}
function runTestExtension() {
    debug("Testing WEBGL_depth_texture");

    var res = 8;

    // make canvas for testing.
    canvas2 = document.createElement("canvas");
    canvas2.width = res;
    canvas2.height = res;
    var ctx = canvas2.getContext("2d");
    ctx.fillStyle = "blue";
    ctx.fillRect(0, 0, canvas2.width, canvas2.height);

    var program = wtu.setupProgram(gl, ['vshader', 'fshader'], ['a_position']);
    gl.useProgram(program);
    gl.uniform2f(gl.getUniformLocation(program, "u_resolution"), res, res);

    var buffer = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
    gl.bufferData(
        gl.ARRAY_BUFFER,
        new Float32Array(
            [   1,  1,  1,
               -1,  1,  0,
               -1, -1, -1,
                1,  1,  1,
               -1, -1, -1,
                1, -1,  0,
            ]),
        gl.STATIC_DRAW);
    gl.enableVertexAttribArray(0);
    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);

    var types = [
        {obj: 'gl',  attachment: 'DEPTH_ATTACHMENT',         format: 'DEPTH_COMPONENT', type: 'UNSIGNED_SHORT',          data: 'new Uint16Array(1)' },
        {obj: 'gl',  attachment: 'DEPTH_ATTACHMENT',         format: 'DEPTH_COMPONENT', type: 'UNSIGNED_INT',            data: 'new Uint32Array(1)' },
        {obj: 'ext', attachment: 'DEPTH_STENCIL_ATTACHMENT', format: 'DEPTH_STENCIL',   type: 'UNSIGNED_INT_24_8_WEBGL', data: 'new Uint32Array(1)' }
    ];

    for (var ii = 0; ii < types.length; ++ii) {
        var typeInfo = types[ii];
        var type = typeInfo.type;
        var typeStr = typeInfo.obj + '.' + type;

        debug("");
        debug("testing: " + type);

        // check that cubemaps are not allowed.
        var cubeTex = gl.createTexture();
        gl.bindTexture(gl.TEXTURE_CUBE_MAP, cubeTex);
        var targets = [
          'TEXTURE_CUBE_MAP_POSITIVE_X',
          'TEXTURE_CUBE_MAP_NEGATIVE_X',
          'TEXTURE_CUBE_MAP_POSITIVE_Y',
          'TEXTURE_CUBE_MAP_NEGATIVE_Y',
          'TEXTURE_CUBE_MAP_POSITIVE_Z',
          'TEXTURE_CUBE_MAP_NEGATIVE_Z'
        ];
        for (var tt = 0; tt < targets.length; ++tt) {
            shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.texImage2D(gl.' + targets[ii] + ', 1, gl.' + typeInfo.format + ', 1, 1, 0, gl.' + typeInfo.format + ', ' + typeStr + ', null)');
        }

        // check 2d textures.
        tex = gl.createTexture();
        gl.bindTexture(gl.TEXTURE_2D, tex);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);

        // test level > 0
        shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.texImage2D(gl.TEXTURE_2D, 1, gl.' + typeInfo.format + ', 1, 1, 0, gl.' + typeInfo.format + ', ' + typeStr + ', null)');

        // test with data
        shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.texImage2D(gl.TEXTURE_2D, 0, gl.' + typeInfo.format + ', 1, 1, 0, gl.' + typeInfo.format + ', ' + typeStr + ', ' + typeInfo.data + ')');

        // test with canvas
        shouldGenerateGLError(gl, [gl.INVALID_VALUE, gl.INVALID_ENUM, gl.INVALID_OPERATION], 'gl.texImage2D(gl.TEXTURE_2D, 0, gl.' + typeInfo.format + ', gl.' + typeInfo.format + ', ' + typeStr  + ', canvas2)');

        // test copyTexImage2D
        shouldGenerateGLError(gl, [gl.INVALID_ENUM, gl.INVALID_OPERATION], 'gl.copyTexImage2D(gl.TEXTURE_2D, 0, gl.' + typeInfo.format + ', 0, 0, 1, 1, 0)');

        // test real thing
        shouldGenerateGLError(gl, gl.NO_ERROR, 'gl.texImage2D(gl.TEXTURE_2D, 0, gl.' + typeInfo.format + ', ' + res + ', ' + res + ', 0, gl.' + typeInfo.format + ', ' + typeStr + ', null)');

        // test texSubImage2D
        shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 1, 1, gl.' + typeInfo.format + ', ' + typeStr  + ', ' + typeInfo.data + ')');

        // test copyTexSubImage2D
        shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.copyTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1)');

        // test generateMipmap
        shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.generateMipmap(gl.TEXTURE_2D)');

        var fbo = gl.createFramebuffer();
        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl[typeInfo.attachment], gl.TEXTURE_2D, tex, 0);
        // TODO: remove this check if the spec is updated to require these combinations to work.
        if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE)
        {
            // try adding a color buffer.
            var colorTex = gl.createTexture();
            gl.bindTexture(gl.TEXTURE_2D, colorTex);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, res, res, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, colorTex, 0);
        }
        
        shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE');

        // use the default texture to render with while we return to the depth texture.
        gl.bindTexture(gl.TEXTURE_2D, null);

        // render the z-quad
        gl.enable(gl.DEPTH_TEST);
        gl.clearColor(1, 0, 0, 1);
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
        gl.drawArrays(gl.TRIANGLES, 0, 6);

        dumpIt(gl, res, "--first--");

        // render the depth texture.
        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
        gl.bindTexture(gl.TEXTURE_2D, tex);
        gl.clearColor(0, 0, 1, 1);
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
        gl.drawArrays(gl.TRIANGLES, 0, 6);

        var actualPixels = new Uint8Array(res * res * 4);
        gl.readPixels(0, 0, res, res, gl.RGBA, gl.UNSIGNED_BYTE, actualPixels);

        dumpIt(gl, res, "--depth--");

        // Check that each pixel's RGB are the same and that it's value is less
        // than the previous pixel in either direction. Basically verify we have a
        // gradient.
        var success = true;
        for (var yy = 0; yy < res; ++yy) {
          for (var xx = 0; xx < res; ++xx) {
            var actual = (yy * res + xx) * 4;
            var left = actual - 4;
            var down = actual - res * 4;

            if (actualPixels[actual + 0] != actualPixels[actual + 1]) {
                testFailed('R != G');
                success = false;
            }
            if (actualPixels[actual + 0] != actualPixels[actual + 2]) {
                testFailed('R != B');
                success = false;
            }
            // ALPHA is implementation dependent
            if (actualPixels[actual + 3] != 0xFF && actualPixels[actual + 3] != actualPixels[actual + 0]) {
                testFailed('A != 255 && A != R');
                success = false;
            }

            if (xx > 0) {
              if (actualPixels[actual] <= actualPixels[left]) {
                  testFailed("actual(" + actualPixels[actual] + ") < left(" + actualPixels[left] + ")");
                  success = false;
              }
            }
            if (yy > 0) {
                if (actualPixels[actual] <= actualPixels[down]) {
                    testFailed("actual(" + actualPixels[actual] + ") < down(" + actualPixels[down] + ")");
                    success = false;
                }
            }
          }
        }

        // Check that bottom left corner is vastly different thatn top right.
        if (actualPixels[(res * res - 1) * 4] - actualPixels[0] < 0xC0) {
            testFailed("corners are not different enough");
            success = false;
        }

        if (success) {
            testPassed("depth texture rendered correctly.");
        }

        // check limitations
        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl[typeInfo.attachment], gl.TEXTURE_2D, null, 0);
        var badAttachment = typeInfo.attachment == 'DEPTH_ATTACHMENT' ? 'DEPTH_STENCIL_ATTACHMENT' : 'DEPTH_ATTACHMENT';
        shouldGenerateGLError(gl, gl.NO_ERROR, 'gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.' + badAttachment + ', gl.TEXTURE_2D, tex, 0)');
        shouldNotBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE');
        shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, 'gl.clear(gl.DEPTH_BUFFER_BIT)');
        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
        shouldBe('gl.getError()', 'gl.NO_ERROR');
    }
}

debug("");
if (window.nonKhronosFrameworkNotifyDone) {
    window.nonKhronosFrameworkNotifyDone();
}
</script>
</body>
</html>