r_surf.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (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.
  12
  13 See the 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 // r_surf.c: surface-related refresh code
  21
  22 #include "quakedef.h"
  23 #include "r_local.h"
  24
  25 drawsurf_t      r_drawsurf;
  26
  27 int                             lightleft, sourcesstep, blocksize, sourcetstep;
  28 int                             lightdelta, lightdeltastep;
  29 int                             lightright, lightleftstep, lightrightstep, blockdivshift;
  30 unsigned                blockdivmask;
  31 void                    *prowdestbase;
  32 unsigned char   *pbasesource;
  33 int                             surfrowbytes;   // used by ASM files
  34 unsigned                *r_lightptr;
  35 int                             r_stepback;
  36 int                             r_lightwidth;
  37 int                             r_numhblocks, r_numvblocks;
  38 unsigned char   *r_source, *r_sourcemax;
  39
  40 void R_DrawSurfaceBlock8_mip0 (void);
  41 void R_DrawSurfaceBlock8_mip1 (void);
  42 void R_DrawSurfaceBlock8_mip2 (void);
  43 void R_DrawSurfaceBlock8_mip3 (void);
  44
  45 static void     (*surfmiptable[4])(void) = {
  46         R_DrawSurfaceBlock8_mip0,
  47         R_DrawSurfaceBlock8_mip1,
  48         R_DrawSurfaceBlock8_mip2,
  49         R_DrawSurfaceBlock8_mip3
  50 };
  51
  52
  53
  54 unsigned                blocklights[18*18];
  55
  56 /*
  57 ===============
  58 R_AddDynamicLights
  59 ===============
  60 */
  61 void R_AddDynamicLights (void)
  62 {
  63         msurface_t *surf;
  64         int                     lnum;
  65         int                     sd, td;
  66         float           dist, rad, minlight;
  67         vec3_t          impact, local;
  68         int                     s, t;
  69         int                     i;
  70         int                     smax, tmax;
  71         mtexinfo_t      *tex;
  72
  73         surf = r_drawsurf.surf;
  74         smax = (surf->extents[0]>>4)+1;
  75         tmax = (surf->extents[1]>>4)+1;
  76         tex = surf->texinfo;
  77
  78         for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
  79         {
  80                 if ( !(surf->dlightbits & (1<<lnum) ) )
  81                         continue;               // not lit by this light
  82
  83                 rad = cl_dlights[lnum].radius;
  84                 dist = DotProduct (cl_dlights[lnum].origin, surf->plane->normal) -
  85                                 surf->plane->dist;
  86                 rad -= fabsf(dist);
  87                 minlight = cl_dlights[lnum].minlight;
  88                 if (rad < minlight)
  89                         continue;
  90                 minlight = rad - minlight;
  91
  92                 for (i=0 ; i<3 ; i++)
  93                 {
  94                         impact[i] = cl_dlights[lnum].origin[i] -
  95                                         surf->plane->normal[i]*dist;
  96                 }
  97
  98                 local[0] = DotProduct (impact, tex->vecs[0]) + tex->vecs[0][3];
  99                 local[1] = DotProduct (impact, tex->vecs[1]) + tex->vecs[1][3];
 100
 101                 local[0] -= surf->texturemins[0];
 102                 local[1] -= surf->texturemins[1];
 103
 104                 for (t = 0 ; t<tmax ; t++)
 105                 {
 106                         td = local[1] - t*16;
 107                         if (td < 0)
 108                                 td = -td;
 109                         for (s=0 ; s<smax ; s++)
 110                         {
 111                                 sd = local[0] - s*16;
 112                                 if (sd < 0)
 113                                         sd = -sd;
 114                                 if (sd > td)
 115                                         dist = sd + (td>>1);
 116                                 else
 117                                         dist = td + (sd>>1);
 118                                 if (dist < minlight)
 119 #ifdef QUAKE2
 120                                 {
 121                                         unsigned temp;
 122                                         temp = (rad - dist)*256;
 123                                         i = t*smax + s;
 124                                         if (!cl_dlights[lnum].dark)
 125                                                 blocklights[i] += temp;
 126                                         else
 127                                         {
 128                                                 if (blocklights[i] > temp)
 129                                                         blocklights[i] -= temp;
 130                                                 else
 131                                                         blocklights[i] = 0;
 132                                         }
 133                                 }
 134 #else
 135                                         blocklights[t*smax + s] += (rad - dist)*256;
 136 #endif
 137                         }
 138                 }
 139         }
 140 }
 141
 142 /*
 143 ===============
 144 R_BuildLightMap
 145
 146 Combine and scale multiple lightmaps into the 8.8 format in blocklights
 147 ===============
 148 */
 149 void R_BuildLightMap (void)
 150 {
 151         int                     smax, tmax;
 152         int                     t;
 153         int                     i, size;
 154         byte            *lightmap;
 155         unsigned        scale;
 156         int                     maps;
 157         msurface_t      *surf;
 158
 159         surf = r_drawsurf.surf;
 160
 161         smax = (surf->extents[0]>>4)+1;
 162         tmax = (surf->extents[1]>>4)+1;
 163         size = smax*tmax;
 164         lightmap = surf->samples;
 165
 166         if (r_fullbright.value || !cl.worldmodel->lightdata)
 167         {
 168                 for (i=0 ; i<size ; i++)
 169                         blocklights[i] = 0;
 170                 return;
 171         }
 172
 173 // clear to ambient
 174         for (i=0 ; i<size ; i++)
 175                 blocklights[i] = r_refdef.ambientlight<<8;
 176
 177
 178 // add all the lightmaps
 179         if (lightmap)
 180                 for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
 181                          maps++)
 182                 {
 183                         scale = r_drawsurf.lightadj[maps];      // 8.8 fraction
 184                         for (i=0 ; i<size ; i++)
 185                                 blocklights[i] += lightmap[i] * scale;
 186                         lightmap += size;       // skip to next lightmap
 187                 }
 188
 189 // add all the dynamic lights
 190         if (surf->dlightframe == r_framecount)
 191                 R_AddDynamicLights ();
 192
 193 // bound, invert, and shift
 194         for (i=0 ; i<size ; i++)
 195         {
 196                 t = (255*256 - (int)blocklights[i]) >> (8 - VID_CBITS);
 197
 198                 if (t < (1 << 6))
 199                         t = (1 << 6);
 200
 201                 blocklights[i] = t;
 202         }
 203 }
 204
 205
 206 /*
 207 ===============
 208 R_TextureAnimation
 209
 210 Returns the proper texture for a given time and base texture
 211 ===============
 212 */
 213 texture_t *R_TextureAnimation (texture_t *base)
 214 {
 215         int             reletive;
 216         int             count;
 217
 218         if (currententity->frame)
 219         {
 220                 if (base->alternate_anims)
 221                         base = base->alternate_anims;
 222         }
 223
 224         if (!base->anim_total)
 225                 return base;
 226
 227         reletive = (int)(cl.time*10) % base->anim_total;
 228
 229         count = 0;
 230         while (base->anim_min > reletive || base->anim_max <= reletive)
 231         {
 232                 base = base->anim_next;
 233                 if (!base)
 234                         Sys_Error ("R_TextureAnimation: broken cycle");
 235                 if (++count > 100)
 236                         Sys_Error ("R_TextureAnimation: infinite cycle");
 237         }
 238
 239         return base;
 240 }
 241
 242
 243 /*
 244 ===============
 245 R_DrawSurface
 246 ===============
 247 */
 248 void R_DrawSurface (void)
 249 {
 250         unsigned char   *basetptr;
 251         int                             smax, tmax, twidth;
 252         int                             u;
 253         int                             soffset, basetoffset, texwidth;
 254         int                             horzblockstep;
 255         unsigned char   *pcolumndest;
 256         void                    (*pblockdrawer)(void);
 257         texture_t               *mt;
 258
 259 // calculate the lightings
 260         R_BuildLightMap ();
 261
 262         surfrowbytes = r_drawsurf.rowbytes;
 263
 264         mt = r_drawsurf.texture;
 265
 266         r_source = (byte *)mt + mt->offsets[r_drawsurf.surfmip];
 267
 268 // the fractional light values should range from 0 to (VID_GRADES - 1) << 16
 269 // from a source range of 0 - 255
 270
 271         texwidth = mt->width >> r_drawsurf.surfmip;
 272
 273         blocksize = 16 >> r_drawsurf.surfmip;
 274         blockdivshift = 4 - r_drawsurf.surfmip;
 275         blockdivmask = (1 << blockdivshift) - 1;
 276
 277         r_lightwidth = (r_drawsurf.surf->extents[0]>>4)+1;
 278
 279         r_numhblocks = r_drawsurf.surfwidth >> blockdivshift;
 280         r_numvblocks = r_drawsurf.surfheight >> blockdivshift;
 281
 282 //==============================
 283
 284         if (r_pixbytes == 1)
 285         {
 286                 pblockdrawer = surfmiptable[r_drawsurf.surfmip];
 287         // TODO: only needs to be set when there is a display settings change
 288                 horzblockstep = blocksize;
 289         }
 290         else
 291         {
 292                 pblockdrawer = R_DrawSurfaceBlock16;
 293         // TODO: only needs to be set when there is a display settings change
 294                 horzblockstep = blocksize << 1;
 295         }
 296
 297         smax = mt->width >> r_drawsurf.surfmip;
 298         twidth = texwidth;
 299         tmax = mt->height >> r_drawsurf.surfmip;
 300         sourcetstep = texwidth;
 301         r_stepback = tmax * twidth;
 302
 303         r_sourcemax = r_source + (tmax * smax);
 304
 305         soffset = r_drawsurf.surf->texturemins[0];
 306         basetoffset = r_drawsurf.surf->texturemins[1];
 307
 308 // << 16 components are to guarantee positive values for %
 309         soffset = ((soffset >> r_drawsurf.surfmip) + (smax << 16)) % smax;
 310         basetptr = &r_source[((((basetoffset >> r_drawsurf.surfmip)
 311                 + (tmax << 16)) % tmax) * twidth)];
 312
 313         pcolumndest = r_drawsurf.surfdat;
 314
 315         for (u=0 ; u<r_numhblocks; u++)
 316         {
 317                 r_lightptr = blocklights + u;
 318
 319                 prowdestbase = pcolumndest;
 320
 321                 pbasesource = basetptr + soffset;
 322
 323                 (*pblockdrawer)();
 324
 325                 soffset = soffset + blocksize;
 326                 if (soffset >= smax)
 327                         soffset = 0;
 328
 329                 pcolumndest += horzblockstep;
 330         }
 331 }
 332
 333
 334 //=============================================================================
 335
 336 #if     !id386
 337
 338 /*
 339 ================
 340 R_DrawSurfaceBlock8_mip0
 341 ================
 342 */
 343 void R_DrawSurfaceBlock8_mip0 (void)
 344 {
 345         int                             v, i, b, lightstep, lighttemp, light;
 346         unsigned char   pix, *psource, *prowdest;
 347
 348         psource = pbasesource;
 349         prowdest = prowdestbase;
 350
 351         for (v=0 ; v<r_numvblocks ; v++)
 352         {
 353         // FIXME: make these locals?
 354         // FIXME: use delta rather than both right and left, like ASM?
 355                 lightleft = r_lightptr[0];
 356                 lightright = r_lightptr[1];
 357                 r_lightptr += r_lightwidth;
 358                 lightleftstep = (r_lightptr[0] - lightleft) >> 4;
 359                 lightrightstep = (r_lightptr[1] - lightright) >> 4;
 360
 361                 for (i=0 ; i<16 ; i++)
 362                 {
 363                         lighttemp = lightleft - lightright;
 364                         lightstep = lighttemp >> 4;
 365
 366                         light = lightright;
 367
 368                         for (b=15; b>=0; b--)
 369                         {
 370                                 pix = psource[b];
 371                                 prowdest[b] = ((unsigned char *)vid.colormap)
 372                                                 [(light & 0xFF00) + pix];
 373                                 light += lightstep;
 374                         }
 375
 376                         psource += sourcetstep;
 377                         lightright += lightrightstep;
 378                         lightleft += lightleftstep;
 379                         prowdest += surfrowbytes;
 380                 }
 381
 382                 if (psource >= r_sourcemax)
 383                         psource -= r_stepback;
 384         }
 385 }
 386
 387
 388 /*
 389 ================
 390 R_DrawSurfaceBlock8_mip1
 391 ================
 392 */
 393 void R_DrawSurfaceBlock8_mip1 (void)
 394 {
 395         int                             v, i, b, lightstep, lighttemp, light;
 396         unsigned char   pix, *psource, *prowdest;
 397
 398         psource = pbasesource;
 399         prowdest = prowdestbase;
 400
 401         for (v=0 ; v<r_numvblocks ; v++)
 402         {
 403         // FIXME: make these locals?
 404         // FIXME: use delta rather than both right and left, like ASM?
 405                 lightleft = r_lightptr[0];
 406                 lightright = r_lightptr[1];
 407                 r_lightptr += r_lightwidth;
 408                 lightleftstep = (r_lightptr[0] - lightleft) >> 3;
 409                 lightrightstep = (r_lightptr[1] - lightright) >> 3;
 410
 411                 for (i=0 ; i<8 ; i++)
 412                 {
 413                         lighttemp = lightleft - lightright;
 414                         lightstep = lighttemp >> 3;
 415
 416                         light = lightright;
 417
 418                         for (b=7; b>=0; b--)
 419                         {
 420                                 pix = psource[b];
 421                                 prowdest[b] = ((unsigned char *)vid.colormap)
 422                                                 [(light & 0xFF00) + pix];
 423                                 light += lightstep;
 424                         }
 425
 426                         psource += sourcetstep;
 427                         lightright += lightrightstep;
 428                         lightleft += lightleftstep;
 429                         prowdest += surfrowbytes;
 430                 }
 431
 432                 if (psource >= r_sourcemax)
 433                         psource -= r_stepback;
 434         }
 435 }
 436
 437
 438 /*
 439 ================
 440 R_DrawSurfaceBlock8_mip2
 441 ================
 442 */
 443 void R_DrawSurfaceBlock8_mip2 (void)
 444 {
 445         int                             v, i, b, lightstep, lighttemp, light;
 446         unsigned char   pix, *psource, *prowdest;
 447
 448         psource = pbasesource;
 449         prowdest = prowdestbase;
 450
 451         for (v=0 ; v<r_numvblocks ; v++)
 452         {
 453         // FIXME: make these locals?
 454         // FIXME: use delta rather than both right and left, like ASM?
 455                 lightleft = r_lightptr[0];
 456                 lightright = r_lightptr[1];
 457                 r_lightptr += r_lightwidth;
 458                 lightleftstep = (r_lightptr[0] - lightleft) >> 2;
 459                 lightrightstep = (r_lightptr[1] - lightright) >> 2;
 460
 461                 for (i=0 ; i<4 ; i++)
 462                 {
 463                         lighttemp = lightleft - lightright;
 464                         lightstep = lighttemp >> 2;
 465
 466                         light = lightright;
 467
 468                         for (b=3; b>=0; b--)
 469                         {
 470                                 pix = psource[b];
 471                                 prowdest[b] = ((unsigned char *)vid.colormap)
 472                                                 [(light & 0xFF00) + pix];
 473                                 light += lightstep;
 474                         }
 475
 476                         psource += sourcetstep;
 477                         lightright += lightrightstep;
 478                         lightleft += lightleftstep;
 479                         prowdest += surfrowbytes;
 480                 }
 481
 482                 if (psource >= r_sourcemax)
 483                         psource -= r_stepback;
 484         }
 485 }
 486
 487
 488 /*
 489 ================
 490 R_DrawSurfaceBlock8_mip3
 491 ================
 492 */
 493 void R_DrawSurfaceBlock8_mip3 (void)
 494 {
 495         int                             v, i, b, lightstep, lighttemp, light;
 496         unsigned char   pix, *psource, *prowdest;
 497
 498         psource = pbasesource;
 499         prowdest = prowdestbase;
 500
 501         for (v=0 ; v<r_numvblocks ; v++)
 502         {
 503         // FIXME: make these locals?
 504         // FIXME: use delta rather than both right and left, like ASM?
 505                 lightleft = r_lightptr[0];
 506                 lightright = r_lightptr[1];
 507                 r_lightptr += r_lightwidth;
 508                 lightleftstep = (r_lightptr[0] - lightleft) >> 1;
 509                 lightrightstep = (r_lightptr[1] - lightright) >> 1;
 510
 511                 for (i=0 ; i<2 ; i++)
 512                 {
 513                         lighttemp = lightleft - lightright;
 514                         lightstep = lighttemp >> 1;
 515
 516                         light = lightright;
 517
 518                         for (b=1; b>=0; b--)
 519                         {
 520                                 pix = psource[b];
 521                                 prowdest[b] = ((unsigned char *)vid.colormap)
 522                                                 [(light & 0xFF00) + pix];
 523                                 light += lightstep;
 524                         }
 525
 526                         psource += sourcetstep;
 527                         lightright += lightrightstep;
 528                         lightleft += lightleftstep;
 529                         prowdest += surfrowbytes;
 530                 }
 531
 532                 if (psource >= r_sourcemax)
 533                         psource -= r_stepback;
 534         }
 535 }
 536
 537
 538 /*
 539 ================
 540 R_DrawSurfaceBlock16
 541
 542 FIXME: make this work
 543 ================
 544 */
 545 void R_DrawSurfaceBlock16 (void)
 546 {
 547         int                             k;
 548         unsigned char   *psource;
 549         int                             lighttemp, lightstep, light;
 550         unsigned short  *prowdest;
 551
 552         prowdest = (unsigned short *)prowdestbase;
 553
 554         for (k=0 ; k<blocksize ; k++)
 555         {
 556                 unsigned short  *pdest;
 557                 unsigned char   pix;
 558                 int                             b;
 559
 560                 psource = pbasesource;
 561                 lighttemp = lightright - lightleft;
 562                 lightstep = lighttemp >> blockdivshift;
 563
 564                 light = lightleft;
 565                 pdest = prowdest;
 566
 567                 for (b=0; b<blocksize; b++)
 568                 {
 569                         pix = *psource;
 570                         *pdest = vid.colormap16[(light & 0xFF00) + pix];
 571                         psource += sourcesstep;
 572                         pdest++;
 573                         light += lightstep;
 574                 }
 575
 576                 pbasesource += sourcetstep;
 577                 lightright += lightrightstep;
 578                 lightleft += lightleftstep;
 579                 prowdest = (unsigned short *)((long)prowdest + surfrowbytes);
 580         }
 581
 582         prowdestbase = prowdest;
 583 }
 584
 585 #endif
 586
 587
 588 //============================================================================
 589
 590 /*
 591 ================
 592 R_GenTurbTile
 593 ================
 594 */
 595 void R_GenTurbTile (pixel_t *pbasetex, void *pdest)
 596 {
 597         int             *turb;
 598         int             i, j, s, t;
 599         byte    *pd;
 600
 601         turb = sintable + ((int)(cl.time*SPEED)&(CYCLE-1));
 602         pd = (byte *)pdest;
 603
 604         for (i=0 ; i<TILE_SIZE ; i++)
 605         {
 606                 for (j=0 ; j<TILE_SIZE ; j++)
 607                 {
 608                         s = (((j << 16) + turb[i & (CYCLE-1)]) >> 16) & 63;
 609                         t = (((i << 16) + turb[j & (CYCLE-1)]) >> 16) & 63;
 610                         *pd++ = *(pbasetex + (t<<6) + s);
 611                 }
 612         }
 613 }
 614
 615
 616 /*
 617 ================
 618 R_GenTurbTile16
 619 ================
 620 */
 621 void R_GenTurbTile16 (pixel_t *pbasetex, void *pdest)
 622 {
 623         int                             *turb;
 624         int                             i, j, s, t;
 625         unsigned short  *pd;
 626
 627         turb = sintable + ((int)(cl.time*SPEED)&(CYCLE-1));
 628         pd = (unsigned short *)pdest;
 629
 630         for (i=0 ; i<TILE_SIZE ; i++)
 631         {
 632                 for (j=0 ; j<TILE_SIZE ; j++)
 633                 {
 634                         s = (((j << 16) + turb[i & (CYCLE-1)]) >> 16) & 63;
 635                         t = (((i << 16) + turb[j & (CYCLE-1)]) >> 16) & 63;
 636                         *pd++ = d_8to16table[*(pbasetex + (t<<6) + s)];
 637                 }
 638         }
 639 }
 640
 641
 642 /*
 643 ================
 644 R_GenTile
 645 ================
 646 */
 647 void R_GenTile (msurface_t *psurf, void *pdest)
 648 {
 649         if (psurf->flags & SURF_DRAWTURB)
 650         {
 651                 if (r_pixbytes == 1)
 652                 {
 653                         R_GenTurbTile ((pixel_t *)
 654                                 ((byte *)psurf->texinfo->texture + psurf->texinfo->texture->offsets[0]), pdest);
 655                 }
 656                 else
 657                 {
 658                         R_GenTurbTile16 ((pixel_t *)
 659                                 ((byte *)psurf->texinfo->texture + psurf->texinfo->texture->offsets[0]), pdest);
 660                 }
 661         }
 662         else if (psurf->flags & SURF_DRAWSKY)
 663         {
 664                 if (r_pixbytes == 1)
 665                 {
 666                         R_GenSkyTile (pdest);
 667                 }
 668                 else
 669                 {
 670                         R_GenSkyTile16 (pdest);
 671                 }
 672         }
 673         else
 674         {
 675                 Sys_Error ("Unknown tile type");
 676         }
 677 }
 678