LayoutTests/webgl/2.0.0/resources/webgl_test_files/conformance/glsl/bugs/constant-precision-qualifier.html - WebKit - Git at Google

 <!--

 /*
 ** Copyright (c) 2014 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
 ** "Materials"), to deal in the Materials without restriction, including
 ** without limitation the rights to use, copy, modify, merge, publish,
 ** distribute, sublicense, and/or sell copies of the Materials, and to
 ** permit persons to whom the Materials are furnished to do so, subject to
 ** the following conditions:
 **
 ** The above copyright notice and this permission notice shall be included
 ** in all copies or substantial portions of the Materials.
 **
 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */

 -->

 <!DOCTYPE html>
 <html>
 <head>
 <meta charset="utf-8">
 <title>Bug - the precision qualifier of a constant variable should affect the precision of a consuming operation</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>
 <script src="../../../js/glsl-conformance-test.js"></script>
 </head>
 <body>
 <div id="description"></div>
 <div id="console"></div>
 <script id="fshader" type="x-shader/x-fragment">
 // It is assumed that uTest is set to 0. It's here to make the expression not constant.
 uniform mediump float uTest;

 void main() {
     // exact representation of 4096.5 requires 13 bits of relative precision.
     const highp float c = 4096.5;
     mediump float a = 0.0;
     // Below, addition should be evaluated at highp, since one of the operands has the highp qualifier.
     // Thus fract should also be evaluated at highp.
     // See OpenGL ES Shading Language spec section 4.5.2.
     // This should make the result 0.5, since highp provides at least 16 bits of relative precision.
     // (exceptions for operation precision are allowed for a small number of computationally
     // intensive built-in functions, but it is reasonable to think that fract is not one of those).
     // However, if fract() is incorrectly evaluated at minimum precision fulfilling mediump criteria,
     // or at IEEE half float precision, the result is 0.0.
     a = fract(c + uTest);

     // Multiply by 2.0 to make the color green.
     gl_FragColor = vec4(0.0, 2.0 * a, 0.0, 1.0);
 }
 </script>
 <script id="fshaderNoConstants" type="x-shader/x-fragment">
 // This shader has the same functionality as the one above, but it doesn't contain
 // operations that can be constant folded at compile-time.
 // It's here to provide a point of comparison.
 uniform mediump float uTest;
 uniform highp float uTestHigh;

 void main() {
     highp float c = 4096.5 + uTestHigh;
     mediump float a = 0.0;
     a = fract(c + uTest);
     gl_FragColor = vec4(0.0, 2.0 * a, 0.0, 1.0);
 }
 </script>
 <script id="fshaderAllHighp" type="x-shader/x-fragment">
 // This shader has the same functionality as the one above, but it only uses highp.
 // It's here to provide a point of comparison.
 uniform highp float uTest;

 void main() {
     highp float c = 4096.5 + uTest;
     highp float a = 0.0;
     a = fract(c + uTest);
     gl_FragColor = vec4(0.0, 2.0 * a, 0.0, 1.0);
 }
 </script>
 <script type="application/javascript">
 "use strict";
 description();

 function test() {
   var wtu = WebGLTestUtils;
   var gl = wtu.create3DContext();
   if (!gl) {
     testFailed("context does not exist");
     finishTest();
     return;
   }
   if (gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT).precision == 0) {
     testPassed("highp precision not supported");
     finishTest();
   } else {
     GLSLConformanceTester.runRenderTests([
     {
       fShaderId: 'fshader',
       fShaderSuccess: true,
       linkSuccess: true,
       passMsg: 'The precision qualifier of a constant affects built-in function results',
       uniforms: [{name: "uTest", functionName: "uniform1f", value: 0}]
     },
     {
       fShaderId: 'fshaderNoConstants',
       fShaderSuccess: true,
       linkSuccess: true,
       passMsg: 'The precision qualifier of a variable affects built-in function results',
       uniforms: [{name: "uTest", functionName: "uniform1f", value: 0},
                  {name: "uTestHigh", functionName: "uniform1f", value: 0}]
     },
     {
       fShaderId: 'fshaderAllHighp',
       fShaderSuccess: true,
       linkSuccess: true,
       passMsg: 'All variables are qualified as highp',
       uniforms: [{name: "uTest", functionName: "uniform1f", value: 0}]
     },
     ]);
   }
 };

 test();
 var successfullyParsed = true;
 </script>
 </body>
 </html>
	<!--

	/*
	** Copyright (c) 2014 The Khronos Group Inc.
	**
	** Permission is hereby granted, free of charge, to any person obtaining a
	** copy of this software and/or associated documentation files (the
	** "Materials"), to deal in the Materials without restriction, including
	** without limitation the rights to use, copy, modify, merge, publish,
	** distribute, sublicense, and/or sell copies of the Materials, and to
	** permit persons to whom the Materials are furnished to do so, subject to
	** the following conditions:
	**
	** The above copyright notice and this permission notice shall be included
	** in all copies or substantial portions of the Materials.
	**
	** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
	*/

	-->

	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	<title>Bug - the precision qualifier of a constant variable should affect the precision of a consuming operation</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>
	<script src="../../../js/glsl-conformance-test.js"></script>
	</head>
	<body>
	<div id="description"></div>
	<div id="console"></div>
	<script id="fshader" type="x-shader/x-fragment">
	// It is assumed that uTest is set to 0. It's here to make the expression not constant.
	uniform mediump float uTest;

	void main() {
	// exact representation of 4096.5 requires 13 bits of relative precision.
	const highp float c = 4096.5;
	mediump float a = 0.0;
	// Below, addition should be evaluated at highp, since one of the operands has the highp qualifier.
	// Thus fract should also be evaluated at highp.
	// See OpenGL ES Shading Language spec section 4.5.2.
	// This should make the result 0.5, since highp provides at least 16 bits of relative precision.
	// (exceptions for operation precision are allowed for a small number of computationally
	// intensive built-in functions, but it is reasonable to think that fract is not one of those).
	// However, if fract() is incorrectly evaluated at minimum precision fulfilling mediump criteria,
	// or at IEEE half float precision, the result is 0.0.
	a = fract(c + uTest);

	// Multiply by 2.0 to make the color green.
	gl_FragColor = vec4(0.0, 2.0 * a, 0.0, 1.0);
	}
	</script>
	<script id="fshaderNoConstants" type="x-shader/x-fragment">
	// This shader has the same functionality as the one above, but it doesn't contain
	// operations that can be constant folded at compile-time.
	// It's here to provide a point of comparison.
	uniform mediump float uTest;
	uniform highp float uTestHigh;

	void main() {
	highp float c = 4096.5 + uTestHigh;
	mediump float a = 0.0;
	a = fract(c + uTest);
	gl_FragColor = vec4(0.0, 2.0 * a, 0.0, 1.0);
	}
	</script>
	<script id="fshaderAllHighp" type="x-shader/x-fragment">
	// This shader has the same functionality as the one above, but it only uses highp.
	// It's here to provide a point of comparison.
	uniform highp float uTest;

	void main() {
	highp float c = 4096.5 + uTest;
	highp float a = 0.0;
	a = fract(c + uTest);
	gl_FragColor = vec4(0.0, 2.0 * a, 0.0, 1.0);
	}
	</script>
	<script type="application/javascript">
	"use strict";
	description();

	function test() {
	var wtu = WebGLTestUtils;
	var gl = wtu.create3DContext();
	if (!gl) {
	testFailed("context does not exist");
	finishTest();
	return;
	}
	if (gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT).precision == 0) {
	testPassed("highp precision not supported");
	finishTest();
	} else {
	GLSLConformanceTester.runRenderTests([
	{
	fShaderId: 'fshader',
	fShaderSuccess: true,
	linkSuccess: true,
	passMsg: 'The precision qualifier of a constant affects built-in function results',
	uniforms: [{name: "uTest", functionName: "uniform1f", value: 0}]
	},
	{
	fShaderId: 'fshaderNoConstants',
	fShaderSuccess: true,
	linkSuccess: true,
	passMsg: 'The precision qualifier of a variable affects built-in function results',
	uniforms: [{name: "uTest", functionName: "uniform1f", value: 0},
	{name: "uTestHigh", functionName: "uniform1f", value: 0}]
	},
	{
	fShaderId: 'fshaderAllHighp',
	fShaderSuccess: true,
	linkSuccess: true,
	passMsg: 'All variables are qualified as highp',
	uniforms: [{name: "uTest", functionName: "uniform1f", value: 0}]
	},
	]);
	}
	};

	test();
	var successfullyParsed = true;
	</script>
	</body>
	</html>