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