AnsweredAssumed Answered

glGetProgramiv(handle, GL_LINK_STATUS, &status) access violation

Question asked by martyj2009 on Apr 25, 2013

When I call the function glGetProgramiv to retrieve the link status like this:

 

 

 

int status = 0;

glGetProgramiv(handle, GL_LINK_STATUS, &status);

 

 

 

I get an access violation error. This problem only occurs if I get the link status when my Tessellation Control and Tessellation Evaluation shaders. I am pretty sure the problem occurs with my shader code but I have no way of knowing as there is no error messages from OpenGL.

 

 

 

My graphics card is a Radeon HD 6870.

 

 

 

Below is my GLSL code.

 

 

 

Vertex

#version 150

 

in vec3 vertexPosition;

in vec4 vertexColor;

in vec3 vertexNormal;

in vec2 textureCoords;

in float textureIndex;

 

out VertexData

{

    vec4 VertexColors;

    vec3 VertexNormals;

    vec2 TextureCoords;

    float TextureIndexs;

} vertex;

 

void main()

{

    gl_Position = vec4(vertexPosition, 1.0);

    vertex.VertexColors = vertexColor;

    vertex.VertexNormals = vertexNormal;

    vertex.TextureCoords = textureCoords;

    vertex.TextureIndexs = textureIndex;

}

 

Tessellation Control

#version 400

 

layout(vertices = 3) out;

 

in VertexData

{

    vec4 VertexPosition;

    vec4 VertexColors;

    vec3 VertexNormals;

    vec2 TextureCoords;

    float TextureIndexs;

} vertsIn[];

 

out VertexData

{

    vec4 VertexPosition;

    vec4 VertexColors;

    vec3 VertexNormals;

    vec2 TextureCoords;

    float TextureIndexs;

} vertsOut[];

 

void main()

{

    float inLevel = 2;

    float outLevel = 2;

   

    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;

 

    vertsOut[gl_InvocationID].VertexColors = vertsIn[gl_InvocationID].VertexColors;

    vertsOut[gl_InvocationID].VertexNormals = vertsIn[gl_InvocationID].VertexNormals;

    vertsOut[gl_InvocationID].TextureCoords = vertsIn[gl_InvocationID].TextureCoords;

    vertsOut[gl_InvocationID].TextureIndexs = vertsIn[gl_InvocationID].TextureIndexs;

 

    if (gl_InvocationID == 0)

    {

        gl_TessLevelOuter[0] = outLevel;

        gl_TessLevelOuter[1] = outLevel;

        gl_TessLevelOuter[2] = outLevel;

        gl_TessLevelOuter[3] = outLevel;

 

        gl_TessLevelInner[0] = inLevel;

        gl_TessLevelInner[1] = inLevel;

    }

}

 

Tessellation Evaluation

#version 400

 

layout(triangles, equal_spacing, ccw) in;

 

in VertexData

{

    vec4 VertexColors;

    vec3 VertexNormals;

    vec2 TextureCoords;

    float TextureIndexs;

} vertex[];

 

out VertexData

{

    vec4 VertexColors;

    vec3 VertexNormals;

    vec2 TextureCoords;

    float TextureIndexs;

} vOut;

 

void main()

{

    vec4 p0 = gl_TessCoord.x * gl_in[0].gl_Position;

    vec4 p1 = gl_TessCoord.y * gl_in[1].gl_Position;

    vec4 p2 = gl_TessCoord.z * gl_in[2].gl_Position;

 

    vec4 newCoord = normalize(p0 + p1 + p2);

    vec3 normal = cross(vec3(p0 - newCoord), vec3(p1 - newCoord));

 

    vOut.VertexColors =  vertex[0].VertexColors;

    vOut.VertexNormals =  normal;

    vOut.TextureCoords = vec2(gl_TessCoord.xy);

    vOut.TextureIndexs = vertex[0].TextureIndexs;

    gl_Position = newCoord;

}

Geometry

#version 400

 

layout(triangles) in;

