Subversion Repositories Kolibri OS

Rev

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
}