diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/canvas/test/webgl-conf/checkout/conformance/ogles/GL/build/CorrectFull_vert.vert | |
parent | Initial commit. (diff) | |
download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip |
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/conformance/ogles/GL/build/CorrectFull_vert.vert')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/conformance/ogles/GL/build/CorrectFull_vert.vert | 654 |
1 files changed, 654 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/ogles/GL/build/CorrectFull_vert.vert b/dom/canvas/test/webgl-conf/checkout/conformance/ogles/GL/build/CorrectFull_vert.vert new file mode 100644 index 0000000000..30f14ad27b --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/ogles/GL/build/CorrectFull_vert.vert @@ -0,0 +1,654 @@ + +/* +Copyright (c) 2019 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. +*/ + + +struct gtf_MaterialParameters +{ +vec4 emission; +vec4 ambient; +vec4 diffuse; +vec4 specular; +float shininess; +}; +struct gtf_LightSourceParameters +{ +vec4 ambient; +vec4 diffuse; +vec4 specular; +vec4 position; +vec4 halfVector; +vec3 spotDirection; +float spotExponent; +float spotCutoff; +float spotCosCutoff; +float constantAttenuation; +float linearAttenuation; +float quadraticAttenuation; +}; +struct gtf_PointParameters { +float size; +float sizeMin; +float sizeMax; +float fadeThresholdSize; +float distanceConstantAttenuation; +float distanceLinearAttenuation; +float distanceQuadraticAttenuation; +}; +struct gtf_DepthRangeParameters { +float near; +float far; +float diff; +}; +struct gtf_LightModelParameters { +vec4 ambient; +}; +struct gtf_LightModelProducts { +vec4 sceneColor; +}; +struct gtf_LightProducts { +vec4 ambient; +vec4 diffuse; +vec4 specular; +}; +struct gtf_FogParameters { +vec4 color; +float density; +float start; +float end; +float scale; +}; +uniform int gtf_MaxFragmentUniformComponents; +uniform int gtf_MaxVertexUniformComponents; +uniform int gtf_MaxVertexTextureImageUnits; +uniform int gtf_MaxLights; +uniform int gtf_MaxClipPlanes; +uniform int gtf_MaxCombinedTextureImageUnits; +uniform int gtf_MaxTextureCoords; +uniform int gtf_MaxVertexAttribs; +uniform int gtf_MaxVaryingFloats; +uniform int gtf_MaxTextureUnits; +uniform int gtf_MaxDrawBuffers; +uniform int gtf_MaxTextureImageUnits; +uniform gtf_LightProducts gtf_FrontLightProduct[8]; +uniform gtf_LightModelProducts gtf_FrontLightModelProduct; +uniform gtf_DepthRangeParameters gtf_DepthRange; +uniform gtf_FogParameters gtf_Fog; +uniform gtf_PointParameters gtf_Point; +uniform gtf_LightModelParameters gtf_LightModel; +varying vec4 gtf_FogFragCoord; +varying vec4 gtf_BackColor; +varying vec4 gtf_BackSecondaryColor; +varying vec4 gtf_FrontSecondaryColor; +varying vec4 gtf_TexCoord[2]; +varying vec4 gtf_FrontColor; +uniform gtf_MaterialParameters gtf_FrontMaterial; +uniform gtf_LightSourceParameters gtf_LightSource[8]; +attribute vec4 gtf_MultiTexCoord1; +attribute vec4 gtf_MultiTexCoord2; +attribute vec4 gtf_SecondaryColor; +attribute vec4 gtf_Color; +attribute vec4 gtf_MultiTexCoord3; +attribute vec4 gtf_MultiTexCoord0; +attribute vec4 gtf_Normal; +attribute vec4 gtf_Vertex; +uniform mat4 gtf_NormalMatrix; +uniform mat4 gtf_ProjectionMatrix; +uniform mat4 gtf_TextureMatrix[8]; +uniform mat4 gtf_ModelViewMatrix; +uniform mat4 gtf_ModelViewProjectionMatrix; +void test_function(const in int in_int, inout int out_int); +int test_function1(in int in_int1, inout int in_out_int); + +uniform float array_float[2]; + +struct nested +{ + int a; + float f; +}; + +struct light1 +{ + float intensity; + vec3 position; + int test_int[2]; + nested light2; +} lightVar; +light1 ll2; + +void Assign (out light1 out1, in light1 in1) +{ + out1.intensity = in1.intensity; + out1.position = in1.position; + out1.test_int[0] = in1.test_int[0]; + out1.test_int[1] = in1.test_int[1]; + out1.light2 = in1.light2; +} + +struct light3 { + float i; +}; + +struct light4 { + float i; +}; + +struct light5 { + float i ; + float a[2]; +} light5_inst; + +uniform light3 uniformLight3; + +struct light6 { + float i; +}; +uniform light6 uniformLight6; + +struct slight10{ + float f; + }; +struct slight9{ + slight10 light10; + }; +struct slight8{ + slight9 light9; + }; +struct light7 { + slight8 light8; +} ; + + +light3 struct_var = light3(5.0); + +// Attribtue variables can only be Global +attribute float flt_attrib; +attribute vec2 vec2_attrib; +attribute vec3 vec3_attrib; +attribute vec4 vec4_attrib; +attribute mat2 mat2_attrib; +attribute mat3 mat3_attrib; +attribute mat4 mat4_attrib; + +uniform float flt_uniform; +uniform vec3 uniform_vec3; +uniform mat3 uniform_mat3; + +uniform sampler2D samp[3]; +uniform sampler2D samp1; + +const struct light12 { + int a; +} uniform_struct = light12(2); + +varying vec3 varying_vec3; +varying vec2 varying_vec2; +varying vec4 varying_vec4; +varying mat4 varying_mat4; +varying mat2 varying_mat2; +varying mat3 varying_mat3; +varying float varying_flt; + +float frequencies[2]; + +void test_function2(int func_int) +{ +} + +void test_function3(light3); +void test_function4(light5 ll20); +void test_function5(light1); +light6 test_function6(int a); + +const float FloatConst1 = 3.0 * 8.0, floatConst2 = 4.0; +const bool BoolConst1 = true && true || false; +const bool BoolConst2 = false || !false && false; + +void main(void) +{ + + int test_int1 = 2; + const int const_test_int1 = 2; + + struct structMain { + float i; + } testStruct; + + struct { + structMain a; + } aStruct; + + testStruct.i = 5.0 ; + struct_var.i = 5.0; + + structMain newStruct, newStruct1; + testStruct = newStruct; + newStruct = newStruct1; + + lightVar.light2.f = 1.1; + + light1 ll1; + ll1.light2.a = 1; + + const struct const_struct { + float i; + } const_struct_inst = const_struct(1.0); + + //ll1 = ll2; + Assign (ll1, ll2); + ll1.light2 = ll2.light2; + ll1.light2 = ll1.light2; + ll1.light2.f = ll2.light2.f; + ll1.light2.f = ll1.light2.f; + + // lightVar = ll2; + // ll2 = lightVar; + Assign (lightVar, ll2); + Assign (ll2, lightVar); + + light5 ll10; + + light7 ll7[4]; + structMain newStruct2[2]; + newStruct2[0].i = 1.1; + + ll7[0].light8.light9.light10.f = 1.1; + + + bool test_bool4 = false ; + + bool test_bool5 = 1.2 > 3.0 ; + + int test_int2 = 047; + int test_int4 = 0xa8; // testing for hexadecimal numbers + + float test_float1 = 1.5; + float test_float2 = .01; + float test_float3 = 10.; + float test_float4 = 10.01; + float test_float5 = 23e+2; + float test_float6 = 23E-3; + float test_float8 = 23E2; + bool test_bool6 = BoolConst1 && ! (test_int1 != 0) && ! BoolConst1 && ! (FloatConst1 != 0.0) && (FloatConst1 != 0.0) && (test_float1 != 0.0); + + vec4 color = vec4(0.0, 1.0, 0.0, 1.0); + vec4 color2 = vec4(0.0); + + vec3 color4 = vec3(test_float8); + + ivec4 test_int_vect1 = ivec4(1.0,1.0,1.0,1.0); + ivec3 test_int_vec3 = ivec3(1, 1, 1) ; + + bvec4 test_bool_vect1 = bvec4(1., 1., 1. , 1. ); + + vec2 test_vec2 = vec2(1., 1.); + vec2 test_vec3 = vec2(1., 1); + vec4 test_vec4 = vec4(test_int_vect1); + + vec2 test_vec5 = vec2(color4); + vec3 test_vec7 = vec3(color); + vec3 test_vec8 = vec3(test_vec2, test_float4); + vec3 test_vec9 = vec3(test_float4, test_vec2); + + vec4 test_vec10 = vec4(test_vec9, 0.01); + vec4 test_vec11 = vec4(0.01, test_vec9); + + vec4 test_vec12 = vec4(test_vec2, test_vec2); + + mat2 test_mat2 = mat2(test_float3); + mat3 test_mat3 = mat3(test_float3); + mat4 test_mat4 = mat4(test_float3); + + mat2 test_mat7 = mat2(test_vec2, test_vec2); + mat2 test_mat8 = mat2(01.01, 2.01, 3.01, 4.01); + + mat3 test_mat9 = mat3(test_vec7, test_vec7, test_vec7); + mat4 test_mat10 = mat4(test_vec10, test_vec10, test_vec10, test_vec10); + test_mat10[1] = test_vec10; + + + mat2 test_mat12 = mat2(test_vec2, 0.01, 0.01); + mat2 test_mat13 = mat2(0.01, 5., test_vec2); + mat2 test_mat15 = mat2(0.1, 5., test_vec2 ); + + //mat2 test_mat16 = mat2(test_mat9); + //mat2 test_mat17 = mat2(test_mat10); + + float freq1[2]; + float freq2[25]; + + for (int i=0; i<100; i++) + { + if (test_float1 < 1.0) + { + + } + else + { + break; + } + } + + freq2[1] = 1.9 ; + const int array_index = 2; + freq2[const_test_int1] = 1.9 ; + freq2[array_index] = 1.8; + + const int const_int = 5; + + test_float1 = varying_flt; + + int out_int; + int intArray[6]; + test_function(test_int1, test_int1); + test_function(test_int1, intArray[2]); + + vec3 vv = vec3(test_function1(test_int1, out_int)); + bool bool_var = true; + int test_int6 = int(bool_var); + test_float1 = float(bool_var); + test_float1 = float(test_int6); + test_int6 = int(test_float1); + bool_var = bool(test_int6); + bool_var = bool(test_float1); + test_float1 = float(test_vec9); + + test_vec2.x = 1.2; + test_vec2.y = 1.4; + test_vec2.xy; + + + color.zy = test_vec2; + + test_vec2[1] = 1.1; + + test_mat2[0][0] = 1.1; + + test_float1 += 1.0; + test_float1 -= 1.0; + test_float1 *= 1.0; + test_float1 /= 1.0; + + test_mat12 *= test_mat13 ; + test_mat12 *= test_float1; + test_vec2 *= test_float1; + test_vec2 *= test_mat12; + test_float1++; + test_float1--; + --test_float1; + ++test_float1; + test_float1; + test_int1++; + test_int1--; + + test_vec2 = test_vec2 + test_float1; + test_vec2 = test_float1 + test_vec2; + + test_mat12 = test_mat12 * test_mat13; + test_vec2 = test_vec2 * test_vec5; + + test_vec2++; + test_mat2++; + + bool test_bool2 = test_float2 > test_float3; + + bool test_bool3 = test_int1 > test_int6 ; + + test_bool3 = test_vec2 == test_vec5; + + test_bool2 = test_bool3 && test_bool4; + test_bool2 = test_bool3 || test_bool4; + test_bool2 = test_bool3 ^^ test_bool4; + + test_bool2 = !test_bool3; + + test_bool3 = !(test_int1 > test_int6) ; + + test_float1 = test_int1 > test_int6 ? test_float2 : test_float3; + test_vec2 = test_int1 > test_int6 ? test_vec2 : test_vec5; + if(test_bool2) + test_float1++; + else + test_float1--; + + if(test_float1 > test_float2) + test_float1++; + + if( test_bool2 ) + { + int if_int; + test_float1++; + } + + if(test_bool2) + if(test_bool3) + if(test_bool3) + test_float1++; + + for(int for_int=0; for_int < 5; for_int++) + { + // do nothing as such + } + + + for(int x1=0; x1 < 10; x1++) + { + if (!test_bool2) + break; + + int for_int; + } + + for(int x2=-10; x2 < 100; x2++) + { + test_bool2 = (test_float1 > test_float2); + if (!test_bool2) + break; + } + + for(int for_int1 = 0; for_int1 < 100; for_int1++) + { + if (!test_bool2) + break; + + int for_int; + } + + for(int for_int1 = 0; for_int1 < 100; for_int1++) + { + if (!test_bool2) + continue; + + int for_int; + } + + + for(int i=0; i<100; i++) + { + if (!(test_float1 > test_float2)) + { + break; + } + + break; + continue; + } + + for(int i=0; i<100; i++) + { + if (!test_bool2) + break; + + break; + } + + for (int i=0; i<100; i++) + { + int dowhile_int; + dowhile_int = 3; + + if (!test_bool2) + break; + } + + gl_Position = vec4(2.0, 3.0, 1.0, 1.1); + gl_Position = gtf_Vertex; + + + // VERTEX SHADER BUILT-IN ATTRIBUTES + + vec4 builtInV4 = gtf_Color + gtf_SecondaryColor + gtf_Vertex + gtf_MultiTexCoord0 + gtf_MultiTexCoord1 + gtf_MultiTexCoord2 + gtf_MultiTexCoord3; + + + int builtInI = gtf_MaxLights + gtf_MaxClipPlanes + gtf_MaxTextureUnits + gtf_MaxTextureCoords + gtf_MaxVertexAttribs + gtf_MaxVertexUniformComponents + gtf_MaxVaryingFloats + gtf_MaxVertexTextureImageUnits + gtf_MaxCombinedTextureImageUnits + gtf_MaxTextureImageUnits + gtf_MaxFragmentUniformComponents + gtf_MaxDrawBuffers ; + + + mat4 builtInM4 = gtf_ModelViewMatrix + gtf_ModelViewProjectionMatrix + gtf_ProjectionMatrix; + + gtf_NormalMatrix; + + gtf_TextureMatrix[gtf_MaxTextureCoords-1]; + gtf_TextureMatrix; + + gtf_DepthRange.near ; + + test_float1 = gtf_DepthRange.near; + test_float1 = gtf_DepthRange.far; + test_float1 = gtf_DepthRange.diff; + + gtf_Point.size; + gtf_Point.sizeMin; + gtf_Point.sizeMax; + gtf_Point.fadeThresholdSize ; + gtf_Point.distanceConstantAttenuation; + gtf_Point.distanceLinearAttenuation ; + gtf_Point.distanceQuadraticAttenuation; + + gtf_MaterialParameters test; + gtf_FrontMaterial.emission; + + color = gtf_FrontMaterial.emission; + color = gtf_FrontMaterial.ambient; + color = gtf_FrontMaterial.diffuse; + color = gtf_FrontMaterial.specular; + test_float1 = gtf_FrontMaterial.shininess; + + gtf_LightSourceParameters lightSource; + + float builtInFloat1 = gtf_LightSource[0].spotExponent; + color = gtf_LightSource[0].ambient; + color = lightSource.ambient; + color = lightSource.diffuse; + color = lightSource.specular; + color = lightSource.position; + color = lightSource.halfVector; + color4 = lightSource.spotDirection; + test_float1 = lightSource.spotExponent; + test_float1 = lightSource.spotCutoff; + test_float1 = lightSource.spotCosCutoff; + test_float1 = lightSource.constantAttenuation; + test_float1 = lightSource.linearAttenuation; + test_float1 = lightSource.quadraticAttenuation; + + color = gtf_LightModel.ambient; + + gtf_LightModelParameters lightModel; + color = gtf_LightModel.ambient; + color = lightModel.ambient; + + color = gtf_FrontLightModelProduct.sceneColor ; + + gtf_LightModelProducts lightModelProd; + + color = lightModelProd.sceneColor; + color = gtf_FrontLightModelProduct.sceneColor; + + color = gtf_FrontLightProduct[0].ambient; + color = gtf_FrontLightProduct[0].ambient; + gtf_LightProducts lightProd; + + color = lightProd.ambient; + color = lightProd.diffuse; + color = lightProd.specular; + + + test_float1 = gtf_Fog.density ; + test_float1 = gtf_Fog.start ; + test_float1 = gtf_Fog.end ; + test_float1 = gtf_Fog.scale ; + color = gtf_Fog.color ; + + gtf_FrontColor = vec4(1.0, 1.0, 1.0, 1.0); + gtf_BackColor = vec4(1.0, 1.0, 1.0, 1.0); + gtf_FrontSecondaryColor = vec4(1.0, 1.0, 1.0, 1.0); + gtf_BackSecondaryColor = vec4(1.0, 1.0, 1.0, 1.0); + + + // VARYING VARIABLES AVAILABLE IN FRAGMENT AND VERTEX SHADERS BOTH + gtf_TexCoord[0] = vec4(1.0, 1.0, 1.0, 1.0); + gtf_FogFragCoord = vec4(1.0, 1.0, 1.0, 1.0); + +} + +void test_function(const in int in_int, inout int out_int) +{ + out_int = 5; + int i = 5; + return ; +} + +int test_function1(in int in_int1, inout int in_out_int) +{ + float ff; + in_int1 = 5; + return in_int1; +} + +void test_function3(light3 ll) +{ + ll.i = 5.0; + varying_flt = 1.2; +} + +void test_function4(light5 ll20) +{ + ll20.i = 10.0; +} + +void test_function5(light1 struct_light1) +{ + struct_light1.light2.a = 1; + light5 ll5; + struct_light1.light2.f = ll5.i; + struct_light1.light2.f++; + struct_light1.light2.a++; +} + +light6 test_function6(int a) +{ + int x; + light6 funcStruct; + light7 funcStruct1; + -x; + x = x - x ; + mat2 m; + m++; + -m; + (m)++; + return funcStruct; +} + +float test_function7(light1 ll1, int light1 ) +{ + float f; + + struct ss1 { + int a; + }; + + return float(1); +} |