static void Render() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0, 0.1, 0.1, 1.0); //set the background
glUseProgram(gProgram->object());
gProgram -> setUniform("camera", gCamera.matrix());
gProgram -> setUniform("model", glm::rotate(glm::mat4(), gDegreesRotated, Axis));
gProgram -> setUniform("light.position", gLight.position);
gProgram -> setUniform("light.intensities",gLight.intensities);
gProgram -> setUniform("materialSpecularColor", specularColor);
gProgram -> setUniform("materialShininess", material_shininess);
gProgram -> setUniform("light.attenuation", gLight.attenuation);
gProgram -> setUniform("light.ambientCoefficient", gLight.ambientCoefficient);
gProgram -> setUniform("cameraPosition", gCamera.position());
glBindVertexArray(gVAO);
glDrawArrays(GL_TRIANGLES, 0, NumVertices);
glBindVertexArray(0);
//glFlush();
gProgram -> stopUsing();
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH);
glfwSwapBuffers();
}
static void RenderInstance(const ModelInstance& inst) {
ModelAsset* asset = inst.asset;
tdogl::Program* shaders = asset->shaders;
//bind the shaders
shaders->use();
shaders->setUniform("gCameraPos", gCamera.position());
//set the shader uniforms
shaders->setUniform("camera", gCamera.matrix());
shaders->setUniform("model", inst.transform);
//shaders->setUniform("materialTex", 0); //set to 0 because the texture will be bound to GL_TEXTURE0
//bind the texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, asset->texture->object());
//bind VAO and draw
glBindVertexArray(asset->vao);
glDrawArrays(asset->drawType, asset->drawStart, asset->drawCount);
//unbind everything
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
shaders->stopUsing();
}
//renders a single `ModelInstance`
static void RenderInstance(const ModelInstance& inst) {
ModelAsset* asset = inst.asset;
tdogl::Program* shaders = asset->shaders;
//bind the shaders
shaders->use();
//set the shader uniforms
shaders->setUniform("camera", gCamera.matrix());
shaders->setUniform("model", inst.transform);
shaders->setUniform("material.tex", 0); //set to 0 because the texture will be bound to GL_TEXTURE0
shaders->setUniform("material.shininess", asset->shininess);
shaders->setUniform("material.specularColor", asset->specularColor);
shaders->setUniform("light.position", gLight.position);
shaders->setUniform("light.intensities", gLight.intensities);
shaders->setUniform("light.attenuation", gLight.attenuation);
shaders->setUniform("light.ambientCoefficient", gLight.ambientCoefficient);
shaders->setUniform("cameraPosition", gCamera.position());
//bind the texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, asset->texture->object());
//bind VAO and draw
glBindVertexArray(asset->vao);
glDrawArrays(asset->drawType, asset->drawStart, asset->drawCount);
//unbind everything
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
shaders->stopUsing();
}
void AppMain() {
if(!glfwInit())
throw std::runtime_error("glfwInit failed");
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_FALSE);
if(!glfwOpenWindow(SCREEN_SIZE.x, SCREEN_SIZE.y, 8, 8, 8, 8, 0, 0, GLFW_WINDOW))
throw std::runtime_error("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
if(glewInit() != GLEW_OK)
throw std::runtime_error("glewInit failed");
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
if(!GLEW_VERSION_3_2)
throw std::runtime_error("OpenGL 3.2 API is not available.");
glfwDisable(GLFW_MOUSE_CURSOR);
glfwSetMousePos(0,0);
glfwSetMouseWheel(0);
LoadShaders();
LoadTriangle();
//intialise the Camera position
gCamera.setPosition(glm::vec3(0,0,4));
gCamera.setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y);
gCamera.setNearAndFarPlanes(0.5, 100.0f);
Axis = glm::vec3(0,1,0);
//intialise the Light attribute
gLight.position = glm::vec3(0.0f,0.1f,-0.1f);
gLight.intensities = glm::vec3(0.8,0.78,1); // white light
gLight.attenuation = 0.2f;
gLight.ambientCoefficient = 0.005f;
double lastTime = glfwGetTime();
while(glfwGetWindowParam(GLFW_OPENED)){
double thisTime = glfwGetTime();
Update(thisTime - lastTime);
lastTime = thisTime;
Render();
}
glfwTerminate();
}
// draws a single frame
static void Render() {
// clear everything
glClearColor(0, 0, 0, 1); // black
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// bind the program (the shaders)
gProgram->use();
// set the "camera" uniform
gProgram->setUniform("camera", gCamera.matrix());
// set the "model" uniform in the vertex shader, based on the gDegreesRotated global
gProgram->setUniform("model", glm::rotate(glm::mat4(), gDegreesRotated, glm::vec3(0,1,0)));
// bind the texture and set the "tex" uniform in the fragment shader
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gTexture->object());
gProgram->setUniform("tex", 0); //set to 0 because the texture is bound to GL_TEXTURE0
// bind the VAO (the triangle)
glBindVertexArray(gVAO);
// draw the VAO
glDrawArrays(GL_TRIANGLES, 0, 6*2*3);
// unbind the VAO, the program and the texture
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
gProgram->stopUsing();
// swap the display buffers (displays what was just drawn)
glfwSwapBuffers();
}
// update the scene based on the time elapsed since last update
static void Update(float secondsElapsed) {
//constantly move position of camera forward
gCamera.fly(secondsElapsed * flyingSpeed);
//accelerate flying speed based on XZ keys
const GLfloat accelerateFlyingPerSecond = 1.3f; //units per second
if(glfwGetKey(gWindow, 'X')){
flyingSpeed += secondsElapsed * accelerateFlyingPerSecond;
} else if(glfwGetKey(gWindow, 'Z')){
flyingSpeed -= secondsElapsed * accelerateFlyingPerSecond;
}
//rotate camera based on WASDQE keys
const GLfloat pitchDegreesPerSecond = 25.0f; //degrees per second
const GLfloat yawDegreesPerSecond = 25.0f; //degrees per second
const GLfloat rollDegreesPerSecond = 25.0f; //degrees per second
if(glfwGetKey(gWindow, 'S')){
gCamera.pitch(secondsElapsed * -pitchDegreesPerSecond);
} else if(glfwGetKey(gWindow, 'W')){
gCamera.pitch(secondsElapsed * pitchDegreesPerSecond);
}
if(glfwGetKey(gWindow, 'A')){
gCamera.yaw(secondsElapsed * yawDegreesPerSecond);
} else if(glfwGetKey(gWindow, 'D')){
gCamera.yaw(secondsElapsed * -yawDegreesPerSecond);
}
if(glfwGetKey(gWindow, 'Q')){
gCamera.roll(secondsElapsed * -rollDegreesPerSecond);
} else if(glfwGetKey(gWindow, 'E')){
gCamera.roll(secondsElapsed * rollDegreesPerSecond);
}
}
// draws a single frame
static void Render() {
// clear everything
glClearColor(0, 0, 0, 1); // black
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// render all the instances
std::list<ModelInstance>::const_iterator it;
for(it = gInstances.begin(); it != gInstances.end(); ++it){
RenderInstance(*it, gCamera.matrix());
}
// swap the display buffers (displays what was just drawn)
glfwSwapBuffers();
}
//renders a single `ModelInstance`
static void RenderInstance(const ModelInstance& inst) {
ModelAsset* asset = inst.asset;
tdogl::Program* shaders = asset->shaders;
//bind the shaders
shaders->use();
//set the shader uniforms
shaders->setUniform("camera", gCamera.matrix());
shaders->setUniform("model", inst.transform);
//bind VAO and draw
glBindVertexArray(asset->vao);
glDrawArrays(asset->drawType, asset->drawStart, asset->drawCount);
//unbind everything
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
shaders->stopUsing();
}
void Render(GLFWwindow* window)
{
// clear everything
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
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(gCamera.matrix()));
GLint uniformModel = glGetUniformLocation(gProgram, "model");
if (uniformModel == -1)
throw std::runtime_error(std::string("Program uniform not found: ") + "tex");
glm::tmat4x4<float, glm::highp> modelMatrix = glm::rotate(glm::mat4(), glm::radians(gDegreesRotated), glm::vec3(0, 1, 0));
glUniformMatrix4fv(uniformModel, 1, GL_FALSE, glm::value_ptr(modelMatrix));
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gTex);
GLint uniformTex = glGetUniformLocation(gProgram, "tex");
if (uniformTex == -1)
throw std::runtime_error(std::string("Program uniform not found: ") + "tex");
glUniform1i(uniformTex, 0);
glBindVertexArray(gVAO);
// draw the VAO
glDrawArrays(GL_TRIANGLES, 0, 6 * 2 * 3);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
glfwSwapBuffers(window);
}
// update the scene based on the time elapsed since last update
void Update(float secondsElapsed) {
const GLfloat degreesPerSecond = 180.0f;
gDegreesRotated += secondsElapsed * degreesPerSecond;
while (gDegreesRotated > 360.0f) gDegreesRotated -= 360.0f;
gInstances.front().transform = glm::rotate(glm::mat4(), gDegreesRotated, glm::vec3(0, 1, 0));
// Move position of camera base on WASD keys
const float moveSpeed = 2.0; // Units per second;
if (glfwGetKey(gWindow, 'S')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward());
} else if (glfwGetKey(gWindow, 'W')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.forward());
}
if (glfwGetKey(gWindow, 'A')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.right());
} else if (glfwGetKey(gWindow, 'D')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.right());
}
if (glfwGetKey(gWindow, 'Z')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.up());
} else if (glfwGetKey(gWindow, 'X')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.up());
}
//rotate camera based on mouse movement
const float mouseSensitivity = 0.1f;
double mouseX, mouseY;
glfwGetCursorPos(gWindow, &mouseX, &mouseY);
gCamera.offsetOrientation(mouseSensitivity * (float)mouseY, mouseSensitivity * (float)mouseX);
glfwSetCursorPos(gWindow, 0, 0); //reset the mouse, so it doesn't go out of the window
//increase or decrease field of view based on mouse wheel
const float zoomSensitivity = -0.2f;
float fieldOfView = gCamera.fieldOfView() + zoomSensitivity * (float)gScrollY;
if (fieldOfView < 5.0f) fieldOfView = 5.0f;
if (fieldOfView > 130.0f) fieldOfView = 130.0f;
gCamera.setFieldOfView(fieldOfView);
gScrollY = 0;
}
//rotated and add keyboard and mouse callback
void Update(float secondsElapsed) {
//change the axis that rotated
if (glfwGetKey('7')){
Axis =glm::vec3(1,0,0);
}
if (glfwGetKey('8')){
Axis =glm::vec3(0,0,1);
}
if (glfwGetKey('9')){
Axis =glm::vec3(0,1,0);
}
//press "T" to stop rotate
GLfloat degreesPerSecond = 20.0f;
if (glfwGetKey('T')){
degreesPerSecond = 0.0f;
}
gDegreesRotated += secondsElapsed * degreesPerSecond;
while (gDegreesRotated > 360.0f) gDegreesRotated -= 360.0f;
const float moveSpeed = 3.0;
if (glfwGetKey('S')) {
gCamera.offsetPositon(secondsElapsed * moveSpeed * -gCamera.forward());
} else if (glfwGetKey('W')){
gCamera.offsetPositon(secondsElapsed * moveSpeed * gCamera.forward());
} else if (glfwGetKey('A')) {
gCamera.offsetPositon(secondsElapsed * moveSpeed * -gCamera.right());
} else if (glfwGetKey('D')) {
gCamera.offsetPositon(secondsElapsed * moveSpeed * gCamera.right());
}
if (glfwGetKey('Z')) {
gCamera.offsetPositon(secondsElapsed* moveSpeed * -glm::vec3(0,1,0));
} else if (glfwGetKey('X')) {
gCamera.offsetPositon(secondsElapsed * moveSpeed * glm::vec3(0,1,0));
}
// change light color
if(glfwGetKey('1'))
gLight.intensities = glm::vec3(0.8, 0.3, 0.0); //red
else if(glfwGetKey('2'))
gLight.intensities = glm::vec3(0.0, 0.8, 0.2); //green
else if (glfwGetKey('3'))
gLight.intensities = glm::vec3(0.1, 0.3, 0.8);
else if(glfwGetKey('4'))
gLight.intensities = glm::vec3(1,1,1); //white
//mouse movement with camera
const float mouseSensitivity = 0.1;
int mouseX, mouseY;
glfwGetMousePos(&mouseX, &mouseY);
gCamera.offsetOrientation(mouseSensitivity* mouseY, mouseSensitivity* mouseX);
glfwSetMousePos(0,0);
//mouse wheel with field of view
const float zoomSensitivity = -0.8;
float fieldOfView = gCamera.fieldOfView() + zoomSensitivity *(float)glfwGetMouseWheel();
if(fieldOfView < 5.0f) fieldOfView = 5.0f;
if(fieldOfView > 130.0f) fieldOfView = 130.0f;
gCamera.setFieldOfView(fieldOfView);
if (glfwGetMouseButton(0)) //press left button to reset the Fov;
gCamera.setFieldOfView(50.0f);
glfwSetMouseWheel(0);
}
// the program starts here
void AppMain() {
// initialise GLFW
glfwSetErrorCallback(OnError);
if(!glfwInit())
throw std::runtime_error("glfwInit failed");
// open a window with GLFW
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
gWindow = glfwCreateWindow((int)SCREEN_SIZE.x, (int)SCREEN_SIZE.y, "OpenGL Tutorial", NULL, NULL);
if(!gWindow)
throw std::runtime_error("glfwCreateWindow failed. Can your hardware handle OpenGL 3.2?");
// GLFW settings
glfwSetInputMode(gWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetCursorPos(gWindow, 0, 0);
glfwSetScrollCallback(gWindow, OnScroll);
glfwMakeContextCurrent(gWindow);
// initialise GLEW
glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
if(glewInit() != GLEW_OK)
throw std::runtime_error("glewInit failed");
// GLEW throws some errors, so discard all the errors so far
while(glGetError() != GL_NO_ERROR) {}
// print out some info about the graphics drivers
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
// make sure OpenGL version 3.2 API is available
if(!GLEW_VERSION_3_2)
throw std::runtime_error("OpenGL 3.2 API is not available.");
// OpenGL settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// initialise the gWoodenCrate asset
LoadWoodenCrateAsset();
// create all the instances in the 3D scene based on the gWoodenCrate asset
CreateInstances();
// setup gCamera
gCamera.setPosition(glm::vec3(-4,0,17));
gCamera.setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y);
gCamera.setNearAndFarPlanes(0.5f, 100.0f);
// setup gLight
gLight.position = gCamera.position();
gLight.intensities = glm::vec3(1,1,1); //white
// run while the window is open
float lastTime = (float)glfwGetTime();
while(!glfwWindowShouldClose(gWindow)){
// process pending events
glfwPollEvents();
// update the scene based on the time elapsed since last update
float thisTime = (float)glfwGetTime();
Update(thisTime - lastTime);
lastTime = thisTime;
// draw one frame
Render();
// check for errors
GLenum error = glGetError();
if(error != GL_NO_ERROR)
std::cerr << "OpenGL Error " << error << std::endl;
//exit program if escape key is pressed
if(glfwGetKey(gWindow, GLFW_KEY_ESCAPE))
glfwSetWindowShouldClose(gWindow, GL_TRUE);
}
// clean up and exit
glfwTerminate();
}
// the program starts here
void AppMain() {
// initialise GLFW
if(!glfwInit())
throw std::runtime_error("glfwInit failed");
// open a window with GLFW
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
if(!glfwOpenWindow((int)SCREEN_SIZE.x, (int)SCREEN_SIZE.y, 8, 8, 8, 8, 16, 0, GLFW_WINDOW))
throw std::runtime_error("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
// GLFW settings
glfwDisable(GLFW_MOUSE_CURSOR);
glfwSetMousePos(0, 0);
glfwSetMouseWheel(0);
// initialise GLEW
glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
if(glewInit() != GLEW_OK)
throw std::runtime_error("glewInit failed");
// GLEW throws some errors, so discard all the errors so far
while(glGetError() != GL_NO_ERROR) {}
// print out some info about the graphics drivers
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
// make sure OpenGL version 3.2 API is available
if(!GLEW_VERSION_3_2)
throw std::runtime_error("OpenGL 3.2 API is not available.");
// OpenGL settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// load vertex and fragment shaders into opengl
LoadShaders();
// load the texture
LoadTexture();
// create buffer and fill it with the points of the triangle
LoadCube();
// setup gCamera
gCamera.setPosition(glm::vec3(0,0,4));
gCamera.setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y);
// run while the window is open
double lastTime = glfwGetTime();
while(glfwGetWindowParam(GLFW_OPENED)){
// update the scene based on the time elapsed since last update
double thisTime = glfwGetTime();
Update(thisTime - lastTime);
lastTime = thisTime;
// draw one frame
Render();
// check for errors
GLenum error = glGetError();
if(error != GL_NO_ERROR)
std::cerr << "OpenGL Error " << error << ": " << (const char*)gluErrorString(error) << std::endl;
//exit program if escape key is pressed
if(glfwGetKey(GLFW_KEY_ESC))
glfwCloseWindow();
}
// clean up and exit
glfwTerminate();
}
// update the scene based on the time elapsed since last update
void Update(float secondsElapsed) {
//rotate the cube
const GLfloat degreesPerSecond = 180.0f;
gDegreesRotated += secondsElapsed * degreesPerSecond;
while(gDegreesRotated > 360.0f) gDegreesRotated -= 360.0f;
//move position of camera based on WASD keys, and XZ keys for up and down
const float moveSpeed = 2.0; //units per second
if(glfwGetKey('S')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward());
} else if(glfwGetKey('W')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.forward());
}
if(glfwGetKey('A')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.right());
} else if(glfwGetKey('D')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.right());
}
if(glfwGetKey('Z')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * -glm::vec3(0,1,0));
} else if(glfwGetKey('X')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * glm::vec3(0,1,0));
}
//rotate camera based on mouse movement
const float mouseSensitivity = 0.1;
int mouseX, mouseY;
glfwGetMousePos(&mouseX, &mouseY);
gCamera.offsetOrientation(mouseSensitivity * mouseY, mouseSensitivity * mouseX);
glfwSetMousePos(0, 0); //reset the mouse, so it doesn't go out of the window
//increase or decrease field of view based on mouse wheel
const float zoomSensitivity = -0.2;
float fieldOfView = gCamera.fieldOfView() + zoomSensitivity * (float)glfwGetMouseWheel();
if(fieldOfView < 5.0f) fieldOfView = 5.0f;
if(fieldOfView > 130.0f) fieldOfView = 130.0f;
gCamera.setFieldOfView(fieldOfView);
glfwSetMouseWheel(0);
}
// update the scene based on the time elapsed since last update
static void Update(float secondsElapsed) {
//rotate the first instance in `gInstances`
const GLfloat degreesPerSecond = 180.0f;
gDegreesRotated += secondsElapsed * degreesPerSecond;
while(gDegreesRotated > 360.0f) gDegreesRotated -= 360.0f;
gInstances.front().transform = glm::rotate(glm::mat4(), gDegreesRotated, glm::vec3(0,1,0));
//move position of camera based on WASD keys, and XZ keys for up and down
const float moveSpeed = 4.0; //units per second
if(glfwGetKey('S')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward());
} else if(glfwGetKey('W')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.forward());
}
if(glfwGetKey('A')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.right());
} else if(glfwGetKey('D')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.right());
}
if(glfwGetKey('Z')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * -glm::vec3(0,1,0));
} else if(glfwGetKey('X')){
gCamera.offsetPosition(secondsElapsed * moveSpeed * glm::vec3(0,1,0));
}
//move light
if(glfwGetKey('1'))
gLight.position = gCamera.position();
// change light color
if(glfwGetKey('2'))
gLight.intensities = glm::vec3(1,0,0); //red
else if(glfwGetKey('3'))
gLight.intensities = glm::vec3(0,1,0); //green
else if(glfwGetKey('4'))
gLight.intensities = glm::vec3(1,1,1); //white
//rotate camera based on mouse movement
const float mouseSensitivity = 0.1f;
int mouseX, mouseY;
glfwGetMousePos(&mouseX, &mouseY);
gCamera.offsetOrientation(mouseSensitivity * mouseY, mouseSensitivity * mouseX);
glfwSetMousePos(0, 0); //reset the mouse, so it doesn't go out of the window
//increase or decrease field of view based on mouse wheel
const float zoomSensitivity = -0.2f;
float fieldOfView = gCamera.fieldOfView() + zoomSensitivity * (float)glfwGetMouseWheel();
if(fieldOfView < 5.0f) fieldOfView = 5.0f;
if(fieldOfView > 130.0f) fieldOfView = 130.0f;
gCamera.setFieldOfView(fieldOfView);
glfwSetMouseWheel(0);
}
int main(void)
{
GLFWwindow* window;
/* Initialize the library */
if (!glfwInit())
return -1;
/* Create a windowed mode window and its OpenGL context */
window = glfwCreateWindow(800, 600, "Hello World", NULL, NULL);
if (!window)
{
glfwTerminate();
return -1;
}
glfwSetScrollCallback(window, OnScroll);
// GLFW settings
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetCursorPos(window, 0, 0);
/* Make the window's context current */
glfwMakeContextCurrent(window);
if (glewInit() != GLEW_OK)
{
glfwTerminate();
return -1;
}
// print out some info about the graphics drivers
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
// OpenGL settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
LoadWoodenCrateAsset();
CreateInstances();
//glClearColor(0.196078431372549f, 0.3137254901960784f, 0.5882352941176471f, 1);
glClearColor(0.0f, 0.0f, 0.0f, 1);
gCamera.setPosition(glm::vec3(3.8, 1, 11));
gCamera.offsetOrientation(10, 0);
gCamera.setViewportAspectRatio(800.0f / 600.0f);
gCamera.setNearAndFarPlanes(0.5f, 100.0f);
double lastTime = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
/* Poll for and process events */
glfwPollEvents();
double thisTime = glfwGetTime();
Update((float)(thisTime - lastTime), window);
lastTime = thisTime;
Render(window);
// check for errors
GLenum error = glGetError();
if (error != GL_NO_ERROR)
std::cerr << "OpenGL Error " << error << std::endl;
//exit program if escape key is pressed
if (glfwGetKey(window, GLFW_KEY_ESCAPE))
glfwSetWindowShouldClose(window, GL_TRUE);
}
glfwTerminate();
return 0;
}
void Update(float secondsElapsed, GLFWwindow* window) {
//const GLfloat degreesPerSecond = 180.0f;
const GLfloat degreesPerSecond = 0.0f;
gDegreesRotated += secondsElapsed * degreesPerSecond;
while (gDegreesRotated > 360.0f) gDegreesRotated -= 360.0f;
//move position of camera based on WASD keys
const float moveSpeed = 2.0; //units per second
if (glfwGetKey(window, 'S')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward());
}
else if (glfwGetKey(window, 'W')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.forward());
}
if (glfwGetKey(window, 'A')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.right());
}
else if (glfwGetKey(window, 'D')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.right());
}
if (glfwGetKey(window, 'Z')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -glm::vec3(0, 1, 0));
}
else if (glfwGetKey(window, 'X')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * glm::vec3(0, 1, 0));
}
//rotate camera based on mouse movement
const float mouseSensitivity = 0.1f;
double mouseX, mouseY;
glfwGetCursorPos(window, &mouseX, &mouseY);
gCamera.offsetOrientation(mouseSensitivity * (float)mouseY, mouseSensitivity * (float)mouseX);
glfwSetCursorPos(window, 0, 0); //reset the mouse, so it doesn't go out of the window
const float zoomSensitivity = -0.2f;
float fieldOfView = gCamera.fieldOfView() + zoomSensitivity * (float)gScrollY;
if (fieldOfView < 5.0f) fieldOfView = 5.0f;
if (fieldOfView > 130.0f) fieldOfView = 130.0f;
gCamera.setFieldOfView(fieldOfView);
gScrollY = 0;
}
int main(void)
{
GLFWwindow* window;
/* Initialize the library */
if (!glfwInit())
return -1;
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
//glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
/* Create a windowed mode window and its OpenGL context */
window = glfwCreateWindow(800, 600, "Hello World", NULL, NULL);
if (!window)
{
glfwTerminate();
return -1;
}
glfwSetScrollCallback(window, OnScroll);
// GLFW settings
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetCursorPos(window, 0, 0);
/* Make the window's context current */
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
if (glewInit() != GLEW_OK)
{
glfwTerminate();
return -1;
}
// print out some info about the graphics drivers
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
// OpenGL settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
init();
gCamera.setPosition(glm::vec3(0, 0, 4));
gCamera.setViewportAspectRatio(800.0f / 600.0f);
double lastTime = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
/* Poll for and process events */
glfwPollEvents();
double thisTime = glfwGetTime();
Update((float)(thisTime - lastTime), window);
lastTime = thisTime;
Render(window);
// check for errors
GLenum error = glGetError();
if (error != GL_NO_ERROR)
std::cerr << "OpenGL Error " << error << std::endl;
//exit program if escape key is pressed
if (glfwGetKey(window, GLFW_KEY_ESCAPE))
glfwSetWindowShouldClose(window, GL_TRUE);
}
glfwTerminate();
return 0;
}
// the program starts here
void AppMain() {
// initialise GLFW
if(!glfwInit())
throw std::runtime_error("glfwInit failed");
// open a window with GLFW
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
if(!glfwOpenWindow((int)SCREEN_SIZE.x, (int)SCREEN_SIZE.y, 8, 8, 8, 8, 16, 0, GLFW_WINDOW))
throw std::runtime_error("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
// GLFW settings
glfwDisable(GLFW_MOUSE_CURSOR);
glfwSetMousePos(0, 0);
glfwSetMouseWheel(0);
// initialise GLEW
glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
if(glewInit() != GLEW_OK)
throw std::runtime_error("glewInit failed");
// GLEW throws some errors, so discard all the errors so far
while(glGetError() != GL_NO_ERROR) {}
// print out some info about the graphics drivers
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
// make sure OpenGL version 3.2 API is available
if(!GLEW_VERSION_3_2)
throw std::runtime_error("OpenGL 3.2 API is not available.");
// OpenGL settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// initialise the gWoodenCrate asset
LoadWoodenCrateAsset();
// create all the instances in the 3D scene based on the gWoodenCrate asset
CreateInstances();
// setup gCamera
gCamera.setPosition(glm::vec3(-4,0,17));
gCamera.setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y);
gCamera.setNearAndFarPlanes(0.5f, 100.0f);
// setup gLight
gLight.position = glm::vec3(-4,0,4);
gLight.intensities = glm::vec3(1,1,1); //white
gLight.attenuation = 0.2f;
gLight.ambientCoefficient = 0.005f;
// run while the window is open
double lastTime = glfwGetTime();
while(glfwGetWindowParam(GLFW_OPENED)){
// update the scene based on the time elapsed since last update
double thisTime = glfwGetTime();
Update((float)(thisTime - lastTime));
lastTime = thisTime;
// draw one frame
Render();
// check for errors
GLenum error = glGetError();
if(error != GL_NO_ERROR)
std::cerr << "OpenGL Error " << error << ": " << (const char*)gluErrorString(error) << std::endl;
//exit program if escape key is pressed
if(glfwGetKey(GLFW_KEY_ESC))
glfwCloseWindow();
}
// clean up and exit
glfwTerminate();
}
void Update(float secondsElapsed, GLFWwindow* window) {
const GLfloat degreesPerSecond = 180.0f;
//const GLfloat degreesPerSecond = 0.0f;
gDegreesRotated += secondsElapsed * degreesPerSecond;
while (gDegreesRotated > 360.0f) gDegreesRotated -= 360.0f;
gInstances.front().transform = glm::rotate(glm::mat4(), gDegreesRotated, glm::vec3(0, 1, 0));
//move position of camera based on WASD keys
const float moveSpeed = 4.0; //units per second
if (glfwGetKey(window, 'S')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward());
}
else if (glfwGetKey(window, 'W')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.forward());
}
if (glfwGetKey(window, 'A')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.right());
}
else if (glfwGetKey(window, 'D')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.right());
}
if (glfwGetKey(window, 'Z')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * -glm::vec3(0, 1, 0));
}
else if (glfwGetKey(window, 'X')) {
gCamera.offsetPosition(secondsElapsed * moveSpeed * glm::vec3(0, 1, 0));
}
//move light
if (glfwGetKey(window, '1'))
gLight.position = gCamera.position();
// change light color
if (glfwGetKey(window, '2'))
gLight.intensities = glm::vec3(1, 0, 0); //red
else if (glfwGetKey(window, '3'))
gLight.intensities = glm::vec3(0, 1, 0); //green
else if (glfwGetKey(window, '4'))
gLight.intensities = glm::vec3(1, 1, 1); //white
//rotate camera based on mouse movement
const float mouseSensitivity = 0.1f;
double mouseX, mouseY;
glfwGetCursorPos(window, &mouseX, &mouseY);
gCamera.offsetOrientation(mouseSensitivity * (float)mouseY, mouseSensitivity * (float)mouseX);
glfwSetCursorPos(window, 0, 0); //reset the mouse, so it doesn't go out of the window
const float zoomSensitivity = -0.2f;
float fieldOfView = gCamera.fieldOfView() + zoomSensitivity * (float)gScrollY;
if (fieldOfView < 5.0f) fieldOfView = 5.0f;
if (fieldOfView > 130.0f) fieldOfView = 130.0f;
gCamera.setFieldOfView(fieldOfView);
gScrollY = 0;
}
