Xcode/TemplatesForXcodeSnowLeopard/SDL OpenGL Application/atlantis/atlantis.c
author Ryan C. Gordon <icculus@icculus.org>
Sun, 11 Sep 2011 14:44:37 -0400
branchSDL-1.2
changeset 5895 402eac854030
child 7191 75360622e65f
permissions -rw-r--r--
Unpacked Xcode.tar.gz.
     1 
     2 /* Copyright (c) Mark J. Kilgard, 1994. */
     3 
     4 /**
     5  * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
     6  * ALL RIGHTS RESERVED
     7  * Permission to use, copy, modify, and distribute this software for
     8  * any purpose and without fee is hereby granted, provided that the above
     9  * copyright notice appear in all copies and that both the copyright notice
    10  * and this permission notice appear in supporting documentation, and that
    11  * the name of Silicon Graphics, Inc. not be used in advertising
    12  * or publicity pertaining to distribution of the software without specific,
    13  * written prior permission.
    14  *
    15  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
    16  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
    17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
    18  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
    19  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
    20  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
    21  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
    22  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
    23  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
    24  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
    25  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
    26  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
    27  *
    28  * US Government Users Restricted Rights
    29  * Use, duplication, or disclosure by the Government is subject to
    30  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
    31  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
    32  * clause at DFARS 252.227-7013 and/or in similar or successor
    33  * clauses in the FAR or the DOD or NASA FAR Supplement.
    34  * Unpublished-- rights reserved under the copyright laws of the
    35  * United States.  Contractor/manufacturer is Silicon Graphics,
    36  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
    37  *
    38  * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
    39  */
    40 #include <stdio.h>
    41 #include <stdlib.h>
    42 #include <string.h>
    43 #include <math.h>
    44 #include <sys/time.h>
    45 #include <GLUT/glut.h>
    46 #include "atlantis.h"
    47 
    48 fishRec sharks[NUM_SHARKS];
    49 fishRec momWhale;
    50 fishRec babyWhale;
    51 fishRec dolph;
    52 
    53 GLboolean Timing = GL_TRUE;
    54 
    55 int w_win = 640;
    56 int h_win = 480;
    57 GLint count  = 0;
    58 GLenum StrMode = GL_VENDOR;
    59 
    60 GLboolean moving;
    61 
    62 static double mtime(void)
    63 {
    64    struct timeval tk_time;
    65    struct timezone tz;
    66    
    67    gettimeofday(&tk_time, &tz);
    68    
    69    return 4294.967296 * tk_time.tv_sec + 0.000001 * tk_time.tv_usec;
    70 }
    71 
    72 static double filter(double in, double *save)
    73 {
    74 	static double k1 = 0.9;
    75 	static double k2 = 0.05;
    76 
    77 	save[3] = in;
    78 	save[1] = save[0]*k1 + k2*(save[3] + save[2]);
    79 
    80 	save[0]=save[1];
    81 	save[2]=save[3];
    82 
    83 	return(save[1]);
    84 }
    85 
    86 void DrawStr(const char *str)
    87 {
    88 	GLint i = 0;
    89 	
    90 	if(!str) return;
    91         
    92 	while(str[i])
    93 	{
    94 		glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, str[i]);
    95 		i++;
    96 	}
    97 }
    98 
    99 void
   100 InitFishs(void)
   101 {
   102     int i;
   103 
   104     for (i = 0; i < NUM_SHARKS; i++) {
   105         sharks[i].x = 70000.0 + rand() % 6000;
   106         sharks[i].y = rand() % 6000;
   107         sharks[i].z = rand() % 6000;
   108         sharks[i].psi = rand() % 360 - 180.0;
   109         sharks[i].v = 1.0;
   110     }
   111 
   112     dolph.x = 30000.0;
   113     dolph.y = 0.0;
   114     dolph.z = 6000.0;
   115     dolph.psi = 90.0;
   116     dolph.theta = 0.0;
   117     dolph.v = 3.0;
   118 
   119     momWhale.x = 70000.0;
   120     momWhale.y = 0.0;
   121     momWhale.z = 0.0;
   122     momWhale.psi = 90.0;
   123     momWhale.theta = 0.0;
   124     momWhale.v = 3.0;
   125 
   126     babyWhale.x = 60000.0;
   127     babyWhale.y = -2000.0;
   128     babyWhale.z = -2000.0;
   129     babyWhale.psi = 90.0;
   130     babyWhale.theta = 0.0;
   131     babyWhale.v = 3.0;
   132 }
   133 
   134 void
   135 Atlantis_Init(void)
   136 {
   137     static float ambient[] = {0.2, 0.2, 0.2, 1.0};
   138     static float diffuse[] = {1.0, 1.0, 1.0, 1.0};
   139     static float position[] = {0.0, 1.0, 0.0, 0.0};
   140     static float mat_shininess[] = {90.0};
   141     static float mat_specular[] = {0.8, 0.8, 0.8, 1.0};
   142     static float mat_diffuse[] = {0.46, 0.66, 0.795, 1.0};
   143     static float mat_ambient[] = {0.3, 0.4, 0.5, 1.0};
   144     static float lmodel_ambient[] = {0.4, 0.4, 0.4, 1.0};
   145     static float lmodel_localviewer[] = {0.0};
   146     //GLfloat map1[4] = {0.0, 0.0, 0.0, 0.0};
   147     //GLfloat map2[4] = {0.0, 0.0, 0.0, 0.0};
   148     static float fog_color[] = {0.0, 0.5, 0.9, 1.0};
   149 
   150     glFrontFace(GL_CCW);
   151 
   152     glDepthFunc(GL_LESS);
   153     glEnable(GL_DEPTH_TEST);
   154 
   155     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
   156     glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
   157     glLightfv(GL_LIGHT0, GL_POSITION, position);
   158     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
   159     glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_localviewer);
   160     glEnable(GL_LIGHTING);
   161     glEnable(GL_LIGHT0);
   162 
   163     glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
   164     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
   165     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
   166     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
   167 
   168     InitFishs();
   169 
   170     glEnable(GL_FOG);
   171 	glFogi(GL_FOG_MODE, GL_EXP);
   172 	glFogf(GL_FOG_DENSITY, 0.0000025);
   173 	glFogfv(GL_FOG_COLOR, fog_color);
   174 
   175     glClearColor(0.0, 0.5, 0.9, 1.0);
   176 }
   177 
   178 void
   179 Atlantis_Reshape(int width, int height)
   180 {
   181 	w_win = width;
   182 	h_win = height;
   183 	
   184     glViewport(0, 0, width, height);
   185 
   186     glMatrixMode(GL_PROJECTION);
   187     glLoadIdentity();
   188     gluPerspective(60.0, (GLfloat) width / (GLfloat) height, 20000.0, 300000.0);
   189     glMatrixMode(GL_MODELVIEW);
   190 }
   191 
   192 void
   193 Atlantis_Animate(void)
   194 {
   195     int i;
   196 
   197     for (i = 0; i < NUM_SHARKS; i++) {
   198         SharkPilot(&sharks[i]);
   199         SharkMiss(i);
   200     }
   201     WhalePilot(&dolph);
   202     dolph.phi++;
   203     //glutPostRedisplay();
   204     WhalePilot(&momWhale);
   205     momWhale.phi++;
   206     WhalePilot(&babyWhale);
   207     babyWhale.phi++;
   208 }
   209 
   210 void
   211 Atlantis_Key(unsigned char key, int x, int y)
   212 {
   213     switch (key) {
   214     case 't':
   215     	Timing = !Timing;
   216     break;
   217     case ' ':
   218     	switch(StrMode)
   219     	{
   220 		    case GL_EXTENSIONS:
   221     			StrMode = GL_VENDOR;
   222 		    break;
   223 		    case GL_VENDOR:
   224 		    	StrMode = GL_RENDERER;
   225 		    break;
   226 		    case GL_RENDERER:
   227 		    	StrMode = GL_VERSION;
   228 		    break;
   229 		    case GL_VERSION:
   230 		    	StrMode = GL_EXTENSIONS;
   231 		    break;
   232 		}
   233 	break;
   234     case 27:           /* Esc will quit */
   235         exit(1);
   236     break;
   237     case 's':             		/* "s" start animation */
   238         moving = GL_TRUE;
   239         //glutIdleFunc(Animate);
   240     break;
   241     case 'a':          			/* "a" stop animation */
   242         moving = GL_FALSE;
   243         //glutIdleFunc(NULL);
   244     break;
   245     case '.':          			/* "." will advance frame */
   246         if (!moving) {
   247             Atlantis_Animate();
   248         }
   249     }
   250 }
   251 /*
   252 void Display(void)
   253 {
   254 	static float P123[3] = {-448.94, -203.14, 9499.60};
   255 	static float P124[3] = {-442.64, -185.20, 9528.07};
   256 	static float P125[3] = {-441.07, -148.05, 9528.07};
   257 	static float P126[3] = {-443.43, -128.84, 9499.60};
   258 	static float P127[3] = {-456.87, -146.78, 9466.67};
   259 	static float P128[3] = {-453.68, -183.93, 9466.67};
   260 
   261 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   262 	
   263 	glPushMatrix();
   264     FishTransform(&dolph);
   265     DrawDolphin(&dolph);
   266     glPopMatrix();
   267  
   268 	glutSwapBuffers();
   269 }
   270 */
   271 
   272 void
   273 Atlantis_Display(void)
   274 {
   275     int i;
   276     static double th[4] = {0.0, 0.0, 0.0, 0.0};
   277 	static double t1 = 0.0, t2 = 0.0, t;
   278 	char num_str[128];
   279     
   280     t1 = t2;
   281 
   282     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   283 
   284     for (i = 0; i < NUM_SHARKS; i++) {
   285         glPushMatrix();
   286         FishTransform(&sharks[i]);
   287         DrawShark(&sharks[i]);
   288         glPopMatrix();
   289     }
   290 
   291     glPushMatrix();
   292     FishTransform(&dolph);
   293     DrawDolphin(&dolph);
   294     glPopMatrix();
   295 
   296     glPushMatrix();
   297     FishTransform(&momWhale);
   298     DrawWhale(&momWhale);
   299     glPopMatrix();
   300 
   301     glPushMatrix();
   302     FishTransform(&babyWhale);
   303     glScalef(0.45, 0.45, 0.3);
   304     DrawWhale(&babyWhale);
   305     glPopMatrix();
   306     
   307     if(Timing)
   308     {
   309 		t2 = mtime();
   310 		t = t2 - t1;
   311 		if(t > 0.0001) t = 1.0 / t;
   312 		
   313 		glDisable(GL_LIGHTING);
   314 		//glDisable(GL_DEPTH_TEST);
   315 		
   316 		glColor3f(1.0, 0.0, 0.0);
   317 		
   318 		glMatrixMode (GL_PROJECTION);
   319 		glPushMatrix();
   320 		glLoadIdentity();
   321 		glOrtho(0, w_win, 0, h_win, -10.0, 10.0);
   322 		
   323 		glRasterPos2f(5.0, 5.0);
   324 		
   325 		switch(StrMode)
   326 		{
   327 			case GL_VENDOR:
   328 				sprintf(num_str, "%0.2f Hz, %dx%d, VENDOR: ", filter(t, th), w_win, h_win);
   329 				DrawStr(num_str);
   330 				DrawStr(glGetString(GL_VENDOR));
   331 			break;
   332 			case GL_RENDERER:
   333 				sprintf(num_str, "%0.2f Hz, %dx%d, RENDERER: ", filter(t, th), w_win, h_win);
   334 				DrawStr(num_str);
   335 				DrawStr(glGetString(GL_RENDERER));
   336 			break;
   337 			case GL_VERSION:
   338 				sprintf(num_str, "%0.2f Hz, %dx%d, VERSION: ", filter(t, th), w_win, h_win);
   339 				DrawStr(num_str);
   340 				DrawStr(glGetString(GL_VERSION));
   341 			break;
   342 			case GL_EXTENSIONS:
   343 				sprintf(num_str, "%0.2f Hz, %dx%d, EXTENSIONS: ", filter(t, th), w_win, h_win);
   344 				DrawStr(num_str);
   345 				DrawStr(glGetString(GL_EXTENSIONS));
   346 			break;
   347 		}
   348 		
   349 		glPopMatrix();
   350 		glMatrixMode(GL_MODELVIEW);
   351 		
   352 		glEnable(GL_LIGHTING);
   353 		//glEnable(GL_DEPTH_TEST);
   354 	}
   355 	
   356     count++;
   357 
   358     glutSwapBuffers();
   359 }
   360 
   361 /*
   362 void
   363 Visible(int state)
   364 {
   365     if (state == GLUT_VISIBLE) {
   366         if (moving)
   367             glutIdleFunc(Animate);
   368     } else {
   369         if (moving)
   370             glutIdleFunc(NULL);
   371     }
   372 }
   373 
   374 
   375 void
   376 timingSelect(int value)
   377 {
   378     switch(value)
   379     {
   380 		case 1:
   381 			StrMode = GL_VENDOR;
   382 		break;
   383 		case 2:
   384 			StrMode = GL_RENDERER;
   385 		break;
   386 		case 3:
   387 			StrMode = GL_VERSION;
   388 		break;
   389 		case 4:
   390 			StrMode = GL_EXTENSIONS;
   391 		break;
   392     }
   393 }
   394 
   395 void
   396 menuSelect(int value)
   397 {
   398     switch (value) {
   399     case 1:
   400         moving = GL_TRUE;
   401         glutIdleFunc(Animate);
   402         break;
   403     case 2:
   404         moving = GL_FALSE;
   405         glutIdleFunc(NULL);
   406         break;
   407     case 4:
   408         exit(0);
   409         break;
   410     }
   411 }
   412 
   413 int
   414 main(int argc, char **argv)
   415 {
   416 	GLboolean fullscreen = GL_FALSE; 
   417 	GLint time_menu;
   418  	
   419  	srand(0);
   420 
   421         glutInit(&argc, argv);
   422 	if (argc > 1 && !strcmp(argv[1], "-w"))
   423 		fullscreen = GL_FALSE;
   424 
   425 	//glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
   426 	glutInitDisplayString("rgba double depth=24");
   427 	if (fullscreen) {
   428 	  glutGameModeString("1024x768:32");
   429 	  glutEnterGameMode();
   430 	} else {
   431 	  glutInitWindowSize(320, 240);
   432 	  glutCreateWindow("Atlantis Timing");
   433 	}
   434     Init();
   435     glutDisplayFunc(Display);
   436     glutReshapeFunc(Reshape);
   437     glutKeyboardFunc(Key);
   438     moving = GL_TRUE;
   439 glutIdleFunc(Animate);
   440     glutVisibilityFunc(Visible);
   441     
   442     time_menu = glutCreateMenu(timingSelect);
   443     glutAddMenuEntry("GL_VENDOR", 1);
   444     glutAddMenuEntry("GL_RENDERER", 2);
   445     glutAddMenuEntry("GL_VERSION", 3);
   446     glutAddMenuEntry("GL_EXTENSIONS", 4);
   447     
   448     glutCreateMenu(menuSelect);
   449     glutAddMenuEntry("Start motion", 1);
   450     glutAddMenuEntry("Stop motion", 2);
   451     glutAddSubMenu("Timing Mode", time_menu);
   452     glutAddMenuEntry("Quit", 4);
   453     
   454     //glutAttachMenu(GLUT_RIGHT_BUTTON);
   455     glutAttachMenu(GLUT_RIGHT_BUTTON);
   456     glutMainLoop();
   457     return 0;             // ANSI C requires main to return int.
   458 }
   459 */