
/*
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);
}
