Rev 298 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
298 | serge | 1 | // Emacs style mode select -*- C++ -*- |
2 | //----------------------------------------------------------------------------- |
||
3 | // |
||
4 | // $Id:$ |
||
5 | // |
||
6 | // Copyright (C) 1993-1996 by id Software, Inc. |
||
7 | // |
||
8 | // This source is available for distribution and/or modification |
||
9 | // only under the terms of the DOOM Source Code License as |
||
10 | // published by id Software. All rights reserved. |
||
11 | // |
||
12 | // The source is distributed in the hope that it will be useful, |
||
13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
14 | // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License |
||
15 | // for more details. |
||
16 | // |
||
17 | // $Log:$ |
||
18 | // |
||
19 | // DESCRIPTION: |
||
333 | serge | 20 | // Rendering main loop and setup functions, |
21 | // utility functions (BSP, geometry, trigonometry). |
||
22 | // See tables.c, too. |
||
298 | serge | 23 | // |
24 | //----------------------------------------------------------------------------- |
||
25 | |||
26 | |||
333 | serge | 27 | //static const char rcsid[] = "$Id: r_main.c,v 1.5 1997/02/03 22:45:12 b1 Exp $"; |
298 | serge | 28 | |
29 | |||
30 | |||
31 | #include |
||
32 | #include |
||
33 | |||
34 | |||
35 | #include "doomdef.h" |
||
36 | #include "d_net.h" |
||
37 | |||
38 | #include "m_bbox.h" |
||
39 | |||
40 | #include "r_local.h" |
||
41 | #include "r_sky.h" |
||
42 | |||
43 | |||
44 | |||
45 | |||
46 | |||
47 | // Fineangles in the SCREENWIDTH wide window. |
||
333 | serge | 48 | #define FIELDOFVIEW 2048 |
298 | serge | 49 | |
50 | |||
51 | |||
333 | serge | 52 | int viewangleoffset; |
298 | serge | 53 | |
54 | // increment every time a check is made |
||
333 | serge | 55 | int validcount = 1; |
298 | serge | 56 | |
57 | |||
333 | serge | 58 | lighttable_t* fixedcolormap; |
59 | extern lighttable_t** walllights; |
||
298 | serge | 60 | |
333 | serge | 61 | int centerx; |
62 | int centery; |
||
298 | serge | 63 | |
333 | serge | 64 | fixed_t centerxfrac; |
65 | fixed_t centeryfrac; |
||
66 | fixed_t projection; |
||
298 | serge | 67 | |
68 | // just for profiling purposes |
||
333 | serge | 69 | int framecount; |
298 | serge | 70 | |
333 | serge | 71 | int sscount; |
72 | int linecount; |
||
73 | int loopcount; |
||
298 | serge | 74 | |
333 | serge | 75 | fixed_t viewx; |
76 | fixed_t viewy; |
||
77 | fixed_t viewz; |
||
298 | serge | 78 | |
333 | serge | 79 | angle_t viewangle; |
298 | serge | 80 | |
333 | serge | 81 | fixed_t viewcos; |
82 | fixed_t viewsin; |
||
298 | serge | 83 | |
333 | serge | 84 | player_t* viewplayer; |
298 | serge | 85 | |
86 | // 0 = high, 1 = low |
||
333 | serge | 87 | int detailshift; |
298 | serge | 88 | |
89 | // |
||
90 | // precalculated math tables |
||
91 | // |
||
333 | serge | 92 | angle_t clipangle; |
298 | serge | 93 | |
94 | // The viewangletox[viewangle + FINEANGLES/4] lookup |
||
95 | // maps the visible view angles to screen X coordinates, |
||
96 | // flattening the arc to a flat projection plane. |
||
97 | // There will be many angles mapped to the same X. |
||
333 | serge | 98 | int viewangletox[FINEANGLES/2]; |
298 | serge | 99 | |
100 | // The xtoviewangleangle[] table maps a screen pixel |
||
101 | // to the lowest viewangle that maps back to x ranges |
||
102 | // from clipangle to -clipangle. |
||
333 | serge | 103 | angle_t xtoviewangle[SCREENWIDTH+1]; |
298 | serge | 104 | |
105 | |||
106 | // UNUSED. |
||
107 | // The finetangentgent[angle+FINEANGLES/4] table |
||
108 | // holds the fixed_t tangent values for view angles, |
||
109 | // ranging from MININT to 0 to MAXINT. |
||
333 | serge | 110 | // fixed_t finetangent[FINEANGLES/2]; |
298 | serge | 111 | |
333 | serge | 112 | // fixed_t finesine[5*FINEANGLES/4]; |
113 | fixed_t* finecosine = &finesine[FINEANGLES/4]; |
||
298 | serge | 114 | |
115 | |||
333 | serge | 116 | lighttable_t* scalelight[LIGHTLEVELS][MAXLIGHTSCALE]; |
117 | lighttable_t* scalelightfixed[MAXLIGHTSCALE]; |
||
118 | lighttable_t* zlight[LIGHTLEVELS][MAXLIGHTZ]; |
||
298 | serge | 119 | |
120 | // bumped light from gun blasts |
||
333 | serge | 121 | int extralight; |
298 | serge | 122 | |
123 | |||
124 | |||
125 | void (*colfunc) (void); |
||
126 | void (*basecolfunc) (void); |
||
127 | void (*fuzzcolfunc) (void); |
||
128 | void (*transcolfunc) (void); |
||
129 | void (*spanfunc) (void); |
||
130 | |||
131 | |||
132 | |||
133 | // |
||
134 | // R_AddPointToBox |
||
135 | // Expand a given bbox |
||
136 | // so that it encloses a given point. |
||
137 | // |
||
138 | void |
||
139 | R_AddPointToBox |
||
333 | serge | 140 | ( int x, |
141 | int y, |
||
142 | fixed_t* box ) |
||
298 | serge | 143 | { |
144 | if (x< box[BOXLEFT]) |
||
333 | serge | 145 | box[BOXLEFT] = x; |
298 | serge | 146 | if (x> box[BOXRIGHT]) |
333 | serge | 147 | box[BOXRIGHT] = x; |
298 | serge | 148 | if (y< box[BOXBOTTOM]) |
333 | serge | 149 | box[BOXBOTTOM] = y; |
298 | serge | 150 | if (y> box[BOXTOP]) |
333 | serge | 151 | box[BOXTOP] = y; |
298 | serge | 152 | } |
153 | |||
154 | |||
155 | // |
||
156 | // R_PointOnSide |
||
157 | // Traverse BSP (sub) tree, |
||
158 | // check point against partition plane. |
||
159 | // Returns side 0 (front) or 1 (back). |
||
160 | // |
||
161 | int |
||
162 | R_PointOnSide |
||
333 | serge | 163 | ( fixed_t x, |
164 | fixed_t y, |
||
165 | node_t* node ) |
||
298 | serge | 166 | { |
333 | serge | 167 | fixed_t dx; |
168 | fixed_t dy; |
||
169 | fixed_t left; |
||
170 | fixed_t right; |
||
171 | |||
298 | serge | 172 | if (!node->dx) |
173 | { |
||
333 | serge | 174 | if (x <= node->x) |
175 | return node->dy > 0; |
||
176 | |||
177 | return node->dy < 0; |
||
298 | serge | 178 | } |
179 | if (!node->dy) |
||
180 | { |
||
333 | serge | 181 | if (y <= node->y) |
182 | return node->dx < 0; |
||
183 | |||
184 | return node->dx > 0; |
||
298 | serge | 185 | } |
333 | serge | 186 | |
298 | serge | 187 | dx = (x - node->x); |
188 | dy = (y - node->y); |
||
333 | serge | 189 | |
298 | serge | 190 | // Try to quickly decide by looking at sign bits. |
191 | if ( (node->dy ^ node->dx ^ dx ^ dy)&0x80000000 ) |
||
192 | { |
||
333 | serge | 193 | if ( (node->dy ^ dx) & 0x80000000 ) |
194 | { |
||
195 | // (left is negative) |
||
196 | return 1; |
||
197 | } |
||
198 | return 0; |
||
298 | serge | 199 | } |
200 | |||
201 | left = FixedMul ( node->dy>>FRACBITS , dx ); |
||
202 | right = FixedMul ( dy , node->dx>>FRACBITS ); |
||
333 | serge | 203 | |
298 | serge | 204 | if (right < left) |
205 | { |
||
333 | serge | 206 | // front side |
207 | return 0; |
||
298 | serge | 208 | } |
209 | // back side |
||
333 | serge | 210 | return 1; |
298 | serge | 211 | } |
212 | |||
213 | |||
214 | int |
||
215 | R_PointOnSegSide |
||
333 | serge | 216 | ( fixed_t x, |
217 | fixed_t y, |
||
218 | seg_t* line ) |
||
298 | serge | 219 | { |
333 | serge | 220 | fixed_t lx; |
221 | fixed_t ly; |
||
222 | fixed_t ldx; |
||
223 | fixed_t ldy; |
||
224 | fixed_t dx; |
||
225 | fixed_t dy; |
||
226 | fixed_t left; |
||
227 | fixed_t right; |
||
228 | |||
298 | serge | 229 | lx = line->v1->x; |
230 | ly = line->v1->y; |
||
333 | serge | 231 | |
298 | serge | 232 | ldx = line->v2->x - lx; |
233 | ldy = line->v2->y - ly; |
||
333 | serge | 234 | |
298 | serge | 235 | if (!ldx) |
236 | { |
||
333 | serge | 237 | if (x <= lx) |
238 | return ldy > 0; |
||
239 | |||
240 | return ldy < 0; |
||
298 | serge | 241 | } |
242 | if (!ldy) |
||
243 | { |
||
333 | serge | 244 | if (y <= ly) |
245 | return ldx < 0; |
||
246 | |||
247 | return ldx > 0; |
||
298 | serge | 248 | } |
333 | serge | 249 | |
298 | serge | 250 | dx = (x - lx); |
251 | dy = (y - ly); |
||
333 | serge | 252 | |
298 | serge | 253 | // Try to quickly decide by looking at sign bits. |
254 | if ( (ldy ^ ldx ^ dx ^ dy)&0x80000000 ) |
||
255 | { |
||
333 | serge | 256 | if ( (ldy ^ dx) & 0x80000000 ) |
257 | { |
||
258 | // (left is negative) |
||
259 | return 1; |
||
260 | } |
||
261 | return 0; |
||
298 | serge | 262 | } |
263 | |||
264 | left = FixedMul ( ldy>>FRACBITS , dx ); |
||
265 | right = FixedMul ( dy , ldx>>FRACBITS ); |
||
333 | serge | 266 | |
298 | serge | 267 | if (right < left) |
268 | { |
||
333 | serge | 269 | // front side |
270 | return 0; |
||
298 | serge | 271 | } |
272 | // back side |
||
333 | serge | 273 | return 1; |
298 | serge | 274 | } |
275 | |||
276 | |||
277 | // |
||
278 | // R_PointToAngle |
||
279 | // To get a global angle from cartesian coordinates, |
||
280 | // the coordinates are flipped until they are in |
||
281 | // the first octant of the coordinate system, then |
||
282 | // the y (<=x) is scaled and divided by x to get a |
||
283 | // tangent (slope) value which is looked up in the |
||
284 | // tantoangle[] table. |
||
285 | |||
286 | // |
||
287 | |||
288 | |||
289 | |||
290 | |||
291 | angle_t |
||
292 | R_PointToAngle |
||
333 | serge | 293 | ( fixed_t x, |
294 | fixed_t y ) |
||
295 | { |
||
298 | serge | 296 | x -= viewx; |
297 | y -= viewy; |
||
298 | |||
299 | if ( (!x) && (!y) ) |
||
333 | serge | 300 | return 0; |
298 | serge | 301 | |
302 | if (x>= 0) |
||
303 | { |
||
333 | serge | 304 | // x >=0 |
305 | if (y>= 0) |
||
306 | { |
||
307 | // y>= 0 |
||
298 | serge | 308 | |
333 | serge | 309 | if (x>y) |
310 | { |
||
311 | // octant 0 |
||
312 | return tantoangle[ SlopeDiv(y,x)]; |
||
313 | } |
||
314 | else |
||
315 | { |
||
316 | // octant 1 |
||
317 | return ANG90-1-tantoangle[ SlopeDiv(x,y)]; |
||
318 | } |
||
319 | } |
||
320 | else |
||
321 | { |
||
322 | // y<0 |
||
323 | y = -y; |
||
298 | serge | 324 | |
333 | serge | 325 | if (x>y) |
326 | { |
||
327 | // octant 8 |
||
328 | return -tantoangle[SlopeDiv(y,x)]; |
||
329 | } |
||
330 | else |
||
331 | { |
||
332 | // octant 7 |
||
333 | return ANG270+tantoangle[ SlopeDiv(x,y)]; |
||
334 | } |
||
335 | } |
||
298 | serge | 336 | } |
337 | else |
||
338 | { |
||
333 | serge | 339 | // x<0 |
340 | x = -x; |
||
298 | serge | 341 | |
333 | serge | 342 | if (y>= 0) |
343 | { |
||
344 | // y>= 0 |
||
345 | if (x>y) |
||
346 | { |
||
347 | // octant 3 |
||
348 | return ANG180-1-tantoangle[ SlopeDiv(y,x)]; |
||
349 | } |
||
350 | else |
||
351 | { |
||
352 | // octant 2 |
||
353 | return ANG90+ tantoangle[ SlopeDiv(x,y)]; |
||
354 | } |
||
355 | } |
||
356 | else |
||
357 | { |
||
358 | // y<0 |
||
359 | y = -y; |
||
298 | serge | 360 | |
333 | serge | 361 | if (x>y) |
362 | { |
||
363 | // octant 4 |
||
364 | return ANG180+tantoangle[ SlopeDiv(y,x)]; |
||
365 | } |
||
366 | else |
||
367 | { |
||
368 | // octant 5 |
||
369 | return ANG270-1-tantoangle[ SlopeDiv(x,y)]; |
||
370 | } |
||
371 | } |
||
298 | serge | 372 | } |
373 | return 0; |
||
374 | } |
||
375 | |||
376 | |||
377 | angle_t |
||
378 | R_PointToAngle2 |
||
333 | serge | 379 | ( fixed_t x1, |
380 | fixed_t y1, |
||
381 | fixed_t x2, |
||
382 | fixed_t y2 ) |
||
383 | { |
||
298 | serge | 384 | viewx = x1; |
385 | viewy = y1; |
||
386 | |||
387 | return R_PointToAngle (x2, y2); |
||
388 | } |
||
389 | |||
390 | |||
391 | fixed_t |
||
392 | R_PointToDist |
||
333 | serge | 393 | ( fixed_t x, |
394 | fixed_t y ) |
||
298 | serge | 395 | { |
333 | serge | 396 | int angle; |
397 | fixed_t dx; |
||
398 | fixed_t dy; |
||
399 | fixed_t temp; |
||
400 | fixed_t dist; |
||
401 | |||
298 | serge | 402 | dx = abs(x - viewx); |
403 | dy = abs(y - viewy); |
||
333 | serge | 404 | |
298 | serge | 405 | if (dy>dx) |
406 | { |
||
333 | serge | 407 | temp = dx; |
408 | dx = dy; |
||
409 | dy = temp; |
||
298 | serge | 410 | } |
333 | serge | 411 | |
298 | serge | 412 | angle = (tantoangle[ FixedDiv(dy,dx)>>DBITS ]+ANG90) >> ANGLETOFINESHIFT; |
413 | |||
414 | // use as cosine |
||
333 | serge | 415 | dist = FixedDiv (dx, finesine[angle] ); |
416 | |||
298 | serge | 417 | return dist; |
418 | } |
||
419 | |||
420 | |||
421 | |||
422 | |||
423 | // |
||
424 | // R_InitPointToAngle |
||
425 | // |
||
426 | void R_InitPointToAngle (void) |
||
427 | { |
||
428 | // UNUSED - now getting from tables.c |
||
429 | #if 0 |
||
333 | serge | 430 | int i; |
431 | long t; |
||
432 | float f; |
||
298 | serge | 433 | // |
434 | // slope (tangent) to angle lookup |
||
435 | // |
||
436 | for (i=0 ; i<=SLOPERANGE ; i++) |
||
437 | { |
||
333 | serge | 438 | f = atan( (float)i/SLOPERANGE )/(3.141592657*2); |
439 | t = 0xffffffff*f; |
||
440 | tantoangle[i] = t; |
||
298 | serge | 441 | } |
442 | #endif |
||
443 | } |
||
444 | |||
445 | |||
446 | // |
||
447 | // R_ScaleFromGlobalAngle |
||
448 | // Returns the texture mapping scale |
||
449 | // for the current line (horizontal span) |
||
450 | // at the given angle. |
||
451 | // rw_distance must be calculated first. |
||
452 | // |
||
453 | fixed_t R_ScaleFromGlobalAngle (angle_t visangle) |
||
454 | { |
||
333 | serge | 455 | fixed_t scale; |
456 | int anglea; |
||
457 | int angleb; |
||
458 | int sinea; |
||
459 | int sineb; |
||
460 | fixed_t num; |
||
461 | int den; |
||
298 | serge | 462 | |
463 | // UNUSED |
||
464 | #if 0 |
||
465 | { |
||
333 | serge | 466 | fixed_t dist; |
467 | fixed_t z; |
||
468 | fixed_t sinv; |
||
469 | fixed_t cosv; |
||
470 | |||
471 | sinv = finesine[(visangle-rw_normalangle)>>ANGLETOFINESHIFT]; |
||
298 | serge | 472 | dist = FixedDiv (rw_distance, sinv); |
473 | cosv = finecosine[(viewangle-visangle)>>ANGLETOFINESHIFT]; |
||
474 | z = abs(FixedMul (dist, cosv)); |
||
475 | scale = FixedDiv(projection, z); |
||
476 | return scale; |
||
477 | } |
||
478 | #endif |
||
479 | |||
480 | anglea = ANG90 + (visangle-viewangle); |
||
481 | angleb = ANG90 + (visangle-rw_normalangle); |
||
482 | |||
483 | // both sines are allways positive |
||
333 | serge | 484 | sinea = finesine[anglea>>ANGLETOFINESHIFT]; |
298 | serge | 485 | sineb = finesine[angleb>>ANGLETOFINESHIFT]; |
486 | num = FixedMul(projection,sineb)< |
||
487 | den = FixedMul(rw_distance,sinea); |
||
488 | |||
489 | if (den > num>>16) |
||
490 | { |
||
333 | serge | 491 | scale = FixedDiv (num, den); |
298 | serge | 492 | |
333 | serge | 493 | if (scale > 64*FRACUNIT) |
494 | scale = 64*FRACUNIT; |
||
495 | else if (scale < 256) |
||
496 | scale = 256; |
||
298 | serge | 497 | } |
498 | else |
||
333 | serge | 499 | scale = 64*FRACUNIT; |
500 | |||
298 | serge | 501 | return scale; |
502 | } |
||
503 | |||
504 | |||
505 | |||
506 | // |
||
507 | // R_InitTables |
||
508 | // |
||
509 | void R_InitTables (void) |
||
510 | { |
||
511 | // UNUSED: now getting from tables.c |
||
512 | #if 0 |
||
333 | serge | 513 | int i; |
514 | float a; |
||
515 | float fv; |
||
516 | int t; |
||
298 | serge | 517 | |
518 | // viewangle tangent table |
||
519 | for (i=0 ; i |
||
520 | { |
||
333 | serge | 521 | a = (i-FINEANGLES/4+0.5)*PI*2/FINEANGLES; |
522 | fv = FRACUNIT*tan (a); |
||
523 | t = fv; |
||
524 | finetangent[i] = t; |
||
298 | serge | 525 | } |
526 | |||
527 | // finesine table |
||
528 | for (i=0 ; i<5*FINEANGLES/4 ; i++) |
||
529 | { |
||
333 | serge | 530 | // OPTIMIZE: mirror... |
531 | a = (i+0.5)*PI*2/FINEANGLES; |
||
532 | t = FRACUNIT*sin (a); |
||
533 | finesine[i] = t; |
||
298 | serge | 534 | } |
535 | #endif |
||
536 | |||
537 | } |
||
538 | |||
539 | |||
540 | |||
541 | // |
||
542 | // R_InitTextureMapping |
||
543 | // |
||
544 | void R_InitTextureMapping (void) |
||
545 | { |
||
333 | serge | 546 | int i; |
547 | int x; |
||
548 | int t; |
||
549 | fixed_t focallength; |
||
298 | serge | 550 | |
551 | // Use tangent table to generate viewangletox: |
||
552 | // viewangletox will give the next greatest x |
||
553 | // after the view angle. |
||
554 | // |
||
555 | // Calc focallength |
||
556 | // so FIELDOFVIEW angles covers SCREENWIDTH. |
||
557 | focallength = FixedDiv (centerxfrac, |
||
333 | serge | 558 | finetangent[FINEANGLES/4+FIELDOFVIEW/2] ); |
559 | |||
298 | serge | 560 | for (i=0 ; i |
561 | { |
||
333 | serge | 562 | if (finetangent[i] > FRACUNIT*2) |
563 | t = -1; |
||
564 | else if (finetangent[i] < -FRACUNIT*2) |
||
565 | t = viewwidth+1; |
||
566 | else |
||
567 | { |
||
568 | t = FixedMul (finetangent[i], focallength); |
||
569 | t = (centerxfrac - t+FRACUNIT-1)>>FRACBITS; |
||
298 | serge | 570 | |
333 | serge | 571 | if (t < -1) |
572 | t = -1; |
||
573 | else if (t>viewwidth+1) |
||
574 | t = viewwidth+1; |
||
575 | } |
||
576 | viewangletox[i] = t; |
||
298 | serge | 577 | } |
578 | |||
579 | // Scan viewangletox[] to generate xtoviewangle[]: |
||
580 | // xtoviewangle will give the smallest view angle |
||
333 | serge | 581 | // that maps to x. |
298 | serge | 582 | for (x=0;x<=viewwidth;x++) |
583 | { |
||
333 | serge | 584 | i = 0; |
585 | while (viewangletox[i]>x) |
||
586 | i++; |
||
587 | xtoviewangle[x] = (i< |
||
298 | serge | 588 | } |
589 | |||
590 | // Take out the fencepost cases from viewangletox. |
||
591 | for (i=0 ; i |
||
592 | { |
||
333 | serge | 593 | t = FixedMul (finetangent[i], focallength); |
594 | t = centerx - t; |
||
595 | |||
596 | if (viewangletox[i] == -1) |
||
597 | viewangletox[i] = 0; |
||
598 | else if (viewangletox[i] == viewwidth+1) |
||
599 | viewangletox[i] = viewwidth; |
||
298 | serge | 600 | } |
333 | serge | 601 | |
298 | serge | 602 | clipangle = xtoviewangle[0]; |
603 | } |
||
604 | |||
605 | |||
606 | |||
607 | // |
||
608 | // R_InitLightTables |
||
609 | // Only inits the zlight table, |
||
610 | // because the scalelight table changes with view size. |
||
611 | // |
||
333 | serge | 612 | #define DISTMAP 2 |
298 | serge | 613 | |
614 | void R_InitLightTables (void) |
||
615 | { |
||
333 | serge | 616 | int i; |
617 | int j; |
||
618 | int level; |
||
619 | int startmap; |
||
620 | int scale; |
||
298 | serge | 621 | |
622 | // Calculate the light levels to use |
||
623 | // for each level / distance combination. |
||
624 | for (i=0 ; i< LIGHTLEVELS ; i++) |
||
625 | { |
||
333 | serge | 626 | startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS; |
627 | for (j=0 ; j |
||
628 | { |
||
629 | scale = FixedDiv ((SCREENWIDTH/2*FRACUNIT), (j+1)< |
||
630 | scale >>= LIGHTSCALESHIFT; |
||
631 | level = startmap - scale/DISTMAP; |
||
632 | |||
633 | if (level < 0) |
||
634 | level = 0; |
||
298 | serge | 635 | |
333 | serge | 636 | if (level >= NUMCOLORMAPS) |
637 | level = NUMCOLORMAPS-1; |
||
298 | serge | 638 | |
333 | serge | 639 | zlight[i][j] = colormaps + level*256; |
640 | } |
||
298 | serge | 641 | } |
642 | } |
||
643 | |||
644 | |||
645 | |||
646 | // |
||
647 | // R_SetViewSize |
||
648 | // Do not really change anything here, |
||
649 | // because it might be in the middle of a refresh. |
||
650 | // The change will take effect next refresh. |
||
651 | // |
||
333 | serge | 652 | boolean setsizeneeded; |
653 | int setblocks; |
||
654 | int setdetail; |
||
298 | serge | 655 | |
656 | |||
657 | void |
||
658 | R_SetViewSize |
||
333 | serge | 659 | ( int blocks, |
660 | int detail ) |
||
298 | serge | 661 | { |
662 | setsizeneeded = true; |
||
663 | setblocks = blocks; |
||
664 | setdetail = detail; |
||
665 | } |
||
666 | |||
667 | |||
668 | // |
||
669 | // R_ExecuteSetViewSize |
||
670 | // |
||
671 | void R_ExecuteSetViewSize (void) |
||
672 | { |
||
333 | serge | 673 | fixed_t cosadj; |
674 | fixed_t dy; |
||
675 | int i; |
||
676 | int j; |
||
677 | int level; |
||
678 | int startmap; |
||
298 | serge | 679 | |
680 | setsizeneeded = false; |
||
681 | |||
682 | if (setblocks == 11) |
||
683 | { |
||
333 | serge | 684 | scaledviewwidth = SCREENWIDTH; |
685 | viewheight = SCREENHEIGHT; |
||
298 | serge | 686 | } |
687 | else |
||
688 | { |
||
333 | serge | 689 | scaledviewwidth = setblocks*32; |
690 | viewheight = (setblocks*168/10)&~7; |
||
298 | serge | 691 | } |
692 | |||
693 | detailshift = setdetail; |
||
694 | viewwidth = scaledviewwidth>>detailshift; |
||
333 | serge | 695 | |
298 | serge | 696 | centery = viewheight/2; |
697 | centerx = viewwidth/2; |
||
698 | centerxfrac = centerx< |
||
699 | centeryfrac = centery< |
||
700 | projection = centerxfrac; |
||
701 | |||
702 | if (!detailshift) |
||
703 | { |
||
333 | serge | 704 | colfunc = basecolfunc = R_DrawColumn; |
705 | fuzzcolfunc = R_DrawFuzzColumn; |
||
706 | transcolfunc = R_DrawTranslatedColumn; |
||
707 | spanfunc = R_DrawSpan; |
||
298 | serge | 708 | } |
709 | else |
||
710 | { |
||
333 | serge | 711 | colfunc = basecolfunc = R_DrawColumnLow; |
712 | fuzzcolfunc = R_DrawFuzzColumn; |
||
713 | transcolfunc = R_DrawTranslatedColumn; |
||
714 | spanfunc = R_DrawSpanLow; |
||
298 | serge | 715 | } |
716 | |||
717 | R_InitBuffer (scaledviewwidth, viewheight); |
||
333 | serge | 718 | |
298 | serge | 719 | R_InitTextureMapping (); |
720 | |||
721 | // psprite scales |
||
722 | pspritescale = FRACUNIT*viewwidth/SCREENWIDTH; |
||
723 | pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth; |
||
724 | |||
725 | // thing clipping |
||
726 | for (i=0 ; i |
||
333 | serge | 727 | screenheightarray[i] = viewheight; |
298 | serge | 728 | |
729 | // planes |
||
730 | for (i=0 ; i |
||
731 | { |
||
333 | serge | 732 | dy = ((i-viewheight/2)< |
733 | dy = abs(dy); |
||
734 | yslope[i] = FixedDiv ( (viewwidth< |
||
298 | serge | 735 | } |
333 | serge | 736 | |
298 | serge | 737 | for (i=0 ; i |
738 | { |
||
333 | serge | 739 | cosadj = abs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]); |
740 | distscale[i] = FixedDiv (FRACUNIT,cosadj); |
||
298 | serge | 741 | } |
742 | |||
743 | // Calculate the light levels to use |
||
744 | // for each level / scale combination. |
||
745 | for (i=0 ; i< LIGHTLEVELS ; i++) |
||
746 | { |
||
333 | serge | 747 | startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS; |
748 | for (j=0 ; j |
||
749 | { |
||
750 | level = startmap - j*SCREENWIDTH/(viewwidth< |
||
751 | |||
752 | if (level < 0) |
||
753 | level = 0; |
||
298 | serge | 754 | |
333 | serge | 755 | if (level >= NUMCOLORMAPS) |
756 | level = NUMCOLORMAPS-1; |
||
298 | serge | 757 | |
333 | serge | 758 | scalelight[i][j] = colormaps + level*256; |
759 | } |
||
298 | serge | 760 | } |
761 | } |
||
762 | |||
763 | |||
764 | |||
765 | // |
||
766 | // R_Init |
||
767 | // |
||
333 | serge | 768 | extern int detailLevel; |
769 | extern int screenblocks; |
||
298 | serge | 770 | |
771 | |||
772 | |||
773 | void R_Init (void) |
||
774 | { |
||
775 | R_InitData (); |
||
333 | serge | 776 | printf ("R_InitData\n\r"); |
298 | serge | 777 | R_InitPointToAngle (); |
333 | serge | 778 | printf ("R_InitPointToAngle\n\r"); |
298 | serge | 779 | R_InitTables (); |
780 | // viewwidth / viewheight / detailLevel are set by the defaults |
||
333 | serge | 781 | printf ("R_InitTables\n\r"); |
298 | serge | 782 | |
783 | R_SetViewSize (screenblocks, detailLevel); |
||
784 | R_InitPlanes (); |
||
333 | serge | 785 | printf ("R_InitPlanes\n\r"); |
298 | serge | 786 | R_InitLightTables (); |
333 | serge | 787 | printf ("R_InitLightTables\n\r"); |
298 | serge | 788 | R_InitSkyMap (); |
333 | serge | 789 | printf ("R_InitSkyMap\n\r"); |
298 | serge | 790 | R_InitTranslationTables (); |
333 | serge | 791 | printf ("R_InitTranslationsTables\n\r"); |
792 | |||
298 | serge | 793 | framecount = 0; |
794 | } |
||
795 | |||
796 | |||
797 | // |
||
798 | // R_PointInSubsector |
||
799 | // |
||
800 | subsector_t* |
||
801 | R_PointInSubsector |
||
333 | serge | 802 | ( fixed_t x, |
803 | fixed_t y ) |
||
298 | serge | 804 | { |
333 | serge | 805 | node_t* node; |
806 | int side; |
||
807 | int nodenum; |
||
298 | serge | 808 | |
809 | // single subsector is a special case |
||
333 | serge | 810 | if (!numnodes) |
811 | return subsectors; |
||
812 | |||
298 | serge | 813 | nodenum = numnodes-1; |
814 | |||
815 | while (! (nodenum & NF_SUBSECTOR) ) |
||
816 | { |
||
333 | serge | 817 | node = &nodes[nodenum]; |
818 | side = R_PointOnSide (x, y, node); |
||
819 | nodenum = node->children[side]; |
||
298 | serge | 820 | } |
333 | serge | 821 | |
298 | serge | 822 | return &subsectors[nodenum & ~NF_SUBSECTOR]; |
823 | } |
||
824 | |||
825 | |||
826 | |||
827 | // |
||
828 | // R_SetupFrame |
||
829 | // |
||
830 | void R_SetupFrame (player_t* player) |
||
333 | serge | 831 | { |
832 | int i; |
||
298 | serge | 833 | |
834 | viewplayer = player; |
||
835 | viewx = player->mo->x; |
||
836 | viewy = player->mo->y; |
||
837 | viewangle = player->mo->angle + viewangleoffset; |
||
838 | extralight = player->extralight; |
||
839 | |||
840 | viewz = player->viewz; |
||
841 | |||
842 | viewsin = finesine[viewangle>>ANGLETOFINESHIFT]; |
||
843 | viewcos = finecosine[viewangle>>ANGLETOFINESHIFT]; |
||
333 | serge | 844 | |
298 | serge | 845 | sscount = 0; |
333 | serge | 846 | |
298 | serge | 847 | if (player->fixedcolormap) |
848 | { |
||
333 | serge | 849 | fixedcolormap = |
850 | colormaps |
||
851 | + player->fixedcolormap*256*sizeof(lighttable_t); |
||
852 | |||
853 | walllights = scalelightfixed; |
||
298 | serge | 854 | |
333 | serge | 855 | for (i=0 ; i |
856 | scalelightfixed[i] = fixedcolormap; |
||
298 | serge | 857 | } |
858 | else |
||
333 | serge | 859 | fixedcolormap = 0; |
860 | |||
298 | serge | 861 | framecount++; |
862 | validcount++; |
||
863 | } |
||
864 | |||
865 | |||
866 | |||
867 | // |
||
868 | // R_RenderView |
||
869 | // |
||
870 | void R_RenderPlayerView (player_t* player) |
||
333 | serge | 871 | { |
298 | serge | 872 | R_SetupFrame (player); |
873 | |||
874 | // Clear buffers. |
||
875 | R_ClearClipSegs (); |
||
876 | R_ClearDrawSegs (); |
||
877 | R_ClearPlanes (); |
||
878 | R_ClearSprites (); |
||
879 | |||
880 | // check for new console commands. |
||
881 | NetUpdate (); |
||
882 | |||
883 | // The head node is the last node output. |
||
884 | R_RenderBSPNode (numnodes-1); |
||
885 | |||
886 | // Check for new console commands. |
||
887 | NetUpdate (); |
||
888 | |||
889 | R_DrawPlanes (); |
||
890 | |||
891 | // Check for new console commands. |
||
892 | NetUpdate (); |
||
893 | |||
894 | R_DrawMasked (); |
||
895 | |||
896 | // Check for new console commands. |
||
333 | serge | 897 | NetUpdate (); |
298 | serge | 898 | }> |