qf/nuq
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/nuq synced 2024-11-25 13:31:19 +00:00
Code Issues Projects Releases Packages Wiki Activity
nuq/source/vid_svgalib.c
Bill Currie 111c1b0d4c un-dosify
2000-08-20 01:33:10 +00:00

1007 lines
21 KiB
C
Raw Blame History

/*
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.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#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);
}
}
Reference in a new issue View git blame Copy permalink