![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to draw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quakeworld / client|
Return to draw.c CVS log | Up to [Quake] / quakeworld / client |
1.1 root 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:
21: // draw.c -- this is the only file outside the refresh that touches the
22: // vid buffer
23:
24: #include "quakedef.h"
25:
26: typedef struct {
27: vrect_t rect;
28: int width;
29: int height;
30: byte *ptexbytes;
31: int rowbytes;
32: } rectdesc_t;
33:
34: static rectdesc_t r_rectdesc;
35:
36: byte *draw_chars; // 8*8 graphic characters
37: qpic_t *draw_disc;
38: qpic_t *draw_backtile;
39:
40: //=============================================================================
41: /* Support Routines */
42:
43: typedef struct cachepic_s
44: {
45: char name[MAX_QPATH];
46: cache_user_t cache;
47: } cachepic_t;
48:
49: #define MAX_CACHED_PICS 128
50: cachepic_t menu_cachepics[MAX_CACHED_PICS];
51: int menu_numcachepics;
52:
53:
54: qpic_t *Draw_PicFromWad (char *name)
55: {
56: return W_GetLumpName (name);
57: }
58:
59: /*
60: ================
61: Draw_CachePic
62: ================
63: */
64: qpic_t *Draw_CachePic (char *path)
65: {
66: cachepic_t *pic;
67: int i;
68: qpic_t *dat;
69:
70: for (pic=menu_cachepics, i=0 ; i<menu_numcachepics ; pic++, i++)
71: if (!strcmp (path, pic->name))
72: break;
73:
74: if (i == menu_numcachepics)
75: {
76: if (menu_numcachepics == MAX_CACHED_PICS)
77: Sys_Error ("menu_numcachepics == MAX_CACHED_PICS");
78: menu_numcachepics++;
79: strcpy (pic->name, path);
80: }
81:
82: dat = Cache_Check (&pic->cache);
83:
84: if (dat)
85: return dat;
86:
87: //
88: // load the pic from disk
89: //
90: COM_LoadCacheFile (path, &pic->cache);
91:
92: dat = (qpic_t *)pic->cache.data;
93: if (!dat)
94: {
95: Sys_Error ("Draw_CachePic: failed to load %s", path);
96: }
97:
98: SwapPic (dat);
99:
100: return dat;
101: }
102:
103:
104:
105: /*
106: ===============
107: Draw_Init
108: ===============
109: */
110: void Draw_Init (void)
111: {
112: draw_chars = W_GetLumpName ("conchars");
113: draw_disc = W_GetLumpName ("disc");
114: draw_backtile = W_GetLumpName ("backtile");
115:
116: r_rectdesc.width = draw_backtile->width;
117: r_rectdesc.height = draw_backtile->height;
118: r_rectdesc.ptexbytes = draw_backtile->data;
119: r_rectdesc.rowbytes = draw_backtile->width;
120: }
121:
122:
123:
124: /*
125: ================
126: Draw_Character
127:
128: Draws one 8*8 graphics character with 0 being transparent.
129: It can be clipped to the top of the screen to allow the console to be
130: smoothly scrolled off.
131: ================
132: */
133: void Draw_Character (int x, int y, int num)
134: {
135: byte *dest;
136: byte *source;
137: unsigned short *pusdest;
138: int drawline;
139: int row, col;
140:
141: num &= 255;
142:
143: if (y <= -8)
144: return; // totally off screen
145:
146: if (y > vid.height - 8 || x < 0 || x > vid.width - 8)
147: return;
148: if (num < 0 || num > 255)
149: return;
150:
151: row = num>>4;
152: col = num&15;
153: source = draw_chars + (row<<10) + (col<<3);
154:
155: if (y < 0)
156: { // clipped
157: drawline = 8 + y;
158: source -= 128*y;
159: y = 0;
160: }
161: else
162: drawline = 8;
163:
164:
165: if (r_pixbytes == 1)
166: {
167: dest = vid.conbuffer + y*vid.conrowbytes + x;
168:
169: while (drawline--)
170: {
171: if (source[0])
172: dest[0] = source[0];
173: if (source[1])
174: dest[1] = source[1];
175: if (source[2])
176: dest[2] = source[2];
177: if (source[3])
178: dest[3] = source[3];
179: if (source[4])
180: dest[4] = source[4];
181: if (source[5])
182: dest[5] = source[5];
183: if (source[6])
184: dest[6] = source[6];
185: if (source[7])
186: dest[7] = source[7];
187: source += 128;
188: dest += vid.conrowbytes;
189: }
190: }
191: else
192: {
193: // FIXME: pre-expand to native format?
194: pusdest = (unsigned short *)
195: ((byte *)vid.conbuffer + y*vid.conrowbytes + (x<<1));
196:
197: while (drawline--)
198: {
199: if (source[0])
200: pusdest[0] = d_8to16table[source[0]];
201: if (source[1])
202: pusdest[1] = d_8to16table[source[1]];
203: if (source[2])
204: pusdest[2] = d_8to16table[source[2]];
205: if (source[3])
206: pusdest[3] = d_8to16table[source[3]];
207: if (source[4])
208: pusdest[4] = d_8to16table[source[4]];
209: if (source[5])
210: pusdest[5] = d_8to16table[source[5]];
211: if (source[6])
212: pusdest[6] = d_8to16table[source[6]];
213: if (source[7])
214: pusdest[7] = d_8to16table[source[7]];
215:
216: source += 128;
217: pusdest += (vid.conrowbytes >> 1);
218: }
219: }
220: }
221:
222: /*
223: ================
224: Draw_String
225: ================
226: */
227: void Draw_String (int x, int y, char *str)
228: {
229: while (*str)
230: {
231: Draw_Character (x, y, *str);
232: str++;
233: x += 8;
234: }
235: }
236:
237: /*
238: ================
239: Draw_Alt_String
240: ================
241: */
242: void Draw_Alt_String (int x, int y, char *str)
243: {
244: while (*str)
245: {
246: Draw_Character (x, y, (*str) | 0x80);
247: str++;
248: x += 8;
249: }
250: }
251:
252: void Draw_Pixel(int x, int y, byte color)
253: {
254: byte *dest;
255: unsigned short *pusdest;
256:
257: if (r_pixbytes == 1)
258: {
259: dest = vid.conbuffer + y*vid.conrowbytes + x;
260: *dest = color;
261: }
262: else
263: {
264: // FIXME: pre-expand to native format?
265: pusdest = (unsigned short *)
266: ((byte *)vid.conbuffer + y*vid.conrowbytes + (x<<1));
267: *pusdest = d_8to16table[color];
268: }
269: }
270:
271: void Draw_Crosshair(void)
272: {
273: int x, y;
274: extern cvar_t crosshair, cl_crossx, cl_crossy, crosshaircolor;
275: extern vrect_t scr_vrect;
276: byte c = (byte)crosshaircolor.value;
277:
278: if (crosshair.value == 2) {
279: x = scr_vrect.x + scr_vrect.width/2 + cl_crossx.value;
280: y = scr_vrect.y + scr_vrect.height/2 + cl_crossy.value;
281: Draw_Pixel(x - 1, y, c);
282: Draw_Pixel(x - 3, y, c);
283: Draw_Pixel(x + 1, y, c);
284: Draw_Pixel(x + 3, y, c);
285: Draw_Pixel(x, y - 1, c);
286: Draw_Pixel(x, y - 3, c);
287: Draw_Pixel(x, y + 1, c);
288: Draw_Pixel(x, y + 3, c);
289: } else if (crosshair.value)
290: Draw_Character (
291: scr_vrect.x + scr_vrect.width/2-4 + cl_crossx.value,
292: scr_vrect.y + scr_vrect.height/2-4 + cl_crossy.value,
293: '+');
294: }
295:
296: /*
297: ================
298: Draw_DebugChar
299:
300: Draws a single character directly to the upper right corner of the screen.
301: This is for debugging lockups by drawing different chars in different parts
302: of the code.
303: ================
304: */
305: void Draw_DebugChar (char num)
306: {
307: byte *dest;
308: byte *source;
309: int drawline;
310: extern byte *draw_chars;
311: int row, col;
312:
313: if (!vid.direct)
314: return; // don't have direct FB access, so no debugchars...
315:
316: drawline = 8;
317:
318: row = num>>4;
319: col = num&15;
320: source = draw_chars + (row<<10) + (col<<3);
321:
322: dest = vid.direct + 312;
323:
324: while (drawline--)
325: {
326: dest[0] = source[0];
327: dest[1] = source[1];
328: dest[2] = source[2];
329: dest[3] = source[3];
330: dest[4] = source[4];
331: dest[5] = source[5];
332: dest[6] = source[6];
333: dest[7] = source[7];
334: source += 128;
335: dest += 320;
336: }
337: }
338:
339: /*
340: =============
341: Draw_Pic
342: =============
343: */
344: void Draw_Pic (int x, int y, qpic_t *pic)
345: {
346: byte *dest, *source;
347: unsigned short *pusdest;
348: int v, u;
349:
350: if ((x < 0) ||
351: (x + pic->width > vid.width) ||
352: (y < 0) ||
353: (y + pic->height > vid.height))
354: {
355: Sys_Error ("Draw_Pic: bad coordinates");
356: }
357:
358: source = pic->data;
359:
360: if (r_pixbytes == 1)
361: {
362: dest = vid.buffer + y * vid.rowbytes + x;
363:
364: for (v=0 ; v<pic->height ; v++)
365: {
366: Q_memcpy (dest, source, pic->width);
367: dest += vid.rowbytes;
368: source += pic->width;
369: }
370: }
371: else
372: {
373: // FIXME: pretranslate at load time?
374: pusdest = (unsigned short *)vid.buffer + y * (vid.rowbytes >> 1) + x;
375:
376: for (v=0 ; v<pic->height ; v++)
377: {
378: for (u=0 ; u<pic->width ; u++)
379: {
380: pusdest[u] = d_8to16table[source[u]];
381: }
382:
383: pusdest += vid.rowbytes >> 1;
384: source += pic->width;
385: }
386: }
387: }
388:
389:
390: /*
391: =============
392: Draw_SubPic
393: =============
394: */
395: void Draw_SubPic(int x, int y, qpic_t *pic, int srcx, int srcy, int width, int height)
396: {
397: byte *dest, *source;
398: unsigned short *pusdest;
399: int v, u;
400:
401: if ((x < 0) ||
402: (x + width > vid.width) ||
403: (y < 0) ||
404: (y + height > vid.height))
405: {
406: Sys_Error ("Draw_Pic: bad coordinates");
407: }
408:
409: source = pic->data + srcy * pic->width + srcx;
410:
411: if (r_pixbytes == 1)
412: {
413: dest = vid.buffer + y * vid.rowbytes + x;
414:
415: for (v=0 ; v<height ; v++)
416: {
417: Q_memcpy (dest, source, width);
418: dest += vid.rowbytes;
419: source += pic->width;
420: }
421: }
422: else
423: {
424: // FIXME: pretranslate at load time?
425: pusdest = (unsigned short *)vid.buffer + y * (vid.rowbytes >> 1) + x;
426:
427: for (v=0 ; v<height ; v++)
428: {
429: for (u=srcx ; u<(srcx+width) ; u++)
430: {
431: pusdest[u] = d_8to16table[source[u]];
432: }
433:
434: pusdest += vid.rowbytes >> 1;
435: source += pic->width;
436: }
437: }
438: }
439:
440:
441: /*
442: =============
443: Draw_TransPic
444: =============
445: */
446: void Draw_TransPic (int x, int y, qpic_t *pic)
447: {
448: byte *dest, *source, tbyte;
449: unsigned short *pusdest;
450: int v, u;
451:
452: if (x < 0 || (unsigned)(x + pic->width) > vid.width || y < 0 ||
453: (unsigned)(y + pic->height) > vid.height)
454: {
455: Sys_Error ("Draw_TransPic: bad coordinates");
456: }
457:
458: source = pic->data;
459:
460: if (r_pixbytes == 1)
461: {
462: dest = vid.buffer + y * vid.rowbytes + x;
463:
464: if (pic->width & 7)
465: { // general
466: for (v=0 ; v<pic->height ; v++)
467: {
468: for (u=0 ; u<pic->width ; u++)
469: if ( (tbyte=source[u]) != TRANSPARENT_COLOR)
470: dest[u] = tbyte;
471:
472: dest += vid.rowbytes;
473: source += pic->width;
474: }
475: }
476: else
477: { // unwound
478: for (v=0 ; v<pic->height ; v++)
479: {
480: for (u=0 ; u<pic->width ; u+=8)
481: {
482: if ( (tbyte=source[u]) != TRANSPARENT_COLOR)
483: dest[u] = tbyte;
484: if ( (tbyte=source[u+1]) != TRANSPARENT_COLOR)
485: dest[u+1] = tbyte;
486: if ( (tbyte=source[u+2]) != TRANSPARENT_COLOR)
487: dest[u+2] = tbyte;
488: if ( (tbyte=source[u+3]) != TRANSPARENT_COLOR)
489: dest[u+3] = tbyte;
490: if ( (tbyte=source[u+4]) != TRANSPARENT_COLOR)
491: dest[u+4] = tbyte;
492: if ( (tbyte=source[u+5]) != TRANSPARENT_COLOR)
493: dest[u+5] = tbyte;
494: if ( (tbyte=source[u+6]) != TRANSPARENT_COLOR)
495: dest[u+6] = tbyte;
496: if ( (tbyte=source[u+7]) != TRANSPARENT_COLOR)
497: dest[u+7] = tbyte;
498: }
499: dest += vid.rowbytes;
500: source += pic->width;
501: }
502: }
503: }
504: else
505: {
506: // FIXME: pretranslate at load time?
507: pusdest = (unsigned short *)vid.buffer + y * (vid.rowbytes >> 1) + x;
508:
509: for (v=0 ; v<pic->height ; v++)
510: {
511: for (u=0 ; u<pic->width ; u++)
512: {
513: tbyte = source[u];
514:
515: if (tbyte != TRANSPARENT_COLOR)
516: {
517: pusdest[u] = d_8to16table[tbyte];
518: }
519: }
520:
521: pusdest += vid.rowbytes >> 1;
522: source += pic->width;
523: }
524: }
525: }
526:
527:
528: /*
529: =============
530: Draw_TransPicTranslate
531: =============
532: */
533: void Draw_TransPicTranslate (int x, int y, qpic_t *pic, byte *translation)
534: {
535: byte *dest, *source, tbyte;
536: unsigned short *pusdest;
537: int v, u;
538:
539: if (x < 0 || (unsigned)(x + pic->width) > vid.width || y < 0 ||
540: (unsigned)(y + pic->height) > vid.height)
541: {
542: Sys_Error ("Draw_TransPic: bad coordinates");
543: }
544:
545: source = pic->data;
546:
547: if (r_pixbytes == 1)
548: {
549: dest = vid.buffer + y * vid.rowbytes + x;
550:
551: if (pic->width & 7)
552: { // general
553: for (v=0 ; v<pic->height ; v++)
554: {
555: for (u=0 ; u<pic->width ; u++)
556: if ( (tbyte=source[u]) != TRANSPARENT_COLOR)
557: dest[u] = translation[tbyte];
558:
559: dest += vid.rowbytes;
560: source += pic->width;
561: }
562: }
563: else
564: { // unwound
565: for (v=0 ; v<pic->height ; v++)
566: {
567: for (u=0 ; u<pic->width ; u+=8)
568: {
569: if ( (tbyte=source[u]) != TRANSPARENT_COLOR)
570: dest[u] = translation[tbyte];
571: if ( (tbyte=source[u+1]) != TRANSPARENT_COLOR)
572: dest[u+1] = translation[tbyte];
573: if ( (tbyte=source[u+2]) != TRANSPARENT_COLOR)
574: dest[u+2] = translation[tbyte];
575: if ( (tbyte=source[u+3]) != TRANSPARENT_COLOR)
576: dest[u+3] = translation[tbyte];
577: if ( (tbyte=source[u+4]) != TRANSPARENT_COLOR)
578: dest[u+4] = translation[tbyte];
579: if ( (tbyte=source[u+5]) != TRANSPARENT_COLOR)
580: dest[u+5] = translation[tbyte];
581: if ( (tbyte=source[u+6]) != TRANSPARENT_COLOR)
582: dest[u+6] = translation[tbyte];
583: if ( (tbyte=source[u+7]) != TRANSPARENT_COLOR)
584: dest[u+7] = translation[tbyte];
585: }
586: dest += vid.rowbytes;
587: source += pic->width;
588: }
589: }
590: }
591: else
592: {
593: // FIXME: pretranslate at load time?
594: pusdest = (unsigned short *)vid.buffer + y * (vid.rowbytes >> 1) + x;
595:
596: for (v=0 ; v<pic->height ; v++)
597: {
598: for (u=0 ; u<pic->width ; u++)
599: {
600: tbyte = source[u];
601:
602: if (tbyte != TRANSPARENT_COLOR)
603: {
604: pusdest[u] = d_8to16table[tbyte];
605: }
606: }
607:
608: pusdest += vid.rowbytes >> 1;
609: source += pic->width;
610: }
611: }
612: }
613:
614:
615: void Draw_CharToConback (int num, byte *dest)
616: {
617: int row, col;
618: byte *source;
619: int drawline;
620: int x;
621:
622: row = num>>4;
623: col = num&15;
624: source = draw_chars + (row<<10) + (col<<3);
625:
626: drawline = 8;
627:
628: while (drawline--)
629: {
630: for (x=0 ; x<8 ; x++)
631: if (source[x])
632: dest[x] = 0x60 + source[x];
633: source += 128;
634: dest += 320;
635: }
636:
637: }
638:
639: /*
640: ================
641: Draw_ConsoleBackground
642:
643: ================
644: */
645: void Draw_ConsoleBackground (int lines)
646: {
647: int x, y, v;
648: byte *src, *dest;
649: unsigned short *pusdest;
650: int f, fstep;
651: qpic_t *conback;
652: char ver[100];
653: static char saveback[320*8];
654:
655: conback = Draw_CachePic ("gfx/conback.lmp");
656:
657: // hack the version number directly into the pic
658:
659: //sprintf (ver, "start commands with a \\ character %4.2f", VERSION);
660:
661: if (cls.download) {
662: sprintf (ver, "%4.2f", VERSION);
663: dest = conback->data + 320 + 320*186 - 11 - 8*strlen(ver);
664: } else {
665: #if defined(__linux__)
666: sprintf (ver, "Linux (%4.2f) QuakeWorld %4.2f", LINUX_VERSION, VERSION);
667: #else
668: sprintf (ver, "QuakeWorld %4.2f", VERSION);
669: #endif
670: dest = conback->data + 320 - (strlen(ver)*8 + 11) + 320*186;
671: }
672:
673: memcpy(saveback, conback->data + 320*186, 320*8);
674: for (x=0 ; x<strlen(ver) ; x++)
675: Draw_CharToConback (ver[x], dest+(x<<3));
676:
677: // draw the pic
678: if (r_pixbytes == 1)
679: {
680: dest = vid.conbuffer;
681:
682: for (y=0 ; y<lines ; y++, dest += vid.conrowbytes)
683: {
684: v = (vid.conheight - lines + y)*200/vid.conheight;
685: src = conback->data + v*320;
686: if (vid.conwidth == 320)
687: memcpy (dest, src, vid.conwidth);
688: else
689: {
690: f = 0;
691: fstep = 320*0x10000/vid.conwidth;
692: for (x=0 ; x<vid.conwidth ; x+=4)
693: {
694: dest[x] = src[f>>16];
695: f += fstep;
696: dest[x+1] = src[f>>16];
697: f += fstep;
698: dest[x+2] = src[f>>16];
699: f += fstep;
700: dest[x+3] = src[f>>16];
701: f += fstep;
702: }
703: }
704: }
705: }
706: else
707: {
708: pusdest = (unsigned short *)vid.conbuffer;
709:
710: for (y=0 ; y<lines ; y++, pusdest += (vid.conrowbytes >> 1))
711: {
712: // FIXME: pre-expand to native format?
713: // FIXME: does the endian switching go away in production?
714: v = (vid.conheight - lines + y)*200/vid.conheight;
715: src = conback->data + v*320;
716: f = 0;
717: fstep = 320*0x10000/vid.conwidth;
718: for (x=0 ; x<vid.conwidth ; x+=4)
719: {
720: pusdest[x] = d_8to16table[src[f>>16]];
721: f += fstep;
722: pusdest[x+1] = d_8to16table[src[f>>16]];
723: f += fstep;
724: pusdest[x+2] = d_8to16table[src[f>>16]];
725: f += fstep;
726: pusdest[x+3] = d_8to16table[src[f>>16]];
727: f += fstep;
728: }
729: }
730: }
731: // put it back
732: memcpy(conback->data + 320*186, saveback, 320*8);
733: }
734:
735:
736: /*
737: ==============
738: R_DrawRect8
739: ==============
740: */
741: void R_DrawRect8 (vrect_t *prect, int rowbytes, byte *psrc,
742: int transparent)
743: {
744: byte t;
745: int i, j, srcdelta, destdelta;
746: byte *pdest;
747:
748: pdest = vid.buffer + (prect->y * vid.rowbytes) + prect->x;
749:
750: srcdelta = rowbytes - prect->width;
751: destdelta = vid.rowbytes - prect->width;
752:
753: if (transparent)
754: {
755: for (i=0 ; i<prect->height ; i++)
756: {
757: for (j=0 ; j<prect->width ; j++)
758: {
759: t = *psrc;
760: if (t != TRANSPARENT_COLOR)
761: {
762: *pdest = t;
763: }
764:
765: psrc++;
766: pdest++;
767: }
768:
769: psrc += srcdelta;
770: pdest += destdelta;
771: }
772: }
773: else
774: {
775: for (i=0 ; i<prect->height ; i++)
776: {
777: memcpy (pdest, psrc, prect->width);
778: psrc += rowbytes;
779: pdest += vid.rowbytes;
780: }
781: }
782: }
783:
784:
785: /*
786: ==============
787: R_DrawRect16
788: ==============
789: */
790: void R_DrawRect16 (vrect_t *prect, int rowbytes, byte *psrc,
791: int transparent)
792: {
793: byte t;
794: int i, j, srcdelta, destdelta;
795: unsigned short *pdest;
796:
797: // FIXME: would it be better to pre-expand native-format versions?
798:
799: pdest = (unsigned short *)vid.buffer +
800: (prect->y * (vid.rowbytes >> 1)) + prect->x;
801:
802: srcdelta = rowbytes - prect->width;
803: destdelta = (vid.rowbytes >> 1) - prect->width;
804:
805: if (transparent)
806: {
807: for (i=0 ; i<prect->height ; i++)
808: {
809: for (j=0 ; j<prect->width ; j++)
810: {
811: t = *psrc;
812: if (t != TRANSPARENT_COLOR)
813: {
814: *pdest = d_8to16table[t];
815: }
816:
817: psrc++;
818: pdest++;
819: }
820:
821: psrc += srcdelta;
822: pdest += destdelta;
823: }
824: }
825: else
826: {
827: for (i=0 ; i<prect->height ; i++)
828: {
829: for (j=0 ; j<prect->width ; j++)
830: {
831: *pdest = d_8to16table[*psrc];
832: psrc++;
833: pdest++;
834: }
835:
836: psrc += srcdelta;
837: pdest += destdelta;
838: }
839: }
840: }
841:
842:
843: /*
844: =============
845: Draw_TileClear
846:
847: This repeats a 64*64 tile graphic to fill the screen around a sized down
848: refresh window.
849: =============
850: */
851: void Draw_TileClear (int x, int y, int w, int h)
852: {
853: int width, height, tileoffsetx, tileoffsety;
854: byte *psrc;
855: vrect_t vr;
856:
857: r_rectdesc.rect.x = x;
858: r_rectdesc.rect.y = y;
859: r_rectdesc.rect.width = w;
860: r_rectdesc.rect.height = h;
861:
862: vr.y = r_rectdesc.rect.y;
863: height = r_rectdesc.rect.height;
864:
865: tileoffsety = vr.y % r_rectdesc.height;
866:
867: while (height > 0)
868: {
869: vr.x = r_rectdesc.rect.x;
870: width = r_rectdesc.rect.width;
871:
872: if (tileoffsety != 0)
873: vr.height = r_rectdesc.height - tileoffsety;
874: else
875: vr.height = r_rectdesc.height;
876:
877: if (vr.height > height)
878: vr.height = height;
879:
880: tileoffsetx = vr.x % r_rectdesc.width;
881:
882: while (width > 0)
883: {
884: if (tileoffsetx != 0)
885: vr.width = r_rectdesc.width - tileoffsetx;
886: else
887: vr.width = r_rectdesc.width;
888:
889: if (vr.width > width)
890: vr.width = width;
891:
892: psrc = r_rectdesc.ptexbytes +
893: (tileoffsety * r_rectdesc.rowbytes) + tileoffsetx;
894:
895: if (r_pixbytes == 1)
896: {
897: R_DrawRect8 (&vr, r_rectdesc.rowbytes, psrc, 0);
898: }
899: else
900: {
901: R_DrawRect16 (&vr, r_rectdesc.rowbytes, psrc, 0);
902: }
903:
904: vr.x += vr.width;
905: width -= vr.width;
906: tileoffsetx = 0; // only the left tile can be left-clipped
907: }
908:
909: vr.y += vr.height;
910: height -= vr.height;
911: tileoffsety = 0; // only the top tile can be top-clipped
912: }
913: }
914:
915:
916: /*
917: =============
918: Draw_Fill
919:
920: Fills a box of pixels with a single color
921: =============
922: */
923: void Draw_Fill (int x, int y, int w, int h, int c)
924: {
925: byte *dest;
926: unsigned short *pusdest;
927: unsigned uc;
928: int u, v;
929:
930: if (x < 0 || x + w > vid.width ||
931: y < 0 || y + h > vid.height) {
932: Con_Printf("Bad Draw_Fill(%d, %d, %d, %d, %c)\n",
933: x, y, w, h, c);
934: return;
935: }
936:
937: if (r_pixbytes == 1)
938: {
939: dest = vid.buffer + y*vid.rowbytes + x;
940: for (v=0 ; v<h ; v++, dest += vid.rowbytes)
941: for (u=0 ; u<w ; u++)
942: dest[u] = c;
943: }
944: else
945: {
946: uc = d_8to16table[c];
947:
948: pusdest = (unsigned short *)vid.buffer + y * (vid.rowbytes >> 1) + x;
949: for (v=0 ; v<h ; v++, pusdest += (vid.rowbytes >> 1))
950: for (u=0 ; u<w ; u++)
951: pusdest[u] = uc;
952: }
953: }
954: //=============================================================================
955:
956: /*
957: ================
958: Draw_FadeScreen
959:
960: ================
961: */
962: void Draw_FadeScreen (void)
963: {
964: int x,y;
965: byte *pbuf;
966:
967: VID_UnlockBuffer ();
968: S_ExtraUpdate ();
969: VID_LockBuffer ();
970:
971: for (y=0 ; y<vid.height ; y++)
972: {
973: int t;
974:
975: pbuf = (byte *)(vid.buffer + vid.rowbytes*y);
976: t = (y & 1) << 1;
977:
978: for (x=0 ; x<vid.width ; x++)
979: {
980: if ((x & 3) != t)
981: pbuf[x] = 0;
982: }
983: }
984:
985: VID_UnlockBuffer ();
986: S_ExtraUpdate ();
987: VID_LockBuffer ();
988: }
989:
990: //=============================================================================
991:
992: /*
993: ================
994: Draw_BeginDisc
995:
996: Draws the little blue disc in the corner of the screen.
997: Call before beginning any disc IO.
998: ================
999: */
1000: void Draw_BeginDisc (void)
1001: {
1002:
1003: D_BeginDirectRect (vid.width - 24, 0, draw_disc->data, 24, 24);
1004: }
1005:
1006:
1007: /*
1008: ================
1009: Draw_EndDisc
1010:
1011: Erases the disc icon.
1012: Call after completing any disc IO
1013: ================
1014: */
1015: void Draw_EndDisc (void)
1016: {
1017:
1018: D_EndDirectRect (vid.width - 24, 0, 24, 24);
1019: }
1020:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.