![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gl_draw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to gl_draw.c CVS log | Up to [Quake] / quake1 |
1.1 ! root 1: ! 2: // draw.c -- this is the only file outside the refresh that touches the ! 3: // vid buffer ! 4: ! 5: #include "quakedef.h" ! 6: ! 7: cvar_t gl_nobind = {"gl_nobind", "0"}; ! 8: cvar_t gl_max_size = {"gl_max_size", "1024"}; ! 9: cvar_t gl_round_down = {"gl_round_down", "1"}; ! 10: cvar_t gl_picmip = {"gl_picmip", "0"}; ! 11: ! 12: byte *draw_chars; // 8*8 graphic characters ! 13: qpic_t *draw_disc; ! 14: qpic_t *draw_backtile; ! 15: ! 16: int translate_texture; ! 17: int char_texture; ! 18: ! 19: typedef struct ! 20: { ! 21: int texnum; ! 22: float sl, tl, sh, th; ! 23: } glpic_t; ! 24: ! 25: byte conback_buffer[sizeof(qpic_t) + sizeof(glpic_t)]; ! 26: qpic_t *conback = (qpic_t *)&conback_buffer; ! 27: ! 28: int gl_lightmap_format = 4; ! 29: int gl_solid_format = 3; ! 30: int gl_alpha_format = 4; ! 31: ! 32: int gl_filter_min = GL_LINEAR_MIPMAP_NEAREST; ! 33: int gl_filter_max = GL_LINEAR; ! 34: ! 35: ! 36: int texels; ! 37: ! 38: typedef struct ! 39: { ! 40: int texnum; ! 41: char identifier[64]; ! 42: int width, height; ! 43: qboolean mipmap; ! 44: } gltexture_t; ! 45: ! 46: #define MAX_GLTEXTURES 1024 ! 47: gltexture_t gltextures[MAX_GLTEXTURES]; ! 48: int numgltextures; ! 49: ! 50: ! 51: void GL_Bind (int texnum) ! 52: { ! 53: if (gl_nobind.value) ! 54: texnum = char_texture; ! 55: if (currenttexture == texnum) ! 56: return; ! 57: currenttexture = texnum; ! 58: bindTexFunc (GL_TEXTURE_2D, texnum); ! 59: } ! 60: ! 61: void GL_Texels_f (void) ! 62: { ! 63: Con_Printf ("Current uploaded texels: %i\n", texels); ! 64: } ! 65: ! 66: /* ! 67: ============================================================================= ! 68: ! 69: scrap allocation ! 70: ! 71: Allocate all the little status bar obejcts into a single texture ! 72: to crutch up stupid hardware / drivers ! 73: ! 74: ============================================================================= ! 75: */ ! 76: ! 77: #define MAX_SCRAPS 1 ! 78: #define BLOCK_WIDTH 256 ! 79: #define BLOCK_HEIGHT 256 ! 80: ! 81: int scrap_allocated[MAX_SCRAPS][BLOCK_WIDTH]; ! 82: byte scrap_texels[MAX_SCRAPS][BLOCK_WIDTH*BLOCK_HEIGHT*4]; ! 83: qboolean scrap_dirty; ! 84: int scrap_texnum; ! 85: ! 86: // returns a texture number and the position inside it ! 87: int Scrap_AllocBlock (int w, int h, int *x, int *y) ! 88: { ! 89: int i, j; ! 90: int best, best2; ! 91: int bestx; ! 92: int texnum; ! 93: ! 94: for (texnum=0 ; texnum<MAX_SCRAPS ; texnum++) ! 95: { ! 96: best = BLOCK_HEIGHT; ! 97: ! 98: for (i=0 ; i<BLOCK_WIDTH-w ; i++) ! 99: { ! 100: best2 = 0; ! 101: ! 102: for (j=0 ; j<w ; j++) ! 103: { ! 104: if (scrap_allocated[texnum][i+j] >= best) ! 105: break; ! 106: if (scrap_allocated[texnum][i+j] > best2) ! 107: best2 = scrap_allocated[texnum][i+j]; ! 108: } ! 109: if (j == w) ! 110: { // this is a valid spot ! 111: *x = i; ! 112: *y = best = best2; ! 113: } ! 114: } ! 115: ! 116: if (best + h > BLOCK_HEIGHT) ! 117: continue; ! 118: ! 119: for (i=0 ; i<w ; i++) ! 120: scrap_allocated[texnum][*x + i] = best + h; ! 121: ! 122: return texnum; ! 123: } ! 124: ! 125: return -1; ! 126: // Sys_Error ("Scrap_AllocBlock: full"); ! 127: } ! 128: ! 129: int scrap_uploads; ! 130: ! 131: void Scrap_Upload (void) ! 132: { ! 133: scrap_uploads++; ! 134: GL_Bind(scrap_texnum); ! 135: GL_Upload8 (scrap_texels[0], BLOCK_WIDTH, BLOCK_HEIGHT, false, true); ! 136: scrap_dirty = false; ! 137: } ! 138: ! 139: //============================================================================= ! 140: /* Support Routines */ ! 141: ! 142: typedef struct cachepic_s ! 143: { ! 144: char name[MAX_QPATH]; ! 145: qpic_t pic; ! 146: byte padding[32]; // for appended glpic ! 147: } cachepic_t; ! 148: ! 149: #define MAX_CACHED_PICS 128 ! 150: cachepic_t menu_cachepics[MAX_CACHED_PICS]; ! 151: int menu_numcachepics; ! 152: ! 153: byte menuplyr_pixels[4096]; ! 154: ! 155: int pic_texels; ! 156: int pic_count; ! 157: ! 158: qpic_t *Draw_PicFromWad (char *name) ! 159: { ! 160: qpic_t *p; ! 161: glpic_t *gl; ! 162: ! 163: p = W_GetLumpName (name); ! 164: gl = (glpic_t *)p->data; ! 165: ! 166: // load little ones into the scrap ! 167: if (p->width < 64 && p->height < 64) ! 168: { ! 169: int x, y; ! 170: int i, j, k; ! 171: int texnum; ! 172: ! 173: texnum = Scrap_AllocBlock (p->width, p->height, &x, &y); ! 174: if (texnum == -1) ! 175: goto nonscrap; ! 176: scrap_dirty = true; ! 177: k = 0; ! 178: for (i=0 ; i<p->height ; i++) ! 179: for (j=0 ; j<p->width ; j++, k++) ! 180: scrap_texels[texnum][(y+i)*BLOCK_WIDTH + x + j] = p->data[k]; ! 181: texnum += scrap_texnum; ! 182: gl->texnum = texnum; ! 183: gl->sl = (x+0.01)/(float)BLOCK_WIDTH; ! 184: gl->sh = (x+p->width-0.01)/(float)BLOCK_WIDTH; ! 185: gl->tl = (y+0.01)/(float)BLOCK_WIDTH; ! 186: gl->th = (y+p->height-0.01)/(float)BLOCK_WIDTH; ! 187: ! 188: pic_count++; ! 189: pic_texels += p->width*p->height; ! 190: } ! 191: else ! 192: { ! 193: nonscrap: ! 194: gl->texnum = GL_LoadPicTexture (p); ! 195: gl->sl = 0; ! 196: gl->sh = 1; ! 197: gl->tl = 0; ! 198: gl->th = 1; ! 199: } ! 200: return p; ! 201: } ! 202: ! 203: ! 204: /* ! 205: ================ ! 206: Draw_CachePic ! 207: ================ ! 208: */ ! 209: qpic_t *Draw_CachePic (char *path) ! 210: { ! 211: cachepic_t *pic; ! 212: int i; ! 213: qpic_t *dat; ! 214: glpic_t *gl; ! 215: ! 216: for (pic=menu_cachepics, i=0 ; i<menu_numcachepics ; pic++, i++) ! 217: if (!strcmp (path, pic->name)) ! 218: return &pic->pic; ! 219: ! 220: if (menu_numcachepics == MAX_CACHED_PICS) ! 221: Sys_Error ("menu_numcachepics == MAX_CACHED_PICS"); ! 222: menu_numcachepics++; ! 223: strcpy (pic->name, path); ! 224: ! 225: // ! 226: // load the pic from disk ! 227: // ! 228: dat = (qpic_t *)COM_LoadTempFile (path); ! 229: if (!dat) ! 230: Sys_Error ("Draw_CachePic: failed to load %s", path); ! 231: SwapPic (dat); ! 232: ! 233: // HACK HACK HACK --- we need to keep the bytes for ! 234: // the translatable player picture just for the menu ! 235: // configuration dialog ! 236: if (!strcmp (path, "gfx/menuplyr.lmp")) ! 237: memcpy (menuplyr_pixels, dat->data, dat->width*dat->height); ! 238: ! 239: pic->pic.width = dat->width; ! 240: pic->pic.height = dat->height; ! 241: ! 242: gl = (glpic_t *)pic->pic.data; ! 243: gl->texnum = GL_LoadPicTexture (dat); ! 244: gl->sl = 0; ! 245: gl->sh = 1; ! 246: gl->tl = 0; ! 247: gl->th = 1; ! 248: ! 249: return &pic->pic; ! 250: } ! 251: ! 252: ! 253: void Draw_CharToConback (int num, byte *dest) ! 254: { ! 255: int row, col; ! 256: byte *source; ! 257: int drawline; ! 258: int x; ! 259: ! 260: row = num>>4; ! 261: col = num&15; ! 262: source = draw_chars + (row<<10) + (col<<3); ! 263: ! 264: drawline = 8; ! 265: ! 266: while (drawline--) ! 267: { ! 268: for (x=0 ; x<8 ; x++) ! 269: if (source[x] != 255) ! 270: dest[x] = 0x60 + source[x]; ! 271: source += 128; ! 272: dest += 320; ! 273: } ! 274: ! 275: } ! 276: ! 277: typedef struct ! 278: { ! 279: char *name; ! 280: int minimize, maximize; ! 281: } mode_t; ! 282: ! 283: mode_t modes[] = { ! 284: {"GL_NEAREST", GL_NEAREST, GL_NEAREST}, ! 285: {"GL_LINEAR", GL_LINEAR, GL_LINEAR}, ! 286: {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST}, ! 287: {"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR}, ! 288: {"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST}, ! 289: {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR} ! 290: }; ! 291: ! 292: /* ! 293: =============== ! 294: Draw_TextureMode_f ! 295: =============== ! 296: */ ! 297: void Draw_TextureMode_f (void) ! 298: { ! 299: int i; ! 300: gltexture_t *glt; ! 301: ! 302: if (Cmd_Argc() == 1) ! 303: { ! 304: for (i=0 ; i< 6 ; i++) ! 305: if (gl_filter_min == modes[i].minimize) ! 306: { ! 307: Con_Printf ("%s\n", modes[i].name); ! 308: return; ! 309: } ! 310: Con_Printf ("current filter is unknown???\n"); ! 311: return; ! 312: } ! 313: ! 314: for (i=0 ; i< 6 ; i++) ! 315: { ! 316: if (!Q_strcasecmp (modes[i].name, Cmd_Argv(1) ) ) ! 317: break; ! 318: } ! 319: if (i == 6) ! 320: { ! 321: Con_Printf ("bad filter name\n"); ! 322: return; ! 323: } ! 324: ! 325: gl_filter_min = modes[i].minimize; ! 326: gl_filter_max = modes[i].maximize; ! 327: ! 328: // change all the existing mipmap texture objects ! 329: for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++) ! 330: { ! 331: if (glt->mipmap) ! 332: { ! 333: GL_Bind (glt->texnum); ! 334: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); ! 335: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); ! 336: } ! 337: } ! 338: } ! 339: ! 340: /* ! 341: =============== ! 342: Draw_Init ! 343: =============== ! 344: */ ! 345: void Draw_Init (void) ! 346: { ! 347: int i; ! 348: qpic_t *cb; ! 349: byte *dest; ! 350: int x, y; ! 351: char ver[40]; ! 352: glpic_t *gl; ! 353: ! 354: Cvar_RegisterVariable (&gl_nobind); ! 355: Cvar_RegisterVariable (&gl_max_size); ! 356: Cvar_RegisterVariable (&gl_round_down); ! 357: Cvar_RegisterVariable (&gl_picmip); ! 358: ! 359: // 3dfx can only handle 256 wide textures ! 360: if (!Q_strncasecmp ((char *)gl_renderer, "3dfx",4)) ! 361: Cvar_Set ("gl_max_size", "256"); ! 362: ! 363: Cmd_AddCommand ("gl_texturemode", &Draw_TextureMode_f); ! 364: Cmd_AddCommand ("gl_texels", &GL_Texels_f); ! 365: ! 366: ! 367: // load the console background and the charset ! 368: // by hand, because we need to write the version ! 369: // string into the background before turning ! 370: // it into a texture ! 371: draw_chars = W_GetLumpName ("conchars"); ! 372: for (i=0 ; i<256*64 ; i++) ! 373: if (draw_chars[i] == 0) ! 374: draw_chars[i] = 255; // proper transparent color ! 375: ! 376: cb = (qpic_t *)COM_LoadTempFile ("gfx/conback.lmp"); ! 377: if (!cb) ! 378: Sys_Error ("Couldn't load gfx/conback.lmp"); ! 379: SwapPic (cb); ! 380: ! 381: // hack the version number directly into the pic ! 382: sprintf (ver, "(gl %4.2f) %4.2f", (float)GLQUAKE_VERSION, (float)VERSION); ! 383: dest = cb->data + 320*186 + 320 - 11 - 8*strlen(ver); ! 384: y = strlen(ver); ! 385: for (x=0 ; x<y ; x++) ! 386: Draw_CharToConback (ver[x], dest+(x<<3)); ! 387: ! 388: // now turn them into textures ! 389: char_texture = GL_LoadTexture ("charset", 128, 128, draw_chars, false, true); ! 390: conback->width = cb->width; ! 391: conback->height = cb->height; ! 392: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); ! 393: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); ! 394: ! 395: gl = (glpic_t *)conback->data; ! 396: gl->texnum = GL_LoadTexture ("conback", 320, 200, cb->data, false, false); ! 397: gl->sl = 0; ! 398: gl->sh = 1; ! 399: gl->tl = 0; ! 400: gl->th = 1; ! 401: ! 402: // save a texture slot for translated picture ! 403: translate_texture = texture_extension_number++; ! 404: ! 405: // save slots for scraps ! 406: scrap_texnum = texture_extension_number; ! 407: texture_extension_number += MAX_SCRAPS; ! 408: ! 409: // ! 410: // get the other pics we need ! 411: // ! 412: draw_disc = Draw_PicFromWad ("disc"); ! 413: draw_backtile = Draw_PicFromWad ("backtile"); ! 414: } ! 415: ! 416: ! 417: ! 418: /* ! 419: ================ ! 420: Draw_Character ! 421: ! 422: Draws one 8*8 graphics character with 0 being transparent. ! 423: It can be clipped to the top of the screen to allow the console to be ! 424: smoothly scrolled off. ! 425: ================ ! 426: */ ! 427: void Draw_Character (int x, int y, int num) ! 428: { ! 429: byte *dest; ! 430: byte *source; ! 431: unsigned short *pusdest; ! 432: int drawline; ! 433: int row, col; ! 434: float frow, fcol, size; ! 435: ! 436: if (num == 32) ! 437: return; // space ! 438: ! 439: num &= 255; ! 440: ! 441: if (y <= -8) ! 442: return; // totally off screen ! 443: ! 444: row = num>>4; ! 445: col = num&15; ! 446: ! 447: frow = row*0.0625; ! 448: fcol = col*0.0625; ! 449: size = 0.0625; ! 450: ! 451: GL_Bind (char_texture); ! 452: ! 453: glBegin (GL_QUADS); ! 454: glTexCoord2f (fcol, frow); ! 455: glVertex2f (x, y); ! 456: glTexCoord2f (fcol + size, frow); ! 457: glVertex2f (x+8, y); ! 458: glTexCoord2f (fcol + size, frow + size); ! 459: glVertex2f (x+8, y+8); ! 460: glTexCoord2f (fcol, frow + size); ! 461: glVertex2f (x, y+8); ! 462: glEnd (); ! 463: } ! 464: ! 465: /* ! 466: ================ ! 467: Draw_String ! 468: ================ ! 469: */ ! 470: void Draw_String (int x, int y, char *str) ! 471: { ! 472: while (*str) ! 473: { ! 474: Draw_Character (x, y, *str); ! 475: str++; ! 476: x += 8; ! 477: } ! 478: } ! 479: ! 480: /* ! 481: ================ ! 482: Draw_DebugChar ! 483: ! 484: Draws a single character directly to the upper right corner of the screen. ! 485: This is for debugging lockups by drawing different chars in different parts ! 486: of the code. ! 487: ================ ! 488: */ ! 489: void Draw_DebugChar (char num) ! 490: { ! 491: } ! 492: ! 493: /* ! 494: ============= ! 495: Draw_Pic ! 496: ============= ! 497: */ ! 498: void Draw_Pic (int x, int y, qpic_t *pic) ! 499: { ! 500: byte *dest, *source; ! 501: unsigned short *pusdest; ! 502: int v, u; ! 503: glpic_t *gl; ! 504: ! 505: if (scrap_dirty) ! 506: Scrap_Upload (); ! 507: gl = (glpic_t *)pic->data; ! 508: glColor4f (1,1,1,1); ! 509: GL_Bind (gl->texnum); ! 510: glBegin (GL_QUADS); ! 511: glTexCoord2f (gl->sl, gl->tl); ! 512: glVertex2f (x, y); ! 513: glTexCoord2f (gl->sh, gl->tl); ! 514: glVertex2f (x+pic->width, y); ! 515: glTexCoord2f (gl->sh, gl->th); ! 516: glVertex2f (x+pic->width, y+pic->height); ! 517: glTexCoord2f (gl->sl, gl->th); ! 518: glVertex2f (x, y+pic->height); ! 519: glEnd (); ! 520: } ! 521: ! 522: ! 523: /* ! 524: ============= ! 525: Draw_TransPic ! 526: ============= ! 527: */ ! 528: void Draw_TransPic (int x, int y, qpic_t *pic) ! 529: { ! 530: byte *dest, *source, tbyte; ! 531: unsigned short *pusdest; ! 532: int v, u; ! 533: ! 534: if (x < 0 || (unsigned)(x + pic->width) > vid.width || y < 0 || ! 535: (unsigned)(y + pic->height) > vid.height) ! 536: { ! 537: Sys_Error ("Draw_TransPic: bad coordinates"); ! 538: } ! 539: ! 540: Draw_Pic (x, y, pic); ! 541: } ! 542: ! 543: ! 544: /* ! 545: ============= ! 546: Draw_TransPicTranslate ! 547: ! 548: Only used for the player color selection menu ! 549: ============= ! 550: */ ! 551: void Draw_TransPicTranslate (int x, int y, qpic_t *pic, byte *translation) ! 552: { ! 553: int v, u, c; ! 554: unsigned trans[64*64], *dest; ! 555: byte *src; ! 556: int p; ! 557: ! 558: GL_Bind (translate_texture); ! 559: ! 560: c = pic->width * pic->height; ! 561: ! 562: dest = trans; ! 563: for (v=0 ; v<64 ; v++, dest += 64) ! 564: { ! 565: src = &menuplyr_pixels[ ((v*pic->height)>>6) *pic->width]; ! 566: for (u=0 ; u<64 ; u++) ! 567: { ! 568: p = src[(u*pic->width)>>6]; ! 569: if (p == 255) ! 570: dest[u] = p; ! 571: else ! 572: dest[u] = d_8to24table[translation[p]]; ! 573: } ! 574: } ! 575: ! 576: glTexImage2D (GL_TEXTURE_2D, 0, gl_alpha_format, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans); ! 577: ! 578: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ! 579: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ! 580: ! 581: glColor3f (1,1,1); ! 582: glBegin (GL_QUADS); ! 583: glTexCoord2f (0, 0); ! 584: glVertex2f (x, y); ! 585: glTexCoord2f (1, 0); ! 586: glVertex2f (x+pic->width, y); ! 587: glTexCoord2f (1, 1); ! 588: glVertex2f (x+pic->width, y+pic->height); ! 589: glTexCoord2f (0, 1); ! 590: glVertex2f (x, y+pic->height); ! 591: glEnd (); ! 592: } ! 593: ! 594: ! 595: /* ! 596: ================ ! 597: Draw_ConsoleBackground ! 598: ! 599: ================ ! 600: */ ! 601: void Draw_ConsoleBackground (int lines) ! 602: { ! 603: Draw_Pic (0, lines-200, conback); ! 604: } ! 605: ! 606: ! 607: /* ! 608: ============= ! 609: Draw_TileClear ! 610: ! 611: This repeats a 64*64 tile graphic to fill the screen around a sized down ! 612: refresh window. ! 613: ============= ! 614: */ ! 615: void Draw_TileClear (int x, int y, int w, int h) ! 616: { ! 617: glColor3f (1,1,1); ! 618: GL_Bind (*(int *)draw_backtile->data); ! 619: glBegin (GL_QUADS); ! 620: glTexCoord2f (x/64.0, y/64.0); ! 621: glVertex2f (x, y); ! 622: glTexCoord2f ( (x+w)/64.0, y/64.0); ! 623: glVertex2f (x+w, y); ! 624: glTexCoord2f ( (x+w)/64.0, (y+h)/64.0); ! 625: glVertex2f (x+w, y+h); ! 626: glTexCoord2f ( x/64.0, (y+h)/64.0 ); ! 627: glVertex2f (x, y+h); ! 628: glEnd (); ! 629: } ! 630: ! 631: ! 632: /* ! 633: ============= ! 634: Draw_Fill ! 635: ! 636: Fills a box of pixels with a single color ! 637: ============= ! 638: */ ! 639: void Draw_Fill (int x, int y, int w, int h, int c) ! 640: { ! 641: glDisable (GL_TEXTURE_2D); ! 642: glColor3f (host_basepal[c*3]/255.0, ! 643: host_basepal[c*3+1]/255.0, ! 644: host_basepal[c*3+2]/255.0); ! 645: ! 646: glBegin (GL_QUADS); ! 647: ! 648: glVertex2f (x,y); ! 649: glVertex2f (x+w, y); ! 650: glVertex2f (x+w, y+h); ! 651: glVertex2f (x, y+h); ! 652: ! 653: glEnd (); ! 654: glColor3f (1,1,1); ! 655: glEnable (GL_TEXTURE_2D); ! 656: } ! 657: //============================================================================= ! 658: ! 659: /* ! 660: ================ ! 661: Draw_FadeScreen ! 662: ! 663: ================ ! 664: */ ! 665: void Draw_FadeScreen (void) ! 666: { ! 667: glEnable (GL_BLEND); ! 668: glDisable (GL_TEXTURE_2D); ! 669: glColor4f (0, 0, 0, 0.8); ! 670: glBegin (GL_QUADS); ! 671: ! 672: glVertex2f (0,0); ! 673: glVertex2f (320, 0); ! 674: glVertex2f (320, 200); ! 675: glVertex2f (0, 200); ! 676: ! 677: glEnd (); ! 678: glColor4f (1,1,1,1); ! 679: glEnable (GL_TEXTURE_2D); ! 680: glDisable (GL_BLEND); ! 681: ! 682: Sbar_Changed(); ! 683: } ! 684: ! 685: //============================================================================= ! 686: ! 687: /* ! 688: ================ ! 689: Draw_BeginDisc ! 690: ! 691: Draws the little blue disc in the corner of the screen. ! 692: Call before beginning any disc IO. ! 693: ================ ! 694: */ ! 695: void Draw_BeginDisc (void) ! 696: { ! 697: if (!draw_disc) ! 698: return; ! 699: glDrawBuffer (GL_FRONT); ! 700: Draw_Pic (320 - 24, 0, draw_disc); ! 701: glDrawBuffer (GL_BACK); ! 702: } ! 703: ! 704: ! 705: /* ! 706: ================ ! 707: Draw_EndDisc ! 708: ! 709: Erases the disc icon. ! 710: Call after completing any disc IO ! 711: ================ ! 712: */ ! 713: void Draw_EndDisc (void) ! 714: { ! 715: } ! 716: ! 717: /* ! 718: ================ ! 719: GL_Set2D ! 720: ! 721: Setup as if the screen was 320*200 ! 722: ================ ! 723: */ ! 724: void GL_Set2D (void) ! 725: { ! 726: glViewport (glx, gly, glwidth, glheight); ! 727: ! 728: glMatrixMode(GL_PROJECTION); ! 729: glLoadIdentity (); ! 730: glOrtho (0, 320, 200, 0, -99999, 99999); ! 731: ! 732: glMatrixMode(GL_MODELVIEW); ! 733: glLoadIdentity (); ! 734: ! 735: glDisable (GL_DEPTH_TEST); ! 736: glDisable (GL_CULL_FACE); ! 737: glDisable (GL_BLEND); ! 738: glEnable (GL_ALPHA_TEST); ! 739: // glDisable (GL_ALPHA_TEST); ! 740: ! 741: glColor4f (1,1,1,1); ! 742: } ! 743: ! 744: //==================================================================== ! 745: ! 746: /* ! 747: ================ ! 748: GL_FindTexture ! 749: ================ ! 750: */ ! 751: int GL_FindTexture (char *identifier) ! 752: { ! 753: int i; ! 754: gltexture_t *glt; ! 755: ! 756: for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++) ! 757: { ! 758: if (!strcmp (identifier, glt->identifier)) ! 759: return gltextures[i].texnum; ! 760: } ! 761: ! 762: return -1; ! 763: } ! 764: ! 765: /* ! 766: ================ ! 767: GL_ResampleTexture ! 768: ================ ! 769: */ ! 770: void GL_ResampleTexture (unsigned *in, int inwidth, int inheight, unsigned *out, int outwidth, int outheight) ! 771: { ! 772: int i, j; ! 773: unsigned *inrow, *inrow2; ! 774: unsigned frac, fracstep; ! 775: unsigned p1[1024], p2[1024]; ! 776: byte *pix1, *pix2, *pix3, *pix4; ! 777: ! 778: fracstep = inwidth*0x10000/outwidth; ! 779: ! 780: frac = fracstep>>2; ! 781: for (i=0 ; i<outwidth ; i++) ! 782: { ! 783: p1[i] = 4*(frac>>16); ! 784: frac += fracstep; ! 785: } ! 786: frac = 3*(fracstep>>2); ! 787: for (i=0 ; i<outwidth ; i++) ! 788: { ! 789: p2[i] = 4*(frac>>16); ! 790: frac += fracstep; ! 791: } ! 792: ! 793: for (i=0 ; i<outheight ; i++, out += outwidth) ! 794: { ! 795: inrow = in + inwidth*(int)((i+0.25)*inheight/outheight); ! 796: inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight); ! 797: frac = fracstep >> 1; ! 798: for (j=0 ; j<outwidth ; j++) ! 799: { ! 800: pix1 = (byte *)inrow + p1[j]; ! 801: pix2 = (byte *)inrow + p2[j]; ! 802: pix3 = (byte *)inrow2 + p1[j]; ! 803: pix4 = (byte *)inrow2 + p2[j]; ! 804: ((byte *)(out+j))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2; ! 805: ((byte *)(out+j))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2; ! 806: ((byte *)(out+j))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2; ! 807: ((byte *)(out+j))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2; ! 808: } ! 809: } ! 810: } ! 811: ! 812: /* ! 813: ================ ! 814: GL_MipMap ! 815: ! 816: Operates in place, quartering the size of the texture ! 817: ================ ! 818: */ ! 819: void GL_MipMap (byte *in, int width, int height) ! 820: { ! 821: int i, j; ! 822: byte *out; ! 823: ! 824: width <<=2; ! 825: height >>= 1; ! 826: out = in; ! 827: for (i=0 ; i<height ; i++, in+=width) ! 828: { ! 829: for (j=0 ; j<width ; j+=8, out+=4, in+=8) ! 830: { ! 831: out[0] = (in[0] + in[4] + in[width+0] + in[width+4])>>2; ! 832: out[1] = (in[1] + in[5] + in[width+1] + in[width+5])>>2; ! 833: out[2] = (in[2] + in[6] + in[width+2] + in[width+6])>>2; ! 834: out[3] = (in[3] + in[7] + in[width+3] + in[width+7])>>2; ! 835: } ! 836: } ! 837: } ! 838: ! 839: /* ! 840: =============== ! 841: GL_Upload32 ! 842: =============== ! 843: */ ! 844: void GL_Upload32 (unsigned *data, int width, int height, qboolean mipmap, qboolean alpha) ! 845: { ! 846: int samples; ! 847: static unsigned scaled[1024*512]; // [512*256]; ! 848: int scaled_width, scaled_height; ! 849: ! 850: for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1) ! 851: ; ! 852: if (gl_round_down.value && scaled_width > width) ! 853: scaled_width >>= 1; ! 854: for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1) ! 855: ; ! 856: if (gl_round_down.value && scaled_height > height) ! 857: scaled_height >>= 1; ! 858: ! 859: scaled_width >>= (int)gl_picmip.value; ! 860: scaled_height >>= (int)gl_picmip.value; ! 861: ! 862: if (scaled_width > gl_max_size.value) ! 863: scaled_width = gl_max_size.value; ! 864: if (scaled_height > gl_max_size.value) ! 865: scaled_height = gl_max_size.value; ! 866: ! 867: if (scaled_width * scaled_height > sizeof(scaled)/4) ! 868: Sys_Error ("GL_LoadTexture: too big"); ! 869: ! 870: samples = alpha ? gl_alpha_format : gl_solid_format; ! 871: ! 872: #if 0 ! 873: if (mipmap) ! 874: gluBuild2DMipmaps (GL_TEXTURE_2D, samples, width, height, GL_RGBA, GL_UNSIGNED_BYTE, trans); ! 875: else if (scaled_width == width && scaled_height == height) ! 876: glTexImage2D (GL_TEXTURE_2D, 0, samples, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans); ! 877: else ! 878: { ! 879: gluScaleImage (GL_RGBA, width, height, GL_UNSIGNED_BYTE, trans, ! 880: scaled_width, scaled_height, GL_UNSIGNED_BYTE, scaled); ! 881: glTexImage2D (GL_TEXTURE_2D, 0, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled); ! 882: } ! 883: #else ! 884: ! 885: if (scaled_width == width && scaled_height == height) ! 886: { ! 887: if (!mipmap) ! 888: { ! 889: glTexImage2D (GL_TEXTURE_2D, 0, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); ! 890: goto done; ! 891: } ! 892: memcpy (scaled, data, width*height*4); ! 893: } ! 894: else ! 895: GL_ResampleTexture (data, width, height, scaled, scaled_width, scaled_height); ! 896: ! 897: texels += scaled_width * scaled_height; ! 898: glTexImage2D (GL_TEXTURE_2D, 0, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled); ! 899: if (mipmap) ! 900: { ! 901: int miplevel; ! 902: ! 903: miplevel = 0; ! 904: while (scaled_width > 1 || scaled_height > 1) ! 905: { ! 906: GL_MipMap ((byte *)scaled, scaled_width, scaled_height); ! 907: scaled_width >>= 1; ! 908: scaled_height >>= 1; ! 909: if (scaled_width < 1) ! 910: scaled_width = 1; ! 911: if (scaled_height < 1) ! 912: scaled_height = 1; ! 913: miplevel++; ! 914: texels += scaled_width * scaled_height; ! 915: glTexImage2D (GL_TEXTURE_2D, miplevel, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled); ! 916: } ! 917: } ! 918: done: ; ! 919: #endif ! 920: ! 921: ! 922: if (mipmap) ! 923: { ! 924: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); ! 925: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); ! 926: } ! 927: else ! 928: { ! 929: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); ! 930: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); ! 931: } ! 932: } ! 933: ! 934: /* ! 935: =============== ! 936: GL_Upload8 ! 937: =============== ! 938: */ ! 939: void GL_Upload8 (byte *data, int width, int height, qboolean mipmap, qboolean alpha) ! 940: { ! 941: static unsigned trans[640*480]; // FIXME, temporary ! 942: int i, s; ! 943: qboolean noalpha; ! 944: int p; ! 945: ! 946: s = width*height; ! 947: // if there are no transparent pixels, make it a 3 component ! 948: // texture even if it was specified as otherwise ! 949: if (alpha) ! 950: { ! 951: noalpha = true; ! 952: for (i=0 ; i<s ; i++) ! 953: { ! 954: p = data[i]; ! 955: if (p == 255) ! 956: noalpha = false; ! 957: trans[i] = d_8to24table[p]; ! 958: } ! 959: ! 960: if (alpha && noalpha) ! 961: alpha = false; ! 962: } ! 963: else ! 964: { ! 965: if (s&3) ! 966: Sys_Error ("GL_Upload8: s&3"); ! 967: for (i=0 ; i<s ; i+=4) ! 968: { ! 969: trans[i] = d_8to24table[data[i]]; ! 970: trans[i+1] = d_8to24table[data[i+1]]; ! 971: trans[i+2] = d_8to24table[data[i+2]]; ! 972: trans[i+3] = d_8to24table[data[i+3]]; ! 973: } ! 974: } ! 975: ! 976: GL_Upload32 (trans, width, height, mipmap, alpha); ! 977: } ! 978: ! 979: /* ! 980: ================ ! 981: GL_LoadTexture ! 982: ================ ! 983: */ ! 984: int GL_LoadTexture (char *identifier, int width, int height, byte *data, qboolean mipmap, qboolean alpha) ! 985: { ! 986: qboolean noalpha; ! 987: int i, p, s; ! 988: gltexture_t *glt; ! 989: ! 990: // see if the texture is allready present ! 991: if (identifier[0]) ! 992: { ! 993: for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++) ! 994: { ! 995: if (!strcmp (identifier, glt->identifier)) ! 996: { ! 997: if (width != glt->width || height != glt->height) ! 998: Sys_Error ("GL_LoadTexture: cache mismatch"); ! 999: return gltextures[i].texnum; ! 1000: } ! 1001: } ! 1002: } ! 1003: else ! 1004: glt = &gltextures[numgltextures]; ! 1005: numgltextures++; ! 1006: ! 1007: strcpy (glt->identifier, identifier); ! 1008: glt->texnum = texture_extension_number; ! 1009: glt->width = width; ! 1010: glt->height = height; ! 1011: glt->mipmap = mipmap; ! 1012: ! 1013: GL_Bind(texture_extension_number ); ! 1014: ! 1015: GL_Upload8 (data, width, height, mipmap, alpha); ! 1016: ! 1017: texture_extension_number++; ! 1018: ! 1019: return texture_extension_number-1; ! 1020: } ! 1021: ! 1022: /* ! 1023: ================ ! 1024: GL_LoadPicTexture ! 1025: ================ ! 1026: */ ! 1027: int GL_LoadPicTexture (qpic_t *pic) ! 1028: { ! 1029: return GL_LoadTexture ("", pic->width, pic->height, pic->data, false, true); ! 1030: } ! 1031:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.