void myInit(void)
{
glClearColor(0.0,0.0,0.0,0.0);
//------------------------------------------------------------Object & Texture
readFile("/Users/jiharu/svn/594CM/gl_obj/obj/triangular/Shatter1.obj");
loadTextures();
//DEFINE NIGTHS in some INIT function..
glEnable(GL_LIGHTING); //enable lighting
glShadeModel (GL_SMOOTH); //GL_SMOOTH, GL_FLAT
#pragma mark -
#pragma mark light
//------------------------------------------------------------Light
//define the lighting model
float ambient[] = {0.08, 0.08, 0.01, 1.0};
float diffuse[] = {0.7, 0.7, 0.0, 1.0};
float specular[] = {0.3, 0.3, 0.3, 1.0};
glEnable(GL_LIGHT0); //turn on one of the lights
// glDisable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
//------------------------------------------------------------Spot Light 1, 2, & 3
float spot_direction1[] = { 0.0, -1.0, 0.0 };
float ambient1[] = {0.01, .2, 0.5, 1.0};
float diffuse1[] = {0.01, 0.5, 0.5, 1.0};
float specular1[] = {0.0, 0.3, 1.0, 1.0};
glEnable(GL_LIGHT1); //turn on one of the lights
// glDisable(GL_LIGHT1);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient1);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse1);
glLightfv(GL_LIGHT1, GL_SPECULAR, specular1);
glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction1);
glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.5);
glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5);
glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.2);
glLightf (GL_LIGHT1, GL_SPOT_CUTOFF, 30.0); // degrees
glLightf (GL_LIGHT1, GL_SPOT_EXPONENT, 2.0);
float spot_direction2[] = { 0.0, -1.0, 0.0 };
float ambient2[] = {0.9, 0.1, 0.01, 1.0};
float diffuse2[] = {0.9, 0.5, 0.0, 1.0};
float specular2[] = {1.0, 0.1, 0.1, 1.0};
glEnable(GL_LIGHT2); //turn on one of the lights
// glDisable(GL_LIGHT2);
glLightfv(GL_LIGHT2, GL_AMBIENT, ambient2);
glLightfv(GL_LIGHT2, GL_DIFFUSE, diffuse2);
glLightfv(GL_LIGHT2, GL_SPECULAR, specular2);
glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, spot_direction2);
glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, 1.5);
glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, 0.8);
glLightf(GL_LIGHT2, GL_QUADRATIC_ATTENUATION, 0.2);
glLightf (GL_LIGHT2, GL_SPOT_CUTOFF, 45.0); // degrees
glLightf (GL_LIGHT2, GL_SPOT_EXPONENT, 1.0);
float spot_direction3[] = { .5, -1.0, 0.0 };
float ambient3[] = {0.5, 0.5, 0.5, 1.0};
float diffuse3[] = {1.0, 1.0, 1.0, 1.0};
float specular3[] = {1.0, 1.0, 1.0, 1.0};
glEnable(GL_LIGHT3); //turn on one of the lights
// glDisable(GL_LIGHT2);
glLightfv(GL_LIGHT3, GL_AMBIENT, ambient3);
glLightfv(GL_LIGHT3, GL_DIFFUSE, diffuse3);
glLightfv(GL_LIGHT3, GL_SPECULAR, specular3);
glLightfv(GL_LIGHT3, GL_SPOT_DIRECTION, spot_direction3);
glLightf(GL_LIGHT3, GL_CONSTANT_ATTENUATION, 0.5);
glLightf(GL_LIGHT3, GL_LINEAR_ATTENUATION, 0.8);
glLightf(GL_LIGHT3, GL_QUADRATIC_ATTENUATION, 0.2);
glLightf (GL_LIGHT3, GL_SPOT_CUTOFF, 45.0); // degrees
glLightf (GL_LIGHT3, GL_SPOT_EXPONENT, 2.0);
#pragma mark material
//------------------------------------------------------------material
//define the material of the object
float mat_shininess[] = { 50. };
float mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
float mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
float mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
float mat_emission[] = {1.0, 0.1, 0.1, 1.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearAccum(0.0, 0.0, 0.0, 0.0);
checkForGLErrors("clearInit");
}
int main(int argc, char **argv)
{
int i;
if (argc > 1) { /* make sure at least 2 args, program and file */
strncpy(filename, argv[argc - 1], sizeof(filename)); /* get the last arg as the file always */
for (i = 0; i < argc; i++) { /* check for startup params */
if (strstr(argv[i], "-s"))
stereo = 1;
}
}
else { /* user only entered program name, help them */
printf("Usage: %s [-s] <obj filename>\n", argv[0]);
exit(0);
}
glutInit(&argc, argv);
if (stereo)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH |
GLUT_STEREO);
else
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
if (game_mode) {
glutGameModeString("1024x768:32@75"); /* Select The 640x480 In 16bpp Mode */
if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
glutEnterGameMode(); /* Enter Full Screen */
else
game_mode = 0; /* Cannot Enter Game Mode, Switch To Windowed */
}
if (!game_mode) {
glutInitWindowSize(1024, 768); /* Window Size If We Start In Windowed Mode */
glutCreateWindow("Wavefront Obj File Viewer");
}
glutDisplayFunc(Display);
glutKeyboardFunc(Keyboard);
getMatrix();
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearAccum(0.0, 0.0, 0.0, 0.0);
glutReshapeFunc(Reshape);
glutMouseFunc(Mouse);
glutMotionFunc(Motion);
glutSpecialFunc(SpecialKeys); /* Register Special Keys Handler */
glutSpecialUpFunc(SpecialKeysUp); /* Called When A Special Key Released */
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_TEXTURE_2D);
#ifdef SMOOTH_HINT
if (smooth_hint) {
glEnable(GL_LINE_SMOOTH);
/* glEnable (GL_POLYGON_SMOOTH); */
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
/* glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST); */
}
#endif /* */
if (!pmodel) { /* load up the model */
pmodel = glmReadOBJ(filename);
if (!pmodel) {
printf("\nUsage: objviewV2 <-s> <obj filename>\n");
exit(0);
}
glmUnitize(pmodel);
glmVertexNormals(pmodel, 90.0, GL_TRUE);
}
glutMainLoop();
exit(0);
}
void initialise()
{
srand(time(NULL));
glEnable(GL_DEPTH_TEST);
glEnable(GL_VERTEX_ARRAY);
//glClearColor(0.0f, 1.0f, 1.0f, 1.0f);
// Set the accumulation buffer clearing colour to black at 0,0f alpha
glClearAccum(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_POINT_SMOOTH); // Smooth the points so that they're circular and not square
glPointSize(fw->particleSize);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Target Camera
cam1 = new target_camera();
cam1->setProjection(glm::degrees(glm::pi<float>() / 4.0f), screenWidth/screenHeight, 0.1f, 10000.0f);
cam1->setPositon(glm::vec3(10.f, 10.0f, 10.0f));
cam1->setTarget(glm::vec3(0.0f, 0.0f, 0.0f));
//fps cam
cam = new first_person_camera();
cam->setProjection(glm::pi<float>() / 4.0f, screenWidth/screenHeight, 0.1f, 10000.0f);
cam->setPositon(glm::vec3(2.0f, 0.0f, 2.0f));
if (!eff.addShader("lit_textured.vert", GL_VERTEX_SHADER))
exit(EXIT_FAILURE);
/*if (!eff.addShader("tarnished.vert", GL_VERTEX_SHADER))
exit(EXIT_FAILURE);*/
/*if (!eff.addShader("enviroment_map.vert", GL_VERTEX_SHADER))
exit(EXIT_FAILURE);*/
if (!eff.addShader("lighting.frag", GL_FRAGMENT_SHADER))
exit(EXIT_FAILURE);
if (!eff.addShader("point_light.frag", GL_FRAGMENT_SHADER))
exit(EXIT_FAILURE);
if (!eff.addShader("spot_light.frag", GL_FRAGMENT_SHADER))
exit(EXIT_FAILURE);
if (!eff.addShader("lit_textured.frag", GL_FRAGMENT_SHADER))
exit(EXIT_FAILURE);
/*if (!eff.addShader("tarnished.frag", GL_FRAGMENT_SHADER))
exit(EXIT_FAILURE);*/
/*if (!eff.addShader("enviroemtn_map.frag", GL_FRAGMENT_SHADER))
exit(EXIT_FAILURE);*/
if (!eff.create())
exit(EXIT_FAILURE);
scene = loadScene("scene.json");
std::vector<std::string> cubemap_texs;
/*cubemap_texs.push_back("xpos.png");
cubemap_texs.push_back("xneg.png");
cubemap_texs.push_back("ypos.png");
cubemap_texs.push_back("yneg.png");
cubemap_texs.push_back("zpos.png");
cubemap_texs.push_back("zneg.png");*/
cubemap_texs.push_back("posx.jpg");
cubemap_texs.push_back("negx.jpg");
cubemap_texs.push_back("posy.jpg");
cubemap_texs.push_back("negy.jpg");
cubemap_texs.push_back("posz.jpg");
cubemap_texs.push_back("negz.jpg");
cubemap* cm = new cubemap(cubemap_texs);
cm->create();
sb = new skybox(cm);
sb->create();
}
void myInit(void)
{
glDepthFunc(GL_LEQUAL);
//glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
//DEFINE NIGTHS in some INIT function..
glEnable(GL_LIGHTING); //enable lighting
glShadeModel (GL_SMOOTH); //GL_SMOOTH, GL_FLAT
//define the lighting model
float ambient[] = {0.08, 0.08, 0.01, 1.0};
float diffuse[] = {0.1, 0.1, 0.1, 1.0};
float specular[] = {0.3, 0.3, 0.3, 1.0};
float emission[] = {.01, .02, .02, 1.0};
glEnable(GL_LIGHT0); //turn on one of the lights
// glDisable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_EMISSION, emission);
//spot light 1
float spot_direction1[] = { 0.0, -1.0, 0.0 };
float ambient1[] = {0.01, .2, 0.2, 1.0};
float diffuse1[] = {0.01, 0.5, 0.5, 1.0};
float specular1[] = {.0, 0.3, .3, 1.0};
float emission1[] = {.0, 0.0, .1, 1.0};
glEnable(GL_LIGHT1); //turn on one of the lights
// glDisable(GL_LIGHT1);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient1);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse1);
glLightfv(GL_LIGHT1, GL_SPECULAR, specular1);
glLightfv(GL_LIGHT1, GL_EMISSION, emission1);
glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction1);
glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.5);
glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5);
glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.2);
glLightf (GL_LIGHT1, GL_SPOT_CUTOFF, 30.0); // degrees
glLightf (GL_LIGHT1, GL_SPOT_EXPONENT, 2.0);
//spot light 2
float spot_direction2[] = { 0.0, -1.0, 0.0 };
float ambient2[] = {0.3, 0.0, 0.01, 1.0};
float diffuse2[] = {0.5, 0.0, 0.01, 1.0};
float specular2[] = {3.0, 0.0, 0.0, 1.0};
float emission2[] = {.1, 0.0, 0.0, 1.0};
glEnable(GL_LIGHT2); //turn on one of the lights
// glDisable(GL_LIGHT2);
glLightfv(GL_LIGHT2, GL_AMBIENT, ambient2);
glLightfv(GL_LIGHT2, GL_DIFFUSE, diffuse2);
glLightfv(GL_LIGHT2, GL_SPECULAR, specular2);
glLightfv(GL_LIGHT2, GL_EMISSION, emission2);
glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, spot_direction2);
glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, 1.5);
glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, 0.5);
glLightf(GL_LIGHT2, GL_QUADRATIC_ATTENUATION, 0.2);
glLightf (GL_LIGHT2, GL_SPOT_CUTOFF, 30.0); // degrees
glLightf (GL_LIGHT2, GL_SPOT_EXPONENT, 2.0);
//define the material of the object
float mat_shininess[] = { 50. };
float mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
float mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
float mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
float mat_emission[] = {1.0, 0.1, 0.1, 0.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearAccum(0.0, 0.0, 0.0, 0.0);
}
M(void, glClearAccum, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
glClearAccum(red, green, blue, alpha);
}
void Cre8Render::InitializeLambdas()
{
// Here we provide the fetch methods for these variables. We will only need to fetch the values if they're requested.
MultiTexturingSupported.SetMethod( [](c8bool& out) { out = GLEW_ARB_multitexture;});
VersionMinor.SetMethod( [](si32& out) { glGetIntegerv(GL_MINOR_VERSION, &out); });
VersionMajor.SetMethod( [](si32& out) { glGetIntegerv(GL_MAJOR_VERSION, &out); });
MaxTextureUnits.SetMethod( [](si32& out) { glGetIntegerv(GL_MAX_TEXTURE_UNITS, &out); });
MaxTextureSize.SetMethod( [](si32& out) { glGetIntegerv(GL_MAX_TEXTURE_SIZE, &out); });
GLSLVersion.SetMethod( [](const char*& out) { out = (char*)glGetString(GL_SHADING_LANGUAGE_VERSION); });
GLEWVersion.SetMethod( [](const char*& out) { out = (char*)glewGetString(GLEW_VERSION); });
m_Textures = new Cre8RenderValue<tTextureID>[MaxTextureUnits.GetValue()];
Cre8RenderValue<tTextureID>* a = &m_Textures[0];
Cre8RenderValue<tTextureID>* b = &m_Textures[1];
Cre8RenderValue<tTextureID>* c = &m_Textures[2];
for(si32 i = 0; i < MaxTextureUnits.GetValue(); ++i)
{
const int ci = i;
auto textureFunc = [ci](const tTextureID& val)
{
if(g_Cre8Render->MultiTexturingSupported == true)
{
glActiveTextureARB(GL_TEXTURE0_ARB + ci);
glEnable(GL_ARB_texture_non_power_of_two);
glBindTexture(GL_ARB_texture_non_power_of_two, val);
}
else
{
glBindTexture(GL_TEXTURE_2D, val);
}
};
m_Textures[i].SetMethod(0, textureFunc);
}
ClearAccum.SetMethod(ColorRGBf(0, 0, 0), [](const ColorRGBf& val) { glClearAccum(val[0], val[1], val[2], 1.f); });
ClearColor.SetMethod(ColorRGBf(0, 0, 0), [](const ColorRGBf& val) { glClearColor(val[0], val[1], val[2], 1.f); });
ClearDepth.SetMethod(1.f, [](const r32& val) { glClearDepth((double)val); });
ClearIndex.SetMethod(1.f, [](const r32& val) { glClearIndex(val); });
ClearStencil.SetMethod(0, [](const si32& val) { glClearStencil(val); });
EnableAttribute.AlphaTest.SetMethod(false, enableBitLambda(GL_ALPHA_TEST));
EnableAttribute.AutoNormal.SetMethod(false, enableBitLambda(GL_AUTO_NORMAL));
EnableAttribute.Blend.SetMethod(false, enableBitLambda(GL_BLEND));
EnableAttribute.colorMaterial.SetMethod(false, enableBitLambda(GL_COLOR_MATERIAL));
EnableAttribute.CullFace.SetMethod(false, enableBitLambda(GL_CULL_FACE));
EnableAttribute.DepthTest.SetMethod(false, enableBitLambda(GL_DEPTH_TEST));
EnableAttribute.Dither.SetMethod(false, enableBitLambda(GL_DITHER));
EnableAttribute.Fog.SetMethod(false, enableBitLambda(GL_FOG));
EnableAttribute.Lighting.SetMethod(false, enableBitLambda(GL_LIGHTING));
EnableAttribute.LineSmooth.SetMethod(false, enableBitLambda(GL_LINE_SMOOTH));
EnableAttribute.LineStipple.SetMethod(false, enableBitLambda(GL_LINE_STIPPLE));
EnableAttribute.ColorLogicOp.SetMethod(false, enableBitLambda(GL_COLOR_LOGIC_OP));
EnableAttribute.IndexLogicOp.SetMethod(false, enableBitLambda(GL_INDEX_LOGIC_OP));
EnableAttribute.Normalize.SetMethod(false, enableBitLambda(GL_NORMALIZE));
EnableAttribute.PointSmooth.SetMethod(false, enableBitLambda(GL_POINT_SMOOTH));
EnableAttribute.PolygonOffsetLine.SetMethod(false, enableBitLambda(GL_POLYGON_OFFSET_LINE));
EnableAttribute.PolygonOffsetFill.SetMethod(false, enableBitLambda(GL_POLYGON_OFFSET_FILL));
EnableAttribute.PolygonOffsetPoint.SetMethod(false, enableBitLambda(GL_POLYGON_OFFSET_POINT));
EnableAttribute.PolygonSmooth.SetMethod(false, enableBitLambda(GL_POLYGON_SMOOTH));
EnableAttribute.PolygonStipple.SetMethod(false, enableBitLambda(GL_POLYGON_STIPPLE));
EnableAttribute.ScissorTest.SetMethod(false, enableBitLambda(GL_SCISSOR_TEST));
EnableAttribute.StencilTest.SetMethod(false, enableBitLambda(GL_STENCIL_TEST));
EnableAttribute.Texture1d.SetMethod(false, enableBitLambda(GL_TEXTURE_1D));
EnableAttribute.Texture2d.SetMethod(false, enableBitLambda(GL_TEXTURE_2D));
}
bool glWindow::ResetGL () {
if (m_resetGLMode == RGM_RECREATEWINDOW) {
RecreateWindow (m_fullScreen, m_border, m_width, m_height, m_bpp, m_stencil, m_title, m_allowResizing, m_fitToWorkArea);
return true;
}
else if (m_resetGLMode == RGM_RECREATECONTEXT) {
RecreateGLContext ();
return true;
}
// Setup OpenGL defaults.
// This should reset as much as possible back to the initial state of OpenGL.
// Exceptions:
// * Projection matrix is initialised to a perspective transform
// End current gl block
try { glEnd (); } catch (...) { ; }
m_dontPaint = false;
// Intialise matrices
try { glMatrixMode (GL_PROJECTION); ClearGLMatrix (); } catch (...) { ; }
try { glMatrixMode (GL_TEXTURE); ClearGLMatrix (); } catch (...) { ; }
try { glMatrixMode (GL_MODELVIEW); ClearGLMatrix (); } catch (...) { ; }
// Initialise state
int i;
try { glColor4f (1, 1, 1, 1); } catch (...) { ; }
try { glIndexi (1); } catch (...) { ; }
try { glTexCoord4f (0, 0, 0, 1); } catch (...) { ; }
try { glNormal3f (0, 0, 1); } catch (...) { ; }
// try { glRasterPos4f (0, 0, 0, 1); } catch (...) { ; }
try { glEdgeFlag (GL_TRUE); } catch (...) { ; }
try { glDisable (GL_VERTEX_ARRAY); } catch (...) { ; }
try { glDisable (GL_NORMAL_ARRAY); } catch (...) { ; }
try { glDisable (GL_COLOR_ARRAY); } catch (...) { ; }
try { glDisable (GL_INDEX_ARRAY); } catch (...) { ; }
try { glDisable (GL_TEXTURE_COORD_ARRAY); } catch (...) { ; }
try { glDisable (GL_EDGE_FLAG_ARRAY); } catch (...) { ; }
try { glDepthRange (0, 1); } catch (...) { ; }
try { glDisable (GL_NORMALIZE); } catch (...) { ; }
for (i = 0; i < GL_MAX_CLIP_PLANES; i++)
try { glDisable (GL_CLIP_PLANE0 + i); } catch (...) { ; }
GLfloat fog[] = {0, 0, 0, 0};
try { glFogfv (GL_FOG_COLOR, fog); } catch (...) { ; }
try { glFogi (GL_FOG_INDEX, 0); } catch (...) { ; }
try { glFogf (GL_FOG_DENSITY, 1.0); } catch (...) { ; }
try { glFogf (GL_FOG_START, 0.0); } catch (...) { ; }
try { glFogf (GL_FOG_END, 1.0); } catch (...) { ; }
try { glFogi (GL_FOG_MODE, GL_EXP); } catch (...) { ; }
try { glDisable (GL_FOG); } catch (...) { ; }
try { glShadeModel (GL_SMOOTH); } catch (...) { ; }
try { glDisable (GL_LIGHTING); } catch (...) { ; }
try { glDisable (GL_COLOR_MATERIAL); } catch (...) { ; }
try { glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); } catch (...) { ; }
GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 },
diffuse[] = { 0.8, 0.8, 0.8, 1.0 },
specular[] = { 0.0, 0.0, 0.0, 1.0 },
emission[] = { 0.0, 0.0, 0.0, 1.0 },
shininess[] = { 0.0 };
try { glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, ambient); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, specular); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emission); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, shininess); } catch (...) { ; }
try { glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambient); } catch (...) { ; }
try { glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); } catch (...) { ; }
try { glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); } catch (...) { ; }
GLfloat lambient[] = { 0.0, 0.0, 0.0, 1.0 },
ldiffuse0[] = { 1.0, 1.0, 1.0, 1.0 },
ldiffuse1[] = { 0.0, 0.0, 0.0, 1.0 },
lspecular0[] = { 1.0, 1.0, 1.0, 1.0 },
lspecular1[] = { 0.0, 0.0, 0.0, 1.0 },
lposition[] = { 0.0, 0.0, 1.0, 0.0 };
for (i = 0; i < 8; i++) {
try { glLightfv (GL_LIGHT0 + i, GL_AMBIENT, lambient); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_DIFFUSE, i == 0 ? ldiffuse0 : ldiffuse1); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_SPECULAR, i == 0 ? lspecular0 : lspecular1); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_POSITION, lposition); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_SPOT_EXPONENT, 0.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, 1.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, 0.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, 0.0); } catch (...) { ; }
try { glDisable (GL_LIGHT0 + i); } catch (...) { ; }
}
try { glPointSize (1.0); } catch (...) { ; }
try { glDisable (GL_POINT_SMOOTH); } catch (...) { ; }
try { glLineWidth (1.0); } catch (...) { ; }
try { glDisable (GL_LINE_SMOOTH); } catch (...) { ; }
try { glLineStipple (1, 0xffff); } catch (...) { ; }
try { glDisable (GL_LINE_STIPPLE); } catch (...) { ; }
try { glDisable (GL_CULL_FACE); } catch (...) { ; }
try { glCullFace (GL_BACK); } catch (...) { ; }
try { glFrontFace (GL_CCW); } catch (...) { ; }
try { glDisable (GL_POLYGON_SMOOTH); } catch (...) { ; }
try { glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); } catch (...) { ; }
try { glDisable (GL_TEXTURE_1D); } catch (...) { ; }
try { glDisable (GL_TEXTURE_2D); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); } catch (...) { ; }
GLfloat texBorder[] = {0, 0, 0, 0};
try { glTexParameterfv (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, texBorder); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_T); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_S); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_R); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_Q); } catch (...) { ; }
for (i = 0; i < 4; i++) {
GLenum coord;
switch (i) {
case 0: coord = GL_T; break;
case 1: coord = GL_S; break;
case 2: coord = GL_R; break;
case 3: coord = GL_Q; break;
}
try { glTexGeni (coord, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); } catch (...) { ; }
}
try { glDisable (GL_SCISSOR_TEST); } catch (...) { ; }
try { glDisable (GL_ALPHA_TEST); } catch (...) { ; }
try { glAlphaFunc (GL_ALWAYS, 0); } catch (...) { ; }
try { glDisable (GL_STENCIL_TEST); } catch (...) { ; }
try { glStencilFunc (GL_ALWAYS, 0, 0xffffffff); } catch (...) { ; }
try { glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); } catch (...) { ; }
try { glDisable (GL_DEPTH_TEST); } catch (...) { ; }
try { glDepthFunc (GL_LESS); } catch (...) { ; }
try { glDisable (GL_BLEND); } catch (...) { ; }
try { glBlendFunc (GL_ONE, GL_ZERO); } catch (...) { ; }
try { glDrawBuffer (GL_BACK); } catch (...) { ; }
try { glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } catch (...) { ; }
try { glDepthMask (GL_TRUE); } catch (...) { ; }
try { glClearAccum (0, 0, 0, 0); } catch (...) { ; }
try { glClearColor (0, 0, 0, 0); } catch (...) { ; }
try { glClearDepth (1); } catch (...) { ; }
try { glClearIndex (0); } catch (...) { ; }
try { glClearStencil (0); } catch (...) { ; }
try { glPixelStorei (GL_PACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; }
try { glPixelStorei (GL_PACK_LSB_FIRST, GL_FALSE); } catch (...) { ; }
try { glPixelStoref (GL_PACK_ROW_LENGTH, 0); } catch (...) { ; }
try { glPixelStoref (GL_PACK_SKIP_PIXELS, 0); } catch (...) { ; }
try { glPixelStorei (GL_PACK_ALIGNMENT, 4); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE); } catch (...) { ; }
try { glPixelStoref (GL_UNPACK_ROW_LENGTH, 0); } catch (...) { ; }
try { glPixelStoref (GL_UNPACK_SKIP_PIXELS, 0); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_ALIGNMENT, 4); } catch (...) { ; }
try { glPixelTransferi (GL_MAP_COLOR, GL_FALSE); } catch (...) { ; }
try { glPixelTransferi (GL_MAP_STENCIL, GL_FALSE); } catch (...) { ; }
try { glPixelTransferi (GL_INDEX_SHIFT, 0); } catch (...) { ; }
try { glPixelTransferi (GL_INDEX_OFFSET, 0); } catch (...) { ; }
try { glPixelTransferf (GL_RED_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_GREEN_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_BLUE_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_ALPHA_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_DEPTH_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_RED_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_GREEN_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_BLUE_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_ALPHA_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_DEPTH_BIAS, 0.0); } catch (...) { ; }
try { glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_POINT_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_FOG_HINT, GL_DONT_CARE); } catch (...) { ; }
// Multitexturing
if (ExtensionSupported ("GL_ARB_multitexture")) {
// Disable texturing for all texture units
int units;
try { glGetIntegerv (GL_MAX_TEXTURE_UNITS_ARB, &units); } catch (...) { ; }
for (int i = 0; i < units; i++) {
if (glActiveTexture != NULL)
glActiveTexture (GL_TEXTURE0_ARB + i);
try { glDisable (GL_TEXTURE_2D); } catch (...) { ; }
try { glDisable (GL_TEXTURE_1D); } catch (...) { ; }
if (i == 0) try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } catch (...) { ; }
else try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); } catch (...) { ; }
}
if (glActiveTexture != NULL)
try { glActiveTexture (GL_TEXTURE0_ARB); } catch (...) { ; }
}
// Setup OpenGL defaults
OpenGLDefaults ();
return TRUE; // Initialization Went OK
}
void StochasticRenderer::initialize_opengl( void )
{
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST );
glClearAccum( 0.0, 0.0, 0.0, 0.0 );
}
int main(int argc, char **argv)
{
int i;
if (argc > 1) { /* make sure at least 2 args, program and file */
strncpy(filename, argv[argc - 1], sizeof(filename)); /* get the last arg as the file always */
for (i = 0; i < argc; i++) { /* check for startup params */
if (strstr(argv[i], "-s"))
stereo = 1;
if (strstr(argv[i], "-f"))
full_screen = 1;
}
} else { /* user only entered program name, help them */
printf("Usage: %s [-s] [-f] <obj filename>\n", argv[0]);
exit(0);
}
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(1024, 768); /* Window Size If We Start In Windowed Mode */
glutCreateWindow("Wavefront Obj File Viewer");
if (full_screen)
glutFullScreen();
glutDisplayFunc(Display);
glutKeyboardFunc(Keyboard);
getMatrix();
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearAccum(0.0, 0.0, 0.0, 0.0);
glutReshapeFunc(Reshape);
glutMouseFunc(Mouse);
glutMotionFunc(Motion);
glutIdleFunc(NULL);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
if (lighting)
glEnable(GL_LIGHTING);
if (lighting)
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_TEXTURE_2D);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
if (!pmodel) { /* load up the model */
pmodel = glmReadOBJ(filename);
if (!pmodel) {
printf("\nUsage: objviewV2 <-s> <obj filename>\n");
exit(0);
}
glmUnitize(pmodel);
glmVertexNormals(pmodel, 90.0, GL_TRUE);
}
glutMainLoop();
return 0;
}
