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 lightColor[] = {1.0, 1.0, 1.0, 1.0}; // White light
\r
114 static GLfloat lightPosition[4];
\r
116 int moving, startx, starty;
\r
117 int lightMoving = 0, lightStartX, lightStartY;
\r
119 /* Time varying or user-controled variables. */
\r
120 static float jump = 0.0;
\r
121 static float lightAngle = 0.0, lightHeight = 5;
\r
122 GLfloat angle = -150; /* in degrees */
\r
123 GLfloat angle2 = 30; /* in degrees */
\r
125 /* Near and far parameters */
\r
126 GLfloat near = -10;
\r
129 /* Zoom factor for mouse movements */
\r
130 GLfloat zoomFactor = 1.0;
\r
132 /* Recursion level for floor drawing */
\r
133 int drawFloorRecurse = 5;
\r
135 /* Size of floor, from -n to n */
\r
136 int floorSize = 100;
\r
139 * Prints out error message when file cannot be read
\r
140 * @param fileName Name of file that could not be read
\r
142 void fileErr(char* fileName) {
\r
143 printf("Error reading file: %s\n", fileName);
\r
144 printf("If not in the CSSE labs, you will need to include the directory containing\n");
\r
145 printf("the models on the command line, or put it in the same folder as the exectutable.");
\r
146 exit(EXIT_FAILURE);
\r
150 * Reads .bmp texture files and converts them to a texture object
\r
151 * @param fileName .bmp texture file
\r
152 * @return texture object
\r
154 texture* loadTexture(char *fileName) {
\r
155 texture* t = malloc(sizeof (texture));
\r
158 t->rgbData = LoadDIBitmap(fileName, &info);
\r
159 t->height=info->bmiHeader.biHeight;
\r
160 t->width=info->bmiHeader.biWidth;
\r
166 * Reads .x files and converts them to a mesh object
\r
167 * @param fileName .x mesh file
\r
168 * @return mesh object
\r
170 mesh* loadMesh(char* fileName) {
\r
171 mesh* m = malloc(sizeof (mesh));
\r
172 FILE* fp = fopen(fileName, "r");
\r
173 char line[256] = "";
\r
174 int lineBuffSize = 256;
\r
176 if(fp == NULL) fileErr(fileName);
\r
178 while(strcmp(line,"Mesh {\r\n") != 0 && strcmp(line,"Mesh {\n") != 0 )
\r
179 fgets(line, lineBuffSize, fp);
\r
181 fscanf(fp, "%d;\n", &(m->nVertices));
\r
182 m->vertices = malloc(m->nVertices * sizeof(vertex));
\r
183 for(int i=0; i < m->nVertices; i++)
\r
184 fscanf(fp, "%f; %f; %f;%*[,;]\n", &(m->vertices[i][0]), &(m->vertices[i][1]), &(m->vertices[i][2]) );
\r
186 fscanf(fp, "%d;\n", &(m->nTriangles));
\r
187 m->triangles = malloc(m->nTriangles * sizeof(triangle));
\r
188 for(int i=0; i < m->nTriangles; i++)
\r
189 fscanf(fp, "%*d; %d, %d, %d;%*[;,]", m->triangles[i], m->triangles[i]+1, m->triangles[i]+2);
\r
191 while(strcmp(line," MeshNormals {\r\n") != 0 && strcmp(line," MeshNormals {\n") != 0)
\r
192 fgets(line, lineBuffSize, fp);
\r
194 fgets(line, lineBuffSize, fp);
\r
195 m->normals = malloc(m->nVertices * sizeof(normal));
\r
196 for(int i=0; i < m->nVertices; i++)
\r
197 fscanf(fp, "%f; %f; %f;%*[;,]\n",
\r
198 &(m->normals[i][0]), &(m->normals[i][1]), &(m->normals[i][2]));
\r
200 while(strcmp(line,"MeshTextureCoords {\r\n") != 0 && strcmp(line,"MeshTextureCoords {\n") != 0)
\r
201 fgets(line, lineBuffSize, fp);
\r
203 fgets(line, lineBuffSize, fp);
\r
204 m->texCoords = malloc(m->nVertices * sizeof(texCoord));
\r
205 for(int i=0; i < m->nVertices; i++)
\r
206 fscanf(fp, "%f;%f;%*[,;]\n", &(m->texCoords[i][0]), &(m->texCoords[i][1]) );
\r
212 // [You may want to add to this function.]
\r
214 * Loads mesh[i] if it isn't already loaded.
\r
215 * You must call getMesh(i) at least once before using mesh[i].
\r
219 void getMesh(int i) { // getMesh(i) loads mesh[i] if it isn't already loaded.
\r
220 char fileName[220];
\r
221 if(i>=NMESH || i<0) {
\r
222 printf("Error in getMesh - wrong model number");
\r
225 if(meshes[i] != NULL)
\r
227 sprintf(fileName, "%s/model%d.x", dataDir, i+1);
\r
228 meshes[i] = loadMesh(fileName);
\r
232 * Loads texture i if it isn't already loaded
\r
234 * After calling getTexture(i), you can make texture i the current texture using
\r
235 * glBindTexture(GL_TEXTURE_2D, i);
\r
236 * Use i=0 to return to the default plain texture.
\r
238 * You can then scale the texture via:
\r
239 * glMatrixMode(GL_TEXTURE);
\r
240 * See the textbook, section 8.8.3.
\r
242 * You must call getTexture(i) at least once before using texture i.
\r
243 * @param i Texture ID
\r
245 void getTexture(int i) {
\r
246 char fileName[220];
\r
247 if(i<1 || i>NTEXTURE) {
\r
248 printf("Error in getTexture - wrong texture number");
\r
251 if(textures[i-1] != NULL)
\r
253 sprintf(fileName, "%s/texture%d.bmp", dataDir, i);
\r
255 textures[i-1] = loadTexture(fileName);
\r
257 glBindTexture(GL_TEXTURE_2D, i);
\r
259 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, textures[i-1]->width, textures[i-1]->height,
\r
260 0, GL_RGB, GL_UNSIGNED_BYTE, textures[i-1]->rgbData);
\r
261 gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, textures[i-1]->width, textures[i-1]->height, GL_RGB,
\r
262 GL_UNSIGNED_BYTE, textures[i-1]->rgbData);
\r
263 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
\r
264 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
\r
265 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
266 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
\r
268 glBindTexture(GL_TEXTURE_2D, 0); // Back to default texture
\r
272 * Event hander for main menu events
\r
273 * @param id ID of menu item selected
\r
275 void processMainEvents(int id) {
\r
277 case ROTATE_MOVE_CAMERA:
\r
281 case POSITION_SCALE:
\r
285 case ROTATION_TEXTURE_SCALE:
\r
290 exit(EXIT_SUCCESS);
\r
296 * Event hander for materials menu events
\r
297 * @param id ID of menu item selected
\r
299 void processMaterialEvents(int id) {
\r
301 case MATERIAL_ALL_RGB:
\r
305 case MATERIAL_AMBIENT_RGB:
\r
309 case MATERIAL_DIFFUSE_RGB:
\r
313 case MATERIAL_SPECULAR_RGB:
\r
317 case MATERIAL_ALL_ADSS:
\r
321 case MATERIAL_RED_ADSS:
\r
325 case MATERIAL_GREEN_ADSS:
\r
329 case MATERIAL_BLUE_ADSS:
\r
337 * Event hander for light menu events
\r
338 * @param id ID of menu item selected
\r
340 void processLightEvents(int id) {
\r
342 case LIGHT_MOVE_LIGHT_1:
\r
346 case LIGHT_RGBALL_LIGHT_1:
\r
350 case LIGHT_MOVE_LIGHT_2:
\r
354 case LIGHT_RGBALL_LIGHT_2:
\r
362 * Event hander for object menu events
\r
363 * @param id ID of object selected
\r
365 void processObjectEvents(int id) {
\r
370 * Event hander for texture menu events
\r
371 * @param id ID of texutre selected
\r
373 void processTextureEvents(int id) {
\r
378 * Event hander for ground texture menu events
\r
379 * @param id ID of ground texture selected
\r
381 void processGTextureEvents(int id) {
\r
386 * Rounds up numbers, from http://stackoverflow.com/questions/3407012/c-rounding-up-to-the-nearest-multiple-of-a-number
\r
387 * @param numToRound Number to round
\r
388 * @param multiple Multiple to round up to
\r
389 * @return Rounded number
\r
391 int roundUp(int numToRound, int multiple) {
\r
392 if(multiple == 0) {
\r
396 int remainder = numToRound % multiple;
\r
397 if (remainder == 0)
\r
399 return numToRound + multiple - remainder;
\r
403 * Makes a submenu from an array of items, splitting the list into subsubmenus
\r
404 * of only 10 items.
\r
405 * @param menuEntries Array of menu items
\r
406 * @param menuEntriesSize Size of menuEntries
\r
407 * @param callback Callback function for this array of menu items
\r
408 * @return Reference to menu created
\r
410 int makeSubmenuFromArray( const char *menuEntries[], unsigned int menuEntriesSize, void *callback ) {
\r
411 if ( menuEntriesSize == 0 ) return -1;
\r
413 int menuNumber = roundUp(menuEntriesSize, 10) / 10;
\r
414 int submenuObjects[menuNumber-1];
\r
416 for( int i = 0; i < menuNumber; i++ ) {
\r
417 submenuObjects[i] = glutCreateMenu(callback);
\r
418 int startNum = i*11 - (i-1);
\r
419 for ( int j = startNum - 1; j < (startNum+9); j++ ) {
\r
420 if ( j == menuEntriesSize ) break; // Detect if we've reached the end of the array
\r
421 glutAddMenuEntry( menuEntries[j], j + 1 );
\r
425 int mainMenu = glutCreateMenu(callback);
\r
426 for ( int i = 0; i < menuNumber; i++ ) {
\r
427 char name[10]; // buffer to hold name
\r
428 int startNum = i*11 - (i-1);
\r
429 int endNum = startNum + 9;
\r
430 if ( i == menuNumber - 1 ) { // We're on the last one
\r
431 endNum = startNum + (menuEntriesSize - startNum); // Work out final number
\r
433 sprintf(name, "%d-%d", startNum, endNum);
\r
434 glutAddSubMenu( name, submenuObjects[i] );
\r
441 * Creates menu for program
\r
444 // Construct material menu
\r
445 int materialMenu = glutCreateMenu(processMaterialEvents);
\r
446 glutAddMenuEntry("All R/G/B", MATERIAL_ALL_RGB);
\r
447 glutAddMenuEntry("Ambient R/G/B", MATERIAL_AMBIENT_RGB);
\r
448 glutAddMenuEntry("Diffuse R/G/B", MATERIAL_DIFFUSE_RGB);
\r
449 glutAddMenuEntry("Specular R/G/B", MATERIAL_SPECULAR_RGB);
\r
450 glutAddMenuEntry("All Amb/Diff/Spec/Shine", MATERIAL_ALL_ADSS);
\r
451 glutAddMenuEntry("Red Amb/Diff/Spec/Shine", MATERIAL_RED_ADSS);
\r
452 glutAddMenuEntry("Green Amb/Diff/Spec/Shine", MATERIAL_GREEN_ADSS);
\r
453 glutAddMenuEntry("Blue Amb/Diff/Spec/Shine", MATERIAL_BLUE_ADSS);
\r
455 // Construct light menu
\r
456 int lightMenu = glutCreateMenu(processLightEvents);
\r
457 glutAddMenuEntry("Move Light 1", LIGHT_MOVE_LIGHT_1);
\r
458 glutAddMenuEntry("R/G/B/All Light 1", LIGHT_RGBALL_LIGHT_1);
\r
459 glutAddMenuEntry("Move Light 2", LIGHT_MOVE_LIGHT_2);
\r
460 glutAddMenuEntry("R/G/B/All Light 2", LIGHT_RGBALL_LIGHT_2);
\r
462 // Construct object menu
\r
463 int objectMenuEntriesSize = sizeof(objectMenuEntries) / sizeof(objectMenuEntries[0]);
\r
464 int objectMenu = makeSubmenuFromArray( objectMenuEntries, objectMenuEntriesSize, processObjectEvents );
\r
466 // Construct texture / ground texture menus
\r
467 int textureMenuEntriesSize = sizeof(textureMenuEntries) / sizeof(textureMenuEntries[0]);
\r
468 int textureMenu = makeSubmenuFromArray( textureMenuEntries, textureMenuEntriesSize, processTextureEvents );
\r
469 int gTextureMenu = makeSubmenuFromArray( textureMenuEntries, textureMenuEntriesSize, processGTextureEvents );
\r
471 // Construct main menu
\r
472 glutCreateMenu(processMainEvents);
\r
473 //glutAddMenuEntry("Rotate/Move Camera", ROTATE_MOVE_CAMERA);
\r
474 //glutAddSubMenu("Add object", objectMenu);
\r
475 //glutAddMenuEntry("Position/Scale", POSITION_SCALE);
\r
476 //glutAddMenuEntry("Rotation/Texture Scale", ROTATION_TEXTURE_SCALE);
\r
477 //glutAddSubMenu("Material", materialMenu);
\r
478 //glutAddSubMenu("Texture", textureMenu);
\r
479 //glutAddSubMenu("Ground texture", gTextureMenu);
\r
480 //glutAddSubMenu("Lights", lightMenu);
\r
481 glutAddMenuEntry("Exit", EXIT);
\r
483 // Bind to right mouse button
\r
484 glutAttachMenu(GLUT_RIGHT_BUTTON);
\r
488 * Called when window is resized
\r
489 * @param w New width
\r
490 * @param h New height
\r
492 void windowReshape(int w, int h) {
\r
493 glViewport(0, 0, (GLsizei) w, (GLsizei) h);
\r
494 glMatrixMode(GL_PROJECTION);
\r
497 glOrtho(near, far, near*(GLfloat)h/(GLfloat)w,
\r
498 far*(GLfloat)h/(GLfloat)w, near, far);
\r
500 glOrtho(near*(GLfloat)w/(GLfloat)h,
\r
501 far*(GLfloat)w/(GLfloat)h, near, far, near, far);
\r
502 glMatrixMode(GL_MODELVIEW);
\r
507 * Called when mouse event occurs
\r
508 * @param btn Mouse button
\r
509 * @param state State of mouse button
\r
510 * @param x Mouse x position
\r
511 * @param y Mouse y position
\r
513 void mouse(int button, int state, int x, int y) {
\r
514 if (button == GLUT_LEFT_BUTTON) {
\r
515 if (state == GLUT_DOWN) {
\r
520 if (state == GLUT_UP) {
\r
524 if (button == GLUT_MIDDLE_BUTTON) {
\r
525 if (state == GLUT_DOWN) {
\r
530 if (state == GLUT_UP) {
\r
537 * Called when motion event occurs
\r
538 * @param x Mouse x position
\r
539 * @param y Mouse y position
\r
541 void motion(int x, int y) {
\r
543 angle = angle + (x - startx);
\r
544 angle2 = angle2 + (y - starty);
\r
547 glutPostRedisplay();
\r
550 lightAngle += (x - lightStartX)/40.0;
\r
551 lightHeight += (lightStartY - y)/20.0;
\r
554 glutPostRedisplay();
\r
559 * Recursive function to draw a square by drawing smaller and smaller
\r
560 * divisions of the square, determined by drawFloorRecurse.
\r
561 * @param recurseLevel Current level of recursion, only pass 0
\r
562 * @param x1 top-left x
\r
563 * @param z1 top-left z
\r
564 * @param x2 bottom-left x
\r
565 * @param z2 bottom-left z
\r
567 void drawSquare(int recurseLevel, float x1, float z1, float x2, float z2) {
\r
569 if ( drawFloorRecurse != recurseLevel ) {
\r
570 // Calculate middle points
\r
571 float xm = (x1 + x2) / 2.0;
\r
572 float zm = (z1 + z2) / 2.0;
\r
574 // Increment recursion level
\r
575 int rnew = recurseLevel + 1;
\r
577 // Split into four sub-quads
\r
578 drawSquare(rnew, x1, z1, xm, zm);
\r
579 drawSquare(rnew, x1, zm, xm, z2);
\r
580 drawSquare(rnew, xm, zm, x2, z2);
\r
581 drawSquare(rnew, xm, z1, x2, zm);
\r
585 // **NOTE: Is the polygon facing in the right direction?
\r
587 glVertex3f(x1, 0.0, z1);
\r
588 glVertex3f(x1, 0.0, z2);
\r
589 glVertex3f(x2, 0.0, z2);
\r
590 glVertex3f(x2, 0.0, z1);
\r
597 * Draw a floor by calling the drawSquare recursion
\r
600 drawSquare(0, -floorSize, -floorSize, floorSize, floorSize);
\r
607 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
\r
610 0.0, 0.0, 10.0, /* eye is at (x,y,z) */
\r
611 0.0, 0.0, 0.0, /* center is at (x,y,z) */
\r
612 0.0, 1.0, 0.0 /* up is in postivie Y direction */
\r
615 // **NOTE: Currently this rotation function is all that moves the camera off
\r
616 // the flat surface. Need to integrate function into gluLookAt
\r
617 glRotatef(30.0, 1.0, 0.0, 0.0);
\r
619 /* Reposition the light source. */
\r
620 lightPosition[0] = 12*cos(lightAngle);
\r
621 lightPosition[1] = lightHeight;
\r
622 lightPosition[2] = 12*sin(lightAngle);
\r
623 lightPosition[3] = 0.0;
\r
627 /* Perform scene rotations based on user mouse input. */
\r
628 glRotatef(angle, 0.0, 1.0, 0.0);
\r
629 //glRotatef(angle2, 1.0, 0.0, 0.0); **NOTE: Only one degree of freedom
\r
631 glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
\r
637 glTranslatef(0.0, 1.0, 0.0);
\r
638 glutWireTeapot(1); // Draw teapot for test
\r
642 glDisable(GL_LIGHTING);
\r
643 glColor3f(1.0, 1.0, 1.0);
\r
645 /* Draw a yellow ball at the light source. */
\r
646 glTranslatef(lightPosition[0], lightPosition[1], lightPosition[2]);
\r
647 glutSolidSphere(1.0, 50, 50);
\r
649 glEnable(GL_LIGHTING);
\r
658 * init function; sets initial OpenGL state
\r
661 glMatrixMode(GL_PROJECTION);
\r
665 60.0, /* field of view in degree */
\r
666 1.0, /* aspect ratio */
\r
672 GLfloat diffuse0[] = {1.0, 1.0, 1.0, 1.0};
\r
673 GLfloat ambient0[] = {1.0, 1.0, 1.0, 1.0};
\r
674 GLfloat specular0[] = {1.0, 1.0, 1.0, 1.0};
\r
675 GLfloat light0_pos[] ={ 1.0, 2.0, 3,0, 1.0};
\r
677 glEnable(GL_LIGHT0);
\r
678 glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
\r
679 glLightfv(GL_LIGHT0, GL_AMBIENT, ambient0);
\r
680 glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse0);
\r
681 glLightfv(GL_LIGHT0, GL_SPECULAR, specular0);
\r
682 glEnable(GL_LIGHTING);
\r
684 glMatrixMode(GL_MODELVIEW);
\r
690 * @param argc Number of arguments
\r
691 * @param argv Array of arguments
\r
692 * @return Program exit code
\r
694 int main(int argc, char **argv) {
\r
696 strcpy(dataDir, argv[1]);
\r
697 else if(opendir(dirDefault1))
\r
698 strcpy(dataDir, dirDefault1);
\r
699 else if(opendir(dirDefault2))
\r
700 strcpy(dataDir, dirDefault2);
\r
701 else fileErr(dirDefault1);
\r
703 for(int i=0; i<NMESH; i++) meshes[i]=NULL;
\r
704 for(int i=0; i<NTEXTURE; i++) textures[i]=NULL;
\r
706 glutInit(&argc, argv);
\r
708 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
\r
710 glutInitWindowSize(500, 500);
\r
711 glutCreateWindow("Scene Editor");
\r
713 glShadeModel(GL_SMOOTH); // Enables Smooth Shading
\r
714 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background
\r
715 glClearDepth(1.0f); // Depth Buffer Setup
\r
716 glEnable(GL_DEPTH_TEST); // Enables Depth Testing
\r
717 glDepthFunc(GL_LEQUAL); // the type
\r
718 glEnable(GL_CULL_FACE);
\r
719 glEnable(GL_TEXTURE_2D);
\r
722 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
\r
724 glutReshapeFunc(windowReshape);
\r
725 glutDisplayFunc(display);
\r
726 glutMouseFunc(mouse);
\r
727 glutMotionFunc(motion);
\r
728 //glutIdleFunc(idle);
\r