void HeightMap::keyEvent(SDL_Keysym &key, bool press) { if (!press) { return; } switch(key.sym) { case SDLK_a: if (_vertsPerSide < 1024) { _vertsPerSide *= 2; _totalVerts = _vertsPerSide * 2 * (_vertsPerSide - 1); glUniform1i(_vpsLoc, _vertsPerSide); checkGLError("Error encountered updating Vertices Per Side count: %s\n", Logger::LOG_WARN); } break; case SDLK_z: if (_vertsPerSide > 4) { _vertsPerSide /= 2; _totalVerts = _vertsPerSide * 2 * (_vertsPerSide - 1); glUniform1i(_vpsLoc, _vertsPerSide); checkGLError("Error encountered updating Vertices Per Side count: %s\n", Logger::LOG_WARN); } break; case SDLK_d: _drawMode = GL_TRIANGLE_STRIP; running &= buildShaderProgram(VERTEX_SHADER, "heightmap-debugfrag.sdr"); loadUniforms(); break; case SDLK_c: _drawMode = GL_TRIANGLE_STRIP; running &= buildShaderProgram(VERTEX_SHADER, FRAGMENT_SHADER); loadUniforms(); break; case SDLK_p: glPointSize(2.0); _drawMode = GL_POINTS; running &= buildShaderProgram(VERTEX_SHADER, "heightmap-pointdebug.sdr"); loadUniforms(); break; case SDLK_f: _flatten = !_flatten; glUniform1i(_flattenLoc, _flatten); break; case SDLK_s: if (_zPlane < 4.0f) { _zPlane += 0.1f; } break; case SDLK_x: if (_zPlane > 0.0f) { _zPlane -= 0.1f; } break; } }
void GraphicsSubsystem::loadUniforms() { GLuint shadow = shaders["shadow"]; GLuint simple = shaders["simple"]; GLuint skybox = shaders["skybox"]; GLuint plane = shaders["plane"]; GLuint ball = shaders["ball"]; programUniforms[shadow]["modelToClipMatrix"] = glGetUniformLocation(shadow, "modelToClipMatrix"); const char *simpleUniforms[] = { "modelToWorldMatrix", "baseColor" }; const char *simpleBlocks[] = { "GlobalMatrices" }; loadUniforms(simple, simpleUniforms, sizeof(simpleUniforms) / sizeof(char*), simpleBlocks, sizeof(simpleBlocks) / sizeof(char*)); const char *skyboxUniforms[] = { "modelToWorldMatrix", "skybox" }; const char *skyboxBlocks[] = { "GlobalMatrices" }; loadUniforms(skybox, skyboxUniforms, sizeof(skyboxUniforms) / sizeof(char*), skyboxBlocks, sizeof(skyboxBlocks) / sizeof(char*)); const char *planeUniforms[] = { "modelToWorldMatrix", "normalModelToCameraMatrix", "modelToLightToClipMatrix", "textureScale", "colorTexture", "shadowTexture", "shadowTexSize" }; const char *planeBlocks[] = { "GlobalMatrices", "Light", "Material" }; loadUniforms(plane, planeUniforms, sizeof(planeUniforms) / sizeof(char*), planeBlocks, sizeof(planeBlocks) / sizeof(char*)); const char *ballUniforms[] = { "modelToWorldMatrix", "normalModelToCameraMatrix", "normalModelToWorldMatrix", "worldToLightMatrix", "worldToLightITMatrix", "colorTexture", "skybox", "camPos" }; const char *ballBlocks[] = { "GlobalMatrices", "Light", "Material" }; loadUniforms(ball, ballUniforms, sizeof(ballUniforms) / sizeof(char*), ballBlocks, sizeof(ballBlocks) / sizeof(char*)); glUniformBlockBinding(skybox, programUniforms[skybox]["GlobalMatrices"], bindingIndexes["matrices"]); glUniformBlockBinding(plane, programUniforms[plane]["GlobalMatrices"], bindingIndexes["matrices"]); glUniformBlockBinding(plane, programUniforms[plane]["Light"], bindingIndexes["light"]); glUniformBlockBinding(plane, programUniforms[plane]["Material"], bindingIndexes["material"]); glUniformBlockBinding(ball, programUniforms[ball]["GlobalMatrices"], bindingIndexes["matrices"]); glUniformBlockBinding(ball, programUniforms[ball]["Light"], bindingIndexes["light"]); glUniformBlockBinding(ball, programUniforms[ball]["Material"], bindingIndexes["material"]); glUseProgram(skybox); glUniform1i(programUniforms[skybox]["skybox"], texUnits["room"]); glUseProgram(0); glUseProgram(plane); glUniform1iv(programUniforms[plane]["shadowTexture"], NUMBER_OF_LIGHTS, shadowTexUnit); glUseProgram(0); glUseProgram(ball); glUniform1i(programUniforms[ball]["colorTexture"], texUnits["ball"]); glUniform1i(programUniforms[ball]["skybox"], texUnits["roomBall"]); glUseProgram(0); }
void generateTerrain(){ static GLuint indexBuffer; static GLuint vertexBuffer; static GLuint normalsBuffer; static GLboolean first = GL_TRUE; if(first){ glGenBuffers(1, &vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); glBufferData(GL_ARRAY_BUFFER, totalVertices * sizeof(GLfloat), verticesArray, GL_STATIC_DRAW); glGenBuffers(1, &indexBuffer); glBindBuffer(GL_ARRAY_BUFFER,indexBuffer); glBufferData(GL_ARRAY_BUFFER, totalIndices * sizeof(GLuint), indicesArray, GL_STATIC_DRAW); glGenBuffers(1, &normalsBuffer); glBindBuffer(GL_ARRAY_BUFFER,normalsBuffer); glBufferData(GL_ARRAY_BUFFER, totalNormals * sizeof(GLfloat), normalsArray, GL_STATIC_DRAW); first = GL_FALSE; } loadUniforms(); glEnableVertexAttribArray(vertexPositionAttr); glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); glVertexAttribPointer(vertexPositionAttr,3, GL_FLOAT,GL_FALSE, 0, (GLvoid*) 0); glEnableVertexAttribArray(vertexNormalAttr); glBindBuffer(GL_ARRAY_BUFFER, normalsBuffer); glVertexAttribPointer(vertexNormalAttr, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*) 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); glDrawElements(GL_TRIANGLES, totalIndices, GL_UNSIGNED_INT, (GLvoid*) 0); }
void arm_segment(void){ static GLboolean first = GL_TRUE; static GLuint vertBuffer; if(first){ static GLfloat verts[4][2] = { {.5, 0}, {.5, -6}, {-.5, -6}, {-.5,0} }; glGenBuffers(1, &vertBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW); first = GL_FALSE; } loadUniforms(); glEnableVertexAttribArray(vertexPositionAttr); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glVertexAttribPointer(vertexPositionAttr, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*) 0); glDrawArrays(GL_LINE_LOOP, 0, 4); }
void torso(void){ static GLboolean first = GL_TRUE; static GLuint vertBuffer; if(first){ static GLfloat verts[10][2] = { {-2.5, 0}, {-2.5, 2}, {-3.5, 6}, {-4.5, 7}, {-1.5, 10}, {1.5, 10}, {4.5, 7}, {3.5, 6}, {2.5, 2}, {2.5, 0} }; glGenBuffers(1, &vertBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW); first = GL_FALSE; } loadUniforms(); glEnableVertexAttribArray(vertexPositionAttr); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glVertexAttribPointer(vertexPositionAttr, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*) 0); glDrawArrays(GL_LINE_LOOP, 0, 10); }
void joint(void){ #define N 30 static GLboolean first = GL_TRUE; static GLuint vertBuffer; if(first){ GLfloat verts[N][2]; for(int i = 0; i < N; i++){ verts[i][0] = cos(i * 2 * M_PI / N); verts[i][1] = sin(i * 2 * M_PI / N); } glGenBuffers(1, &vertBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW); first = GL_FALSE; } loadUniforms(); glEnableVertexAttribArray(vertexPositionAttr); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glVertexAttribPointer(vertexPositionAttr, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*) 0); glDrawArrays(GL_LINE_LOOP, 0, N); }
void HeightMap::appInit() { bool shaderReady = buildShaderProgram(VERTEX_SHADER, FRAGMENT_SHADER); if (!shaderReady) { exit(1); } loadUniforms(); glGenVertexArrays(1, &_vertexArray); glBindVertexArray(_vertexArray); resizeWindow(400, 400); running &= checkGLError("Error encountered binding Texture Sampler: %s\n", Logger::LOG_ERROR); glEnable(GL_DEPTH_TEST); running &= checkGLError("Error encountered enabling Depth Buffer: %s\n", Logger::LOG_ERROR); glClearColor(0.2f, 0.2f, 0.2f, 1.0f); }
void spline_mesh(void){ static GLboolean first = GL_TRUE; static GLuint vertBuffer; static GLuint normalBuffer; static GLuint indexBuffer; GLdouble tube[TUBE_N][TUBE_M][3]; GLdouble tubeNormals[TUBE_N][TUBE_M][3]; if(first){ double t, u; int i, j, k; double dt = 2 * M_PI / TUBE_N; double du = 2 * M_PI / TUBE_M; for(i = 0, t = 0.0; i < TUBE_N; i++, t += dt){ GLdouble x = (a + b * cos(q * t)) * cos(p * t); GLdouble y = (a + b * cos(q * t)) * sin(p * t); GLdouble z = b * sin(q * t); GLdouble tangx = -p * y - b * q * sin(q * t) * cos(p * t); GLdouble tangy = p * x - b * q * sin(q * t) * sin(p * t); GLdouble tangz = b * q * cos(q * t); GLdouble accelx = -p * tangy + b * q * (p * sin(q * t) * sin(p * t) - q * cos(q * t) * cos(p * t)); GLdouble accely = p * tangx - b * q * (p * sin(q * t) * cos(p * t) + q * cos(q * t) * sin(p * t)); GLdouble accelz = -(q * q) * b * sin(q * t); GLdouble C[3] = {x, y, z}; GLdouble T[3] = {tangx, tangy, tangz}; GLdouble A[3] = {accelx, accely, accelz}; GLdouble N[3]; GLdouble B[3]; cross(T, A, B); normalize(T); normalize(B); cross(B, T, N); for(j = 0, u = 0.0; j < TUBE_M; j++, u += du){ for(k = 0; k < 3; k++){ tubeNormals[i][j][k] = cos(u) * B[k] + sin(u) * N[k]; tube[i][j][k] = C[k] + R * tubeNormals[i][j][k]; } } } createMeshStripIndices(); glGenBuffers(1, &indexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(tubeStrips), tubeStrips, GL_STATIC_DRAW); glGenBuffers(1, &vertBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(tube), tube, GL_STATIC_DRAW); glGenBuffers(1, &normalBuffer); glBindBuffer(GL_ARRAY_BUFFER, normalBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(tubeNormals), tubeNormals, GL_STATIC_DRAW); first = GL_FALSE; } loadUniforms(); glEnableVertexAttribArray(vertexPositionAttr); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glVertexAttribPointer(vertexPositionAttr, 3, GL_DOUBLE, GL_FALSE, 0, (GLvoid*) 0); //glEnableVertexAttribArray(vertexNormalAttr); //glBindBuffer(GL_ARRAY_BUFFER, normalBuffer); //glVertexAttribPointer(vertexNormalAttr, 3, GL_DOUBLE, GL_FALSE, 0, (GLvoid*) 0); int i; char *offset; glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); for(i = 0, offset = 0; i < NUM_STRIPS; i++, offset += INDICES_PER_STRIP * sizeof(GLushort)){ glDrawElements(GL_QUAD_STRIP, INDICES_PER_STRIP, GL_UNSIGNED_SHORT, (GLvoid*) offset); } }
int GraphicsSubsystem::initGraphicsSubsystem() { char *myargv[1]; int myargc = 1; myargv[0] = _strdup(COPYRIGHT); glutInit(&myargc, myargv); glutInitWindowPosition(WIN_POS_X, WIN_POS_Y); glutInitWindowSize(windowSize.x, windowSize.y); glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA | GLUT_MULTISAMPLE); glutCreateWindow("Practical Work"); glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { printf("Errors occurred during glew init\n"); return GSS_ERROR; } else if (!GLEW_VERSION_3_3) { GLint major = 0, minor = 0; glGetIntegerv(GL_MAJOR_VERSION, &major); glGetIntegerv(GL_MINOR_VERSION, &minor); printf("Application requires OpenGL 3.3; current version is %i.%i\n", major, minor); return GSS_ERROR; } bindingIndexes["matrices"] = 0; bindingIndexes["light"] = 1; bindingIndexes["material"] = 2; const char *textureUnits[] = { "ball", "cloth", "wood", "room", "roomBall" }; loadTextureUnits(textureUnits, sizeof(textureUnits) / sizeof(char*)); loadShaders(); loadUniforms(); loadBuffers(); printf("Loading textures...\n"); loadTexture(TEXTURE_PATH "ball_albedo.png", textures["ball"]); loadTexture(TEXTURE_PATH "cloth.png", textures["cloth"]); loadTexture(TEXTURE_PATH "wood.png", textures["wood"]); #if loadSky == 1 const char *skybox[] = { TEXTURE_PATH "skybox/negx.jpg", TEXTURE_PATH "skybox/posx.jpg", TEXTURE_PATH "skybox/negy.jpg", TEXTURE_PATH "skybox/posy.jpg", TEXTURE_PATH "skybox/negz.jpg", TEXTURE_PATH "skybox/posz.jpg" }; const char *skyboxBall[] = { TEXTURE_PATH "skyboxBall/negx.jpg", TEXTURE_PATH "skyboxBall/posx.jpg", TEXTURE_PATH "skyboxBall/negy.jpg", TEXTURE_PATH "skyboxBall/posy.jpg", TEXTURE_PATH "skyboxBall/negz.jpg", TEXTURE_PATH "skyboxBall/posz.jpg" }; loadCubemap(skybox, sizeof(skybox) / sizeof(char*), textures["room"]); loadCubemap(skyboxBall, sizeof(skyboxBall) / sizeof(char*), textures["roomBall"]); #endif createDepthBuffer(); createSampler(); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnable(GL_MULTISAMPLE); glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); glDepthRange(0.0f, 1.0f); glEnable(GL_DEPTH_CLAMP); return 0; }
void ellipsoidWireFrame() { static GLuint vertBuffer; static GLuint normalsBuffer; static GLuint indexBuffer; static GLboolean first = GL_TRUE; GLfloat u,v; int m,n; int cnt=0; if (first || changeFlag) { for (n=0; n <= BIG_N; n++) { v = -M_PI/2.0 + (float) n/ (float) BIG_N * M_PI; for (m=0; m <= BIG_M; m++) { u = -M_PI + (float) m/ (float) BIG_M * 2.0 * M_PI; verticesArray[cnt] = xValue(u,v); normalsArray[cnt] = nxValue(u,v); cnt++; verticesArray[cnt] = yValue(u,v); normalsArray[cnt] = nyValue(u,v); cnt++; verticesArray[cnt] = zValue(u,v); normalsArray[cnt] = nzValue(u,v); cnt++; } } glGenBuffers(1, &vertBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(verticesArray), verticesArray, GL_STATIC_DRAW); glGenBuffers(1, &normalsBuffer); glBindBuffer(GL_ARRAY_BUFFER,normalsBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(normalsArray), normalsArray, GL_STATIC_DRAW); if (first) { createMeshStripIndices(); glGenBuffers(1, &indexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(tubeStrips), tubeStrips, GL_STATIC_DRAW); } first = GL_FALSE; changeFlag = GL_FALSE; } loadUniforms(); glEnableVertexAttribArray(vertexPositionAttr); glBindBuffer(GL_ARRAY_BUFFER, vertBuffer); glVertexAttribPointer(vertexPositionAttr,3, GL_FLOAT,GL_FALSE, 0, (GLvoid*) 0); glBindBuffer(GL_ARRAY_BUFFER, normalsBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,indexBuffer); glDrawElements(GL_QUAD_STRIP, TOTAL_INDICES, GL_UNSIGNED_SHORT, (GLvoid*) 0); }