?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
console: Format tabs semi-intelligently
[attac-man.git] / render_map.c
blob64faf12d2024da6d87c516ef1b2765c5c2ac391b
1 /*
2 Pacman Arena
3 Copyright (C) 2003 Nuno Subtil
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19
20 static const char cvsid[] =
21 "$Id: render_map.c,v 1.4 2003/11/30 17:43:55 nsubtil Exp $";
22
23 #ifdef _WIN32
24 #include <windows.h>
25 #endif
26
27 #include <SDL.h>
28 #include <GL/gl.h>
29 #include <GL/glu.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <stdio.h>
33 #include <math.h>
34
35 #include "object.h"
36 #include "game.h"
37 #include "player.h"
38 #include "render.h"
39 #include "gfx.h"
40 #include "m_math.h"
41 #include "shot.h"
42
43 #include "map.h"
44
45 /*
46 prepara-se para desenhar um tile do mapa
47 */
48 void map_setup_wall(struct game *game, int x, int y)
49 {
50 struct map *map;
51 #if 0
52 static struct image_rgba32 *rocket_lightmap = NULL;
53 int c;
54
55 if(rocket_lightmap == NULL)
56 {
57 rocket_lightmap = gfx_get("gfx/rocket-highlight.tga");
58 gfx_alpha_from_intensity("gfx/rocket-highlight.tga");
59 gfx_upload_texture("gfx/rocket-highlight.tga");
60 }
61 #endif
62
63 map = game->map;
64
65 glMatrixMode(GL_MODELVIEW);
66 glLoadIdentity();
67
68 glTranslatef((GLfloat)x + 0.5, -0.5, (GLfloat)y + 0.5);
69
70 glEnable(GL_DEPTH_TEST);
71 glDepthMask(GL_TRUE);
72 // glDisable(GL_TEXTURE_2D);
73 // glDisable(GL_BLEND);
74
75 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
76 glEnable(GL_COLOR_MATERIAL);
77
78 #if 0
79 /* compute lightmaps */
80 for(c = 0; c < game->n_shots; c++)
81 {
82 if(game->shots[c].type == SHOT_TYPE_ROCKET && game->shots[c].state == SHOT_STATE_ACTIVE)
83 {
84 int rx, ry;
85
86 rx = (int)game->shots[c].position[X];
87 ry = (int)game->shots[c].position[Z];
88
89 switch(MAP(game->map, x, y).wall)
90 {
91 case MAP_WALL_HORIZONTAL:
92 if(rx == x && (ry == y - 1 || ry == y + 1))
93 {
94 GLfloat params[4];
95
96 /* XXX - multitexturing! */
97 glActiveTexture(GL_TEXTURE0_ARB);
98 glDisable(GL_TEXTURE_2D);
99
100 glActiveTexture(GL_TEXTURE1_ARB);
101 glBindTexture(GL_TEXTURE_2D, rocket_lightmap->id);
102 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
103 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
104 glEnable(GL_TEXTURE_2D);
105
106 map_lightmap_param_rocket(params, game, x, y, c);
107
108 params[X] = 1.0;
109 params[Y] = 1.0;
110 params[Z] = 1.0;
111 params[W] = 1.0;
112 glTexGenfv(GL_S, GL_OBJECT_PLANE, params);
113 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
114 glEnable(GL_TEXTURE_GEN_S);
115
116 params[X] = 1.0;
117 params[Y] = 1.0;
118 params[Z] = 1.0;
119 params[W] = 1.0;
120 glTexGenfv(GL_T, GL_OBJECT_PLANE, params);
121 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
122 glEnable(GL_TEXTURE_GEN_T);
123
124 glBlendFunc(GL_ONE, GL_ONE);
125 glEnable(GL_BLEND);
126
127 return;
128 }
129
130 break;
131 }
132 }
133 }
134 #endif
135 }
136
137 /*
138 computes lightmap parameters for wall at x, y and rocket n
139 */
140 void map_lightmap_param_rocket(GLfloat params[4], struct game *game, int x, int y, int r)
141 {
142 struct map *map;
143 struct shot *rocket;
144
145 map = game->map;
146 rocket = &game->shots[r];
147
148 /* xxx - do something nice */
149 params[0] = 1.0;
150 params[1] = 1.0;
151 params[2] = 0.0;
152 params[3] = 1.0;
153 }
154
155 /*
156 desenha uma parede vertical em x, y
157 */
158 void map_draw_vertical_wall(struct game *game, int x, int y)
159 {
160 static struct object *wall = NULL;
161
162 map_setup_wall(game, x, y);
163
164 if(wall == NULL)
165 {
166 int nframes;
167
168 wall = object_read_file("gfx/wall-vertical.3d", &nframes);
169 }
170
171 render_dlist(wall, NULL);
172 }
173
174 /*
175 desenha uma parede horizontal em (x, y)
176 */
177 void map_draw_horizontal_wall(struct game *game, int x, int y)
178 {
179 static struct object *wall = NULL;
180
181 map_setup_wall(game, x, y);
182
183 if(wall == NULL)
184 {
185 int nframes;
186
187 wall = object_read_file("gfx/wall-horizontal.3d", &nframes);
188 render_compile_dlist(wall);
189 }
190
191 render_dlist(wall, NULL);
192 }
193
194 /*
195 canto inferior esquerdo
196 */
197 void map_draw_ll_wall(struct game *game, int x, int y)
198 {
199 static struct object *wall = NULL;
200
201 map_setup_wall(game, x, y);
202
203 if(wall == NULL)
204 {
205 int nframes;
206
207 wall = object_read_file("gfx/wall-ll.3d", &nframes);
208 render_compile_dlist(wall);
209 }
210
211 render_dlist(wall, NULL);
212 }
213
214 /*
215 canto inferior direito
216 */
217 void map_draw_lr_wall(struct game *game, int x, int y)
218 {
219 static struct object *wall = NULL;
220
221 map_setup_wall(game, x, y);
222
223 if(wall == NULL)
224 {
225 int nframes;
226
227 wall = object_read_file("gfx/wall-lr.3d", &nframes);
228 render_compile_dlist(wall);
229 }
230
231 render_dlist(wall, NULL);
232 }
233
234 /*
235 canto superior direito
236 */
237 void map_draw_ur_wall(struct game *game, int x, int y)
238 {
239 static struct object *wall = NULL;
240
241 map_setup_wall(game, x, y);
242
243 if(wall == NULL)
244 {
245 int nframes;
246
247 wall = object_read_file("gfx/wall-ur.3d", &nframes);
248 render_compile_dlist(wall);
249 }
250
251 render_dlist(wall, NULL);
252 }
253
254 /*
255 canto superior esquerdo
256 */
257 void map_draw_ul_wall(struct game *game, int x, int y)
258 {
259 static struct object *wall = NULL;
260
261 map_setup_wall(game, x, y);
262
263 if(wall == NULL)
264 {
265 int nframes;
266
267 wall = object_read_file("gfx/wall-ul.3d", &nframes);
268 render_compile_dlist(wall);
269 }
270
271 render_dlist(wall, NULL);
272 }
273
274 /*
275 desenha comida do pacman em (x,y) no mapa
276 */
277 void map_draw_pacman_food(struct map *map, int x, int y)
278 {
279 static struct image_rgba32 *food = NULL;
280
281 if(food == NULL)
282 {
283 food = gfx_get("gfx/dot-yellow.tga");
284 gfx_alpha_from_intensity("gfx/dot-yellow.tga");
285 gfx_upload_texture("gfx/dot-yellow.tga");
286 }
287
288 glDisable(GL_LIGHTING);
289 glEnable(GL_DEPTH_TEST);
290 glEnable(GL_BLEND);
291 // glBlendFunc(GL_ONE, GL_ONE);
292 // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
293 glEnable(GL_TEXTURE_2D);
294 glBindTexture(GL_TEXTURE_2D, food->id);
295
296 glDepthMask(GL_FALSE);
297
298 switch(MAP_FOOD(map, x, y).type)
299 {
300 case FOOD_TYPE_NORMAL:
301 if(MAP_FOOD(map, x, y).status == FOOD_STATUS_ACTIVE)
302 render_draw_plane((GLfloat)x + 0.5, -0.5, (GLfloat)y + 0.5, 1.0);
303
304 break;
305
306 case FOOD_TYPE_RESPAWN:
307 if(MAP_FOOD(map, x, y).status == FOOD_STATUS_EATEN)
308 {
309 if(MAP_FOOD(map, x, y).time <= MAP_FOOD(map, x, y).fade_in)
310 render_draw_plane((GLfloat)x + 0.5, -0.5, (GLfloat)y + 0.5,
311 1.0 - (MAP_FOOD(map, x, y).time /
312 MAP_FOOD(map, x, y).fade_in));
313 } else
314 /* active */
315 render_draw_plane((GLfloat)x + 0.5, -0.5, (GLfloat)y + 0.5, 1.0);
316
317 break;
318
319 case FOOD_TYPE_INTERMITTENT:
320 if(MAP_FOOD(map, x, y).status == FOOD_STATUS_ACTIVE)
321 {
322 if(MAP_FOOD(map, x, y).time <= MAP_FOOD(map, x, y).fade_out)
323 render_draw_plane((GLfloat)x + 0.5, -0.5, (GLfloat)y + 0.5,
324 (MAP_FOOD(map, x, y).time /
325 MAP_FOOD(map, x, y).fade_out));
326 else
327 render_draw_plane((GLfloat)x + 0.5, -0.5, (GLfloat)y + 0.5, 1.0);
328 } else {
329 if(MAP_FOOD(map, x, y).time <= MAP_FOOD(map, x, y).fade_in)
330 render_draw_plane((GLfloat)x + 0.5, -0.5, (GLfloat)y + 0.5,
331 1.0 - (MAP_FOOD(map, x, y).time /
332 MAP_FOOD(map, x, y).fade_in));
333 }
334
335 break;
336 }
337
338 glDepthMask(GL_TRUE);
339 }
340
341 void map_draw_pacman_pill(struct map *map, int x, int y)
342 {
343 static GLUquadricObj *sphere = NULL;
344
345 if(sphere == NULL)
346 {
347 sphere = gluNewQuadric();
348 gluQuadricNormals(sphere, GLU_SMOOTH);
349 gluQuadricTexture(sphere, GLU_FALSE);
350 gluQuadricOrientation(sphere, GLU_OUTSIDE);
351 gluQuadricDrawStyle(sphere, GLU_FILL);
352 }
353
354 glMatrixMode(GL_MODELVIEW);
355 glLoadIdentity();
356
357 /* XXX - isto a mexer fica mais giro */
358 // glTranslatef((GLfloat)x + 0.5, pill_height, (GLfloat)y + 0.5);
359 // glTranslatef((GLfloat)x + 0.5, MAP(map, x, y).c_data.pill.height, (GLfloat)y + 0.5);
360 glTranslatef((GLfloat)x + 0.5,
361 -0.5 + 0.25 * sin(PILL_BOB_FREQUENCY * (float)SDL_GetTicks() / 1000.0 +
362 MAP(map, x, y).c_data.pill.phase),
363 (GLfloat)y + 0.5);
364
365 glEnable(GL_DEPTH_TEST);
366 glDepthMask(GL_TRUE);
367 glDisable(GL_TEXTURE_2D);
368 glDisable(GL_BLEND);
369
370 glColor4f(0.91, 0.88, 0.28, 1.0);
371 gluSphere(sphere, 0.2, 15, 15);
372 }
373
374 void map_draw_wall(struct game *game, int x, int y)
375 {
376 struct map *map;
377
378 map = game->map;
379
380 switch(MAP(map, x, y).wall)
381 {
382 case MAP_WALL_HORIZONTAL:
383 map_draw_horizontal_wall(game, x, y);
384 break;
385
386 case MAP_WALL_VERTICAL:
387 map_draw_vertical_wall(game, x, y);
388 break;
389
390 case MAP_WALL_LL:
391 map_draw_ll_wall(game, x, y);
392 break;
393
394 case MAP_WALL_UL:
395 map_draw_ul_wall(game, x, y);
396 break;
397
398 case MAP_WALL_LR:
399 map_draw_lr_wall(game, x, y);
400 break;
401
402 case MAP_WALL_UR:
403 map_draw_ur_wall(game, x, y);
404 break;
405
406 default:
407 break;
408 }
409 }
410
411 void map_render_opaque_objects(struct game *game)
412 {
413 int x, y;
414 struct map *map;
415
416 map = game->map;
417
418 /* pass 1: untextured geometry */
419
420 glDisable(GL_BLEND);
421 glDisable(GL_TEXTURE_2D);
422
423 for(x = 0; x < map->width; x++)
424 for(y = 0; y < map->height; y++)
425 {
426 map_draw_wall(game, x, y);
427
428 glDisable(GL_BLEND);
429 glDisable(GL_TEXTURE_2D);
430 glDisable(GL_TEXTURE_GEN_S);
431 glDisable(GL_TEXTURE_GEN_T);
432
433 switch(MAP(map, x, y).content)
434 {
435 case MAP_CONTENT_PILL:
436 if(MAP(map, x, y).c_data.pill.status == PILL_STATUS_ACTIVE)
437 map_draw_pacman_pill(map, x, y);
438 break;
439 }
440 }
441
442 #ifdef UGLY_LIGHTMAPS
443 /* pass 2: additive lightmaps */
444 for(c = 0; c < game->n_shots; c++)
445 switch(game->shots[c].type)
446 {
447 case SHOT_TYPE_ROCKET:
448 if(game->shots[c].state != SHOT_STATE_ACTIVE)
449 continue;
450
451 map_draw_rocket_lightmap(game, c);
452 break;
453 }
454 #endif
455 }
456
457 void map_draw_rocket_lightmap(struct game *game, int c)
458 {
459 static struct image_rgba32 *texture = NULL;
460 struct shot *rocket;
461 int x, y;
462
463 /* object plane coefficients (s, t, r, q) */
464 GLfloat params[4];
465
466 if(texture == NULL)
467 {
468 texture = gfx_get("gfx/rocket-highlight.tga");
469 gfx_upload_texture("gfx/rocket-highlight.tga");
470 }
471
472 rocket = &game->shots[c];
473
474 /* set up texturing */
475 glBindTexture(GL_TEXTURE_2D, texture->id);
476 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
477 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
478 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
479 glEnable(GL_TEXTURE_2D);
480
481 /* texture coordinate generation */
482 switch(rocket->direction)
483 {
484 case DIRECTION_LEFT:
485 params[X] = -1.0;
486 params[Y] = 0.0;
487 params[Z] = 1.0;
488 params[W] = 1.0;
489 break;
490
491 case DIRECTION_RIGHT:
492 params[X] = 1.0;
493 params[Y] = 0.0;
494 params[Z] = 1.0;
495 params[W] = 1.0;
496 break;
497
498 case DIRECTION_UP:
499 params[X] = 0.0;
500 params[Y] = 0.0;
501 params[Z] = 1.0;
502 params[W] = 1.0;
503 break;
504
505 case DIRECTION_DOWN:
506 params[X] = 0.0;
507 params[Y] = 0.0;
508 params[Z] = -1.0;
509 params[W] = 1.0;
510 break;
511 }
512
513 glTexGenfv(GL_S, GL_OBJECT_PLANE, params);
514 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
515 glEnable(GL_TEXTURE_GEN_S);
516
517 params[X] = 0.0;
518 params[Y] = 1.0;
519 params[Z] = 0.0;
520 params[W] = 1.0;
521 glTexGenfv(GL_T, GL_OBJECT_PLANE, params);
522 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
523 glEnable(GL_TEXTURE_GEN_T);
524
525 /* additive alpha blending */
526 glBlendFunc(GL_ONE, GL_ONE);
527 glEnable(GL_BLEND);
528
529 glColor4f(1.0, 1.0, 1.0, 1.0);
530
531 /* draw map squares */
532 x = (int)rocket->position[X];
533 y = (int)rocket->position[Z];
534
535 switch(rocket->direction)
536 {
537 case DIRECTION_LEFT:
538 /* up right square */
539
540 /* glPolygonOffset and glDepthFunc(GL_LESS) might be a better idea
541 instead of messing with the projection matrix */
542 glMatrixMode(GL_PROJECTION);
543 glPushMatrix();
544 glTranslatef(0.0, 0.0, -0.01);
545
546 glMatrixMode(GL_TEXTURE);
547 glLoadIdentity();
548 glTranslatef(-(rocket->position[X] - (float)x) + 1.0, -0.5, 0.3);
549
550 #if 0
551 switch(MAP(game->map, x + 1, y + 1).wall)
552 {
553 case MAP_WALL_LL:
554 /* fix texturing for LL corners */
555 printf("fixing LL corner for UR\n");
556 params[X] = -1.0;
557 params[Y] = 0.0;
558 params[Z] = 1.0;
559 params[W] = 1.0;
560 break;
561
562 default:
563 params[X] = -1.0;
564 params[Y] = 0.0;
565 params[Z] = 1.0;
566 params[W] = 1.0;
567 break;
568 }
569
570 glTexGenfv(GL_S, GL_OBJECT_PLANE, params);
571 #endif
572 map_draw_wall(game, x + 1, y + 1);
573
574 /* up square */
575 glMatrixMode(GL_TEXTURE);
576 glLoadIdentity();
577 glTranslatef(-(rocket->position[X] - (float)x), -0.5, 0.3);
578
579 #if 0
580 switch(MAP(game->map, x, y + 1).wall)
581 {
582 case MAP_WALL_LL:
583 /* fix texturing for LL corners */
584 printf("fixing LL corner for UP\n");
585 params[X] = -1.0;
586 params[Y] = 0.0;
587 params[Z] = 1.0;
588 params[W] = 1.0;
589 break;
590
591 default:
592 params[X] = -1.0;
593 params[Y] = 0.0;
594 params[Z] = 1.0;
595 params[W] = 1.0;
596 break;
597 }
598
599 glTexGenfv(GL_S, GL_OBJECT_PLANE, params);
600 #endif
601 map_draw_wall(game, x, y + 1);
602
603
604 /* down right square */
605 glMatrixMode(GL_PROJECTION);
606 glPopMatrix();
607 glPushMatrix();
608 glTranslatef(0.0, 0.0, 0.01);
609
610 glMatrixMode(GL_TEXTURE);
611 glLoadIdentity();
612 glTranslatef(-(rocket->position[X] - (float)x), -0.5, 0.3);
613
614 map_draw_wall(game, x + 1, y - 1);
615
616 /* down square */
617 glMatrixMode(GL_TEXTURE);
618 glLoadIdentity();
619 glTranslatef(-(rocket->position[X] - (float)x) - 1.0, -0.5, 0.3);
620
621 map_draw_wall(game, x, y - 1);
622
623 glMatrixMode(GL_PROJECTION);
624 glPopMatrix();
625
626 break;
627
628 case DIRECTION_RIGHT:
629 /* up left square */
630 glMatrixMode(GL_PROJECTION);
631 glPushMatrix();
632 glTranslatef(0.0, 0.0, -0.01);
633
634 glMatrixMode(GL_TEXTURE);
635 glLoadIdentity();
636 glTranslatef(-(rocket->position[X] - (float)x), -0.5, 0.0);
637
638 map_draw_wall(game, x - 1, y + 1);
639
640 /* up square */
641 glMatrixMode(GL_TEXTURE);
642 glLoadIdentity();
643 glTranslatef(-(rocket->position[X] - (float)x) + 1.0, -0.5, 0.0);
644
645 map_draw_wall(game, x, y + 1);
646
647
648 /* down left square */
649 glMatrixMode(GL_PROJECTION);
650 glPopMatrix();
651 glPushMatrix();
652 glTranslatef(0.0, 0.0, 0.01);
653
654 glMatrixMode(GL_TEXTURE);
655 glLoadIdentity();
656 glTranslatef(-(rocket->position[X] - (float)x) - 1.0, -0.5, 0.0);
657
658 map_draw_wall(game, x - 1, y - 1);
659
660 /* down square */
661 glMatrixMode(GL_TEXTURE);
662 glLoadIdentity();
663 glTranslatef(-(rocket->position[X] - (float)x), -0.5, 0.0);
664
665 map_draw_wall(game, x, y - 1);
666
667 glMatrixMode(GL_PROJECTION);
668 glPopMatrix();
669
670 break;
671
672 case DIRECTION_UP:
673 /* left down square */
674 glMatrixMode(GL_PROJECTION);
675 glPushMatrix();
676 glTranslatef(0.01, 0.0, 0.0);
677
678 glMatrixMode(GL_TEXTURE);
679 glLoadIdentity();
680 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y));
681
682 map_draw_wall(game, x - 1, y - 1);
683
684 /* left square */
685 glMatrixMode(GL_TEXTURE);
686 glLoadIdentity();
687 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y) + 1.0);
688
689 map_draw_wall(game, x - 1, y);
690
691 /* right down square */
692 glMatrixMode(GL_PROJECTION);
693 glPopMatrix();
694 glPushMatrix();
695 glTranslatef(-0.01, 0.0, 0.0);
696
697 glMatrixMode(GL_TEXTURE);
698 glLoadIdentity();
699 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y));
700
701 map_draw_wall(game, x + 1, y - 1);
702
703 /* right square */
704 glMatrixMode(GL_TEXTURE);
705 glLoadIdentity();
706 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y) + 1.0);
707
708 map_draw_wall(game, x + 1, y);
709
710 glMatrixMode(GL_PROJECTION);
711 glPopMatrix();
712
713 break;
714
715 case DIRECTION_DOWN:
716 /* left up square */
717 glMatrixMode(GL_PROJECTION);
718 glPushMatrix();
719 glTranslatef(0.01, 0.0, 0.0);
720
721 glMatrixMode(GL_TEXTURE);
722 glLoadIdentity();
723 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y) + 1.0);
724
725 map_draw_wall(game, x - 1, y + 1);
726
727 /* left square */
728 glMatrixMode(GL_TEXTURE);
729 glLoadIdentity();
730 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y));
731
732 map_draw_wall(game, x - 1, y);
733
734 /* right up square */
735 glMatrixMode(GL_PROJECTION);
736 glPopMatrix();
737 glPushMatrix();
738 glTranslatef(-0.01, 0.0, 0.0);
739
740 glMatrixMode(GL_TEXTURE);
741 glLoadIdentity();
742 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y) + 1.0);
743
744 map_draw_wall(game, x + 1, y + 1);
745
746 /* right square */
747 glMatrixMode(GL_TEXTURE);
748 glLoadIdentity();
749 glTranslatef(0.0, -0.5, -(rocket->position[Z] - (float)y));
750
751 map_draw_wall(game, x + 1, y);
752
753 glMatrixMode(GL_PROJECTION);
754 glPopMatrix();
755
756 break;
757 }
758
759 glDisable(GL_BLEND);
760 glDisable(GL_TEXTURE_GEN_S);
761 glDisable(GL_TEXTURE_GEN_T);
762 glDisable(GL_TEXTURE_2D);
763 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
764
765 glMatrixMode(GL_TEXTURE);
766 glLoadIdentity();
767 glMatrixMode(GL_MODELVIEW);
768 }
769
770 void map_render_translucent_objects(struct game *game, int player_no)
771 {
772 int x, y;
773 struct map *map;
774 struct camera *cam;
775
776 if(player_no == -1)
777 cam = game->demo_camera;
778 else
779 cam = game->players[player_no].camera;
780
781 render_setup_plane_geometry(cam, 1.0);
782
783 map = game->map;
784 for(x = 0; x < map->width; x++)
785 for(y = 0; y < map->height; y++)
786 switch(MAP(map, x, y).content)
787 {
788 case MAP_CONTENT_FOOD:
789 /* comidinha do pacman */
790 map_draw_pacman_food(map, x, y);
791 break;
792 }
793
794 }
multi-player pac-man clone