2 * CITS2231 Graphics Scene Editor
\r
3 * @author Ashley Tyndall (20915779)
\r
12 #include <GL/glut.h>
\r
17 // Type definitions for vertex-coordinates, normals, texture-coordinates,
\r
18 // and triangles (via the indices of 3 vertices).
\r
19 typedef GLfloat vertex[3];
\r
20 typedef GLfloat normal[3];
\r
21 typedef GLfloat texCoord[2];
\r
22 typedef GLint vertexIndex;
\r
23 typedef vertexIndex triangle[3];
\r
25 // A type for a mesh
\r
27 int nVertices; // The number of vertices in the mesh
\r
28 vertex* vertices; // Array with coordinates of vertices
\r
29 normal* normals; // Array with normals of vertices
\r
30 texCoord* texCoords; // Array with texture-coordinates of vertices
\r
31 int nTriangles; // The number of triangles in the mesh
\r
32 triangle* triangles; // Array of trangles via 3 indices into "vertices"
\r
35 #define NMESH 54 // The number of meshes (in the models-textures dir)
\r
36 mesh* meshes[NMESH]; // An array of pointers to the meshes - see getMesh
\r
38 // A type for a 2D texture, with height and width in pixels
\r
42 GLubyte *rgbData; // Array of bytes with the colour data for the texture
\r
45 #define NTEXTURE 30 // The number of textures (in the models-textures dir)
\r
46 texture* textures[NTEXTURE]; // An array of texture pointers - see getTexture
\r
49 // You'll need to add scale, rotation, material, mesh number, etc.,
\r
50 // to this structure
\r
59 ROTATION_TEXTURE_SCALE,
\r
64 MATERIAL_AMBIENT_RGB,
\r
65 MATERIAL_DIFFUSE_RGB,
\r
66 MATERIAL_SPECULAR_RGB,
\r
69 MATERIAL_GREEN_ADSS,
\r
74 LIGHT_RGBALL_LIGHT_1,
\r
76 LIGHT_RGBALL_LIGHT_2
\r
80 const char *textureMenuEntries[NTEXTURE] = {
\r
81 "1 Plain", "2 Rust", "3 Concrete", "4 Carpet", "5 Beach Sand",
\r
82 "6 Rocky", "7 Brick", "8 Water", "9 Paper", "10 Marble",
\r
83 "11 Wood", "12 Scales", "13 Fur", "14 Denim", "15 Hessian",
\r
84 "16 Orange Peel", "17 Ice Crystals", "18 Grass", "19 Corrugated Iron", "20 Styrofoam",
\r
85 "21 Bubble Wrap", "22 Leather", "23 Camouflage", "24 Asphalt", "25 Scratched Ice",
\r
86 "26 Rattan", "27 Snow", "28 Dry Mud", "29 Old Concrete", "30 Leopard Skin"
\r
89 const char *objectMenuEntries[NMESH] = {
\r
90 "1 Thin Dinosaur","2 Big Dog","3 Saddle Dinosaur", "4 Dragon", "5 Cleopatra",
\r
91 "6 Bone I", "7 Bone II", "8 Rabbit", "9 Long Dragon", "10 Buddha",
\r
92 "11 Sitting Rabbit", "12 Frog", "13 Cow", "14 Monster", "15 Sea Horse",
\r
93 "16 Head", "17 Pelican", "18 Horse", "19 Kneeling Angel", "20 Porsche I",
\r
94 "21 Truck", "22 Statue of Liberty", "23 Sitting Angel", "24 Metal Part", "25 Car",
\r
95 "26 Apatosaurus", "27 Airliner", "28 Motorbike", "29 Dolphin", "30 Spaceman",
\r
96 "31 Winnie the Pooh", "32 Shark", "33 Crocodile", "34 Toddler", "35 Fat Dinosaur",
\r
97 "36 Chihuahua", "37 Sabre-toothed Tiger", "38 Lioness", "39 Fish", "40 Horse (head down)",
\r
98 "41 Horse (head up)", "42 Skull", "43 Fighter Jet I", "44 Toad", "45 Convertible",
\r
99 "46 Porsche II", "47 Hare", "48 Vintage Car", "49 Fighter Jet II", "50 Winged Monkey",
\r
100 "51 Chef", "52 Parasaurolophus", "53 Rooster", "54 T-rex"
\r
103 #define MAXOBJECTS 256
\r
104 SceneObject sceneObjs[MAXOBJECTS]; // An array with details of the objects in a scene
\r
105 int nObjects=0; // How many objects there are in the scene currently.
\r
107 // Directories containing models
\r
108 char *dirDefault1 = "models-textures";
\r
109 char *dirDefault2 = "/cslinux/examples/CITS2231/project-files/models-textures";
\r
111 char dataDir[200]; // Stores the directory name for the meshes and textures.
\r
113 static GLfloat floorVertices[4][3] = {
\r
114 { -1000.0, 0.0, 1000.0 },
\r
115 { 1000.0, 0.0, 1000.0 },
\r
116 { 1000.0, 0.0, -1000.0 },
\r
117 { -1000.0, 0.0, -1000.0 },
\r
120 static GLfloat lightColor[] = {1.0, 1.0, 1.0, 1.0}; // White light
\r
121 static GLfloat lightPosition[4];
\r
123 int moving, startx, starty;
\r
124 int lightMoving = 0, lightStartX, lightStartY;
\r
126 /* Time varying or user-controled variables. */
\r
127 static float jump = 0.0;
\r
128 static float lightAngle = 0.0, lightHeight = 20;
\r
129 GLfloat angle = -150; /* in degrees */
\r
130 GLfloat angle2 = 30; /* in degrees */
\r
133 * Prints out error message when file cannot be read
\r
134 * @param fileName Name of file that could not be read
\r
136 void fileErr(char* fileName) {
\r
137 printf("Error reading file: %s\n", fileName);
\r
138 printf("If not in the CSSE labs, you will need to include the directory containing\n");
\r
139 printf("the models on the command line, or put it in the same folder as the exectutable.");
\r
140 exit(EXIT_FAILURE);
\r
144 * Reads .bmp texture files and converts them to a texture object
\r
145 * @param fileName .bmp texture file
\r
146 * @return texture object
\r
148 texture* loadTexture(char *fileName) {
\r
149 texture* t = malloc(sizeof (texture));
\r
152 t->rgbData = LoadDIBitmap(fileName, &info);
\r
153 t->height=info->bmiHeader.biHeight;
\r
154 t->width=info->bmiHeader.biWidth;
\r
160 * Reads .x files and converts them to a mesh object
\r
161 * @param fileName .x mesh file
\r
162 * @return mesh object
\r
164 mesh* loadMesh(char* fileName) {
\r
165 mesh* m = malloc(sizeof (mesh));
\r
166 FILE* fp = fopen(fileName, "r");
\r
167 char line[256] = "";
\r
168 int lineBuffSize = 256;
\r
170 if(fp == NULL) fileErr(fileName);
\r
172 while(strcmp(line,"Mesh {\r\n") != 0 && strcmp(line,"Mesh {\n") != 0 )
\r
173 fgets(line, lineBuffSize, fp);
\r
175 fscanf(fp, "%d;\n", &(m->nVertices));
\r
176 m->vertices = malloc(m->nVertices * sizeof(vertex));
\r
177 for(int i=0; i < m->nVertices; i++)
\r
178 fscanf(fp, "%f; %f; %f;%*[,;]\n", &(m->vertices[i][0]), &(m->vertices[i][1]), &(m->vertices[i][2]) );
\r
180 fscanf(fp, "%d;\n", &(m->nTriangles));
\r
181 m->triangles = malloc(m->nTriangles * sizeof(triangle));
\r
182 for(int i=0; i < m->nTriangles; i++)
\r
183 fscanf(fp, "%*d; %d, %d, %d;%*[;,]", m->triangles[i], m->triangles[i]+1, m->triangles[i]+2);
\r
185 while(strcmp(line," MeshNormals {\r\n") != 0 && strcmp(line," MeshNormals {\n") != 0)
\r
186 fgets(line, lineBuffSize, fp);
\r
188 fgets(line, lineBuffSize, fp);
\r
189 m->normals = malloc(m->nVertices * sizeof(normal));
\r
190 for(int i=0; i < m->nVertices; i++)
\r
191 fscanf(fp, "%f; %f; %f;%*[;,]\n",
\r
192 &(m->normals[i][0]), &(m->normals[i][1]), &(m->normals[i][2]));
\r
194 while(strcmp(line,"MeshTextureCoords {\r\n") != 0 && strcmp(line,"MeshTextureCoords {\n") != 0)
\r
195 fgets(line, lineBuffSize, fp);
\r
197 fgets(line, lineBuffSize, fp);
\r
198 m->texCoords = malloc(m->nVertices * sizeof(texCoord));
\r
199 for(int i=0; i < m->nVertices; i++)
\r
200 fscanf(fp, "%f;%f;%*[,;]\n", &(m->texCoords[i][0]), &(m->texCoords[i][1]) );
\r
206 // [You may want to add to this function.]
\r
208 * Loads mesh[i] if it isn't already loaded.
\r
209 * You must call getMesh(i) at least once before using mesh[i].
\r
213 void getMesh(int i) { // getMesh(i) loads mesh[i] if it isn't already loaded.
\r
214 char fileName[220];
\r
215 if(i>=NMESH || i<0) {
\r
216 printf("Error in getMesh - wrong model number");
\r
219 if(meshes[i] != NULL)
\r
221 sprintf(fileName, "%s/model%d.x", dataDir, i+1);
\r
222 meshes[i] = loadMesh(fileName);
\r
226 * Loads texture i if it isn't already loaded
\r
228 * After calling getTexture(i), you can make texture i the current texture using
\r
229 * glBindTexture(GL_TEXTURE_2D, i);
\r
230 * Use i=0 to return to the default plain texture.
\r
232 * You can then scale the texture via:
\r
233 * glMatrixMode(GL_TEXTURE);
\r
234 * See the textbook, section 8.8.3.
\r
236 * You must call getTexture(i) at least once before using texture i.
\r
237 * @param i Texture ID
\r
239 void getTexture(int i) {
\r
240 char fileName[220];
\r
241 if(i<1 || i>NTEXTURE) {
\r
242 printf("Error in getTexture - wrong texture number");
\r
245 if(textures[i-1] != NULL)
\r
247 sprintf(fileName, "%s/texture%d.bmp", dataDir, i);
\r
249 textures[i-1] = loadTexture(fileName);
\r
251 glBindTexture(GL_TEXTURE_2D, i);
\r
253 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, textures[i-1]->width, textures[i-1]->height,
\r
254 0, GL_RGB, GL_UNSIGNED_BYTE, textures[i-1]->rgbData);
\r
255 gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, textures[i-1]->width, textures[i-1]->height, GL_RGB,
\r
256 GL_UNSIGNED_BYTE, textures[i-1]->rgbData);
\r
257 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
\r
258 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
\r
259 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
260 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
\r
262 glBindTexture(GL_TEXTURE_2D, 0); // Back to default texture
\r
266 * Event hander for main menu events
\r
267 * @param id ID of menu item selected
\r
269 void processMainEvents(int id) {
\r
271 case ROTATE_MOVE_CAMERA:
\r
275 case POSITION_SCALE:
\r
279 case ROTATION_TEXTURE_SCALE:
\r
284 exit(EXIT_SUCCESS);
\r
290 * Event hander for materials menu events
\r
291 * @param id ID of menu item selected
\r
293 void processMaterialEvents(int id) {
\r
295 case MATERIAL_ALL_RGB:
\r
299 case MATERIAL_AMBIENT_RGB:
\r
303 case MATERIAL_DIFFUSE_RGB:
\r
307 case MATERIAL_SPECULAR_RGB:
\r
311 case MATERIAL_ALL_ADSS:
\r
315 case MATERIAL_RED_ADSS:
\r
319 case MATERIAL_GREEN_ADSS:
\r
323 case MATERIAL_BLUE_ADSS:
\r
331 * Event hander for light menu events
\r
332 * @param id ID of menu item selected
\r
334 void processLightEvents(int id) {
\r
336 case LIGHT_MOVE_LIGHT_1:
\r
340 case LIGHT_RGBALL_LIGHT_1:
\r
344 case LIGHT_MOVE_LIGHT_2:
\r
348 case LIGHT_RGBALL_LIGHT_2:
\r
356 * Event hander for object menu events
\r
357 * @param id ID of object selected
\r
359 void processObjectEvents(int id) {
\r
364 * Event hander for texture menu events
\r
365 * @param id ID of texutre selected
\r
367 void processTextureEvents(int id) {
\r
372 * Event hander for ground texture menu events
\r
373 * @param id ID of ground texture selected
\r
375 void processGTextureEvents(int id) {
\r
380 * Rounds up numbers, from http://stackoverflow.com/questions/3407012/c-rounding-up-to-the-nearest-multiple-of-a-number
\r
381 * @param numToRound Number to round
\r
382 * @param multiple Multiple to round up to
\r
383 * @return Rounded number
\r
385 int roundUp(int numToRound, int multiple) {
\r
386 if(multiple == 0) {
\r
390 int remainder = numToRound % multiple;
\r
391 if (remainder == 0)
\r
393 return numToRound + multiple - remainder;
\r
397 * Makes a submenu from an array of items, splitting the list into subsubmenus
\r
398 * of only 10 items.
\r
399 * @param menuEntries Array of menu items
\r
400 * @param menuEntriesSize Size of menuEntries
\r
401 * @param callback Callback function for this array of menu items
\r
402 * @return Reference to menu created
\r
404 int makeSubmenuFromArray( const char *menuEntries[], unsigned int menuEntriesSize, void *callback ) {
\r
405 if ( menuEntriesSize == 0 ) return -1;
\r
407 int menuNumber = roundUp(menuEntriesSize, 10) / 10;
\r
408 int submenuObjects[menuNumber-1];
\r
410 for( int i = 0; i < menuNumber; i++ ) {
\r
411 submenuObjects[i] = glutCreateMenu(callback);
\r
412 int startNum = i*11 - (i-1);
\r
413 for ( int j = startNum - 1; j < (startNum+9); j++ ) {
\r
414 if ( j == menuEntriesSize ) break; // Detect if we've reached the end of the array
\r
415 glutAddMenuEntry( menuEntries[j], j + 1 );
\r
419 int mainMenu = glutCreateMenu(callback);
\r
420 for ( int i = 0; i < menuNumber; i++ ) {
\r
421 char name[10]; // buffer to hold name
\r
422 int startNum = i*11 - (i-1);
\r
423 int endNum = startNum + 9;
\r
424 if ( i == menuNumber - 1 ) { // We're on the last one
\r
425 endNum = startNum + (menuEntriesSize - startNum); // Work out final number
\r
427 sprintf(name, "%d-%d", startNum, endNum);
\r
428 glutAddSubMenu( name, submenuObjects[i] );
\r
435 * Creates menu for program
\r
438 // Construct material menu
\r
439 int materialMenu = glutCreateMenu(processMaterialEvents);
\r
440 glutAddMenuEntry("All R/G/B", MATERIAL_ALL_RGB);
\r
441 glutAddMenuEntry("Ambient R/G/B", MATERIAL_AMBIENT_RGB);
\r
442 glutAddMenuEntry("Diffuse R/G/B", MATERIAL_DIFFUSE_RGB);
\r
443 glutAddMenuEntry("Specular R/G/B", MATERIAL_SPECULAR_RGB);
\r
444 glutAddMenuEntry("All Amb/Diff/Spec/Shine", MATERIAL_ALL_ADSS);
\r
445 glutAddMenuEntry("Red Amb/Diff/Spec/Shine", MATERIAL_RED_ADSS);
\r
446 glutAddMenuEntry("Green Amb/Diff/Spec/Shine", MATERIAL_GREEN_ADSS);
\r
447 glutAddMenuEntry("Blue Amb/Diff/Spec/Shine", MATERIAL_BLUE_ADSS);
\r
449 // Construct light menu
\r
450 int lightMenu = glutCreateMenu(processLightEvents);
\r
451 glutAddMenuEntry("Move Light 1", LIGHT_MOVE_LIGHT_1);
\r
452 glutAddMenuEntry("R/G/B/All Light 1", LIGHT_RGBALL_LIGHT_1);
\r
453 glutAddMenuEntry("Move Light 2", LIGHT_MOVE_LIGHT_2);
\r
454 glutAddMenuEntry("R/G/B/All Light 2", LIGHT_RGBALL_LIGHT_2);
\r
456 // Construct object menu
\r
457 int objectMenuEntriesSize = sizeof(objectMenuEntries) / sizeof(objectMenuEntries[0]);
\r
458 int objectMenu = makeSubmenuFromArray( objectMenuEntries, objectMenuEntriesSize, processObjectEvents );
\r
460 // Construct texture / ground texture menus
\r
461 int textureMenuEntriesSize = sizeof(textureMenuEntries) / sizeof(textureMenuEntries[0]);
\r
462 int textureMenu = makeSubmenuFromArray( textureMenuEntries, textureMenuEntriesSize, processTextureEvents );
\r
463 int gTextureMenu = makeSubmenuFromArray( textureMenuEntries, textureMenuEntriesSize, processGTextureEvents );
\r
465 // Construct main menu
\r
466 glutCreateMenu(processMainEvents);
\r
467 //glutAddMenuEntry("Rotate/Move Camera", ROTATE_MOVE_CAMERA);
\r
468 //glutAddSubMenu("Add object", objectMenu);
\r
469 //glutAddMenuEntry("Position/Scale", POSITION_SCALE);
\r
470 //glutAddMenuEntry("Rotation/Texture Scale", ROTATION_TEXTURE_SCALE);
\r
471 //glutAddSubMenu("Material", materialMenu);
\r
472 //glutAddSubMenu("Texture", textureMenu);
\r
473 //glutAddSubMenu("Ground texture", gTextureMenu);
\r
474 //glutAddSubMenu("Lights", lightMenu);
\r
475 glutAddMenuEntry("Exit", EXIT);
\r
477 // Bind to right mouse button
\r
478 glutAttachMenu(GLUT_RIGHT_BUTTON);
\r
482 * Called when window is resized
\r
483 * @param w New width
\r
484 * @param h New height
\r
486 void windowReshape(int w, int h) {
\r
487 GLdouble near = -1000.0;
\r
488 GLdouble far = 1000.0;
\r
490 glViewport(0, 0, (GLsizei) w, (GLsizei) h);
\r
491 glMatrixMode(GL_PROJECTION);
\r
494 glOrtho(near, far, near*(GLfloat)h/(GLfloat)w,
\r
495 far*(GLfloat)h/(GLfloat)w, near, far);
\r
497 glOrtho(near*(GLfloat)w/(GLfloat)h,
\r
498 far*(GLfloat)w/(GLfloat)h, near, far, near, far);
\r
499 glMatrixMode(GL_MODELVIEW);
\r
504 * Called when mouse event occurs
\r
505 * @param btn Mouse button
\r
506 * @param state State of mouse button
\r
507 * @param x Mouse x position
\r
508 * @param y Mouse y position
\r
510 /*void mouse(int btn, int state, int x, int y) {
\r
514 mouse(int button, int state, int x, int y)
\r
516 if (button == GLUT_LEFT_BUTTON) {
\r
517 if (state == GLUT_DOWN) {
\r
522 if (state == GLUT_UP) {
\r
526 if (button == GLUT_MIDDLE_BUTTON) {
\r
527 if (state == GLUT_DOWN) {
\r
532 if (state == GLUT_UP) {
\r
539 motion(int x, int y)
\r
542 angle = angle + (x - startx);
\r
543 angle2 = angle2 + (y - starty);
\r
546 glutPostRedisplay();
\r
549 lightAngle += (x - lightStartX)/40.0;
\r
550 lightHeight += (lightStartY - y)/20.0;
\r
553 glutPostRedisplay();
\r
558 angle = (int)(angle + 10) % 360;
\r
559 //angle2 = (int)(angle2 + 10) % 360;
\r
560 printf("Angle 1: %f, Angle 2: %f\n", angle, angle2);
\r
562 glutPostRedisplay();
\r
569 glDisable(GL_LIGHTING);
\r
571 //if (useTexture) {
\r
572 // glEnable(GL_TEXTURE_2D);
\r
575 /*glBegin(GL_QUADS);
\r
576 glTexCoord2f(0.0, 0.0);
\r
577 glVertex3fv(floorVertices[0]);
\r
578 glTexCoord2f(0.0, 16.0);
\r
579 glVertex3fv(floorVertices[1]);
\r
580 glTexCoord2f(16.0, 16.0);
\r
581 glVertex3fv(floorVertices[2]);
\r
582 glTexCoord2f(16.0, 0.0);
\r
583 glVertex3fv(floorVertices[3]);
\r
586 drawSquare(0, -1000, -1000, 1000, 1000);
\r
588 /*if (useTexture) {
\r
589 glDisable(GL_TEXTURE_2D);
\r
592 glEnable(GL_LIGHTING);
\r
595 int drawFloorRecurse = 2;
\r
596 /*void drawSquare(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
\r
597 drawSquare(0, x1, y1, x2, y2);
\r
600 void drawSquare(int recurseLevel, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
\r
604 if ( drawFloorRecurse != recurseLevel ) {
\r
605 GLfloat xm = (x1 + x2) / 2.0;
\r
606 GLfloat ym = (y1 + y2) / 2.0;
\r
607 int rnew = recurseLevel + 1;
\r
608 printf("Recursing to level %d\n", rnew);
\r
610 // Split into four sub-quads
\r
611 drawSquare(rnew, x1, y1, xm, ym);
\r
612 drawSquare(rnew, x1, ym, xm, y2);
\r
613 drawSquare(rnew, xm, ym, x2, y2);
\r
614 drawSquare(rnew, xm, y1, x2, ym);
\r
617 printf("Drawing (%f, %f) -> (%f, %f)\n", x1, y2, x2, y2);
\r
619 glVertex3f(x1, 0.0, y1);
\r
620 glVertex3f(x1, 0.0, y2);
\r
621 glVertex3f(x2, 0.0, y2);
\r
622 glVertex3f(x2, 0.0, y1);
\r
632 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
\r
635 0.0, 0.0, 60.0, /* eye is at (x,y,z) */
\r
636 0.0, 0.0, 0.0, /* center is at (x,y,z) */
\r
637 0.0, 1.0, 0.0 /* up is in postivie Y direction */
\r
640 /* Reposition the light source. */
\r
641 lightPosition[0] = 12*cos(lightAngle);
\r
642 lightPosition[1] = lightHeight;
\r
643 lightPosition[2] = 12*sin(lightAngle);
\r
644 lightPosition[3] = 0.0;
\r
647 /* Perform scene rotations based on user mouse input. */
\r
648 glRotatef(angle2, 1.0, 0.0, 0.0);
\r
649 glRotatef(angle, 0.0, 1.0, 0.0);
\r
651 glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
\r
653 glEnable(GL_BLEND);
\r
654 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
\r
656 glDisable(GL_BLEND);
\r
660 //glTranslatef(0.0, 0.0, 0.0);
\r
661 glutWireTeapot(30); // Draw teapot for test
\r
665 glDisable(GL_LIGHTING);
\r
666 glColor3f(1.0, 1.0, 1.0);
\r
668 /* Draw a yellow ball at the light source. */
\r
669 glTranslatef(lightPosition[0], lightPosition[1], lightPosition[2]);
\r
670 glutSolidSphere(1.0, 5, 5);
\r
672 glEnable(GL_LIGHTING);
\r
681 * init function; sets initial OpenGL state
\r
684 glMatrixMode(GL_PROJECTION);
\r
688 60.0, /* field of view in degree */
\r
689 1.0, /* aspect ratio */
\r
690 -1000.0, /* Z near */
\r
694 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
\r
695 glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor);
\r
696 glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1);
\r
697 glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05);
\r
698 glEnable(GL_LIGHT0);
\r
699 glEnable(GL_LIGHTING);
\r
701 glMatrixMode(GL_MODELVIEW);
\r
707 * @param argc Number of arguments
\r
708 * @param argv Array of arguments
\r
709 * @return Program exit code
\r
711 int main(int argc, char **argv) {
\r
713 strcpy(dataDir, argv[1]);
\r
714 else if(opendir(dirDefault1))
\r
715 strcpy(dataDir, dirDefault1);
\r
716 else if(opendir(dirDefault2))
\r
717 strcpy(dataDir, dirDefault2);
\r
718 else fileErr(dirDefault1);
\r
720 for(int i=0; i<NMESH; i++) meshes[i]=NULL;
\r
721 for(int i=0; i<NTEXTURE; i++) textures[i]=NULL;
\r
723 glutInit(&argc, argv);
\r
725 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
\r
727 glutInitWindowSize(500, 500);
\r
728 glutCreateWindow("Scene Editor");
\r
730 glShadeModel(GL_SMOOTH); // Enables Smooth Shading
\r
731 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background
\r
732 glClearDepth(1.0f); // Depth Buffer Setup
\r
733 glEnable(GL_DEPTH_TEST); // Enables Depth Testing
\r
734 glDepthFunc(GL_LEQUAL); // the type
\r
735 glEnable(GL_CULL_FACE);
\r
736 glEnable(GL_TEXTURE_2D);
\r
739 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
\r
741 glutReshapeFunc(windowReshape);
\r
742 glutDisplayFunc(display);
\r
743 //glutMouseFunc(mouse);
\r
744 //glutMotionFunc(motion);
\r
745 glutIdleFunc(idle);
\r