1 /*
2 Copyright (C) 2000/2002 Xavier Hosxe <xhosxe@free.fr>
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19
20 #include <string.h>
21
22 #include "SDL.h"
23
24 #include "scene.hpp"
25 #include "variables.hpp"
26 #include "listsprite.hpp"
27
28 #include "myship.hpp"
29 #include "cube.hpp"
30 #include "diamond.hpp"
31 #include "ship1.hpp"
32 #include "bandit2.hpp"
33 #include "fighter2.hpp"
34 #include "spirale.hpp"
35 #include "piege.hpp"
36 #include "tank.hpp"
37 #include "tache.hpp"
38
39
40 #ifdef WIN32
41 #else
42 // #define GLX_GLXEXT_LEGACY
43 #define GLX_GLXEXT_PROTOTYPES 1
44 #include <GL/glx.h>
45 // #include <GL/glxext.h>
46 #endif
47
48
49
50 // To know if a key has just be pressed
51 extern bool bKeyDown;
52
53
54 PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV;
55 PFNGLCOMBINERINPUTNVPROC glCombinerInputNV;
56 PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV;
57 PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV;
58 PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV;
59
60
61 PFNGLBINDPROGRAMNVPROC glBindProgramNV;
62 PFNGLLOADPROGRAMNVPROC glLoadProgramNV;
63 PFNGLTRACKMATRIXNVPROC glTrackMatrixNV;
64 PFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV;
65
66 #ifdef WIN32
67 PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
68 PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB;
69 #endif
70
71 GLenum glError;
72
73
74
75 /*
76 GLfloat light_pos[] = { 10, 20, 10, 0 };
77
78
79 GLfloat shadowMatrix[] = { light_pos[1],0,0,0, -light_pos[0],0,
80 -light_pos[2],-1,0,0,light_pos[1],0,0,
81 0,0,light_pos[1]};
82 */
83 float camX, camY, camZ;
84
85
drawText(float x,float y,float z,char * text,float size,float r,float g,float b)86 void drawText(float x, float y, float z,char *text, float size, float r, float g, float b) {
87 int strLenth = strlen(text);
88 char letter;
89 glPushMatrix();
90 glBindTexture(GL_TEXTURE_2D,GLvar->texture_letters);
91
92 glTranslatef(x,y,z);
93 for (int i=0; i<strLenth; i++) {
94 letter = text[i];
95
96 if (letter==32) {
97 glTranslatef(size/700,0,0) ;
98 } else
99 if (letter>=65 && letter<=90) {
100 glBegin(GL_QUADS) ;
101 {
102 glColor4f(r,g,b,1);
103 glTexCoord2f(.03125*(letter-65), .0625);
104 glVertex3f(0,0,0);
105 glTexCoord2f(.03125*(letter-64), .0625);
106 glVertex3f(size/700,0,0);
107 glColor4f(1,1,1,1);
108 glTexCoord2f(.03125*(letter-64), 0);
109 glVertex3f(size/700,size/300,0);
110 glTexCoord2f(.03125*(letter-65), 0);
111 glVertex3f(0,size/300,0);
112 }
113 glEnd();
114 glTranslatef(size/700,0,0) ;
115 } else
116 if (letter>=97 && letter<=122) {
117 glBegin(GL_QUADS) ;
118 {
119 glColor4f(r,g,b,1);
120 glTexCoord2f(.03125*(letter-97), .125);
121 glVertex3f(0,0,0);
122 glTexCoord2f(.03125*(letter-96), .125);
123 glVertex3f(size/700,0,0);
124 glColor4f(.9,.9,1,1);
125 glTexCoord2f(.03125*(letter-96), 0.0625);
126
127 glVertex3f(size/700,size/300,0);
128 glTexCoord2f(.03125*(letter-97), 0.0625);
129 glVertex3f(0,size/300,0);
130 }
131 glEnd();
132 glTranslatef(size/700,0,0) ;
133 } else
134 if (letter>=48 && letter<=57) {
135 glBegin(GL_QUADS) ;
136 {
137 glColor4f(r,g,b,1);
138 glTexCoord2f(.03125*(letter-48), .1875);
139 glVertex3f(0,0,0);
140 glTexCoord2f(.03125*(letter-47), .1875);
141 glVertex3f(size/700,0,0);
142 glColor4f(.9,.9,1,1);
143 glTexCoord2f(.03125*(letter-47), 0.125);
144
145 glVertex3f(size/700,size/300,0);
146 glTexCoord2f(.03125*(letter-48), 0.125);
147 glVertex3f(0,size/300,0);
148 }
149 glEnd();
150 glTranslatef(size/700,0,0) ;
151 } else
152 if (letter==':') {
153 glBegin(GL_QUADS) ;
154 {
155 glColor4f(r,g,b,1);
156 glTexCoord2f(.03125*13, .1875);
157 glVertex2f(0,0);
158 glTexCoord2f(.03125*12, .1875);
159 glVertex2f(size/700,0);
160 glColor4f(.9,.9,1,1);
161 glTexCoord2f(.03125*12, 0.125);
162
163 glVertex2f(size/700,size/300);
164 glTexCoord2f(.03125*13, 0.125);
165 glVertex2f(0,size/300);
166 }
167 glEnd();
168 glTranslatef(size/700,0,0) ;
169 }else
170 if (letter=='!') {
171 glBegin(GL_QUADS) ;
172 {
173 glColor4f(r,g,b,1);
174 glTexCoord2f(.03125*14, .1875);
175 glVertex2f(0,0);
176 glTexCoord2f(.03125*13, .1875);
177 glVertex2f(size/700,0);
178 glColor4f(.9,.9,1,1);
179 glTexCoord2f(.03125*13, 0.125);
180
181 glVertex2f(size/700,size/300);
182 glTexCoord2f(.03125*14, 0.125);
183 glVertex2f(0,size/300);
184 }
185 glEnd();
186 glTranslatef(size/700,0,0) ;
187 }else
188 if (letter=='.') {
189 glBegin(GL_QUADS) ;
190 {
191 glColor4f(r,g,b,1);
192 glTexCoord2f(.03125*16, .1875);
193 glVertex2f(0,0);
194 glTexCoord2f(.03125*15, .1875);
195 glVertex2f(size/700,0);
196 glColor4f(.9,.9,1,1);
197 glTexCoord2f(.03125*15, 0.125);
198
199 glVertex2f(size/700,size/300);
200 glTexCoord2f(.03125*16, 0.125);
201 glVertex2f(0,size/300);
202 }
203 glEnd();
204 glTranslatef(size/700,0,0) ;
205 }else
206 if (letter=='/') {
207 glBegin(GL_QUADS) ;
208 {
209 glColor4f(r,g,b,1);
210 glTexCoord2f(.03125*17, .1875);
211 glVertex2f(0,0);
212 glTexCoord2f(.03125*16, .1875);
213 glVertex2f(size/700,0);
214 glColor4f(.9,.9,1,1);
215 glTexCoord2f(.03125*16, 0.125);
216
217 glVertex2f(size/700,size/300);
218 glTexCoord2f(.03125*17, 0.125);
219 glVertex2f(0,size/300);
220 }
221 glEnd();
222 glTranslatef(size/700,0,0) ;
223 } else {
224 printf("letter To add '%c' : %d\n", letter, (int)letter);
225 }
226
227 }
228 glPopMatrix();
229 }
230
drawText(float x,float y,float z,char * text,float size)231 void drawText(float x, float y, float z,char *text, float size) {
232 drawText( x, y, z, text, size, .3,.3,1) ;
233 }
234
235 /*
236 * getScene()
237 *
238 * get the singleton
239 */
240
241
getScene()242 Scene* Scene::getScene() {
243 if (scene==NULL) {
244 scene = new Scene();
245 }
246 return scene;
247 }
248
Scene()249 Scene::Scene() {
250 initVariables();
251 }
252
253
initVariables()254 void Scene::initVariables() {
255 int i,j,k;
256 nStars = STARS;
257 for (i=0;i<nStars;i++)
258 {
259 stars[i][3] = (float)(random()%1400)/10.0-70;
260 stars[i][4] = (float)(random()%600)/4.0-100;
261 stars[i][5] = 90.0;
262 stars[i][0] = stars[i][1] = stars[i][2] = (float)(random()%750)/1000.0 +.25;
263 }
264 globalScore=-1;
265 lasttime = glutGet((GLenum)GLUT_ELAPSED_TIME);
266 displayFPS=0;
267 globalList = new ListSprite();
268 floorOffset =0;
269 floorScrollOffset =0;
270
271 aFloor = new int[6*16];
272 aFloorMap = new int[6*16];
273 for (i=0; i<6*15;i++) {
274 aFloor[i]=random()%5;
275 aFloorMap[i]=random()%5;
276 }
277
278
279 }
280
281 /*
282 * static void drawSky
283 *
284 * Draw the Pictures & the stars
285 */
286
drawSky()287 void Scene::drawSky()
288 {
289
290 glDisable(GL_FOG);
291 glDisable(GL_LIGHTING);
292 glDisable(GL_TEXTURE_2D);
293
294 int tmpStars = nStars / (3-GLvar->details);
295 int st = random()%tmpStars;
296 stars[st][0] = stars[st][1] = stars[st][2] = (float)(random()%750)/1000.0 +.25;
297 glInterleavedArrays(GL_C3F_V3F,0,stars);
298 glDrawArrays(GL_POINTS, 0, tmpStars);
299
300 if (GLvar->details!=0) {
301 // glMaterialfv(GL_FRONT,GL_DIFFUSE,blanc_diffuse);
302 glColor4fv(GLvar->blanc_diffuse);
303 glEnable(GL_TEXTURE_2D);
304 glEnable(GL_BLEND);
305 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
306
307 for (int i=0; i<SPACE; i++) {
308 glBindTexture(GL_TEXTURE_2D, GLvar->texture_space[i]);
309 glBegin(GL_QUADS);
310 glTexCoord2f(0,0);
311 glVertex3f(GLvar->pos_space[0+i*5],GLvar->pos_space[1+i*5],GLvar->pos_space[4+i*5]);
312 glTexCoord2f(0,1);
313 glVertex3f(GLvar->pos_space[0+i*5],GLvar->pos_space[3+i*5],GLvar->pos_space[4+i*5]);
314 glTexCoord2f(1,1);
315 glVertex3f(GLvar->pos_space[2+i*5],GLvar->pos_space[3+i*5],GLvar->pos_space[4+i*5]);
316 glTexCoord2f(1,0);
317 glVertex3f(GLvar->pos_space[2+i*5],GLvar->pos_space[1+i*5],GLvar->pos_space[4+i*5]);
318 glEnd();
319 }
320 }
321
322 glEnable(GL_FOG);
323 glDisable(GL_BLEND);
324 glEnable(GL_LIGHTING);
325 }
326
327 /*
328 * static void drawFloor
329 *
330 * Draw and scroll the floor
331 */
332
333
getDirection(float x,float y,float z)334 float* getDirection(float x, float y, float z) {
335 static float *fReturn = NULL;
336
337 if (fReturn==NULL) fReturn = new float[3];
338
339 float py = 2;
340 float px, pz;
341 if ( GLvar->mySpaceShip!=NULL) {
342 px = GLvar->mySpaceShip->getX();
343 pz = GLvar->mySpaceShip->getZ();
344 } else {
345 px = 0;
346 pz = 23;
347 }
348
349 fReturn[0] = x-px;
350 fReturn[2] = py-y;
351 fReturn[1] = pz-z;
352
353 float size = sqrt(fReturn[0]*fReturn[0] +fReturn[1]*fReturn[1] +fReturn[2]*fReturn[2]) ;
354 // printf("Size = %f\n", size);
355
356 fReturn[0] /= size;
357 fReturn[1] /= size;
358 fReturn[2] /= size;
359 // printf("%f, %f, %f ====> %f, %f, %f\n",x,y,z, fReturn[0],fReturn[1],fReturn[2]);
360
361 fReturn[0] /= 2;
362 fReturn[1] /= 2;
363 fReturn[2] /= 2;
364 fReturn[0] +=.5;
365 fReturn[1] +=.5;
366 fReturn[2] +=.5;
367
368
369 return fReturn;
370 }
371
372
drawSolidFloor()373 void Scene::drawSolidFloor() {
374
375 }
376
drawFloor()377 void Scene::drawFloor()
378 {
379 static float dot3LightX = 0;
380 static float cpt=0;
381 static float halfMul[] = {.5, .5 , .5,0};
382 static float halfAdd[] = {.5,.5,.5,0};
383 int texture ;
384 int textureMap;
385 int i;
386
387 glLightfv(GL_LIGHT0, GL_SPECULAR, GLvar->nothing);
388
389 floorScrollOffset +=.1* GLvar->global_timeadjustment;
390 if (floorScrollOffset>=5) {
391 int lineToChange = floorOffset;
392 floorScrollOffset=(floorScrollOffset-5);
393 floorOffset = (floorOffset+1)%15;
394 for (i=0; i<6;i++) {
395 aFloor[lineToChange*6+i]=random()%5;
396 aFloorMap[lineToChange*6+i]=(random()%5);
397 }
398 }
399
400
401 glMaterialfv(GL_FRONT,GL_DIFFUSE,GLvar->blanc_diffuse);
402 glColor4fv(GLvar->blanc_diffuse);
403 glEnable(GL_BLEND);
404 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
405 glNormal3f(0,1,0);
406 /*
407 glEnable(GL_ALPHA_TEST);
408 glAlphaFunc(GL_GREATER, .15);
409 */
410 float vertexX,vertexZ, vertexY;
411 #if defined( GL_REGISTER_COMBINERS_NV) && defined(GL_VERTEX_PROGRAM_NV)
412 if (GLvar->bNVExtension && GLvar->details!=0) {
413 glEnable(GL_LIGHTING);
414 glActiveTextureARB(GL_TEXTURE1_ARB);
415 glEnable(GL_TEXTURE_2D);
416 glActiveTextureARB(GL_TEXTURE0_ARB);
417 glEnable(GL_TEXTURE_2D);
418 glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV,halfMul);
419 glCombinerParameterfvNV(GL_CONSTANT_COLOR1_NV,halfAdd);
420
421
422 if (GLvar->m_nRegisterCombiners>2) {
423 glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV,3);
424 glCombinerInputNV(GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
425 glCombinerInputNV(GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_B_NV, GL_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
426 glCombinerOutputNV(GL_COMBINER2_NV, GL_RGB, GL_SECONDARY_COLOR_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
427 } else {
428 glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV,2);
429 }
430
431 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_EXPAND_NORMAL_NV, GL_RGB);
432 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_TEXTURE1_ARB, GL_EXPAND_NORMAL_NV, GL_RGB);
433 glCombinerOutputNV(GL_COMBINER0_NV, GL_RGB, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE , GL_TRUE, GL_FALSE, GL_FALSE);
434
435
436 glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE0_NV, GL_SIGNED_IDENTITY_NV, GL_RGB);
437 glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV, GL_SIGNED_IDENTITY_NV, GL_RGB);
438 glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
439 glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_D_NV, GL_CONSTANT_COLOR1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
440 glCombinerOutputNV(GL_COMBINER1_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
441
442 glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_FOG, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
443 glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_E_TIMES_F_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
444 glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
445
446 glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
447
448 glFinalCombinerInputNV(GL_VARIABLE_E_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
449 glFinalCombinerInputNV(GL_VARIABLE_F_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
450
451 glFinalCombinerInputNV(GL_VARIABLE_G_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
452
453
454 glEnable(GL_REGISTER_COMBINERS_NV);
455
456 glEnable(GL_VERTEX_PROGRAM_NV);
457 glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1);
458
459
460
461 for (i=0; i<15; i++) {
462 for (int j=-3;j<3;j++) {
463
464 texture = aFloor[((i+floorOffset)%15)*6+j+3];
465 textureMap = aFloorMap[((i+floorOffset)%15)*6+j+3];
466
467 glActiveTextureARB(GL_TEXTURE1_ARB);
468 glBindTexture(GL_TEXTURE_2D, GLvar->texture_floorMap[textureMap]);
469 glActiveTextureARB(GL_TEXTURE0_ARB);
470 glBindTexture(GL_TEXTURE_2D, GLvar->texture_floor[texture]);
471
472 glBegin(GL_QUADS);
473
474 vertexX = j*3.5;
475 vertexZ = (i+1)*5-floorScrollOffset;
476 vertexY = 0;
477 glTexCoord2f(1,1);
478 glVertex3f(vertexX, vertexY , vertexZ);
479
480 vertexX = j*3.5+3.5;
481 vertexZ = (i+1)*5-floorScrollOffset;
482 glTexCoord2f(0,1);
483 vertexY = 0;
484 glVertex3f(vertexX, vertexY , vertexZ);
485
486 vertexX = j*3.5+3.5;
487 vertexZ = i*5-floorScrollOffset;
488 vertexY = 0;
489 glTexCoord2f(0,0);
490 glVertex3f(vertexX, vertexY , vertexZ);
491
492 vertexX = j*3.5;
493 vertexZ = i*5-floorScrollOffset;
494 vertexY = 0;
495 glTexCoord2f(1,0);
496 glVertex3f(vertexX, vertexY , vertexZ);
497
498 glEnd();
499
500 }
501 }
502
503
504 glActiveTextureARB(GL_TEXTURE1_ARB);
505 glBindTexture(GL_TEXTURE_2D, GLvar->texture_floorMap[1]);
506 glActiveTextureARB(GL_TEXTURE0_ARB);
507
508
509 glBindTexture(GL_TEXTURE_2D, GLvar->texture_border);
510 glBegin(GL_QUADS);
511 for (i=0; i<15; i++) {
512 int j=-4;
513 vertexX = j*3.5+2;
514 vertexZ = (i+1)*5-floorScrollOffset;
515 vertexY = 0;
516 glTexCoord2f(.5,1);
517 glVertex3f(vertexX, vertexY , vertexZ);
518
519 vertexX = j*3.5+3.5;
520 vertexZ = (i+1)*5-floorScrollOffset;
521 glTexCoord2f(.99,1);
522 vertexY = 0;
523 glVertex3f(vertexX, vertexY , vertexZ);
524
525 vertexX = j*3.5+3.5;
526 vertexZ = i*5-floorScrollOffset;
527 vertexY = 0;
528 glTexCoord2f(.99,0);
529 glVertex3f(vertexX, vertexY , vertexZ);
530
531 vertexX = j*3.5+2;
532 vertexZ = i*5-floorScrollOffset;
533 vertexY = 0;
534 glTexCoord2f(0.5,0);
535 glVertex3f(vertexX, vertexY , vertexZ);
536
537
538 j=3 ;
539 vertexX = j*3.5;
540 vertexZ = (i+1)*5-floorScrollOffset;
541 vertexY = 0;
542 glTexCoord2f(.99,1);
543 glVertex3f(vertexX, vertexY , vertexZ);
544
545 vertexX = j*3.5+2;
546 vertexZ = (i+1)*5-floorScrollOffset;
547 glTexCoord2f(0.5,1);
548 vertexY = 0;
549 glVertex3f(vertexX, vertexY , vertexZ);
550
551 vertexX = j*3.5+2;
552 vertexZ = i*5-floorScrollOffset;
553 vertexY = 0;
554 glTexCoord2f(0.5,0);
555 glVertex3f(vertexX, vertexY , vertexZ);
556
557 vertexX = j*3.5;
558 vertexZ = i*5-floorScrollOffset;
559 vertexY = 0;
560 glTexCoord2f(.99,0);
561 glVertex3f(vertexX, vertexY , vertexZ);
562
563
564 }
565 glEnd();
566
567
568
569 glActiveTextureARB(GL_TEXTURE1_ARB);
570 glDisable(GL_TEXTURE_2D);
571 glDisable(GL_VERTEX_PROGRAM_NV);
572 glDisable(GL_REGISTER_COMBINERS_NV);
573 glActiveTextureARB(GL_TEXTURE0_ARB);
574
575 } else
576 #endif
577 if (GLvar->bEXTEnvDot3 && GLvar->details!=0) {
578 static float interpolateCoef[] = { .55,.55,.55,.55 };
579 int oldFloor = 0;
580 int oldFloorMap = 0;
581
582 glDisable(GL_LIGHTING);
583 glActiveTextureARB(GL_TEXTURE0_ARB);
584 glEnable(GL_TEXTURE_2D);
585 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
586 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_DOT3_RGB_EXT);
587 glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
588 glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT);
589
590 glActiveTextureARB(GL_TEXTURE1_ARB);
591 glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, interpolateCoef);
592 glEnable(GL_TEXTURE_2D);
593 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
594 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_INTERPOLATE_EXT);
595 glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
596 glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);
597 glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_CONSTANT_EXT);
598 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
599 glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
600
601
602 for (i=0; i<15; i++) {
603 for (int j=-3;j<3;j++) {
604
605 texture = aFloor[((i+floorOffset)%15)*6+j+3];
606 textureMap = aFloorMap[((i+floorOffset)%15)*6+j+3];
607
608 if (GLvar->texture_floorMap[textureMap]!=oldFloorMap) {
609 oldFloorMap = GLvar->texture_floorMap[textureMap];
610 glActiveTextureARB(GL_TEXTURE0_ARB);
611 glBindTexture(GL_TEXTURE_2D, oldFloorMap);
612 }
613
614 if (GLvar->texture_floorMap[texture]!=oldFloor) {
615 oldFloor = GLvar->texture_floor[texture];
616 glActiveTextureARB(GL_TEXTURE1_ARB);
617 glBindTexture(GL_TEXTURE_2D, oldFloor);
618 }
619
620
621 glBegin(GL_QUADS);
622
623 vertexX = j*3.5;
624 vertexZ = (i+1)*5-floorScrollOffset;
625 vertexY = 0;
626 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1,1);
627 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,1,1);
628 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
629 glVertex3f(vertexX, vertexY , vertexZ);
630
631 vertexX = j*3.5+3.5;
632 vertexZ = (i+1)*5-floorScrollOffset;
633 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,1);
634 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,1);
635 vertexY = 0;
636 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
637 glVertex3f(vertexX, vertexY , vertexZ);
638
639 vertexX = j*3.5+3.5;
640 vertexZ = i*5-floorScrollOffset;
641 vertexY = 0;
642 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,0);
643 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,0);
644 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
645 glVertex3f(vertexX, vertexY , vertexZ);
646
647 vertexX = j*3.5;
648 vertexZ = i*5-floorScrollOffset;
649 vertexY = 0;
650 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1,0);
651 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,1,0);
652 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
653 glVertex3f(vertexX, vertexY , vertexZ);
654
655 glEnd();
656 }
657 }
658
659 glActiveTextureARB(GL_TEXTURE0_ARB);
660 glBindTexture(GL_TEXTURE_2D, GLvar->texture_floorMap[1]);
661 glActiveTextureARB(GL_TEXTURE1_ARB);
662 glBindTexture(GL_TEXTURE_2D, GLvar->texture_border);
663
664 glBegin(GL_QUADS);
665 for (i=0; i<15; i++) {
666 int j=-4;
667 vertexX = j*3.5+2;
668 vertexZ = (i+1)*5-floorScrollOffset;
669 vertexY = 0;
670 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,.5,1);
671 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,.5,1);
672 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
673 glVertex3f(vertexX, vertexY , vertexZ);
674
675 vertexX = j*3.5+3.5;
676 vertexZ = (i+1)*5-floorScrollOffset;
677 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0.99,1);
678 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0.99,1);
679 vertexY = 0;
680 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
681 glVertex3f(vertexX, vertexY , vertexZ);
682
683 vertexX = j*3.5+3.5;
684 vertexZ = i*5-floorScrollOffset;
685 vertexY = 0;
686 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0.99,0);
687 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0.99,0);
688 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
689 glVertex3f(vertexX, vertexY , vertexZ);
690
691 vertexX = j*3.5+2;
692 vertexZ = i*5-floorScrollOffset;
693 vertexY = 0;
694 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,.5,0);
695 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,.5,0);
696 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
697 glVertex3f(vertexX, vertexY , vertexZ);
698
699
700 j=3 ;
701 vertexX = j*3.5;
702 vertexZ = (i+1)*5-floorScrollOffset;
703 vertexY = 0;
704 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0.99,1);
705 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0.99,1);
706 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
707 glVertex3f(vertexX, vertexY , vertexZ);
708
709 vertexX = j*3.5+2;
710 vertexZ = (i+1)*5-floorScrollOffset;
711 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,.5,1);
712 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,.5,1);
713 vertexY = 0;
714 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
715 glVertex3f(vertexX, vertexY , vertexZ);
716
717 vertexX = j*3.5+2;
718 vertexZ = i*5-floorScrollOffset;
719 vertexY = 0;
720 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,.5,0);
721 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,.5,0);
722 glTexCoord2f(0.5,0);
723 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
724 glVertex3f(vertexX, vertexY , vertexZ);
725
726 vertexX = j*3.5;
727 vertexZ = i*5-floorScrollOffset;
728 vertexY = 0;
729 glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0.99,0);
730 glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0.99,0);
731 glColor3fv(getDirection(vertexX, vertexY, vertexZ));
732 glVertex3f(vertexX, vertexY , vertexZ);
733 }
734 glEnd();
735
736
737 glActiveTextureARB(GL_TEXTURE1_ARB);
738 glDisable(GL_TEXTURE_2D);
739 glActiveTextureARB(GL_TEXTURE0_ARB);
740 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
741
742 } else {
743
744 // BASIC OPENGL RENDERING
745
746 glEnable(GL_LIGHTING);
747 glEnable(GL_TEXTURE_2D);
748
749 for (i=0; i<15; i++) {
750 for (int j=-3;j<3;j++) {
751
752 texture = aFloor[((i+floorOffset)%15)*6+j+3];
753 textureMap = aFloorMap[((i+floorOffset)%15)*6+j+3];
754
755 glBindTexture(GL_TEXTURE_2D, GLvar->texture_floor[texture]);
756
757 glBegin(GL_QUADS);
758
759 vertexX = j*3.5;
760 vertexZ = (i+1)*5-floorScrollOffset;
761 vertexY = 0;
762 glTexCoord2f(1,1);
763 glVertex3f(vertexX, vertexY , vertexZ);
764
765 vertexX = j*3.5+3.5;
766 vertexZ = (i+1)*5-floorScrollOffset;
767 glTexCoord2f(0,1);
768 vertexY = 0;
769 glVertex3f(vertexX, vertexY , vertexZ);
770
771 vertexX = j*3.5+3.5;
772 vertexZ = i*5-floorScrollOffset;
773 vertexY = 0;
774 glTexCoord2f(0,0);
775 glVertex3f(vertexX, vertexY , vertexZ);
776
777 vertexX = j*3.5;
778 vertexZ = i*5-floorScrollOffset;
779 vertexY = 0;
780 glTexCoord2f(1,0);
781 glVertex3f(vertexX, vertexY , vertexZ);
782
783 glEnd();
784
785 }
786
787 }
788
789 glBindTexture(GL_TEXTURE_2D, GLvar->texture_border);
790 glBegin(GL_QUADS);
791 for (i=0; i<15; i++) {
792 int j=-4;
793 vertexX = j*3.5+2;
794 vertexZ = (i+1)*5-floorScrollOffset;
795 vertexY = 0;
796 glTexCoord2f(.5,1);
797 glVertex3f(vertexX, vertexY , vertexZ);
798
799 vertexX = j*3.5+3.5;
800 vertexZ = (i+1)*5-floorScrollOffset;
801 glTexCoord2f(.99,1);
802 vertexY = 0;
803 glVertex3f(vertexX, vertexY , vertexZ);
804
805 vertexX = j*3.5+3.5;
806 vertexZ = i*5-floorScrollOffset;
807 vertexY = 0;
808 glTexCoord2f(.99,0);
809 glVertex3f(vertexX, vertexY , vertexZ);
810
811 vertexX = j*3.5+2;
812 vertexZ = i*5-floorScrollOffset;
813 vertexY = 0;
814 glTexCoord2f(0.5,0);
815 glVertex3f(vertexX, vertexY , vertexZ);
816
817
818 j=3 ;
819 vertexX = j*3.5;
820 vertexZ = (i+1)*5-floorScrollOffset;
821 vertexY = 0;
822 glTexCoord2f(.99,1);
823 glVertex3f(vertexX, vertexY , vertexZ);
824
825 vertexX = j*3.5+2;
826 vertexZ = (i+1)*5-floorScrollOffset;
827 glTexCoord2f(0.5,1);
828 vertexY = 0;
829 glVertex3f(vertexX, vertexY , vertexZ);
830
831 vertexX = j*3.5+2;
832 vertexZ = i*5-floorScrollOffset;
833 vertexY = 0;
834 glTexCoord2f(0.5,0);
835 glVertex3f(vertexX, vertexY , vertexZ);
836
837 vertexX = j*3.5;
838 vertexZ = i*5-floorScrollOffset;
839 vertexY = 0;
840 glTexCoord2f(.99,0);
841 glVertex3f(vertexX, vertexY , vertexZ);
842
843
844 }
845 glEnd();
846
847 glDisable(GL_TEXTURE_2D);
848
849 }
850
851 glDisable(GL_ALPHA_TEST);
852
853 glDisable(GL_TEXTURE_2D);
854 glLightfv(GL_LIGHT0, GL_SPECULAR, GLvar->blanc_diffuse);
855 glDisable(GL_BLEND);
856 }
857
858 /*
859 * static void drawPlayers
860 *
861 * Draw everything concerning the player
862 */
863
864
drawPlayers()865 void Scene::drawPlayers()
866 {
867 static int oldPower=-1;
868 static int oldPowerMax=-1;
869 static int oldBomb=-1;
870 int i;
871 static char stBomb[] ="x 5 ";
872 static char stScore[]= "00000000";
873 #ifdef GLAX_VERSION
874 static char stVersion[] = "Glaxium "GLAX_VERSION;
875 #endif
876 static float powerRatio;
877
878
879 glDepthMask(GL_FALSE);
880 glMatrixMode(GL_PROJECTION);
881 glLoadIdentity();
882 glOrtho(0.0f, (GLfloat) GLvar->width, 0.0f, (GLfloat) GLvar->height, -1.0f, 1.0f);
883
884 glMatrixMode(GL_MODELVIEW);
885 glLoadIdentity();
886
887 // glMaterialfv(GL_FRONT,GL_AMBIENT, GLvar->blanc_diffuse);
888 // glMaterialfv(GL_FRONT,GL_DIFFUSE,GLvar->blanc_diffuse);
889
890 // ====== POWER ===========
891
892
893 glDisable(GL_LIGHTING);
894 glDisable(GL_TEXTURE_2D);
895 glEnable(GL_BLEND);
896 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
897
898 if (GLvar->mySpaceShip!=NULL)
899 {
900 if (oldPower!=((MyShip*)GLvar->mySpaceShip)->getShield())
901 {
902 oldPower=((MyShip*)GLvar->mySpaceShip)->getShield();
903 }
904 if (oldPowerMax!=((MyShip*)GLvar->mySpaceShip)->getShieldMax())
905 {
906 oldPowerMax=((MyShip*)GLvar->mySpaceShip)->getShieldMax();
907 }
908 } else {
909 oldPower=0;
910 }
911 powerRatio =((float)oldPower/oldPowerMax);
912
913 glBegin(GL_QUADS);
914
915 glColor4f(.7,.3,.3,0.8);
916 glVertex2f(GLvar->width*.822,GLvar->height*.845);
917 glVertex2f(GLvar->width*.822,GLvar->height*.815);
918 glColor4f(.7-.4*powerRatio,.3,.3+.4*powerRatio,0.8);
919 glVertex2f(GLvar->width*.822 + GLvar->width * .134*powerRatio,GLvar->height*.815);
920 glVertex2f(GLvar->width*.822 + GLvar->width * .134*powerRatio,GLvar->height*.845);
921 // glColor4f(.5,.5,1,0.6);
922
923 glEnd();
924
925
926
927
928 glEnable(GL_TEXTURE_2D);
929 glBindTexture(GL_TEXTURE_2D,GLvar->texture_board);
930 glColor4f(1,1,1,1);
931
932 glBegin(GL_QUADS);
933 glTexCoord2f(0,0);
934 glVertex2f(GLvar->width*.8,GLvar->height*.98);
935 glTexCoord2f(0,1);
936 glVertex2f(GLvar->width*.8,GLvar->height*.8);
937 glTexCoord2f(1,1);
938 glVertex2f(GLvar->width*.98,GLvar->height*.8);
939 glTexCoord2f(1,0);
940 glVertex2f(GLvar->width*.98,GLvar->height*.98);
941 glEnd();
942
943 glDisable(GL_LIGHTING);
944 glDisable(GL_TEXTURE_2D);
945
946
947
948
949
950
951 // ============= bomb ==============
952
953 glColor4f(1,1,0,0.6);
954
955 glBegin(GL_TRIANGLES);
956 glVertex2f(GLvar->width*.89-22,GLvar->height*.90);
957 glVertex2f(GLvar->width*.89-26,GLvar->height*.885);
958 glVertex2f(GLvar->width*.89-18,GLvar->height*.885);
959 glEnd();
960
961
962
963 // ============ New Partie =============
964
965
966
967 if (GLvar->mySpaceShip==NULL)
968 {
969 glEnable(GL_TEXTURE_2D);
970 glBindTexture(GL_TEXTURE_2D,GLvar->texture_gameover);
971 //glEnable(GL_LIGHTING);
972 glMaterialfv(GL_FRONT,GL_DIFFUSE,GLvar->blanc_diffuse);
973 glEnable(GL_ALPHA_TEST);
974 glAlphaFunc(GL_GEQUAL, 0.3);
975
976 glColor4f(1,1,2,1);
977 glBegin(GL_QUADS);
978 glTexCoord2f(0,0);
979 glVertex2f(GLvar->width/4,3*GLvar->height/4);
980 glTexCoord2f(0,1);
981 glVertex2f(GLvar->width/4,GLvar->height/1.7);
982 glTexCoord2f(1,1);
983 glVertex2f(3*GLvar->width/4,GLvar->height/1.7);
984 glTexCoord2f(1,0);
985 glVertex2f(3*GLvar->width/4,3*GLvar->height/4);
986 glEnd();
987
988 glDisable(GL_ALPHA_TEST);
989 // glDisable(GL_LIGHTING);
990 glDisable(GL_TEXTURE_2D);
991
992 }
993
994 // TEXT
995 glMatrixMode(GL_PROJECTION);
996 glLoadIdentity();
997 glOrtho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
998
999 glDepthFunc(GL_ALWAYS);
1000 glMatrixMode(GL_MODELVIEW);
1001 glLoadIdentity();
1002 glEnable(GL_BLEND);
1003 glEnable(GL_TEXTURE_2D);
1004 glDisable(GL_LIGHTING);
1005
1006 // ========= Score ============
1007
1008 // glColor4f(1,0,0,0.4);
1009
1010 if (GLvar->mySpaceShip!=NULL) {
1011 if (globalScore!=((MyShip*)GLvar->mySpaceShip)->getScore())
1012 {
1013 globalScore=((MyShip*)GLvar->mySpaceShip)->getScore();
1014 sprintf(stScore,"%8.8d",globalScore);
1015 }
1016
1017 if (oldBomb!=((MyShip*)GLvar->mySpaceShip)->getBomb())
1018 {
1019 oldBomb=((MyShip*)GLvar->mySpaceShip)->getBomb();
1020 sprintf(stBomb, "X %d", oldBomb);
1021 }
1022 }
1023
1024 drawText(.832,.91, 0, stScore,10);
1025
1026 drawText(.885,.875, 0, stBomb, 8, 1,1,0);
1027
1028 /*
1029 for(i = 0; stScore[i] != 0; i++){
1030 // glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, stScore[i]);
1031 glBitmap(8,15, 0.0 ,0.0 ,10.0 ,0.0 ,numbers[stScore[i]-48]);
1032 }
1033 */
1034
1035
1036 if (displayFPS) {
1037 drawFPS();
1038 }
1039
1040 glDepthMask(GL_TRUE);
1041 glDepthFunc(GL_LEQUAL);
1042 glDisable(GL_BLEND);
1043 glEnable(GL_LIGHTING);
1044 }
1045
1046
1047 /*
1048 * void drawFPS
1049 *
1050 * Draws FPS in upper left corner of Display d
1051 *
1052 */
1053
drawFPS()1054 void Scene::drawFPS()
1055 {
1056 static char tmp[20]="FPS: 0";
1057 int i;
1058 int diff;
1059 static int fps = 0;
1060 static int cpt =0;
1061
1062
1063 diff = (dt > 0) ? dt : 1;
1064 cpt++;
1065 if (cpt==30)
1066 {
1067 cpt=0;
1068 timediff();
1069 fps = 30000 / dt;
1070
1071 sprintf(tmp, "FPS: %d", fps);
1072 }
1073
1074 drawText(.01,.95, 0,tmp, 10);
1075 }
1076
1077
1078
timediff()1079 void Scene::timediff()
1080 {
1081 int t;
1082
1083 t = glutGet((GLenum)GLUT_ELAPSED_TIME);
1084 dt = t - lasttime;
1085 lasttime = t;
1086 }
1087
toggleDisplayFPS()1088 void Scene::toggleDisplayFPS() {
1089 if (displayFPS)
1090 {
1091 displayFPS=0;
1092 }
1093 else
1094 {
1095 displayFPS=1;
1096 }
1097 }
1098
toggleSpecular()1099 void Scene::toggleSpecular() {
1100 if (bSpecular)
1101 {
1102 bSpecular=false;
1103 glMaterialfv(GL_FRONT, GL_SPECULAR, GLvar->nothing);
1104 glLightfv(GL_LIGHT0, GL_SPECULAR, GLvar->nothing);
1105 }
1106 else
1107 {
1108 bSpecular=true;
1109 glMaterialfv(GL_FRONT, GL_SPECULAR, GLvar->blanc_diffuse);
1110 glLightfv(GL_LIGHT0, GL_SPECULAR, GLvar->blanc_diffuse);
1111
1112 }
1113 }
1114
1115
toggleFog()1116 void Scene::toggleFog() {
1117 if (nFog==1) {
1118 nFog=0;
1119 glFogf(GL_FOG_MODE,GL_EXP2);
1120 glFogf(GL_FOG_DENSITY, .022);
1121 glFogfv(GL_FOG_COLOR,GLvar->nothing);
1122 } else {
1123 nFog=1;
1124 glFogf(GL_FOG_MODE,GL_LINEAR);
1125 glFogf(GL_FOG_START, 35);
1126 glFogf(GL_FOG_END, 65);
1127 glFogfv(GL_FOG_COLOR,GLvar->nothing);
1128 }
1129 }
1130
1131 /*
1132 * void drawPresentation
1133 *
1134 * Draws the first page with the spaceship turning
1135 *
1136 */
1137
1138
1139
drawPresentation()1140 void Scene::drawPresentation() {
1141 int i,j;
1142
1143 glColor4f(0,0,0,1);
1144 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1145
1146 glViewport(0,0,GLvar->width ,GLvar->height);
1147 glMatrixMode(GL_PROJECTION);
1148 glLoadIdentity();
1149 glOrtho(0.0, 1.0 , 0.0, 1.0 , -10.0, 10.0);
1150 glMatrixMode(GL_MODELVIEW);
1151
1152 glLoadIdentity();
1153
1154 glDisable(GL_DEPTH_TEST);
1155 glDisable(GL_BLEND);
1156 glEnable(GL_TEXTURE_2D);
1157 glEnable(GL_LIGHTING);
1158
1159 for (j=0; j<2; j++) {
1160 for (i=0; i<3; i++) {
1161 glBindTexture(GL_TEXTURE_2D, GLvar->texture_title[j*3+i]);
1162
1163 glBegin(GL_QUADS) ;
1164 {
1165 glNormal3f(0,1,0);
1166
1167 glTexCoord2f(0,0);
1168 glVertex3f(0.4*i,1.0-0.5333333*j,5);
1169 glTexCoord2f(0,1);
1170 glVertex3f(0.4*i,1.0-0.5333333*(j+1),5);
1171 glTexCoord2f(1,1);
1172 glVertex3f(0.4*(i+1),1.0-0.5333333*(j+1),5);
1173
1174 glTexCoord2f(1,0);
1175 glVertex3f(0.4*(i+1),1.0-0.5333333*j,5);
1176
1177
1178 }
1179 glEnd();
1180 }
1181 }
1182
1183
1184
1185 glEnable(GL_DEPTH_TEST);
1186 glMatrixMode(GL_PROJECTION);
1187
1188 glLoadIdentity();
1189
1190 gluPerspective(50, 1.333333 , 0.5, 10);
1191 glMatrixMode(GL_MODELVIEW);
1192
1193 glLoadIdentity();
1194 gluLookAt( 0,2.0,-3.6,
1195 0,1.0,0,
1196 0,1.0,0);
1197 glTranslatef(0,.2,0);
1198
1199 glRotatef(GLvar->rotateMyShip,0,1,0);
1200
1201 glBindTexture(GL_TEXTURE_2D, GLvar->texture_myship);
1202 glEnable(GL_TEXTURE_2D);
1203 glMaterialfv(GL_FRONT, GL_DIFFUSE, GLvar->blanc_diffuse);
1204
1205
1206 if (GLvar->bNVExtension)
1207 glCallList(MyShip::list_);
1208 else {
1209 #ifdef GL_SINGLE_COLOR
1210 if (GLvar->bSeparateSpecularColor) {
1211 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
1212 }
1213 #endif
1214 glCallList(MyShip::list_+3);
1215 #ifdef GL_SEPARATE_SPECULAR_COLOR
1216 if (GLvar->bSeparateSpecularColor) {
1217 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1218 }
1219 #endif
1220 }
1221
1222
1223
1224 SDL_GL_SwapBuffers();
1225
1226 if ((glError=glGetError())!=GL_NO_ERROR) {
1227 printf("OpenGL error : %s\n", gluErrorString(glError));
1228 }
1229 }
1230
1231
1232
1233 /*
1234 * void drawGame
1235 *
1236 * Draws all the spaceships.. test the collision etc...
1237 *
1238 */
1239
1240
drawGame()1241 void Scene::drawGame()
1242 {
1243 static float posX,posZ,dposX,dposZ;
1244
1245 if (GLvar->bShadows==true) {
1246 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
1247 } else {
1248 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1249 }
1250
1251 glViewport(0,0,GLvar->width ,GLvar->height);
1252
1253 if (GLvar->mySpaceShip!=NULL)
1254 {
1255 if( posX != GLvar->mySpaceShip->getX())
1256 {
1257 posX = GLvar->mySpaceShip->getX();
1258 }
1259 if( posZ != GLvar->mySpaceShip->getZ())
1260 {
1261 posZ = GLvar->mySpaceShip->getZ();
1262 }
1263 if( dposX != GLvar->mySpaceShip->getDx())
1264 {
1265 dposX = GLvar->mySpaceShip->getDx();
1266 }
1267 if( dposZ != GLvar->mySpaceShip->getDz())
1268 {
1269 dposZ = GLvar->mySpaceShip->getDz();
1270 }
1271
1272 }
1273 else
1274 {
1275 if (posX<-0.01)
1276 {
1277 posX+=.02;
1278 }
1279 else if (posX>0.01)
1280 {
1281 posX-=.02;
1282 }
1283 else
1284 {
1285 posX=0;
1286 }
1287 if (posZ<12)
1288 {
1289 posZ+=.02;
1290 }
1291 }
1292
1293 switch (GLvar->camera)
1294 {
1295 case 1:
1296 glMatrixMode(GL_PROJECTION);
1297 glLoadIdentity();
1298 gluPerspective(50, 1.333333 , 2.0, 160);
1299 // Important part !
1300 glMatrixMode(GL_MODELVIEW);
1301 glLoadIdentity();
1302
1303 camX = posX*.9;
1304 camY = 2.5+posZ/3 ;
1305 camZ = -2;
1306 gluLookAt( posX*.9 , 3+posZ/3 ,-2,
1307 posX, .4 , 7+posZ/2.5 ,
1308 dposX/4, 1-dposX/4, 0);
1309 // glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 11, posX*.9, 2.5+posZ/3 ,-2, 1); // Light direction
1310 break;
1311 case 2:
1312 glMatrixMode(GL_PROJECTION);
1313 glLoadIdentity();
1314 gluPerspective(50, 0.8, 3, 100);
1315 glMatrixMode(GL_MODELVIEW);
1316 glLoadIdentity();
1317 camX = posX*.2;
1318 camY = 36 ;
1319 camZ = 21-(21-posZ)*.2;
1320 gluLookAt(posX*.2 , 36 ,21-(21-posZ)*.2,
1321 posX*.2 , 0, 21-(21-posZ)*.2,
1322 0, 0, 1);
1323 // glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 11, posX*.2 , 36 ,21-(21-posZ)*.2,1); // Light direction
1324 break;
1325 }
1326 // c[8] : Spaceship position
1327 #if defined( GL_REGISTER_COMBINERS_NV) && defined(GL_VERTEX_PROGRAM_NV)
1328 if (glProgramParameter4fNV!=NULL) {
1329 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 8, -posX, 3.5 , posZ, 1);
1330 // c[11] : camera position
1331 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 11, camX, camY, camZ,1);
1332 }
1333 #endif
1334
1335 glPushMatrix();
1336
1337 glColor4f(1.0, 1.0, 1.0 , 1);
1338
1339
1340 drawSky();
1341
1342 if (GLvar->bShadows==true) {
1343
1344 // glDepthMask(GL_FALSE);
1345
1346 glEnable(GL_STENCIL_TEST);
1347 glStencilFunc(GL_ALWAYS, 1,1);
1348 glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
1349
1350 drawFloor();
1351
1352 glDisable(GL_STENCIL_TEST);
1353 glEnable(GL_LIGHTING);
1354 } else {
1355 glEnable(GL_LIGHTING);
1356 drawFloor();
1357 }
1358
1359 glPopMatrix();
1360
1361
1362 globalList->draw();
1363
1364 if (GLvar->bShadows==true) {
1365 glEnable(GL_STENCIL_TEST);
1366 glStencilFunc(GL_EQUAL, 1, 1);
1367 glStencilOp(GL_ZERO,GL_ZERO,GL_ZERO);
1368 // glDepthMask(GL_TRUE);
1369
1370 glMultMatrixf(GLvar->shadowMatrix);
1371
1372 glDisable(GL_TEXTURE_2D);
1373 glDisable(GL_LIGHTING);
1374
1375 glEnable(GL_POLYGON_OFFSET_FILL);
1376 glPolygonOffset(-1.0,1.0);
1377 glEnable(GL_BLEND);
1378 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1379 glColor4f(0,0,0,.35);
1380
1381 globalList->drawShadows();
1382
1383 glDisable(GL_POLYGON_OFFSET_FILL);
1384
1385 glDisable(GL_BLEND);
1386 glDisable(GL_STENCIL_TEST);
1387 glEnable(GL_LIGHTING);
1388 }
1389
1390 globalList->collision();
1391
1392 if (GLvar->mySpaceShip!=NULL) {
1393 if (GLvar->mySpaceShip->isDead())
1394 {
1395 GLvar->mySpaceShip=NULL;
1396 GLvar->delay=0;
1397 }
1398 } else {
1399 GLvar->delay+=GLvar->global_timeadjustment;
1400 }
1401
1402 globalList->cleanList();
1403
1404 drawPlayers();
1405
1406 SDL_GL_SwapBuffers();
1407
1408 if ((glError=glGetError())!=GL_NO_ERROR) {
1409 printf("OpenGL error : %s\n", gluErrorString(glError));
1410 }
1411
1412
1413 }
1414
1415
1416
1417
1418
1419
1420 /*
1421 * void init
1422 *
1423 * OpenGL initialisation
1424 */
1425
1426
initOpenGl()1427 void Scene::initOpenGl()
1428 {
1429 // This is the actual vertex program. For more information on what these instructions do
1430 // refere to NVIDIA's website. There are numberous Docs on this specification.
1431 // R0 = NORMAL
1432 // R3 = light direction
1433 // R4 = R0.R3
1434
1435 const unsigned char floorShader[]=
1436 {
1437 "!!VP1.0 MOV o[TEX0],v[TEX0]; MOV o[TEX1],v[TEX0]; DP4 o[HPOS].x,v[OPOS],c[0]; DP4 o[HPOS].y,v[OPOS],c[1]; DP4 o[HPOS].z,v[OPOS],c[2]; DP4 o[HPOS].w,v[OPOS],c[3]; MOV R0, v[OPOS]; ADD R7, c[11], -R0; MOV R0.x, -R0.x; ADD R3, c[8], -R0; DP3 R1, R3, R3; RSQ R1.x, R1.x; MUL R5.x, c[9].x, R1.x; MUL R3.xyz, R3, R1.x; MAD R4, R3, c[10], c[10]; MOV o[COL0], R4.xzyw; ADD R3.x, R5.x, c[12].x; MAX R2.x, R2.x, c[12].y; MUL o[COL1],R5.x, R3.x; DP3 R7, R7, R7; RSQ R7.x, R7.x; MUL o[FOGC], R7.x, R7.y; END"
1438 };
1439
1440
1441 printf("OpenGL Info : %s\n %s\n %s\n",
1442 glGetString(GL_VENDOR),
1443 glGetString(GL_RENDERER),
1444 glGetString(GL_VERSION));
1445
1446 // printf("%s\n", glGetString(GL_EXTENSIONS));
1447
1448 glClearColor(0,0,0,1.0);
1449
1450 glEnable(GL_FOG);
1451
1452 nFog=1;
1453 glFogf(GL_FOG_MODE,GL_LINEAR);
1454 glFogf(GL_FOG_START, 35);
1455 glFogf(GL_FOG_END, 65);
1456 glFogfv(GL_FOG_COLOR,GLvar->nothing);
1457 #if 0
1458 glFogf(GL_FOG_MODE,GL_EXP2);
1459 glFogf(GL_FOG_START, 50);
1460 glFogf(GL_FOG_DENSITY, .022);
1461 glFogfv(GL_FOG_COLOR,GLvar->nothing);
1462 #endif
1463
1464 glEnable(GL_NORMALIZE);
1465
1466 bSpecular = true;
1467 glMaterialfv(GL_FRONT, GL_AMBIENT, GLvar->lm_ambient);
1468 glMaterialfv(GL_FRONT, GL_SPECULAR, GLvar->blanc_diffuse);
1469 glMaterialfv(GL_FRONT, GL_DIFFUSE, GLvar->blanc_diffuse);
1470 glMaterialf(GL_FRONT, GL_SHININESS, 64.0f);
1471
1472 glLightfv(GL_LIGHT0, GL_AMBIENT, GLvar->lm_ambient);
1473 glLightfv(GL_LIGHT0, GL_DIFFUSE, GLvar->blanc_diffuse);
1474 glLightfv(GL_LIGHT0, GL_SPECULAR, GLvar->blanc_diffuse);
1475 glLightfv(GL_LIGHT0, GL_POSITION, GLvar->light_position);
1476
1477 #ifdef GL_SEPARATE_SPECULAR_COLOR
1478 if (GlaxiumVariables::isExtensionSupported("GL_EXT_separate_specular_color")) {
1479 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1480 }
1481 #endif
1482
1483
1484 // IF speedUP
1485 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);
1486 //s else
1487 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
1488 glEnable(GL_LIGHTING);
1489 glEnable(GL_LIGHT0);
1490 glEnable(GL_DEPTH_TEST);
1491
1492 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1493
1494 glEnable(GL_CULL_FACE);
1495 glCullFace(GL_BACK);
1496
1497
1498 #ifdef WIN32
1499 glActiveTextureARB=(PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB");
1500 glMultiTexCoord2fARB=(PFNGLMULTITEXCOORD2FARBPROC)wglGetProcAddress("glMultiTexCoord2fARB");
1501 #endif
1502
1503 #if defined( GL_REGISTER_COMBINERS_NV) && defined(GL_VERTEX_PROGRAM_NV)
1504 if (GLvar->bNVExtension) {
1505 #ifdef WIN32
1506 glCombinerParameteriNV=(PFNGLCOMBINERPARAMETERINVPROC)wglGetProcAddress("glCombinerParameteriNV");
1507 glCombinerInputNV=(PFNGLCOMBINERINPUTNVPROC)wglGetProcAddress("glCombinerInputNV");
1508 glCombinerOutputNV=(PFNGLCOMBINEROUTPUTNVPROC)wglGetProcAddress("glCombinerOutputNV");
1509 glFinalCombinerInputNV=(PFNGLFINALCOMBINERINPUTNVPROC)wglGetProcAddress("glFinalCombinerInputNV");
1510 glCombinerParameterfvNV=(PFNGLCOMBINERPARAMETERFVNVPROC)wglGetProcAddress("glCombinerParameterfvNV");
1511 glLoadProgramNV=(PFNGLLOADPROGRAMNVPROC )wglGetProcAddress("glLoadProgramNV");
1512 glBindProgramNV=(PFNGLBINDPROGRAMNVPROC)wglGetProcAddress("glBindProgramNV");
1513 glTrackMatrixNV=(PFNGLTRACKMATRIXNVPROC)wglGetProcAddress("glTrackMatrixNV");
1514 glProgramParameter4fNV=(PFNGLPROGRAMPARAMETER4FNVPROC)wglGetProcAddress("glProgramParameter4fNV");
1515 #else
1516 glCombinerParameteriNV=(PFNGLCOMBINERPARAMETERINVPROC)glXGetProcAddressARB((const GLubyte *)"glCombinerParameteriNV");
1517 glCombinerInputNV=(PFNGLCOMBINERINPUTNVPROC)glXGetProcAddressARB((const GLubyte *)"glCombinerInputNV");
1518 glCombinerOutputNV=(PFNGLCOMBINEROUTPUTNVPROC)glXGetProcAddressARB((const GLubyte *)"glCombinerOutputNV");
1519 glFinalCombinerInputNV=(PFNGLFINALCOMBINERINPUTNVPROC)glXGetProcAddressARB((const GLubyte *)"glFinalCombinerInputNV");
1520 glCombinerParameterfvNV=(PFNGLCOMBINERPARAMETERFVNVPROC)glXGetProcAddressARB((const GLubyte *)"glCombinerParameterfvNV");
1521 glLoadProgramNV=(PFNGLLOADPROGRAMNVPROC )glXGetProcAddressARB((const GLubyte *)"glLoadProgramNV");
1522 glBindProgramNV=(PFNGLBINDPROGRAMNVPROC)glXGetProcAddressARB((const GLubyte *)"glBindProgramNV");
1523 glTrackMatrixNV=(PFNGLTRACKMATRIXNVPROC)glXGetProcAddressARB((const GLubyte *)"glTrackMatrixNV");
1524 glProgramParameter4fNV=(PFNGLPROGRAMPARAMETER4FNVPROC)glXGetProcAddressARB((const GLubyte *)"glProgramParameter4fNV");
1525 #endif
1526 // enabled in when required
1527 glDisable(GL_VERTEX_PROGRAM_NV);
1528 //Now we enable VERTEX PROGRAMS. And Load it up.
1529 glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1);
1530 glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1, strlen((char * ) floorShader), floorShader);
1531
1532 //Load the Projection matrix into Vector Registers c[0]...
1533 glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
1534 glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV);
1535 //Load the Light position into Vector Register c[8].
1536 // glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 8, posX, 2 , posZ, 1); // Light direction
1537 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 8, 0, 10 , 20, 1); // Light direction
1538 // c[9].x : lumiere vaisseau
1539 // FOG = dist * c[9].z + / c[9].y
1540 // linear near = 40; far = 70;
1541 // c[9].y : -40
1542 // c[9].z : 1/(fog far- fog near) = 1/30 =
1543 // c[9].w : ambiant floor color (c[9].w,c[9].w,c[9].w);
1544 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 9, 3, -40 , 0.0333333, .25); // Constant
1545 // c[10]
1546 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 10, .5, 0.5 , .5, 1); // Constant for bump map...
1547 // c[11] : camera position
1548 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 11, 1,1,1,1);
1549 // c[12] : fog for secondary color
1550 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 12, -.2
1551 , 0, 0, 0);
1552
1553
1554 }
1555 #endif
1556 }
1557
1558 /*
1559 * void gameIdle
1560 *
1561 * Main game loop
1562 *
1563 */
1564
1565
gameIdle()1566 void Scene::gameIdle()
1567 {
1568 static int oldTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
1569
1570 int newTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
1571
1572
1573 // printf("%d : %f\n",newTimer, GLvar->global_timeadjustment);
1574 GLvar->global_timeadjustment = ((float)newTimer-oldTimer)/20;
1575
1576 if (GLvar->global_timeadjustment > 10)
1577 {
1578 GLvar->global_timeadjustment=10;
1579 }
1580
1581 oldTimer = newTimer;
1582
1583 if (GLvar->global_pause)
1584 GLvar->global_timeadjustment=0;
1585
1586 globalList->move();
1587
1588
1589
1590
1591
1592
1593 int level = 0;
1594 if (GLvar->mySpaceShip!=NULL) {
1595 level = scene->globalScore/8000;
1596 }
1597 /*
1598 if (GLvar->myRandom(300))
1599 {
1600 float newX = (float)(random()%140)/10-7;
1601 float speed = ((float)(random()%64) /128.0f)+.5f;
1602 Fighter2 *newOne = new Fighter2(globalList,
1603 newX,70,
1604 speed,
1605 3+level);
1606 globalList->Add(newOne);
1607 }*/
1608 if (GLvar->myRandom(1000))
1609 {
1610 Tache *newOne = new Tache(globalList,
1611 (random()%21)-10, 8+level);
1612 globalList->Add(newOne);
1613
1614 }
1615 if (GLvar->myRandom(160+ (scene->globalScore>10000)*80))
1616 {
1617 // printf("NEW sprite...................\n");
1618 Cube *newOne = new Cube(globalList,
1619 2,
1620 (random()%21)-10);
1621 globalList->Add(newOne);
1622
1623 }
1624 if (GLvar->mySpaceShip!=NULL) {
1625
1626
1627 if (((scene->globalScore>1000) && (scene->globalScore<12000)) || (scene->globalScore>35000)) {
1628 if (GLvar->myRandom(160)) {
1629 float newX = (float)(random()%140)/10-7;
1630 float speed = ((float)(random()%64) /128.0f)+.5f;
1631 // printf("speed : %f\n", speed);
1632 Bandit2 *newOne = new Bandit2(globalList,
1633 newX,70,
1634 speed,
1635 3+level);
1636 globalList->Add(newOne);
1637
1638 }
1639 }
1640
1641 if (((scene->globalScore>12000) && (scene->globalScore<35000)) || (scene->globalScore>55000)) {
1642 if (GLvar->myRandom(200)) {
1643 float newX = (float)(random()%140)/10-7;
1644 float speed = ((float)(random()%64) /128.0f)+.5f;
1645 // printf("speed : %f\n", speed);
1646 Ship1 *newOne = new Ship1(globalList,
1647 newX,70.0f,
1648 speed,
1649 (int)(3+level*1.5));
1650 globalList->Add(newOne);
1651 }
1652 }
1653
1654 }
1655
1656
1657 if (scene->globalScore> 4000)
1658 {
1659 if (GLvar->myRandom(150 + (scene->globalScore>10000)*100))
1660 {
1661 Piege *newOne = new Piege(globalList,
1662 2,
1663 (random()%21)-10);
1664 globalList->Add(newOne);
1665
1666 }
1667 }
1668
1669
1670 if (scene->globalScore > 50000)
1671 {
1672 if (GLvar->mySpaceShip!=NULL)
1673 {
1674 if (GLvar->myRandom(350-100*(scene->globalScore>80000)))
1675 {
1676 if (scene->globalScore<100000 && Tank::numberOfTanks_<3) {
1677 Tank*newOne = new Tank(globalList,
1678 (random()%21)-10,
1679 7+level*2);
1680 globalList->Add(newOne);
1681 }
1682 if (scene->globalScore>100000 && Tank::numberOfTanks_<6) {
1683 Tank*newOne = new Tank(globalList,
1684 (random()%21)-10,
1685 7+level*2);
1686 globalList->Add(newOne);
1687 }
1688
1689 }
1690 }
1691 }
1692
1693
1694
1695 if (scene->globalScore > 100000)
1696 {
1697 if (GLvar->myRandom(300))
1698 {
1699 // printf("NEW sprite...................\n");
1700 Tache *newOne = new Tache(globalList,
1701 (random()%21)-10,
1702 8+level);
1703 globalList->Add(newOne);
1704 }
1705
1706 }
1707 }
1708
1709
presentationIdle()1710 void Scene::presentationIdle() {
1711 static int oldTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
1712
1713 int newTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
1714
1715
1716 GLvar->global_timeadjustment = ((float)newTimer-oldTimer)/20;
1717
1718 if (GLvar->global_timeadjustment > 10)
1719 {
1720 GLvar->global_timeadjustment=10;
1721 }
1722
1723 oldTimer = newTimer;
1724
1725
1726 if ((GLvar->rotateMyShip+=0.3*GLvar->global_timeadjustment)>360) GLvar->rotateMyShip-=360;
1727 }
1728
1729
1730
createCube(float size)1731 int Scene::createCube(float size)
1732 {
1733 int list = glGenLists(1);
1734 glNewList(list,GL_COMPILE);
1735 {
1736 glBegin(GL_QUADS);
1737
1738 glTexCoord2f(0, 0);
1739 glVertex3f(size/2,size/2,size/2);
1740 glTexCoord2f(0, 1);
1741 glVertex3f(size/2,size/2,-size/2);
1742 glTexCoord2f(1,1);
1743 glVertex3f(-size/2,size/2,-size/2);
1744 glTexCoord2f(1,0);
1745 glVertex3f(-size/2,size/2,size/2);
1746
1747
1748 glTexCoord2f(0, 0);
1749 glVertex3f(size/2,-size/2,size/2);
1750 glTexCoord2f(0, 1);
1751 glVertex3f(size/2,-size/2,-size/2);
1752 glTexCoord2f(1,1);
1753 glVertex3f(-size/2,-size/2,-size/2);
1754 glTexCoord2f(1,0);
1755 glVertex3f(-size/2,-size/2,size/2);
1756
1757 glTexCoord2f(0, 0);
1758 glVertex3f(size/2,size/2,size/2);
1759 glTexCoord2f(1,0);
1760 glVertex3f(-size/2,size/2,size/2);
1761 glTexCoord2f(1,1);
1762 glVertex3f(-size/2,-size/2,size/2);
1763 glTexCoord2f(0, 1);
1764 glVertex3f(size/2,-size/2,size/2);
1765
1766 glTexCoord2f(0, 0);
1767 glVertex3f(size/2,size/2,-size/2);
1768 glTexCoord2f(0, 1);
1769 glVertex3f(size/2,-size/2,-size/2);
1770 glTexCoord2f(1,1);
1771 glVertex3f(-size/2,-size/2,-size/2);
1772 glTexCoord2f(1,0);
1773 glVertex3f(-size/2,size/2,-size/2);
1774
1775 glTexCoord2f(0, 0);
1776 glVertex3f(size/2,size/2,size/2);
1777 glTexCoord2f(0, 1);
1778 glVertex3f(size/2,size/2,-size/2);
1779 glTexCoord2f(1,1);
1780 glVertex3f(size/2,-size/2,-size/2);
1781 glTexCoord2f(1,0);
1782 glVertex3f(size/2,-size/2,size/2);
1783
1784
1785 glTexCoord2f(0, 0);
1786 glVertex3f(-size/2,size/2,size/2);
1787 glTexCoord2f(0, 1);
1788 glVertex3f(-size/2,size/2,-size/2);
1789 glTexCoord2f(1,1);
1790 glVertex3f(-size/2,-size/2,-size/2);
1791 glTexCoord2f(1,0);
1792 glVertex3f(-size/2,-size/2,size/2);
1793
1794 glEnd();
1795
1796 }
1797 glEndList();
1798 return list;
1799 }
1800
createCube(float sizex,float sizey,float sizez)1801 void Scene::createCube(float sizex,float sizey,float sizez)
1802 {
1803 glBegin(GL_QUADS);
1804
1805 glTexCoord2f(0, 0);
1806 glVertex3f(sizex/2,sizey/2,sizez/2);
1807 glTexCoord2f(0, 1);
1808 glVertex3f(sizex/2,sizey/2,-sizez/2);
1809 glTexCoord2f(1,1);
1810 glVertex3f(-sizex/2,sizey/2,-sizez/2);
1811 glTexCoord2f(1,0);
1812 glVertex3f(-sizex/2,sizey/2,sizez/2);
1813
1814
1815 glTexCoord2f(0, 0);
1816 glVertex3f(sizex/2,-sizey/2,sizez/2);
1817 glTexCoord2f(0, 1);
1818 glVertex3f(sizex/2,-sizey/2,-sizez/2);
1819 glTexCoord2f(1,1);
1820 glVertex3f(-sizex/2,-sizey/2,-sizez/2);
1821 glTexCoord2f(1,0);
1822 glVertex3f(-sizex/2,-sizey/2,sizez/2);
1823
1824 glTexCoord2f(0, 0);
1825 glVertex3f(sizex/2,sizey/2,sizez/2);
1826 glTexCoord2f(1,0);
1827 glVertex3f(-sizex/2,sizey/2,sizez/2);
1828 glTexCoord2f(1,1);
1829 glVertex3f(-sizex/2,-sizey/2,sizez/2);
1830 glTexCoord2f(0, 1);
1831 glVertex3f(sizex/2,-sizey/2,sizez/2);
1832
1833 glTexCoord2f(0, 0);
1834 glVertex3f(sizex/2,sizey/2,-sizez/2);
1835 glTexCoord2f(0, 1);
1836 glVertex3f(sizex/2,-sizey/2,-sizez/2);
1837 glTexCoord2f(1,1);
1838 glVertex3f(-sizex/2,-sizey/2,-sizez/2);
1839 glTexCoord2f(1,0);
1840 glVertex3f(-sizex/2,sizey/2,-sizez/2);
1841
1842 glTexCoord2f(0, 0);
1843 glVertex3f(sizex/2,sizey/2,sizez/2);
1844 glTexCoord2f(0, 1);
1845 glVertex3f(sizex/2,sizey/2,-sizez/2);
1846 glTexCoord2f(1,1);
1847 glVertex3f(sizex/2,-sizey/2,-sizez/2);
1848 glTexCoord2f(1,0);
1849 glVertex3f(sizex/2,-sizey/2,sizez/2);
1850
1851
1852 glTexCoord2f(0, 0);
1853 glVertex3f(-sizex/2,sizey/2,sizez/2);
1854 glTexCoord2f(0, 1);
1855 glVertex3f(-sizex/2,sizey/2,-sizez/2);
1856 glTexCoord2f(1,1);
1857 glVertex3f(-sizex/2,-sizey/2,-sizez/2);
1858 glTexCoord2f(1,0);
1859 glVertex3f(-sizex/2,-sizey/2,sizez/2);
1860
1861 glEnd();
1862
1863 }
1864
1865
1866
1867
1868 /*******************************
1869 ** **
1870 ** BENCHMARCK **
1871 ** BENCHMARCK **
1872 ** BENCHMARCK **
1873 ** BENCHMARCK **
1874 ** BENCHMARCK **
1875 ** **
1876 ** **
1877 *******************************/
1878
1879 static char strFinalResult[128];
1880
drawBench()1881 void Scene::drawBench()
1882 {
1883 if (GLvar->bShadows==true) {
1884 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
1885 } else {
1886 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1887 }
1888
1889 glViewport(0,0,GLvar->width ,GLvar->height);
1890
1891 glMatrixMode(GL_PROJECTION);
1892 glLoadIdentity();
1893 gluPerspective(50, 1.333333 , 2.0, 160);
1894 // Important part !
1895 glMatrixMode(GL_MODELVIEW);
1896 glLoadIdentity();
1897
1898 camX = 4;
1899 camY = 5;
1900 camZ = -2;
1901 gluLookAt(4*cos(benchPeriod), 6 +cos(benchPeriod/2) , 6+ 9*sin(benchPeriod/2),
1902 0, .4 , 20 +4*sin(benchPeriod/2),
1903 .3*cos(benchPeriod), 1, 0);
1904 // c[8] : Spaceship position
1905 #if defined( GL_REGISTER_COMBINERS_NV) && defined(GL_VERTEX_PROGRAM_NV)
1906 if (glProgramParameter4fNV!=NULL) {
1907 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 8, 0, 3.5 , 10, 1);
1908 // c[11] : camera position
1909 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 11, camX, camY, camZ,1);
1910 }
1911 #endif
1912
1913 glPushMatrix();
1914
1915 glColor4f(1.0, 1.0, 1.0 , 1);
1916
1917 drawSky();
1918
1919 if (GLvar->bShadows==true) {
1920
1921 // glDepthMask(GL_FALSE);
1922
1923 glEnable(GL_STENCIL_TEST);
1924 glStencilFunc(GL_ALWAYS, 1,1);
1925 glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
1926
1927 drawFloor();
1928
1929 glDisable(GL_STENCIL_TEST);
1930 glEnable(GL_LIGHTING);
1931 } else {
1932 glEnable(GL_LIGHTING);
1933 drawFloor();
1934 }
1935
1936 glPopMatrix();
1937
1938 globalList->draw();
1939
1940 glDisable(GL_TEXTURE_2D);
1941 glDisable(GL_LIGHTING);
1942
1943 if (GLvar->bShadows==true) {
1944 glEnable(GL_STENCIL_TEST);
1945 glStencilFunc(GL_EQUAL, 1, 1);
1946 glStencilOp(GL_ZERO,GL_ZERO,GL_ZERO);
1947 // glDepthMask(GL_TRUE);
1948
1949 glMultMatrixf(GLvar->shadowMatrix);
1950
1951
1952 glEnable(GL_POLYGON_OFFSET_FILL);
1953 glPolygonOffset(-1.0,1.0);
1954 glEnable(GL_BLEND);
1955 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1956 glColor4f(0,0,0,.35);
1957
1958 globalList->drawShadows();
1959
1960 glDisable(GL_POLYGON_OFFSET_FILL);
1961
1962 glDisable(GL_BLEND);
1963 glDisable(GL_STENCIL_TEST);
1964 }
1965
1966 // globalList->collision();
1967
1968
1969 globalList->cleanList();
1970
1971 // TEXT
1972 glMatrixMode(GL_PROJECTION);
1973 glLoadIdentity();
1974 glOrtho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
1975
1976 glDepthFunc(GL_ALWAYS);
1977 glMatrixMode(GL_MODELVIEW);
1978 glLoadIdentity();
1979 glEnable(GL_BLEND);
1980 glEnable(GL_TEXTURE_2D);
1981 glDisable(GL_LIGHTING);
1982
1983 drawFPSBench();
1984
1985 if (benchState==4) {
1986 drawText(.3,.8, 0,strFinalResult, 20, 1,0,0);
1987 }
1988
1989 glDepthFunc(GL_LEQUAL);
1990
1991 SDL_GL_SwapBuffers();
1992
1993 if ((glError=glGetError())!=GL_NO_ERROR) {
1994 printf("OpenGL error : %s\n", gluErrorString(glError));
1995 }
1996 }
1997
1998
1999
benchIdle()2000 void Scene::benchIdle()
2001 {
2002 static TacheBench *newOne;
2003 static int oldTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
2004 static int benchFrames;
2005 static int benchTime;
2006
2007 int newTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
2008 int i;
2009
2010 // printf("%d : %f\n",newTimer, GLvar->global_timeadjustment);
2011 GLvar->global_timeadjustment = ((float)newTimer-oldTimer)/20;
2012
2013 if (GLvar->global_timeadjustment > 10)
2014 {
2015 GLvar->global_timeadjustment=10;
2016 }
2017
2018 oldTimer = newTimer;
2019 globalList->move() ;
2020 #ifndef PI
2021 #define PI=3.151592653589793
2022 #endif
2023 benchFrames++;
2024
2025 benchPeriod+=.01*GLvar->global_timeadjustment;
2026 if (benchPeriod>4*PI) {
2027 benchPeriod-=4*PI;
2028 }
2029 // printf("%d\n", benchPeriod);
2030 switch (benchState) {
2031 case 0:
2032 benchFrames=0;
2033 benchTime=glutGet((GLenum)(GLUT_ELAPSED_TIME));
2034 for (i=-4;i<=4;i++) {
2035
2036 newOne = new TacheBench(globalList, i*2.7, 100);
2037 globalList->Add(newOne);
2038 }
2039 benchState = 1;
2040 break;
2041 case 1:
2042
2043 if (globalList->get_mfirst()==NULL ) {
2044 glEnable(GL_LIGHTING);
2045 benchState=4;
2046 benchTime=glutGet((GLenum)(GLUT_ELAPSED_TIME))-benchTime;
2047 printf("+---------------------------------+\n");
2048 printf("| GLAXIUM BENCHMARK RESULT (v1) |\n");
2049 printf("+---------------------------------+\n");
2050 if (GLvar->bNVExtension) {
2051 printf(">> NVidia extensions version\n");
2052 } else if (GLvar->bEXTEnvDot3) {
2053 printf(">> EXT combine & dot3 version\n");
2054 } else {
2055 printf(">> One texture unit version\n");
2056 }
2057 printf(">> %d frames in %f sec\n", benchFrames, (float)benchTime/1000.0);
2058 sprintf(strFinalResult, "Average FPS: %d", (int)1000.0*benchFrames/benchTime);
2059 printf(">> average FPS : %f \n", (float)1000.0*benchFrames/benchTime);
2060 printf("+----------------------------+\n");
2061
2062 }
2063 break;
2064 case 4:
2065 {
2066
2067
2068 // SHOULD BE FINISHED BY MAIN
2069 break;
2070 }
2071
2072 }
2073
2074 }
2075
drawFPSBench()2076 void Scene::drawFPSBench()
2077 {
2078 static char tmp[20]="FPS: 0";
2079 int i;
2080 int diff;
2081 static int fps = 0;
2082 static int cpt =0;
2083
2084
2085 // glMaterialfv(GL_FRONT,GL_AMBIENT, GLvar->blanc_diffuse);
2086 // glMaterialfv(GL_FRONT,GL_DIFFUSE,GLvar->blanc_diffuse);
2087
2088
2089 diff = (dt > 0) ? dt : 1;
2090
2091 cpt++;
2092 if (cpt==10)
2093 {
2094 cpt=0;
2095 timediff();
2096 fps = 10000 / dt;
2097
2098 sprintf(tmp, "FPS: %d", fps);
2099 }
2100 drawText(.01,.95, 0,tmp, 10);
2101 }
2102
2103
2104 /*******************************
2105 ** MENU **
2106 *******************************/
2107
2108 static bool hideMenu = false;
2109 static int menuSelected = 0;
2110 static char infos[][128] = {"Texture filtering: Trilinear", "0", "Details level: High", "0"};
2111
drawMenu()2112 void Scene::drawMenu()
2113 {
2114 static char optionsChars[] = "OPTIONS";
2115 static char hideChars[] = "H to hide / Esc to go back";
2116 int i, j;
2117
2118 if (infos[1][0]=='0') {
2119 sprintf(infos[1],"Anisotropic texturing: %d", (int)GLvar->fMaxAnis);
2120 }
2121 if (infos[3][0]=='0') {
2122 sprintf(infos[3],"Shadows: %s", (GLvar->bShadows? "On":"Off"));
2123 }
2124
2125 if (GLvar->bShadows==true) {
2126 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
2127 } else {
2128 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
2129 }
2130
2131 glViewport(0,0,GLvar->width ,GLvar->height);
2132
2133 glMatrixMode(GL_PROJECTION);
2134
2135 glLoadIdentity();
2136 gluPerspective(50, 1.333333 , 2.0, 160);
2137 // Important part !
2138 glMatrixMode(GL_MODELVIEW);
2139 glLoadIdentity();
2140
2141 camX = 4;
2142 camY = 5;
2143 camZ = -2;
2144 gluLookAt( 10, 2, 6,
2145 10, .4 , 20,
2146 0, 1, 0);
2147 // c[8] : Spaceship position
2148 #if defined( GL_REGISTER_COMBINERS_NV) && defined(GL_VERTEX_PROGRAM_NV)
2149 if (glProgramParameter4fNV!=NULL) {
2150 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 8, 0, 3.5 , 10, 1);
2151 // c[11] : camera position
2152 glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 11, camX, camY, camZ,1);
2153 }
2154 #endif
2155
2156 glPushMatrix();
2157
2158 glColor4f(1.0, 1.0, 1.0 , 1);
2159
2160
2161 drawSky();
2162
2163 if (GLvar->bShadows==true) {
2164
2165
2166 glEnable(GL_STENCIL_TEST);
2167 glStencilFunc(GL_ALWAYS, 1,1);
2168 glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
2169
2170 drawFloor();
2171
2172 glDisable(GL_STENCIL_TEST);
2173 glEnable(GL_LIGHTING);
2174 } else {
2175 glEnable(GL_LIGHTING);
2176 drawFloor();
2177 }
2178
2179 glPopMatrix();
2180
2181 globalList->draw();
2182
2183 glEnable(GL_BLEND);
2184 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2185 if (GLvar->bShadows==true) {
2186 glEnable(GL_STENCIL_TEST);
2187 glStencilFunc(GL_EQUAL, 1, 1);
2188 glStencilOp(GL_ZERO,GL_ZERO,GL_ZERO);
2189 // glDepthMask(GL_TRUE);
2190
2191 glMultMatrixf(GLvar->shadowMatrix);
2192
2193 glDisable(GL_TEXTURE_2D);
2194 glDisable(GL_LIGHTING);
2195
2196 glEnable(GL_POLYGON_OFFSET_FILL);
2197 glPolygonOffset(-1.0,1.0);
2198 glColor4f(0,0,0,.35);
2199
2200 globalList->drawShadows();
2201
2202 glDisable(GL_POLYGON_OFFSET_FILL);
2203
2204 glDisable(GL_STENCIL_TEST);
2205 }
2206
2207 // globalList->collision();
2208 // INFORMATIONS
2209 glDisable(GL_LIGHTING);
2210
2211 if( !hideMenu) {
2212 glMatrixMode(GL_PROJECTION);
2213
2214 glLoadIdentity();
2215 glOrtho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
2216
2217 glMatrixMode(GL_MODELVIEW);
2218 glLoadIdentity();
2219
2220 glDepthFunc(GL_ALWAYS);
2221 glDisable(GL_TEXTURE_2D);
2222 glColor4f(.3,0,0, .8);
2223 glBegin(GL_QUADS) ;
2224 {
2225 glVertex3f(.3,.95,0);
2226 glVertex3f(.3,.6,0);
2227 glVertex3f(.7,.6,0);
2228 glVertex3f(.7,.95,0);
2229 }
2230 glEnd();
2231
2232 glEnable(GL_TEXTURE_2D);
2233
2234 drawText(.43, .9, 0,optionsChars, 12, 1,.3,.3);
2235 drawText(.38, .88,0, hideChars, 7, 1,.7,.3);
2236
2237 for (j=0; j<4; j++) {
2238 drawText(.32, .8-.05*j,0, infos[j], 8);
2239 }
2240 glDisable(GL_TEXTURE_2D);
2241 glColor4f(1,1,0,1);
2242 glBegin(GL_TRIANGLES) ;
2243 {
2244 glVertex3f(.28,.8 - menuSelected*.05+.007,0);
2245 glVertex3f(.30,.8 - menuSelected*.05+.016,0);
2246 glVertex3f(.28,.8 - menuSelected*.05+.025,0);
2247 }
2248 glEnd();
2249 glDepthFunc(GL_LEQUAL);
2250 } // else {
2251 glDisable(GL_TEXTURE_2D);
2252 glDisable(GL_BLEND);
2253
2254 // TEXT
2255 glMatrixMode(GL_PROJECTION);
2256 glLoadIdentity();
2257 glOrtho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
2258
2259 glDepthFunc(GL_ALWAYS);
2260 glMatrixMode(GL_MODELVIEW);
2261 glLoadIdentity();
2262 glEnable(GL_BLEND);
2263 glEnable(GL_TEXTURE_2D);
2264 glDisable(GL_LIGHTING);
2265
2266 drawFPSBench();
2267
2268
2269 glDepthFunc(GL_LEQUAL);
2270
2271 // }
2272
2273 globalList->cleanList();
2274
2275
2276 SDL_GL_SwapBuffers();
2277
2278 if ((glError=glGetError())!=GL_NO_ERROR) {
2279 printf("OpenGL error : %s\n", gluErrorString(glError));
2280 }
2281 }
changeAllTexturesAnis(int anisValue)2282 void changeAllTexturesAnis(int anisValue) {
2283 int i;
2284 for (i=0; i<5; i++) {
2285 glBindTexture(GL_TEXTURE_2D, GLvar->texture_floor[i]);
2286 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAX_ANISOTROPY_EXT, anisValue);
2287 glBindTexture(GL_TEXTURE_2D, GLvar->texture_floorMap[i]);
2288 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAX_ANISOTROPY_EXT, anisValue);
2289 }
2290 glBindTexture(GL_TEXTURE_2D, GLvar->texture_border);
2291 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAX_ANISOTROPY_EXT, anisValue);
2292 }
2293
changeTexture(int tex,GLenum mag,GLenum min)2294 void changeTexture(int tex, GLenum mag, GLenum min) {
2295 glBindTexture(GL_TEXTURE_2D, tex);
2296 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag);
2297 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min);
2298 }
changeAllTextures(GLenum mag,GLenum min)2299 void changeAllTextures(GLenum mag, GLenum min) {
2300 int i;
2301 for (i=0; i<5; i++) {
2302 changeTexture( GLvar->texture_floor[i], mag, min);
2303 changeTexture( GLvar->texture_floorMap[i], mag, min);
2304 }
2305 changeTexture( GLvar->texture_border, mag, min);
2306 changeTexture( GLvar->texture_mark, mag, min);
2307 changeTexture( GLvar->texture_tache, mag, min);
2308 changeTexture( GLvar->texture_fumee[0], mag, min);
2309 changeTexture( GLvar->texture_fumee[1], mag, min);
2310 changeTexture( GLvar->texture_fumee[2], mag, min);
2311 for (i=0; i< SPACE;i++) {
2312 changeTexture(GLvar->texture_space[i],mag, min);
2313 }
2314
2315 }
2316
menuIdle()2317 void Scene::menuIdle()
2318 {
2319 static TacheBench *newOne;
2320 static int oldTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
2321 static int benchFrames;
2322 static int benchTime;
2323 static Uint8 *keys;
2324 static int anisValue = (int)GLvar->fMaxAnis;
2325 static int filterValue = 2;
2326 static int detailValue = 2;
2327 static char filterChars[][64] = {"Basic Mipmap", "Bilinear", "Trilinear"};
2328 static char detailChars[][64] = {"Low", "Medium", "High"};
2329 static bool optionsLoaded = false;
2330 int newTimer = glutGet((GLenum)(GLUT_ELAPSED_TIME));
2331 int i;
2332 bool anisChanged = false;
2333 bool filterChanged = false;
2334 bool detailChanged = false;
2335 bool shadowChanged = false;
2336
2337
2338 if (!optionsLoaded) {
2339 optionsLoaded = true;
2340 FILE *fOptions = fopen(GLvar->getFullOptionsPath(), "r");
2341 if (fOptions != NULL) {
2342 int nshadows;
2343 fscanf(fOptions, "%d %d %d %d", &filterValue, &anisValue, &detailValue, &nshadows);
2344 GLvar->bShadows = (nshadows==1);
2345 fclose(fOptions);
2346 }
2347 sprintf(infos[3],"Shadows: %s", (GLvar->bShadows? "On":"Off"));
2348 sprintf(infos[0], "Texture filtering: %s", filterChars[filterValue]);
2349 sprintf(infos[1],"Anisotropic texturing: %d", anisValue);
2350 sprintf(infos[2],"Details level: %s", detailChars[detailValue]);
2351 }
2352
2353 // printf("%d : %f\n",newTimer, GLvar->global_timeadjustment);
2354 GLvar->global_timeadjustment = ((float)newTimer-oldTimer)/20;
2355
2356 if (GLvar->global_timeadjustment > 10)
2357 {
2358 GLvar->global_timeadjustment=10;
2359 }
2360
2361 oldTimer = newTimer;
2362 globalList->move() ;
2363 #ifndef PI
2364 #define PI=3.141592653589793
2365 #endif
2366 benchFrames++;
2367
2368 benchPeriod+=.01*GLvar->global_timeadjustment;
2369 if (benchPeriod>4*PI) {
2370 benchPeriod-=4*PI;
2371 }
2372 // printf("%d\n", benchPeriod);
2373 switch (benchState) {
2374 case 0:
2375 benchFrames=0;
2376 benchTime=glutGet((GLenum)(GLUT_ELAPSED_TIME));
2377 for (i=-2;i<=2;i++) {
2378
2379 newOne = new TacheBench(globalList, i*5.0, 200);
2380 globalList->Add(newOne);
2381 }
2382 benchState = 1;
2383 break;
2384 case 1:
2385 {
2386 if (globalList->get_mfirst()==NULL) {
2387 benchState=0;
2388 }
2389
2390 keys = SDL_GetKeyState(NULL);
2391 if (keys[SDLK_UP] && bKeyDown) {
2392 menuSelected = menuSelected-1;
2393 if( menuSelected<0) menuSelected=3;
2394 }
2395 if (keys[SDLK_DOWN] && bKeyDown) {
2396 menuSelected = menuSelected+1;
2397 if( menuSelected>3) menuSelected=0;
2398 }
2399 if (keys[SDLK_h] && bKeyDown) {
2400 hideMenu = (hideMenu? false:true);
2401 }
2402
2403 if (keys[SDLK_RIGHT] && bKeyDown) {
2404 switch (menuSelected) {
2405 case 0:
2406 filterValue ++ ;
2407 if (filterValue>2) filterValue= 0;
2408 filterChanged = true;
2409 break;
2410
2411 case 1:
2412 if (GLvar->fMaxAnis!=0) {
2413 anisValue *=2 ;
2414 if (anisValue>GLvar->fMaxAnis) anisValue= 1;
2415 anisChanged = true;
2416 }
2417 break;
2418 case 2:
2419 detailValue ++ ;
2420 if (detailValue>2) detailValue= 0;
2421 detailChanged = true;
2422 break;
2423 case 3:
2424 GLvar->bShadows = (GLvar->bShadows? false:true);
2425 sprintf(infos[3],"Shadows: %s", (GLvar->bShadows? "On":"Off"));
2426 shadowChanged = true;
2427 break;
2428 }
2429 }
2430 if (keys[SDLK_LEFT] && bKeyDown) {
2431 switch (menuSelected) {
2432 case 0:
2433 filterValue -- ;
2434 if (filterValue<0) filterValue= 2;
2435 filterChanged = true;
2436 break;
2437 case 1:
2438 if (GLvar->fMaxAnis!=0) {
2439 anisValue /=2 ;
2440 if (anisValue<1) anisValue= (int)(GLvar->fMaxAnis);
2441 anisChanged = true;
2442 }
2443 break;
2444 case 2:
2445 detailValue -- ;
2446 if (detailValue<0) detailValue= 2;
2447 detailChanged = true;
2448 break;
2449 case 3:
2450 GLvar->bShadows = (GLvar->bShadows? false:true);
2451 shadowChanged = true;
2452 sprintf(infos[3],"Shadows: %s", (GLvar->bShadows? "On":"Off"));
2453 break;
2454
2455 }
2456 }
2457
2458 if (filterChanged) {
2459 sprintf(infos[0], "Texture filtering: %s", filterChars[filterValue]);
2460 switch (filterValue) {
2461 case 0:
2462 changeAllTextures(GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST);
2463 break;
2464 case 1:
2465 changeAllTextures(GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST);
2466 break;
2467 case 2:
2468 changeAllTextures(GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR);
2469 break;
2470 }
2471 }
2472 if (anisChanged) {
2473 sprintf(infos[1],"Anisotropic texturing: %d", anisValue);
2474 changeAllTexturesAnis(anisValue);
2475 }
2476
2477 if (detailChanged) {
2478 sprintf(infos[2],"Details level: %s", detailChars[detailValue]);
2479 GLvar->details = detailValue;
2480 }
2481 if (detailChanged || anisChanged || filterChanged || shadowChanged) {
2482 FILE *fOptions = fopen(GLvar->getFullOptionsPath(), "w+");
2483 if( fOptions!=NULL) {
2484 fprintf(fOptions, "%d %d %d %d", filterValue, anisValue, detailValue, GLvar->bShadows?1:0);
2485 fclose(fOptions);
2486 }
2487 }
2488 }
2489 break;
2490 case 4:
2491 {
2492 // SHOULD BE FINISHED BY MAIN
2493 break;
2494 }
2495 }
2496 }
2497
2498
2499
2500
2501