static void render_char(font_info* info, const char ch, float* x, float* y, float sx, float sy, float startX, float startY) {
#ifdef KUHL_UTIL_USE_FREETYPE
FT_GlyphSlot g = info->face->glyph;
if(FT_Load_Char(info->face, ch, FT_LOAD_RENDER))
return;
if (ch == '\n') {
*y -= info->pointSize * sy;
*x = startX;
return;
} else if (ch == '\r') {
*x = startX;
return;
}
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RED,
g->bitmap.width,
g->bitmap.rows,
0,
GL_RED,
GL_UNSIGNED_BYTE,
g->bitmap.buffer
);
kuhl_errorcheck();
float x2 = *x + g->bitmap_left * sx;
float y2 = -*y - g->bitmap_top * sy;
float w = g->bitmap.width * sx;
float h = g->bitmap.rows * sy;
GLfloat box[4][4] = {
{x2, -y2 , 0, 0},
{x2 + w, -y2 , 1, 0},
{x2, -y2 - h, 0, 1},
{x2 + w, -y2 - h, 1, 1},
};
glBufferData(GL_ARRAY_BUFFER, sizeof box, box, GL_DYNAMIC_DRAW);
kuhl_errorcheck();
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
kuhl_errorcheck();
*x += (g->advance.x >> 6) * sx;
*y += (g->advance.y >> 6) * sy;
#endif
}
void init_geometryTriangle(kuhl_geometry *geom, GLuint prog)
{
kuhl_geometry_new(geom, prog, 3, GL_TRIANGLES);
GLfloat texcoordData[] = {0, 0,
1, 0,
1, 1 };
kuhl_geometry_attrib(geom, texcoordData, 2, "in_TexCoord", KG_WARN);
/* The data that we want to draw */
GLfloat vertexData[] = {0, 0, 0,
1, 0, 0,
1, 1, 0};
kuhl_geometry_attrib(geom, vertexData, 3, "in_Position", KG_WARN);
/* Load the texture. It will be bound to texId */
GLuint texId = 0;
kuhl_read_texture_file("../images/rainbow.png", &texId);
/* Tell this piece of geometry to use the texture we just loaded. */
kuhl_geometry_texture(geom, texId, "tex", KG_WARN);
kuhl_errorcheck();
}
/* This illustrates how to draw a quad by drawing two triangles and reusing vertices. */
void init_geometryQuad(kuhl_geometry *geom, GLuint prog)
{
kuhl_geometry_new(geom, prog,
4, // number of vertices
GL_TRIANGLES); // type of thing to draw
/* Vertices that we want to form triangles out of. Every 3 numbers
* is a vertex position. Below, we provide indices to form
* triangles out of these vertices. */
GLfloat vertexPositions[] = {0+1.1, 0, 0,
1+1.1, 0, 0,
1+1.1, 1, 0,
0+1.1, 1, 0 };
kuhl_geometry_attrib(geom, vertexPositions,
3, // number of components x,y,z
"in_Position", // GLSL variable
KG_WARN); // warn if attribute is missing in GLSL program?
/* A list of triangles that we want to draw. "0" refers to the
* first vertex in our list of vertices. Every three numbers forms
* a single triangle. */
GLuint indexData[] = { 0, 1, 2,
0, 2, 3 };
kuhl_geometry_indices(geom, indexData, 6);
kuhl_errorcheck();
}
/* This illustrates how to draw a quad by drawing two triangles and reusing vertices. */
void init_geometryQuad(kuhl_geometry *geom, GLuint prog)
{
kuhl_geometry_new(geom, prog,
4, // number of vertices
GL_TRIANGLES); // type of thing to draw
/* The data that we want to draw */
GLfloat vertexPositions[] = {0, 0, 0,
1, 0, 0,
1, 1, 0,
0, 1, 0 };
kuhl_geometry_attrib(geom, vertexPositions,
3, // number of components x,y,z
"in_Position", // GLSL variable
KG_WARN); // warn if attribute is missing in GLSL program?
GLfloat texcoord[] = {0, 0,
1, 0,
1, 1,
0, 1};
kuhl_geometry_attrib(geom, texcoord,
2, // number of components x,y,z
"in_TexCoord", // GLSL variable
KG_WARN); // warn if attribute is missing in GLSL program?
GLuint indexData[] = { 0, 1, 2, // first triangle is index 0, 1, and 2 in the list of vertices
0, 2, 3 }; // indices of second triangle.
kuhl_geometry_indices(geom, indexData, 6);
kuhl_errorcheck();
}
int main(int argc, char** argv)
{
/* Initialize GLUT and GLEW */
kuhl_ogl_init(&argc, argv, 512, 512, 32,
GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE, 4);
// setup callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
/* Compile and link a GLSL program composed of a vertex shader and
* a fragment shader. */
program = kuhl_create_program("triangle.vert", "triangle.frag");
glUseProgram(program);
kuhl_errorcheck();
/* Set the uniform variable in the shader that is named "red" to the value 1. */
glUniform1i(kuhl_get_uniform("red"), 1);
kuhl_errorcheck();
/* Good practice: Unbind objects until we really need them. */
glUseProgram(0);
/* Create kuhl_geometry structs for the objects that we want to
* draw. */
init_geometryTriangle(&triangle, program);
init_geometryQuad(&quad, program);
prerendProgram = kuhl_create_program("prerend.vert", "prerend.frag");
init_geometryQuadPrerender(&prerendQuad, prerendProgram);
dgr_init(); /* Initialize DGR based on environment variables. */
projmat_init(); /* Figure out which projection matrix we should use based on environment variables */
float initCamPos[3] = {0,0,3}; // location of camera
float initCamLook[3] = {0,0,0}; // a point the camera is facing at
float initCamUp[3] = {0,1,0}; // a vector indicating which direction is up
viewmat_init(initCamPos, initCamLook, initCamUp);
/* Tell GLUT to start running the main loop and to call display(),
* keyboard(), etc callback methods as needed. */
glutMainLoop();
/* // An alternative approach:
while(1)
glutMainLoopEvent();
*/
exit(EXIT_SUCCESS);
}
/** Draw a object at the location and orientation of the tracked vrpn object */
void drawObject(const int objectIndex, float viewMat[16])
{
const char *vrpnObject = global_argv[objectIndex];
const float scaleFactor = .5;
float pos[4], orient[16];
vrpn_get(vrpnObject, NULL, pos, orient);
float modelMat[16],translate[16],scale[16];
mat4f_scale_new(scale, scaleFactor, scaleFactor, scaleFactor);
mat4f_translateVec_new(translate, pos);
mat4f_mult_mat4f_many(modelMat, translate, orient, scale, NULL);
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, modelMat); // modelview = view * model
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
glUniform1i(kuhl_get_uniform("renderStyle"), 2);
kuhl_errorcheck();
kuhl_geometry_draw(modelgeom); /* Draw the model */
kuhl_errorcheck();
/* Transparency of labels may not appear right because we aren't
* sorting them by depth. */
float labelScale[16];
mat4f_scale_new(labelScale, 1, 1/labelAspectRatio[objectIndex-1], 1);
mat4f_mult_mat4f_new(modelview, modelview, labelScale);
glUniformMatrix4fv(kuhl_get_uniform("ModelView"), 1, 0, modelview);
glUniform1i(kuhl_get_uniform("renderStyle"), 1);
kuhl_geometry_texture(&quad, label[objectIndex-1], "tex", 1);
kuhl_geometry_draw(&quad);
#if 0
printf("%s is at\n", vrpnObject);
vec3f_print(pos);
mat4f_print(orient);
#endif
}
int main(int argc, char** argv)
{
totalTextures = argc-1;
if(totalTextures == 0)
{
printf("ERROR: Provide textures to use.\n");
exit(EXIT_FAILURE);
}
globalargv = argv;
/* set up our GLUT window */
glutInit(&argc, argv);
glutInitWindowSize(1152, 432); // same aspect ratio as IVS
/* Ask GLUT to for a double buffered, full color window that
* includes a depth buffer */
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow(argv[0]); // set window title to executable name
/* Initialize GLEW */
GLenum glewError = glewInit();
if(glewError != GLEW_OK)
{
fprintf(stderr, "Error initializing GLEW: %s\n", glewGetErrorString(glewError));
exit(EXIT_FAILURE);
}
kuhl_errorcheck();
// setup callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutSpecialFunc(special_keyboard); // pageup,pagedown, etc
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
// Initialize DGR
dgr_init();
projmat_init();
loadTexture(1);
/* Tell GLUT to start running the main loop and to call display(),
* keyboard(), etc callback methods as needed. */
glutMainLoop();
exit(EXIT_SUCCESS);
}
/** Should be called when we have completed rendering a frame. For
* HMDs, this should be called after both the left and right eyes have
* been rendered. */
void viewmat_end_frame(void)
{
if(viewmat_display_mode == VIEWMAT_OCULUS)
{
#ifndef MISSING_OVR
/* Copy the prerendered image from a multisample antialiasing
texture into a normal OpenGL texture. This section of code
is not necessary if we are rendering directly into the
normal (non-antialiased) OpenGL texture. */
GLuint buffersToBlit[3] = { GL_COLOR_BUFFER_BIT, GL_STENCIL_BUFFER_BIT, GL_DEPTH_BUFFER_BIT };
glBindFramebuffer(GL_READ_FRAMEBUFFER, leftFramebufferAA);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, leftFramebuffer);
for(unsigned int i=0; i<sizeof(buffersToBlit)/sizeof(buffersToBlit[0]); i++)
glBlitFramebuffer(0, 0, recommendTexSizeL.w,
recommendTexSizeL.h, 0, 0, recommendTexSizeL.w,
recommendTexSizeL.h, buffersToBlit[i], GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER, rightFramebufferAA);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, rightFramebuffer);
for(unsigned int i=0; i<sizeof(buffersToBlit)/sizeof(buffersToBlit[0]); i++)
glBlitFramebuffer(0, 0, recommendTexSizeL.w,
recommendTexSizeL.h, 0, 0, recommendTexSizeL.w,
recommendTexSizeL.h, buffersToBlit[i], GL_NEAREST);
kuhl_errorcheck();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if(hmd)
ovrHmd_EndFrame(hmd, pose, &EyeTexture[0].Texture);
#endif
}
else if(viewmat_display_mode == VIEWMAT_ANAGLYPH)
{
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
/* Need to swap front and back buffers here unless we are using
* Oculus. (Oculus draws to the screen directly). */
if(viewmat_display_mode != VIEWMAT_OCULUS)
glutSwapBuffers();
viewmat_validate_fps();
}
/* Called by GLUT whenever the window needs to be redrawn. This
* function should not be called directly by the programmer. Instead,
* we can call glutPostRedisplay() to request that GLUT call display()
* at some point. */
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right.) */
viewmat_begin_frame();
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
viewmat_begin_eye(viewportID);
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Clear the current viewport. Without glScissor(), glClear()
* clears the entire screen. We could call glClear() before
* this viewport loop---but on order for all variations of
* this code to work (Oculus support, etc), we can only draw
* after viewmat_begin_eye(). */
glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
glEnable(GL_SCISSOR_TEST);
glClearColor(.2,.2,.2,0); // set clear color to grey
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16], perspective[16];
viewmat_get(viewMat, perspective, viewportID);
/* Calculate an angle to rotate the
* object. glutGet(GLUT_ELAPSED_TIME) is the number of
* milliseconds since glutInit() was called. */
int count = glutGet(GLUT_ELAPSED_TIME) % 10000; // get a counter that repeats every 10 seconds
float angle = count / 10000.0 * 360; // rotate 360 degrees every 10 seconds
/* Make sure all computers/processes use the same angle */
dgr_setget("angle", &angle, sizeof(GLfloat));
/* Create a 4x4 rotation matrix based on the angle we computed. */
float rotateMat[16];
mat4f_rotateAxis_new(rotateMat, angle, 0,1,0);
/* Create a scale matrix. */
float scaleMatrix[16];
mat4f_scale_new(scaleMatrix, 3, 3, 3);
// Modelview = (viewMatrix * scaleMatrix) * rotationMatrix
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, scaleMatrix);
mat4f_mult_mat4f_new(modelview, modelview, rotateMat);
kuhl_errorcheck();
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
kuhl_errorcheck();
/* Draw the geometry using the matrices that we sent to the
* vertex programs immediately above. Use the stencil buffer
* to keep track of which object appears on top. */
if(viewportID == 0)
glEnable(GL_STENCIL_TEST);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, -1);
kuhl_geometry_draw(&triangle);
glStencilFunc(GL_ALWAYS, 2, -1);
kuhl_geometry_draw(&quad);
glDisable(GL_STENCIL_TEST);
/* If we have multiple viewports, only draw cursor in the
* first viewport. */
if(viewportID == 0)
{
/* Draw the cursor in normalized device coordinates. Don't
* use any matrices. */
float identity[16];
mat4f_identity(identity);
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, 0, identity);
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, 0, identity);
/* Disable depth testing so the cursor isn't occluded by
* anything. */
glDisable(GL_DEPTH_TEST);
kuhl_geometry_draw(&cursor);
glEnable(GL_DEPTH_TEST);
/* When we render images on the Oculus, we are rendering
* into a multisampled framebuffer object, and we can't
* read from the multisample FBO until we have blitted it
* into a normal FBO. Here, we get the blitted FBO for the
* *previous* frame. */
GLint fb =viewmat_get_blitted_framebuffer(viewportID);
glBindFramebuffer(GL_FRAMEBUFFER, fb);
GLuint stencilVal = 0;
kuhl_errorcheck();
glReadPixels(viewport[0]+viewport[2]/2, viewport[1]+viewport[3]/2,
1,1, // get data for 1x1 area (i.e., a pixel)
GL_STENCIL_INDEX, // query the stencil buffer
GL_UNSIGNED_INT,
&stencilVal);
kuhl_errorcheck();
if(stencilVal == 1)
printf("Cursor is on triangle.\n");
else if(stencilVal == 2)
printf("Cursor is on quad.\n");
else
printf("Cursor isn't on anything.\n");
}
glUseProgram(0); // stop using a GLSL program.
} // finish viewport loop
viewmat_end_frame();
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
int main(int argc, char** argv)
{
/* Initialize GLUT and GLEW */
kuhl_ogl_init(&argc, argv, 512, 512, 32,
GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE, 4);
if(argc != 2 && argc != 3 && argc != 7 && argc != 13)
{
printf("Usage for cylindrical panoramas:\n");
printf(" %s panoImage.jpg\n", argv[0]);
printf(" %s left.jpg right.jpg\n", argv[0]);
printf("\n");
printf("Usage for cubemap panoramas:\n");
printf(" %s front.jpg back.jpg left.jpg right.jpg down.jpg up.jpg\n", argv[0]);
printf(" %s Lfront.jpg Lback.jpg Lleft.jpg Lright.jpg Ldown.jpg Lup.jpg Rfront.jpg Rback.jpg Rleft.jpg Rright.jpg Rdown.jpg Rup.jpg\n", argv[0]);
printf("\n");
printf("Tip: Works best if horizon is at center of the panorama.\n");
exit(EXIT_FAILURE);
}
// setup callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
/* Compile and link a GLSL program composed of a vertex shader and
* a fragment shader. */
program = kuhl_create_program("texture.vert", "texture.frag");
glUseProgram(program);
kuhl_errorcheck();
init_geometryQuad(&quad, program);
init_geometryCylinder(&cylinder, program);
if(argc == 2)
{
msg(INFO, "Cylinder mono image: %s\n", argv[1]);
kuhl_read_texture_file(argv[1], &texIdLeft);
texIdRight = texIdLeft;
}
if(argc == 3)
{
msg(INFO, "Cylinder left image: %s\n", argv[1]);
kuhl_read_texture_file(argv[1], &texIdLeft);
msg(INFO, "Cylinder right image: %s\n", argv[2]);
kuhl_read_texture_file(argv[2], &texIdRight);
}
char *cubemapNames[] = { "front", "back", "left", "right", "down", "up" };
if(argc == 7)
{
for(int i=0; i<6; i++)
{
msg(INFO, "Cubemap image (%-5s): %s\n", cubemapNames[i], argv[i+1]);
kuhl_read_texture_file(argv[i+1], &(cubemapLeftTex[i]));
cubemapRightTex[i]= cubemapLeftTex[i];
texIdLeft =0;
texIdRight=0;
}
}
if(argc == 13)
{
for(int i=0; i<6; i++)
{
msg(INFO, "Cubemap image (left, %-5s): %s\n", cubemapNames[i], argv[i+6+1]);
kuhl_read_texture_file(argv[i+6+1], &(cubemapLeftTex[i]));
msg(INFO, "Cubemap image (right, %-5s)\n", cubemapNames[i], argv[i+6+1]);
cubemapRightTex[i]= cubemapLeftTex[i];
texIdLeft =0;
texIdRight=0;
}
}
/* Good practice: Unbind objects until we really need them. */
glUseProgram(0);
dgr_init(); /* Initialize DGR based on environment variables. */
projmat_init(); /* Figure out which projection matrix we should use based on environment variables */
float initCamPos[3] = {0,0,0}; // location of camera
float initCamLook[3] = {0,0,-1}; // a point the camera is facing at
float initCamUp[3] = {0,1,0}; // a vector indicating which direction is up
viewmat_init(initCamPos, initCamLook, initCamUp);
/* Tell GLUT to start running the main loop and to call display(),
* keyboard(), etc callback methods as needed. */
glutMainLoop();
/* // An alternative approach:
while(1)
glutMainLoopEvent();
*/
exit(EXIT_SUCCESS);
}
/* Called by GLUT whenever the window needs to be redrawn. This
* function should not be called directly by the programmer. Instead,
* we can call glutPostRedisplay() to request that GLUT call display()
* at some point. */
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
dgr_setget("style", &renderStyle, sizeof(int));
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
viewmat_begin_frame();
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
viewmat_begin_eye(viewportID);
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Clear the current viewport. Without glScissor(), glClear()
* clears the entire screen. We could call glClear() before
* this viewport loop---but on order for all variations of
* this code to work (Oculus support, etc), we can only draw
* after viewmat_begin_eye(). */
glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
glEnable(GL_SCISSOR_TEST);
glClearColor(.2,.2,.2,0); // set clear color to grey
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Turn on blending (note, if you are using transparent textures,
the transparency may not look correct unless you draw further
items before closer items.). */
glEnable(GL_BLEND);
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16], perspective[16];
viewmat_get(viewMat, perspective, viewportID);
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
float modelMat[16];
get_model_matrix(modelMat);
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, modelMat); // modelview = view * model
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
glUniform1i(kuhl_get_uniform("renderStyle"), renderStyle);
// Copy far plane value into vertex program so we can render depth buffer.
float f[6]; // left, right, bottom, top, near>0, far>0
projmat_get_frustum(f, viewport[2], viewport[3]);
glUniform1f(kuhl_get_uniform("farPlane"), f[5]);
kuhl_errorcheck();
kuhl_limitfps(60);
update();
kuhl_geometry_draw(modelgeom); /* Draw the model */
kuhl_errorcheck();
glUseProgram(0); // stop using a GLSL program.
} // finish viewport loop
viewmat_end_frame();
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
// kuhl_video_record("videoout", 30);
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
int main(int argc, char** argv)
{
/* set up our GLUT window */
glutInit(&argc, argv);
glutInitWindowSize(512, 512);
/* Ask GLUT to for a double buffered, full color window that
* includes a depth buffer */
#ifdef __APPLE__
glutInitDisplayMode(GLUT_3_2_CORE_PROFILE | GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
#else
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitContextVersion(3,2);
glutInitContextProfile(GLUT_CORE_PROFILE);
#endif
glutCreateWindow(argv[0]); // set window title to executable name
/* Initialize GLEW */
glewExperimental = GL_TRUE;
GLenum glewError = glewInit();
if(glewError != GLEW_OK)
{
fprintf(stderr, "Error initializing GLEW: %s\n", glewGetErrorString(glewError));
exit(EXIT_FAILURE);
}
/* When experimental features are turned on in GLEW, the first
* call to glGetError() or kuhl_errorcheck() may incorrectly
* report an error. So, we call glGetError() to ensure that a
* later call to glGetError() will only see correct errors. For
* details, see:
* http://www.opengl.org/wiki/OpenGL_Loading_Library */
glGetError();
// setup callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
/* Compile and link a GLSL program composed of a vertex shader and
* a fragment shader. */
program = kuhl_create_program("ogl3-triangle.vert", "ogl3-triangle.frag");
glUseProgram(program);
kuhl_errorcheck();
/* Set the uniform variable in the shader that is named "red" to the value 1. */
glUniform1i(kuhl_get_uniform("red"), 1);
kuhl_errorcheck();
/* Good practice: Unbind objects until we really need them. */
glUseProgram(0);
/* Create kuhl_geometry structs for the objects that we want to
* draw. */
init_geometryTriangle(&triangle, program);
init_geometryQuad(&quad, program);
dgr_init(); /* Initialize DGR based on environment variables. */
projmat_init(); /* Figure out which projection matrix we should use based on environment variables */
float initCamPos[3] = {0,0,10}; // location of camera
float initCamLook[3] = {0,0,0}; // a point the camera is facing at
float initCamUp[3] = {0,1,0}; // a vector indicating which direction is up
viewmat_init(initCamPos, initCamLook, initCamUp);
/* Tell GLUT to start running the main loop and to call display(),
* keyboard(), etc callback methods as needed. */
glutMainLoop();
/* // An alternative approach:
while(1)
glutMainLoopEvent();
*/
exit(EXIT_SUCCESS);
}
/* Called by GLUT whenever the window needs to be redrawn. This
* function should not be called directly by the programmer. Instead,
* we can call glutPostRedisplay() to request that GLUT call display()
* at some point. */
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
viewmat_begin_frame();
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
viewmat_begin_eye(viewportID);
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Clear the current viewport. Without glScissor(), glClear()
* clears the entire screen. We could call glClear() before
* this viewport loop---but on order for all variations of
* this code to work (Oculus support, etc), we can only draw
* after viewmat_begin_eye(). */
glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
glEnable(GL_SCISSOR_TEST);
glClearColor(.2,.2,.2,0); // set clear color to grey
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16], perspective[16];
viewmat_get(viewMat, perspective, viewportID);
/* Calculate an angle to rotate the
* object. glutGet(GLUT_ELAPSED_TIME) is the number of
* milliseconds since glutInit() was called. */
int count = glutGet(GLUT_ELAPSED_TIME) % 10000; // get a counter that repeats every 10 seconds
float angle = count / 10000.0 * 360; // rotate 360 degrees every 10 seconds
/* Make sure all computers/processes use the same angle */
dgr_setget("angle", &angle, sizeof(GLfloat));
/* Create a 4x4 rotation matrix based on the angle we computed. */
float rotateMat[16];
mat4f_rotateAxis_new(rotateMat, angle, 0,1,0);
/* Create a scale matrix. */
float scaleMatrix[16];
mat4f_scale_new(scaleMatrix, 3, 3, 3);
// Modelview = (viewMatrix * scaleMatrix) * rotationMatrix
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, scaleMatrix);
mat4f_mult_mat4f_new(modelview, modelview, rotateMat);
kuhl_errorcheck();
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
kuhl_errorcheck();
/* Setup prerender directly to texture once (and reuse the
* framebuffer object for subsequent draw commands). */
if(prerenderFrameBuffer == 0)
{
#if USE_MSAA==1
/* Generate a MSAA framebuffer + texture */
GLuint prerenderTexIDAA;
prerenderFrameBufferAA = kuhl_gen_framebuffer_msaa(viewport[2], viewport[3],
&prerenderTexIDAA,
NULL, 16);
#endif
prerenderFrameBuffer = kuhl_gen_framebuffer(viewport[2], viewport[3],
&prerenderTexID,
NULL);
/* Apply the texture to our geometry and draw the quad. */
kuhl_geometry_texture(&prerendQuad, prerenderTexID, "tex", 1);
}
/* Switch to framebuffer and set the OpenGL viewport to cover
* the entire framebuffer. */
#if USE_MSAA==1
glBindFramebuffer(GL_FRAMEBUFFER, prerenderFrameBufferAA);
#else
glBindFramebuffer(GL_FRAMEBUFFER, prerenderFrameBuffer);
#endif
glViewport(0,0,viewport[2], viewport[3]);
kuhl_errorcheck();
/* Clear the framebuffer and the depth buffer. */
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
/* Draw the geometry using the matrices that we sent to the
* vertex programs immediately above */
kuhl_geometry_draw(&triangle);
kuhl_geometry_draw(&quad);
/* Stop rendering to texture */
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glUseProgram(0);
kuhl_errorcheck();
#if USE_MSAA==1
/* Copy the MSAA framebuffer into the normal framebuffer */
glBindFramebuffer(GL_READ_FRAMEBUFFER, prerenderFrameBufferAA);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, prerenderFrameBuffer);
glBlitFramebuffer(0,0,viewport[2],viewport[3],
0,0,viewport[2],viewport[3],
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER,0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER,0);
kuhl_errorcheck();
#endif
/* Set up the viewport to draw on the screen */
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
kuhl_geometry_draw(&prerendQuad);
} // finish viewport loop
viewmat_end_frame();
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
/** Called by GLUT whenever the window needs to be redrawn. This
* function should not be called directly by the programmer. Instead,
* we can call glutPostRedisplay() to request that GLUT call display()
* at some point. */
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
/* Get current frames per second calculations. */
float fps = kuhl_getfps(&fps_state);
if(dgr_is_enabled() == 0 || dgr_is_master())
{
// If DGR is being used, only display dgr counter if we are
// the master process.
// Check if FPS value was just updated by kuhl_getfps()
if(fps_state.frame == 0)
msg(INFO, "FPS: %0.1f", fps);
}
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
viewmat_begin_frame();
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
viewmat_begin_eye(viewportID);
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Clear the current viewport. Without glScissor(), glClear()
* clears the entire screen. We could call glClear() before
* this viewport loop---but on order for all variations of
* this code to work (Oculus support, etc), we can only draw
* after viewmat_begin_eye(). */
glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
glEnable(GL_SCISSOR_TEST);
glClearColor(.2,.2,.2,0); // set clear color to grey
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Turn on blending (note, if you are using transparent textures,
the transparency may not look correct unless you draw further
items before closer items.). */
glEnable(GL_BLEND);
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16], perspective[16];
viewmat_get(viewMat, perspective, viewportID);
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
for(int i=1; i<global_argc; i++)
drawObject(i, viewMat);
glUseProgram(0); // stop using a GLSL program.
} // finish viewport loop
viewmat_end_frame();
/* Update the model for the next frame based on the time. We
* convert the time to seconds and then use mod to cause the
* animation to repeat. */
int time = glutGet(GLUT_ELAPSED_TIME);
dgr_setget("time", &time, sizeof(int));
kuhl_update_model(modelgeom, 0, ((time%10000)/1000.0));
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
//kuhl_video_record("videoout", 30);
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
/* Called by GLUT whenever the window needs to be redrawn. This
* function should not be called directly by the programmer. Instead,
* we can call glutPostRedisplay() to request that GLUT call display()
* at some point. */
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
viewmat_begin_frame();
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
viewmat_begin_eye(viewportID);
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Clear the current viewport. Without glScissor(), glClear()
* clears the entire screen. We could call glClear() before
* this viewport loop---but on order for all variations of
* this code to work (Oculus support, etc), we can only draw
* after viewmat_begin_eye(). */
glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
glEnable(GL_SCISSOR_TEST);
glClearColor(.2,.2,.2,0); // set clear color to grey
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Turn on blending (note, if you are using transparent textures,
the transparency may not look correct unless you draw further
items before closer items. This program always draws the
geometry in the same order.). */
glEnable(GL_BLEND);
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16], perspective[16];
viewmat_get(viewMat, perspective, viewportID);
/* Calculate an angle to rotate the
* object. glutGet(GLUT_ELAPSED_TIME) is the number of
* milliseconds since glutInit() was called. */
int count = glutGet(GLUT_ELAPSED_TIME) % 10000; // get a counter that repeats every 10 seconds
float angle = count / 10000.0 * 360; // rotate 360 degrees every 10 seconds
/* Make sure all computers/processes use the same angle */
dgr_setget("angle", &angle, sizeof(GLfloat));
/* Create a 4x4 rotation matrix based on the angle we computed. */
float rotateMat[16];
mat4f_rotateAxis_new(rotateMat, angle, 0,1,0);
/* Create a scale matrix. */
float scaleMatrix[16];
mat4f_scale_new(scaleMatrix, 3, 3, 3);
// Modelview = (viewMatrix * scaleMatrix) * rotationMatrix
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, scaleMatrix);
mat4f_mult_mat4f_new(modelview, modelview, rotateMat);
kuhl_errorcheck();
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
kuhl_errorcheck();
/* Draw the geometry using the matrices that we sent to the
* vertex programs immediately above */
kuhl_geometry_draw(&triangle);
} // finish viewport loop
viewmat_end_frame();
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
/** Initializes the vertex array object (VAO), vertex buffer object (VBO) and texture
associated with this font_info and initializes other variables inside of the struct.
@param info A font_info struct populated with the information necessary to draw text.
@param program A GLSL program to be used when rendering this font.
@param fontFile The file path to the TTF file you wish to load.
@param pointSize The point size of the font.
@param pixelsPerPoint The number of screen pixels per glyph pixel (2 is usually good).
@return ok Returns 1 if there were no problems, 0 if something went wrong (i.e. bad
shader program, invalid font file, etc.).
*/
int font_info_new(font_info* info, const GLuint program, const char* fontFile, const unsigned int pointSize, const unsigned int pixelsPerPoint)
{
#ifndef KUHL_UTIL_USE_FREETYPE
return 0;
#else
// Set up the shader program
glUseProgram(program);
kuhl_errorcheck();
// Make sure it's got the right variables
info->uniform_tex = kuhl_get_uniform("tex");
kuhl_errorcheck();
if (info->uniform_tex < 0) {
fprintf(stderr, "Could not bind texture uniform\n");
return 0;
}
info->attribute_coord = kuhl_get_attribute(program, "coord");
kuhl_errorcheck();
if (info->attribute_coord < 0) {
fprintf(stderr, "Could not bind coord attribute\n");
return 0;
}
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &info->tex);
glBindTexture(GL_TEXTURE_2D, info->tex);
glUniform1i(info->uniform_tex, 0);
kuhl_errorcheck();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenVertexArrays(1, &info->vao);
kuhl_errorcheck();
glBindVertexArray(info->vao);
kuhl_errorcheck();
glGenBuffers(1, &info->vbo);
kuhl_errorcheck();
glEnableVertexAttribArray(info->attribute_coord);
kuhl_errorcheck();
glBindBuffer(GL_ARRAY_BUFFER, info->vbo);
kuhl_errorcheck();
glVertexAttribPointer(info->attribute_coord, 4, GL_FLOAT, GL_FALSE, 0, 0);
kuhl_errorcheck();
FT_Face face;
if (!font_load(&face, fontFile, pointSize))
return 0;
info->face = face;
info->program = program;
info->pointSize = pointSize;
info->pixelsPerPoint = pixelsPerPoint;
return 1;
#endif
}
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
/* Get current frames per second calculations. */
float fps = kuhl_getfps(&fps_state);
if(dgr_is_enabled() == 0 || dgr_is_master())
{
// If DGR is being used, only display dgr counter if we are
// the master process.
// Check if FPS value was just updated by kuhl_getfps()
if(fps_state.frame == 0)
{
char label[1024];
snprintf(label, 1024, "FPS: %0.1f", fps);
/* Delete old label if it exists */
if(fpsLabel != 0)
glDeleteTextures(1, &fpsLabel);
/* Make a new label */
float labelColor[3] = { 1,1,1 };
float labelBg[4] = { 0,0,0,.3 };
/* Change the last parameter (point size) to adjust the
* size of the texture that the text is rendered in to. */
fpsLabelAspectRatio = kuhl_make_label(label,
&fpsLabel,
labelColor, labelBg, 24);
if(fpsLabel != 0)
kuhl_geometry_texture(&labelQuad, fpsLabel, "tex", 1);
}
}
/* Ensure the slaves use the same render style as the master
* process. */
dgr_setget("style", &renderStyle, sizeof(int));
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
viewmat_begin_frame();
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
viewmat_begin_eye(viewportID);
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Clear the current viewport. Without glScissor(), glClear()
* clears the entire screen. We could call glClear() before
* this viewport loop---but on order for all variations of
* this code to work (Oculus support, etc), we can only draw
* after viewmat_begin_eye(). */
glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
glEnable(GL_SCISSOR_TEST);
glClearColor(.2,.2,.2,0); // set clear color to grey
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Turn on blending (note, if you are using transparent textures,
the transparency may not look correct unless you draw further
items before closer items.). */
glEnable(GL_BLEND);
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16], perspective[16];
viewmat_get(viewMat, perspective, viewportID);
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
float modelMat[16];
get_model_matrix(modelMat);
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, modelMat); // modelview = view * model
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
glUniform1i(kuhl_get_uniform("renderStyle"), renderStyle);
// Copy far plane value into vertex program so we can render depth buffer.
float f[6]; // left, right, bottom, top, near>0, far>0
projmat_get_frustum(f, viewport[2], viewport[3]);
glUniform1f(kuhl_get_uniform("farPlane"), f[5]);
kuhl_errorcheck();
kuhl_geometry_draw(modelgeom); /* Draw the model */
kuhl_errorcheck();
if(showOrigin)
{
/* Save current line width */
GLfloat origLineWidth;
glGetFloatv(GL_LINE_WIDTH, &origLineWidth);
glLineWidth(4); // make lines thick
/* Object coordinate system origin */
kuhl_geometry_draw(origingeom); /* Draw the origin marker */
/* World coordinate origin */
mat4f_copy(modelview, viewMat);
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
kuhl_geometry_draw(origingeom); /* Draw the origin marker */
/* Restore line width */
glLineWidth(origLineWidth);
}
if(dgr_is_enabled() == 0 || dgr_is_master())
{
/* The shape of the frames per second quad depends on the
* aspect ratio of the label texture and the aspect ratio of
* the window (because we are placing the quad in normalized
* device coordinates). */
int windowWidth, windowHeight;
viewmat_window_size(&windowWidth, &windowHeight);
float windowAspect = windowWidth / (float)windowHeight;
float stretchLabel[16];
mat4f_scale_new(stretchLabel, 1/8.0 * fpsLabelAspectRatio / windowAspect, 1/8.0, 1);
/* Position label in the upper left corner of the screen */
float transLabel[16];
mat4f_translate_new(transLabel, -.9, .8, 0);
mat4f_mult_mat4f_new(modelview, transLabel, stretchLabel);
glUniformMatrix4fv(kuhl_get_uniform("ModelView"), 1, 0, modelview);
/* Make sure we don't use a projection matrix */
float identity[16];
mat4f_identity(identity);
glUniformMatrix4fv(kuhl_get_uniform("Projection"), 1, 0, identity);
/* Don't use depth testing and make sure we use the texture
* rendering style */
glDisable(GL_DEPTH_TEST);
glUniform1i(kuhl_get_uniform("renderStyle"), 1);
kuhl_geometry_draw(&labelQuad); /* Draw the quad */
glEnable(GL_DEPTH_TEST);
kuhl_errorcheck();
}
glUseProgram(0); // stop using a GLSL program.
} // finish viewport loop
viewmat_end_frame();
/* Update the model for the next frame based on the time. We
* convert the time to seconds and then use mod to cause the
* animation to repeat. */
int time = glutGet(GLUT_ELAPSED_TIME);
dgr_setget("time", &time, sizeof(int));
kuhl_update_model(modelgeom, 0, ((time%10000)/1000.0));
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
//kuhl_video_record("videoout", 30);
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
void display()
{
dgr_update();
dgr_setget("style", &renderStyle, sizeof(int));
// Clear the screen to black, clear the depth buffer
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Turn on blending (note, if you are using transparent textures,
the transparency may not look correct unless you draw further
items before closer items.). */
glEnable(GL_BLEND);
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Get the frustum information which will be later used to generate a perspective projection matrix. */
float f[6]; // left, right, top, bottom, near>0, far>0
projmat_get_frustum(f, viewport[2], viewport[3]);
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16];
viewmat_get(viewMat, f, viewportID);
glUseProgram(program);
/* Communicate matricies to OpenGL */
float perspective[16];
mat4f_frustum_new(perspective,f[0], f[1], f[2], f[3], f[4], f[5]);
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // count
0, // transpose
perspective); // value
float modelMat[16];
get_model_matrix(modelMat);
// modelview = view * model
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, modelMat);
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // count
0, // transpose
modelview); // value
glUniform1i(kuhl_get_uniform("renderStyle"), renderStyle);
// Copy far plane value into vertex program so we can render depth buffer.
glUniform1f(kuhl_get_uniform("farPlane"), f[5]);
kuhl_errorcheck();
kuhl_draw_model_file_ogl3(modelFilename, modelTexturePath, program);
kuhl_errorcheck();
glUseProgram(0); // stop using a GLSL program.
} // finish viewport loop
int time = glutGet(GLUT_ELAPSED_TIME);
float fps = kuhl_getfps(time);
if(time % 1000 == 0)
printf("Frames per second: %0.1f\n", fps);
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
glFlush();
glFinish();
/* Display the buffer we just drew (necessary for double buffering). */
glutSwapBuffers();
// kuhl_video_record("videoout", 30);
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
/* Called by GLUT whenever a key is pressed. */
void keyboard(unsigned char key, int x, int y)
{
switch(key)
{
case 'q':
case 'Q':
case 27: // ASCII code for Escape key
dgr_exit();
exit(EXIT_SUCCESS);
break;
case 'f': // full screen
glutFullScreen();
break;
case 'F': // switch to window from full screen mode
glutPositionWindow(0,0);
break;
case 'r':
{
// Reload GLSL program from disk
kuhl_delete_program(program);
program = kuhl_create_program(GLSL_VERT_FILE, GLSL_FRAG_FILE);
/* Apply the program to the model geometry */
kuhl_geometry_program(modelgeom, program, KG_FULL_LIST);
/* and the fps label*/
kuhl_geometry_program(&labelQuad, program, KG_FULL_LIST);
break;
}
case 'w':
{
// Toggle between wireframe and solid
int polygonMode;
glGetIntegerv(GL_POLYGON_MODE, &polygonMode);
if(polygonMode == GL_LINE)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
break;
}
case 'p':
{
// Toggle between points and solid
int polygonMode;
glGetIntegerv(GL_POLYGON_MODE, &polygonMode);
if(polygonMode == GL_POINT)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
break;
}
case 'c':
{
// Toggle front, back, and no culling
int cullMode;
glGetIntegerv(GL_CULL_FACE_MODE, &cullMode);
if(glIsEnabled(GL_CULL_FACE))
{
if(cullMode == GL_FRONT)
{
glCullFace(GL_BACK);
printf("Culling: Culling back faces; drawing front faces\n");
}
else
{
glDisable(GL_CULL_FACE);
printf("Culling: No culling; drawing all faces.\n");
}
}
else
{
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
printf("Culling: Culling front faces; drawing back faces\n");
}
kuhl_errorcheck();
break;
}
case '+': // increase size of points and width of lines
{
GLfloat currentPtSize;
GLfloat sizeRange[2];
glGetFloatv(GL_POINT_SIZE, ¤tPtSize);
glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, sizeRange);
GLfloat temp = currentPtSize+1;
if(temp > sizeRange[1])
temp = sizeRange[1];
glPointSize(temp);
printf("Point size is %f (can be between %f and %f)\n", temp, sizeRange[0], sizeRange[1]);
kuhl_errorcheck();
GLfloat currentLineWidth;
GLfloat widthRange[2];
glGetFloatv(GL_LINE_WIDTH, ¤tLineWidth);
glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, widthRange);
temp = currentLineWidth+1;
if(temp > widthRange[1])
temp = widthRange[1];
glLineWidth(temp);
printf("Line width is %f (can be between %f and %f)\n", temp, widthRange[0], widthRange[1]);
kuhl_errorcheck();
break;
}
case '-': // decrease size of points and width of lines
{
GLfloat currentPtSize;
GLfloat sizeRange[2];
glGetFloatv(GL_POINT_SIZE, ¤tPtSize);
glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, sizeRange);
GLfloat temp = currentPtSize-1;
if(temp < sizeRange[0])
temp = sizeRange[0];
glPointSize(temp);
printf("Point size is %f (can be between %f and %f)\n", temp, sizeRange[0], sizeRange[1]);
kuhl_errorcheck();
GLfloat currentLineWidth;
GLfloat widthRange[2];
glGetFloatv(GL_LINE_WIDTH, ¤tLineWidth);
glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, widthRange);
temp = currentLineWidth-1;
if(temp < widthRange[0])
temp = widthRange[0];
glLineWidth(temp);
printf("Line width is %f (can be between %f and %f)\n", temp, widthRange[0], widthRange[1]);
kuhl_errorcheck();
break;
}
case ' ': // Toggle different sections of the GLSL fragment shader
renderStyle++;
if(renderStyle > 9)
renderStyle = 0;
switch(renderStyle)
{
case 0: printf("Render style: Diffuse (headlamp light)\n"); break;
case 1: printf("Render style: Texture (color is used on non-textured geometry)\n"); break;
case 2: printf("Render style: Texture+diffuse (color is used on non-textured geometry)\n"); break;
case 3: printf("Render style: Vertex color\n"); break;
case 4: printf("Render style: Vertex color + diffuse (headlamp light)\n"); break;
case 5: printf("Render style: Normals\n"); break;
case 6: printf("Render style: Texture coordinates\n"); break;
case 7: printf("Render style: Front (green) and back (red) faces based on winding\n"); break;
case 8: printf("Render style: Front (green) and back (red) based on normals\n"); break;
case 9: printf("Render style: Depth (white=far; black=close)\n"); break;
}
break;
}
/* Whenever any key is pressed, request that display() get
* called. */
glutPostRedisplay();
}
/* Called by GLUT whenever the window needs to be redrawn. This
* function should not be called directly by the programmer. Instead,
* we can call glutPostRedisplay() to request that GLUT call display()
* at some point. */
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
viewmat_begin_frame();
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
viewmat_begin_eye(viewportID);
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Clear the current viewport. Without glScissor(), glClear()
* clears the entire screen. We could call glClear() before
* this viewport loop---but on order for all variations of
* this code to work (Oculus support, etc), we can only draw
* after viewmat_begin_eye(). */
glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
glEnable(GL_SCISSOR_TEST);
glClearColor(.2,.2,.2,0); // set clear color to grey
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Turn on blending (note, if you are using transparent textures,
the transparency may not look correct unless you draw further
items before closer items. This program always draws the
geometry in the same order.). */
glEnable(GL_BLEND);
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16], perspective[16];
viewmat_eye eye = viewmat_get(viewMat, perspective, viewportID);
/* Always put camera at origin (no translation, no
* interpupillary distance). */
float noTranslation[4] = {0,0,0,1};
mat4f_setColumn(viewMat, noTranslation, 3); // last column
/* Create a scale matrix. */
float scaleMatrix[16];
mat4f_scale_new(scaleMatrix, 20, 20, 20);
// Modelview = (viewMatrix * scaleMatrix) * rotationMatrix
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, scaleMatrix);
kuhl_errorcheck();
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
kuhl_errorcheck();
if(texIdLeft != 0 && texIdRight != 0) // cylinder
{
/* Draw the cylinder with the appropriate texture */
if(eye == VIEWMAT_EYE_RIGHT)
kuhl_geometry_texture(&cylinder, texIdRight, "tex", KG_WARN);
else
kuhl_geometry_texture(&cylinder, texIdLeft, "tex", KG_WARN);
kuhl_geometry_draw(&cylinder);
}
else // cubemap
{
if(eye == VIEWMAT_EYE_RIGHT)
setupCubemap(cubemapRightTex, quad, modelview);
else
setupCubemap(cubemapLeftTex, quad, modelview);
}
} // finish viewport loop
viewmat_end_frame();
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
static int fps_state_init = 0;
static kuhl_fps_state fps_state;
if(fps_state_init == 0)
{
kuhl_getfps_init(&fps_state);
fps_state_init = 1;
}
float fps = kuhl_getfps(&fps_state);
if(fps_state.frame == 0)
msg(INFO, "fps: %6.1f\n", fps);
}
/* Called by GLUT whenever the window needs to be redrawn. This
* function should not be called directly by the programmer. Instead,
* we can call glutPostRedisplay() to request that GLUT call display()
* at some point. */
void display()
{
/* If we are using DGR, send or receive data to keep multiple
* processes/computers synchronized. */
dgr_update();
glClearColor(.2,.2,.2,0); // set clear color to grey
// Clear the screen to black, clear the depth buffer
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST); // turn on depth testing
kuhl_errorcheck();
/* Render the scene once for each viewport. Frequently one
* viewport will fill the entire screen. However, this loop will
* run twice for HMDs (once for the left eye and once for the
* right. */
for(int viewportID=0; viewportID<viewmat_num_viewports(); viewportID++)
{
/* Where is the viewport that we are drawing onto and what is its size? */
int viewport[4]; // x,y of lower left corner, width, height
viewmat_get_viewport(viewport, viewportID);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
/* Get the frustum information which will be later used to generate a perspective projection matrix. */
float f[6]; // left, right, top, bottom, near>0, far>0
projmat_get_frustum(f, viewport[2], viewport[3]);
/* Get the view or camera matrix; update the frustum values if needed. */
float viewMat[16];
viewmat_get(viewMat, f, viewportID);
/* Create a 4x4 perspective projection matrix from the frustum values. */
float perspective[16];
mat4f_frustum_new(perspective,f[0], f[1], f[2], f[3], f[4], f[5]);
/* Calculate an angle to rotate the
* object. glutGet(GLUT_ELAPSED_TIME) is the number of
* milliseconds since glutInit() was called. */
int count = glutGet(GLUT_ELAPSED_TIME) % 10000; // get a counter that repeats every 10 seconds
float angle = count / 10000.0 * 360; // rotate 360 degrees every 10 seconds
/* Make sure all computers/processes use the same angle */
dgr_setget("angle", &angle, sizeof(GLfloat));
/* Create a 4x4 rotation matrix based on the angle we computed. */
float rotateMat[16];
mat4f_rotateAxis_new(rotateMat, angle, 0,1,0);
/* Create a scale matrix. */
float scaleMatrix[16];
mat4f_scale_new(scaleMatrix, 3, 3, 3);
// Modelview = (viewMatrix * scaleMatrix) * rotationMatrix
float modelview[16];
mat4f_mult_mat4f_new(modelview, viewMat, scaleMatrix);
mat4f_mult_mat4f_new(modelview, modelview, rotateMat);
kuhl_errorcheck();
glUseProgram(program);
kuhl_errorcheck();
/* Send the perspective projection matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("Projection"),
1, // number of 4x4 float matrices
0, // transpose
perspective); // value
/* Send the modelview matrix to the vertex program. */
glUniformMatrix4fv(kuhl_get_uniform("ModelView"),
1, // number of 4x4 float matrices
0, // transpose
modelview); // value
kuhl_errorcheck();
/* Draw the geometry using the matrices that we sent to the
* vertex programs immediately above */
kuhl_geometry_draw(&triangle);
kuhl_geometry_draw(&quad);
glUseProgram(0); // stop using a GLSL program.
} // finish viewport loop
/* Check for errors. If there are errors, consider adding more
* calls to kuhl_errorcheck() in your code. */
kuhl_errorcheck();
/* Display the buffer we just drew (necessary for double buffering). */
glutSwapBuffers();
/* Ask GLUT to call display() again. We shouldn't call display()
* ourselves recursively because it will not leave time for GLUT
* to call other callback functions for when a key is pressed, the
* window is resized, etc. */
glutPostRedisplay();
}
/* Called by GLUT whenever a key is pressed. */
void keyboard(unsigned char key, int x, int y)
{
switch(key)
{
case 'q':
case 'Q':
case 27: // ASCII code for Escape key
dgr_exit();
exit(EXIT_SUCCESS);
break;
case '+': // increase size of points and width of lines
{
GLfloat currentPtSize;
GLfloat sizeRange[2];
glGetFloatv(GL_POINT_SIZE, ¤tPtSize);
glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, sizeRange);
GLfloat temp = currentPtSize+1;
if(temp > sizeRange[1])
temp = sizeRange[1];
glPointSize(temp);
printf("Point size is %f (can be between %f and %f)\n", temp, sizeRange[0], sizeRange[1]);
kuhl_errorcheck();
GLfloat currentLineWidth;
GLfloat widthRange[2];
glGetFloatv(GL_LINE_WIDTH, ¤tLineWidth);
glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, widthRange);
temp = currentLineWidth+1;
if(temp > widthRange[1])
temp = widthRange[1];
glLineWidth(temp);
printf("Line width is %f (can be between %f and %f)\n", temp, widthRange[0], widthRange[1]);
kuhl_errorcheck();
break;
}
case '-': // decrease size of points and width of lines
{
GLfloat currentPtSize;
GLfloat sizeRange[2];
glGetFloatv(GL_POINT_SIZE, ¤tPtSize);
glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, sizeRange);
GLfloat temp = currentPtSize-1;
if(temp < sizeRange[0])
temp = sizeRange[0];
glPointSize(temp);
printf("Point size is %f (can be between %f and %f)\n", temp, sizeRange[0], sizeRange[1]);
kuhl_errorcheck();
GLfloat currentLineWidth;
GLfloat widthRange[2];
glGetFloatv(GL_LINE_WIDTH, ¤tLineWidth);
glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, widthRange);
temp = currentLineWidth-1;
if(temp < widthRange[0])
temp = widthRange[0];
glLineWidth(temp);
printf("Line width is %f (can be between %f and %f)\n", temp, widthRange[0], widthRange[1]);
kuhl_errorcheck();
break;
}
case 'x':
explode();
break;
case 'z':
update();
break;
case ' ': // Toggle different sections of the GLSL fragment shader
renderStyle++;
if(renderStyle > 9)
renderStyle = 0;
switch(renderStyle)
{
case 0: printf("Render style: Diffuse (headlamp light)\n"); break;
case 1: printf("Render style: Texture (color is used on non-textured geometry)\n"); break;
case 2: printf("Render style: Texture+diffuse (color is used on non-textured geometry)\n"); break;
case 3: printf("Render style: Vertex color\n"); break;
case 4: printf("Render style: Vertex color + diffuse (headlamp light)\n"); break;
case 5: printf("Render style: Normals\n"); break;
case 6: printf("Render style: Texture coordinates\n"); break;
case 7: printf("Render style: Front (green) and back (red) faces based on winding\n"); break;
case 8: printf("Render style: Front (green) and back (red) based on normals\n"); break;
case 9: printf("Render style: Depth (white=far; black=close)\n"); break;
}
break;
}
/* Whenever any key is pressed, request that display() get
* called. */
glutPostRedisplay();
}
