aboutsummaryrefslogtreecommitdiffstats
path: root/WinQuake/vid_svgalib.c
diff options
context:
space:
mode:
Diffstat (limited to 'WinQuake/vid_svgalib.c')
-rw-r--r--WinQuake/vid_svgalib.c1003
1 files changed, 1003 insertions, 0 deletions
diff --git a/WinQuake/vid_svgalib.c b/WinQuake/vid_svgalib.c
new file mode 100644
index 0000000..e0fea3a
--- /dev/null
+++ b/WinQuake/vid_svgalib.c
@@ -0,0 +1,1003 @@
+/*
+Copyright (C) 1996-1997 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+*/
+#include <termios.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/vt.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <signal.h>
+
+#include <asm/io.h>
+
+#include "vga.h"
+#include "vgakeyboard.h"
+#include "vgamouse.h"
+
+#include "quakedef.h"
+#include "d_local.h"
+
+#define stringify(m) { #m, m }
+
+unsigned short d_8to16table[256];
+static byte *vid_surfcache;
+static int VID_highhunkmark;
+
+int num_modes;
+vga_modeinfo *modes;
+int current_mode;
+
+int num_shades=32;
+
+struct
+{
+ char *name;
+ int num;
+} mice[] =
+{
+ stringify(MOUSE_MICROSOFT),
+ stringify(MOUSE_MOUSESYSTEMS),
+ stringify(MOUSE_MMSERIES),
+ stringify(MOUSE_LOGITECH),
+ stringify(MOUSE_BUSMOUSE),
+ stringify(MOUSE_PS2),
+};
+
+static unsigned char scantokey[128];
+static byte vid_current_palette[768];
+
+int num_mice = sizeof (mice) / sizeof(mice[0]);
+
+int d_con_indirect = 0;
+
+int svgalib_inited=0;
+int UseMouse = 1;
+int UseDisplay = 1;
+int UseKeyboard = 1;
+
+int mouserate = MOUSE_DEFAULTSAMPLERATE;
+
+cvar_t vid_mode = {"vid_mode","5",false};
+cvar_t vid_redrawfull = {"vid_redrawfull","0",false};
+cvar_t vid_waitforrefresh = {"vid_waitforrefresh","0",true};
+
+char *framebuffer_ptr;
+
+cvar_t mouse_button_commands[3] =
+{
+ {"mouse1","+attack"},
+ {"mouse2","+strafe"},
+ {"mouse3","+forward"},
+};
+
+int mouse_buttons;
+int mouse_buttonstate;
+int mouse_oldbuttonstate;
+float mouse_x, mouse_y;
+float old_mouse_x, old_mouse_y;
+int mx, my;
+
+cvar_t m_filter = {"m_filter","0"};
+
+static byte backingbuf[48*24];
+
+int VGA_width, VGA_height, VGA_rowbytes, VGA_bufferrowbytes, VGA_planar;
+byte *VGA_pagebase;
+
+void VGA_UpdatePlanarScreen (void *srcbuffer);
+
+void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
+{
+ int i, j, k, plane, reps, repshift, offset, vidpage, off;
+
+ if (!svgalib_inited || !vid.direct || !vga_oktowrite()) return;
+
+ if (vid.aspect > 1.5)
+ {
+ reps = 2;
+ repshift = 1;
+ } else {
+ reps = 1;
+ repshift = 0;
+ }
+
+ vidpage = 0;
+ vga_setpage(0);
+
+ if (VGA_planar)
+ {
+ for (plane=0 ; plane<4 ; plane++)
+ {
+ // select the correct plane for reading and writing
+ outb(0x02, 0x3C4);
+ outb(1 << plane, 0x3C5);
+ outb(4, 0x3CE);
+ outb(plane, 0x3CF);
+
+ for (i=0 ; i<(height << repshift) ; i += reps)
+ {
+ for (k=0 ; k<reps ; k++)
+ {
+ for (j=0 ; j<(width >> 2) ; j++)
+ {
+ backingbuf[(i + k) * 24 + (j << 2) + plane] =
+ vid.direct[(y + i + k) * VGA_rowbytes +
+ (x >> 2) + j];
+ vid.direct[(y + i + k) * VGA_rowbytes + (x>>2) + j] =
+ pbitmap[(i >> repshift) * 24 +
+ (j << 2) + plane];
+ }
+ }
+ }
+ }
+ } else {
+ for (i=0 ; i<(height << repshift) ; i += reps)
+ {
+ for (j=0 ; j<reps ; j++)
+ {
+ offset = x + ((y << repshift) + i + j) * vid.rowbytes;
+ off = offset % 0x10000;
+ if ((offset / 0x10000) != vidpage) {
+ vidpage=offset / 0x10000;
+ vga_setpage(vidpage);
+ }
+ memcpy (&backingbuf[(i + j) * 24],
+ vid.direct + off, width);
+ memcpy (vid.direct + off,
+ &pbitmap[(i >> repshift)*width], width);
+ }
+ }
+ }
+}
+
+void D_EndDirectRect (int x, int y, int width, int height)
+{
+ int i, j, k, plane, reps, repshift, offset, vidpage, off;
+
+ if (!svgalib_inited || !vid.direct || !vga_oktowrite()) return;
+
+ if (vid.aspect > 1.5)
+ {
+ reps = 2;
+ repshift = 1;
+ } else {
+ reps = 1;
+ repshift = 0;
+ }
+
+ vidpage = 0;
+ vga_setpage(0);
+
+ if (VGA_planar)
+ {
+ for (plane=0 ; plane<4 ; plane++)
+ {
+ // select the correct plane for writing
+ outb(2, 0x3C4);
+ outb(1 << plane, 0x3C5);
+ outb(4, 0x3CE);
+ outb(plane, 0x3CF);
+
+ for (i=0 ; i<(height << repshift) ; i += reps)
+ {
+ for (k=0 ; k<reps ; k++)
+ {
+ for (j=0 ; j<(width >> 2) ; j++)
+ {
+ vid.direct[(y + i + k) * VGA_rowbytes + (x>>2) + j] =
+ backingbuf[(i + k) * 24 + (j << 2) + plane];
+ }
+ }
+ }
+ }
+ } else {
+ for (i=0 ; i<(height << repshift) ; i += reps)
+ {
+ for (j=0 ; j<reps ; j++)
+ {
+ offset = x + ((y << repshift) + i + j) * vid.rowbytes;
+ off = offset % 0x10000;
+ if ((offset / 0x10000) != vidpage) {
+ vidpage=offset / 0x10000;
+ vga_setpage(vidpage);
+ }
+ memcpy (vid.direct + off,
+ &backingbuf[(i +j)*24],
+ width);
+ }
+ }
+ }
+}
+
+/*
+=================
+VID_Gamma_f
+
+Keybinding command
+=================
+*/
+void VID_Gamma_f (void)
+{
+ float gamma, f, inf;
+ unsigned char palette[768];
+ int i;
+
+ if (Cmd_Argc () == 2)
+ {
+ gamma = Q_atof (Cmd_Argv(1));
+
+ for (i=0 ; i<768 ; i++)
+ {
+ f = pow ( (host_basepal[i]+1)/256.0 , gamma );
+ inf = f*255 + 0.5;
+ if (inf < 0)
+ inf = 0;
+ if (inf > 255)
+ inf = 255;
+ palette[i] = inf;
+ }
+
+ VID_SetPalette (palette);
+
+ vid.recalc_refdef = 1; // force a surface cache flush
+ }
+}
+
+void VID_DescribeMode_f (void)
+{
+ int modenum;
+
+ modenum = Q_atoi (Cmd_Argv(1));
+ if ((modenum >= num_modes) || (modenum < 0 ) || !modes[modenum].width)
+ Con_Printf("Invalid video mode: %d!\n",modenum);
+ Con_Printf("%d: %d x %d - ",modenum,modes[modenum].width,modes[modenum].height);
+ if (modes[modenum].bytesperpixel == 0)
+ Con_Printf("ModeX\n");
+ else
+ Con_Printf("%d bpp\n", modes[modenum].bytesperpixel<<3);
+}
+
+void VID_DescribeModes_f (void)
+{
+ int i;
+
+ for (i=0;i<num_modes;i++)
+ if (modes[i].width) {
+ Con_Printf("%d: %d x %d - ", i, modes[i].width,modes[i].height);
+ if (modes[i].bytesperpixel == 0)
+ Con_Printf("ModeX\n");
+ else
+ Con_Printf("%d bpp\n", modes[i].bytesperpixel<<3);
+ }
+}
+
+/*
+================
+VID_NumModes
+================
+*/
+int VID_NumModes ()
+{
+ int i,i1=0;
+
+ for (i=0;i<num_modes;i++)
+ i1+=(modes[i].width?1:0);
+ return (i1);
+}
+
+void VID_NumModes_f (void)
+{
+ Con_Printf("%d modes\n",VID_NumModes());
+}
+
+void VID_Debug_f (void)
+{
+ Con_Printf("mode: %d\n",current_mode);
+ Con_Printf("height x width: %d x %d\n",vid.height,vid.width);
+ Con_Printf("bpp: %d\n",modes[current_mode].bytesperpixel*8);
+ Con_Printf("vid.aspect: %f\n",vid.aspect);
+}
+
+
+
+void VID_InitModes(void)
+{
+
+ int i;
+
+// get complete information on all modes
+
+ num_modes = vga_lastmodenumber()+1;
+ modes = Z_Malloc(num_modes * sizeof(vga_modeinfo));
+ for (i=0 ; i<num_modes ; i++)
+ {
+ if (vga_hasmode(i))
+ Q_memcpy(&modes[i], vga_getmodeinfo(i), sizeof (vga_modeinfo));
+ else
+ modes[i].width = 0; // means not available
+ }
+
+// filter for modes i don't support
+
+ for (i=0 ; i<num_modes ; i++)
+ {
+ if (modes[i].bytesperpixel != 1 && modes[i].colors != 256)
+ modes[i].width = 0;
+ }
+
+}
+
+int get_mode(char *name, int width, int height, int depth)
+{
+
+ int i;
+ int ok, match;
+
+ match = (!!width) + (!!height)*2 + (!!depth)*4;
+
+ if (name)
+ {
+ i = vga_getmodenumber(name);
+ if (!modes[i].width)
+ {
+ Sys_Printf("Mode [%s] not supported\n", name);
+ i = G320x200x256;
+ }
+ }
+ else
+ {
+ for (i=0 ; i<num_modes ; i++)
+ if (modes[i].width)
+ {
+ ok = (modes[i].width == width)
+ + (modes[i].height == height)*2
+ + (modes[i].bytesperpixel == depth/8)*4;
+ if ((ok & match) == ok)
+ break;
+ }
+ if (i==num_modes)
+ {
+ Sys_Printf("Mode %dx%d (%d bits) not supported\n",
+ width, height, depth);
+ i = G320x200x256;
+ }
+ }
+
+ return i;
+
+}
+
+int matchmouse(int mouse, char *name)
+{
+ int i;
+ for (i=0 ; i<num_mice ; i++)
+ if (!strcmp(mice[i].name, name))
+ return i;
+ return mouse;
+}
+
+#if 0
+
+void vtswitch(int newconsole)
+{
+
+ int fd;
+ struct vt_stat x;
+
+// switch consoles and wait until reactivated
+ fd = open("/dev/console", O_RDONLY);
+ ioctl(fd, VT_GETSTATE, &x);
+ ioctl(fd, VT_ACTIVATE, newconsole);
+ ioctl(fd, VT_WAITACTIVE, x.v_active);
+ close(fd);
+
+}
+
+#endif
+
+void keyhandler(int scancode, int state)
+{
+
+ int sc;
+
+ sc = scancode & 0x7f;
+// Con_Printf("scancode=%x (%d%s)\n", scancode, sc, scancode&0x80?"+128":"");
+ Key_Event(scantokey[sc], state == KEY_EVENTPRESS);
+
+}
+
+void VID_Shutdown(void)
+{
+
+ if (!svgalib_inited) return;
+
+// printf("shutdown graphics called\n");
+ if (UseKeyboard)
+ keyboard_close();
+ if (UseDisplay)
+ vga_setmode(TEXT);
+// printf("shutdown graphics finished\n");
+
+ svgalib_inited = 0;
+
+}
+
+void VID_ShiftPalette(unsigned char *p)
+{
+ VID_SetPalette(p);
+}
+
+void VID_SetPalette(byte *palette)
+{
+
+ static int tmppal[256*3];
+ int *tp;
+ int i;
+
+ if (!svgalib_inited)
+ return;
+
+ memcpy(vid_current_palette, palette, sizeof(vid_current_palette));
+
+ if (vga_getcolors() == 256)
+ {
+
+ tp = tmppal;
+ for (i=256*3 ; i ; i--)
+ *(tp++) = *(palette++) >> 2;
+
+ if (UseDisplay && vga_oktowrite())
+ vga_setpalvec(0, 256, tmppal);
+
+ }
+}
+
+int VID_SetMode (int modenum, unsigned char *palette)
+{
+ int bsize, zsize, tsize;
+
+ if ((modenum >= num_modes) || (modenum < 0) || !modes[modenum].width)
+ {
+ Cvar_SetValue ("vid_mode", (float)current_mode);
+
+ Con_Printf("No such video mode: %d\n",modenum);
+
+ return 0;
+ }
+
+ Cvar_SetValue ("vid_mode", (float)modenum);
+
+ current_mode=modenum;
+
+ vid.width = modes[current_mode].width;
+ vid.height = modes[current_mode].height;
+
+ VGA_width = modes[current_mode].width;
+ VGA_height = modes[current_mode].height;
+ VGA_planar = modes[current_mode].bytesperpixel == 0;
+ VGA_rowbytes = modes[current_mode].linewidth;
+ vid.rowbytes = modes[current_mode].linewidth;
+ if (VGA_planar) {
+ VGA_bufferrowbytes = modes[current_mode].linewidth * 4;
+ vid.rowbytes = modes[current_mode].linewidth*4;
+ }
+
+ vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
+ vid.colormap = (pixel_t *) host_colormap;
+ vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
+ vid.conrowbytes = vid.rowbytes;
+ vid.conwidth = vid.width;
+ vid.conheight = vid.height;
+ vid.numpages = 1;
+
+ vid.maxwarpwidth = WARP_WIDTH;
+ vid.maxwarpheight = WARP_HEIGHT;
+
+ // alloc zbuffer and surface cache
+ if (d_pzbuffer) {
+ D_FlushCaches();
+ Hunk_FreeToHighMark (VID_highhunkmark);
+ d_pzbuffer = NULL;
+ vid_surfcache = NULL;
+ }
+
+ bsize = vid.rowbytes * vid.height;
+ tsize = D_SurfaceCacheForRes (vid.width, vid.height);
+ zsize = vid.width * vid.height * sizeof(*d_pzbuffer);
+
+ VID_highhunkmark = Hunk_HighMark ();
+
+ d_pzbuffer = Hunk_HighAllocName (bsize+tsize+zsize, "video");
+
+ vid_surfcache = ((byte *)d_pzbuffer) + zsize;
+
+ vid.conbuffer = vid.buffer = (pixel_t *)(((byte *)d_pzbuffer) + zsize + tsize);
+
+ D_InitCaches (vid_surfcache, tsize);
+
+// get goin'
+
+ vga_setmode(current_mode);
+ VID_SetPalette(palette);
+
+ VGA_pagebase = vid.direct = framebuffer_ptr = (char *) vga_getgraphmem();
+// if (vga_setlinearaddressing()>0)
+// framebuffer_ptr = (char *) vga_getgraphmem();
+ if (!framebuffer_ptr)
+ Sys_Error("This mode isn't hapnin'\n");
+
+ vga_setpage(0);
+
+ svgalib_inited=1;
+
+ vid.recalc_refdef = 1; // force a surface cache flush
+
+ return 0;
+}
+
+void VID_Init(unsigned char *palette)
+{
+
+ int i;
+ int w, h, d;
+
+ if (svgalib_inited)
+ return;
+
+// Cmd_AddCommand ("gamma", VID_Gamma_f);
+
+ if (UseDisplay)
+ {
+ vga_init();
+
+ VID_InitModes();
+
+ Cvar_RegisterVariable (&vid_mode);
+ Cvar_RegisterVariable (&vid_redrawfull);
+ Cvar_RegisterVariable (&vid_waitforrefresh);
+
+ Cmd_AddCommand("vid_nummodes", VID_NumModes_f);
+ Cmd_AddCommand("vid_describemode", VID_DescribeMode_f);
+ Cmd_AddCommand("vid_describemodes", VID_DescribeModes_f);
+ Cmd_AddCommand("vid_debug", VID_Debug_f);
+
+ // interpret command-line params
+
+ w = h = d = 0;
+ if (getenv("GSVGAMODE"))
+ current_mode = get_mode(getenv("GSVGAMODE"), w, h, d);
+ else if (COM_CheckParm("-mode"))
+ current_mode = get_mode(com_argv[COM_CheckParm("-mode")+1], w, h, d);
+ else if (COM_CheckParm("-w") || COM_CheckParm("-h")
+ || COM_CheckParm("-d"))
+ {
+ if (COM_CheckParm("-w"))
+ w = Q_atoi(com_argv[COM_CheckParm("-w")+1]);
+ if (COM_CheckParm("-h"))
+ h = Q_atoi(com_argv[COM_CheckParm("-h")+1]);
+ if (COM_CheckParm("-d"))
+ d = Q_atoi(com_argv[COM_CheckParm("-d")+1]);
+ current_mode = get_mode(0, w, h, d);
+ }
+ else
+ current_mode = G320x200x256;
+
+ // set vid parameters
+ VID_SetMode(current_mode, palette);
+
+ VID_SetPalette(palette);
+
+ // we do want to run in the background when switched away
+ vga_runinbackground(1);
+ }
+
+ if (COM_CheckParm("-nokbd")) UseKeyboard = 0;
+
+ if (UseKeyboard)
+ {
+ for (i=0 ; i<128 ; i++)
+ scantokey[i] = ' ';
+
+ scantokey[42] = K_SHIFT;
+ scantokey[54] = K_SHIFT;
+ scantokey[72] = K_UPARROW;
+ scantokey[103] = K_UPARROW;
+ scantokey[80] = K_DOWNARROW;
+ scantokey[108] = K_DOWNARROW;
+ scantokey[75] = K_LEFTARROW;
+ scantokey[105] = K_LEFTARROW;
+ scantokey[77] = K_RIGHTARROW;
+ scantokey[106] = K_RIGHTARROW;
+ scantokey[29] = K_CTRL;
+ scantokey[97] = K_CTRL;
+ scantokey[56] = K_ALT;
+ scantokey[100] = K_ALT;
+// scantokey[58] = JK_CAPS;
+// scantokey[69] = JK_NUM_LOCK;
+ scantokey[71] = K_HOME;
+ scantokey[73] = K_PGUP;
+ scantokey[79] = K_END;
+ scantokey[81] = K_PGDN;
+ scantokey[82] = K_INS;
+ scantokey[83] = K_DEL;
+ scantokey[1 ] = K_ESCAPE;
+ scantokey[28] = K_ENTER;
+ scantokey[15] = K_TAB;
+ scantokey[14] = K_BACKSPACE;
+ scantokey[119] = K_PAUSE;
+ scantokey[57] = ' ';
+
+ scantokey[102] = K_HOME;
+ scantokey[104] = K_PGUP;
+ scantokey[107] = K_END;
+ scantokey[109] = K_PGDN;
+ scantokey[110] = K_INS;
+ scantokey[111] = K_DEL;
+
+ scantokey[2] = '1';
+ scantokey[3] = '2';
+ scantokey[4] = '3';
+ scantokey[5] = '4';
+ scantokey[6] = '5';
+ scantokey[7] = '6';
+ scantokey[8] = '7';
+ scantokey[9] = '8';
+ scantokey[10] = '9';
+ scantokey[11] = '0';
+ scantokey[12] = '-';
+ scantokey[13] = '=';
+ scantokey[41] = '`';
+ scantokey[26] = '[';
+ scantokey[27] = ']';
+ scantokey[39] = ';';
+ scantokey[40] = '\'';
+ scantokey[51] = ',';
+ scantokey[52] = '.';
+ scantokey[53] = '/';
+ scantokey[43] = '\\';
+
+ scantokey[59] = K_F1;
+ scantokey[60] = K_F2;
+ scantokey[61] = K_F3;
+ scantokey[62] = K_F4;
+ scantokey[63] = K_F5;
+ scantokey[64] = K_F6;
+ scantokey[65] = K_F7;
+ scantokey[66] = K_F8;
+ scantokey[67] = K_F9;
+ scantokey[68] = K_F10;
+ scantokey[87] = K_F11;
+ scantokey[88] = K_F12;
+ scantokey[30] = 'a';
+ scantokey[48] = 'b';
+ scantokey[46] = 'c';
+ scantokey[32] = 'd';
+ scantokey[18] = 'e';
+ scantokey[33] = 'f';
+ scantokey[34] = 'g';
+ scantokey[35] = 'h';
+ scantokey[23] = 'i';
+ scantokey[36] = 'j';
+ scantokey[37] = 'k';
+ scantokey[38] = 'l';
+ scantokey[50] = 'm';
+ scantokey[49] = 'n';
+ scantokey[24] = 'o';
+ scantokey[25] = 'p';
+ scantokey[16] = 'q';
+ scantokey[19] = 'r';
+ scantokey[31] = 's';
+ scantokey[20] = 't';
+ scantokey[22] = 'u';
+ scantokey[47] = 'v';
+ scantokey[17] = 'w';
+ scantokey[45] = 'x';
+ scantokey[21] = 'y';
+ scantokey[44] = 'z';
+
+ if (keyboard_init())
+ Sys_Error("keyboard_init() failed");
+ keyboard_seteventhandler(keyhandler);
+ }
+
+}
+
+void VID_Update(vrect_t *rects)
+{
+ if (!svgalib_inited)
+ return;
+
+ if (!vga_oktowrite())
+ return; // can't update screen if it's not active
+
+ if (vid_waitforrefresh.value)
+ vga_waitretrace();
+
+ if (VGA_planar)
+ VGA_UpdatePlanarScreen (vid.buffer);
+
+ else if (vid_redrawfull.value) {
+ int total = vid.rowbytes * vid.height;
+ int offset;
+
+ for (offset=0;offset<total;offset+=0x10000) {
+ vga_setpage(offset/0x10000);
+ memcpy(framebuffer_ptr,
+ vid.buffer + offset,
+ ((total-offset>0x10000)?0x10000:(total-offset)));
+ }
+ } else {
+ int ycount;
+ int offset;
+ int vidpage=0;
+
+ vga_setpage(0);
+
+ while (rects)
+ {
+ ycount = rects->height;
+ offset = rects->y * vid.rowbytes + rects->x;
+ while (ycount--)
+ {
+ register int i = offset % 0x10000;
+
+ if ((offset / 0x10000) != vidpage) {
+ vidpage=offset / 0x10000;
+ vga_setpage(vidpage);
+ }
+ if (rects->width + i > 0x10000) {
+ memcpy(framebuffer_ptr + i,
+ vid.buffer + offset,
+ 0x10000 - i);
+ vga_setpage(++vidpage);
+ memcpy(framebuffer_ptr,
+ vid.buffer + offset + 0x10000 - i,
+ rects->width - 0x10000 + i);
+ } else
+ memcpy(framebuffer_ptr + i,
+ vid.buffer + offset,
+ rects->width);
+ offset += vid.rowbytes;
+ }
+
+ rects = rects->pnext;
+ }
+ }
+
+ if (vid_mode.value != current_mode)
+ VID_SetMode ((int)vid_mode.value, vid_current_palette);
+}
+
+static int dither;
+
+void VID_DitherOn(void)
+{
+ if (dither == 0)
+ {
+// R_ViewChanged (&vrect, sb_lines, vid.aspect);
+ dither = 1;
+ }
+}
+
+void VID_DitherOff(void)
+{
+ if (dither)
+ {
+// R_ViewChanged (&vrect, sb_lines, vid.aspect);
+ dither = 0;
+ }
+}
+
+void Sys_SendKeyEvents(void)
+{
+ if (!svgalib_inited)
+ return;
+
+ if (UseKeyboard)
+ while (keyboard_update());
+}
+
+void Force_CenterView_f (void)
+{
+ cl.viewangles[PITCH] = 0;
+}
+
+
+void mousehandler(int buttonstate, int dx, int dy)
+{
+ mouse_buttonstate = buttonstate;
+ mx += dx;
+ my += dy;
+}
+
+void IN_Init(void)
+{
+
+ int mtype;
+ char *mousedev;
+ int mouserate;
+
+ if (UseMouse)
+ {
+
+ Cvar_RegisterVariable (&mouse_button_commands[0]);
+ Cvar_RegisterVariable (&mouse_button_commands[1]);
+ Cvar_RegisterVariable (&mouse_button_commands[2]);
+ Cvar_RegisterVariable (&m_filter);
+ Cmd_AddCommand ("force_centerview", Force_CenterView_f);
+
+ mouse_buttons = 3;
+
+ mtype = vga_getmousetype();
+
+ mousedev = "/dev/mouse";
+ if (getenv("MOUSEDEV")) mousedev = getenv("MOUSEDEV");
+ if (COM_CheckParm("-mdev"))
+ mousedev = com_argv[COM_CheckParm("-mdev")+1];
+
+ mouserate = 1200;
+ if (getenv("MOUSERATE")) mouserate = atoi(getenv("MOUSERATE"));
+ if (COM_CheckParm("-mrate"))
+ mouserate = atoi(com_argv[COM_CheckParm("-mrate")+1]);
+
+// printf("Mouse: dev=%s,type=%s,speed=%d\n",
+// mousedev, mice[mtype].name, mouserate);
+ if (mouse_init(mousedev, mtype, mouserate))
+ {
+ Con_Printf("No mouse found\n");
+ UseMouse = 0;
+ }
+ else
+ mouse_seteventhandler(mousehandler);
+
+ }
+
+}
+
+void IN_Shutdown(void)
+{
+ if (UseMouse)
+ mouse_close();
+}
+
+/*
+===========
+IN_Commands
+===========
+*/
+void IN_Commands (void)
+{
+ if (UseMouse && cls.state != ca_dedicated)
+ {
+ // poll mouse values
+ while (mouse_update())
+ ;
+
+ // perform button actions
+ if ((mouse_buttonstate & MOUSE_LEFTBUTTON) &&
+ !(mouse_oldbuttonstate & MOUSE_LEFTBUTTON))
+ Key_Event (K_MOUSE1, true);
+ else if (!(mouse_buttonstate & MOUSE_LEFTBUTTON) &&
+ (mouse_oldbuttonstate & MOUSE_LEFTBUTTON))
+ Key_Event (K_MOUSE1, false);
+
+ if ((mouse_buttonstate & MOUSE_RIGHTBUTTON) &&
+ !(mouse_oldbuttonstate & MOUSE_RIGHTBUTTON))
+ Key_Event (K_MOUSE2, true);
+ else if (!(mouse_buttonstate & MOUSE_RIGHTBUTTON) &&
+ (mouse_oldbuttonstate & MOUSE_RIGHTBUTTON))
+ Key_Event (K_MOUSE2, false);
+
+ if ((mouse_buttonstate & MOUSE_MIDDLEBUTTON) &&
+ !(mouse_oldbuttonstate & MOUSE_MIDDLEBUTTON))
+ Key_Event (K_MOUSE3, true);
+ else if (!(mouse_buttonstate & MOUSE_MIDDLEBUTTON) &&
+ (mouse_oldbuttonstate & MOUSE_MIDDLEBUTTON))
+ Key_Event (K_MOUSE3, false);
+
+ mouse_oldbuttonstate = mouse_buttonstate;
+ }
+}
+
+/*
+===========
+IN_Move
+===========
+*/
+void IN_MouseMove (usercmd_t *cmd)
+{
+ if (!UseMouse)
+ return;
+
+ // poll mouse values
+ while (mouse_update())
+ ;
+
+ if (m_filter.value)
+ {
+ mouse_x = (mx + old_mouse_x) * 0.5;
+ mouse_y = (my + old_mouse_y) * 0.5;
+ }
+ else
+ {
+ mouse_x = mx;
+ mouse_y = my;
+ }
+ old_mouse_x = mx;
+ old_mouse_y = my;
+ mx = my = 0; // clear for next update
+
+ mouse_x *= sensitivity.value;
+ mouse_y *= sensitivity.value;
+
+// add mouse X/Y movement to cmd
+ if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
+ cmd->sidemove += m_side.value * mouse_x;
+ else
+ cl.viewangles[YAW] -= m_yaw.value * mouse_x;
+
+ if (in_mlook.state & 1)
+ V_StopPitchDrift ();
+
+ if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
+ {
+ cl.viewangles[PITCH] += m_pitch.value * mouse_y;
+ if (cl.viewangles[PITCH] > 80)
+ cl.viewangles[PITCH] = 80;
+ if (cl.viewangles[PITCH] < -70)
+ cl.viewangles[PITCH] = -70;
+ }
+ else
+ {
+ if ((in_strafe.state & 1) && noclip_anglehack)
+ cmd->upmove -= m_forward.value * mouse_y;
+ else
+ cmd->forwardmove -= m_forward.value * mouse_y;
+ }
+}
+
+void IN_Move (usercmd_t *cmd)
+{
+ IN_MouseMove(cmd);
+}
+
+
+/*
+================
+VID_ModeInfo
+================
+*/
+char *VID_ModeInfo (int modenum)
+{
+ static char *badmodestr = "Bad mode number";
+ static char modestr[40];
+
+ if (modenum == 0)
+ {
+ sprintf (modestr, "%d x %d, %d bpp",
+ vid.width, vid.height, modes[current_mode].bytesperpixel*8);
+ return (modestr);
+ }
+ else
+ {
+ return (badmodestr);
+ }
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2026-10-05 23:45:19 +0000