Thank you for your replies, sadly I still haven’t been able to find a solution to the problem although I’m getting close (I think). I am using glew and freeglut for my context and I looked into retrieving context information as John suggested and here’s what I managed to do:
main.cpp:
// Local Includes
#include "Game.h"
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(200, 200);
glutInitWindowSize(WIDTH, HEIGHT);
glutCreateWindow("Robotron 3D");
glewInit();
// -------------------
// DEBUGGING
// -------------------
GLint major = 0;
GLint minor = 0;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &major);
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &minor);
std::cout << "major: " << major << ", " << "minor: " << minor << "
"; // Output is 2, 2 (I do not fully understand what that means though)
// -------------------
//MainMenu();
InitializeGameContents(); // Temp (remove later uncomment above line)
// Register callbacks
glutDisplayFunc(render);
glutKeyboardFunc(KeyboardDown);
glutKeyboardUpFunc(KeyboardUp);
glutSpecialFunc(SpecialKey);
glutSpecialUpFunc(SpecialKeyUp);
glutTimerFunc(10, Update, 0);
glutMainLoop();
return 0;
}
Here is how my shader.cpp looks like at this moment:
// Local Includes
#include "Shader.h"
// Pre-processor directives
#include <vector>
// STD Elements
using std::getline;
using std::cout;
// GLuint shaderID = 0;
std::string ShaderTypeName(GLuint shader)
{
if (glIsShader(shader))
{
GLint shaderType = 0;
glGetShaderiv(shader, GL_SHADER_TYPE, &shaderType);
if (shaderType == GL_VERTEX_SHADER)
return "Vertex Shader";
if (shaderType== GL_TESS_CONTROL_SHADER)
return "Tessellation Control Shader";
if (shaderType == GL_TESS_EVALUATION_SHADER)
return "Tessellation Evaluation Shader";
if (shaderType == GL_GEOMETRY_SHADER)
return "Geometry Shader";
if (shaderType == GL_FRAGMENT_SHADER)
return "Fragment Shader";
if (shaderType == GL_COMPUTE_SHADER)
return "Compute Shader";
}
return "invalid shader";
}
std::string Shader::LoaderShaderFile(char* filename)
{
std::string shaderCode;
std::ifstream file(filename, std::ios::in);
if (!file.good())
{
std::cout << "ERROR: Unable to read file: " << filename << std::endl;
std::terminate();
}
file.seekg(0, std::ios::end);
shaderCode.resize((unsigned int)file.tellg());
file.seekg(0, std::ios::beg);
file.read(&shaderCode[0], shaderCode.size());
file.close();
return shaderCode;
}
GLuint Shader::CreateShader(GLenum shaderType, std::string source, char* shaderName)
{
int compile_result = 0;
GLuint shader = glCreateShader(shaderType);
const char* shader_code_ptr = source.c_str();
const int shader_code_size = source.size();
glShaderSource(shader, 1, &shader_code_ptr, &shader_code_size);
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_result);
//check for errors
if (compile_result == GL_FALSE)
{
int info_log_length = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);
std::vector<char> shader_log(info_log_length);
glGetShaderInfoLog(shader, info_log_length, NULL, &shader_log[0]);
std::cout << "ERROR compiling shader: " << shaderName << std::endl << &shader_log[0] << std::endl;
return 0;
}
return shader;
}
void Shader::UpdateSkyboxTexture(GLuint& SkyboxID)
{
glDepthMask(GL_FALSE);
glUniform1i(glGetUniformLocation(m_program, "Skybox"), 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, SkyboxID);
glDepthMask(GL_TRUE);
}
// Get uniform
void Shader::UpdateTransform(const MatrixTransform& transformation, const Camera& camera)
{
m_uniforms[TRANSFORM_U] = glGetUniformLocation(m_program, "TransformationMatrix");
glm::mat4 ModelMatrix = camera.GetWorldToViewMatrix() * transformation.GetModel();
glUniformMatrix4fv(m_uniforms[TRANSFORM_U], 1, GL_FALSE, &ModelMatrix[0][0]);
}
std::string Shader::ShaderInfoLog(GLuint shader)
{
if (glIsShader(shader))
{
GLint logsize = 0;
GLchar infolog[1024] = { 0 };
glGetShaderInfoLog(shader, 1024, &logsize, infolog);
return std::string(infolog);
}
return "invalid shader";
}
std::string Shader::ProgramInfoLog(GLuint program)
{
if (glIsProgram(program))
{
GLint logsize = 0;
GLchar infolog[1024] = { 0 };
glGetProgramInfoLog(program, 1024, &logsize, infolog);
return std::string(infolog);
}
return "invalid program";
}
GLuint Shader::CreateProgram(char* vertexShaderFilename, char* fragmentShaderFilename)
{
//read the shader files and save the code
std::string vertex_shader_code = LoaderShaderFile(vertexShaderFilename);
std::string fragment_shader_code = LoaderShaderFile(fragmentShaderFilename);
GLuint vertex_shader = CreateShader(GL_VERTEX_SHADER, vertex_shader_code, "vertex shader");
GLuint fragment_shader = CreateShader(GL_FRAGMENT_SHADER, fragment_shader_code, "fragment shader");
int link_result = 0;
//create the program handle, attatch the shaders and link it
GLuint program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &link_result);
//check for link errors
if (link_result == GL_FALSE)
{
int info_log_length = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_log_length);
std::vector<char> program_log(info_log_length);
glGetProgramInfoLog(program, info_log_length, NULL, &program_log[0]);
std::cout << "ERROR: Linking Operation Failed " << std::endl << &program_log[0] << std::endl;
return 0;
}
// ----------------------
// DEBUGGING
// ----------------------
std::string CheckVertexShader = "", CheckFragShader = "", CheckType = "";
CheckVertexShader = ShaderInfoLog(vertex_shader);
CheckFragShader = ShaderInfoLog(fragment_shader);
std::cout << CheckVertexShader << "
";
std::cout << CheckFragShader << "
";
CheckType = ShaderTypeName(fragment_shader);
std::cout << CheckType << "
";
// ------------------------------------------------
return program;
}
So I haven’t been able to determine the cause of the problem yet but maybe I’d get something from the shader logs when I try to run the code on the other machine (the one that renders everything invisible), though I do not have access to it right now so I’d have to wait for tomorrow to be able to test that out. Hopefully I’ll be able to get this issue sorted out and if not then at least I tried. I’m still very thankful for your help 
