glGetUniformLocation Returns -1

Question

I've been trying to develop shaders that would allow me to easily display text on screen using a font texture. I've previously written shaders that simply drew the text on screen and I passed the exact coordinates for the vertices and UV coordinates to the shaders. With my new shaders, I'm trying to pass just a single point for each letter, representing the bottom left corner each letter, as well as a single point for the UV coordinate of the letter, representing its location on the font texture. I then use a geometry shader to generate the triangles and UV coordinates necessary to draw the letters. Here is my code for the shaders:

Vertex Shader:

#version 330
layout(location = 0) in vec2 vertexPosition;
layout(location = 1) in vec2 vertexUV;
layout(location = 2) in float textSize;
uniform unsigned int textureX;
uniform unsigned int textureY;
out VertexData
{
    vec2 uv;
    float textSize;
} outputData;
void main()
{
    // Represents the bottom left corner
    gl_Position = vec4(vertexPosition, 0.0f, 1.0f);
    // Convert the UV coordinates from [0, textureX - 1] to [0, 1]
    outputData.uv = vertexUV / vec2(textureX, textureY);
    outputData.textSize = textSize;
}

Geometry Shader:

#version 330
layout(points) in;
layout(triangle_strip, max_vertices = 6) out;
uniform unsigned int textureX;
uniform unsigned int textureY;
in VertexData
{
    vec2 uv;
    float textSize;
} inputData[];
out FragmentData
{
    vec2 uv;
} outputData;
void main()
{
    float textureWidth = 1.0f / textureX;
    float textureHeight = 1.0f / textureY;
    // Calculate the vertices
    vec2 brCorner = vec2(gl_in[0].gl_Position) + vec2(inputData[0].textSize, 0.0f);
    vec2 tlCorner = vec2(gl_in[0].gl_Position) + vec2(0.0f, inputData[0].textSize);
    vec2 trCorner = vec2(gl_in[0].gl_Position) + vec2(inputData[0].textSize, inputData[0].textSize);
    vec2 uvBR = inputData[0].uv + vec2(textureWidth, 0.0f);
    vec2 uvTL = inputData[0].uv + vec2(0.0f, textureHeight);
    vec2 uvTR = inputData[0].uv + vec2(textureWidth, textureHeight);
    gl_Position = vec4(tlCorner, 0.0f, 1.0f);
    outputData.uv = uvTL;
    EmitVertex();
    gl_Position = gl_in[0].gl_Position;
    outputData.uv = inputData[0].uv;
    EmitVertex();
    gl_Position = vec4(trCorner, 0.0f, 1.0f);
    outputData.uv = uvTR;
    EmitVertex();
    EndPrimitive();
    gl_Position = gl_in[0].gl_Position;
    outputData.uv = inputData[0].uv;
    EmitVertex();
    gl_Position = vec4(brCorner, 0.0f, 1.0f);
    outputData.uv = uvBR;
    EmitVertex();
    gl_Position = vec4(trCorner, 0.0f, 1.0f);
    outputData.uv = uvTR;
    EmitVertex();
    EndPrimitive();
}

Fragment Shader:

#version 330 core
in FragData
{
    vec2 uv;
} inputData;
out vec4 color;
uniform sampler2D textureSampler;
void main()
{
    color = texture2D(textureSampler, inputData.uv);
}

When I call glGetUniformLocation for the textureSampler uniform in my fragment shader, I get a valid uniform location back. However, when I call glGetUniformLocation for textureX and textureY, glGetUniformLocation returns -1. When I searched for what could cause this, the main cause of this issue is usually the compiler optimizing the variable out as it's not used. I don't believe this to be true in my case, but I have no idea what could be causing glGetUniformLocation to return -1 for this.

Edit: After reading Andon M. Coleman's excellent answer on how active uniforms are determined, I discovered the issue. The name of the struct the geometry shader outputs and the name of the struct the fragment shader accepts are different-

Geometry Shader:

