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);
}
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);
}
int main(int argc, char** argv)
{
char *modelFilename = NULL;
char *modelTexturePath = NULL;
int currentArgIndex = 1; // skip program name
int usageError = 0;
while(argc > currentArgIndex)
{
if(strcmp(argv[currentArgIndex], "--fit") == 0)
fitToView = 1;
else if(strcmp(argv[currentArgIndex], "--origin") == 0)
showOrigin = 1;
else if(modelFilename == NULL)
{
modelFilename = argv[currentArgIndex];
modelTexturePath = NULL;
}
else if(modelTexturePath == NULL)
modelTexturePath = argv[currentArgIndex];
else
{
usageError = 1;
}
currentArgIndex++;
}
// If we have no model to load or if there were too many arguments.
if(modelFilename == NULL || usageError)
{
printf("Usage:\n"
"%s [--fit] [--origin] modelFile - Textures are assumed to be in the same directory as the model.\n"
"- or -\n"
"%s [--fit] [--origin] modelFile texturePath\n"
"If the optional --fit parameter is included, the model will be scaled and translated to fit within the approximate view of the camera\n"
"If the optional --origin parameter is included, a box will is drawn at the origin and unit-length lines are drawn down each axis.\n",
argv[0], argv[0]);
exit(EXIT_FAILURE);
}
/* set up our GLUT window */
glutInit(&argc, argv);
glutInitWindowSize(512, 512);
glutSetOption(GLUT_MULTISAMPLE, 4); // set msaa samples; default to 4
/* 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 | GLUT_MULTISAMPLE);
#else
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE);
glutInitContextVersion(3,2);
glutInitContextProfile(GLUT_CORE_PROFILE);
#endif
glutCreateWindow(argv[0]); // set window title to executable name
glEnable(GL_MULTISAMPLE);
/* 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(GLSL_VERT_FILE, GLSL_FRAG_FILE);
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,1.55,2}; // 1.55m is a good approx eyeheight
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);
// Clear the screen while things might be loading
glClearColor(.2,.2,.2,1);
glClear(GL_COLOR_BUFFER_BIT);
// Load the model from the file
modelgeom = kuhl_load_model(modelFilename, modelTexturePath, program, bbox);
if(showOrigin)
origingeom = kuhl_load_model("../models/origin/origin.obj", NULL, program, NULL);
init_geometryQuad(&labelQuad, program);
kuhl_getfps_init(&fps_state);
/* 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);
}
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);
}
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 == 1)
{
msg(FATAL, "You didn't provide the name of the object(s) that you want to track.");
msg(FATAL, "Usage: %s vrpnObjectName1 vrpnObjectName2 ...");
exit(EXIT_FAILURE);
}
global_argc = argc;
global_argv = argv;
// 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(GLSL_VERT_FILE, GLSL_FRAG_FILE);
dgr_init(); /* Initialize DGR based on environment variables. */
projmat_init(); /* Figure out which projection matrix we should use based on environment variables */
viewmat_init(initCamPos, initCamLook, initCamUp);
// Clear the screen while things might be loading
glClearColor(.2,.2,.2,1);
glClear(GL_COLOR_BUFFER_BIT);
// Load the model from the file
//modelgeom = kuhl_load_model("../models/cube/cube.obj", NULL, program, NULL);
modelgeom = kuhl_load_model("../models/origin/origin.obj", NULL, program, NULL);
init_geometryQuad(&quad, program);
label = malloc(sizeof(GLuint)*argc-1);
labelAspectRatio = malloc(sizeof(float)*argc-1);
float labelColor[3] = { 1,1,1 };
float labelBg[4] = { 0,0,0,.3 };
for(int i=1; i<argc; i++)
{
labelAspectRatio[i-1] = kuhl_make_label(argv[i],
&(label[i-1]),
labelColor, labelBg, 24);
}
kuhl_getfps_init(&fps_state);
/* 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);
}
