int main(int argc, char* argv[]) {
int camerafound = 0;
if(argc != 2)
{
printf("usage: camctl <u,d,l,r>\n");
return 0;
}
if ((fd = open("/dev/video1",O_RDWR, 0)) != -1)
camerafound = 1;
else if ((fd = open("/dev/video0",O_RDWR, 0)) != -1)
camerafound = 1;
else
return 0;
if (argv[1][0] == 'u'){
camera_tilt(TILTUP, fd);
printf("up\n");
}
if (argv[1][0] == 'd') {
camera_tilt(TILTDOWN, fd);
printf("down\n");
}
if (argv[1][0] == 'l') {
camera_pan(PANLEFT, fd);
printf("left\n");
}
if (argv[1][0] == 'r') {
camera_pan(PANRIGHT, fd);
printf("right\n");
}
return 0;
}
int main( int argc, char **argv )
{
int width = 800, height= 600;
float widthf = (float) width, heightf = (float) height;
double t;
float fps = 0.f;
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Force core profile on Mac OSX
#ifdef __APPLE__
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
// Open a window and create its OpenGL context
if( !glfwOpenWindow( width, height, 0,0,0,0, 24, 0, GLFW_WINDOW ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSetWindowTitle( "001_a" );
// Core profile is flagged as experimental in glew
#ifdef __APPLE__
glewExperimental = GL_TRUE;
#endif
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit( EXIT_FAILURE );
}
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
GLenum glerr = GL_NO_ERROR;
glerr = glGetError();
if (!imguiRenderGLInit(DroidSans_ttf, DroidSans_ttf_len))
{
fprintf(stderr, "Could not init GUI renderer.\n");
exit(EXIT_FAILURE);
}
// Init viewer structures
Camera camera;
camera_defaults(camera);
GUIStates guiStates;
init_gui_states(guiStates);
float dummySlider = 0.f;
// Load images and upload textures
GLuint textures[2];
glGenTextures(2, textures);
int x;
int y;
int comp;
unsigned char * diffuse = stbi_load("textures/spnza_bricks_a_diff.tga", &x, &y, &comp, 3);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, diffuse);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Diffuse %dx%d:%d\n", x, y, comp);
unsigned char * spec = stbi_load("textures/spnza_bricks_a_spec.tga", &x, &y, &comp, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, x, y, 0, GL_RED, GL_UNSIGNED_BYTE, spec);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Spec %dx%d:%d\n", x, y, comp);
glerr = glGetError();
if(glerr != GL_NO_ERROR)
fprintf(stderr, "2nd OpenGL Error : %s\n", gluErrorString(glerr));
// Try to load and compile shader
ShaderGLSL shader;
const char * shaderFile = "001/3a.glsl";
//const char * shaderFile = "001/4a.glsl";
//const char * shaderFile = "001/5a.glsl";
//const char * shaderFile = "001/5ba.glsl";
//const char * shaderFile = "001/6a.glsl";
//const char * shaderFile = "001/7a.glsl";
//const char * shaderFile = "001/8a.glsl";
//int status = load_shader_from_file(shader, shaderFile, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
int status = load_shader_from_file(shader, shaderFile, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFile);
exit( EXIT_FAILURE );
}
// Apply shader
GLuint program = shader.program;
glUseProgram(program);
GLuint projectionLocation = glGetUniformLocation(program, "Projection");
GLuint viewLocation = glGetUniformLocation(program, "View");
GLuint objectLocation = glGetUniformLocation(program, "Object");
GLuint timeLocation = glGetUniformLocation(program, "Time");
GLuint diffuseLocation = glGetUniformLocation(program, "Diffuse");
GLuint specLocation = glGetUniformLocation(program, "Spec");
GLuint cameraPositionLocation = glGetUniformLocation(program, "CameraPosition");
glUniform1i(diffuseLocation, 0);
glUniform1i(specLocation, 1);
// Load geometry
int cube_triangleCount = 12;
int cube_triangleList[] = {0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 7, 8, 9, 10, 10, 9, 11, 12, 13, 14, 14, 13, 15, 16, 17, 18, 19, 17, 20, 21, 22, 23, 24, 25, 26, };
float cube_uvs[] = {0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 1.f, 1.f, 0.f, };
float cube_vertices[] = {-0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5 };
float cube_normals[] = {0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, };
int plane_triangleCount = 2;
int plane_triangleList[] = {0, 1, 2, 2, 1, 3};
float plane_uvs[] = {0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f};
float plane_vertices[] = {-5.0, -1.0, 5.0, 5.0, -1.0, 5.0, -5.0, -1.0, -5.0, 5.0, -1.0, -5.0};
float plane_normals[] = {0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0};
// Vertex Array Object
GLuint vao[2];
glGenVertexArrays(2, vao);
// Vertex Buffer Objects
GLuint vbo[8];
glGenBuffers(8, vbo);
// Cube
glBindVertexArray(vao[0]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_triangleList), cube_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_normals), cube_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_uvs), cube_uvs, GL_STATIC_DRAW);
// Plane
glBindVertexArray(vao[1]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[4]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(plane_triangleList), plane_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[5]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_vertices), plane_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[6]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_normals), plane_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[7]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_uvs), plane_uvs, GL_STATIC_DRAW);
// Unbind everything. Potentially illegal on some implementations
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Viewport
glViewport( 0, 0, width, height );
do
{
t = glfwGetTime();
// Mouse states
int leftButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_LEFT );
int rightButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_RIGHT );
int middleButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_MIDDLE );
if( leftButton == GLFW_PRESS )
guiStates.turnLock = true;
else
guiStates.turnLock = false;
if( rightButton == GLFW_PRESS )
guiStates.zoomLock = true;
else
guiStates.zoomLock = false;
if( middleButton == GLFW_PRESS )
guiStates.panLock = true;
else
guiStates.panLock = false;
// Camera movements
int altPressed = glfwGetKey(GLFW_KEY_LSHIFT);
if (!altPressed && (leftButton == GLFW_PRESS || rightButton == GLFW_PRESS || middleButton == GLFW_PRESS))
{
int x; int y;
glfwGetMousePos(&x, &y);
guiStates.lockPositionX = x;
guiStates.lockPositionY = y;
}
if (altPressed == GLFW_PRESS)
{
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
int diffLockPositionX = mousex - guiStates.lockPositionX;
int diffLockPositionY = mousey - guiStates.lockPositionY;
if (guiStates.zoomLock)
{
float zoomDir = 0.0;
if (diffLockPositionX > 0)
zoomDir = -1.f;
else if (diffLockPositionX < 0 )
zoomDir = 1.f;
camera_zoom(camera, zoomDir * GUIStates::MOUSE_ZOOM_SPEED);
}
else if (guiStates.turnLock)
{
camera_turn(camera, diffLockPositionY * GUIStates::MOUSE_TURN_SPEED,
diffLockPositionX * GUIStates::MOUSE_TURN_SPEED);
}
else if (guiStates.panLock)
{
camera_pan(camera, diffLockPositionX * GUIStates::MOUSE_PAN_SPEED,
diffLockPositionY * GUIStates::MOUSE_PAN_SPEED);
}
guiStates.lockPositionX = mousex;
guiStates.lockPositionY = mousey;
}
// Default states
glEnable(GL_DEPTH_TEST);
// Clear the front buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Get camera matrices
glm::mat4 projection = glm::perspective(45.0f, widthf / heightf, 0.1f, 100.f);
glm::mat4 worldToView = glm::lookAt(camera.eye, camera.o, camera.up);
glm::mat4 objectToWorld;
// Select textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
// Select shader
glUseProgram(program);
// Upload uniforms
glUniformMatrix4fv(projectionLocation, 1, 0, glm::value_ptr(projection));
glUniformMatrix4fv(viewLocation, 1, 0, glm::value_ptr(worldToView));
glUniformMatrix4fv(objectLocation, 1, 0, glm::value_ptr(objectToWorld));
glUniform1f(timeLocation, t);
glUniform3fv(cameraPositionLocation, 1, glm::value_ptr(camera.eye));
// Render vaos
glBindVertexArray(vao[0]);
glDrawElementsInstanced(GL_TRIANGLES, cube_triangleCount * 3, GL_UNSIGNED_INT, (void*)0, 4);
//glDrawElements(GL_TRIANGLES, cube_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
glBindVertexArray(vao[1]);
glDrawElements(GL_TRIANGLES, plane_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
#if 1
// Draw UI
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, width, height);
unsigned char mbut = 0;
int mscroll = 0;
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
mousey = height - mousey;
if( leftButton == GLFW_PRESS )
mbut |= IMGUI_MBUT_LEFT;
imguiBeginFrame(mousex, mousey, mbut, mscroll);
int logScroll = 0;
char lineBuffer[512];
imguiBeginScrollArea("001", width - 210, height - 310, 200, 300, &logScroll);
sprintf(lineBuffer, "FPS %f", fps);
imguiLabel(lineBuffer);
imguiSlider("Dummy", &dummySlider, 0.0, 3.0, 0.1);
imguiEndScrollArea();
imguiEndFrame();
imguiRenderGLDraw(width, height);
glDisable(GL_BLEND);
#endif
// Check for errors
GLenum err = glGetError();
if(err != GL_NO_ERROR)
{
fprintf(stderr, "OpenGL Error : %s\n", gluErrorString(err));
}
// Swap buffers
glfwSwapBuffers();
double newTime = glfwGetTime();
fps = 1.f/ (newTime - t);
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}
int main( int argc, char* args[] )
{
// this is the last time (SDL_Getticks()) that beasts were evaluated
int beastLastEval=0;
// this is how many times per second the beasts should be evaluated
int beastEvalsPerSec = 30;
paused = 0;
//get a random seed.
sgenrand(time(NULL));
//mouse variables and cell types
int x, y, sleepTime = 0, countVar = 0;
//mouse is held variables
int mouseStatusLeft = 0, mouseStatusRight = 0;
// these keep track of the position of the right mouse button when it was clicked down
int mouseRDx;
int mouseRDy;
//make sure the program waits for a quit
int quit = false;
init_mats();
init_graphics();
init_controls();
//Initialize
if( init() == false ) return 1;
//Load the files
if( load_files() == false ) return 2;
//Update the screen
if( SDL_Flip( screen ) == -1 ) return 3;
gen_world();
// these keep track of the WASD keys.
int keyw=0, keya=0, keys=0, keyd=0;
int key; // used as a stand-int for the verbose event.key.keysym.sym
bool keyF3=true;
//these are used to calculating and keeping track of the FPS
int ticksSinceLastFPSUpdate = 0;
int cumulativeFrames = 0;
int currentTicks = 0;
SDL_Rect screenRect;
screenRect.x = screenRect.y = 0;
screenRect.w = SCREEN_WIDTH;
screenRect.h = SCREEN_HEIGHT;
//While the user hasn't quit
while(1){
//While there's an event to handle
while( SDL_PollEvent( &event ) ){
//If the user has Xed out the window
if( event.type == SDL_QUIT || quit == true ){
//Quit the program
clean_up();
return 0;
}
if( event.type == SDL_MOUSEBUTTONDOWN ){ /// mouse down
x = event.motion.x;
y = event.motion.y;
if( event.button.button == SDL_BUTTON_LEFT ){
mouseStatusLeft = 1;
}
else if( event.button.button == SDL_BUTTON_RIGHT ){
mouseStatusRight = 1;
mouseRDx = x;
mouseRDy = y;
}
else if( event.button.button == SDL_BUTTON_WHEELUP )
;//zoom_in(x,y);
else if( event.button.button == SDL_BUTTON_WHEELDOWN )
;//zoom_out(x,y);
}
else if(event.type == SDL_MOUSEBUTTONUP){ /// mouse up
x = event.motion.x;
y = event.motion.y;
if( event.button.button == SDL_BUTTON_LEFT ){
mouseStatusLeft = 0;
}
else if( event.button.button == SDL_BUTTON_RIGHT ){
mouseStatusRight = 0;
}
}
else if( event.type == SDL_MOUSEMOTION ){ /// mouse motion
x = event.motion.x;
y = event.motion.y;
/*
// if the alt key (camera panning key) is down and the coordinates have changed, then let the screen be panned!
if(alt && x != mouse_x_when_pan && y != mouse_y_when_pan){
// this adjusts the x-axis camera (this scales with the CELL_SIZE)
camera_x += (x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE;
camera_y += (y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE;
//calculate the remainders of the mouse motion.
// these values represent the motion of the mouse that is not utilized by the discrete nature of the operation on the camera_x and camera_y values.
remainder_panning_motion_x = (x-mouse_x_when_pan+remainder_panning_motion_x) - (int)((x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE)*CELL_SIZE;
remainder_panning_motion_y = (y-mouse_y_when_pan+remainder_panning_motion_y) - (int)((y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE)*CELL_SIZE;
// make sure the camera is not out of bounds.
verify_camera();
//reset the user's curcor position to the original position the curcor was in when the user started panning the camera
SDL_WarpMouse(mouse_x_when_pan, mouse_y_when_pan);
}
*/
}
else if(event.type == SDL_VIDEORESIZE){ /// window resize
// don't resize the grid.
//float new_cell_size = CELL_SIZE * event.resize.h/((float)SCREEN_HEIGHT); // adjust the pixel size.
//if(new_cell_size - ((int)new_cell_size) >= 0.5f) CELL_SIZE = new_cell_size + 1;
//else CELL_SIZE = new_cell_size;
screenRect.w = SCREEN_WIDTH = event.resize.w;
screenRect.h = SCREEN_HEIGHT = event.resize.h;
set_window_size(event.resize.w, event.resize.h); // set window to correct dimensions
}
if( event.type == SDL_KEYDOWN ){ ///keyboard event
key = event.key.keysym.sym;
if (key == controlsGame.pan[d_up]) camera_pan(d_up); // pan up
else if(key == controlsGame.pan[d_down]) camera_pan(d_down); // pan down
else if(key == controlsGame.pan[d_left]) camera_pan(d_left); // pan left
else if(key == controlsGame.pan[d_right]) camera_pan(d_right); // pan right
else if(key == controlsGame.debug) keyF3 ^= 1; // toggle the keyF3 state
}
if( event.type == SDL_KEYUP ){ ///keyboard event
// nothing here yet
}
} // end while(event)
//no more events to handle at the moment.
if(mouseStatusLeft==true && beast_find_at_cell(x/CELL_SIZE+cameraX,y/CELL_SIZE+cameraY) == NULL){
// add beast function
struct beastData *myBeast;
myBeast = beast_create(NULL);
if(myBeast != NULL ){
myBeast->x = x/CELL_SIZE + cameraX;
myBeast->y = y/CELL_SIZE + cameraY;
}
}
if(SDL_GetTicks()-beastLastEval > 1000/beastEvalsPerSec){
// evaluate all beasts
beasts_evaluate();
beastLastEval = SDL_GetTicks();
}
// print the grid data
print_grid(screen);
print_beasts(screen);
print_beasts_targets(screen);
// print debugging information
if(keyF3) print_debugging_information(screen);
//updates the screen
SDL_Flip( screen );
SDL_FillRect(screen, &screenRect, 0);
//----------------------------------------------------
// FPS calculation and variable handling
//----------------------------------------------------
currentTicks = SDL_GetTicks();
// it is officially the next second
if(currentTicks >= ticksSinceLastFPSUpdate + 1000){
// calculate the FPS
FPS = cumulativeFrames;//(cumulativeFrames*1000 ) / (currentTicks-ticksSinceLastFPSUpdate);
cumulativeFrames=0; // reset cumulative amount of frames
ticksSinceLastFPSUpdate = currentTicks; // reset the last FPS update to the number of ticks now.
}
cumulativeFrames++;
}// end while(quit == false)
//Free the surface and quit SDL
clean_up();
return 0;
}
/// this will make sure that your camera has valid parameters (1/3 < scale < 3, x within (BLOCK_WIDTH/2 - 1), and y within (BLOCK_HEIGHT/2 - 1)).
// returns 0 on successful check
// returns 1 on null cam pointer
short camera_check(struct cameraData *cam){
if(cam == NULL){
// report error
error("camera_check() was sent invalid cam. cam = NULL");
// and return an error
return 1;
}
short check;
do{
// check is initially set to 0 at the start of each loop.
// if a camera action was performed, check will be set to 1.
// this will indicate the loop needs to be evaluated one more time.
check = 0;
//--------------------------------------------------
// check to see if x is out of the bounds of the target block
//--------------------------------------------------
if(cam->x < 0){
// pan the camera appropriately
camera_pan(cam, CAMERA_PAN_LEFT);
// record that a single check was made.
check = 1;
}
else if(cam->x >= BLOCK_WIDTH){
// pan the camera appropriately
camera_pan(cam, CAMERA_PAN_RIGHT);
// record that a single check was made.
check = 1;
}
//--------------------------------------------------
// check if y is out of bounds of the target block
//--------------------------------------------------
if(cam->y < 0){
// pan the camera appropriately
camera_pan(cam, CAMERA_PAN_UP);
// record that a single check was made.
check = 1;
}
else if(cam->y >= BLOCK_HEIGHT){
// pan the camera appropriately
camera_pan(cam, CAMERA_PAN_DOWN);
// record that a single check was made.
check = 1;
}
//--------------------------------------------------
// check for scale being too large
//--------------------------------------------------
if(cam->scale >= BLOCK_LINEAR_SCALE_FACTOR){
// zoom out once
camera_zoom_out(cam);
// record that a single check was made
check = 1;
}
//--------------------------------------------------
// check for scale being too small
//--------------------------------------------------
if(cam->scale <= 1/BLOCK_LINEAR_SCALE_FACTOR){
// zoom in once
camera_zoom_in(cam);
// record that a single check was made.
check = 1;
}
}while(check); // loop again if a modification was made to the camera
return 0;
}
int main( int argc, char **argv )
{
int width = 1024, height=768;
float widthf = (float) width, heightf = (float) height;
double t;
float fps = 0.f;
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Force core profile on Mac OSX
#ifdef __APPLE__
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
// Open a window and create its OpenGL context
if( !glfwOpenWindow( width, height, 0,0,0,0, 24, 0, GLFW_WINDOW ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSetWindowTitle( "002_forward_a" );
// Core profile is flagged as experimental in glew
#ifdef __APPLE__
glewExperimental = GL_TRUE;
#endif
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit( EXIT_FAILURE );
}
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
GLenum glerr = GL_NO_ERROR;
glerr = glGetError();
if (!imguiRenderGLInit(DroidSans_ttf, DroidSans_ttf_len))
{
fprintf(stderr, "Could not init GUI renderer.\n");
exit(EXIT_FAILURE);
}
// Init viewer structures
Camera camera;
camera_defaults(camera);
GUIStates guiStates;
init_gui_states(guiStates);
// GUI
float numLights = 10.f;
// Load images and upload textures
GLuint textures[3];
glGenTextures(3, textures);
int x;
int y;
int comp;
unsigned char * diffuse = stbi_load("textures/spnza_bricks_a_diff.tga", &x, &y, &comp, 3);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, diffuse);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Diffuse %dx%d:%d\n", x, y, comp);
unsigned char * spec = stbi_load("textures/spnza_bricks_a_spec.tga", &x, &y, &comp, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, x, y, 0, GL_RED, GL_UNSIGNED_BYTE, spec);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Spec %dx%d:%d\n", x, y, comp);
// Try to load and compile shader
int status;
ShaderGLSL gbuffer_shader;
const char * shaderFileGBuffer = "002/2_gbuffera.glsl";
//int status = load_shader_from_file(gbuffer_shader, shaderFileGBuffer, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
status = load_shader_from_file(gbuffer_shader, shaderFileGBuffer, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFileGBuffer);
exit( EXIT_FAILURE );
}
// Compute locations for gbuffer_shader
GLuint gbuffer_projectionLocation = glGetUniformLocation(gbuffer_shader.program, "Projection");
GLuint gbuffer_viewLocation = glGetUniformLocation(gbuffer_shader.program, "View");
GLuint gbuffer_objectLocation = glGetUniformLocation(gbuffer_shader.program, "Object");
GLuint gbuffer_timeLocation = glGetUniformLocation(gbuffer_shader.program, "Time");
GLuint gbuffer_diffuseLocation = glGetUniformLocation(gbuffer_shader.program, "Diffuse");
GLuint gbuffer_specLocation = glGetUniformLocation(gbuffer_shader.program, "Spec");
// Load Blit shader
ShaderGLSL blit_shader;
const char * shaderFileBlit = "002/2_blita.glsl";
//int status = load_shader_from_file(blit_shader, shaderFileBlit, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
status = load_shader_from_file(blit_shader, shaderFileBlit, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFileBlit);
exit( EXIT_FAILURE );
}
// Compute locations for blit_shader
GLuint blit_tex1Location = glGetUniformLocation(blit_shader.program, "Texture1");
// Load light accumulation shader
ShaderGLSL lighting_shader;
const char * shaderFileLighting = "002/2_lighta.glsl";
//int status = load_shader_from_file(lighting_shader, shaderFileLighting, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
status = load_shader_from_file(lighting_shader, shaderFileLighting, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFileLighting);
exit( EXIT_FAILURE );
}
// Compute locations for lighting_shader
GLuint lighting_materialLocation = glGetUniformLocation(lighting_shader.program, "Material");
GLuint lighting_normalLocation = glGetUniformLocation(lighting_shader.program, "Normal");
GLuint lighting_depthLocation = glGetUniformLocation(lighting_shader.program, "Depth");
GLuint lighting_inverseViewProjectionLocation = glGetUniformLocation(lighting_shader.program, "InverseViewProjection");
GLuint lighting_cameraPositionLocation = glGetUniformLocation(lighting_shader.program, "CameraPosition");
GLuint lighting_lightPositionLocation = glGetUniformLocation(lighting_shader.program, "LightPosition");
GLuint lighting_lightColorLocation = glGetUniformLocation(lighting_shader.program, "LightColor");
GLuint lighting_lightIntensityLocation = glGetUniformLocation(lighting_shader.program, "LightIntensity");
// Load geometry
int cube_triangleCount = 12;
int cube_triangleList[] = {0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 7, 8, 9, 10, 10, 9, 11, 12, 13, 14, 14, 13, 15, 16, 17, 18, 19, 17, 20, 21, 22, 23, 24, 25, 26, };
float cube_uvs[] = {0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 1.f, 1.f, 0.f, };
float cube_vertices[] = {-0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5 };
float cube_normals[] = {0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, };
int plane_triangleCount = 2;
int plane_triangleList[] = {0, 1, 2, 2, 1, 3};
float plane_uvs[] = {0.f, 0.f, 0.f, 10.f, 10.f, 0.f, 10.f, 10.f};
float plane_vertices[] = {-50.0, -1.0, 50.0, 50.0, -1.0, 50.0, -50.0, -1.0, -50.0, 50.0, -1.0, -50.0};
float plane_normals[] = {0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0};
int quad_triangleCount = 2;
int quad_triangleList[] = {0, 1, 2, 2, 1, 3};
float quad_vertices[] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0};
// Vertex Array Object
GLuint vao[3];
glGenVertexArrays(3, vao);
// Vertex Buffer Objects
GLuint vbo[12];
glGenBuffers(12, vbo);
// Cube
glBindVertexArray(vao[0]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_triangleList), cube_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_normals), cube_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_uvs), cube_uvs, GL_STATIC_DRAW);
// Plane
glBindVertexArray(vao[1]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[4]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(plane_triangleList), plane_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[5]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_vertices), plane_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[6]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_normals), plane_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[7]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_uvs), plane_uvs, GL_STATIC_DRAW);
// Quad
glBindVertexArray(vao[2]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[8]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quad_triangleList), quad_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[9]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GL_STATIC_DRAW);
// Unbind everything. Potentially illegal on some implementations
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Init frame buffers
GLuint gbufferFbo;
GLuint gbufferTextures[3];
GLuint gbufferDrawBuffers[2];
glGenTextures(3, gbufferTextures);
// Create color texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_FLOAT, 0);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Create normal texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_FLOAT, 0);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Create depth texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Create Framebuffer Object
glGenFramebuffers(1, &gbufferFbo);
glBindFramebuffer(GL_FRAMEBUFFER, gbufferFbo);
// Attach textures to framebuffer
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D, gbufferTextures[0], 0);
gbufferDrawBuffers[0] = GL_COLOR_ATTACHMENT0;
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , GL_TEXTURE_2D, gbufferTextures[1], 0);
gbufferDrawBuffers[1] = GL_COLOR_ATTACHMENT1;
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, gbufferTextures[2], 0);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
fprintf(stderr, "Error on building framebuffer\n");
exit( EXIT_FAILURE );
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
do
{
t = glfwGetTime();
// Mouse states
int leftButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_LEFT );
int rightButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_RIGHT );
int middleButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_MIDDLE );
if( leftButton == GLFW_PRESS )
guiStates.turnLock = true;
else
guiStates.turnLock = false;
if( rightButton == GLFW_PRESS )
guiStates.zoomLock = true;
else
guiStates.zoomLock = false;
if( middleButton == GLFW_PRESS )
guiStates.panLock = true;
else
guiStates.panLock = false;
// Camera movements
int altPressed = glfwGetKey(GLFW_KEY_LSHIFT);
if (!altPressed && (leftButton == GLFW_PRESS || rightButton == GLFW_PRESS || middleButton == GLFW_PRESS))
{
int x; int y;
glfwGetMousePos(&x, &y);
guiStates.lockPositionX = x;
guiStates.lockPositionY = y;
}
if (altPressed == GLFW_PRESS)
{
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
int diffLockPositionX = mousex - guiStates.lockPositionX;
int diffLockPositionY = mousey - guiStates.lockPositionY;
if (guiStates.zoomLock)
{
float zoomDir = 0.0;
if (diffLockPositionX > 0)
zoomDir = -1.f;
else if (diffLockPositionX < 0 )
zoomDir = 1.f;
camera_zoom(camera, zoomDir * GUIStates::MOUSE_ZOOM_SPEED);
}
else if (guiStates.turnLock)
{
camera_turn(camera, diffLockPositionY * GUIStates::MOUSE_TURN_SPEED,
diffLockPositionX * GUIStates::MOUSE_TURN_SPEED);
}
else if (guiStates.panLock)
{
camera_pan(camera, diffLockPositionX * GUIStates::MOUSE_PAN_SPEED,
diffLockPositionY * GUIStates::MOUSE_PAN_SPEED);
}
guiStates.lockPositionX = mousex;
guiStates.lockPositionY = mousey;
}
// Get camera matrices
glm::mat4 projection = glm::perspective(45.0f, widthf / heightf, 0.1f, 100.f);
glm::mat4 worldToView = glm::lookAt(camera.eye, camera.o, camera.up);
glm::mat4 objectToWorld;
glm::mat4 worldToScreen = projection * worldToView;
glm::mat4 screenToWorld = glm::transpose(glm::inverse(worldToScreen));
glBindFramebuffer(GL_FRAMEBUFFER, gbufferFbo);
glDrawBuffers(2, gbufferDrawBuffers);
// Viewport
glViewport( 0, 0, width, height );
// Default states
glEnable(GL_DEPTH_TEST);
// Clear the front buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind gbuffer shader
glUseProgram(gbuffer_shader.program);
// Upload uniforms
glUniformMatrix4fv(gbuffer_projectionLocation, 1, 0, glm::value_ptr(projection));
glUniformMatrix4fv(gbuffer_viewLocation, 1, 0, glm::value_ptr(worldToView));
glUniformMatrix4fv(gbuffer_objectLocation, 1, 0, glm::value_ptr(objectToWorld));
glUniform1f(gbuffer_timeLocation, t);
glUniform1i(gbuffer_diffuseLocation, 0);
glUniform1i(gbuffer_specLocation, 1);
// Bind textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
// Render vaos
glBindVertexArray(vao[0]);
glDrawElementsInstanced(GL_TRIANGLES, cube_triangleCount * 3, GL_UNSIGNED_INT, (void*)0, 4);
glBindVertexArray(vao[1]);
glDrawElements(GL_TRIANGLES, plane_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
// Unbind framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Viewport
glViewport( 0, 0, width, height );
// Clear the front buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind lighting shader
glUseProgram(lighting_shader.program);
// Upload uniforms
glUniform1i(lighting_materialLocation, 0);
glUniform1i(lighting_normalLocation, 1);
glUniform1i(lighting_depthLocation, 2);
glUniform3fv(lighting_cameraPositionLocation, 1, glm::value_ptr(camera.eye));
glUniformMatrix4fv(lighting_inverseViewProjectionLocation, 1, 0, glm::value_ptr(screenToWorld));
// Bind color to unit 0
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gbufferTextures[0]);
// Bind normal to unit 1
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, gbufferTextures[1]);
// Bind depth to unit 2
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, gbufferTextures[2]);
// Blit above the rest
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
for (int i = 0; i < (int) numLights; ++i)
{
float tl = t * i;
//Update light uniforms
float lightPosition[3] = { sinf(tl) * 10.f, -0.5f, cosf(tl) * 10.f};
float lightColor[3] = {sinf(tl) * 1.f, 1.f - cosf(tl), -sinf(tl)};
float lightIntensity = 10.0;
glUniform3fv(lighting_lightPositionLocation, 1, lightPosition);
glUniform3fv(lighting_lightColorLocation, 1, lightColor);
glUniform1f(lighting_lightIntensityLocation, lightIntensity);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
}
glDisable(GL_BLEND);
// Bind blit shader
glUseProgram(blit_shader.program);
// Upload uniforms
glUniform1i(blit_tex1Location, 0);
// use only unit 0
glActiveTexture(GL_TEXTURE0);
// Viewport
glViewport( 0, 0, width/3, height/4 );
// Bind texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[0]);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
// Viewport
glViewport( width/3, 0, width/3, height/4 );
// Bind texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[1]);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
// Viewport
glViewport( width/3 * 2, 0, width/3, height/4 );
// Bind texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[2]);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
#if 1
// Draw UI
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, width, height);
unsigned char mbut = 0;
int mscroll = 0;
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
mousey = height - mousey;
if( leftButton == GLFW_PRESS )
mbut |= IMGUI_MBUT_LEFT;
imguiBeginFrame(mousex, mousey, mbut, mscroll);
int logScroll = 0;
char lineBuffer[512];
imguiBeginScrollArea("001", width - 210, height - 310, 200, 300, &logScroll);
sprintf(lineBuffer, "FPS %f", fps);
imguiLabel(lineBuffer);
imguiSlider("Lights", &numLights, 0.0, 100.0, 1.0);
imguiEndScrollArea();
imguiEndFrame();
imguiRenderGLDraw(width, height);
glDisable(GL_BLEND);
#endif
// Check for errors
GLenum err = glGetError();
if(err != GL_NO_ERROR)
{
fprintf(stderr, "OpenGL Error : %s\n", gluErrorString(err));
}
// Swap buffers
glfwSwapBuffers();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Clean UI
imguiRenderGLDestroy();
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}
