GLuint Shader_Loader::CreateProgram(char* vertexShaderFilename, char* fragmentShaderFilename){ //read the shader files and save the code std::string vertex_shader_code = ReadShader(vertexShaderFilename); std::string fragment_shader_code = ReadShader(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 << "Shader Loader : LINK ERROR" << std::endl << &program_log[0] << std::endl; return 0; } return program; }
void Shader::Init(const char* vertexShaderPath, const char* fragmentShaderPath) { _vertexProgram = glCreateShader(GL_VERTEX_SHADER); _fragmentProgram = glCreateShader(GL_FRAGMENT_SHADER); std::string vertexShaderText; std::string fragmentShaderText; if (!ReadShader(vertexShaderPath, vertexShaderText) || !ReadShader(fragmentShaderPath, fragmentShaderText)) { std::cerr << "Either vertex shader or fragment shader file not found." << std::endl; return; } const char* constVST = vertexShaderText.c_str(); const char* constFST = fragmentShaderText.c_str(); glShaderSource(_vertexProgram, 1, &constVST, 0); glShaderSource(_fragmentProgram, 1, &constFST, 0); glCompileShader(_vertexProgram); ValidateShader(_vertexProgram, vertexShaderPath); glCompileShader(_fragmentProgram); ValidateShader(_fragmentProgram, fragmentShaderPath); _id = glCreateProgram(); glAttachShader(_id, _vertexProgram); glAttachShader(_id, _fragmentProgram); glLinkProgram(_id); ValidateProgram(_id); }
void Renderer::ChangeShaders() { CleanShaders(); QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this); QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this); //QOpenGLShader *gshader = new QOpenGLShader(QOpenGLShader::Geometry, this); bool compiled = ReadShader(vshader, "shaders\\vertexShader.ogl"); //compiled &= ReadShader(gshader, "shaders\\geometryShader.ogl"); compiled &= ReadShader(fshader, "shaders\\fragmentShader.ogl"); if (!compiled) return; makeCurrent(); CreateModels(); _shaderProgram = new QOpenGLShaderProgram; _shaderProgram->addShader(vshader); //_shaderProgram->addShader(gshader); _shaderProgram->addShader(fshader); _shaderProgram->bindAttributeLocation("vertexPosition_modelspace", VERTEX_LOCATION); _shaderProgram->bindAttributeLocation("vertexNormal_modelspace", NORMAL_LOCATION); _shaderProgram->bindAttributeLocation("barycentric", BARYCENTRIC_LOCATION); // vertdata + normals bool vbocreated = _vertexBuffer.create(); int vbSize = 0; DoAssert(vbocreated); bool vbobound = _vertexBuffer.bind(); DoAssert(vbobound); _indicesBuffer.create(); std::vector<GLfloat> vertexNormal; std::vector<int> indices; for (int i = 0; i < _renderData.size(); i++) { _renderData[i]._mesh.GetVertexNormal(vertexNormal); _renderData[i]._mesh.GetIndices(indices); } _vertexBuffer.allocate(vertexNormal.data(), vertexNormal.size() * sizeof(GLfloat)); _indicesBuffer.bind(); _indicesBuffer.allocate(indices.data(), indices.size() * sizeof(GLint)); _indices = indices.size(); if (!_shaderProgram->link()) { QString eeror = _shaderProgram->log(); emit reportSignal(MError, eeror); delete _shaderProgram; _shaderProgram = NULL; return; } _shaderProgram->bind(); update(); }
static GLuint CompileShader(const char *filename, GLenum type) { GLuint shader; assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER); shader = _mesa_CreateShader(type); ReadShader(shader, filename); return shader; }
bool GLShader::VInitFromFile(const UString& path) { /*grab source from file*/ const GLchar* source = ReadShader(path); if (!source) { DebugPrintF(VTEXT("Failed to parse shader source\n")); return false; } if (!LoadShader(source)) { DebugPrintF(VTEXT("Failed to init shader from file\n")); return false; } return true; }
GLuint LoadShaders( ShaderInfo* shaders ) { if ( shaders == NULL ) { return 0; } GLuint program = glCreateProgram(); ShaderInfo* entry = shaders; while ( entry->type != GL_NONE ) { GLuint shader = glCreateShader( entry->type ); entry->shader = shader; const GLchar* source = ReadShader( entry->filename ); if ( source == NULL ) { for ( entry = shaders; entry->type != GL_NONE; ++entry ) { glDeleteShader( entry->shader ); entry->shader = 0; } return 0; } glShaderSource( shader, 1, &source, NULL ); delete [] source; glCompileShader( shader ); GLint compiled; glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled ); if ( !compiled ) { #ifdef _DEBUG GLsizei len; glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &len ); GLchar* log = new GLchar[len+1]; glGetShaderInfoLog( shader, len, &len, log ); std::cerr << "Shader compilation failed: " << log << std::endl; delete [] log; #endif /* DEBUG */ return 0; } glAttachShader( program, shader ); ++entry; } #ifdef GL_VERSION_4_1 if ( GLEW_VERSION_4_1 ) { // glProgramParameteri( program, GL_PROGRAM_SEPARABLE, GL_TRUE ); } #endif /* GL_VERSION_4_1 */ glLinkProgram( program ); GLint linked; glGetProgramiv( program, GL_LINK_STATUS, &linked ); if ( !linked ) { #ifdef _DEBUG GLsizei len; glGetProgramiv( program, GL_INFO_LOG_LENGTH, &len ); GLchar* log = new GLchar[len+1]; glGetProgramInfoLog( program, len, &len, log ); std::cerr << "Shader linking failed: " << log << std::endl; delete [] log; #endif /* DEBUG */ for ( entry = shaders; entry->type != GL_NONE; ++entry ) { glDeleteShader( entry->shader ); entry->shader = 0; } return 0; } return program; }
static void Init(void) { const char *version; GLint i; version = (const char *) glGetString(GL_VERSION); if (version[0] != '2' || version[1] != '.') { printf("Warning: this program expects OpenGL 2.0\n"); /*exit(1);*/ } GetExtensionFuncs(); vertShader = glCreateShader_func(GL_VERTEX_SHADER); ReadShader(vertShader, VertProgFile); fragShader = glCreateShader_func(GL_FRAGMENT_SHADER); ReadShader(fragShader, FragProgFile); program = glCreateProgram_func(); glAttachShader_func(program, fragShader); glAttachShader_func(program, vertShader); glLinkProgram_func(program); CheckLink(program); glUseProgram_func(program); for (i = 0; Uniforms[i].name; i++) { Uniforms[i].location = glGetUniformLocation_func(program, Uniforms[i].name); printf("Uniform %s location: %d\n", Uniforms[i].name, Uniforms[i].location); switch (Uniforms[i].size) { case 1: glUniform1fv_func(Uniforms[i].location, 1, Uniforms[i].value); break; case 2: glUniform2fv_func(Uniforms[i].location, 1, Uniforms[i].value); break; case 3: glUniform3fv_func(Uniforms[i].location, 1, Uniforms[i].value); break; case 4: glUniform4fv_func(Uniforms[i].location, 1, Uniforms[i].value); break; default: abort(); } } assert(glGetError() == 0); glClearColor(0.4f, 0.4f, 0.8f, 0.0f); printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER)); assert(glIsProgram_func(program)); assert(glIsShader_func(fragShader)); assert(glIsShader_func(vertShader)); glColor3f(1, 0, 0); }
static void Init(void) { static const char *fragShaderText = "uniform vec4 diffuse;\n" "uniform vec4 specular;\n" "varying vec3 normal;\n" "void main() {\n" " // Compute dot product of light direction and normal vector\n" " float dotProd = max(dot(gl_LightSource[0].position.xyz, \n" " normalize(normal)), 0.0);\n" " // Compute diffuse and specular contributions\n" " gl_FragColor = diffuse * dotProd + specular * pow(dotProd, 20.0);\n" "}\n"; static const char *vertShaderText = "varying vec3 normal;\n" "void main() {\n" " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" " normal = gl_NormalMatrix * gl_Normal;\n" "}\n"; const char *version; version = (const char *) glGetString(GL_VERSION); if (version[0] != '2' || version[1] != '.') { printf("This program requires OpenGL 2.x, found %s\n", version); exit(1); } GetExtensionFuncs(); fragShader = glCreateShader_func(GL_FRAGMENT_SHADER); if (FragProgFile) ReadShader(fragShader, FragProgFile); else LoadAndCompileShader(fragShader, fragShaderText); vertShader = glCreateShader_func(GL_VERTEX_SHADER); if (VertProgFile) ReadShader(vertShader, VertProgFile); else LoadAndCompileShader(vertShader, vertShaderText); program = glCreateProgram_func(); glAttachShader_func(program, fragShader); glAttachShader_func(program, vertShader); glLinkProgram_func(program); CheckLink(program); glUseProgram_func(program); uDiffuse = glGetUniformLocation_func(program, "diffuse"); uSpecular = glGetUniformLocation_func(program, "specular"); uTexture = glGetUniformLocation_func(program, "texture"); printf("DiffusePos %d SpecularPos %d TexturePos %d\n", uDiffuse, uSpecular, uTexture); glUniform4fv_func(uDiffuse, 1, diffuse); glUniform4fv_func(uSpecular, 1, specular); /* assert(glGetError() == 0);*/ glUniform1i_func(uTexture, 2); /* use texture unit 2 */ /*assert(glGetError() == 0);*/ if (CoordAttrib) { int i; glBindAttribLocation_func(program, CoordAttrib, "coord"); i = glGetAttribLocation_func(program, "coord"); assert(i >= 0); if (i != CoordAttrib) { printf("Hmmm, NVIDIA bug?\n"); CoordAttrib = i; } else { printf("Mesa bind attrib: coord = %d\n", i); } } /*assert(glGetError() == 0);*/ glClearColor(0.3f, 0.3f, 0.3f, 0.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0f); MakeSphere(); MakeRect(); CurList = SphereList; #if TEXTURE MakeTexture(); #endif printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER)); printf("Press p to toggle between per-pixel and per-vertex lighting\n"); /* test glGetShaderSource() */ if (0) { GLsizei len = strlen(fragShaderText) + 1; GLsizei lenOut; GLchar *src =(GLchar *) malloc(len * sizeof(GLchar)); glGetShaderSource_func(fragShader, 0, NULL, src); glGetShaderSource_func(fragShader, len, &lenOut, src); assert(len == lenOut + 1); assert(strcmp(src, fragShaderText) == 0); free(src); } assert(glIsProgram_func(program)); assert(glIsShader_func(fragShader)); assert(glIsShader_func(vertShader)); glColor3f(1, 0, 0); /* for testing state vars */ { static GLfloat fc[4] = { 1, 1, 0, 0 }; static GLfloat amb[4] = { 1, 0, 1, 0 }; glFogfv(GL_FOG_COLOR, fc); glLightfv(GL_LIGHT1, GL_AMBIENT, amb); } #if 0 TestFunctions(); #else (void) TestFunctions; #endif }
static void Init(void) { static const char *fragShaderText = "uniform sampler2DShadow shadowTex2D; \n" "uniform sampler2DRectShadow shadowTexRect; \n" "void main() {\n" #if USE_RECT " gl_FragColor = shadow2DRectProj(shadowTexRect, gl_TexCoord[0]); \n" #else " gl_FragColor = shadow2D(shadowTex2D, gl_TexCoord[0].xyz); \n" #endif "}\n"; static const char *vertShaderText = "void main() {\n" " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" " gl_TexCoord[0] = gl_MultiTexCoord0; \n" "}\n"; const char *version; #if USE_RECT if (!glutExtensionSupported("GL_ARB_texture_rectangle")) { printf("This program requires GL_ARB_texture_rectangle\n"); exit(1); } #endif version = (const char *) glGetString(GL_VERSION); if (version[0] != '2' || version[1] != '.') { printf("This program requires OpenGL 2.x, found %s\n", version); exit(1); } printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER)); fragShader = glCreateShader(GL_FRAGMENT_SHADER); if (FragProgFile) ReadShader(fragShader, FragProgFile); else LoadAndCompileShader(fragShader, fragShaderText); vertShader = glCreateShader(GL_VERTEX_SHADER); if (VertProgFile) ReadShader(vertShader, VertProgFile); else LoadAndCompileShader(vertShader, vertShaderText); program = glCreateProgram(); glAttachShader(program, fragShader); glAttachShader(program, vertShader); glLinkProgram(program); CheckLink(program); glUseProgram(program); uTexture2D = glGetUniformLocation(program, "shadowTex2D"); uTextureRect = glGetUniformLocation(program, "shadowTexRect"); printf("uTexture2D %d uTextureRect %d\n", uTexture2D, uTextureRect); if (uTexture2D >= 0) { glUniform1i(uTexture2D, 0); /* use texture unit 0 */ } if (uTextureRect >= 0) { glUniform1i(uTextureRect, 1); /* use texture unit 0 */ } CheckError(__LINE__); glClearColor(0.3f, 0.3f, 0.3f, 0.0f); glColor3f(1, 1, 1); MakeTexture(); CheckError(__LINE__); }
void init() { gProgram = glCreateProgram(); { GLuint shader = glCreateShader(GL_VERTEX_SHADER); const GLchar* source = ReadShader("vertex-shader.txt"); if (source == NULL) { return; } glShaderSource(shader, 1, &source, NULL); delete[] source; glCompileShader(shader); GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_FALSE) { std::string msg("Compile failure in shader:\n"); GLint infoLogLength; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); char* strInfoLog = new char[infoLogLength + 1]; glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog); msg += strInfoLog; delete[] strInfoLog; glDeleteShader(shader); shader = 0; throw std::runtime_error(msg); } glAttachShader(gProgram, shader); } { GLuint shader = glCreateShader(GL_FRAGMENT_SHADER); const GLchar* source = ReadShader("fragment-shader.txt"); if (source == NULL) { return; } glShaderSource(shader, 1, &source, NULL); delete[] source; glCompileShader(shader); GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_FALSE) { std::string msg("Compile failure in shader:\n"); GLint infoLogLength; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); char* strInfoLog = new char[infoLogLength + 1]; glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog); msg += strInfoLog; delete[] strInfoLog; glDeleteShader(shader); shader = 0; throw std::runtime_error(msg); } glAttachShader(gProgram, shader); } glLinkProgram(gProgram); //glDetachShader(program, shader); GLint linkStatus; glGetProgramiv(gProgram, GL_LINK_STATUS, &linkStatus); if (linkStatus == GL_FALSE) { std::string msg("Program linking failure: "); GLint infoLogLength; glGetProgramiv(gProgram, GL_INFO_LOG_LENGTH, &infoLogLength); char* strInfoLog = new char[infoLogLength + 1]; glGetProgramInfoLog(gProgram, infoLogLength, NULL, strInfoLog); msg += strInfoLog; delete[] strInfoLog; glDeleteProgram(gProgram); gProgram = 0; throw std::runtime_error(msg); } glUseProgram(gProgram); /* glm::mat4 projection = glm::perspective(glm::radians(50.0f), 800.0f / 600.0f, 0.1f, 10.0f); GLint uniformProjection = glGetUniformLocation(gProgram, "projection"); if (uniformProjection == -1) throw std::runtime_error(std::string("Program uniform not found: ") + "projection"); glUniformMatrix4fv(uniformProjection, 1, GL_FALSE, glm::value_ptr(projection)); glm::mat4 camera = glm::lookAt(glm::vec3(3, 3, 3), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0)); //glm::mat4 camera = glm::lookAt(glm::vec3(0.5, 0.5, 0.5), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0)); GLint uniformCamera = glGetUniformLocation(gProgram, "camera"); if (uniformCamera == -1) throw std::runtime_error(std::string("Program uniform not found: ") + "camera"); glUniformMatrix4fv(uniformCamera, 1, GL_FALSE, glm::value_ptr(camera)); */ int width, height, channels; unsigned char* pixels = stbi_load("wooden-crate.jpg", &width, &height, &channels, 0); if (!pixels) { throw std::runtime_error(stbi_failure_reason()); } unsigned long rowSize = channels *width; unsigned char* rowBuffer = new unsigned char[rowSize]; unsigned halfRows = height / 2; for (unsigned rowIdx = 0; rowIdx < halfRows; ++rowIdx) { unsigned char* row = pixels + (rowIdx * width + 0) * channels;//GetPixelOffset(0, rowIdx, _width, _height, _format); unsigned char* oppositeRow = pixels + ((height - rowIdx - 1) * width + 0) * channels;//GetPixelOffset(0, _height - rowIdx - 1, _width, _height, _format); memcpy(rowBuffer, row, rowSize); memcpy(row, oppositeRow, rowSize); memcpy(oppositeRow, rowBuffer, rowSize); } delete[] rowBuffer; glGenTextures(1, &gTex); glBindTexture(GL_TEXTURE_2D, gTex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); GLint internalformat; switch (channels) { case 1: internalformat = GL_LUMINANCE; break; case 2: internalformat = GL_LUMINANCE_ALPHA; break; case 3: internalformat = GL_RGB; break; case 4: internalformat = GL_RGBA; break; default: throw std::runtime_error("Unrecognised Bitmap::Format"); } glTexImage2D(GL_TEXTURE_2D, 0, internalformat, (GLsizei)width, (GLsizei)height, 0, internalformat, GL_UNSIGNED_BYTE, pixels); glBindTexture(GL_TEXTURE_2D, 0); stbi_image_free(pixels); // make and bind the VAO glGenVertexArrays(1, &gVAO); glBindVertexArray(gVAO); // make and bind the VBO glGenBuffers(1, &gVBO); glBindBuffer(GL_ARRAY_BUFFER, gVBO); GLfloat vertexData[] = { // X Y Z U V // bottom -1.0f,-1.0f,-1.0f, 0.0f, 0.0f, 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, -1.0f,-1.0f, 1.0f, 0.0f, 1.0f, 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, 1.0f,-1.0f, 1.0f, 1.0f, 1.0f, -1.0f,-1.0f, 1.0f, 0.0f, 1.0f, // top -1.0f, 1.0f,-1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f,-1.0f, 1.0f, 0.0f, 1.0f, 1.0f,-1.0f, 1.0f, 0.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, // front -1.0f,-1.0f, 1.0f, 1.0f, 0.0f, 1.0f,-1.0f, 1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,-1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, // back -1.0f,-1.0f,-1.0f, 0.0f, 0.0f, -1.0f, 1.0f,-1.0f, 0.0f, 1.0f, 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, -1.0f, 1.0f,-1.0f, 0.0f, 1.0f, 1.0f, 1.0f,-1.0f, 1.0f, 1.0f, // left -1.0f,-1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f,-1.0f, 1.0f, 0.0f, -1.0f,-1.0f,-1.0f, 0.0f, 0.0f, -1.0f,-1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f,-1.0f, 1.0f, 0.0f, // right 1.0f,-1.0f, 1.0f, 1.0f, 1.0f, 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, 1.0f, 1.0f,-1.0f, 0.0f, 0.0f, 1.0f,-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,-1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f }; glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW); GLint attrib = glGetAttribLocation(gProgram, "vert"); if (attrib == -1) throw std::runtime_error(std::string("Program attribute not found: ") + "vert"); glEnableVertexAttribArray(attrib); glVertexAttribPointer(attrib, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), NULL); GLint vertTexCoord = glGetAttribLocation(gProgram, "vertTexCoord"); if (vertTexCoord == -1) throw std::runtime_error(std::string("Program attribute not found: ") + "vertTexCoord"); glEnableVertexAttribArray(vertTexCoord); glVertexAttribPointer(vertTexCoord, 2, GL_FLOAT, GL_TRUE, 5 * sizeof(GLfloat), (const GLvoid*)(3 * sizeof(GLfloat))); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glClearColor(0.196078431372549f, 0.3137254901960784f, 0.5882352941176471f, 1); }
/** * Make initial OpenGL settings. Build a shader program and generate a * vertex array object. */ void initialize() { // Initialize OpenGL glEnable(GL_DEPTH_TEST); // Turn on depth testing glClearColor(0.1f, 0.1f, 0.5f, 0.0f); // Set the window clear color // Build shader proram shaderProgram = glCreateProgram(); // Make the vertex shader GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); const GLchar* vertexShaderSource = ReadShader("vertexShader.vs.glsl"); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); GLint compiled; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compiled); //If compilation failed if (!compiled) { GLsizei len; glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &len); GLchar* log = new GLchar[len + 1]; glGetShaderInfoLog(vertexShader, len, &len, log); cout << "shader compilation failed: " << log << endl; delete[] log; } else { cout << "shader compilation successful" << endl; } glAttachShader(shaderProgram, vertexShader); // Make the fragment shader GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); const GLchar* fragmentShaderSource = ReadShader("fragmentShader.fs.glsl"); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShader); glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compiled); //If compilation failed if (!compiled) { GLsizei len; glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &len); GLchar* log = new GLchar[len + 1]; glGetShaderInfoLog(vertexShader, len, &len, log); cout << "fragment shader compilation failed: " << log << endl; delete[] log; } else { cout << "fragment shader compilation successful" << endl; } glAttachShader(shaderProgram, fragmentShader); // Link the shader porgram and check for errors glLinkProgram(shaderProgram); GLint linked; glGetProgramiv(vertexShader, GL_COMPILE_STATUS, &linked); //If linking failed if (!linked) { GLsizei len; glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &len); GLchar* log = new GLchar[len + 1]; glGetShaderInfoLog(vertexShader, len, &len, log); cout << "shader linking failed: " << log << endl; delete[] log; } else { cout << "shader linking successful" << endl; } // Generate vertex array object and bind it for the first time glGenVertexArrays(1, &vertexArrayObject); glBindVertexArray(vertexArrayObject); // Delete the shader glDeleteShader(vertexShader); }