![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to whvfx1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Witchaven II] / src|
Return to whvfx1.c CVS log | Up to [Witchaven II] / src |
1.1 root 1: #define TEKWAR
2: /***************************************************************************
3: * NAME: EXAMPLE.C
4: ** COPYRIGHT:
5: ** "Copyright (c) 1994, by FORTE"
6: **
7: ** "This software is furnished under a license and may be used,
8: ** copied, or disclosed only in accordance with the terms of such
9: ** license and with the inclusion of the above copyright notice.
10: ** This software or any other copies thereof may not be provided or
11: ** otherwise made available to any other person. No title to and
12: ** ownership of the software is hereby transfered."
13: ****************************************************************************
14: * CREATION DATE: 06/01/94
15: *--------------------------------------------------------------------------*
16: * VERSION DATE NAME DESCRIPTION
17: * 06/20/94 Example SENSE example interface code.
18: * 06/27/94 Modified for support for Windows
19: * Tracking support.
20: * (plus example video mode changes)
21: ***************************************************************************/
22:
23: #ifndef TEKWAR
24: #ifdef __WATCOMC__
25: #include <graph.h>
26:
27: #elif defined(_WINDOWS)
28: #include <windows.h>
29: unsigned long win_memory;
30: #endif
31:
32: #if defined(__WATCOMC__) || defined(_WINDOWS)
33: #include "dpmi.h"
34: #endif
35: #endif
36:
37: #include <stddef.h>
38: #include <stdio.h>
39: #include <stdlib.h>
40: #include <string.h>
41: #include <conio.h>
42: #include <dos.h>
43:
44: #include "vfx1.h"
45: #ifndef TEKWAR
46: #include "vesa.h"
47: #endif
48:
49: #define MAX_CONFIG_SIZE 256
50: #define MAX_REPORT_SIZE 256
51:
52: #define DOS_ERROR 0xFF
53:
54: #define PALETTE_SIZE 768
55: #define MONO_320_200 0x13
56:
57: #define LEFT_EYE 0
58: #define RIGHT_EYE 1
59: #define BOTH_EYES 2
60:
61: #define MAX_HTDS 6
62: #define MAX_HPDS 6
63:
64: SYSTEM_CPKT *system_cfg;
65: VENDOR_CPKT *vendor_cfg;
66: HMS_CPKT *hms_cfg;
67: HTD_CPKT *htd_cfg;
68: HPD_CPKT *hpd_cfg;
69:
70: // Structures specific to what the application enables
71: // Set Video Mode for a "Something" mounted display
72: struct svm_struct
73: {
74: SVM_CPKT cfg;
75: NULL_CPKT null_end;
76: };
77: typedef struct svm_struct SVM_STRUCT;
78:
79: // Head tracker devices
80: struct htd_struct
81: {
82: short yaw;
83: short pitch;
84: short roll;
85: };
86: typedef struct htd_struct HTD_STRUCT;
87:
88: // Hand held devices
89: struct hpd_struct
90: {
91: short yaw;
92: short pitch;
93: short roll;
94: char buttons;
95: };
96: typedef struct hpd_struct HPD_STRUCT;
97:
98: SVM_STRUCT svm;
99: HTD_STRUCT far *htd_data[ MAX_HTDS ];
100: HPD_STRUCT far *hpd_data[ MAX_HPDS ];
101:
102: //#ifndef TEKWAR
103: union REGS regs;
104: struct SREGS sregs;
105: //#endif
106:
107: // Fields required for ISA bus io.
108: int vip_air_port;
109: int vip_csr_port;
110:
111: #ifndef TEKWAR
112: // Holding array for current VGA palette
113: char vga_palette[ PALETTE_SIZE ];
114:
115: // Fields required for MONO video example.
116: char mono_colors[ PALETTE_SIZE ];
117:
118: // Fields required for STEREO video example.
119: char left_colors[ PALETTE_SIZE ];
120: char right_colors[ PALETTE_SIZE ];
121: #endif
122:
123: int SenseStatus( void );
124: int SenseGetConfiguration( int function, int *count, char *config_buffer);
125: int SenseSetConfiguration( int function, char *config_buffer );
126: int SenseReport( int function, int *count, char *report_buffer );
127: #ifndef TEKWAR
128: void ShowMonoPattern( void );
129: void PutPalette( int which_eye, char *pPalette );
130: void GetPalette( char *pPalette );
131: void VideoChannel( int stereo_mode, int page );
132: void ShowStereoPattern( void );
133: void BuildPalettes( void );
134: void CleanUp( void );
135: #endif
136:
137: #ifdef TEKWAR
138: #include "keydefs.h"
139:
140: #define DPMI_INT 0x31
141: #define MOUSE_INT 0x33
142:
143: #define AX(r) ((r).x.eax)
144: #define BX(r) ((r).x.ebx)
145: #define CX(r) ((r).x.ecx)
146: #define DX(r) ((r).x.edx)
147: #define SI(r) ((r).x.esi)
148: #define DI(r) ((r).x.edi)
149:
150: static void *pdosmem;
151:
152: short segment,
153: selector;
154:
155: int sense_function;
156:
157: char vfx1_cyberpuck;
158: char config_buffer[MAX_CONFIG_SIZE];
159: char *report_offset;
160: char report_buffer[MAX_REPORT_SIZE];
161:
162: enum {
163: OPT_RUN,
164: OPT_SHOOT,
165: OPT_USEOPEN,
166: OPT_JUMP,
167: OPT_CROUCH,
168: OPT_MAP,
169: OPT_MAPZOOMIN,
170: OPT_MAPZOOMOUT,
171: NUMBUTOPTIONS
172: };
173:
174: char *butkeystr[]={
175: "BUTTON1:",
176: "BUTTON2:",
177: "BUTTON3:"
178: };
179:
180: char *butoptstr[]={
181: "RUN",
182: "SHOOT",
183: "USE_OPEN",
184: "JUMP",
185: "CROUCH",
186: "MAP",
187: "MAP_ZOOM_IN",
188: "MAP_ZOOM_OUT",
189: };
190:
191: char puckbuttons;
192:
193: short butoptval[]={
194: KEYRUN,KEYFIRE,KEYUSE,KEYJUMP,KEYCROUCH,
195: KEYMAP,KEYZOOMI,KEYZOOMO
196: };
197:
198: #define NUMPUCKBUTTONS 3
199:
200: short puckpitch,
201: puckroll,
202: puckbutton[NUMPUCKBUTTONS];
203:
204: FILE *fp;
205: char buf[256];
206:
207: extern
208: union REGS regs;
209: extern
210: struct SREGS sregs;
211:
212: //extern
213: int vfx1enabled;
214:
215: static struct rminfo {
216: long di;
217: long si;
218: long bp;
219: long reserved_by_system;
220: long bx;
221: long dx;
222: long cx;
223: long ax;
224: short flags;
225: short es, ds, fs, gs, ip, cs, sp, ss;
226: } SENSE;
227:
228: void *
229: allocDOS(unsigned nbytes, short *pseg, short *psel)
230: {
231: unsigned npara=(nbytes+15)/16;
232: void *pprot;
233:
234: pprot=NULL;
235: *pseg=0;
236: *psel=0;
237: segread(&sregs);
238: AX(regs)=0x0100; // DPMI: Allocate DOS Memory
239: BX(regs)=npara; // number of paragraphs to alloc
240: int386( DPMI_INT, ®s, ®s);
241: if (regs.w.cflag == 0) {
242: *pseg=AX(regs);
243: *psel=DX(regs);
244: pprot=(void *)((unsigned)*pseg<<4);
245: }
246: return(pprot);
247: }
248:
249: void
250: VFX1MouseInt(struct rminfo *prmi)
251: {
252: memset(&sregs,0,sizeof (sregs));
253: memset(®s,0,sizeof (regs));
254: AX(regs)=0x0300; // DPMI: simulate interrupt
255: BX(regs)=MOUSE_INT;
256: CX(regs)=0;
257: DI(regs)=FP_OFF(prmi);
258: sregs.es=FP_SEG(prmi);
259: int386x(DPMI_INT,®s,®s,&sregs);
260: }
261:
262: void
263: vfx1_read(short *tyaw,short *tpitch,short *troll,
264: short *ppitch,short *proll,char *pbuttons)
265: {
266: int count,ret;
267:
268: if (ret=SenseReport(sense_function,&count,report_buffer)) {
269: return;
270: }
271: *tyaw=htd_data[0]->yaw;
272: *tpitch=htd_data[0]->pitch;
273: *troll=htd_data[0]->roll;
274: *ppitch=hpd_data[0]->pitch;
275: *proll=hpd_data[0]->roll;
276: *pbuttons=hpd_data[0]->buttons;
277: }
278: #endif
279: #include <memcheck.h>
280:
281: int SenseStatus( void )
282: {
283: int function, result, i;
284:
285: for( i=MIN_SENSE_FUNCTION; i <= MAX_SENSE_FUNCTION; i++ )
286: {
287: result = i;
288: result |= (SENSE_DRIVER_STATUS << 8);
289: function = SENSE_DRIVER_STATUS;
290: function |= (i << 8);
291:
292: #if defined(__WATCOMC__) || defined(_WINDOWS)
293:
294: memset(&SENSE, 0, sizeof(SENSE));
295: SENSE.ax = function;
296: SENSE.bx = 0;
297: SENSE.cx = 0;
298: SENSE.dx = 0;
299: VFX1MouseInt( &SENSE ); // Generate the INT 33
300:
301: if( SENSE.ax == result )
302: return( function & 0xFF00 );
303: #else
304: regs.x.cx = 0;
305: regs.x.dx = 0;
306: regs.x.bx = 0;
307: regs.x.ax = function;
308: int86( SENSE_VECTOR, ®s, ®s );
309:
310: if( regs.x.ax == result )
311: return( function & 0xFF00 );
312: #endif
313: }
314:
315: return( 0 );
316: }
317:
318: int SenseGetConfiguration( int function, int *count, char *config_buffer )
319: {
320: #if defined(__WATCOMC__) || defined(_WINDOWS)
321: char *src,*dest;
322: int i;
323:
324: memset(&SENSE, 0, sizeof(SENSE));
325: SENSE.ax = function | GET_CONFIGURATION;
326: SENSE.cx = 0;
327: SENSE.es = segment;
328: SENSE.dx = 0;
329: VFX1MouseInt( &SENSE );
330:
331: src = (char *)pdosmem;
332: for( i=0; i < SENSE.cx; i++ )
333: config_buffer[i] = src[i];
334:
335: *count = SENSE.cx;
336:
337: return( SENSE.ax );
338: #else
339: regs.x.ax = function | GET_CONFIGURATION;
340: regs.x.cx = 0;
341: regs.x.dx = FP_OFF( config_buffer );
342: sregs.es = FP_SEG( config_buffer );
343:
344: int86x( SENSE_VECTOR, ®s, ®s, &sregs);
345:
346: *count = regs.x.cx;
347:
348: return( regs.x.ax );
349: #endif
350: }
351:
352: int SenseSetConfiguration( int function, char *config_buffer )
353: {
354: #if defined(__WATCOMC__) || defined(_WINDOWS)
355: char *src,*dest;
356: int i;
357:
358: dest = (char *)pdosmem;
359: for (i = 0; i < MAX_CONFIG_SIZE; i++)
360: dest[i] = config_buffer[i];
361:
362: memset(&SENSE, 0, sizeof(SENSE));
363: SENSE.ax = function | SET_CONFIGURATION;
364: SENSE.cx = 0;
365: SENSE.es = segment;
366: SENSE.dx = 0;
367:
368: VFX1MouseInt( &SENSE );
369:
370: return( SENSE.ax );
371: #else
372: regs.x.ax = function | SET_CONFIGURATION;
373: regs.x.cx = 0;
374: regs.x.dx = FP_OFF( config_buffer );
375: sregs.es = FP_SEG( config_buffer );
376:
377: int86x( SENSE_VECTOR, ®s, ®s, &sregs);
378:
379: return( regs.x.ax );
380: #endif
381: }
382:
383: int SenseReport( int function, int *count, char *report_buffer )
384: {
385: #if defined(__WATCOMC__) || defined(_WINDOWS)
386: char *src;
387: int i;
388:
389: memset(&SENSE, 0, sizeof(SENSE));
390: SENSE.ax = function | REPORT;
391: SENSE.cx = 0;
392: SENSE.es = segment;
393: SENSE.dx = 0;
394: VFX1MouseInt( &SENSE );
395:
396: src = (char *)pdosmem;
397: for (i = 0; i < SENSE.cx; i++)
398: report_buffer[i] = src[i];
399:
400: *count = SENSE.cx;
401:
402: return( SENSE.ax );
403: #else
404: regs.x.ax = function | REPORT;
405: regs.x.cx = 0;
406: regs.x.dx = FP_OFF( report_buffer );
407: sregs.es = FP_SEG( report_buffer );
408:
409: int86x( SENSE_VECTOR, ®s, ®s, &sregs );
410:
411: *count = regs.x.cx;
412:
413: return( regs.x.ax );
414: #endif
415: }
416:
417: #ifndef TEKWAR
418: void ShowMonoPattern( void )
419: {
420: int color;
421: int i,j;
422: char *vga_screen;
423:
424: // While waiting for a key press show a simple pattern
425: color = 0;
426: vga_screen = (char *) SCREEN_BASE_LA;
427: for( j=0; j < 199; j++ ) {
428: for( i=0; i < 320; i++ )
429: vga_screen[ j*320 + i ] = color;
430: color++;
431: }
432:
433: getch();
434: }
435:
436: void PutPalette( int which_eye, char *pPalette )
437: {
438: int i;
439: char *pTmp = pPalette;
440: char palette_control_bits;
441:
442: /* turn on palette */
443: outp( vip_air_port,VIP_PPMR );
444: outp( vip_csr_port, 0xFF );
445:
446: // Enable write of proper selected palettes (right and/or left eyes)
447:
448: outp( vip_air_port, VIP_PCR );
449: palette_control_bits = inp( vip_csr_port );
450: if( which_eye == LEFT_EYE )// Left eye update only.
451: {
452: palette_control_bits |= 0x02; // Select left.
453: palette_control_bits &= ~0x04;// Turn off update of both.
454: palette_control_bits |= 0x01;// Turn off snoop.
455: }
456: else
457: if( which_eye == RIGHT_EYE )// Right eye update only.
458: {
459: palette_control_bits &= ~0x02;// Select right.
460: palette_control_bits &= ~0x04;// Turn off update of both.
461: palette_control_bits |= 0x01;// Turn off snoop.
462: }
463: else
464: { // Enable both eye updates.
465: palette_control_bits |= 0x04;// Turn on update of both.
466: palette_control_bits &= ~0x01;// Turn on snoop.
467: }
468:
469: outp( vip_csr_port, palette_control_bits );
470:
471: // Setup the VGA's video palette.
472: outp(0x3c8,0);
473: for (i=0; i<256; i++) {
474: outp(0x3c9,*pPalette++);
475: outp(0x3c9,*pPalette++);
476: outp(0x3c9,*pPalette++);
477: }
478:
479: // Setup the VIP video palette or palettes
480: outp(vip_air_port,VIP_PWAR);
481: outp(vip_csr_port,0);
482: outp(vip_air_port,VIP_PCRR);
483:
484: for (i=0; i < 256; i++) {
485: outp(vip_csr_port,*pTmp++);
486: outp(vip_csr_port,*pTmp++);
487: outp(vip_csr_port,*pTmp++);
488: }
489: }
490:
491: void GetPalette( char *pPalette )
492: {
493: int i;
494: // Read the VGA's video palette.
495: outp(0x3c8,0);
496: for (i=0; i<PALETTE_SIZE; i++) pPalette[i] = inp( 0x3c9 );
497: }
498:
499: void VideoChannel( int stereo_mode, int page )
500: {
501: // This procedure will use the ISA bus to set which quardrant the
502: // left and right eyes will be looking at.
503: outp( vip_air_port, VIP_PSR );
504:
505: if( page )
506: {
507: if( stereo_mode )
508: // Stereo on page one is defined as lower left(left eye),
509: // lower right(right eye).
510: outp( vip_csr_port, 0x23);
511: else
512: {
513: // Mono on page one is defined as lower left corner both eyes.
514: outp( vip_csr_port, 0x22);
515: }
516: }
517: else
518: {
519: if( stereo_mode )
520: // Stereo on page zero is defined as upper left(left eye),
521: // upper right(right eye).
522: outp( vip_csr_port, 0x01);
523: else
524: {
525: // Mono on page zero is defined as upper left corner both eyes.
526: outp( vip_csr_port, 0x00);
527: }
528: }
529: }
530:
531: void ShowStereoPattern( void )
532: {
533: long Offset;
534: long over;
535: int VESAWriteWindow = 0;
536: int SubWindow;
537: int RetVal;
538: int sPageOffset;
539: int stereo_mode = 0;
540: int i,j;
541: int left_index;
542: int right_index;
543: char key;
544: char *pDst;
545: char *pPageBase;
546: char *vga_screen;
547:
548: RetVal = VESAExists();
549:
550: if (RetVal == VESA_NO_SUPPORT) {
551: printf("VESA Function 00h: Super VGA Information not supported.");
552: return;
553: }
554:
555: if (RetVal == VESA_BAD_INFO) {
556: printf("VESA Function 00h: Super VGA Information failed.\n");
557: return;
558: }
559:
560: if( VESAGetModeInfo( VESA_G640x480x256 ) ) {
561: printf("VESA mode %x is NOT supported\n", VESA_G640x480x256 );
562: return;
563: }
564:
565: if (!(VesaModeInfo.ModeAttributes & VESA_MA_MODE_SUPPORTED)) {
566: printf("VESA mode %x is NOT supported\n", VESA_G640x480x256 );
567: return;
568: }
569:
570: if ((VesaModeInfo.WinAAttributes & VESA_WA_MODE_SUPPORTED)
571: && (VesaModeInfo.WinAAttributes & VESA_WA_WRITABLE)) {
572: VESAWriteWindow = 0;
573: }
574: else
575: {
576: if ((VesaModeInfo.WinBAttributes & VESA_WA_MODE_SUPPORTED)
577: && (VesaModeInfo.WinBAttributes & VESA_WA_WRITABLE)) {
578: VESAWriteWindow = 1;
579: }
580: else {
581: printf("Cannot write to VESA Windows\n");
582: return;
583: }
584: }
585:
586: stereo_mode = 1;
587: sPageOffset = 0;
588: vga_screen = (char *) SCREEN_BASE_LA;
589:
590: // Now show the same pattern only in stereo
591: while( 1 ) {
592: VESASetMode( VESA_G640x480x256 );
593:
594: VideoChannel( stereo_mode, sPageOffset / 640 );
595:
596: PutPalette( LEFT_EYE, left_colors );
597: PutPalette( RIGHT_EYE, right_colors );
598:
599: SubWindow = 0;
600: Offset = sPageOffset;
601: pPageBase = (char *)(vga_screen + sPageOffset);
602: pDst = (char *)pPageBase; /* start address on VGA */
603: left_index = 0;
604: right_index = 200;
605:
606: VESASetWin( VESAWriteWindow, SubWindow );
607:
608: for (i = 0; i < 200; i++) {
609: if (Offset + 640L < 65536L) {
610: for (j = 0; j < 320; j++) *pDst++ = left_index;
611: for (j = 0; j < 320; j++) *pDst++ = right_index;
612:
613: pDst += 640;
614: Offset += 1280L;
615:
616: if (Offset >= 65536L) {
617: Offset &= 0x0000FFFF;
618: pDst = (char *)(pPageBase + Offset);
619: VESASetWin( VESAWriteWindow, ++SubWindow );
620: }
621: }
622: else {
623: if (Offset + 320L < 65536L) {
624: for (j = 0; j < 320; j++) *pDst++ = left_index;
625: over = (Offset + 640L) - 65536L;
626: for (j = 0; j < (320L - over); j++) *pDst++ = right_index;
627:
628: pDst = (char *)pPageBase;
629: VESASetWin( VESAWriteWindow,++SubWindow );
630:
631: for (j = 0; j < over; j++) *pDst++ = right_index;
632:
633: pDst += 640;
634: Offset = 640L + over;
635: }
636: else {
637: over = (Offset + 320L) - 65536L;
638: for (j = 0; j < (320L - over); j++) *pDst++ = left_index;
639:
640: pDst = (char *)pPageBase;
641: VESASetWin( VESAWriteWindow, ++SubWindow );
642:
643: for (j = 0; j < over; j++ ) *pDst++ = left_index;
644: for (j = 0; j < 320; j++ ) *pDst++ = right_index;
645:
646: pDst += 640;
647: Offset = 960L + over;
648: }
649: }
650: left_index++;
651: right_index--;
652: pPageBase = (char *)(vga_screen);
653: }
654:
655: #ifdef __WATCOMC__
656: _settextposition( 1,1 );
657: #else
658: gotoxy( 1,1 );
659: #endif
660: printf("Enter: Toggle stereo/mono Space: Toggle page 0/1 Esc: exit\n");
661: printf("Current settings:\n");
662: if( sPageOffset ) printf("Page 1: ");
663: else printf("Page 0: ");
664: if( stereo_mode ) printf("Stereo mode:\n");
665: else printf("Mono mode:\n");
666:
667: key = getch();
668: if( key == 27 ) break;// Simply exit this example code.
669: if( key == 13 ) // Simply toggle to and from stereo/mono mode.
670: stereo_mode = !stereo_mode;
671: if( key == 32 ) // Simply flip to other page on press of space bar
672: {
673: if( sPageOffset ) sPageOffset = 0;
674: else sPageOffset = 640;
675: }
676: }
677: }
678:
679: void BuildPalettes( void )
680: {
681: int i;
682:
683: // Both eyes palette (mono test)
684: for( i = 0; i < PALETTE_SIZE; ) {
685: mono_colors[i++] = 0x0;
686: mono_colors[i++] = 0x0;
687: mono_colors[i++] = i % 100;
688: }
689:
690: // All red in left eye (stereo test)
691: for( i=0; i<PALETTE_SIZE; i++ ) {
692: if( !(i % 3) ) left_colors[i] = i;
693: else left_colors[i] = 0;
694: }
695: // All green in right eye (stereo test)
696: for( i=0; i<PALETTE_SIZE; i++ ) {
697: if( !((i+2) % 3) ) right_colors[i] = i;
698: else right_colors[i] = 0;
699:
700: }
701: }
702:
703: void CleanUp( void )
704: {
705: #if defined(__WATCOMC__) || defined(_WINDOWS)
706: // Free the dos memory.
707: if (pdosmem) {
708: freeDOS(selector);
709: pdosmem = 0;
710: }
711: #endif
712: }
713: #endif // Les 09/29/95
714:
715: void vfx1_init(void)
716: {
717: #ifndef TEKWAR
718: int sense_function;
719: int current_video_mode;
720: #endif
721: int htd_index, hpd_index;
722: int count, i, j;
723: int packet_size;
724: int ret;
725: #ifndef TEKWAR
726: char vfx1_cyberpuck;
727: char config_buffer[ MAX_CONFIG_SIZE ];
728: char *report_offset;
729: char report_buffer[ MAX_REPORT_SIZE ];
730: #endif
731: char *env_ptr, *dptr;
732:
733: #if defined(__WATCOMC__) || defined(_WINDOWS)
734: // allocate a DOS real-mode buffer
735: pdosmem = allocDOS(MAX_CONFIG_SIZE, &segment, &selector);
736: if (!pdosmem) {
737: printf("Error getting DOS memory!\n");
738: exit(0);
739: }
740: #endif
741:
742: // Should use environment string here.
743: // Get the VIPPORT Environment string and setup the port variables.
744: env_ptr = getenv("VIPPORT");
745: if (env_ptr == NULL) {
746: #ifndef TEKWAR
747: printf("VIPPORT Environment string not setup, using default.\n");
748: #endif
749: vip_air_port = 0x300;
750: }
751: else {
752: vip_air_port = strtol( env_ptr, &dptr, 16 );
753: }
754:
755: vip_csr_port = vip_air_port + VIP_CSR;
756:
757: if( (sense_function = SenseStatus()) == 0 ) {
758: #ifndef TEKWAR
759: printf("No Sense devices installed\n");
760: CleanUp();
761: exit(2);
762: #endif
763: }
764:
765: #ifndef TEKWAR
766: printf("Sense devices installed on function %x\n", sense_function );
767: #endif
768:
769: if( ret=SenseGetConfiguration( sense_function, &count, config_buffer ) ) {
770: #ifndef TEKWAR
771: printf("Error#(%d) getting configuration packets\n", ret );
772: CleanUp();
773: exit(3);
774: #endif
775: }
776:
777: #ifndef TEKWAR
778: printf("Configuration packet sizes %d\n", count );
779: #endif
780:
781: report_offset = report_buffer;
782: htd_index = hpd_index = 0;
783:
784: for( i=0; i < count; i += packet_size ) {
785: packet_size = (int)config_buffer[i];
786:
787: switch( config_buffer[i+1] )
788: {
789: case NULLP:
790: // All done packets break out
791: i = count;
792: break;
793: case SYSI:
794: system_cfg = (SYSTEM_CPKT *) &config_buffer[i];
795:
796: break;
797: case VNDI:
798: vendor_cfg = (VENDOR_CPKT *) &config_buffer[i];
799: #ifndef TEKWAR
800: printf("%s\n", vendor_cfg->prdm );
801: printf("%s\n", vendor_cfg->prdn );
802: printf("Serial #: %s\n", vendor_cfg->prdsn );
803: printf("Revision level: %s\n", vendor_cfg->prdrl );
804: #endif
805: if( !strcmp( vendor_cfg->prdn, PRDN ) )
806: vfx1_cyberpuck = 1;
807: else
808: vfx1_cyberpuck = 0;
809: break;
810: case HMS:
811: hms_cfg = (HMS_CPKT *) &config_buffer[i];
812:
813: svm.cfg.psiz = sizeof( SVM_CPKT );
814: svm.cfg.ptyp = SVM;
815: svm.cfg.dcls = hms_cfg->dcls;
816: svm.cfg.dnum = hms_cfg->dnum;
817:
818: break;
819: case HTD:
820: if( htd_index >= MAX_HTDS ) break;
821: htd_data[htd_index++] = (HTD_STRUCT far *) report_offset;
822: report_offset += sizeof( HTD_STRUCT );
823:
824: htd_cfg = (HTD_CPKT *) &config_buffer[i];
825: // Only enable if Head tracker is for a Vfx1 Cyberbuck
826: if( vfx1_cyberpuck )
827: {// Vfx1 Cyberpuck Head tracker.
828: htd_cfg->ywcd.rcf.den = 1;
829: htd_cfg->ptcd.rcf.den = 1;
830: htd_cfg->rlcd.rcf.den = 1;
831: }
832: break;
833: case HPD:
834: if( hpd_index >= MAX_HPDS ) break;
835: hpd_data[hpd_index++] = (HPD_STRUCT far *) report_offset;
836: report_offset += sizeof( HPD_STRUCT );
837:
838: hpd_cfg = (HPD_CPKT *) &config_buffer[i];
839:
840: if( vfx1_cyberpuck )
841: {// Vfx1 Cyberpuck Head tracker.
842: hpd_cfg->ywcd.rcf.den = 1;
843: hpd_cfg->ptcd.rcf.den = 1;
844: hpd_cfg->rlcd.rcf.den = 1;
845: hpd_cfg->btcd.den = 1;
846: }
847: break;
848: default:
849: #ifndef TEKWAR
850: printf("Strange packet type here\n");
851: #endif
852: break;
853: }
854: }
855:
856: if( ret=SenseSetConfiguration( sense_function, config_buffer ) ) {
857: #ifndef TEKWAR
858: printf("Error#(%d) enabling configuration packets\n",ret);
859: CleanUp();
860: exit(4);
861: #endif
862: }
863:
864: #ifndef TEKWAR
865: getch();
866:
867: #ifdef __WATCOMC__
868: _clearscreen( 0 );
869: #else
870: clrscr();
871: #endif
872: #endif
873:
874: // Configuration packets are now enabled and ready for reporting
875: #ifndef TEKWAR
876: if( htd_index )
877: printf("VFX1 Head tracker device installed\n" );
878: if( hpd_index )
879: printf("CyberPuck Pointing device installed\n" );
880:
881: while( !kbhit() ) {
882: if( ret=SenseReport( sense_function, &count, report_buffer ) ) {
883: printf("Error#(%d) during reporting packets\n",ret);
884: CleanUp();
885: exit(5);
886: }
887:
888: #ifdef __WATCOMC__
889: _settextposition( 1,5 );
890: #else
891: gotoxy( 1,5 );
892: #endif
893:
894: if( htd_index )
895: printf("VFX1: yaw(%-05d) pitch(%-05d) roll(%-05d) \n",
896: htd_data[0]->yaw, htd_data[0]->pitch, htd_data[0]->roll);
897:
898: if( hpd_index )
899: printf("CyberPuck: pitch(%-05d) roll(%-05d) Buttons(%03x) \n",
900: hpd_data[0]->pitch, hpd_data[0]->roll, hpd_data[0]->buttons);
901: }
902: getch();
903: #endif
904:
905: #ifndef TEKWAR
906: #ifndef _WINDOWS
907: // Now let's do both a stero and a mono video test.
908: // First build the palettes for both tests.
909: BuildPalettes();
910:
911: // Store current VGA mode.
912: current_video_mode = VESAGetMode( );
913:
914: // First let's do a simple MONO video test.
915: VESASetMode( MONO_320_200 );
916:
917: // Get the VGA palette
918: GetPalette( vga_palette );
919:
920: // Now put the "Something" mounted display in mono mode.
921: svm.cfg.vmod = 0;
922: if( ret=SenseSetConfiguration( sense_function, (char *)&svm ) ) {
923: VESASetMode( current_video_mode );
924: printf("Error#(%d) setting mono video mode\n",ret);
925: }
926: else {
927: PutPalette( BOTH_EYES, mono_colors );
928:
929: // Put up a mono screen.
930: ShowMonoPattern( );
931: }
932:
933: // Finally let's do a simple STEREO video test.
934: VESASetMode( VESA_G640x480x256 );
935:
936: // Now put the "Something" mounted display in stereo mode.
937: svm.cfg.vmod = 1;
938: if( ret=SenseSetConfiguration( sense_function, (char *)&svm ) ) {
939: VESASetMode( current_video_mode );
940: printf("Error#(%d) setting mono video mode\n",ret);
941: }
942: else {
943: PutPalette( LEFT_EYE, left_colors );
944: PutPalette( RIGHT_EYE, right_colors );
945:
946: // Put up a stereo screen. This routine also performs stereo tests.
947: ShowStereoPattern();
948: }
949:
950: // Now put the "Something" mounted display back in mono mode.
951: VESASetMode( MONO_320_200 );
952: svm.cfg.vmod = 0;
953: if( ret=SenseSetConfiguration( sense_function, (char *)&svm ) ) {
954: VESASetMode( current_video_mode );
955: printf("Error#(%d) setting mono video mode\n",ret);
956: }
957:
958: // Reset the VGA palette
959: PutPalette( BOTH_EYES, vga_palette );
960:
961: // Reset VGA mode
962: VESASetMode( current_video_mode );
963: #else
964: // Now put the "Something" mounted display in stereo mode.
965: svm.cfg.vmod = 1;
966: if( ret=SenseSetConfiguration( sense_function, (char *)&svm ) ) {
967: VESASetMode( current_video_mode );
968: printf("Error#(%d) setting mono video mode\n",ret);
969: }
970: else {
971: printf("Now in STEREO Mode\n");
972: getch();
973: }
974:
975: // Now put the "Something" mounted display in mono mode.
976: svm.cfg.vmod = 0;
977: if( ret=SenseSetConfiguration( sense_function, (char *)&svm ) ) {
978: VESASetMode( current_video_mode );
979: printf("Error#(%d) setting mono video mode\n",ret);
980: }
981: else {
982: printf("Now in MONO Mode\n");
983: getch();
984: }
985: #endif
986:
987: CleanUp();
988: #else
989: vfx1enabled=1;
990: #if 0
991: fp=fopen("VFX1.CFG","r");
992: if (fp != NULL) {
993: while (fgets(buf,256,fp) != NULL) {
994: for (i=0 ; i < NUMPUCKBUTTONS ; i++) {
995: if (strstr(buf,butkeystr[i]) != NULL) {
996: for (j=0 ; j < NUMBUTOPTIONS ; j++) {
997: if (strstr(buf,butoptstr[j]) != NULL) {
998: switch (j) {
999: case OPT_RUN:
1000: case OPT_SHOOT:
1001: case OPT_USEOPEN:
1002: case OPT_JUMP:
1003: case OPT_CROUCH:
1004: case OPT_MAP:
1005: case OPT_MAPZOOMIN:
1006: case OPT_MAPZOOMOUT:
1007: puckbutton[i]=butoptval[j];
1008: break;
1009: }
1010: }
1011: }
1012: }
1013: }
1014: }
1015: fclose(fp);
1016: }
1017: #endif
1018: #endif
1019: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.