qf
/
newtree
mirror of https://git.code.sf.net/p/quake/newtree
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
newtree/source/vid_ggi.c

1170 lines
24 KiB
C
Raw Blame History

/*
vid_ggi.c
general LibGGI video driver
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 1999 Marcus Sundberg [mackan@stacken.kth.se]
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
#define _BSD
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ggi/ggi.h>
#include "bothdefs.h" // needed by: common.h, net.h,
// client.h
#include "bspfile.h" // needed by: glquake.h
#include "vid.h"
#include "sys.h"
#include "mathlib.h" // needed by: protocol.h, render.h,
// client.h,
// modelgen.h, glmodel.h
#include "wad.h"
#include "draw.h"
#include "cvar.h"
#include "net.h" // needed by: client.h
#include "protocol.h" // needed by: client.h
#include "cmd.h"
#include "host.h"
#include "keys.h"
#include "sbar.h"
#include "sound.h"
#include "render.h" // needed by: client.h, gl_model.h,
// glquake.h
#include "client.h" // need cls in this file
#include "model.h" // needed by: glquake.h
#include "console.h"
#include "qendian.h"
#include "qargs.h"
#include "compat.h"
#include "d_local.h"
#include "input.h"
#include "cl_input.h"
#include "view.h"
#include "joystick.h"
extern viddef_t vid; // global video state
unsigned short d_8to16table[256];
cvar_t *m_filter;
cvar_t *_windowed_mouse;
/* Unused */
int VGA_width, VGA_height, VGA_rowbytes, VGA_bufferrowbytes, VGA_planar;
byte *VGA_pagebase;
#define NUM_STDBUTTONS 3
#define NUM_BUTTONS 10
static qboolean mouse_avail;
static float mouse_x, mouse_y;
static float old_mouse_x, old_mouse_y;
static int p_mouse_x, p_mouse_y;
static float old_windowed_mouse;
static ggi_visual_t ggivis = NULL;
static ggi_mode mode;
static const ggi_directbuffer *dbuf1 = NULL, *dbuf2 = NULL;
static uint8 *drawptr = NULL;
static void *frameptr[2] = { NULL, NULL };
static void *oneline = NULL;
static void *palette = NULL;
static int curframe = 0;
static int realwidth, realheight;
static int doublebuffer;
static int scale;
static int stride, drawstride;
static int pixelsize;
static int usedbuf, havedbuf;
int VID_options_items = 1;
static void
do_scale8 (int xsize, int ysize, uint8 * dest, uint8 * src)
{
int i, j, destinc = stride * 2 - xsize * 2;
for (j = 0; j < ysize; j++) {
for (i = 0; i < xsize; /* i is incremented below */ ) {
register uint32 pix1 = src[i++], pix2 = src[i++];
#ifdef GGI_LITTLE_ENDIAN
*((uint32 *) (dest + stride))
= *((uint32 *) dest)
= (pix1 | (pix1 << 8)
| (pix2 << 16) | (pix2 << 24));
#else
*((uint32 *) (dest + stride))
= *((uint32 *) dest)
= (pix2 | (pix2 << 8)
| (pix1 << 16) | (pix1 << 24));
#endif
dest += 4;
}
dest += destinc;
src += xsize;
}
}
static void
do_scale16 (int xsize, int ysize, uint8 * dest, uint8 * src)
{
int i, j, destinc = stride * 2 - xsize * 4;
uint16 *palptr = palette;
for (j = 0; j < ysize; j++) {
for (i = 0; i < xsize; /* i is incremented below */ ) {
register uint32 pixel = palptr[src[i++]];
*((uint32 *) (dest + stride))
= *((uint32 *) dest)
= pixel | (pixel << 16);
dest += 4;
}
dest += destinc;
src += xsize;
}
}
static void
do_scale32 (int xsize, int ysize, uint8 * dest, uint8 * src)
{
int i, j, destinc = stride * 2 - xsize * 8;
uint32 *palptr = palette;
for (j = 0; j < ysize; j++) {
for (i = 0; i < xsize; /* i is incremented below */ ) {
register uint32 pixel = palptr[src[i++]];
*((uint32 *) (dest + stride))
= *((uint32 *) (dest)) = pixel;
dest += 4;
*((uint32 *) (dest + stride))
= *((uint32 *) (dest)) = pixel;
dest += 4;
}
dest += destinc;
src += xsize;
}
}
static void
do_copy8 (int xsize, int ysize, uint8 * dest, uint8 * src)
{
int i, j;
uint8 *palptr = palette;
for (j = 0; j < ysize; j++) {
for (i = 0; i < xsize; i++) {
dest[i] = palptr[src[i]];
}
dest += stride;
src += xsize;
}
}
static void
do_copy16 (int xsize, int ysize, void *destptr, uint8 * src)
{
int i, j, destinc = (stride / 2 - xsize) / 2;
uint16 *palptr = palette;
uint32 *dest = destptr;
for (j = 0; j < ysize; j++) {
for (i = 0; i < xsize; /* i is incremented below */ ) {
register uint32 pixel = palptr[src[i++]];
#ifdef GGI_LITTLE_ENDIAN
*(dest++) = pixel | (palptr[src[i++]] << 16);
#else
*(dest++) = (palptr[src[i++]] << 16) | pixel;
#endif
}
dest += destinc;
src += xsize;
}
}
static void
do_copy32 (int xsize, int ysize, uint32 * dest, uint8 * src)
{
int i, j, destinc = stride / 4;
uint32 *palptr = palette;
for (j = 0; j < ysize; j++) {
for (i = 0; i < xsize; i++) {
dest[i] = palptr[src[i]];
}
dest += destinc;
src += xsize;
}
}
void
ResetFrameBuffer (void)
{
int tbuffersize, tcachesize;
void *vid_surfcache;
// Calculate the sizes we want first
tbuffersize = vid.width * vid.height * sizeof (*d_pzbuffer);
tcachesize = D_SurfaceCacheForRes (vid.width, vid.height);
// Free the old z-buffer
if (d_pzbuffer) {
free (d_pzbuffer);
d_pzbuffer = NULL;
}
// Free the old surface cache
vid_surfcache = D_SurfaceCacheAddress ();
if (vid_surfcache) {
D_FlushCaches ();
free (vid_surfcache);
vid_surfcache = NULL;
}
// Allocate the new z-buffer
d_pzbuffer = calloc (tbuffersize, 1);
if (!d_pzbuffer) {
Sys_Error ("Not enough memory for video mode\n");
}
// Allocate the new surface cache; free the z-buffer if we fail
vid_surfcache = calloc (tcachesize, 1);
if (!vid_surfcache) {
free (d_pzbuffer);
d_pzbuffer = NULL;
Sys_Error ("Not enough memory for video mode\n");
}
D_InitCaches (vid_surfcache, tcachesize);
}
// Called at startup to set up translation tables, takes 256 8 bit RGB values
// the palette data will go away after the call, so it must be copied off if
// the video driver will need it again
void
VID_Init (unsigned char *pal)
{
int pnum;
vid.width = GGI_AUTO;
vid.height = GGI_AUTO;
srandom (getpid ());
if (ggiInit () < 0) {
Sys_Error ("VID: Unable to init LibGGI\n");
}
ggivis = ggiOpen (NULL);
if (!ggivis) {
Sys_Error ("VID: Unable to open default visual\n");
}
/* Go into async mode */
ggiSetFlags (ggivis, GGIFLAG_ASYNC);
/* check for command-line window size */
if ((pnum = COM_CheckParm ("-winsize"))) {
if (pnum >= com_argc - 2)
Sys_Error ("VID: -winsize <width> <height>\n");
vid.width = atoi (com_argv[pnum + 1]);
vid.height = atoi (com_argv[pnum + 2]);
if (!vid.width || !vid.height)
Sys_Error ("VID: Bad window width/height\n");
}
if ((pnum = COM_CheckParm ("-width"))) {
if (pnum >= com_argc - 1)
Sys_Error ("VID: -width <width>\n");
vid.width = atoi (com_argv[pnum + 1]);
if (!vid.width)
Sys_Error ("VID: Bad window width\n");
}
if ((pnum = COM_CheckParm ("-height"))) {
if (pnum >= com_argc - 1)
Sys_Error ("VID: -height <height>\n");
vid.height = atoi (com_argv[pnum + 1]);
if (!vid.height)
Sys_Error ("VID: Bad window height\n");
}
scale = COM_CheckParm ("-scale");
/* specify a LibGGI mode */
if ((pnum = COM_CheckParm ("-ggimode"))) {
if (pnum >= com_argc - 1)
Sys_Error ("VID: -ggimode <mode>\n");
ggiParseMode (com_argv[pnum + 1], &mode);
} else {
/* This will give the default mode */
ggiParseMode ("", &mode);
/* Now put in any parameters given above */
mode.visible.x = vid.width;
mode.visible.y = vid.height;
}
if (scale) {
mode.visible.x *= 2;
mode.visible.y *= 2;
}
/* We prefer 8 bit mode unless otherwise specified */
if (mode.graphtype == GT_AUTO)
mode.graphtype = GT_8BIT;
/* We want double buffering if possible */
if (mode.frames == GGI_AUTO) {
ggi_mode tmpmode = mode;
tmpmode.frames = 2;
if (ggiCheckMode (ggivis, &tmpmode) == 0) {
mode = tmpmode;
} else {
tmpmode.frames = 2;
if (ggiCheckMode (ggivis, &tmpmode) == 0) {
mode = tmpmode;
}
}
}
if (ggiSetMode (ggivis, &mode) != 0) {
/* Try again with suggested mode */
if (ggiSetMode (ggivis, &mode) != 0) {
Sys_Error ("VID: LibGGI can't set any modes!\n");
}
}
/* Pixel size must be 1, 2 or 4 bytes */
if (GT_SIZE (mode.graphtype) != 8 &&
GT_SIZE (mode.graphtype) != 16 && GT_SIZE (mode.graphtype) != 32) {
if (GT_SIZE (mode.graphtype) == 24) {
Sys_Error
("VID: 24 bits per pixel not supported - try using the palemu target.\n");
} else {
Sys_Error ("VID: %d bits per pixel not supported by GGI Quake.\n",
GT_SIZE (mode.graphtype));
}
}
realwidth = mode.visible.x;
realheight = mode.visible.y;
if (scale) {
vid.width = realwidth / 2;
vid.height = realheight / 2;
} else {
vid.width = realwidth;
vid.height = realheight;
}
if (mode.frames >= 2)
doublebuffer = 1;
else
doublebuffer = 0;
pixelsize = (GT_SIZE (mode.graphtype) + 7) / 8;
if (mode.graphtype != GT_8BIT) {
if ((palette = malloc (pixelsize * 256)) == NULL) {
Sys_Error ("VID: Unable to allocate palette table\n");
}
}
VID_SetPalette (pal);
usedbuf = havedbuf = 0;
drawstride = vid.width;
stride = realwidth * pixelsize;
if ((dbuf1 = ggiDBGetBuffer (ggivis, 0)) != NULL &&
(dbuf1->type & GGI_DB_SIMPLE_PLB)) {
havedbuf = 1;
stride = dbuf1->buffer.plb.stride;
if (doublebuffer) {
if ((dbuf2 = ggiDBGetBuffer (ggivis, 1)) == NULL ||
!(dbuf2->type & GGI_DB_SIMPLE_PLB)) {
/* Only one DB? No double buffering then */
doublebuffer = 0;
}
}
if (doublebuffer) {
fprintf (stderr, "VID: Got two DirectBuffers\n");
} else {
fprintf (stderr, "VID: Got one DirectBuffer\n");
}
if (doublebuffer && !scale && !palette) {
usedbuf = 1;
drawstride = stride;
frameptr[0] = dbuf1->write;
if (doublebuffer) {
frameptr[1] = dbuf2->write;
} else {
frameptr[1] = frameptr[0];
}
drawptr = frameptr[0];
fprintf (stderr, "VID: Drawing into DirectBuffer\n");
}
}
if (!usedbuf) {
if ((drawptr = malloc (vid.width * vid.height)) == NULL) {
Sys_Error ("VID: Unable to allocate draw buffer\n");
}
if (!havedbuf && (scale || palette)) {
int linesize = pixelsize * realwidth;
if (scale)
linesize *= 4;
if ((oneline = malloc (linesize)) == NULL) {
Sys_Error ("VID: Unable to allocate line buffer\n");
}
}
fprintf (stderr, "VID: Drawing into offscreen memory\n");
}
ResetFrameBuffer ();
curframe = 0;
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.numpages = doublebuffer ? 2 : 1;
vid.colormap = host_colormap;
vid.buffer = drawptr;
vid.rowbytes = drawstride;
vid.direct = drawptr;
vid.conbuffer = vid.buffer;
vid.conrowbytes = vid.rowbytes;
vid.conwidth = vid.width;
vid.conheight = vid.height;
vid.aspect = ((float) vid.height / (float) vid.width) * (320.0 / 240.0);
vid.fullbright = 256 - LittleLong (*((int *) vid.colormap + 2048));
}
void
VID_ShiftPalette (unsigned char *pal)
{
VID_SetPalette (pal);
}
void
VID_SetPalette (unsigned char *pal)
{
int i;
ggi_color colors[256];
for (i = 0; i < 256; i++) {
colors[i].r = pal[i * 3] * 257;
colors[i].g = pal[i * 3 + 1] * 257;
colors[i].b = pal[i * 3 + 2] * 257;
}
if (palette) {
ggiPackColors (ggivis, palette, colors, 256);
} else {
ggiSetPalette (ggivis, 0, 256, colors);
}
}
// Called at shutdown
void
VID_Shutdown (void)
{
Con_Printf ("VID_Shutdown\n");
if (!usedbuf) {
free (drawptr);
drawptr = NULL;
}
if (oneline) {
free (oneline);
oneline = NULL;
}
if (palette) {
free (palette);
palette = NULL;
}
if (ggivis) {
ggiClose (ggivis);
ggivis = NULL;
}
ggiExit ();
}
// flushes the given rectangles from the view buffer to the screen
void
VID_Update (vrect_t *rects)
{
int height = 0;
#if 0
// if the window changes dimension, skip this frame
if (config_notify) {
fprintf (stderr, "config notify\n");
config_notify = 0;
vid.width = config_notify_width & ~7;
vid.height = config_notify_height;
if (doShm)
ResetSharedFrameBuffers ();
else
ResetFrameBuffer ();
vid.rowbytes = x_framebuffer[0]->bytes_per_line;
vid.buffer = x_framebuffer[curframe]->data;
vid.conbuffer = vid.buffer;
vid.conwidth = vid.width;
vid.conheight = vid.height;
vid.conrowbytes = vid.rowbytes;
vid.recalc_refdef = 1; // force a surface cache flush
Con_CheckResize ();
Con_Clear_f ();
return;
}
// force full update if not 8bit
if (x_visinfo->depth != 8) {
extern int scr_fullupdate;
scr_fullupdate = 0;
}
#endif
while (rects) {
int y = rects->y + rects->height;
if (y > height)
height = y;
rects = rects->pnext;
}
if (!usedbuf) {
int i;
if (havedbuf) {
if (ggiResourceAcquire (dbuf1->resource,
GGI_ACTYPE_WRITE) != 0 ||
(doublebuffer ?
ggiResourceAcquire (dbuf2->resource,
GGI_ACTYPE_WRITE) != 0 : 0)) {
ggiPanic ("Unable to acquire DirectBuffer!\n");
}
/* ->write is allowed to change at acquire time */
frameptr[0] = dbuf1->write;
if (doublebuffer) {
frameptr[1] = dbuf2->write;
} else {
frameptr[1] = frameptr[0];
}
}
if (scale) {
switch (pixelsize) {
case 1:
if (havedbuf) {
do_scale8 (vid.width, height,
frameptr[curframe], drawptr);
} else {
uint8 *buf = drawptr;
for (i = 0; i < height; i++) {
do_scale8 (vid.width, 1, oneline, buf);
ggiPutBox (ggivis, 0, i * 2, realwidth, 2, oneline);
buf += vid.width;
}
}
break;
case 2:
if (havedbuf) {
do_scale16 (vid.width, height,
frameptr[curframe], drawptr);
} else {
uint8 *buf = drawptr;
for (i = 0; i < height; i++) {
do_scale16 (vid.width, 1, oneline, buf);
ggiPutBox (ggivis, 0, i * 2, realwidth, 2, oneline);
buf += vid.width;
}
}
break;
case 4:
if (havedbuf) {
do_scale32 (vid.width, height,
frameptr[curframe], drawptr);
} else {
uint8 *buf = drawptr;
for (i = 0; i < height; i++) {
do_scale32 (vid.width, 1, oneline, buf);
ggiPutBox (ggivis, 0, i * 2, realwidth, 2, oneline);
buf += vid.width;
}
}
break;
}
} else if (palette) {
switch (pixelsize) {
case 1:
if (havedbuf) {
do_copy8 (vid.width, height,
frameptr[curframe], drawptr);
} else {
uint8 *buf = drawptr;
for (i = 0; i < height; i++) {
do_copy8 (vid.width, 1, oneline, buf);
ggiPutBox (ggivis, 0, i, realwidth, 1, oneline);
buf += vid.width;
}
}
break;
case 2:
if (havedbuf) {
do_copy16 (vid.width, height,
frameptr[curframe], drawptr);
} else {
uint8 *buf = drawptr;
for (i = 0; i < height; i++) {
do_copy16 (vid.width, 1, oneline, buf);
ggiPutBox (ggivis, 0, i, realwidth, 1, oneline);
buf += vid.width;
}
}
break;
case 4:
if (havedbuf) {
do_copy32 (vid.width, height,
frameptr[curframe], drawptr);
} else {
uint8 *buf = drawptr;
for (i = 0; i < height; i++) {
do_copy32 (vid.width, 1, oneline, buf);
ggiPutBox (ggivis, 0, i, realwidth, 1, oneline);
buf += vid.width;
}
}
break;
}
} else {
ggiPutBox (ggivis, 0, 0, vid.width, height, drawptr);
}
if (havedbuf) {
ggiResourceRelease (dbuf1->resource);
if (doublebuffer) {
ggiResourceRelease (dbuf2->resource);
}
}
}
if (doublebuffer) {
ggiSetDisplayFrame (ggivis, curframe);
curframe = !curframe;
if (usedbuf) {
vid.buffer = vid.conbuffer = vid.direct
= drawptr = frameptr[curframe];
}
ggiSetWriteFrame (ggivis, curframe);
}
#if 0
if (GT_SIZE (mode.graphtype) == 16) {
do_copy16 (vid.width, height, (uint16 *) frameptr, drawptr);
} else if (GT_SIZE (mode.graphtype) == 32) {
do_copy32 (vid.width, height, (uint32 *) frameptr, drawptr);
}
#endif
ggiFlush (ggivis);
}
void
D_BeginDirectRect (int x, int y, byte * pbitmap, int width, int height)
{
// direct drawing of the "accessing disk" icon isn't supported under Linux
}
void
D_EndDirectRect (int x, int y, int width, int height)
{
// direct drawing of the "accessing disk" icon isn't supported under Linux
}
/*
***************************************************************************
Input handling
***************************************************************************
*/
static int
XLateKey (ggi_key_event * ev)
{
int key = 0;
if (GII_KTYP (ev->label) == GII_KT_DEAD) {
ev->label = GII_KVAL (ev->label);
}
switch (ev->label) {
case GIIK_P9:
key = KP_PGUP;
break;
case GIIK_PageUp:
key = K_PGUP;
break;
case GIIK_P3:
key = KP_PGDN;
break;
case GIIK_PageDown:
key = K_PGDN;
break;
case GIIK_P7:
key = KP_HOME;
break;
case GIIK_Home:
key = K_HOME;
break;
case GIIK_P1:
key = KP_END;
break;
case GIIK_End:
key = K_END;
break;
case GIIK_P4:
key = KP_LEFTARROW;
break;
case GIIK_Left:
key = K_LEFTARROW;
break;
case GIIK_P6:
key = KP_RIGHTARROW;
break;
case GIIK_Right:
key = K_RIGHTARROW;
break;
case GIIK_P2:
key = KP_DOWNARROW;
break;
case GIIK_Down:
key = K_DOWNARROW;
break;
case GIIK_P8:
key = KP_UPARROW;
break;
case GIIK_Up:
key = K_UPARROW;
break;
case GIIK_P5:
key = KP_5;
break;
case GIIK_PBegin:
key = K_AUX32;
break;
case GIIK_P0:
key = KP_INS;
break;
case GIIK_Insert:
key = K_INS;
break;
case GIIK_PSeparator:
case GIIK_PDecimal:
key = KP_DEL;
break;
case GIIUC_Delete:
key = K_DEL;
break;
case GIIK_PStar:
key = KP_MULTIPLY;
break;
case GIIK_PPlus:
key = KP_PLUS;
break;
case GIIK_PMinus:
key = KP_MINUS;
break;
case GIIK_PSlash:
key = KP_DIVIDE;
break;
case GIIK_PEnter:
key = KP_ENTER;
break;
case GIIUC_Return:
key = K_ENTER;
break;
case GIIUC_Escape:
key = K_ESCAPE;
break;
case GIIUC_Tab:
key = K_TAB;
break;
case GIIK_F1:
key = K_F1;
break;
case GIIK_F2:
key = K_F2;
break;
case GIIK_F3:
key = K_F3;
break;
case GIIK_F4:
key = K_F4;
break;
case GIIK_F5:
key = K_F5;
break;
case GIIK_F6:
key = K_F6;
break;
case GIIK_F7:
key = K_F7;
break;
case GIIK_F8:
key = K_F8;
break;
case GIIK_F9:
key = K_F9;
break;
case GIIK_F10:
key = K_F10;
break;
case GIIK_F11:
key = K_F11;
break;
case GIIK_F12:
key = K_F12;
break;
case GIIUC_BackSpace:
key = K_BACKSPACE;
break;
case GIIK_ShiftL:
case GIIK_ShiftR:
key = K_SHIFT;
break;
case GIIK_Execute:
case GIIK_CtrlL:
case GIIK_CtrlR:
key = K_CTRL;
break;
case GIIK_AltL:
case GIIK_MetaL:
case GIIK_AltR:
case GIIK_MetaR:
case GIIK_AltGr:
case GIIK_ModeSwitch:
key = K_ALT;
break;
case GIIK_Caps:
key = K_CAPSLOCK;
break;
case GIIK_PrintScreen:
key = K_PRNTSCR;
break;
case GIIK_ScrollLock:
key = K_SCRLCK;
break;
case GIIK_Pause:
key = K_PAUSE;
break;
case GIIK_NumLock:
key = KP_NUMLCK;
break;
case GIIUC_Comma:
case GIIUC_Minus:
case GIIUC_Period:
key = ev->label;
break;
case GIIUC_Section:
key = '~';
break;
default:
if (ev->label >= 0 && ev->label <= 9)
return ev->label;
if (ev->label >= 'A' && ev->label <= 'Z') {
return ev->label - 'A' + 'a';
}
if (ev->label >= 'a' && ev->label <= 'z')
return ev->label;
if (ev->sym <= 0x7f) {
key = ev->sym;
if (key >= 'A' && key <= 'Z') {
key = key - 'A' + 'a';
}
return key;
}
if (ev->label <= 0x7f) {
return ev->label;
}
break;
}
return key;
}
static void
GetEvent (void)
{
ggi_event ev;
uint32 b;
ggiEventRead (ggivis, &ev, emAll);
switch (ev.any.type) {
case evKeyPress:
Key_Event (XLateKey (&ev.key), 0, true);
break;
case evKeyRelease:
Key_Event (XLateKey (&ev.key), 0, false);
break;
case evPtrRelative:
mouse_x += (float) ev.pmove.x;
mouse_y += (float) ev.pmove.y;
break;
case evPtrAbsolute:
mouse_x += (float) (ev.pmove.x - p_mouse_x);
mouse_y += (float) (ev.pmove.y - p_mouse_y);
p_mouse_x = ev.pmove.x;
p_mouse_y = ev.pmove.y;
break;
case evPtrButtonPress:
if (!mouse_avail)
return;
b = ev.pbutton.button - 1;
if (b < NUM_STDBUTTONS) {
Key_Event (K_MOUSE1 + b, 0, true);
} else if (b < NUM_STDBUTTONS + 2) {
b -= 3;
if (b)
Key_Event (K_MWHEELDOWN, 0, true);
else
Key_Event (K_MWHEELUP, 0, true);
} else if (b < NUM_BUTTONS) {
Key_Event (K_AUX32 - NUM_BUTTONS + b, 0, true);
}
break;
case evPtrButtonRelease:
if (!mouse_avail)
return;
b = ev.pbutton.button - 1;
if (b < NUM_STDBUTTONS) {
Key_Event (K_MOUSE1 + b, 0, false);
} else if (b < NUM_STDBUTTONS + 2) {
b -= 3;
if (b)
Key_Event (K_MWHEELDOWN, 0, false);
else
Key_Event (K_MWHEELUP, 0, false);
} else if (b < NUM_BUTTONS) {
Key_Event (K_AUX32 - NUM_BUTTONS + b, 0, false);
}
break;
#if 0
case ConfigureNotify:
//printf("config notify\n");
config_notify_width = ev.xconfigure.width;
config_notify_height = ev.xconfigure.height;
config_notify = 1;
break;
default:
#endif
}
}
void
IN_SendKeyEvents (void)
{
/* Get events from LibGGI */
if (ggivis) {
struct timeval t = { 0, 0 };
if (ggiEventPoll (ggivis, emAll, &t)) {
int i = ggiEventsQueued (ggivis, emAll);
while (i--)
GetEvent ();
}
}
}
void
IN_Init (void)
{
JOY_Init ();
old_windowed_mouse = -1; /* Force update */
if (COM_CheckParm ("-nomouse"))
return;
mouse_x = mouse_y = 0.0;
mouse_avail = 1;
}
void
IN_Init_Cvars (void)
{
JOY_Init_Cvars ();
_windowed_mouse = Cvar_Get ("_windowed_mouse", "0", CVAR_ARCHIVE, "None");
m_filter = Cvar_Get ("m_filter", "0", CVAR_ARCHIVE, "None");
}
void
IN_Shutdown (void)
{
JOY_Shutdown ();
Con_Printf ("IN_Shutdown\n");
mouse_avail = 0;
}
void
IN_Commands (void)
{
JOY_Command ();
/* Only supported by LibGII 0.7 or later. */
#ifdef GII_CMDCODE_PREFER_RELPTR
if (old_windowed_mouse != _windowed_mouse->int_val) {
gii_event ev;
old_windowed_mouse = _windowed_mouse->int_val;
ev.cmd.size = sizeof (gii_cmd_nodata_event);
ev.cmd.type = evCommand;
ev.cmd.target = GII_EV_TARGET_ALL;
ev.cmd.code = _windowed_mouse->int_val ? GII_CMDCODE_PREFER_RELPTR
: GII_CMDCODE_PREFER_ABSPTR;
ggiEventSend (ggivis, &ev);
}
#endif
}
void
IN_Move (usercmd_t *cmd)
{
JOY_Move (cmd);
if (!mouse_avail)
return;
if (m_filter->int_val) {
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
}
old_mouse_x = mouse_x;
old_mouse_y = mouse_y;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
if ((in_strafe.state & 1) || (lookstrafe->int_val && freelook))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (freelook)
V_StopPitchDrift ();
if (freelook && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
cl.viewangles[PITCH] = bound (-70, cl.viewangles[PITCH], 80);
} else {
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward->value * mouse_y;
}
mouse_x = mouse_y = 0.0;
}
void
VID_Init_Cvars (void)
{
}
void
VID_LockBuffer (void)
{
}
void
VID_UnlockBuffer (void)
{
}
void
VID_SetCaption (char *text)
{
}
Reference in New Issue View Git Blame Copy Permalink