diff options
Diffstat (limited to 'apps/plugins/sdl/progs/quake/vid_svgalib.c')
-rw-r--r-- | apps/plugins/sdl/progs/quake/vid_svgalib.c | 1003 |
1 files changed, 1003 insertions, 0 deletions
diff --git a/apps/plugins/sdl/progs/quake/vid_svgalib.c b/apps/plugins/sdl/progs/quake/vid_svgalib.c new file mode 100644 index 0000000000..e0fea3af09 --- /dev/null +++ b/apps/plugins/sdl/progs/quake/vid_svgalib.c | |||
@@ -0,0 +1,1003 @@ | |||
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 | #include <termios.h> | ||
21 | #include <sys/ioctl.h> | ||
22 | #include <sys/stat.h> | ||
23 | #include <sys/vt.h> | ||
24 | #include <stdarg.h> | ||
25 | #include <stdio.h> | ||
26 | #include <signal.h> | ||
27 | |||
28 | #include <asm/io.h> | ||
29 | |||
30 | #include "vga.h" | ||
31 | #include "vgakeyboard.h" | ||
32 | #include "vgamouse.h" | ||
33 | |||
34 | #include "quakedef.h" | ||
35 | #include "d_local.h" | ||
36 | |||
37 | #define stringify(m) { #m, m } | ||
38 | |||
39 | unsigned short d_8to16table[256]; | ||
40 | static byte *vid_surfcache; | ||
41 | static int VID_highhunkmark; | ||
42 | |||
43 | int num_modes; | ||
44 | vga_modeinfo *modes; | ||
45 | int current_mode; | ||
46 | |||
47 | int num_shades=32; | ||
48 | |||
49 | struct | ||
50 | { | ||
51 | char *name; | ||
52 | int num; | ||
53 | } mice[] = | ||
54 | { | ||
55 | stringify(MOUSE_MICROSOFT), | ||
56 | stringify(MOUSE_MOUSESYSTEMS), | ||
57 | stringify(MOUSE_MMSERIES), | ||
58 | stringify(MOUSE_LOGITECH), | ||
59 | stringify(MOUSE_BUSMOUSE), | ||
60 | stringify(MOUSE_PS2), | ||
61 | }; | ||
62 | |||
63 | static unsigned char scantokey[128]; | ||
64 | static byte vid_current_palette[768]; | ||
65 | |||
66 | int num_mice = sizeof (mice) / sizeof(mice[0]); | ||
67 | |||
68 | int d_con_indirect = 0; | ||
69 | |||
70 | int svgalib_inited=0; | ||
71 | int UseMouse = 1; | ||
72 | int UseDisplay = 1; | ||
73 | int UseKeyboard = 1; | ||
74 | |||
75 | int mouserate = MOUSE_DEFAULTSAMPLERATE; | ||
76 | |||
77 | cvar_t vid_mode = {"vid_mode","5",false}; | ||
78 | cvar_t vid_redrawfull = {"vid_redrawfull","0",false}; | ||
79 | cvar_t vid_waitforrefresh = {"vid_waitforrefresh","0",true}; | ||
80 | |||
81 | char *framebuffer_ptr; | ||
82 | |||
83 | cvar_t mouse_button_commands[3] = | ||
84 | { | ||
85 | {"mouse1","+attack"}, | ||
86 | {"mouse2","+strafe"}, | ||
87 | {"mouse3","+forward"}, | ||
88 | }; | ||
89 | |||
90 | int mouse_buttons; | ||
91 | int mouse_buttonstate; | ||
92 | int mouse_oldbuttonstate; | ||
93 | float mouse_x, mouse_y; | ||
94 | float old_mouse_x, old_mouse_y; | ||
95 | int mx, my; | ||
96 | |||
97 | cvar_t m_filter = {"m_filter","0"}; | ||
98 | |||
99 | static byte backingbuf[48*24]; | ||
100 | |||
101 | int VGA_width, VGA_height, VGA_rowbytes, VGA_bufferrowbytes, VGA_planar; | ||
102 | byte *VGA_pagebase; | ||
103 | |||
104 | void VGA_UpdatePlanarScreen (void *srcbuffer); | ||
105 | |||
106 | void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height) | ||
107 | { | ||
108 | int i, j, k, plane, reps, repshift, offset, vidpage, off; | ||
109 | |||
110 | if (!svgalib_inited || !vid.direct || !vga_oktowrite()) return; | ||
111 | |||
112 | if (vid.aspect > 1.5) | ||
113 | { | ||
114 | reps = 2; | ||
115 | repshift = 1; | ||
116 | } else { | ||
117 | reps = 1; | ||
118 | repshift = 0; | ||
119 | } | ||
120 | |||
121 | vidpage = 0; | ||
122 | vga_setpage(0); | ||
123 | |||
124 | if (VGA_planar) | ||
125 | { | ||
126 | for (plane=0 ; plane<4 ; plane++) | ||
127 | { | ||
128 | // select the correct plane for reading and writing | ||
129 | outb(0x02, 0x3C4); | ||
130 | outb(1 << plane, 0x3C5); | ||
131 | outb(4, 0x3CE); | ||
132 | outb(plane, 0x3CF); | ||
133 | |||
134 | for (i=0 ; i<(height << repshift) ; i += reps) | ||
135 | { | ||
136 | for (k=0 ; k<reps ; k++) | ||
137 | { | ||
138 | for (j=0 ; j<(width >> 2) ; j++) | ||
139 | { | ||
140 | backingbuf[(i + k) * 24 + (j << 2) + plane] = | ||
141 | vid.direct[(y + i + k) * VGA_rowbytes + | ||
142 | (x >> 2) + j]; | ||
143 | vid.direct[(y + i + k) * VGA_rowbytes + (x>>2) + j] = | ||
144 | pbitmap[(i >> repshift) * 24 + | ||
145 | (j << 2) + plane]; | ||
146 | } | ||
147 | } | ||
148 | } | ||
149 | } | ||
150 | } else { | ||
151 | for (i=0 ; i<(height << repshift) ; i += reps) | ||
152 | { | ||
153 | for (j=0 ; j<reps ; j++) | ||
154 | { | ||
155 | offset = x + ((y << repshift) + i + j) * vid.rowbytes; | ||
156 | off = offset % 0x10000; | ||
157 | if ((offset / 0x10000) != vidpage) { | ||
158 | vidpage=offset / 0x10000; | ||
159 | vga_setpage(vidpage); | ||
160 | } | ||
161 | memcpy (&backingbuf[(i + j) * 24], | ||
162 | vid.direct + off, width); | ||
163 | memcpy (vid.direct + off, | ||
164 | &pbitmap[(i >> repshift)*width], width); | ||
165 | } | ||
166 | } | ||
167 | } | ||
168 | } | ||
169 | |||
170 | void D_EndDirectRect (int x, int y, int width, int height) | ||
171 | { | ||
172 | int i, j, k, plane, reps, repshift, offset, vidpage, off; | ||
173 | |||
174 | if (!svgalib_inited || !vid.direct || !vga_oktowrite()) return; | ||
175 | |||
176 | if (vid.aspect > 1.5) | ||
177 | { | ||
178 | reps = 2; | ||
179 | repshift = 1; | ||
180 | } else { | ||
181 | reps = 1; | ||
182 | repshift = 0; | ||
183 | } | ||
184 | |||
185 | vidpage = 0; | ||
186 | vga_setpage(0); | ||
187 | |||
188 | if (VGA_planar) | ||
189 | { | ||
190 | for (plane=0 ; plane<4 ; plane++) | ||
191 | { | ||
192 | // select the correct plane for writing | ||
193 | outb(2, 0x3C4); | ||
194 | outb(1 << plane, 0x3C5); | ||
195 | outb(4, 0x3CE); | ||
196 | outb(plane, 0x3CF); | ||
197 | |||
198 | for (i=0 ; i<(height << repshift) ; i += reps) | ||
199 | { | ||
200 | for (k=0 ; k<reps ; k++) | ||
201 | { | ||
202 | for (j=0 ; j<(width >> 2) ; j++) | ||
203 | { | ||
204 | vid.direct[(y + i + k) * VGA_rowbytes + (x>>2) + j] = | ||
205 | backingbuf[(i + k) * 24 + (j << 2) + plane]; | ||
206 | } | ||
207 | } | ||
208 | } | ||
209 | } | ||
210 | } else { | ||
211 | for (i=0 ; i<(height << repshift) ; i += reps) | ||
212 | { | ||
213 | for (j=0 ; j<reps ; j++) | ||
214 | { | ||
215 | offset = x + ((y << repshift) + i + j) * vid.rowbytes; | ||
216 | off = offset % 0x10000; | ||
217 | if ((offset / 0x10000) != vidpage) { | ||
218 | vidpage=offset / 0x10000; | ||
219 | vga_setpage(vidpage); | ||
220 | } | ||
221 | memcpy (vid.direct + off, | ||
222 | &backingbuf[(i +j)*24], | ||
223 | width); | ||
224 | } | ||
225 | } | ||
226 | } | ||
227 | } | ||
228 | |||
229 | /* | ||
230 | ================= | ||
231 | VID_Gamma_f | ||
232 | |||
233 | Keybinding command | ||
234 | ================= | ||
235 | */ | ||
236 | void VID_Gamma_f (void) | ||
237 | { | ||
238 | float gamma, f, inf; | ||
239 | unsigned char palette[768]; | ||
240 | int i; | ||
241 | |||
242 | if (Cmd_Argc () == 2) | ||
243 | { | ||
244 | gamma = Q_atof (Cmd_Argv(1)); | ||
245 | |||
246 | for (i=0 ; i<768 ; i++) | ||
247 | { | ||
248 | f = pow ( (host_basepal[i]+1)/256.0 , gamma ); | ||
249 | inf = f*255 + 0.5; | ||
250 | if (inf < 0) | ||
251 | inf = 0; | ||
252 | if (inf > 255) | ||
253 | inf = 255; | ||
254 | palette[i] = inf; | ||
255 | } | ||
256 | |||
257 | VID_SetPalette (palette); | ||
258 | |||
259 | vid.recalc_refdef = 1; // force a surface cache flush | ||
260 | } | ||
261 | } | ||
262 | |||
263 | void VID_DescribeMode_f (void) | ||
264 | { | ||
265 | int modenum; | ||
266 | |||
267 | modenum = Q_atoi (Cmd_Argv(1)); | ||
268 | if ((modenum >= num_modes) || (modenum < 0 ) || !modes[modenum].width) | ||
269 | Con_Printf("Invalid video mode: %d!\n",modenum); | ||
270 | Con_Printf("%d: %d x %d - ",modenum,modes[modenum].width,modes[modenum].height); | ||
271 | if (modes[modenum].bytesperpixel == 0) | ||
272 | Con_Printf("ModeX\n"); | ||
273 | else | ||
274 | Con_Printf("%d bpp\n", modes[modenum].bytesperpixel<<3); | ||
275 | } | ||
276 | |||
277 | void VID_DescribeModes_f (void) | ||
278 | { | ||
279 | int i; | ||
280 | |||
281 | for (i=0;i<num_modes;i++) | ||
282 | if (modes[i].width) { | ||
283 | Con_Printf("%d: %d x %d - ", i, modes[i].width,modes[i].height); | ||
284 | if (modes[i].bytesperpixel == 0) | ||
285 | Con_Printf("ModeX\n"); | ||
286 | else | ||
287 | Con_Printf("%d bpp\n", modes[i].bytesperpixel<<3); | ||
288 | } | ||
289 | } | ||
290 | |||
291 | /* | ||
292 | ================ | ||
293 | VID_NumModes | ||
294 | ================ | ||
295 | */ | ||
296 | int VID_NumModes () | ||
297 | { | ||
298 | int i,i1=0; | ||
299 | |||
300 | for (i=0;i<num_modes;i++) | ||
301 | i1+=(modes[i].width?1:0); | ||
302 | return (i1); | ||
303 | } | ||
304 | |||
305 | void VID_NumModes_f (void) | ||
306 | { | ||
307 | Con_Printf("%d modes\n",VID_NumModes()); | ||
308 | } | ||
309 | |||
310 | void VID_Debug_f (void) | ||
311 | { | ||
312 | Con_Printf("mode: %d\n",current_mode); | ||
313 | Con_Printf("height x width: %d x %d\n",vid.height,vid.width); | ||
314 | Con_Printf("bpp: %d\n",modes[current_mode].bytesperpixel*8); | ||
315 | Con_Printf("vid.aspect: %f\n",vid.aspect); | ||
316 | } | ||
317 | |||
318 | |||
319 | |||
320 | void VID_InitModes(void) | ||
321 | { | ||
322 | |||
323 | int i; | ||
324 | |||
325 | // get complete information on all modes | ||
326 | |||
327 | num_modes = vga_lastmodenumber()+1; | ||
328 | modes = Z_Malloc(num_modes * sizeof(vga_modeinfo)); | ||
329 | for (i=0 ; i<num_modes ; i++) | ||
330 | { | ||
331 | if (vga_hasmode(i)) | ||
332 | Q_memcpy(&modes[i], vga_getmodeinfo(i), sizeof (vga_modeinfo)); | ||
333 | else | ||
334 | modes[i].width = 0; // means not available | ||
335 | } | ||
336 | |||
337 | // filter for modes i don't support | ||
338 | |||
339 | for (i=0 ; i<num_modes ; i++) | ||
340 | { | ||
341 | if (modes[i].bytesperpixel != 1 && modes[i].colors != 256) | ||
342 | modes[i].width = 0; | ||
343 | } | ||
344 | |||
345 | } | ||
346 | |||
347 | int get_mode(char *name, int width, int height, int depth) | ||
348 | { | ||
349 | |||
350 | int i; | ||
351 | int ok, match; | ||
352 | |||
353 | match = (!!width) + (!!height)*2 + (!!depth)*4; | ||
354 | |||
355 | if (name) | ||
356 | { | ||
357 | i = vga_getmodenumber(name); | ||
358 | if (!modes[i].width) | ||
359 | { | ||
360 | Sys_Printf("Mode [%s] not supported\n", name); | ||
361 | i = G320x200x256; | ||
362 | } | ||
363 | } | ||
364 | else | ||
365 | { | ||
366 | for (i=0 ; i<num_modes ; i++) | ||
367 | if (modes[i].width) | ||
368 | { | ||
369 | ok = (modes[i].width == width) | ||
370 | + (modes[i].height == height)*2 | ||
371 | + (modes[i].bytesperpixel == depth/8)*4; | ||
372 | if ((ok & match) == ok) | ||
373 | break; | ||
374 | } | ||
375 | if (i==num_modes) | ||
376 | { | ||
377 | Sys_Printf("Mode %dx%d (%d bits) not supported\n", | ||
378 | width, height, depth); | ||
379 | i = G320x200x256; | ||
380 | } | ||
381 | } | ||
382 | |||
383 | return i; | ||
384 | |||
385 | } | ||
386 | |||
387 | int matchmouse(int mouse, char *name) | ||
388 | { | ||
389 | int i; | ||
390 | for (i=0 ; i<num_mice ; i++) | ||
391 | if (!strcmp(mice[i].name, name)) | ||
392 | return i; | ||
393 | return mouse; | ||
394 | } | ||
395 | |||
396 | #if 0 | ||
397 | |||
398 | void vtswitch(int newconsole) | ||
399 | { | ||
400 | |||
401 | int fd; | ||
402 | struct vt_stat x; | ||
403 | |||
404 | // switch consoles and wait until reactivated | ||
405 | fd = open("/dev/console", O_RDONLY); | ||
406 | ioctl(fd, VT_GETSTATE, &x); | ||
407 | ioctl(fd, VT_ACTIVATE, newconsole); | ||
408 | ioctl(fd, VT_WAITACTIVE, x.v_active); | ||
409 | close(fd); | ||
410 | |||
411 | } | ||
412 | |||
413 | #endif | ||
414 | |||
415 | void keyhandler(int scancode, int state) | ||
416 | { | ||
417 | |||
418 | int sc; | ||
419 | |||
420 | sc = scancode & 0x7f; | ||
421 | // Con_Printf("scancode=%x (%d%s)\n", scancode, sc, scancode&0x80?"+128":""); | ||
422 | Key_Event(scantokey[sc], state == KEY_EVENTPRESS); | ||
423 | |||
424 | } | ||
425 | |||
426 | void VID_Shutdown(void) | ||
427 | { | ||
428 | |||
429 | if (!svgalib_inited) return; | ||
430 | |||
431 | // printf("shutdown graphics called\n"); | ||
432 | if (UseKeyboard) | ||
433 | keyboard_close(); | ||
434 | if (UseDisplay) | ||
435 | vga_setmode(TEXT); | ||
436 | // printf("shutdown graphics finished\n"); | ||
437 | |||
438 | svgalib_inited = 0; | ||
439 | |||
440 | } | ||
441 | |||
442 | void VID_ShiftPalette(unsigned char *p) | ||
443 | { | ||
444 | VID_SetPalette(p); | ||
445 | } | ||
446 | |||
447 | void VID_SetPalette(byte *palette) | ||
448 | { | ||
449 | |||
450 | static int tmppal[256*3]; | ||
451 | int *tp; | ||
452 | int i; | ||
453 | |||
454 | if (!svgalib_inited) | ||
455 | return; | ||
456 | |||
457 | memcpy(vid_current_palette, palette, sizeof(vid_current_palette)); | ||
458 | |||
459 | if (vga_getcolors() == 256) | ||
460 | { | ||
461 | |||
462 | tp = tmppal; | ||
463 | for (i=256*3 ; i ; i--) | ||
464 | *(tp++) = *(palette++) >> 2; | ||
465 | |||
466 | if (UseDisplay && vga_oktowrite()) | ||
467 | vga_setpalvec(0, 256, tmppal); | ||
468 | |||
469 | } | ||
470 | } | ||
471 | |||
472 | int VID_SetMode (int modenum, unsigned char *palette) | ||
473 | { | ||
474 | int bsize, zsize, tsize; | ||
475 | |||
476 | if ((modenum >= num_modes) || (modenum < 0) || !modes[modenum].width) | ||
477 | { | ||
478 | Cvar_SetValue ("vid_mode", (float)current_mode); | ||
479 | |||
480 | Con_Printf("No such video mode: %d\n",modenum); | ||
481 | |||
482 | return 0; | ||
483 | } | ||
484 | |||
485 | Cvar_SetValue ("vid_mode", (float)modenum); | ||
486 | |||
487 | current_mode=modenum; | ||
488 | |||
489 | vid.width = modes[current_mode].width; | ||
490 | vid.height = modes[current_mode].height; | ||
491 | |||
492 | VGA_width = modes[current_mode].width; | ||
493 | VGA_height = modes[current_mode].height; | ||
494 | VGA_planar = modes[current_mode].bytesperpixel == 0; | ||
495 | VGA_rowbytes = modes[current_mode].linewidth; | ||
496 | vid.rowbytes = modes[current_mode].linewidth; | ||
497 | if (VGA_planar) { | ||
498 | VGA_bufferrowbytes = modes[current_mode].linewidth * 4; | ||
499 | vid.rowbytes = modes[current_mode].linewidth*4; | ||
500 | } | ||
501 | |||
502 | vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0); | ||
503 | vid.colormap = (pixel_t *) host_colormap; | ||
504 | vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048)); | ||
505 | vid.conrowbytes = vid.rowbytes; | ||
506 | vid.conwidth = vid.width; | ||
507 | vid.conheight = vid.height; | ||
508 | vid.numpages = 1; | ||
509 | |||
510 | vid.maxwarpwidth = WARP_WIDTH; | ||
511 | vid.maxwarpheight = WARP_HEIGHT; | ||
512 | |||
513 | // alloc zbuffer and surface cache | ||
514 | if (d_pzbuffer) { | ||
515 | D_FlushCaches(); | ||
516 | Hunk_FreeToHighMark (VID_highhunkmark); | ||
517 | d_pzbuffer = NULL; | ||
518 | vid_surfcache = NULL; | ||
519 | } | ||
520 | |||
521 | bsize = vid.rowbytes * vid.height; | ||
522 | tsize = D_SurfaceCacheForRes (vid.width, vid.height); | ||
523 | zsize = vid.width * vid.height * sizeof(*d_pzbuffer); | ||
524 | |||
525 | VID_highhunkmark = Hunk_HighMark (); | ||
526 | |||
527 | d_pzbuffer = Hunk_HighAllocName (bsize+tsize+zsize, "video"); | ||
528 | |||
529 | vid_surfcache = ((byte *)d_pzbuffer) + zsize; | ||
530 | |||
531 | vid.conbuffer = vid.buffer = (pixel_t *)(((byte *)d_pzbuffer) + zsize + tsize); | ||
532 | |||
533 | D_InitCaches (vid_surfcache, tsize); | ||
534 | |||
535 | // get goin' | ||
536 | |||
537 | vga_setmode(current_mode); | ||
538 | VID_SetPalette(palette); | ||
539 | |||
540 | VGA_pagebase = vid.direct = framebuffer_ptr = (char *) vga_getgraphmem(); | ||
541 | // if (vga_setlinearaddressing()>0) | ||
542 | // framebuffer_ptr = (char *) vga_getgraphmem(); | ||
543 | if (!framebuffer_ptr) | ||
544 | Sys_Error("This mode isn't hapnin'\n"); | ||
545 | |||
546 | vga_setpage(0); | ||
547 | |||
548 | svgalib_inited=1; | ||
549 | |||
550 | vid.recalc_refdef = 1; // force a surface cache flush | ||
551 | |||
552 | return 0; | ||
553 | } | ||
554 | |||
555 | void VID_Init(unsigned char *palette) | ||
556 | { | ||
557 | |||
558 | int i; | ||
559 | int w, h, d; | ||
560 | |||
561 | if (svgalib_inited) | ||
562 | return; | ||
563 | |||
564 | // Cmd_AddCommand ("gamma", VID_Gamma_f); | ||
565 | |||
566 | if (UseDisplay) | ||
567 | { | ||
568 | vga_init(); | ||
569 | |||
570 | VID_InitModes(); | ||
571 | |||
572 | Cvar_RegisterVariable (&vid_mode); | ||
573 | Cvar_RegisterVariable (&vid_redrawfull); | ||
574 | Cvar_RegisterVariable (&vid_waitforrefresh); | ||
575 | |||
576 | Cmd_AddCommand("vid_nummodes", VID_NumModes_f); | ||
577 | Cmd_AddCommand("vid_describemode", VID_DescribeMode_f); | ||
578 | Cmd_AddCommand("vid_describemodes", VID_DescribeModes_f); | ||
579 | Cmd_AddCommand("vid_debug", VID_Debug_f); | ||
580 | |||
581 | // interpret command-line params | ||
582 | |||
583 | w = h = d = 0; | ||
584 | if (getenv("GSVGAMODE")) | ||
585 | current_mode = get_mode(getenv("GSVGAMODE"), w, h, d); | ||
586 | else if (COM_CheckParm("-mode")) | ||
587 | current_mode = get_mode(com_argv[COM_CheckParm("-mode")+1], w, h, d); | ||
588 | else if (COM_CheckParm("-w") || COM_CheckParm("-h") | ||
589 | || COM_CheckParm("-d")) | ||
590 | { | ||
591 | if (COM_CheckParm("-w")) | ||
592 | w = Q_atoi(com_argv[COM_CheckParm("-w")+1]); | ||
593 | if (COM_CheckParm("-h")) | ||
594 | h = Q_atoi(com_argv[COM_CheckParm("-h")+1]); | ||
595 | if (COM_CheckParm("-d")) | ||
596 | d = Q_atoi(com_argv[COM_CheckParm("-d")+1]); | ||
597 | current_mode = get_mode(0, w, h, d); | ||
598 | } | ||
599 | else | ||
600 | current_mode = G320x200x256; | ||
601 | |||
602 | // set vid parameters | ||
603 | VID_SetMode(current_mode, palette); | ||
604 | |||
605 | VID_SetPalette(palette); | ||
606 | |||
607 | // we do want to run in the background when switched away | ||
608 | vga_runinbackground(1); | ||
609 | } | ||
610 | |||
611 | if (COM_CheckParm("-nokbd")) UseKeyboard = 0; | ||
612 | |||
613 | if (UseKeyboard) | ||
614 | { | ||
615 | for (i=0 ; i<128 ; i++) | ||
616 | scantokey[i] = ' '; | ||
617 | |||
618 | scantokey[42] = K_SHIFT; | ||
619 | scantokey[54] = K_SHIFT; | ||
620 | scantokey[72] = K_UPARROW; | ||
621 | scantokey[103] = K_UPARROW; | ||
622 | scantokey[80] = K_DOWNARROW; | ||
623 | scantokey[108] = K_DOWNARROW; | ||
624 | scantokey[75] = K_LEFTARROW; | ||
625 | scantokey[105] = K_LEFTARROW; | ||
626 | scantokey[77] = K_RIGHTARROW; | ||
627 | scantokey[106] = K_RIGHTARROW; | ||
628 | scantokey[29] = K_CTRL; | ||
629 | scantokey[97] = K_CTRL; | ||
630 | scantokey[56] = K_ALT; | ||
631 | scantokey[100] = K_ALT; | ||
632 | // scantokey[58] = JK_CAPS; | ||
633 | // scantokey[69] = JK_NUM_LOCK; | ||
634 | scantokey[71] = K_HOME; | ||
635 | scantokey[73] = K_PGUP; | ||
636 | scantokey[79] = K_END; | ||
637 | scantokey[81] = K_PGDN; | ||
638 | scantokey[82] = K_INS; | ||
639 | scantokey[83] = K_DEL; | ||
640 | scantokey[1 ] = K_ESCAPE; | ||
641 | scantokey[28] = K_ENTER; | ||
642 | scantokey[15] = K_TAB; | ||
643 | scantokey[14] = K_BACKSPACE; | ||
644 | scantokey[119] = K_PAUSE; | ||
645 | scantokey[57] = ' '; | ||
646 | |||
647 | scantokey[102] = K_HOME; | ||
648 | scantokey[104] = K_PGUP; | ||
649 | scantokey[107] = K_END; | ||
650 | scantokey[109] = K_PGDN; | ||
651 | scantokey[110] = K_INS; | ||
652 | scantokey[111] = K_DEL; | ||
653 | |||
654 | scantokey[2] = '1'; | ||
655 | scantokey[3] = '2'; | ||
656 | scantokey[4] = '3'; | ||
657 | scantokey[5] = '4'; | ||
658 | scantokey[6] = '5'; | ||
659 | scantokey[7] = '6'; | ||
660 | scantokey[8] = '7'; | ||
661 | scantokey[9] = '8'; | ||
662 | scantokey[10] = '9'; | ||
663 | scantokey[11] = '0'; | ||
664 | scantokey[12] = '-'; | ||
665 | scantokey[13] = '='; | ||
666 | scantokey[41] = '`'; | ||
667 | scantokey[26] = '['; | ||
668 | scantokey[27] = ']'; | ||
669 | scantokey[39] = ';'; | ||
670 | scantokey[40] = '\''; | ||
671 | scantokey[51] = ','; | ||
672 | scantokey[52] = '.'; | ||
673 | scantokey[53] = '/'; | ||
674 | scantokey[43] = '\\'; | ||
675 | |||
676 | scantokey[59] = K_F1; | ||
677 | scantokey[60] = K_F2; | ||
678 | scantokey[61] = K_F3; | ||
679 | scantokey[62] = K_F4; | ||
680 | scantokey[63] = K_F5; | ||
681 | scantokey[64] = K_F6; | ||
682 | scantokey[65] = K_F7; | ||
683 | scantokey[66] = K_F8; | ||
684 | scantokey[67] = K_F9; | ||
685 | scantokey[68] = K_F10; | ||
686 | scantokey[87] = K_F11; | ||
687 | scantokey[88] = K_F12; | ||
688 | scantokey[30] = 'a'; | ||
689 | scantokey[48] = 'b'; | ||
690 | scantokey[46] = 'c'; | ||
691 | scantokey[32] = 'd'; | ||
692 | scantokey[18] = 'e'; | ||
693 | scantokey[33] = 'f'; | ||
694 | scantokey[34] = 'g'; | ||
695 | scantokey[35] = 'h'; | ||
696 | scantokey[23] = 'i'; | ||
697 | scantokey[36] = 'j'; | ||
698 | scantokey[37] = 'k'; | ||
699 | scantokey[38] = 'l'; | ||
700 | scantokey[50] = 'm'; | ||
701 | scantokey[49] = 'n'; | ||
702 | scantokey[24] = 'o'; | ||
703 | scantokey[25] = 'p'; | ||
704 | scantokey[16] = 'q'; | ||
705 | scantokey[19] = 'r'; | ||
706 | scantokey[31] = 's'; | ||
707 | scantokey[20] = 't'; | ||
708 | scantokey[22] = 'u'; | ||
709 | scantokey[47] = 'v'; | ||
710 | scantokey[17] = 'w'; | ||
711 | scantokey[45] = 'x'; | ||
712 | scantokey[21] = 'y'; | ||
713 | scantokey[44] = 'z'; | ||
714 | |||
715 | if (keyboard_init()) | ||
716 | Sys_Error("keyboard_init() failed"); | ||
717 | keyboard_seteventhandler(keyhandler); | ||
718 | } | ||
719 | |||
720 | } | ||
721 | |||
722 | void VID_Update(vrect_t *rects) | ||
723 | { | ||
724 | if (!svgalib_inited) | ||
725 | return; | ||
726 | |||
727 | if (!vga_oktowrite()) | ||
728 | return; // can't update screen if it's not active | ||
729 | |||
730 | if (vid_waitforrefresh.value) | ||
731 | vga_waitretrace(); | ||
732 | |||
733 | if (VGA_planar) | ||
734 | VGA_UpdatePlanarScreen (vid.buffer); | ||
735 | |||
736 | else if (vid_redrawfull.value) { | ||
737 | int total = vid.rowbytes * vid.height; | ||
738 | int offset; | ||
739 | |||
740 | for (offset=0;offset<total;offset+=0x10000) { | ||
741 | vga_setpage(offset/0x10000); | ||
742 | memcpy(framebuffer_ptr, | ||
743 | vid.buffer + offset, | ||
744 | ((total-offset>0x10000)?0x10000:(total-offset))); | ||
745 | } | ||
746 | } else { | ||
747 | int ycount; | ||
748 | int offset; | ||
749 | int vidpage=0; | ||
750 | |||
751 | vga_setpage(0); | ||
752 | |||
753 | while (rects) | ||
754 | { | ||
755 | ycount = rects->height; | ||
756 | offset = rects->y * vid.rowbytes + rects->x; | ||
757 | while (ycount--) | ||
758 | { | ||
759 | register int i = offset % 0x10000; | ||
760 | |||
761 | if ((offset / 0x10000) != vidpage) { | ||
762 | vidpage=offset / 0x10000; | ||
763 | vga_setpage(vidpage); | ||
764 | } | ||
765 | if (rects->width + i > 0x10000) { | ||
766 | memcpy(framebuffer_ptr + i, | ||
767 | vid.buffer + offset, | ||
768 | 0x10000 - i); | ||
769 | vga_setpage(++vidpage); | ||
770 | memcpy(framebuffer_ptr, | ||
771 | vid.buffer + offset + 0x10000 - i, | ||
772 | rects->width - 0x10000 + i); | ||
773 | } else | ||
774 | memcpy(framebuffer_ptr + i, | ||
775 | vid.buffer + offset, | ||
776 | rects->width); | ||
777 | offset += vid.rowbytes; | ||
778 | } | ||
779 | |||
780 | rects = rects->pnext; | ||
781 | } | ||
782 | } | ||
783 | |||
784 | if (vid_mode.value != current_mode) | ||
785 | VID_SetMode ((int)vid_mode.value, vid_current_palette); | ||
786 | } | ||
787 | |||
788 | static int dither; | ||
789 | |||
790 | void VID_DitherOn(void) | ||
791 | { | ||
792 | if (dither == 0) | ||
793 | { | ||
794 | // R_ViewChanged (&vrect, sb_lines, vid.aspect); | ||
795 | dither = 1; | ||
796 | } | ||
797 | } | ||
798 | |||
799 | void VID_DitherOff(void) | ||
800 | { | ||
801 | if (dither) | ||
802 | { | ||
803 | // R_ViewChanged (&vrect, sb_lines, vid.aspect); | ||
804 | dither = 0; | ||
805 | } | ||
806 | } | ||
807 | |||
808 | void Sys_SendKeyEvents(void) | ||
809 | { | ||
810 | if (!svgalib_inited) | ||
811 | return; | ||
812 | |||
813 | if (UseKeyboard) | ||
814 | while (keyboard_update()); | ||
815 | } | ||
816 | |||
817 | void Force_CenterView_f (void) | ||
818 | { | ||
819 | cl.viewangles[PITCH] = 0; | ||
820 | } | ||
821 | |||
822 | |||
823 | void mousehandler(int buttonstate, int dx, int dy) | ||
824 | { | ||
825 | mouse_buttonstate = buttonstate; | ||
826 | mx += dx; | ||
827 | my += dy; | ||
828 | } | ||
829 | |||
830 | void IN_Init(void) | ||
831 | { | ||
832 | |||
833 | int mtype; | ||
834 | char *mousedev; | ||
835 | int mouserate; | ||
836 | |||
837 | if (UseMouse) | ||
838 | { | ||
839 | |||
840 | Cvar_RegisterVariable (&mouse_button_commands[0]); | ||
841 | Cvar_RegisterVariable (&mouse_button_commands[1]); | ||
842 | Cvar_RegisterVariable (&mouse_button_commands[2]); | ||
843 | Cvar_RegisterVariable (&m_filter); | ||
844 | Cmd_AddCommand ("force_centerview", Force_CenterView_f); | ||
845 | |||
846 | mouse_buttons = 3; | ||
847 | |||
848 | mtype = vga_getmousetype(); | ||
849 | |||
850 | mousedev = "/dev/mouse"; | ||
851 | if (getenv("MOUSEDEV")) mousedev = getenv("MOUSEDEV"); | ||
852 | if (COM_CheckParm("-mdev")) | ||
853 | mousedev = com_argv[COM_CheckParm("-mdev")+1]; | ||
854 | |||
855 | mouserate = 1200; | ||
856 | if (getenv("MOUSERATE")) mouserate = atoi(getenv("MOUSERATE")); | ||
857 | if (COM_CheckParm("-mrate")) | ||
858 | mouserate = atoi(com_argv[COM_CheckParm("-mrate")+1]); | ||
859 | |||
860 | // printf("Mouse: dev=%s,type=%s,speed=%d\n", | ||
861 | // mousedev, mice[mtype].name, mouserate); | ||
862 | if (mouse_init(mousedev, mtype, mouserate)) | ||
863 | { | ||
864 | Con_Printf("No mouse found\n"); | ||
865 | UseMouse = 0; | ||
866 | } | ||
867 | else | ||
868 | mouse_seteventhandler(mousehandler); | ||
869 | |||
870 | } | ||
871 | |||
872 | } | ||
873 | |||
874 | void IN_Shutdown(void) | ||
875 | { | ||
876 | if (UseMouse) | ||
877 | mouse_close(); | ||
878 | } | ||
879 | |||
880 | /* | ||
881 | =========== | ||
882 | IN_Commands | ||
883 | =========== | ||
884 | */ | ||
885 | void IN_Commands (void) | ||
886 | { | ||
887 | if (UseMouse && cls.state != ca_dedicated) | ||
888 | { | ||
889 | // poll mouse values | ||
890 | while (mouse_update()) | ||
891 | ; | ||
892 | |||
893 | // perform button actions | ||
894 | if ((mouse_buttonstate & MOUSE_LEFTBUTTON) && | ||
895 | !(mouse_oldbuttonstate & MOUSE_LEFTBUTTON)) | ||
896 | Key_Event (K_MOUSE1, true); | ||
897 | else if (!(mouse_buttonstate & MOUSE_LEFTBUTTON) && | ||
898 | (mouse_oldbuttonstate & MOUSE_LEFTBUTTON)) | ||
899 | Key_Event (K_MOUSE1, false); | ||
900 | |||
901 | if ((mouse_buttonstate & MOUSE_RIGHTBUTTON) && | ||
902 | !(mouse_oldbuttonstate & MOUSE_RIGHTBUTTON)) | ||
903 | Key_Event (K_MOUSE2, true); | ||
904 | else if (!(mouse_buttonstate & MOUSE_RIGHTBUTTON) && | ||
905 | (mouse_oldbuttonstate & MOUSE_RIGHTBUTTON)) | ||
906 | Key_Event (K_MOUSE2, false); | ||
907 | |||
908 | if ((mouse_buttonstate & MOUSE_MIDDLEBUTTON) && | ||
909 | !(mouse_oldbuttonstate & MOUSE_MIDDLEBUTTON)) | ||
910 | Key_Event (K_MOUSE3, true); | ||
911 | else if (!(mouse_buttonstate & MOUSE_MIDDLEBUTTON) && | ||
912 | (mouse_oldbuttonstate & MOUSE_MIDDLEBUTTON)) | ||
913 | Key_Event (K_MOUSE3, false); | ||
914 | |||
915 | mouse_oldbuttonstate = mouse_buttonstate; | ||
916 | } | ||
917 | } | ||
918 | |||
919 | /* | ||
920 | =========== | ||
921 | IN_Move | ||
922 | =========== | ||
923 | */ | ||
924 | void IN_MouseMove (usercmd_t *cmd) | ||
925 | { | ||
926 | if (!UseMouse) | ||
927 | return; | ||
928 | |||
929 | // poll mouse values | ||
930 | while (mouse_update()) | ||
931 | ; | ||
932 | |||
933 | if (m_filter.value) | ||
934 | { | ||
935 | mouse_x = (mx + old_mouse_x) * 0.5; | ||
936 | mouse_y = (my + old_mouse_y) * 0.5; | ||
937 | } | ||
938 | else | ||
939 | { | ||
940 | mouse_x = mx; | ||
941 | mouse_y = my; | ||
942 | } | ||
943 | old_mouse_x = mx; | ||
944 | old_mouse_y = my; | ||
945 | mx = my = 0; // clear for next update | ||
946 | |||
947 | mouse_x *= sensitivity.value; | ||
948 | mouse_y *= sensitivity.value; | ||
949 | |||
950 | // add mouse X/Y movement to cmd | ||
951 | if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) )) | ||
952 | cmd->sidemove += m_side.value * mouse_x; | ||
953 | else | ||
954 | cl.viewangles[YAW] -= m_yaw.value * mouse_x; | ||
955 | |||
956 | if (in_mlook.state & 1) | ||
957 | V_StopPitchDrift (); | ||
958 | |||
959 | if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) | ||
960 | { | ||
961 | cl.viewangles[PITCH] += m_pitch.value * mouse_y; | ||
962 | if (cl.viewangles[PITCH] > 80) | ||
963 | cl.viewangles[PITCH] = 80; | ||
964 | if (cl.viewangles[PITCH] < -70) | ||
965 | cl.viewangles[PITCH] = -70; | ||
966 | } | ||
967 | else | ||
968 | { | ||
969 | if ((in_strafe.state & 1) && noclip_anglehack) | ||
970 | cmd->upmove -= m_forward.value * mouse_y; | ||
971 | else | ||
972 | cmd->forwardmove -= m_forward.value * mouse_y; | ||
973 | } | ||
974 | } | ||
975 | |||
976 | void IN_Move (usercmd_t *cmd) | ||
977 | { | ||
978 | IN_MouseMove(cmd); | ||
979 | } | ||
980 | |||
981 | |||
982 | /* | ||
983 | ================ | ||
984 | VID_ModeInfo | ||
985 | ================ | ||
986 | */ | ||
987 | char *VID_ModeInfo (int modenum) | ||
988 | { | ||
989 | static char *badmodestr = "Bad mode number"; | ||
990 | static char modestr[40]; | ||
991 | |||
992 | if (modenum == 0) | ||
993 | { | ||
994 | sprintf (modestr, "%d x %d, %d bpp", | ||
995 | vid.width, vid.height, modes[current_mode].bytesperpixel*8); | ||
996 | return (modestr); | ||
997 | } | ||
998 | else | ||
999 | { | ||
1000 | return (badmodestr); | ||
1001 | } | ||
1002 | } | ||
1003 | |||