title: c++ OpenGL glGetUniformLocation for Sampler2D returns -1 on Raspberry PI but works on Windows
body: <p>I'm making a crossplatform OpenGL program. However, I've encountered a problem, where glGetUniformLocation, which should return the location of a uniform variable in my shader program, returns -1, and it only occurs on Linux (Raspbian distro, ran on Raspberry PI), and on Windows the same code works perfectly! Here's my code:</p>
  
  <p><strong>Load Shader program function:</strong></p>
  
  <pre><code>int shader, status;
  
  programID = glCreateProgram();
  
  // Load vertex shader
  shader = LoadShaderFromString(GL_VERTEX_SHADER, Tools::GetFileAsString("VertexShader.glsl"), "Unable to compile vertex shader.\n");
  glAttachShader(programID, shader);
  
  // Load pixel shader
  shader = LoadShaderFromString(GL_FRAGMENT_SHADER, Tools::GetFileAsString("FilterPixelShader.glsl"), "Unable to compile pixel shader.\n");
  glAttachShader(programID, shader);
  
  // Link the program
  glLinkProgram(programID);
  glGetProgramiv(programID, GL_LINK_STATUS, &amp;status);
  
  if (status == 0)
  {
      Log("Unable to link filter shader program.\n");
      PrintProgramLog(programID);
      Fail();     // Quits program
  }   
  
  // returns -1 here!
  frameTextureLocation = glGetUniformLocation(programID, "FrameTextureUnit");
  if (frameTextureLocation == -1)
  {
      int errorCode = glGetError();
      Log(string("Error retrieving variable frameTextureLocation from shader program: "));
      Log((const char*)glewGetErrorString(errorCode))
      Log("!\n");
      Fail();
  }
  </code></pre>
  
  <p><strong>LoadShaderFromString:</strong></p>
  
  <pre><code>int Shader::LoadShaderFromString(int type, const string&amp; shaderSource, const string&amp; errorMessage)
  {
      int shader, status;
      const char* programSource;
  
      shader = glCreateShader(type);
      programSource = shaderSource.c_str();
      glShaderSource(shader, 1, &amp;programSource, nullptr);
      glCompileShader(shader);
      glGetShaderiv(shader, GL_COMPILE_STATUS, &amp;status);
  
      if (status == 0)
      {
          Log(errorMessage);
          PrintShaderLog(shader);
          Fail();
      }
  
      return shader;
  }
  </code></pre>
  
  <p><strong>Lastly, the shader itself:</strong></p>
  
  <pre><code>uniform sampler2D FrameTextureUnit; 
  uniform sampler2D BackgroundTextureUnit;
  
  #if __VERSION__ &gt;= 130 
      // Texture coordinate 
      in vec2 texCoord; 
  
      // Final color 
      out vec4 gl_FragColor; 
  #else
      // Texture coordinate 
      varying vec2 texCoord; 
  #endif
  
  uniform float Tolerance;                    // Tolerance for color difference
  uniform vec4 FilterColor;                   // Color of the filter
  
  void main()
  {
      vec4 pixel = texture2D(FrameTextureUnit, texCoord);
      vec4 background = texture2D(BackgroundTextureUnit, texCoord);
  
      float difference = abs(background.x - pixel.x)
                     + abs(background.y - pixel.y)
                     + abs(background.z - pixel.z);
  
      if (difference &gt; Tolerance)
      {
          gl_FragColor = FilterColor;
      }
      else
      {
          // Y = 0.2126 R + 0.7152 G + 0.0722 B 
          float gray = pixel.x * 0.2126 + pixel.y * 0.7152 + pixel.z * 0.0722;
          gl_FragColor = vec4(gray, gray, gray, 1);
      }
  }
  </code></pre>
  
  <p>Does anyone know why this might be happening? :( It's worth adding that the error handling code:</p>
  
  <pre><code>    int errorCode = glGetError();
      Log(string("Error retrieving variable frameTextureLocation from shader program: "));
      Log((const char*)glewGetErrorString(errorCode));
  </code></pre>
  
  <p><strong>Prints "Error retrieving variable frameTextureLocation from shader program: No error".</strong></p>