![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gl_warp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to gl_warp.c CVS log | Up to [Quake] / quake1 |
1.1 ! root 1: // gl_warp.c -- sky and water polygons ! 2: ! 3: #include "quakedef.h" ! 4: ! 5: extern model_t *loadmodel; ! 6: ! 7: int skytexturenum; ! 8: ! 9: int solidskytexture; ! 10: int alphaskytexture; ! 11: float speedscale; // for top sky and bottom sky ! 12: ! 13: msurface_t *warpface; ! 14: ! 15: #define SUBDIVIDE_SIZE 64 ! 16: ! 17: void BoundPoly (int numverts, float *verts, vec3_t mins, vec3_t maxs) ! 18: { ! 19: int i, j; ! 20: float *v; ! 21: ! 22: mins[0] = mins[1] = mins[2] = 9999; ! 23: maxs[0] = maxs[1] = maxs[2] = -9999; ! 24: v = verts; ! 25: for (i=0 ; i<numverts ; i++) ! 26: for (j=0 ; j<3 ; j++, v++) ! 27: { ! 28: if (*v < mins[j]) ! 29: mins[j] = *v; ! 30: if (*v > maxs[j]) ! 31: maxs[j] = *v; ! 32: } ! 33: } ! 34: ! 35: void SubdividePolygon (int numverts, float *verts) ! 36: { ! 37: int i, j, k; ! 38: vec3_t mins, maxs; ! 39: float m; ! 40: float *v; ! 41: vec3_t front[64], back[64]; ! 42: int f, b; ! 43: float dist[64]; ! 44: float frac; ! 45: glpoly_t *poly; ! 46: float s, t; ! 47: ! 48: if (numverts > 60) ! 49: Sys_Error ("numverts = %i", numverts); ! 50: ! 51: BoundPoly (numverts, verts, mins, maxs); ! 52: ! 53: for (i=0 ; i<3 ; i++) ! 54: { ! 55: m = (mins[i] + maxs[i]) * 0.5; ! 56: m = SUBDIVIDE_SIZE * floor (m/SUBDIVIDE_SIZE + 0.5); ! 57: if (maxs[i] - m < 8) ! 58: continue; ! 59: if (m - mins[i] < 8) ! 60: continue; ! 61: ! 62: // cut it ! 63: v = verts + i; ! 64: for (j=0 ; j<numverts ; j++, v+= 3) ! 65: dist[j] = *v - m; ! 66: ! 67: // wrap cases ! 68: dist[j] = dist[0]; ! 69: v-=i; ! 70: VectorCopy (verts, v); ! 71: ! 72: f = b = 0; ! 73: v = verts; ! 74: for (j=0 ; j<numverts ; j++, v+= 3) ! 75: { ! 76: if (dist[j] >= 0) ! 77: { ! 78: VectorCopy (v, front[f]); ! 79: f++; ! 80: } ! 81: if (dist[j] <= 0) ! 82: { ! 83: VectorCopy (v, back[b]); ! 84: b++; ! 85: } ! 86: if (dist[j] == 0 || dist[j+1] == 0) ! 87: continue; ! 88: if ( (dist[j] > 0) != (dist[j+1] > 0) ) ! 89: { ! 90: // clip point ! 91: frac = dist[j] / (dist[j] - dist[j+1]); ! 92: for (k=0 ; k<3 ; k++) ! 93: front[f][k] = back[b][k] = v[k] + frac*(v[3+k] - v[k]); ! 94: f++; ! 95: b++; ! 96: } ! 97: } ! 98: ! 99: SubdividePolygon (f, front[0]); ! 100: SubdividePolygon (b, back[0]); ! 101: return; ! 102: } ! 103: ! 104: poly = Hunk_Alloc (sizeof(glpoly_t) + (numverts-4) * VERTEXSIZE*sizeof(float)); ! 105: poly->next = warpface->polys; ! 106: warpface->polys = poly; ! 107: poly->numverts = numverts; ! 108: for (i=0 ; i<numverts ; i++, verts+= 3) ! 109: { ! 110: VectorCopy (verts, poly->verts[i]); ! 111: s = DotProduct (verts, warpface->texinfo->vecs[0]); ! 112: t = DotProduct (verts, warpface->texinfo->vecs[1]); ! 113: poly->verts[i][3] = s; ! 114: poly->verts[i][4] = t; ! 115: } ! 116: } ! 117: ! 118: /* ! 119: ================ ! 120: GL_SubdivideSurface ! 121: ! 122: Breaks a polygon up along axial 64 unit ! 123: boundaries so that turbulent and sky warps ! 124: can be done reasonably. ! 125: ================ ! 126: */ ! 127: void GL_SubdivideSurface (msurface_t *fa) ! 128: { ! 129: vec3_t verts[64]; ! 130: int numverts; ! 131: int i; ! 132: int lindex; ! 133: float *vec; ! 134: texture_t *t; ! 135: ! 136: warpface = fa; ! 137: ! 138: // ! 139: // convert edges back to a normal polygon ! 140: // ! 141: numverts = 0; ! 142: for (i=0 ; i<fa->numedges ; i++) ! 143: { ! 144: lindex = loadmodel->surfedges[fa->firstedge + i]; ! 145: ! 146: if (lindex > 0) ! 147: vec = loadmodel->vertexes[loadmodel->edges[lindex].v[0]].position; ! 148: else ! 149: vec = loadmodel->vertexes[loadmodel->edges[-lindex].v[1]].position; ! 150: VectorCopy (vec, verts[numverts]); ! 151: numverts++; ! 152: } ! 153: ! 154: SubdividePolygon (numverts, verts[0]); ! 155: } ! 156: ! 157: //========================================================= ! 158: ! 159: ! 160: ! 161: // speed up sin calculations - Ed ! 162: float turbsin[] = ! 163: { ! 164: #include "gl_warp_sin.h" ! 165: }; ! 166: #define TURBSCALE (256.0 / (2 * M_PI)) ! 167: ! 168: /* ! 169: ============= ! 170: EmitWaterPolys ! 171: ! 172: Does a water warp on the pre-fragmented glpoly_t chain ! 173: ============= ! 174: */ ! 175: void EmitWaterPolys (msurface_t *fa) ! 176: { ! 177: glpoly_t *p; ! 178: float *v; ! 179: int i; ! 180: float s, t, os, ot; ! 181: ! 182: ! 183: for (p=fa->polys ; p ; p=p->next) ! 184: { ! 185: glBegin (GL_POLYGON); ! 186: for (i=0,v=p->verts[0] ; i<p->numverts ; i++, v+=VERTEXSIZE) ! 187: { ! 188: os = v[3]; ! 189: ot = v[4]; ! 190: ! 191: s = os + turbsin[(int)((ot*0.125+realtime) * TURBSCALE) & 255]; ! 192: s *= (1.0/64); ! 193: ! 194: t = ot + turbsin[(int)((os*0.125+realtime) * TURBSCALE) & 255]; ! 195: t *= (1.0/64); ! 196: ! 197: glTexCoord2f (s, t); ! 198: glVertex3fv (v); ! 199: } ! 200: glEnd (); ! 201: } ! 202: } ! 203: ! 204: ! 205: ! 206: ! 207: /* ! 208: ============= ! 209: EmitSkyPolys ! 210: ============= ! 211: */ ! 212: void EmitSkyPolys (msurface_t *fa) ! 213: { ! 214: glpoly_t *p; ! 215: float *v; ! 216: int i; ! 217: float s, t; ! 218: vec3_t dir; ! 219: float length; ! 220: ! 221: for (p=fa->polys ; p ; p=p->next) ! 222: { ! 223: glBegin (GL_POLYGON); ! 224: for (i=0,v=p->verts[0] ; i<p->numverts ; i++, v+=VERTEXSIZE) ! 225: { ! 226: VectorSubtract (v, r_origin, dir); ! 227: dir[2] *= 3; // flatten the sphere ! 228: ! 229: length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2]; ! 230: length = sqrt (length); ! 231: length = 6*63/length; ! 232: ! 233: dir[0] *= length; ! 234: dir[1] *= length; ! 235: ! 236: s = (speedscale + dir[0]) * (1.0/128); ! 237: t = (speedscale + dir[1]) * (1.0/128); ! 238: ! 239: glTexCoord2f (s, t); ! 240: glVertex3fv (v); ! 241: } ! 242: glEnd (); ! 243: } ! 244: } ! 245: ! 246: /* ! 247: =============== ! 248: EmitBothSkyLayers ! 249: ! 250: Does a sky warp on the pre-fragmented glpoly_t chain ! 251: This will be called for brushmodels, the world ! 252: will have them chained together. ! 253: =============== ! 254: */ ! 255: void EmitBothSkyLayers (msurface_t *fa) ! 256: { ! 257: int i; ! 258: int lindex; ! 259: float *vec; ! 260: ! 261: GL_Bind (solidskytexture); ! 262: speedscale = realtime*8; ! 263: speedscale -= (int)speedscale & ~127 ; ! 264: ! 265: EmitSkyPolys (fa); ! 266: ! 267: glEnable (GL_BLEND); ! 268: GL_Bind (alphaskytexture); ! 269: speedscale = realtime*16; ! 270: speedscale -= (int)speedscale & ~127 ; ! 271: ! 272: EmitSkyPolys (fa); ! 273: ! 274: glDisable (GL_BLEND); ! 275: } ! 276: ! 277: #ifndef QUAKE2 ! 278: /* ! 279: ================= ! 280: R_DrawSkyChain ! 281: ================= ! 282: */ ! 283: void R_DrawSkyChain (msurface_t *s) ! 284: { ! 285: msurface_t *fa; ! 286: ! 287: // used when gl_texsort is on ! 288: GL_Bind(solidskytexture); ! 289: speedscale = realtime*8; ! 290: speedscale -= (int)speedscale & ~127 ; ! 291: ! 292: for (fa=s ; fa ; fa=fa->texturechain) ! 293: EmitSkyPolys (fa); ! 294: ! 295: glEnable (GL_BLEND); ! 296: GL_Bind (alphaskytexture); ! 297: speedscale = realtime*16; ! 298: speedscale -= (int)speedscale & ~127 ; ! 299: ! 300: for (fa=s ; fa ; fa=fa->texturechain) ! 301: EmitSkyPolys (fa); ! 302: ! 303: glDisable (GL_BLEND); ! 304: } ! 305: ! 306: #endif ! 307: ! 308: /* ! 309: ================================================================= ! 310: ! 311: Quake 2 environment sky ! 312: ! 313: ================================================================= ! 314: */ ! 315: ! 316: #ifdef QUAKE2 ! 317: ! 318: ! 319: #define SKY_TEX 2000 ! 320: ! 321: /* ! 322: ================================================================= ! 323: ! 324: PCX Loading ! 325: ! 326: ================================================================= ! 327: */ ! 328: ! 329: typedef struct ! 330: { ! 331: char manufacturer; ! 332: char version; ! 333: char encoding; ! 334: char bits_per_pixel; ! 335: unsigned short xmin,ymin,xmax,ymax; ! 336: unsigned short hres,vres; ! 337: unsigned char palette[48]; ! 338: char reserved; ! 339: char color_planes; ! 340: unsigned short bytes_per_line; ! 341: unsigned short palette_type; ! 342: char filler[58]; ! 343: unsigned data; // unbounded ! 344: } pcx_t; ! 345: ! 346: byte *pcx_rgb; ! 347: ! 348: /* ! 349: ============ ! 350: LoadPCX ! 351: ============ ! 352: */ ! 353: void LoadPCX (FILE *f) ! 354: { ! 355: pcx_t *pcx, pcxbuf; ! 356: byte palette[768]; ! 357: byte *pix; ! 358: int x, y; ! 359: int dataByte, runLength; ! 360: int count; ! 361: ! 362: // ! 363: // parse the PCX file ! 364: // ! 365: fread (&pcxbuf, 1, sizeof(pcxbuf), f); ! 366: ! 367: pcx = &pcxbuf; ! 368: ! 369: if (pcx->manufacturer != 0x0a ! 370: || pcx->version != 5 ! 371: || pcx->encoding != 1 ! 372: || pcx->bits_per_pixel != 8 ! 373: || pcx->xmax >= 320 ! 374: || pcx->ymax >= 256) ! 375: { ! 376: Con_Printf ("Bad pcx file\n"); ! 377: return; ! 378: } ! 379: ! 380: // seek to palette ! 381: fseek (f, -768, SEEK_END); ! 382: fread (palette, 1, 768, f); ! 383: ! 384: fseek (f, sizeof(pcxbuf) - 4, SEEK_SET); ! 385: ! 386: count = (pcx->xmax+1) * (pcx->ymax+1); ! 387: pcx_rgb = malloc( count * 4); ! 388: ! 389: for (y=0 ; y<=pcx->ymax ; y++) ! 390: { ! 391: pix = pcx_rgb + 4*y*(pcx->xmax+1); ! 392: for (x=0 ; x<=pcx->ymax ; ) ! 393: { ! 394: dataByte = fgetc(f); ! 395: ! 396: if((dataByte & 0xC0) == 0xC0) ! 397: { ! 398: runLength = dataByte & 0x3F; ! 399: dataByte = fgetc(f); ! 400: } ! 401: else ! 402: runLength = 1; ! 403: ! 404: while(runLength-- > 0) ! 405: { ! 406: pix[0] = palette[dataByte*3]; ! 407: pix[1] = palette[dataByte*3+1]; ! 408: pix[2] = palette[dataByte*3+2]; ! 409: pix[3] = 255; ! 410: pix += 4; ! 411: x++; ! 412: } ! 413: } ! 414: } ! 415: } ! 416: ! 417: /* ! 418: ========================================================= ! 419: ! 420: TARGA LOADING ! 421: ! 422: ========================================================= ! 423: */ ! 424: ! 425: typedef struct _TargaHeader { ! 426: unsigned char id_length, colormap_type, image_type; ! 427: unsigned short colormap_index, colormap_length; ! 428: unsigned char colormap_size; ! 429: unsigned short x_origin, y_origin, width, height; ! 430: unsigned char pixel_size, attributes; ! 431: } TargaHeader; ! 432: ! 433: ! 434: TargaHeader targa_header; ! 435: byte *targa_rgba; ! 436: ! 437: int fgetLittleShort (FILE *f) ! 438: { ! 439: byte b1, b2; ! 440: ! 441: b1 = fgetc(f); ! 442: b2 = fgetc(f); ! 443: ! 444: return (short)(b1 + b2*256); ! 445: } ! 446: ! 447: int fgetLittleLong (FILE *f) ! 448: { ! 449: byte b1, b2, b3, b4; ! 450: ! 451: b1 = fgetc(f); ! 452: b2 = fgetc(f); ! 453: b3 = fgetc(f); ! 454: b4 = fgetc(f); ! 455: ! 456: return b1 + (b2<<8) + (b3<<16) + (b4<<24); ! 457: } ! 458: ! 459: ! 460: /* ! 461: ============= ! 462: LoadTGA ! 463: ============= ! 464: */ ! 465: void LoadTGA (FILE *fin) ! 466: { ! 467: int columns, rows, numPixels; ! 468: byte *pixbuf; ! 469: int row, column; ! 470: ! 471: targa_header.id_length = fgetc(fin); ! 472: targa_header.colormap_type = fgetc(fin); ! 473: targa_header.image_type = fgetc(fin); ! 474: ! 475: targa_header.colormap_index = fgetLittleShort(fin); ! 476: targa_header.colormap_length = fgetLittleShort(fin); ! 477: targa_header.colormap_size = fgetc(fin); ! 478: targa_header.x_origin = fgetLittleShort(fin); ! 479: targa_header.y_origin = fgetLittleShort(fin); ! 480: targa_header.width = fgetLittleShort(fin); ! 481: targa_header.height = fgetLittleShort(fin); ! 482: targa_header.pixel_size = fgetc(fin); ! 483: targa_header.attributes = fgetc(fin); ! 484: ! 485: if (targa_header.image_type!=2 ! 486: && targa_header.image_type!=10) ! 487: Sys_Error ("LoadTGA: Only type 2 and 10 targa RGB images supported\n"); ! 488: ! 489: if (targa_header.colormap_type !=0 ! 490: || (targa_header.pixel_size!=32 && targa_header.pixel_size!=24)) ! 491: Sys_Error ("Texture_LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n"); ! 492: ! 493: columns = targa_header.width; ! 494: rows = targa_header.height; ! 495: numPixels = columns * rows; ! 496: ! 497: targa_rgba = malloc (numPixels*4); ! 498: ! 499: if (targa_header.id_length != 0) ! 500: fseek(fin, targa_header.id_length, SEEK_CUR); // skip TARGA image comment ! 501: ! 502: if (targa_header.image_type==2) { // Uncompressed, RGB images ! 503: for(row=rows-1; row>=0; row--) { ! 504: pixbuf = targa_rgba + row*columns*4; ! 505: for(column=0; column<columns; column++) { ! 506: unsigned char red,green,blue,alphabyte; ! 507: switch (targa_header.pixel_size) { ! 508: case 24: ! 509: ! 510: blue = getc(fin); ! 511: green = getc(fin); ! 512: red = getc(fin); ! 513: *pixbuf++ = red; ! 514: *pixbuf++ = green; ! 515: *pixbuf++ = blue; ! 516: *pixbuf++ = 255; ! 517: break; ! 518: case 32: ! 519: blue = getc(fin); ! 520: green = getc(fin); ! 521: red = getc(fin); ! 522: alphabyte = getc(fin); ! 523: *pixbuf++ = red; ! 524: *pixbuf++ = green; ! 525: *pixbuf++ = blue; ! 526: *pixbuf++ = alphabyte; ! 527: break; ! 528: } ! 529: } ! 530: } ! 531: } ! 532: else if (targa_header.image_type==10) { // Runlength encoded RGB images ! 533: unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j; ! 534: for(row=rows-1; row>=0; row--) { ! 535: pixbuf = targa_rgba + row*columns*4; ! 536: for(column=0; column<columns; ) { ! 537: packetHeader=getc(fin); ! 538: packetSize = 1 + (packetHeader & 0x7f); ! 539: if (packetHeader & 0x80) { // run-length packet ! 540: switch (targa_header.pixel_size) { ! 541: case 24: ! 542: blue = getc(fin); ! 543: green = getc(fin); ! 544: red = getc(fin); ! 545: alphabyte = 255; ! 546: break; ! 547: case 32: ! 548: blue = getc(fin); ! 549: green = getc(fin); ! 550: red = getc(fin); ! 551: alphabyte = getc(fin); ! 552: break; ! 553: } ! 554: ! 555: for(j=0;j<packetSize;j++) { ! 556: *pixbuf++=red; ! 557: *pixbuf++=green; ! 558: *pixbuf++=blue; ! 559: *pixbuf++=alphabyte; ! 560: column++; ! 561: if (column==columns) { // run spans across rows ! 562: column=0; ! 563: if (row>0) ! 564: row--; ! 565: else ! 566: goto breakOut; ! 567: pixbuf = targa_rgba + row*columns*4; ! 568: } ! 569: } ! 570: } ! 571: else { // non run-length packet ! 572: for(j=0;j<packetSize;j++) { ! 573: switch (targa_header.pixel_size) { ! 574: case 24: ! 575: blue = getc(fin); ! 576: green = getc(fin); ! 577: red = getc(fin); ! 578: *pixbuf++ = red; ! 579: *pixbuf++ = green; ! 580: *pixbuf++ = blue; ! 581: *pixbuf++ = 255; ! 582: break; ! 583: case 32: ! 584: blue = getc(fin); ! 585: green = getc(fin); ! 586: red = getc(fin); ! 587: alphabyte = getc(fin); ! 588: *pixbuf++ = red; ! 589: *pixbuf++ = green; ! 590: *pixbuf++ = blue; ! 591: *pixbuf++ = alphabyte; ! 592: break; ! 593: } ! 594: column++; ! 595: if (column==columns) { // pixel packet run spans across rows ! 596: column=0; ! 597: if (row>0) ! 598: row--; ! 599: else ! 600: goto breakOut; ! 601: pixbuf = targa_rgba + row*columns*4; ! 602: } ! 603: } ! 604: } ! 605: } ! 606: breakOut:; ! 607: } ! 608: } ! 609: ! 610: fclose(fin); ! 611: } ! 612: ! 613: /* ! 614: ================== ! 615: R_LoadSkys ! 616: ================== ! 617: */ ! 618: char *suf[6] = {"rt", "bk", "lf", "ft", "up", "dn"}; ! 619: void R_LoadSkys (void) ! 620: { ! 621: int i; ! 622: FILE *f; ! 623: char name[64]; ! 624: ! 625: for (i=0 ; i<6 ; i++) ! 626: { ! 627: GL_Bind (SKY_TEX + i); ! 628: sprintf (name, "gfx/env/bkgtst%s.tga", suf[i]); ! 629: COM_FOpenFile (name, &f); ! 630: if (!f) ! 631: { ! 632: Con_Printf ("Couldn't load %s\n", name); ! 633: continue; ! 634: } ! 635: LoadTGA (f); ! 636: // LoadPCX (f); ! 637: ! 638: glTexImage2D (GL_TEXTURE_2D, 0, gl_solid_format, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, targa_rgba); ! 639: // glTexImage2D (GL_TEXTURE_2D, 0, gl_solid_format, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, pcx_rgb); ! 640: ! 641: free (targa_rgba); ! 642: // free (pcx_rgb); ! 643: ! 644: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ! 645: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ! 646: } ! 647: } ! 648: ! 649: ! 650: vec3_t skyclip[6] = { ! 651: {1,1,0}, ! 652: {1,-1,0}, ! 653: {0,-1,1}, ! 654: {0,1,1}, ! 655: {1,0,1}, ! 656: {-1,0,1} ! 657: }; ! 658: int c_sky; ! 659: ! 660: // 1 = s, 2 = t, 3 = 2048 ! 661: int st_to_vec[6][3] = ! 662: { ! 663: {3,-1,2}, ! 664: {-3,1,2}, ! 665: ! 666: {1,3,2}, ! 667: {-1,-3,2}, ! 668: ! 669: {-2,-1,3}, // 0 degrees yaw, look straight up ! 670: {2,-1,-3} // look straight down ! 671: ! 672: // {-1,2,3}, ! 673: // {1,2,-3} ! 674: }; ! 675: ! 676: // s = [0]/[2], t = [1]/[2] ! 677: int vec_to_st[6][3] = ! 678: { ! 679: {-2,3,1}, ! 680: {2,3,-1}, ! 681: ! 682: {1,3,2}, ! 683: {-1,3,-2}, ! 684: ! 685: {-2,-1,3}, ! 686: {-2,1,-3} ! 687: ! 688: // {-1,2,3}, ! 689: // {1,2,-3} ! 690: }; ! 691: ! 692: float skymins[2][6], skymaxs[2][6]; ! 693: ! 694: void DrawSkyPolygon (int nump, vec3_t vecs) ! 695: { ! 696: int i,j; ! 697: vec3_t v, av; ! 698: float s, t, dv; ! 699: int axis; ! 700: float *vp; ! 701: ! 702: c_sky++; ! 703: #if 0 ! 704: glBegin (GL_POLYGON); ! 705: for (i=0 ; i<nump ; i++, vecs+=3) ! 706: { ! 707: VectorAdd(vecs, r_origin, v); ! 708: glVertex3fv (v); ! 709: } ! 710: glEnd(); ! 711: return; ! 712: #endif ! 713: // decide which face it maps to ! 714: VectorCopy (vec3_origin, v); ! 715: for (i=0, vp=vecs ; i<nump ; i++, vp+=3) ! 716: { ! 717: VectorAdd (vp, v, v); ! 718: } ! 719: av[0] = fabs(v[0]); ! 720: av[1] = fabs(v[1]); ! 721: av[2] = fabs(v[2]); ! 722: if (av[0] > av[1] && av[0] > av[2]) ! 723: { ! 724: if (v[0] < 0) ! 725: axis = 1; ! 726: else ! 727: axis = 0; ! 728: } ! 729: else if (av[1] > av[2] && av[1] > av[0]) ! 730: { ! 731: if (v[1] < 0) ! 732: axis = 3; ! 733: else ! 734: axis = 2; ! 735: } ! 736: else ! 737: { ! 738: if (v[2] < 0) ! 739: axis = 5; ! 740: else ! 741: axis = 4; ! 742: } ! 743: ! 744: // project new texture coords ! 745: for (i=0 ; i<nump ; i++, vecs+=3) ! 746: { ! 747: j = vec_to_st[axis][2]; ! 748: if (j > 0) ! 749: dv = vecs[j - 1]; ! 750: else ! 751: dv = -vecs[-j - 1]; ! 752: ! 753: j = vec_to_st[axis][0]; ! 754: if (j < 0) ! 755: s = -vecs[-j -1] / dv; ! 756: else ! 757: s = vecs[j-1] / dv; ! 758: j = vec_to_st[axis][1]; ! 759: if (j < 0) ! 760: t = -vecs[-j -1] / dv; ! 761: else ! 762: t = vecs[j-1] / dv; ! 763: ! 764: if (s < skymins[0][axis]) ! 765: skymins[0][axis] = s; ! 766: if (t < skymins[1][axis]) ! 767: skymins[1][axis] = t; ! 768: if (s > skymaxs[0][axis]) ! 769: skymaxs[0][axis] = s; ! 770: if (t > skymaxs[1][axis]) ! 771: skymaxs[1][axis] = t; ! 772: } ! 773: } ! 774: ! 775: #define MAX_CLIP_VERTS 64 ! 776: void ClipSkyPolygon (int nump, vec3_t vecs, int stage) ! 777: { ! 778: float *norm; ! 779: float *v; ! 780: qboolean front, back; ! 781: float d, e; ! 782: float dists[MAX_CLIP_VERTS]; ! 783: int sides[MAX_CLIP_VERTS]; ! 784: vec3_t newv[2][MAX_CLIP_VERTS]; ! 785: int newc[2]; ! 786: int i, j; ! 787: ! 788: if (nump > MAX_CLIP_VERTS-2) ! 789: Sys_Error ("ClipSkyPolygon: MAX_CLIP_VERTS"); ! 790: if (stage == 6) ! 791: { // fully clipped, so draw it ! 792: DrawSkyPolygon (nump, vecs); ! 793: return; ! 794: } ! 795: ! 796: front = back = false; ! 797: norm = skyclip[stage]; ! 798: for (i=0, v = vecs ; i<nump ; i++, v+=3) ! 799: { ! 800: d = DotProduct (v, norm); ! 801: if (d > ON_EPSILON) ! 802: { ! 803: front = true; ! 804: sides[i] = SIDE_FRONT; ! 805: } ! 806: else if (d < ON_EPSILON) ! 807: { ! 808: back = true; ! 809: sides[i] = SIDE_BACK; ! 810: } ! 811: else ! 812: sides[i] = SIDE_ON; ! 813: dists[i] = d; ! 814: } ! 815: ! 816: if (!front || !back) ! 817: { // not clipped ! 818: ClipSkyPolygon (nump, vecs, stage+1); ! 819: return; ! 820: } ! 821: ! 822: // clip it ! 823: sides[i] = sides[0]; ! 824: dists[i] = dists[0]; ! 825: VectorCopy (vecs, (vecs+(i*3)) ); ! 826: newc[0] = newc[1] = 0; ! 827: ! 828: for (i=0, v = vecs ; i<nump ; i++, v+=3) ! 829: { ! 830: switch (sides[i]) ! 831: { ! 832: case SIDE_FRONT: ! 833: VectorCopy (v, newv[0][newc[0]]); ! 834: newc[0]++; ! 835: break; ! 836: case SIDE_BACK: ! 837: VectorCopy (v, newv[1][newc[1]]); ! 838: newc[1]++; ! 839: break; ! 840: case SIDE_ON: ! 841: VectorCopy (v, newv[0][newc[0]]); ! 842: newc[0]++; ! 843: VectorCopy (v, newv[1][newc[1]]); ! 844: newc[1]++; ! 845: break; ! 846: } ! 847: ! 848: if (sides[i] == SIDE_ON || sides[i+1] == SIDE_ON || sides[i+1] == sides[i]) ! 849: continue; ! 850: ! 851: d = dists[i] / (dists[i] - dists[i+1]); ! 852: for (j=0 ; j<3 ; j++) ! 853: { ! 854: e = v[j] + d*(v[j+3] - v[j]); ! 855: newv[0][newc[0]][j] = e; ! 856: newv[1][newc[1]][j] = e; ! 857: } ! 858: newc[0]++; ! 859: newc[1]++; ! 860: } ! 861: ! 862: // continue ! 863: ClipSkyPolygon (newc[0], newv[0][0], stage+1); ! 864: ClipSkyPolygon (newc[1], newv[1][0], stage+1); ! 865: } ! 866: ! 867: /* ! 868: ================= ! 869: R_DrawSkyChain ! 870: ================= ! 871: */ ! 872: void R_DrawSkyChain (msurface_t *s) ! 873: { ! 874: msurface_t *fa; ! 875: ! 876: int i; ! 877: vec3_t verts[MAX_CLIP_VERTS]; ! 878: glpoly_t *p; ! 879: ! 880: c_sky = 0; ! 881: GL_Bind(solidskytexture); ! 882: ! 883: // calculate vertex values for sky box ! 884: ! 885: for (fa=s ; fa ; fa=fa->texturechain) ! 886: { ! 887: for (p=fa->polys ; p ; p=p->next) ! 888: { ! 889: for (i=0 ; i<p->numverts ; i++) ! 890: { ! 891: VectorSubtract (p->verts[i], r_origin, verts[i]); ! 892: } ! 893: ClipSkyPolygon (p->numverts, verts[0], 0); ! 894: } ! 895: } ! 896: } ! 897: ! 898: ! 899: /* ! 900: ============== ! 901: R_ClearSkyBox ! 902: ============== ! 903: */ ! 904: void R_ClearSkyBox (void) ! 905: { ! 906: int i; ! 907: ! 908: for (i=0 ; i<6 ; i++) ! 909: { ! 910: skymins[0][i] = skymins[1][i] = 9999; ! 911: skymaxs[0][i] = skymaxs[1][i] = -9999; ! 912: } ! 913: } ! 914: ! 915: ! 916: void MakeSkyVec (float s, float t, int axis) ! 917: { ! 918: vec3_t v, b; ! 919: int j, k; ! 920: ! 921: b[0] = s*2048; ! 922: b[1] = t*2048; ! 923: b[2] = 2048; ! 924: ! 925: for (j=0 ; j<3 ; j++) ! 926: { ! 927: k = st_to_vec[axis][j]; ! 928: if (k < 0) ! 929: v[j] = -b[-k - 1]; ! 930: else ! 931: v[j] = b[k - 1]; ! 932: v[j] += r_origin[j]; ! 933: } ! 934: ! 935: // avoid bilerp seam ! 936: s = (s+1)*0.5; ! 937: t = (t+1)*0.5; ! 938: ! 939: if (s < 1.0/512) ! 940: s = 1.0/512; ! 941: else if (s > 511.0/512) ! 942: s = 511.0/512; ! 943: if (t < 1.0/512) ! 944: t = 1.0/512; ! 945: else if (t > 511.0/512) ! 946: t = 511.0/512; ! 947: ! 948: t = 1.0 - t; ! 949: glTexCoord2f (s, t); ! 950: glVertex3fv (v); ! 951: } ! 952: ! 953: /* ! 954: ============== ! 955: R_DrawSkyBox ! 956: ============== ! 957: */ ! 958: int skytexorder[6] = {0,2,1,3,4,5}; ! 959: void R_DrawSkyBox (void) ! 960: { ! 961: int i, j, k; ! 962: vec3_t v; ! 963: float s, t; ! 964: ! 965: #if 0 ! 966: glEnable (GL_BLEND); ! 967: glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); ! 968: glColor4f (1,1,1,0.5); ! 969: glDisable (GL_DEPTH_TEST); ! 970: #endif ! 971: for (i=0 ; i<6 ; i++) ! 972: { ! 973: if (skymins[0][i] >= skymaxs[0][i] ! 974: || skymins[1][i] >= skymaxs[1][i]) ! 975: continue; ! 976: ! 977: GL_Bind (SKY_TEX+skytexorder[i]); ! 978: #if 0 ! 979: skymins[0][i] = -1; ! 980: skymins[1][i] = -1; ! 981: skymaxs[0][i] = 1; ! 982: skymaxs[1][i] = 1; ! 983: #endif ! 984: glBegin (GL_QUADS); ! 985: MakeSkyVec (skymins[0][i], skymins[1][i], i); ! 986: MakeSkyVec (skymins[0][i], skymaxs[1][i], i); ! 987: MakeSkyVec (skymaxs[0][i], skymaxs[1][i], i); ! 988: MakeSkyVec (skymaxs[0][i], skymins[1][i], i); ! 989: glEnd (); ! 990: } ! 991: #if 0 ! 992: glDisable (GL_BLEND); ! 993: glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); ! 994: glColor4f (1,1,1,0.5); ! 995: glEnable (GL_DEPTH_TEST); ! 996: #endif ! 997: } ! 998: ! 999: ! 1000: #endif ! 1001: ! 1002: //=============================================================== ! 1003: ! 1004: /* ! 1005: ============= ! 1006: R_InitSky ! 1007: ! 1008: A sky texture is 256*128, with the right side being a masked overlay ! 1009: ============== ! 1010: */ ! 1011: void R_InitSky (texture_t *mt) ! 1012: { ! 1013: int i, j, p; ! 1014: byte *src; ! 1015: unsigned trans[128*128]; ! 1016: unsigned transpix; ! 1017: int r, g, b; ! 1018: unsigned *rgba; ! 1019: extern int skytexturenum; ! 1020: ! 1021: src = (byte *)mt + mt->offsets[0]; ! 1022: ! 1023: // make an average value for the back to avoid ! 1024: // a fringe on the top level ! 1025: ! 1026: r = g = b = 0; ! 1027: for (i=0 ; i<128 ; i++) ! 1028: for (j=0 ; j<128 ; j++) ! 1029: { ! 1030: p = src[i*256 + j + 128]; ! 1031: rgba = &d_8to24table[p]; ! 1032: trans[(i*128) + j] = *rgba; ! 1033: r += ((byte *)rgba)[0]; ! 1034: g += ((byte *)rgba)[1]; ! 1035: b += ((byte *)rgba)[2]; ! 1036: } ! 1037: ! 1038: ((byte *)&transpix)[0] = r/(128*128); ! 1039: ((byte *)&transpix)[1] = g/(128*128); ! 1040: ((byte *)&transpix)[2] = b/(128*128); ! 1041: ((byte *)&transpix)[3] = 0; ! 1042: ! 1043: ! 1044: if (!solidskytexture) ! 1045: solidskytexture = texture_extension_number++; ! 1046: GL_Bind (solidskytexture ); ! 1047: glTexImage2D (GL_TEXTURE_2D, 0, gl_solid_format, 128, 128, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans); ! 1048: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ! 1049: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ! 1050: ! 1051: ! 1052: for (i=0 ; i<128 ; i++) ! 1053: for (j=0 ; j<128 ; j++) ! 1054: { ! 1055: p = src[i*256 + j]; ! 1056: if (p == 0) ! 1057: trans[(i*128) + j] = transpix; ! 1058: else ! 1059: trans[(i*128) + j] = d_8to24table[p]; ! 1060: } ! 1061: ! 1062: if (!alphaskytexture) ! 1063: alphaskytexture = texture_extension_number++; ! 1064: GL_Bind(alphaskytexture); ! 1065: glTexImage2D (GL_TEXTURE_2D, 0, gl_alpha_format, 128, 128, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans); ! 1066: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ! 1067: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ! 1068: } ! 1069:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.