![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vid_next.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to vid_next.m CVS log | Up to [Quake] / quake1 |
1.1 root 1: // vid_next.m -- NEXTSTEP video driver
2:
3: #define INTERCEPTOR
4:
5: #import <appkit/appkit.h>
6: #import <string.h>
7: #import "intercep.h"
8: #include "quakedef.h"
9: #include "d_local.h"
10:
11: int BASEWIDTH = 320;
12: int BASEHEIGHT = 200;
13:
14: void SetupBitmap (void);
15: void SetupFramebuffer (void);
16: void UpdateBitmap (void);
17: void UpdateFramebuffer (vrect_t *vrect);
18: void SetVideoEncoding (char *encoding);
19: void Update8_1 (pixel_t *src, byte *dest, int width,
20: int height, int destrowbytes);
21: void Update16_1 (pixel_t *src, unsigned short *dest, int width,
22: int height, int destrowbytes);
23: void Update32_1 (pixel_t *src, unsigned *dest, int width,
24: int height, int destrowbytes);
25:
26: void (*vid_menudrawfn)(void);
27: void (*vid_menukeyfn)(int key);
28:
29: @interface QuakeView : View
30: @end
31:
32: @interface FrameWindow:Window
33: @end
34:
35: unsigned short d_8to16table[256]; // not used in 8 bpp mode
36: unsigned d_8to24table[256]; // not used in 8 bpp mode
37:
38:
39: /*
40: ==========================================================================
41:
42: API FUNCTIONS
43:
44: ==========================================================================
45: */
46:
47: typedef enum {disp_bitmap, disp_framebuffer} display_t;
48:
49: pixel_t *vid_buffer;
50: pixel_t *buffernative;
51: unsigned pcolormap[4][256]; // map from quake pixels to native pixels
52: unsigned pixbytesnative;
53: unsigned rowbytesnative;
54: int dither;
55:
56: int drawdirect = 0;
57:
58: int d_con_indirect = 0;
59:
60: display_t vid_display;
61:
62: byte vid_palette[768]; // saved for restarting vid system
63:
64: id vid_window_i;
65: id vid_view_i;
66: #ifdef INTERCEPTOR
67: NXDirectBitmap *vid_dbitmap_i;
68: NXFramebuffer *vid_framebuffer_i;
69: #endif
70:
71: NXRect screenBounds; // only valid in framebuffer mode
72:
73: int vid_scale;
74:
75: char *vid_encodingstring;
76:
77: int vid_fullscreen;
78: int vid_screen;
79:
80: int vid_high_hunk_mark;
81:
82: typedef enum
83: {
84: enc_24_rgba,
85: enc_24_0rgb,
86: enc_24_rgb0,
87: enc_12_rgba,
88: enc_12_rgb0,
89: enc_15_0rgb,
90: enc_564,
91: enc_8_gray,
92: enc_8_rgb
93: } vid_encoding_t;
94:
95: typedef struct
96: {
97: char *string;
98: int pixelbytes;
99: void (*colormap) (void);
100: vid_encoding_t name;
101: } vidtype_t;
102:
103: vid_encoding_t vid_encoding;
104:
105: void Table8 (void);
106: void Table15 (void);
107: void Table12 (void);
108: void Table12Swap (void);
109: void Table24 (void);
110: void Table24Swap (void);
111:
112: vidtype_t vid_encodingtable[]=
113: {
114: {"RRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA",4, Table24Swap, enc_24_rgba},
115: {"--------RRRRRRRRGGGGGGGGBBBBBBBB",4, Table24, enc_24_0rgb},
116: {"RRRRRRRRGGGGGGGGBBBBBBBB--------",4, Table24Swap, enc_24_rgb0},
117: {"RRRRGGGGBBBBAAAA",2, Table12Swap, enc_12_rgba},
118: {"RRRRGGGGBBBB----",2, Table12, enc_12_rgb0},
119: {"-RRRRRGGGGGBBBBB",2, Table15, enc_15_0rgb},
120: {"WWWWWWWW",1, Table8, enc_8_gray},
121: {"PPPPPPPP",1, Table8, enc_8_rgb},
122: {NULL,0, 0, 0}
123: };
124:
125: vidtype_t *vid_type;
126: void InitNS8Bit (void);
127:
128: /*
129: ================
130: D_BeginDirectRect
131: ================
132: */
133: void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
134: {
135: // direct drawing of the "accessing disk" icon isn't supported under Nextstep
136: }
137:
138:
139: /*
140: ================
141: D_EndDirectRect
142: ================
143: */
144: void D_EndDirectRect (int x, int y, int width, int height)
145: {
146: // direct drawing of the "accessing disk" icon isn't supported under Nextstep
147: }
148:
149:
150: /*
151: ==============
152: VID_Restart
153:
154: internal call only
155: ===============
156: */
157: void VID_Restart (display_t mode, int scale)
158: {
159: vid_display = mode;
160: vid_scale = scale;
161:
162: [NXApp activateSelf:YES];
163:
164: if (vid_display == disp_framebuffer)
165: SetupFramebuffer ();
166: else
167: SetupBitmap ();
168:
169: vid.recalc_refdef = 1;
170: }
171:
172:
173: /*
174: =================
175: VID_Scale_f
176:
177: Keybinding command
178: =================
179: */
180: void VID_Scale_f (void)
181: {
182: int scale;
183:
184: if (Cmd_Argc () != 2)
185: return;
186:
187: scale = atoi (Cmd_Argv(1));
188: if (scale != 1 && scale != 2)
189: {
190: Con_Printf ("scale must be 1 or 2\n");
191: return;
192: }
193: VID_Shutdown ();
194: VID_Restart (vid_display, scale);
195: }
196:
197: /*
198: =================
199: VID_Mode_f
200:
201: Keybinding command
202: =================
203: */
204: void VID_Mode_f (void)
205: {
206: int mode;
207:
208: if (Cmd_Argc () != 2)
209: return;
210:
211: mode = atoi (Cmd_Argv(1));
212:
213: VID_Shutdown ();
214: if (mode == 0)
215: {
216: drawdirect = 0;
217: VID_Restart (disp_bitmap, vid_scale);
218: }
219: else if (mode == 1)
220: {
221: drawdirect = 0;
222: VID_Restart (disp_framebuffer, vid_scale);
223: }
224: else
225: {
226: drawdirect = 1;
227: VID_Restart (disp_framebuffer, vid_scale);
228: }
229: }
230:
231: /*
232: =================
233: VID_Size_f
234:
235: Keybinding command
236: =================
237: */
238: void VID_Size_f (void)
239: {
240: if (Cmd_Argc () != 3)
241: return;
242:
243: VID_Shutdown ();
244:
245: BASEWIDTH = atoi (Cmd_Argv(1));
246: BASEHEIGHT = atoi (Cmd_Argv(2));
247:
248: VID_Restart (vid_display, vid_scale);
249: }
250:
251: /*
252: ================
253: VID_Init
254: ================
255: */
256: void VID_Init (unsigned char *palette)
257: {
258: InitNS8Bit (); // fixed palette lookups
259:
260: Q_memcpy (vid_palette, palette, sizeof(vid_palette));
261:
262: if (COM_CheckParm ("-bitmap"))
263: vid_display = disp_bitmap;
264: else
265: vid_display = disp_framebuffer;
266:
267: if (COM_CheckParm ("-screen2"))
268: vid_screen = 1;
269: else
270: vid_screen = 0;
271:
272: if (COM_CheckParm ("-direct"))
273: drawdirect = 1;
274:
275: Cmd_AddCommand ("vid_scale", VID_Scale_f);
276: Cmd_AddCommand ("vid_mode", VID_Mode_f);
277: Cmd_AddCommand ("vid_size", VID_Size_f);
278:
279: vid.width = BASEWIDTH;
280: vid.height = BASEHEIGHT;
281: vid.aspect = 1.0;
282: vid.numpages = 1;
283: vid.colormap = host_colormap;
284: vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
285: vid.maxwarpwidth = WARP_WIDTH;
286: vid.maxwarpheight = WARP_HEIGHT;
287:
288: if (COM_CheckParm ("-scale2"))
289: vid_scale = 2;
290: else
291: vid_scale = 1;
292:
293: [Application new];
294:
295: VID_Restart (vid_display, vid_scale);
296: }
297:
298:
299: /*
300: ================
301: VID_Shutdown
302: ================
303: */
304: void VID_Shutdown (void)
305: {
306: #ifdef INTERCEPTOR
307: if (vid_dbitmap_i)
308: {
309: [vid_dbitmap_i free];
310: vid_dbitmap_i = 0;
311: }
312: if (vid_framebuffer_i)
313: {
314: [vid_framebuffer_i free];
315: vid_framebuffer_i = 0;
316: }
317: #endif
318: [vid_window_i close];
319: [vid_window_i free];
320: }
321:
322:
323: /*
324: ================
325: VID_Update
326: ================
327: */
328: void VID_Update (vrect_t *rects)
329: {
330: if (drawdirect)
331: return;
332:
333: while (rects)
334: {
335: UpdateFramebuffer (rects);
336: rects = rects->pnext;
337: }
338:
339: if (vid_display == disp_bitmap)
340: UpdateBitmap ();
341: }
342:
343:
344: /*
345: ================
346: VID_SetPalette
347: ================
348: */
349: void VID_SetPalette (unsigned char *palette)
350: {
351: Q_memcpy (vid_palette, palette, sizeof(vid_palette));
352: vid_type->colormap ();
353: }
354:
355:
356: /*
357: ================
358: VID_ShiftPalette
359: ================
360: */
361: void VID_ShiftPalette (unsigned char *palette)
362: {
363:
364: VID_SetPalette (palette);
365: }
366:
367:
368: /*
369: ==========================================================================
370:
371: NS STUFF
372:
373: ==========================================================================
374: */
375:
376:
377: /*
378: =================
379: SetVideoEncoding
380: =================
381: */
382: void SetVideoEncoding (char *encoding)
383: {
384: vidtype_t *type;
385:
386: Sys_Printf ("SetVideoEncoding: %s\n",encoding);
387: vid_encodingstring = encoding;
388:
389: for (type = vid_encodingtable ; type->string ; type++)
390: {
391: if (strcmp(type->string, encoding) == 0)
392: {
393: pixbytesnative = type->pixelbytes;
394: vid_encoding = type->name;
395: type->colormap ();
396: vid_type = type;
397: return;
398: }
399: }
400:
401: Sys_Error ("Unsupported video encoding: %s\n",encoding);
402: }
403:
404: /*
405: =================
406: AllocBuffers
407: =================
408: */
409: void AllocBuffers (qboolean withnative)
410: {
411: int surfcachesize;
412: void *surfcache;
413: int pixels;
414: int pixbytes;
415: int vid_buffersize;
416:
417: if (vid_buffer)
418: {
419: D_FlushCaches ();
420: Hunk_FreeToHighMark (vid_high_hunk_mark);
421: vid_high_hunk_mark = 0;
422: vid_buffer = NULL;
423: }
424:
425: pixels = vid.width * vid.height;
426:
427: pixbytes = 1 +sizeof (*d_pzbuffer);
428: if (withnative)
429: pixbytes += pixbytesnative;
430:
431: surfcachesize = D_SurfaceCacheForRes (vid.width, vid.height);
432: vid_buffersize = pixels * pixbytes + surfcachesize;
433:
434: vid_high_hunk_mark = Hunk_HighMark ();
435: vid_buffer = Hunk_HighAllocName (vid_buffersize, "video");
436: if (!vid_buffer)
437: Sys_Error ("Couldn't alloc video buffers");
438:
439: vid.buffer = vid_buffer;
440:
441: d_pzbuffer = (unsigned short *)((byte *)vid_buffer + pixels);
442: surfcache = (byte *)d_pzbuffer + pixels * sizeof (*d_pzbuffer);
443: if (withnative)
444: buffernative = (byte *)surfcache + surfcachesize;
445:
446: D_InitCaches (surfcache, surfcachesize);
447: }
448:
449: /*
450: =================
451: SetupFramebuffer
452: =================
453: */
454: void SetupFramebuffer (void)
455: {
456: #ifdef INTERCEPTOR
457: int windowNum;
458: NXRect cont;
459: NXScreen const *screens;
460: int screencount;
461:
462: //
463: // get the screen list
464: //
465: [NXApp getScreens:&screens count:&screencount];
466:
467: //
468: // create vid_framebuffer_i
469: //
470: vid_framebuffer_i = [[NXFramebuffer alloc]
471: initFromScreen:screens[vid_screen].screenNumber andMapIfPossible:YES];
472: [vid_framebuffer_i screenBounds:&screenBounds];
473:
474: SetVideoEncoding ([vid_framebuffer_i pixelEncoding]);
475:
476: buffernative = [vid_framebuffer_i data];
477: rowbytesnative = [vid_framebuffer_i bytesPerRow];
478:
479: //
480: // create window
481: //
482: if (vid_fullscreen)
483: {
484: vid.height = screenBounds.size.height / vid_scale;
485: vid.width = screenBounds.size.width / vid_scale;
486: cont.origin.x = 0;
487: cont.origin.y = 0;
488: cont.size.width = screenBounds.size.width;
489: cont.size.height = screenBounds.size.height;
490: }
491: else
492: {
493: buffernative = (unsigned char *)buffernative + 8 * rowbytesnative +
494: 8 * pixbytesnative;
495: vid.width = BASEWIDTH;
496: vid.height = BASEHEIGHT;
497: cont.origin.x = 8;
498: cont.origin.y = screenBounds.size.height - (vid.height*vid_scale) - 8;
499: cont.size.width = vid.width * vid_scale;
500: cont.size.height = vid.height * vid_scale;
501: }
502:
503: vid_window_i = [[FrameWindow alloc]
504: initContent: &cont
505: style: NX_PLAINSTYLE
506: backing: NX_NONRETAINED
507: buttonMask: 0
508: defer: NO
509: screen: screens+vid_screen];
510: windowNum = [vid_window_i windowNum];
511: PSsetwindowlevel(40, windowNum);
512: PSsetautofill(YES, windowNum);
513: PSgsave();
514: PSwindowdeviceround(windowNum);
515: PSsetgray(NX_BLACK);
516: PSsetexposurecolor();
517: PSgrestore();
518:
519: //
520: // create view
521: //
522: vid_view_i = [[QuakeView alloc] initFrame: &screenBounds];
523: [[vid_window_i setContentView: vid_view_i] free];
524: [vid_window_i makeFirstResponder: vid_view_i];
525: [vid_window_i setDelegate: vid_view_i];
526: [vid_window_i display];
527: [vid_window_i makeKeyAndOrderFront: nil];
528: NXPing ();
529:
530: AllocBuffers (false); // no native buffer
531:
532: if (drawdirect)
533: { // the direct drawing mode to NeXT colorspace
534: vid.buffer = buffernative;
535: vid.rowbytes = rowbytesnative;
536: }
537: else
538: vid.rowbytes = vid.width;
539:
540: vid.conbuffer = vid.buffer;
541: vid.conrowbytes = vid.rowbytes;
542: vid.conwidth = vid.width;
543: vid.conheight = vid.height;
544: #endif
545: }
546:
547: /*
548: =================
549: SetupBitmap
550: =================
551: */
552: void SetupBitmap (void)
553: {
554: int depth;
555: NXRect content;
556:
557: //
558: // open a window
559: //
560: NXSetRect (&content, 8,136, vid.width*vid_scale, vid.height*vid_scale);
561: vid_window_i = [[Window alloc]
562: initContent: &content
563: style: NX_RESIZEBARSTYLE
564: backing: NX_RETAINED
565: buttonMask: 0
566: defer: NO
567: ];
568: [vid_window_i display];
569: [vid_window_i makeKeyAndOrderFront: nil];
570:
571: NXPing ();
572:
573: content.origin.x = content.origin.y = 0;
574: vid_view_i = [[QuakeView alloc] initFrame: &content];
575: [[vid_window_i setContentView: vid_view_i] free];
576: [vid_window_i makeFirstResponder: vid_view_i];
577: [vid_window_i setDelegate: vid_view_i];
578:
579: [vid_window_i addToEventMask: NX_FLAGSCHANGEDMASK];
580:
581: //
582: // find video info
583: //
584: depth = [Window defaultDepthLimit];
585: switch (depth) {
586: case NX_EightBitGrayDepth:
587: SetVideoEncoding ("WWWWWWWW");
588: break;
589: case NX_TwelveBitRGBDepth:
590: SetVideoEncoding ("RRRRGGGGBBBBAAAA");
591: break;
592: default:
593: case NX_TwentyFourBitRGBDepth:
594: SetVideoEncoding ("RRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA");
595: break;
596: // default: // 8 bit color shows up as an unknown...
597: Sys_Error ("Unsupported window depth");
598: }
599:
600: [vid_window_i setTitle: "Bitmap Quake Console"];
601:
602: //
603: // allocate memory for the back and translation buffers
604: //
605: vid.rowbytes = vid.width;
606: rowbytesnative = vid.width * pixbytesnative;
607:
608: AllocBuffers (true);
609:
610: vid.conbuffer = vid.buffer;
611: vid.conrowbytes = vid.rowbytes;
612: vid.conwidth = vid.width;
613: vid.conheight = vid.height;
614: }
615:
616:
617: /*
618: =================
619: UpdateFramebuffer
620: =================
621: */
622: void UpdateFramebuffer (vrect_t *vrect)
623: {
624: byte *psourcebase;
625: byte *pdestbase;
626: int scale;
627:
628: psourcebase = vid.buffer + vrect->x + vrect->y * vid.rowbytes;
629:
630: if (vid_display == disp_bitmap)
631: scale = 1; // let NS do the scaling
632: else
633: scale = vid_scale;
634:
635: pdestbase = buffernative + scale *
636: (vrect->x * pixbytesnative + vrect->y * rowbytesnative);
637:
638: //
639: // translate from ideal to native (except 8 bpp direct) and copy to screen
640: //
641:
642: if (pixbytesnative == 1)
643: Update8_1 (psourcebase, pdestbase, vrect->width, vrect->height,
644: rowbytesnative);
645: else if (pixbytesnative == 2)
646: Update16_1 (psourcebase, (unsigned short *)pdestbase, vrect->width, vrect->height,
647: rowbytesnative);
648: else
649: Update32_1 (psourcebase, (unsigned *)pdestbase, vrect->width, vrect->height,
650: rowbytesnative);
651: }
652:
653:
654: /*
655: =================
656: UpdateBitmap
657: =================
658: */
659: void UpdateBitmap (void)
660: {
661: unsigned char *planes[5];
662: NXRect bounds;
663: int bpp, spp, bps, bpr, colorspace;
664:
665: //
666: // flush the screen with an image call
667: //
668: if (pixbytesnative == 1)
669: {
670: bps = 8;
671: spp = 1;
672: bpp = 8;
673: bpr = vid.width;
674: colorspace = NX_OneIsWhiteColorSpace;
675: planes[0] = vid.buffer;
676: }
677: else if (pixbytesnative == 2)
678: {
679: bps = 4;
680: spp = 3;
681: bpp = 16;
682: bpr = vid.width * 2;
683: colorspace = NX_RGBColorSpace;
684: planes[0] = buffernative;
685: }
686: else
687: {
688: bps = 8;
689: spp = 3;
690: bpp = 32;
691: bpr = vid.width * 4;
692: colorspace = NX_RGBColorSpace;
693: planes[0] = buffernative;
694: }
695:
696: [vid_view_i getBounds: &bounds];
697: [vid_view_i lockFocus];
698:
699: NXDrawBitmap(
700: &bounds,
701: vid.width,
702: vid.height,
703: bps,
704: spp,
705: bpp,
706: bpr,
707: NO,
708: NO,
709: colorspace,
710: planes
711: );
712:
713: [vid_view_i unlockFocus];
714: NXPing ();
715: }
716:
717:
718:
719: /*
720: ==========================================================================
721:
722: TRANSLATION TABLE BUILDING
723:
724: ==========================================================================
725: */
726:
727: int redramp[] = {0, 19, 59, 113, 178, 255, 300};
728: int greenramp[] = {0, 11, 34, 66, 104, 149, 199, 255, 300};
729: int blueramp[] = {0, 28, 84, 161, 255, 300};
730: int greyramp[] = { 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204,
731: 221, 238, 255, 300};
732:
733: byte greytable[256];
734: byte redtable[256];
735: byte greentable[256];
736: byte bluetable[256];
737:
738: void FillTable (byte *table, int *ramp, int base)
739: {
740: int i, j, o;
741:
742: o = 0;
743: for (i=0 ; i<16 && o < 256; i++)
744: {
745: j = ramp[i];
746: for ( ; o<=j ; o++)
747: table[o] = base + i;
748: }
749: }
750:
751: void InitNS8Bit (void)
752: {
753: FillTable (greytable, greyramp, 240);
754: FillTable (redtable, redramp, 0);
755: FillTable (greentable, greenramp, 0);
756: FillTable (bluetable, blueramp, 0);
757: }
758:
759:
760: byte ns8trans[256] = // FIXME: dynamically calc this so palettes work
761: {
762: 0,241,242,243,244,244,245,246,247,248,249,250,251,252,253,254,
763: 45,241,241,242,91,91,91,96,96,136,136,136,141,141,141,141,
764: 241,46,242,243,243,97,97,97,245,246,143,143,143,143,148,148,
765: 0,5,45,45,50,50,90,90,95,95,95,95,95,140,140,141,
766: 0,40,40,40,40,80,80,80,80,80,120,120,120,120,120,120,
767: 45,50,50,90,90,95,95,135,135,135,136,141,141,181,181,181,
768: 45,90,91,91,131,131,136,136,136,176,181,181,186,226,231,236,
769: 45,45,91,91,96,96,136,136,137,142,182,182,187,188,188,233,
770: 188,249,248,247,246,137,137,137,244,243,243,91,242,241,241,45,
771: 183,183,183,247,137,137,137,137,137,244,91,91,91,241,241,45,
772: 252,251,188,188,248,248,142,142,142,244,244,243,91,242,241,45,
773: 247,247,246,246,245,245,244,244,243,243,242,242,51,241,241,5,
774: 236,231,231,191,186,185,185,140,140,135,135,95,90,90,45,45,
775: 4,49,49,53,53,93,93,93,93,92,92,92,243,242,46,241,
776: 239,239,239,239,239,239,239,239,239,239,239,239,239,239,239,239,
777: 239,239,239,239,239,239,239,239,239,239,239,239,239,239,239,182
778: };
779:
780: /*
781: ===================
782: Table8
783: ===================
784: */
785: void Table8 (void)
786: {
787: byte *pal;
788: int r,g,b,v;
789: int i;
790: byte *table;
791:
792: pal = vid_palette;
793: table = (byte *)pcolormap[0];
794:
795: for (i=0 ; i<256 ; i++)
796: {
797: r = pal[0];
798: g = pal[1];
799: b = pal[2];
800: pal += 3;
801:
802: // use the grey ramp if all indexes are close
803:
804: if (r-g < 16 && r-g > -16 && r-b < 16 && r-b > -16)
805: {
806: v = (r+g+b)/3;
807: *table++ = greytable[v];
808: continue;
809: }
810:
811: r = redtable[r];
812: g = greentable[g];
813: b = bluetable[b];
814:
815: // otherwise use the color cube
816: *table++ = r*(8*5) + g*5 + b;
817: }
818: }
819:
820: /*
821: ===================
822: Table24
823: ===================
824: */
825: void Table24 (void)
826: {
827: byte *pal;
828: int r,g,b,v;
829: int i;
830: unsigned *table;
831:
832:
833: //
834: // 8 8 8 encoding
835: //
836: pal = vid_palette;
837: table = (unsigned *)pcolormap[0];
838:
839: for (i=0 ; i<256 ; i++)
840: {
841: r = pal[0];
842: g = pal[1];
843: b = pal[2];
844: pal += 3;
845:
846: v = (r<<16) + (g<<8) + b;
847: *table++ = v;
848: }
849: }
850:
851: /*
852: ===================
853: Table24Swap
854: ===================
855: */
856: void Table24Swap (void)
857: {
858: byte *pal;
859: int r,g,b,v;
860: int i;
861: unsigned *table;
862:
863: //
864: // 8 8 8 encoding
865: //
866: pal = vid_palette;
867: table = (unsigned *)pcolormap[0];
868:
869: for (i=0 ; i<256 ; i++)
870: {
871: r = pal[0];
872: g = pal[1];
873: b = pal[2];
874: pal += 3;
875:
876: v = (r<<24) + (g<<16) + (b<<8) /*+ 255*/;
877: v = NXSwapBigLongToHost (v);
878: *table++ = v;
879: }
880: }
881:
882:
883: /*
884: ===================
885: Table15
886: ===================
887: */
888: void Table15 (void)
889: {
890: byte *pal;
891: int r,g,b,v;
892: int i, k;
893: unsigned char *palette;
894: unsigned short *table;
895: int dadj;
896: int ditheradjust[4] = {(1 << 9) * 3 / 8,
897: (1 << 9) * 5 / 8,
898: (1 << 9) * 7 / 8,
899: (1 << 9) * 1 / 8};
900:
901: palette = vid_palette;
902: table = (unsigned short *)pcolormap;
903:
904: //
905: // 5 5 5 encoding
906: //
907: for (k=0 ; k<4 ; k++)
908: {
909: dadj = ditheradjust[k];
910:
911: pal = vid_palette;
912:
913: for (i=0 ; i<256 ; i++)
914: {
915: // shift 6 bits to get back to 0-255, & 3 more for 5 bit color
916: // FIXME: scale intensity levels properly
917: r = (pal[0] + dadj) >> 3;
918: g = (pal[1] + dadj) >> 3;
919: b = (pal[2] + dadj) >> 3;
920: pal += 3;
921:
922: v = (r<<10) + (g<<5) + b;
923:
924: *table++ = v;
925: }
926: }
927: }
928:
929: /*
930: ===================
931: Table12
932: ===================
933: */
934: void Table12 (void)
935: {
936: byte *pal;
937: int r,g,b,v;
938: int i, k;
939: unsigned short *table;
940: int dadj;
941: static int ditheradjust[4] = {(1 << 9) * 3 / 8,
942: (1 << 9) * 5 / 8,
943: (1 << 9) * 7 / 8,
944: (1 << 9) * 1 / 8};
945:
946: table = (unsigned short *)pcolormap;
947:
948: //
949: // 4 4 4 encoding
950: //
951: for (k=0 ; k<4 ; k++)
952: {
953: dadj = ditheradjust[k];
954:
955: pal = vid_palette;
956:
957: for (i=0 ; i<256 ; i++)
958: {
959: // shift 5 bits to get back to 0-255, & 4 more for 4 bit color
960: // FIXME: scale intensity levels properly
961: r = (pal[0] + dadj) >> 4;
962: g = (pal[1] + dadj) >> 4;
963: b = (pal[2] + dadj) >> 4;
964: pal += 3;
965:
966: v = ((r<<12) + (g<<8) + (b<<4) /*+ 15*/);
967:
968: *table++ = v;
969: }
970: }
971: }
972:
973: /*
974: ===================
975: Table12Swap
976: ===================
977: */
978: void Table12Swap (void)
979: {
980: byte *pal;
981: int r,g,b,v;
982: int i, k;
983: unsigned short *table;
984: int dadj;
985: static int ditheradjust[4] = {(1 << 9) * 3 / 8,
986: (1 << 9) * 5 / 8,
987: (1 << 9) * 7 / 8,
988: (1 << 9) * 1 / 8};
989:
990: table = (unsigned short *)pcolormap;
991:
992: //
993: // 4 4 4 encoding
994: //
995: for (k=0 ; k<4 ; k++)
996: {
997: dadj = ditheradjust[k];
998:
999: pal = vid_palette;
1000:
1001: for (i=0 ; i<256 ; i++)
1002: {
1003: // shift 5 bits to get back to 0-255, & 4 more for 4 bit color
1004: // FIXME: scale intensity levels properly
1005: r = (pal[0] + dadj) >> 4;
1006: g = (pal[1] + dadj) >> 4;
1007: b = (pal[2] + dadj) >> 4;
1008: pal += 3;
1009:
1010: v = ((r<<12) + (g<<8) + (b<<4) /*+ 15*/);
1011: v = NXSwapBigShortToHost (v);
1012:
1013: *table++ = v;
1014: }
1015: }
1016: }
1017:
1018:
1019: /*
1020: ==========================================================================
1021:
1022: GENERIC IMAGING FUNCTIONS
1023:
1024: ==========================================================================
1025: */
1026:
1027: /*
1028: ===================
1029: Update8_1
1030: ===================
1031: */
1032: void Update8_1 (pixel_t *src, byte *dest, int width, int height,
1033: int destrowbytes)
1034: {
1035: int x,y;
1036: unsigned rowdelta, srcdelta;
1037: unsigned xcount;
1038: byte *pdest;
1039: int xwidth;
1040:
1041: pdest = dest;
1042:
1043: xcount = width >> 3;
1044: srcdelta = vid.width - width;
1045:
1046: xwidth = width - (xcount << 3);
1047: if (xwidth)
1048: Sys_Error ("Width not multiple of 8");
1049:
1050: if ((vid_display == disp_framebuffer) && (vid_scale == 2))
1051: {
1052: int nextrow = destrowbytes;
1053:
1054: rowdelta = destrowbytes - (width << 1) + destrowbytes;
1055:
1056: if (dither)
1057: {
1058: unsigned short *psrc;
1059:
1060: psrc = (unsigned short *)src;
1061:
1062: for (y = height ; y ; y--)
1063: {
1064: for (x = xcount ; x ;x--)
1065: {
1066: unsigned temp;
1067:
1068: temp = psrc[0];
1069: pdest[0] = ((byte *)pcolormap[0])[temp];
1070: pdest[1] = ((byte *)pcolormap[1])[temp];
1071: pdest[nextrow] = ((byte *)pcolormap[2])[temp];
1072: pdest[nextrow + 1] = ((byte *)pcolormap[3])[temp];
1073: temp = psrc[1];
1074: pdest[2] = ((byte *)pcolormap[0])[temp];
1075: pdest[3] = ((byte *)pcolormap[1])[temp];
1076: pdest[nextrow + 2] = ((byte *)pcolormap[2])[temp];
1077: pdest[nextrow + 3] = ((byte *)pcolormap[3])[temp];
1078: temp = psrc[2];
1079: pdest[4] = ((byte *)pcolormap[0])[temp];
1080: pdest[5] = ((byte *)pcolormap[1])[temp];
1081: pdest[nextrow + 4] = ((byte *)pcolormap[2])[temp];
1082: pdest[nextrow + 5] = ((byte *)pcolormap[3])[temp];
1083: temp = psrc[3];
1084: pdest[6] = ((byte *)pcolormap[0])[temp];
1085: pdest[7] = ((byte *)pcolormap[1])[temp];
1086: pdest[nextrow + 6] = ((byte *)pcolormap[2])[temp];
1087: pdest[nextrow + 7] = ((byte *)pcolormap[3])[temp];
1088: temp = psrc[4];
1089: pdest[8] = ((byte *)pcolormap[0])[temp];
1090: pdest[9] = ((byte *)pcolormap[1])[temp];
1091: pdest[nextrow + 8] = ((byte *)pcolormap[2])[temp];
1092: pdest[nextrow + 9] = ((byte *)pcolormap[3])[temp];
1093: temp = psrc[5];
1094: pdest[10] = ((byte *)pcolormap[0])[temp];
1095: pdest[11] = ((byte *)pcolormap[1])[temp];
1096: pdest[nextrow + 10] = ((byte *)pcolormap[2])[temp];
1097: pdest[nextrow + 11] = ((byte *)pcolormap[3])[temp];
1098: temp = psrc[6];
1099: pdest[12] = ((byte *)pcolormap[0])[temp];
1100: pdest[13] = ((byte *)pcolormap[1])[temp];
1101: pdest[nextrow + 12] = ((byte *)pcolormap[2])[temp];
1102: pdest[nextrow + 13] = ((byte *)pcolormap[3])[temp];
1103: temp = psrc[7];
1104: pdest[14] = ((byte *)pcolormap[0])[temp];
1105: pdest[15] = ((byte *)pcolormap[1])[temp];
1106: pdest[nextrow + 14] = ((byte *)pcolormap[2])[temp];
1107: pdest[nextrow + 15] = ((byte *)pcolormap[3])[temp];
1108: pdest += 16; psrc += 8;
1109: }
1110:
1111: psrc += srcdelta;
1112: pdest += rowdelta;
1113: }
1114: }
1115: else
1116: {
1117: byte *psrc;
1118:
1119: psrc = (byte *)src;
1120:
1121: for (y = height ; y ; y--)
1122: {
1123: for (x = xcount ; x ;x--)
1124: {
1125: pdest[0] = pdest[1] = pdest[nextrow] =
1126: pdest[nextrow + 1] = ((byte *)pcolormap[0])[psrc[0]];
1127: pdest[2] = pdest[3] = pdest[nextrow + 2] =
1128: pdest[nextrow + 3] = ((byte *)pcolormap[0])[psrc[1]];
1129: pdest[4] = pdest[5] = pdest[nextrow + 4] =
1130: pdest[nextrow + 5] = ((byte *)pcolormap[0])[psrc[2]];
1131: pdest[6] = pdest[7] = pdest[nextrow + 6] =
1132: pdest[nextrow + 7] = ((byte *)pcolormap[0])[psrc[3]];
1133: pdest[8] = pdest[9] = pdest[nextrow + 8] =
1134: pdest[nextrow + 9] = ((byte *)pcolormap[0])[psrc[4]];
1135: pdest[10] = pdest[11] = pdest[nextrow + 10] =
1136: pdest[nextrow + 11] = ((byte *)pcolormap[0])[psrc[5]];
1137: pdest[12] = pdest[13] = pdest[nextrow + 12] =
1138: pdest[nextrow + 13] = ((byte *)pcolormap[0])[psrc[6]];
1139: pdest[14] = pdest[15] = pdest[nextrow + 14] =
1140: pdest[nextrow + 15] = ((byte *)pcolormap[0])[psrc[7]];
1141: pdest += 16; psrc += 8;
1142: }
1143:
1144: psrc += srcdelta;
1145: pdest += rowdelta;
1146: }
1147: }
1148: }
1149: else
1150: {
1151: rowdelta = destrowbytes - width;
1152:
1153: if (dither)
1154: {
1155: unsigned short *psrc;
1156:
1157: psrc = (unsigned short *)src;
1158:
1159: for (y = height ; y>0 ; y -= 2)
1160: {
1161: for (x = xcount ; x ;x--)
1162: {
1163: pdest[0] = ((byte *)pcolormap[0])[psrc[0]];
1164: pdest[1] = ((byte *)pcolormap[1])[psrc[1]];
1165: pdest[2] = ((byte *)pcolormap[0])[psrc[2]];
1166: pdest[3] = ((byte *)pcolormap[1])[psrc[3]];
1167: pdest[4] = ((byte *)pcolormap[0])[psrc[4]];
1168: pdest[5] = ((byte *)pcolormap[1])[psrc[5]];
1169: pdest[6] = ((byte *)pcolormap[0])[psrc[6]];
1170: pdest[7] = ((byte *)pcolormap[1])[psrc[7]];
1171: pdest += 8; psrc += 8;
1172: }
1173:
1174: psrc += srcdelta;
1175: pdest += rowdelta;
1176:
1177: for (x = xcount ; x ;x--)
1178: {
1179: pdest[0] = ((byte *)pcolormap[2])[psrc[0]];
1180: pdest[1] = ((byte *)pcolormap[3])[psrc[1]];
1181: pdest[2] = ((byte *)pcolormap[2])[psrc[2]];
1182: pdest[3] = ((byte *)pcolormap[3])[psrc[3]];
1183: pdest[4] = ((byte *)pcolormap[2])[psrc[4]];
1184: pdest[5] = ((byte *)pcolormap[3])[psrc[5]];
1185: pdest[6] = ((byte *)pcolormap[2])[psrc[6]];
1186: pdest[7] = ((byte *)pcolormap[3])[psrc[7]];
1187: pdest += 8; psrc += 8;
1188: }
1189:
1190: psrc += srcdelta;
1191: pdest += rowdelta;
1192: }
1193: }
1194: else
1195: {
1196: byte *psrc;
1197:
1198: psrc = (byte *)src;
1199: // srcdelta += width;
1200: // rowdelta += width;
1201:
1202: for (y = height ; y ; y--)
1203: {
1204: for (x = xcount ; x ;x--)
1205: {
1206: pdest[0] = ((byte *)pcolormap[0])[psrc[0]];
1207: pdest[1] = ((byte *)pcolormap[0])[psrc[1]];
1208: pdest[2] = ((byte *)pcolormap[0])[psrc[2]];
1209: pdest[3] = ((byte *)pcolormap[0])[psrc[3]];
1210: pdest[4] = ((byte *)pcolormap[0])[psrc[4]];
1211: pdest[5] = ((byte *)pcolormap[0])[psrc[5]];
1212: pdest[6] = ((byte *)pcolormap[0])[psrc[6]];
1213: pdest[7] = ((byte *)pcolormap[0])[psrc[7]];
1214: pdest += 8; psrc += 8;
1215: }
1216:
1217: psrc += srcdelta;
1218: pdest += rowdelta;
1219: }
1220: }
1221: }
1222: }
1223:
1224:
1225: /*
1226: ===================
1227: Update16_1
1228: ===================
1229: */
1230: void Update16_1 (pixel_t *src, unsigned short *dest, int width,
1231: int height, int destrowbytes)
1232: {
1233: int x,y;
1234: unsigned rowdelta, srcdelta;
1235: unsigned xcount;
1236: pixel_t *psrc;
1237: unsigned short *pdest;
1238: int xwidth;
1239:
1240:
1241: psrc = src;
1242: pdest = dest;
1243:
1244: xcount = width >> 3;
1245: srcdelta = vid.width - width;
1246:
1247: xwidth = width - (xcount << 3);
1248: if (xwidth)
1249: Sys_Error ("Width not multiple of 8");
1250:
1251: if ((vid_display == disp_framebuffer) && (vid_scale == 2))
1252: {
1253: int nextrow = destrowbytes >> 1;
1254:
1255: rowdelta = (destrowbytes - ((width << 1) << 1) + destrowbytes) >> 1;
1256:
1257: if (dither)
1258: {
1259: for (y = height ; y ; y--)
1260: {
1261: for (x = xcount ; x ;x--)
1262: {
1263: unsigned temp;
1264:
1265: temp = psrc[0];
1266: pdest[0] = ((unsigned short *)pcolormap[0])[temp];
1267: pdest[1] = ((unsigned short *)pcolormap[1])[temp];
1268: pdest[nextrow] = ((unsigned short *)pcolormap[2])[temp];
1269: pdest[nextrow + 1] = ((unsigned short *)pcolormap[3])[temp];
1270: temp = psrc[1];
1271: pdest[2] = ((unsigned short *)pcolormap[0])[temp];
1272: pdest[3] = ((unsigned short *)pcolormap[1])[temp];
1273: pdest[nextrow + 2] = ((unsigned short *)pcolormap[2])[temp];
1274: pdest[nextrow + 3] = ((unsigned short *)pcolormap[3])[temp];
1275: temp = psrc[2];
1276: pdest[4] = ((unsigned short *)pcolormap[0])[temp];
1277: pdest[5] = ((unsigned short *)pcolormap[1])[temp];
1278: pdest[nextrow + 4] = ((unsigned short *)pcolormap[2])[temp];
1279: pdest[nextrow + 5] = ((unsigned short *)pcolormap[3])[temp];
1280: temp = psrc[3];
1281: pdest[6] = ((unsigned short *)pcolormap[0])[temp];
1282: pdest[7] = ((unsigned short *)pcolormap[1])[temp];
1283: pdest[nextrow + 6] = ((unsigned short *)pcolormap[2])[temp];
1284: pdest[nextrow + 7] = ((unsigned short *)pcolormap[3])[temp];
1285: temp = psrc[4];
1286: pdest[8] = ((unsigned short *)pcolormap[0])[temp];
1287: pdest[9] = ((unsigned short *)pcolormap[1])[temp];
1288: pdest[nextrow + 8] = ((unsigned short *)pcolormap[2])[temp];
1289: pdest[nextrow + 9] = ((unsigned short *)pcolormap[3])[temp];
1290: temp = psrc[5];
1291: pdest[10] = ((unsigned short *)pcolormap[0])[temp];
1292: pdest[11] = ((unsigned short *)pcolormap[1])[temp];
1293: pdest[nextrow + 10] = ((unsigned short *)pcolormap[2])[temp];
1294: pdest[nextrow + 11] = ((unsigned short *)pcolormap[3])[temp];
1295: temp = psrc[6];
1296: pdest[12] = ((unsigned short *)pcolormap[0])[temp];
1297: pdest[13] = ((unsigned short *)pcolormap[1])[temp];
1298: pdest[nextrow + 12] = ((unsigned short *)pcolormap[2])[temp];
1299: pdest[nextrow + 13] = ((unsigned short *)pcolormap[3])[temp];
1300: temp = psrc[7];
1301: pdest[14] = ((unsigned short *)pcolormap[0])[temp];
1302: pdest[15] = ((unsigned short *)pcolormap[1])[temp];
1303: pdest[nextrow + 14] = ((unsigned short *)pcolormap[2])[temp];
1304: pdest[nextrow + 15] = ((unsigned short *)pcolormap[3])[temp];
1305: pdest += 16; psrc += 8;
1306: }
1307:
1308: psrc += srcdelta;
1309: pdest += rowdelta;
1310: }
1311: }
1312: else
1313: {
1314: for (y = height ; y ; y--)
1315: {
1316: for (x = xcount ; x ;x--)
1317: {
1318: pdest[0] = pdest[1] = pdest[nextrow] =
1319: pdest[nextrow + 1] = pcolormap[0][psrc[0]];
1320: pdest[2] = pdest[3] = pdest[nextrow + 2] =
1321: pdest[nextrow + 3] = pcolormap[0][psrc[1]];
1322: pdest[4] = pdest[5] = pdest[nextrow + 4] =
1323: pdest[nextrow + 5] = pcolormap[0][psrc[2]];
1324: pdest[6] = pdest[7] = pdest[nextrow + 6] =
1325: pdest[nextrow + 7] = pcolormap[0][psrc[3]];
1326: pdest[8] = pdest[9] = pdest[nextrow + 8] =
1327: pdest[nextrow + 9] = pcolormap[0][psrc[4]];
1328: pdest[10] = pdest[11] = pdest[nextrow + 10] =
1329: pdest[nextrow + 11] = pcolormap[0][psrc[5]];
1330: pdest[12] = pdest[13] = pdest[nextrow + 12] =
1331: pdest[nextrow + 13] = pcolormap[0][psrc[6]];
1332: pdest[14] = pdest[15] = pdest[nextrow + 14] =
1333: pdest[nextrow + 15] = pcolormap[0][psrc[7]];
1334: pdest += 16; psrc += 8;
1335: }
1336:
1337: psrc += srcdelta;
1338: pdest += rowdelta;
1339: }
1340: }
1341: }
1342: else
1343: {
1344: rowdelta = (destrowbytes - (width<<1))>>1;
1345:
1346: if (dither)
1347: {
1348: for (y = height ; y>0 ; y -= 2)
1349: {
1350: for (x = xcount ; x ;x--)
1351: {
1352: pdest[0] = ((unsigned short *)pcolormap[0])[psrc[0]];
1353: pdest[1] = ((unsigned short *)pcolormap[1])[psrc[1]];
1354: pdest[2] = ((unsigned short *)pcolormap[0])[psrc[2]];
1355: pdest[3] = ((unsigned short *)pcolormap[1])[psrc[3]];
1356: pdest[4] = ((unsigned short *)pcolormap[0])[psrc[4]];
1357: pdest[5] = ((unsigned short *)pcolormap[1])[psrc[5]];
1358: pdest[6] = ((unsigned short *)pcolormap[0])[psrc[6]];
1359: pdest[7] = ((unsigned short *)pcolormap[1])[psrc[7]];
1360: pdest += 8; psrc += 8;
1361: }
1362:
1363: psrc += srcdelta;
1364: pdest += rowdelta;
1365:
1366: for (x = xcount ; x ;x--)
1367: {
1368: pdest[0] = ((unsigned short *)pcolormap[2])[psrc[0]];
1369: pdest[1] = ((unsigned short *)pcolormap[3])[psrc[1]];
1370: pdest[2] = ((unsigned short *)pcolormap[2])[psrc[2]];
1371: pdest[3] = ((unsigned short *)pcolormap[3])[psrc[3]];
1372: pdest[4] = ((unsigned short *)pcolormap[2])[psrc[4]];
1373: pdest[5] = ((unsigned short *)pcolormap[3])[psrc[5]];
1374: pdest[6] = ((unsigned short *)pcolormap[2])[psrc[6]];
1375: pdest[7] = ((unsigned short *)pcolormap[3])[psrc[7]];
1376: pdest += 8; psrc += 8;
1377: }
1378:
1379: psrc += srcdelta;
1380: pdest += rowdelta;
1381: }
1382: }
1383: else
1384: {
1385: for (y = height ; y ; y--)
1386: {
1387: for (x = xcount ; x ;x--)
1388: {
1389: pdest[0] = pcolormap[0][psrc[0]];
1390: pdest[1] = pcolormap[0][psrc[1]];
1391: pdest[2] = pcolormap[0][psrc[2]];
1392: pdest[3] = pcolormap[0][psrc[3]];
1393: pdest[4] = pcolormap[0][psrc[4]];
1394: pdest[5] = pcolormap[0][psrc[5]];
1395: pdest[6] = pcolormap[0][psrc[6]];
1396: pdest[7] = pcolormap[0][psrc[7]];
1397: pdest += 8; psrc += 8;
1398: }
1399:
1400: psrc += srcdelta;
1401: pdest += rowdelta;
1402: }
1403: }
1404: }
1405: }
1406:
1407:
1408: /*
1409: ===================
1410: Update32_1
1411: ===================
1412: */
1413: void Update32_1 (pixel_t *src, unsigned *dest, int width, int height,
1414: int destrowbytes)
1415: {
1416: int x,y;
1417: unsigned rowdelta, srcdelta;
1418: unsigned xcount;
1419: pixel_t *psrc;
1420: unsigned *pdest;
1421: int xwidth;
1422:
1423: psrc = src;
1424: pdest = dest;
1425:
1426: xcount = width >> 3;
1427: srcdelta = vid.width - width;
1428:
1429: xwidth = width - (xcount << 3);
1430: if (xwidth)
1431: Sys_Error ("Width not multiple of 8");
1432:
1433: if ((vid_display == disp_framebuffer) && (vid_scale == 2))
1434: {
1435: int nextrow = destrowbytes >> 2;
1436:
1437: rowdelta = ((destrowbytes - ((width << 1) << 2)) >> 2) +
1438: (destrowbytes >> 2);
1439:
1440: for (y = height ; y ; y--)
1441: {
1442: for (x = xcount ; x ;x--)
1443: {
1444: pdest[0] = pdest[1] = pdest[nextrow] =
1445: pdest[nextrow + 1] = pcolormap[0][psrc[0]];
1446: pdest[2] = pdest[3] = pdest[nextrow + 2] =
1447: pdest[nextrow + 3] = pcolormap[0][psrc[1]];
1448: pdest[4] = pdest[5] = pdest[nextrow + 4] =
1449: pdest[nextrow + 5] = pcolormap[0][psrc[2]];
1450: pdest[6] = pdest[7] = pdest[nextrow + 6] =
1451: pdest[nextrow + 7] = pcolormap[0][psrc[3]];
1452: pdest[8] = pdest[9] = pdest[nextrow + 8] =
1453: pdest[nextrow + 9] = pcolormap[0][psrc[4]];
1454: pdest[10] = pdest[11] = pdest[nextrow + 10] =
1455: pdest[nextrow + 11] = pcolormap[0][psrc[5]];
1456: pdest[12] = pdest[13] = pdest[nextrow + 12] =
1457: pdest[nextrow + 13] = pcolormap[0][psrc[6]];
1458: pdest[14] = pdest[15] = pdest[nextrow + 14] =
1459: pdest[nextrow + 15] = pcolormap[0][psrc[7]];
1460: pdest += 16; psrc += 8;
1461: }
1462:
1463: psrc += srcdelta;
1464: pdest += rowdelta;
1465: }
1466: }
1467: else
1468: {
1469: rowdelta = (destrowbytes - (width<<2))>>2;
1470:
1471: for (y = height ; y ; y--)
1472: {
1473: for (x = xcount ; x ;x--)
1474: {
1475: pdest[0] = pcolormap[0][psrc[0]];
1476: pdest[1] = pcolormap[0][psrc[1]];
1477: pdest[2] = pcolormap[0][psrc[2]];
1478: pdest[3] = pcolormap[0][psrc[3]];
1479: pdest[4] = pcolormap[0][psrc[4]];
1480: pdest[5] = pcolormap[0][psrc[5]];
1481: pdest[6] = pcolormap[0][psrc[6]];
1482: pdest[7] = pcolormap[0][psrc[7]];
1483: pdest += 8; psrc += 8;
1484: }
1485:
1486: psrc += srcdelta;
1487: pdest += rowdelta;
1488: }
1489: }
1490: }
1491:
1492:
1493: /*
1494: ==========================================================================
1495:
1496: NEXTSTEP VIEW CLASS
1497:
1498: ==========================================================================
1499: */
1500:
1501:
1502: @implementation QuakeView
1503:
1504: /*
1505: =================
1506: windowDidMove
1507:
1508: =================
1509: */
1510: - windowDidMove:sender
1511: {
1512: NXPoint aPoint;
1513: NXRect winframe;
1514:
1515: aPoint.x = aPoint.y = 0;
1516: [self convertPoint:&aPoint toView:nil];
1517: [window convertBaseToScreen: &aPoint];
1518: [window getFrame: &winframe];
1519:
1520: if ((int)aPoint.x & 7)
1521: {
1522: [window moveTo:winframe.origin.x - ((int)aPoint.x&7)
1523: :winframe.origin.y];
1524: [window getFrame: &winframe];
1525: }
1526: return self;
1527: }
1528:
1529: - windowWillResize:sender toSize:(NXSize *)frameSize
1530: {
1531: NXRect fr, cont;
1532:
1533: fr.origin.x = fr.origin.y = 0;
1534: fr.size = *frameSize;
1535:
1536: [Window getContentRect:&cont forFrameRect: &fr style:[window style]];
1537:
1538: cont.size.width = (int)cont.size.width & ~15;
1539: if (cont.size.width < 128)
1540: cont.size.width = 128;
1541: cont.size.height = (int)cont.size.height & ~3;
1542: if (cont.size.height < 32)
1543: cont.size.height = 32;
1544:
1545: [Window getFrameRect:&fr forContentRect: &cont style:[window style]];
1546:
1547: *frameSize = fr.size;
1548:
1549: return self;
1550: }
1551:
1552: - windowDidResize:sender
1553: {
1554: if (vid_display == disp_framebuffer)
1555: Sys_Error ("How the heck are you resizing a framebuffer window?!?");
1556:
1557: vid.width = bounds.size.width/vid_scale;
1558: vid.height = bounds.size.height/vid_scale;
1559:
1560: //
1561: // allocate memory for the back and translation buffers
1562: //
1563: vid.rowbytes = vid.width;
1564: rowbytesnative = vid.width * pixbytesnative;
1565:
1566: AllocBuffers (true);
1567:
1568: vid.conbuffer = vid.buffer;
1569: vid.conrowbytes = vid.rowbytes;
1570: vid.conwidth = vid.width;
1571: vid.conheight = vid.height;
1572:
1573: vid.recalc_refdef = 1;
1574:
1575: return self;
1576: }
1577:
1578: -(BOOL) acceptsFirstResponder
1579: {
1580: return YES;
1581: }
1582:
1583:
1584: typedef struct
1585: {
1586: int source, dest;
1587: } keymap_t;
1588:
1589: keymap_t keymaps[] =
1590: {
1591: {103, K_RIGHTARROW},
1592: {102, K_LEFTARROW},
1593: {100, K_UPARROW},
1594: {101, K_DOWNARROW},
1595: {111, K_PAUSE},
1596:
1597: {59, K_F1},
1598: {60, K_F2},
1599: {61, K_F3},
1600: {62, K_F4},
1601: {63, K_F5},
1602: {64, K_F6},
1603: {65, K_F7},
1604: {66, K_F8},
1605: {67, K_F9},
1606: {68, K_F10},
1607: {87, K_F11},
1608: {88, K_F12},
1609:
1610: {-1,-1}
1611: };
1612:
1613: keymap_t flagmaps[] =
1614: {
1615: {NX_SHIFTMASK, K_SHIFT},
1616: {NX_CONTROLMASK, K_CTRL},
1617: {NX_ALTERNATEMASK, K_ALT},
1618: {NX_COMMANDMASK, K_ALT},
1619:
1620: {-1,-1}
1621: };
1622:
1623: /*
1624: ===================
1625: keyboard methods
1626: ===================
1627: */
1628: - keyDown:(NXEvent *)theEvent
1629: {
1630: int ch;
1631: keymap_t *km;
1632:
1633: PSobscurecursor ();
1634:
1635: // check for non-ascii first
1636: ch = theEvent->data.key.keyCode;
1637: for (km=keymaps;km->source!=-1;km++)
1638: if (ch == km->source)
1639: {
1640: Key_Event (km->dest, true);
1641: return self;
1642: }
1643:
1644: ch = theEvent->data.key.charCode;
1645: if (ch >= 'A' && ch <= 'Z')
1646: ch += 'a' - 'A';
1647: if (ch>=256)
1648: return self;
1649:
1650: Key_Event (ch, true);
1651: return self;
1652: }
1653:
1654: - flagsChanged:(NXEvent *)theEvent
1655: {
1656: static int oldflags;
1657: int newflags;
1658: int delta;
1659: keymap_t *km;
1660: int i;
1661:
1662: PSobscurecursor ();
1663: newflags = theEvent->flags;
1664: delta = newflags ^ oldflags;
1665: for (i=0 ; i<32 ; i++)
1666: {
1667: if ( !(delta & (1<<i)))
1668: continue;
1669: // changed
1670: for (km=flagmaps;km->source!=-1;km++)
1671: if ( (1<<i) == km->source)
1672: {
1673: if (newflags & (1<<i))
1674: Key_Event (km->dest, true);
1675: else
1676: Key_Event (km->dest, false);
1677: }
1678:
1679: }
1680:
1681: oldflags = newflags;
1682:
1683: return self;
1684: }
1685:
1686:
1687: - keyUp:(NXEvent *)theEvent
1688: {
1689: int ch;
1690: keymap_t *km;
1691:
1692: // check for non-ascii first
1693: ch = theEvent->data.key.keyCode;
1694: for (km=keymaps;km->source!=-1;km++)
1695: if (ch == km->source)
1696: {
1697: Key_Event (km->dest, false);
1698: return self;
1699: }
1700:
1701: ch = theEvent->data.key.charCode;
1702: if (ch >= 'A' && ch <= 'Z')
1703: ch += 'a' - 'A';
1704: if (ch>=256)
1705: return self;
1706: Key_Event (ch, false);
1707: return self;
1708: }
1709:
1710:
1711: - tiffShot
1712: {
1713: id imagerep, image;
1714: NXRect r;
1715: NXStream *stream;
1716: int fd;
1717: int i;
1718: char tiffname[80];
1719:
1720: [vid_window_i getFrame: &r];
1721: r.origin.x = r.origin.y = 0;
1722: image = [[NXImage alloc] initSize: &r.size];
1723: imagerep = [[NXCachedImageRep alloc] initFromWindow:vid_window_i rect:&r];
1724:
1725: [image lockFocus];
1726: [imagerep draw];
1727: [image unlockFocus];
1728:
1729: //
1730: // find a file name to save it to
1731: //
1732: strcpy(tiffname,"quake00.tif");
1733:
1734: for (i=0 ; i<=99 ; i++)
1735: {
1736: tiffname[5] = i/10 + '0';
1737: tiffname[6] = i%10 + '0';
1738: if (Sys_FileTime(tiffname) == -1)
1739: break; // file doesn't exist
1740: }
1741: if (i==100)
1742: Sys_Error ("SCR_ScreenShot_f: Couldn't create a tiff");
1743:
1744: fd = open (tiffname, O_RDWR|O_CREAT|O_TRUNC, 0666);
1745: stream = NXOpenFile (fd, NX_READWRITE);
1746: [image writeTIFF: stream];
1747: NXClose (stream);
1748: close (fd);
1749: printf ("wrote %s\n", tiffname);
1750:
1751: [image free];
1752: [imagerep free];
1753: return self;
1754:
1755: }
1756:
1757: - screenShot: sender
1758: {
1759: return [self tiffShot];
1760: }
1761:
1762: - setScaleFullScreen: sender
1763: {
1764: VID_Shutdown ();
1765: if (vid_fullscreen)
1766: {
1767: vid_fullscreen = 0;
1768: VID_Restart (vid_display, vid_scale);
1769: }
1770: else
1771: {
1772: vid_fullscreen = 1;
1773: VID_Restart (vid_display, vid_scale);
1774: }
1775: return self;
1776: }
1777:
1778: @end
1779:
1780: //============================================================================
1781:
1782: @implementation FrameWindow
1783:
1784: - windowExposed:(NXEvent *)theEvent
1785: {
1786: return self;
1787: }
1788:
1789: @end
1790:
1791:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.