out FragmentData
{
    vec2 uv;
} outputData;

Fragment Shader:

in FragData
{
    vec2 uv;
} inputData;

After changing the structs to share the same name, I am able to get a valid uniform location back.

Answer 1

Since there was a little bit of confusion in the comments regarding what is required for a uniform to be active, I will try to explain it here.

The first thing you need to understand is that in OpenGL, GLSL programs are built in two phases:

1. Compile
2. Link

These are analogous to compiling and linking in a language like C, except some implementations of GLSL (e.g. NVIDIA) actually "compile" your shader in both phases. The most important thing that happens in the Compile phase is that general parse / syntax errors are caught, and inputs and outputs are determined.

After the compile phase determines the set of inputs and outputs for each stage of the GLSL program, the Link phase then assigns data locations to things like generic vertex attribute locations, fragment bindings, uniform locations, etc. But there is a catch, it only assigns locations to uniforms that actively contribute to pipeline output.

---

Below are two overly-simplified shaders that exemplify what happens when a Vertex Shader outputs something that is not used by any other stage to produce an output.

Hypothetical Vertex Shader _{(Active + Inactive Uniforms)}

#version 330

uniform float UsedButNotActive;
uniform float Active;

in      vec4  ndc_vtx;

out     float UsedButNotOutput;
out     float Used;

void main (void)
{
  gl_Position = ndc_vtx;

  UsedButNotOutput = UsedButNotActive;
  Used             = Active;
}

Hypothetical Fragment Shader

#version 330

in  float UsedButNotOutput;
in  float Used;

out vec4  color;

void main (void)
{
  // Inactive, because this does not produce any output
  float Pointless = sqrt (UsedButNotOutput);

  // Used, and any variable that was used to compute it, is part of an active code path
  color = vec4 (Used);
}

Because the variable Used is the only variable in the fragment shader stage that contributes to an output, it is the only active code path. This means the uniform Active is part of an active code path and will be assigned a uniform location.

UsedButNotOuput, on the other hand, is used to compute something in the fragment shader, but that something is never output. This variable effectively dies inside the fragment shader. If you trace its path back to the vertex shader, you will see that UsedButNotActive was used to set this value, but does not belong to an active code path. Thus, that uniform is not active and is not assigned a uniform location.

---

Remember how I mentioned that some GLSL implementations compile your shader twice? Well, after all this active vs. inactive codepath determination, some lines and variables will effectively be stripped from the shader the second time it is compiled.

Hypothetical Link-Phase Vertex Shader _{(Active Uniforms)}

#version 330

//uniform float UsedButNotActive; -- STRIPPED
uniform float Active;

in      vec4  ndc_vtx;

//out     float UsedButNotOutput; -- STRIPPED
out     float Used;

void main (void)
{
  gl_Position = ndc_vtx;

  //UsedButNotOutput = UsedButNotActive; -- STRIPPED
  Used   = Active;
}

Hypothetical Link-Phase Fragment Shader

#version 330

//in  float UsedButNotOutput; -- STRIPPED
in  float Used;

out vec4  color;

void main (void)
{
  //float Pointless = sqrt (UsedButNotOutput); -- STRIPPED

  // Used, and any variable that was used to compute it, is part of an active code path
  color = vec4 (Used);
}

---

It is worth mentioning that some of this behavior is altered by new OpenGL features such as Separate Shader Objects, which makes the concept of active vs. inactive uniforms almost meaningless / impossible to determine. Also, when transform feedback is used, it means that data does not have to be output from the fragment shader stage in order for a variable to be involved in an active codepath. However, this explanation should make it obvious why if you are missing the geometry shader stage of your GLSL program in your code, then the uniforms textureX and textureY do not belong to any active code paths.

Also note that any uniform used to calculate gl_Position is active simply because gl_Position is an important interpolated/used input for every shader stage following vertex. It is responsible for producing gl_FragCoord, which determines where the fragment is output in the fragment shader stage, for instance.