layout(triangle_strip, max_vertices = 3) out;

 

in VertexData

{

    vec4 VertexColors;

    vec3 VertexNormals;

    vec2 TextureCoords;

    float TextureIndexs;

} vertex[];

 

uniform vec3 LightNorm;

uniform vec4 LightIntensReflect;

 

uniform vec4 AmbientLight;

uniform bool UseLighting;

uniform bool UseTexture;

uniform bool UseTextureArray;

 

uniform mat4 uMVPMatrix;

uniform mat4 DepthBiasMVP;

uniform mat3 uNMatrix;

 

uniform bool UseWaveGeometry;

uniform float GameTime;

 

out vec4 LightShade;

out vec4 ShadowCoord;

out vec4 vColor;

out vec3 tCoord;

 

float rand(vec2 n)

{

    return 0.5 + 0.5 * fract(sin(dot(n.xy, vec2(12.9898, 78.233)))* 43758.5453);

}

 

void setUpValues(int index)

{

    vec4 vertPosit = gl_in[index].gl_Position;

    if(UseTexture)

    {

        tCoord = vec3(vertex[index].TextureCoords.st, vertex[index].TextureIndexs);

    }

   

    if(UseLighting)

    {

        ShadowCoord = DepthBiasMVP * vertPosit;

 

        vec3 tnorm = normalize(uNMatrix * vertex[index].VertexNormals);       

       

        LightShade = LightIntensReflect * max(dot(LightNorm, tnorm), 0.0);

        vColor = LightShade * vertex[index].VertexColors + (AmbientLight * vertex[index].VertexColors);

    }

    else

    {

        vColor = vertex[index].VertexColors;

    }

 

    if(UseWaveGeometry)

    {

        if(false)

        {

        vertPosit.y = vertPosit.y + GameTime + ((cos(vertPosit.x) + cos(vertPosit.z)) * GameTime) - ((sin(vertPosit.x) + sin(vertPosit.z))*GameTime);

        }

        vertPosit.y = vertPosit.y + (GameTime + ((cos(vertPosit.x)) * GameTime) - ((sin(vertPosit.x))*GameTime)*2.2);

    }

 

    gl_Position = uMVPMatrix * vertPosit;

}

 

void main()

{

    for(int i = 0; i < 3; i++)

    {

        setUpValues(i);

        EmitVertex();

    }

    EndPrimitive();

}

 

Fragment

#version 150

#extension GL_EXT_gpu_shader4: enable

#extension GL_EXT_texture_array: enable

 

uniform sampler2DShadow ShadowMap;

uniform sampler2D TextureData;

uniform sampler2DArray TextureArrayData;

 

uniform vec4 AmbientLight;

uniform bool UseLighting;

uniform bool UseTexture;

uniform bool UseTextureArray;

uniform bool UseAlpha;

uniform float ColorAlpha;

 

in vec4 vColor;

in vec4 LightShade;

in vec4 ShadowCoord;

in vec3 tCoord;

 

out vec4 FragColor;

 

void main()

{

    vec4 color = vec4(1.0);

    float Shadow = 1.0;

    if(UseTexture)

    {

        if(UseTextureArray)

        {

            color = texture2DArray(TextureArrayData, tCoord.stp);

        }

        else

        {

            color = texture2D(TextureData, tCoord.st);

        }

 

        if(UseLighting)

        {

            Shadow = textureProj(ShadowMap, ShadowCoord);

        }

 

        if(UseAlpha)

        {

            color = vec4(color.r, color.g, color.b, ColorAlpha);

        }

 

        FragColor = (LightShade * color) * Shadow + (color * AmbientLight);

    }

    else

    {

        float Shadow = 1.0;

        if(UseLighting)

        {

            Shadow = textureProj(ShadowMap, ShadowCoord);

        }

       

        if(UseAlpha)

        {

            color = vec4(vColor.r, vColor.g, vColor.b, ColorAlpha);

        }

 

        FragColor = color * Shadow;

    }

}

 

Thank you for your time,

Marty

Outcomes