1 files changed, 251 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/extensions/nv-shader-noperspective-interpolation.html b/dom/canvas/test/webgl-conf/checkout/conformance2/extensions/nv-shader-noperspective-interpolation.html
new file mode 100644
index 0000000000..2198c17b1a
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance2/extensions/nv-shader-noperspective-interpolation.html
@@ -0,0 +1,251 @@
+<!--
+Copyright (c) 2023 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL NV_shader_noperspective_interpolation Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<canvas width="128" height="128" id="c"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description("This test verifies the functionality of the NV_shader_noperspective_interpolation extension, if it is available.");
+
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("c", null, 2);
+var ext;
+
+function runShaderTests(extensionEnabled) {
+    debug("");
+    debug("Testing various shader compiles with extension " + (extensionEnabled ? "enabled" : "disabled"));
+
+    const macroVertex = `#version 300 es
+        in vec4 vPosition;
+        void main() {
+        #ifdef GL_NV_shader_noperspective_interpolation
+            gl_Position = vPosition;
+        #else
+            #error no GL_NV_shader_noperspective_interpolation;
+        #endif
+        }`;
+
+    const macroFragment = `#version 300 es
+        precision highp float;
+        out vec4 my_FragColor;
+        void main() {
+        #ifdef GL_NV_shader_noperspective_interpolation
+            my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+        #else
+            #error no GL_NV_shader_noperspective_interpolation;
+        #endif
+        }`;
+
+    for (const shaders of [[wtu.simpleVertexShaderESSL300, macroFragment],
+                           [macroVertex, wtu.simpleColorFragmentShaderESSL300]]) {
+        // Expect the macro shader to succeed ONLY if enabled
+        if (wtu.setupProgram(gl, shaders)) {
+            if (extensionEnabled) {
+                testPassed("Macro defined in shaders when extension is enabled");
+            } else {
+                testFailed("Macro defined in shaders when extension is disabled");
+            }
+        } else {
+            if (extensionEnabled) {
+                testFailed("Macro not defined in shaders when extension is enabled");
+            } else {
+                testPassed("Macro not defined in shaders when extension is disabled");
+            }
+        }
+    }
+
+    const missingVertex = `#version 300 es
+        noperspective out float interpolant;
+        in vec4 vPosition;
+        void main() {
+            gl_Position = vPosition;
+        }`;
+
+    const missingFragment = `#version 300 es
+        precision highp float;
+        noperspective in float interpolant;
+        out vec4 my_FragColor;
+        void main() {
+            my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+        }`;
+
+    // Always expect the shader missing the #extension pragma to fail (whether enabled or not)
+    for (const shaders of [[missingVertex, wtu.simpleColorFragmentShaderESSL300],
+                           [wtu.simpleVertexShaderESSL300, missingFragment],
+                           [missingVertex, missingFragment]]) {
+        if (wtu.setupProgram(gl, shaders)) {
+            testFailed("Noperspective interpolation qualifier allowed without #extension pragma");
+        } else {
+            testPassed("Noperspective interpolation qualifier disallowed without #extension pragma");
+        }
+    }
+
+    const validVertex = `#version 300 es
+        #extension GL_NV_shader_noperspective_interpolation : enable
+        noperspective out float interpolant;
+        in vec4 vPosition;
+        void main() {
+            gl_Position = vPosition;
+        }`;
+
+    const validFragment = `#version 300 es
+        #extension GL_NV_shader_noperspective_interpolation : enable
+        precision highp float;
+        noperspective in float interpolant;
+        out vec4 my_FragColor;
+        void main() {
+            my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+        }`;
+
+    // Try to compile a shader using a noperspective qualifier that should only succeed if enabled
+    if (wtu.setupProgram(gl, [validVertex, validFragment])) {
+        if (extensionEnabled) {
+            testPassed("Noperspective interpolation qualifier compiled successfully when extension enabled");
+        } else {
+            testFailed("Noperspective interpolation qualifier compiled successfully when extension disabled");
+        }
+    } else {
+        if (extensionEnabled) {
+            testFailed("Noperspective interpolation qualifier failed to compile when extension enabled");
+        } else {
+            testPassed("Noperspective interpolation qualifier failed to compile when extension disabled");
+        }
+    }
+
+    debug("");
+}
+
+function runInterpolationTest() {
+    function draw(program, skew) {
+        gl.useProgram(program);
+
+        const posLoc = gl.getAttribLocation(program, "position");
+        const colLoc = gl.getAttribLocation(program, "color");
+
+        const buf = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+        gl.bufferData(
+            gl.ARRAY_BUFFER,
+            new Float32Array([
+                -1.0, -1.0,        0.0, 1.0,
+                +1.0, -1.0,        0.0, 1.0,
+                 0.0, +1.0 * skew, 0.0, skew,
+
+                 1.0, 0.0, 0.0, 1.0,
+                 0.0, 1.0, 0.0, 1.0,
+                 0.0, 0.0, 1.0, 1.0]),
+            gl.STATIC_DRAW);
+
+        gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0);
+        gl.vertexAttribPointer(colLoc, 4, gl.FLOAT, false, 0, 48);
+        gl.enableVertexAttribArray(posLoc);
+        gl.enableVertexAttribArray(colLoc);
+        gl.drawArrays(gl.TRIANGLES, 0, 3);
+    }
+
+    const vertexSmooth = `#version 300 es
+        in vec4 position;
+        in vec4 color;
+        smooth out vec4 interp_color;
+        void main() {
+            gl_Position = position;
+            interp_color = color;
+        }`;
+
+    const fragmentSmooth = `#version 300 es
+        precision highp float;
+        smooth in vec4 interp_color;
+        out vec4 fragColor;
+        void main() {
+            fragColor = interp_color;
+        }`;
+    const programSmooth = wtu.setupProgram(gl, [vertexSmooth, fragmentSmooth]);
+
+    debug("Get non-skewed value with smooth interpolation");
+    gl.clearColor(0.0, 0.0, 0.0, 1.0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    draw(programSmooth, 1.0);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+
+    const smoothColor = new Uint8Array(4);
+    gl.readPixels(64, 64, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, smoothColor);
+
+    const vertexNoperspective = `#version 300 es
+        #extension GL_NV_shader_noperspective_interpolation : require
+        in vec4 position;
+        in vec4 color;
+        noperspective out vec4 interp_color;
+        void main() {
+            gl_Position = position;
+            interp_color = color;
+        }`;
+
+    const fragmentNoperspective = `#version 300 es
+        #extension GL_NV_shader_noperspective_interpolation : require
+        precision highp float;
+        noperspective in vec4 interp_color;
+        out vec4 fragColor;
+        void main() {
+            fragColor = interp_color;
+        }`;
+    const programNoperspective = wtu.setupProgram(gl, [vertexNoperspective, fragmentNoperspective]);
+
+    debug("");
+    debug("Check non-skewed value with noperspective interpolation");
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    draw(programNoperspective, 1.0);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+    wtu.checkCanvasRect(gl, 64, 64, 1, 1, smoothColor, "Non-skewed noperspective should match smooth");
+
+    debug("");
+    debug("Check skewed value with noperspective interpolation");
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    draw(programNoperspective, 2.0);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+    wtu.checkCanvasRect(gl, 64, 64, 1, 1, smoothColor, "Skewed noperspective should match smooth");
+}
+
+function runTest() {
+    if (!gl) {
+        testFailed("WebGL context does not exist");
+        return;
+    }
+    testPassed("WebGL context exists");
+
+    runShaderTests(false);
+
+    ext = gl.getExtension("NV_shader_noperspective_interpolation");
+    wtu.runExtensionSupportedTest(gl, "NV_shader_noperspective_interpolation", ext !== null);
+
+    if (!ext) {
+        testPassed("No NV_shader_noperspective_interpolation support -- this is legal");
+    } else {
+        testPassed("Successfully enabled NV_shader_noperspective_interpolation extension");
+        runShaderTests(true);
+        runInterpolationTest();
+    }
+}
+
+runTest();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>