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);
}
