qf/newtree
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/newtree synced 2024-11-14 00:21:27 +00:00
Code Issues Projects Releases Packages Wiki Activity
newtree/source/vid_mgl.c
Bill Currie 435c588e37 function header audit.
2001-02-09 02:53:09 +00:00

3197 lines
73 KiB
C
Raw Blame History

/*
vid_mgl.c
Win32 Scitech MGL video driver
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdlib.h>
#include "cdaudio.h"
#include "cmd.h"
#include "console.h"
#include "d_local.h"
#include "draw.h"
#include "host.h"
#include "in_win.h"
#include "keys.h"
#include "qargs.h"
#include "qendian.h"
#include "resource.h"
#include "screen.h"
#include "sound.h"
#include "sys.h"
#include "va.h"
#include "wad.h"
#include "winquake.h"
#define MINIMUM_MEMORY 0x550000
#define MAX_MODE_LIST 30
#define VID_ROW_SIZE 3
extern void (*vid_menudrawfn) (void);
extern void (*vid_menukeyfn) (int);
/* Unused */
int VGA_width, VGA_height, VGA_rowbytes, VGA_bufferrowbytes, VGA_planar;
byte *VGA_pagebase;
qboolean dibonly;
extern qboolean Minimized;
HWND mainwindow;
HWND WINAPI InitializeWindow (HINSTANCE hInstance, int nCmdShow);
int DIBWidth, DIBHeight;
qboolean DDActive;
RECT WindowRect;
DWORD WindowStyle, ExWindowStyle;
int window_center_x, window_center_y, window_x, window_y, window_width,
window_height;
RECT window_rect;
static DEVMODE gdevmode;
static qboolean startwindowed = 0, windowed_mode_set = 0;
static int firstupdate = 1;
static qboolean vid_initialized = false, vid_palettized;
static int lockcount;
static int vid_fulldib_on_focus_mode;
static qboolean force_minimized, in_mode_set, is_mode0x13, force_mode_set;
static int vid_stretched, windowed_mouse;
static qboolean palette_changed, syscolchg, vid_mode_set, hide_window,
pal_is_nostatic;
static HICON hIcon;
extern viddef_t vid; // global video state
#define MODE_WINDOWED 0
#define MODE_SETTABLE_WINDOW 2
#define NO_MODE (MODE_WINDOWED - 1)
#define MODE_FULLSCREEN_DEFAULT (MODE_WINDOWED + 3)
// Note that 0 is MODE_WINDOWED
cvar_t *vid_mode;
// Note that 0 is MODE_WINDOWED
// Note that 3 is MODE_FULLSCREEN_DEFAULT
cvar_t *_vid_default_mode_win;
cvar_t *vid_nopageflip;
cvar_t *vid_config_x;
cvar_t *vid_config_y;
cvar_t *vid_stretch_by_2;
cvar_t *_windowed_mouse;
cvar_t *vid_fullscreen_mode;
cvar_t *vid_windowed_mode;
cvar_t *block_switch;
cvar_t *vid_window_x;
cvar_t *vid_window_y;
typedef struct {
int width;
int height;
} lmode_t;
lmode_t lowresmodes[] = {
{320, 200},
{320, 240},
{400, 300},
{512, 384},
};
int vid_modenum = NO_MODE;
int vid_testingmode, vid_realmode;
double vid_testendtime;
int vid_default = MODE_WINDOWED;
static int windowed_default;
modestate_t modestate = MS_UNINIT;
static byte *vid_surfcache;
static int vid_surfcachesize;
static int VID_highhunkmark;
unsigned char vid_curpal[256 * 3];
unsigned short d_8to16table[256];
unsigned int d_8to24table[256];
int driver = grDETECT, mode;
qboolean useWinDirect = true, useDirectDraw = true;
MGLDC *mgldc = NULL, *memdc = NULL, *dibdc = NULL, *windc = NULL;
typedef struct {
modestate_t type;
int width;
int height;
int modenum;
int mode13;
int stretched;
int dib;
int fullscreen;
int bpp;
int halfscreen;
char modedesc[13];
} vmode_t;
static vmode_t modelist[MAX_MODE_LIST];
static int nummodes;
int aPage; // Current active display page
int vPage; // Current visible display page
int waitVRT = true; // True to wait for retrace on flip
static vmode_t badmode;
static byte backingbuf[48 * 24];
void VID_MenuDraw (void);
void VID_MenuKey (int key);
LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
void AppActivate (BOOL fActive, BOOL minimize);
/*
VID_RememberWindowPos
*/
void
VID_RememberWindowPos (void)
{
RECT rect;
if (GetWindowRect (mainwindow, &rect)) {
if ((rect.left < GetSystemMetrics (SM_CXSCREEN)) &&
(rect.top < GetSystemMetrics (SM_CYSCREEN)) &&
(rect.right > 0) && (rect.bottom > 0)) {
Cvar_SetValue (vid_window_x, rect.left);
Cvar_SetValue (vid_window_y, rect.top);
}
}
}
/*
VID_CheckWindowXY
*/
void
VID_CheckWindowXY (void)
{
if ((vid_window_x->int_val > (GetSystemMetrics (SM_CXSCREEN) - 160)) ||
(vid_window_y->int_val > (GetSystemMetrics (SM_CYSCREEN) - 120)) ||
(vid_window_x->int_val < 0) || (vid_window_y->int_val < 0)) {
Cvar_SetValue (vid_window_x, 0.0);
Cvar_SetValue (vid_window_y, 0.0);
}
}
/*
VID_UpdateWindowStatus
*/
void
VID_UpdateWindowStatus (void)
{
window_rect.left = window_x;
window_rect.top = window_y;
window_rect.right = window_x + window_width;
window_rect.bottom = window_y + window_height;
window_center_x = (window_rect.left + window_rect.right) / 2;
window_center_y = (window_rect.top + window_rect.bottom) / 2;
IN_UpdateClipCursor ();
}
extern void CL_ClearStates ();
/*
ClearAllStates
*/
void
ClearAllStates (void)
{
CL_ClearStates ();
Key_ClearStates ();
IN_ClearStates ();
}
/*
VID_CheckAdequateMem
*/
qboolean
VID_CheckAdequateMem (int width, int height)
{
return true;
}
/*
VID_AllocBuffers
*/
qboolean
VID_AllocBuffers (int width, int height)
{
int zbuffersize, cachesize;
// Calculate the sizes we want first
zbuffersize = width * height * sizeof (*d_pzbuffer);
cachesize = D_SurfaceCacheForRes (width, 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 (zbuffersize, 1);
if (!d_pzbuffer) {
Sys_Error ("Not enough memory for video mode\n");
return false;
}
// Allocate the new surface cache; free the z-buffer if we fail
vid_surfcache = calloc (cachesize, 1);
if (!vid_surfcache) {
free (d_pzbuffer);
d_pzbuffer = NULL;
Sys_Error ("Not enough memory for video mode\n");
return false;
}
vid_surfcachesize = cachesize;
return true;
}
void
initFatalError (void)
{
MGL_exit ();
MGL_fatalError (MGL_errorMsg (MGL_result ()));
exit (EXIT_FAILURE);
}
#if 0 // def NEW_SUSPEND
int
VID_Suspend (MGLDC * dc, int flags)
{
int i;
if (flags & MGL_DEACTIVATE) {
IN_RestoreOriginalMouseState ();
CDAudio_Pause ();
// keep WM_PAINT from trying to redraw
in_mode_set = true;
block_drawing = true;
} else if (flags & MGL_REACTIVATE) {
IN_SetQuakeMouseState ();
// fix the leftover Alt from any Alt-Tab or the like that switched us
// away
ClearAllStates ();
CDAudio_Resume ();
in_mode_set = false;
block_drawing = false;
// vid.recalc_refdef = 1;
force_mode_set = 1;
i = msg_suppress_1;
msg_suppress_1 = 1;
VID_Fullscreen_f ();
msg_suppress_1 = i;
force_mode_set = 0;
}
return 1;
}
#else
int
VID_Suspend (MGLDC * dc, int flags)
{
if (flags & MGL_DEACTIVATE) {
// FIXME: this doesn't currently work on NT
if (block_switch->int_val && !WinNT) {
return MGL_NO_DEACTIVATE;
}
S_BlockSound ();
S_ClearBuffer ();
IN_RestoreOriginalMouseState ();
CDAudio_Pause ();
// keep WM_PAINT from trying to redraw
in_mode_set = true;
block_drawing = true; // so we don't try to draw while
// switched away
} else if (flags & MGL_REACTIVATE) {
IN_SetQuakeMouseState ();
// fix the leftover Alt from any Alt-Tab or the like that switched us
// away
ClearAllStates ();
CDAudio_Resume ();
S_UnblockSound ();
in_mode_set = false;
vid.recalc_refdef = 1;
block_drawing = false;
}
return MGL_NO_SUSPEND_APP;
}
#endif
void
registerAllDispDrivers (void)
{
/* Event though these driver require WinDirect, we register * them so
that they will still be available even if DirectDraw * is present and
the user has disable the high performance * WinDirect modes. */
MGL_registerDriver (MGL_VGA8NAME, VGA8_driver);
// MGL_registerDriver(MGL_VGAXNAME,VGAX_driver);
/* Register display drivers */
if (useWinDirect) {
//we don't want VESA 1.X drivers MGL_registerDriver(MGL_SVGA8NAME,SVGA8_driver);
MGL_registerDriver (MGL_LINEAR8NAME, LINEAR8_driver);
if (!COM_CheckParm ("-novbeaf"))
MGL_registerDriver (MGL_ACCEL8NAME, ACCEL8_driver);
}
if (useDirectDraw) {
MGL_registerDriver (MGL_DDRAW8NAME, DDRAW8_driver);
}
}
void
registerAllMemDrivers (void)
{
/* Register memory context drivers */
MGL_registerDriver (MGL_PACKED8NAME, PACKED8_driver);
}
void
VID_InitMGLFull (HINSTANCE hInstance)
{
int i, xRes, yRes, bits, lowres, curmode, temp;
int lowstretchedres, stretchedmode = 0, lowstretched;
uchar *m;
// FIXME: NT is checked for because MGL currently has a bug that causes it
// to try to use WinDirect modes even on NT
if (COM_CheckParm ("-nowindirect") ||
COM_CheckParm ("-nowd") || COM_CheckParm ("-novesa") || WinNT) {
useWinDirect = false;
}
if (COM_CheckParm ("-nodirectdraw") || COM_CheckParm ("-noddraw")
|| COM_CheckParm ("-nodd"))
useDirectDraw = false;
// Initialise the MGL
MGL_unregisterAllDrivers ();
registerAllDispDrivers ();
registerAllMemDrivers ();
MGL_detectGraph (&driver, &mode);
m = MGL_availableModes ();
if (m[0] != 0xFF) {
lowres = lowstretchedres = 99999;
lowstretched = 0;
curmode = 0;
// find the lowest-res mode, or a mode we can stretch up to and get
// lowest-res that way
for (i = 0; m[i] != 0xFF; i++) {
MGL_modeResolution (m[i], &xRes, &yRes, &bits);
if ((bits == 8) &&
(xRes <= MAXWIDTH) &&
(yRes <= MAXHEIGHT) && (curmode < MAX_MODE_LIST)) {
if (m[i] == grVGA_320x200x256)
is_mode0x13 = true;
if (!COM_CheckParm ("-noforcevga")) {
if (m[i] == grVGA_320x200x256) {
mode = i;
break;
}
}
if (xRes < lowres) {
lowres = xRes;
mode = i;
}
if ((xRes < lowstretchedres) && ((xRes >> 1) >= 320)) {
lowstretchedres = xRes >> 1;
stretchedmode = i;
}
}
curmode++;
}
// if there's a mode we can stretch by 2 up to, thereby effectively
// getting
// a lower-res mode than the lowest-res real but still at least
// 320x200, that
// will be our default mode
if (lowstretchedres < lowres) {
mode = stretchedmode;
lowres = lowstretchedres;
lowstretched = 1;
}
// build the mode list, leaving room for the low-res stretched mode,
// if any
nummodes++; // leave room for default mode
for (i = 0; m[i] != 0xFF; i++) {
MGL_modeResolution (m[i], &xRes, &yRes, &bits);
if ((bits == 8) &&
(xRes <= MAXWIDTH) &&
(yRes <= MAXHEIGHT) && (nummodes < MAX_MODE_LIST)) {
if (i == mode) {
if (lowstretched) {
stretchedmode = nummodes;
curmode = nummodes++;
} else {
curmode = MODE_FULLSCREEN_DEFAULT;
}
} else {
curmode = nummodes++;
}
modelist[curmode].type = MS_FULLSCREEN;
modelist[curmode].width = xRes;
modelist[curmode].height = yRes;
snprintf (modelist[curmode].modedesc,
sizeof (modelist[curmode].modedesc), "%dx%d", xRes,
yRes);
if (m[i] == grVGA_320x200x256)
modelist[curmode].mode13 = 1;
else
modelist[curmode].mode13 = 0;
modelist[curmode].modenum = m[i];
modelist[curmode].stretched = 0;
modelist[curmode].dib = 0;
modelist[curmode].fullscreen = 1;
modelist[curmode].halfscreen = 0;
modelist[curmode].bpp = 8;
}
}
if (lowstretched) {
modelist[MODE_FULLSCREEN_DEFAULT] = modelist[stretchedmode];
modelist[MODE_FULLSCREEN_DEFAULT].stretched = 1;
modelist[MODE_FULLSCREEN_DEFAULT].width >>= 1;
modelist[MODE_FULLSCREEN_DEFAULT].height >>= 1;
snprintf (modelist[MODE_FULLSCREEN_DEFAULT].modedesc,
sizeof (modelist[MODE_FULLSCREEN_DEFAULT].modedesc),
"%dx%d", modelist[MODE_FULLSCREEN_DEFAULT].width,
modelist[MODE_FULLSCREEN_DEFAULT].height);
}
vid_default = MODE_FULLSCREEN_DEFAULT;
temp = m[0];
if (!MGL_init (&driver, &temp, "")) {
initFatalError ();
}
}
MGL_setSuspendAppCallback (VID_Suspend);
}
MGLDC *
createDisplayDC (int forcemem)
/****************************************************************************
*
* Function: createDisplayDC
* Returns: Pointer to the MGL device context to use for the application
*
* Description: Initialises the MGL and creates an appropriate display
* device context to be used by the GUI. This creates and
* apropriate device context depending on the system being
* compile for, and should be the only place where system
* specific code is required.
*
****************************************************************************/
{
MGLDC *dc;
pixel_format_t pf;
int npages;
// Start the specified video mode
if (!MGL_changeDisplayMode (mode))
initFatalError ();
npages = MGL_availablePages (mode);
if (npages > 3)
npages = 3;
if (!COM_CheckParm ("-notriplebuf")) {
if (npages > 2) {
npages = 2;
}
}
if ((dc = MGL_createDisplayDC (npages)) == NULL)
return NULL;
if (!forcemem && (MGL_surfaceAccessType (dc)) == MGL_LINEAR_ACCESS
&& (dc->mi.maxPage > 0)) {
MGL_makeCurrentDC (dc);
memdc = NULL;
} else {
// Set up for blitting from a memory buffer
memdc =
MGL_createMemoryDC (MGL_sizex (dc) + 1, MGL_sizey (dc) + 1, 8, &pf);
MGL_makeCurrentDC (memdc);
}
// Enable page flipping even for even for blitted surfaces
if (forcemem) {
vid.numpages = 1;
} else {
vid.numpages = dc->mi.maxPage + 1;
if (vid.numpages > 1) {
// Set up for page flipping
MGL_setActivePage (dc, aPage = 1);
MGL_setVisualPage (dc, vPage = 0, false);
}
if (vid.numpages > 3)
vid.numpages = 3;
}
if (vid.numpages == 2)
waitVRT = true;
else
waitVRT = false;
return dc;
}
void
VID_InitMGLDIB (HINSTANCE hInstance)
{
WNDCLASS wc;
HDC hdc;
hIcon = LoadIcon (hInstance, MAKEINTRESOURCE (IDI_ICON1));
/* Register the frame class */
wc.style = 0;
wc.lpfnWndProc = (WNDPROC) MainWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = 0;
wc.hCursor = LoadCursor (NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = 0;
wc.lpszClassName = "WinQuake";
if (!RegisterClass (&wc))
Sys_Error ("Couldn't register window class");
/* Find the size for the DIB window */
/* Initialise the MGL for windowed operation */
MGL_setAppInstance (hInstance);
registerAllMemDrivers ();
MGL_initWindowed ("");
modelist[0].type = MS_WINDOWED;
modelist[0].width = 320;
modelist[0].height = 240;
strcpy (modelist[0].modedesc, "320x240");
modelist[0].mode13 = 0;
modelist[0].modenum = MODE_WINDOWED;
modelist[0].stretched = 0;
modelist[0].dib = 1;
modelist[0].fullscreen = 0;
modelist[0].halfscreen = 0;
modelist[0].bpp = 8;
modelist[1].type = MS_WINDOWED;
modelist[1].width = 640;
modelist[1].height = 480;
strcpy (modelist[1].modedesc, "640x480");
modelist[1].mode13 = 0;
modelist[1].modenum = MODE_WINDOWED + 1;
modelist[1].stretched = 1;
modelist[1].dib = 1;
modelist[1].fullscreen = 0;
modelist[1].halfscreen = 0;
modelist[1].bpp = 8;
modelist[2].type = MS_WINDOWED;
modelist[2].width = 800;
modelist[2].height = 600;
strcpy (modelist[2].modedesc, "800x600");
modelist[2].mode13 = 0;
modelist[2].modenum = MODE_WINDOWED + 2;
modelist[2].stretched = 1;
modelist[2].dib = 1;
modelist[2].fullscreen = 0;
modelist[2].halfscreen = 0;
modelist[2].bpp = 8;
// automatically stretch the default mode up if > 640x480 desktop resolution
hdc = GetDC (NULL);
if ((GetDeviceCaps (hdc, HORZRES) > 640)
&& !COM_CheckParm ("-noautostretch")) {
vid_default = MODE_WINDOWED + 1;
} else {
vid_default = MODE_WINDOWED;
}
windowed_default = vid_default;
ReleaseDC (NULL, hdc);
nummodes = 3; // reserve space for windowed mode
DDActive = 0;
}
/*
VID_InitFullDIB
*/
void
VID_InitFullDIB (HINSTANCE hInstance)
{
DEVMODE devmode;
int i, j, modenum, existingmode, originalnummodes, lowestres;
int numlowresmodes, bpp, done;
int cstretch, istretch, mstretch = 0;
BOOL stat;
// enumerate 8 bpp modes
originalnummodes = nummodes;
modenum = 0;
lowestres = 99999;
do {
stat = EnumDisplaySettings (NULL, modenum, &devmode);
if ((devmode.dmBitsPerPel == 8) &&
(devmode.dmPelsWidth <= MAXWIDTH) &&
(devmode.dmPelsHeight <= MAXHEIGHT) && (nummodes < MAX_MODE_LIST)) {
devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
DISP_CHANGE_SUCCESSFUL) {
modelist[nummodes].type = MS_FULLDIB;
modelist[nummodes].width = devmode.dmPelsWidth;
modelist[nummodes].height = devmode.dmPelsHeight;
modelist[nummodes].modenum = 0;
modelist[nummodes].mode13 = 0;
modelist[nummodes].stretched = 0;
modelist[nummodes].halfscreen = 0;
modelist[nummodes].dib = 1;
modelist[nummodes].fullscreen = 1;
modelist[nummodes].bpp = devmode.dmBitsPerPel;
snprintf (modelist[nummodes].modedesc,
sizeof (modelist[nummodes].modedesc), "%ldx%ld",
devmode.dmPelsWidth, devmode.dmPelsHeight);
// if the width is more than twice the height, reduce it by
// half because this
// is probably a dual-screen monitor
if (!COM_CheckParm ("-noadjustaspect")) {
if (modelist[nummodes].width >
(modelist[nummodes].height << 1)) {
modelist[nummodes].width >>= 1;
modelist[nummodes].halfscreen = 1;
snprintf (modelist[nummodes].modedesc,
sizeof (modelist[nummodes].modedesc), "%dx%d",
modelist[nummodes].width,
modelist[nummodes].height);
}
}
for (i = originalnummodes, existingmode = 0; i < nummodes; i++) {
if ((modelist[nummodes].width == modelist[i].width) &&
(modelist[nummodes].height == modelist[i].height)) {
existingmode = 1;
break;
}
}
if (!existingmode) {
if (modelist[nummodes].width < lowestres)
lowestres = modelist[nummodes].width;
nummodes++;
}
}
}
modenum++;
} while (stat);
// see if any of them were actually settable; if so, this is our mode list,
// else enumerate all modes; our mode list is whichever ones are settable
// with > 8 bpp
if (nummodes == originalnummodes) {
modenum = 0;
lowestres = 99999;
Con_Printf ("No 8-bpp fullscreen DIB modes found\n");
do {
stat = EnumDisplaySettings (NULL, modenum, &devmode);
if ((((devmode.dmPelsWidth <= MAXWIDTH) &&
(devmode.dmPelsHeight <= MAXHEIGHT)) ||
(!COM_CheckParm ("-noadjustaspect") &&
(devmode.dmPelsWidth <= (MAXWIDTH * 2)) &&
(devmode.dmPelsWidth > (devmode.dmPelsHeight * 2)))) &&
(nummodes < MAX_MODE_LIST) && (devmode.dmBitsPerPel > 8)) {
devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN)
== DISP_CHANGE_SUCCESSFUL) {
modelist[nummodes].type = MS_FULLDIB;
modelist[nummodes].width = devmode.dmPelsWidth;
modelist[nummodes].height = devmode.dmPelsHeight;
modelist[nummodes].modenum = 0;
modelist[nummodes].mode13 = 0;
modelist[nummodes].stretched = 0;
modelist[nummodes].halfscreen = 0;
modelist[nummodes].dib = 1;
modelist[nummodes].fullscreen = 1;
modelist[nummodes].bpp = devmode.dmBitsPerPel;
snprintf (modelist[nummodes].modedesc,
sizeof (modelist[nummodes].modedesc), "%ldx%ld",
devmode.dmPelsWidth, devmode.dmPelsHeight);
// if the width is more than twice the height, reduce it
// by half because this
// is probably a dual-screen monitor
if (!COM_CheckParm ("-noadjustaspect")) {
if (modelist[nummodes].width >
(modelist[nummodes].height * 2)) {
modelist[nummodes].width >>= 1;
modelist[nummodes].halfscreen = 1;
snprintf (modelist[nummodes].modedesc,
sizeof (modelist[nummodes].modedesc),
"%dx%d", modelist[nummodes].width,
modelist[nummodes].height);
}
}
for (i = originalnummodes, existingmode = 0; i < nummodes;
i++) {
if ((modelist[nummodes].width == modelist[i].width)
&& (modelist[nummodes].height ==
modelist[i].height)) {
// pick the lowest available bpp
if (modelist[nummodes].bpp < modelist[i].bpp)
modelist[i] = modelist[nummodes];
existingmode = 1;
break;
}
}
if (!existingmode) {
if (modelist[nummodes].width < lowestres)
lowestres = modelist[nummodes].width;
nummodes++;
}
}
}
modenum++;
} while (stat);
}
// see if there are any low-res modes that aren't being reported
numlowresmodes = sizeof (lowresmodes) / sizeof (lowresmodes[0]);
bpp = 8;
done = 0;
// first make sure the driver doesn't just answer yes to all tests
devmode.dmBitsPerPel = 8;
devmode.dmPelsWidth = 42;
devmode.dmPelsHeight = 37;
devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
DISP_CHANGE_SUCCESSFUL) {
done = 1;
}
while (!done) {
for (j = 0; (j < numlowresmodes) && (nummodes < MAX_MODE_LIST); j++) {
devmode.dmBitsPerPel = bpp;
devmode.dmPelsWidth = lowresmodes[j].width;
devmode.dmPelsHeight = lowresmodes[j].height;
devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
DISP_CHANGE_SUCCESSFUL) {
modelist[nummodes].type = MS_FULLDIB;
modelist[nummodes].width = devmode.dmPelsWidth;
modelist[nummodes].height = devmode.dmPelsHeight;
modelist[nummodes].modenum = 0;
modelist[nummodes].mode13 = 0;
modelist[nummodes].stretched = 0;
modelist[nummodes].halfscreen = 0;
modelist[nummodes].dib = 1;
modelist[nummodes].fullscreen = 1;
modelist[nummodes].bpp = devmode.dmBitsPerPel;
snprintf (modelist[nummodes].modedesc,
sizeof (modelist[nummodes].modedesc), "%ldx%ld",
devmode.dmPelsWidth, devmode.dmPelsHeight);
// we only want the lowest-bpp version of each mode
for (i = originalnummodes, existingmode = 0; i < nummodes; i++) {
if ((modelist[nummodes].width == modelist[i].width) &&
(modelist[nummodes].height == modelist[i].height) &&
(modelist[nummodes].bpp >= modelist[i].bpp)) {
existingmode = 1;
break;
}
}
if (!existingmode) {
if (modelist[nummodes].width < lowestres)
lowestres = modelist[nummodes].width;
nummodes++;
}
}
}
switch (bpp) {
case 8:
bpp = 16;
break;
case 16:
bpp = 32;
break;
case 32:
done = 1;
break;
}
}
// now add the lowest stretch-by-2 pseudo-modes between 320-wide
// (inclusive) and lowest real res (not inclusive)
// don't bother if we have a real VGA mode 0x13 mode
if (!is_mode0x13) {
for (i = originalnummodes, cstretch = 0; i < nummodes; i++) {
if (((modelist[i].width >> 1) < lowestres) &&
((modelist[i].width >> 1) >= 320)) {
lowestres = modelist[i].width >> 1;
cstretch = 1;
mstretch = i;
}
}
if ((nummodes + cstretch) > MAX_MODE_LIST)
cstretch = MAX_MODE_LIST - nummodes;
if (cstretch > 0) {
for (i = (nummodes - 1); i >= originalnummodes; i--)
modelist[i + cstretch] = modelist[i];
nummodes += cstretch;
istretch = originalnummodes;
modelist[istretch] = modelist[mstretch];
modelist[istretch].width >>= 1;
modelist[istretch].height >>= 1;
modelist[istretch].stretched = 1;
snprintf (modelist[istretch].modedesc,
sizeof (modelist[istretch].modedesc), "%dx%d",
modelist[istretch].width, modelist[istretch].height);
}
}
if (nummodes != originalnummodes)
vid_default = MODE_FULLSCREEN_DEFAULT;
else
Con_Printf ("No fullscreen DIB modes found\n");
}
/*
VID_NumModes
*/
int
VID_NumModes (void)
{
return nummodes;
}
/*
VID_GetModePtr
*/
vmode_t *
VID_GetModePtr (int modenum)
{
if ((modenum >= 0) && (modenum < nummodes))
return &modelist[modenum];
else
return &badmode;
}
/*
VID_CheckModedescFixup
*/
void
VID_CheckModedescFixup (int mode)
{
int x, y, stretch;
if (mode == MODE_SETTABLE_WINDOW) {
modelist[mode].stretched = vid_stretch_by_2->int_val;
stretch = modelist[mode].stretched;
Cvar_SetValue (vid_config_x,
max (vid_config_x->int_val, 320 << stretch));
Cvar_SetValue (vid_config_y,
max (vid_config_y->int_val, 200 << stretch));
x = vid_config_x->int_val;
y = vid_config_y->int_val;
snprintf (modelist[mode].modedesc, sizeof (modelist[mode].modedesc),
"%dx%d", x, y);
modelist[mode].width = x;
modelist[mode].height = y;
}
}
/*
VID_GetModeDescriptionMemCheck
*/
char *
VID_GetModeDescriptionMemCheck (int mode)
{
char *pinfo;
vmode_t *pv;
if ((mode < 0) || (mode >= nummodes))
return NULL;
VID_CheckModedescFixup (mode);
pv = VID_GetModePtr (mode);
pinfo = pv->modedesc;
if (VID_CheckAdequateMem (pv->width, pv->height)) {
return pinfo;
} else {
return NULL;
}
}
/*
VID_GetModeDescription
*/
char *
VID_GetModeDescription (int mode)
{
char *pinfo;
vmode_t *pv;
if ((mode < 0) || (mode >= nummodes))
return NULL;
VID_CheckModedescFixup (mode);
pv = VID_GetModePtr (mode);
pinfo = pv->modedesc;
return pinfo;
}
/*
VID_GetModeDescription2
Tacks on "windowed" or "fullscreen"
*/
char *
VID_GetModeDescription2 (int mode)
{
static char pinfo[40];
vmode_t *pv;
if ((mode < 0) || (mode >= nummodes))
return NULL;
VID_CheckModedescFixup (mode);
pv = VID_GetModePtr (mode);
if (modelist[mode].type == MS_FULLSCREEN) {
snprintf (pinfo, sizeof (pinfo), "%s fullscreen", pv->modedesc);
} else if (modelist[mode].type == MS_FULLDIB) {
snprintf (pinfo, sizeof (pinfo), "%s fullscreen", pv->modedesc);
} else {
snprintf (pinfo, sizeof (pinfo), "%s windowed", pv->modedesc);
}
return pinfo;
}
// KJB: Added this to return the mode driver name in description for console
char *
VID_GetExtModeDescription (int mode)
{
static char pinfo[40];
vmode_t *pv;
if ((mode < 0) || (mode >= nummodes))
return NULL;
VID_CheckModedescFixup (mode);
pv = VID_GetModePtr (mode);
if (modelist[mode].type == MS_FULLSCREEN) {
snprintf (pinfo, sizeof (pinfo), "%s fullscreen %s", pv->modedesc,
MGL_modeDriverName (pv->modenum));
} else if (modelist[mode].type == MS_FULLDIB) {
snprintf (pinfo, sizeof (pinfo), "%s fullscreen DIB", pv->modedesc);
} else {
snprintf (pinfo, sizeof (pinfo), "%s windowed", pv->modedesc);
}
return pinfo;
}
void
DestroyDIBWindow (void)
{
if (modestate == MS_WINDOWED) {
// destroy the associated MGL DC's; the window gets reused
if (windc)
MGL_destroyDC (windc);
if (dibdc)
MGL_destroyDC (dibdc);
windc = dibdc = NULL;
}
}
void
DestroyFullscreenWindow (void)
{
if (modestate == MS_FULLSCREEN) {
// destroy the existing fullscreen mode and DC's
if (mgldc)
MGL_destroyDC (mgldc);
if (memdc)
MGL_destroyDC (memdc);
mgldc = memdc = NULL;
}
}
void
DestroyFullDIBWindow (void)
{
if (modestate == MS_FULLDIB) {
ChangeDisplaySettings (NULL, CDS_FULLSCREEN);
// Destroy the fullscreen DIB window and associated MGL DC's
if (windc)
MGL_destroyDC (windc);
if (dibdc)
MGL_destroyDC (dibdc);
windc = dibdc = NULL;
}
}
qboolean
VID_SetWindowedMode (int modenum)
{
HDC hdc;
pixel_format_t pf;
qboolean stretched;
int lastmodestate;
if (!windowed_mode_set) {
if (COM_CheckParm ("-resetwinpos")) {
Cvar_SetValue (vid_window_x, 0.0);
Cvar_SetValue (vid_window_y, 0.0);
}
windowed_mode_set = 1;
}
VID_CheckModedescFixup (modenum);
DDActive = 0;
lastmodestate = modestate;
DestroyFullscreenWindow ();
DestroyFullDIBWindow ();
if (windc)
MGL_destroyDC (windc);
if (dibdc)
MGL_destroyDC (dibdc);
windc = dibdc = NULL;
// KJB: Signal to the MGL that we are going back to windowed mode
if (!MGL_changeDisplayMode (grWINDOWED))
initFatalError ();
WindowRect.top = WindowRect.left = 0;
WindowRect.right = modelist[modenum].width;
WindowRect.bottom = modelist[modenum].height;
stretched = modelist[modenum].stretched;
DIBWidth = modelist[modenum].width;
DIBHeight = modelist[modenum].height;
if (stretched) {
DIBWidth >>= 1;
DIBHeight >>= 1;
}
WindowStyle = WS_OVERLAPPED | WS_BORDER | WS_CAPTION | WS_SYSMENU |
WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
ExWindowStyle = 0;
AdjustWindowRectEx (&WindowRect, WindowStyle, FALSE, 0);
// the first time we're called to set the mode, create the window we'll use
// for the rest of the session
if (!vid_mode_set) {
mainwindow = CreateWindowEx (ExWindowStyle,
"WinQuake",
PROGRAM,
WindowStyle,
0, 0,
WindowRect.right - WindowRect.left,
WindowRect.bottom - WindowRect.top,
NULL, NULL, global_hInstance, NULL);
if (!mainwindow)
Sys_Error ("Couldn't create DIB window");
// tell MGL to use this window for fullscreen modes
MGL_registerFullScreenWindow (mainwindow);
vid_mode_set = true;
} else {
SetWindowLong (mainwindow, GWL_STYLE, WindowStyle | WS_VISIBLE);
SetWindowLong (mainwindow, GWL_EXSTYLE, ExWindowStyle);
}
if (!SetWindowPos (mainwindow,
NULL,
0, 0,
WindowRect.right - WindowRect.left,
WindowRect.bottom - WindowRect.top,
SWP_NOCOPYBITS | SWP_NOZORDER | SWP_HIDEWINDOW)) {
Sys_Error ("Couldn't resize DIB window");
}
if (hide_window)
return true;
// position and show the DIB window
VID_CheckWindowXY ();
SetWindowPos (mainwindow, NULL, vid_window_x->int_val,
vid_window_y->int_val, 0, 0,
SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
if (force_minimized)
ShowWindow (mainwindow, SW_MINIMIZE);
else
ShowWindow (mainwindow, SW_SHOWDEFAULT);
UpdateWindow (mainwindow);
modestate = MS_WINDOWED;
vid_fulldib_on_focus_mode = 0;
// because we have set the background brush for the window to NULL
// (to avoid flickering when re-sizing the window on the desktop),
// we clear the window to black when created, otherwise it will be
// empty while Quake starts up.
hdc = GetDC (mainwindow);
PatBlt (hdc, 0, 0, WindowRect.right, WindowRect.bottom, BLACKNESS);
ReleaseDC (mainwindow, hdc);
/* Create the MGL window DC and the MGL memory DC */
if ((windc = MGL_createWindowedDC (mainwindow)) == NULL)
MGL_fatalError ("Unable to create Windowed DC!");
if ((dibdc = MGL_createMemoryDC (DIBWidth, DIBHeight, 8, &pf)) == NULL)
MGL_fatalError ("Unable to create Memory DC!");
MGL_makeCurrentDC (dibdc);
vid.buffer = vid.conbuffer = vid.direct = dibdc->surface;
vid.rowbytes = vid.conrowbytes = dibdc->mi.bytesPerLine;
vid.numpages = 1;
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.height = vid.conheight = DIBHeight;
vid.width = vid.conwidth = DIBWidth;
vid.aspect = ((float) vid.height / (float) vid.width) * (320.0 / 240.0);
vid_stretched = stretched;
SendMessage (mainwindow, WM_SETICON, (WPARAM) TRUE, (LPARAM) hIcon);
SendMessage (mainwindow, WM_SETICON, (WPARAM) FALSE, (LPARAM) hIcon);
return true;
}
qboolean
VID_SetFullscreenMode (int modenum)
{
DDActive = 1;
DestroyDIBWindow ();
DestroyFullDIBWindow ();
mode = modelist[modenum].modenum;
// Destroy old DC's, resetting back to fullscreen mode
if (mgldc)
MGL_destroyDC (mgldc);
if (memdc)
MGL_destroyDC (memdc);
mgldc = memdc = NULL;
if ((mgldc = createDisplayDC (modelist[modenum].stretched ||
vid_nopageflip->int_val)) == NULL) {
return false;
}
modestate = MS_FULLSCREEN;
vid_fulldib_on_focus_mode = 0;
vid.buffer = vid.conbuffer = vid.direct = NULL;
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
DIBHeight = vid.height = vid.conheight = modelist[modenum].height;
DIBWidth = vid.width = vid.conwidth = modelist[modenum].width;
vid.aspect = ((float) vid.height / (float) vid.width) * (320.0 / 240.0);
vid_stretched = modelist[modenum].stretched;
// needed because we're not getting WM_MOVE messages fullscreen on NT
window_x = 0;
window_y = 0;
// set the large icon, so the Quake icon will show up in the taskbar
SendMessage (mainwindow, WM_SETICON, (WPARAM) 1, (LPARAM) hIcon);
SendMessage (mainwindow, WM_SETICON, (WPARAM) 0, (LPARAM) hIcon);
// shouldn't be needed, but Kendall needs to let us get the activation
// message for this not to be needed on NT
AppActivate (true, false);
return true;
}
qboolean
VID_SetFullDIBMode (int modenum)
{
HDC hdc;
pixel_format_t pf;
int lastmodestate;
DDActive = 0;
DestroyFullscreenWindow ();
DestroyDIBWindow ();
if (windc)
MGL_destroyDC (windc);
if (dibdc)
MGL_destroyDC (dibdc);
windc = dibdc = NULL;
// KJB: Signal to the MGL that we are going back to windowed mode
if (!MGL_changeDisplayMode (grWINDOWED))
initFatalError ();
gdevmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
gdevmode.dmBitsPerPel = modelist[modenum].bpp;
gdevmode.dmPelsWidth =
modelist[modenum].width << modelist[modenum].
stretched << modelist[modenum].halfscreen;
gdevmode.dmPelsHeight =
modelist[modenum].height << modelist[modenum].stretched;
gdevmode.dmSize = sizeof (gdevmode);
if (ChangeDisplaySettings (&gdevmode, CDS_FULLSCREEN) !=
DISP_CHANGE_SUCCESSFUL) Sys_Error ("Couldn't set fullscreen DIB mode");
lastmodestate = modestate;
modestate = MS_FULLDIB;
vid_fulldib_on_focus_mode = modenum;
WindowRect.top = WindowRect.left = 0;
hdc = GetDC (NULL);
WindowRect.right = modelist[modenum].width << modelist[modenum].stretched;
WindowRect.bottom = modelist[modenum].height << modelist[modenum].stretched;
ReleaseDC (NULL, hdc);
DIBWidth = modelist[modenum].width;
DIBHeight = modelist[modenum].height;
WindowStyle = WS_POPUP | WS_SYSMENU | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
ExWindowStyle = 0;
AdjustWindowRectEx (&WindowRect, WindowStyle, FALSE, 0);
SetWindowLong (mainwindow, GWL_STYLE, WindowStyle | WS_VISIBLE);
SetWindowLong (mainwindow, GWL_EXSTYLE, ExWindowStyle);
if (!SetWindowPos (mainwindow,
NULL,
0, 0,
WindowRect.right - WindowRect.left,
WindowRect.bottom - WindowRect.top,
SWP_NOCOPYBITS | SWP_NOZORDER)) {
Sys_Error ("Couldn't resize DIB window");
}
// position and show the DIB window
SetWindowPos (mainwindow, HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_SHOWWINDOW | SWP_DRAWFRAME);
ShowWindow (mainwindow, SW_SHOWDEFAULT);
UpdateWindow (mainwindow);
// Because we have set the background brush for the window to NULL
// (to avoid flickering when re-sizing the window on the desktop), we
// clear the window to black when created, otherwise it will be
// empty while Quake starts up.
hdc = GetDC (mainwindow);
PatBlt (hdc, 0, 0, WindowRect.right, WindowRect.bottom, BLACKNESS);
ReleaseDC (mainwindow, hdc);
/* Create the MGL window DC and the MGL memory DC */
if ((windc = MGL_createWindowedDC (mainwindow)) == NULL)
MGL_fatalError ("Unable to create Fullscreen DIB DC!");
if ((dibdc = MGL_createMemoryDC (DIBWidth, DIBHeight, 8, &pf)) == NULL)
MGL_fatalError ("Unable to create Memory DC!");
MGL_makeCurrentDC (dibdc);
vid.buffer = vid.conbuffer = vid.direct = dibdc->surface;
vid.rowbytes = vid.conrowbytes = dibdc->mi.bytesPerLine;
vid.numpages = 1;
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.height = vid.conheight = DIBHeight;
vid.width = vid.conwidth = DIBWidth;
vid.aspect = ((float) vid.height / (float) vid.width) * (320.0 / 240.0);
vid_stretched = modelist[modenum].stretched;
// needed because we're not getting WM_MOVE messages fullscreen on NT
window_x = 0;
window_y = 0;
return true;
}
void
VID_RestoreOldMode (int original_mode)
{
static qboolean inerror = false;
if (inerror)
return;
in_mode_set = false;
inerror = true;
// make sure mode set happens (video mode changes)
vid_modenum = original_mode - 1;
if (!VID_SetMode (original_mode, vid_curpal)) {
vid_modenum = MODE_WINDOWED - 1;
if (!VID_SetMode (windowed_default, vid_curpal))
Sys_Error ("Can't set any video mode");
}
inerror = false;
}
void
VID_SetDefaultMode (void)
{
if (vid_initialized)
VID_SetMode (0, vid_curpal);
IN_DeactivateMouse ();
}
int
VID_SetMode (int modenum, unsigned char *palette)
{
int original_mode, temp;
qboolean stat;
MSG msg;
HDC hdc;
while ((modenum >= nummodes) || (modenum < 0)) {
if (vid_modenum == NO_MODE) {
if (modenum == vid_default) {
modenum = windowed_default;
} else {
modenum = vid_default;
}
Cvar_SetValue (vid_mode, modenum);
} else {
Cvar_SetValue (vid_mode, vid_modenum);
return 0;
}
}
if (!force_mode_set && (modenum == vid_modenum))
return true;
// so Con_Printfs don't mess us up by forcing vid and snd updates
temp = scr_disabled_for_loading;
scr_disabled_for_loading = true;
in_mode_set = true;
CDAudio_Pause ();
S_ClearBuffer ();
if (vid_modenum == NO_MODE)
original_mode = windowed_default;
else
original_mode = vid_modenum;
// Set either the fullscreen or windowed mode
if (modelist[modenum].type == MS_WINDOWED) {
if (_windowed_mouse->int_val && key_dest == key_game) {
stat = VID_SetWindowedMode (modenum);
IN_ActivateMouse ();
IN_HideMouse ();
} else {
IN_DeactivateMouse ();
IN_ShowMouse ();
stat = VID_SetWindowedMode (modenum);
}
} else if (modelist[modenum].type == MS_FULLDIB) {
stat = VID_SetFullDIBMode (modenum);
IN_ActivateMouse ();
IN_HideMouse ();
} else {
stat = VID_SetFullscreenMode (modenum);
IN_ActivateMouse ();
IN_HideMouse ();
}
window_width = vid.width << vid_stretched;
window_height = vid.height << vid_stretched;
VID_UpdateWindowStatus ();
CDAudio_Resume ();
scr_disabled_for_loading = temp;
if (!stat) {
VID_RestoreOldMode (original_mode);
return false;
}
if (hide_window)
return true;
// now we try to make sure we get the focus on the mode switch, because
// sometimes in some systems we don't. We grab the foreground, then
// finish setting up, pump all our messages, and sleep for a little while
// to let messages finish bouncing around the system, then we put
// ourselves at the top of the z order, then grab the foreground again,
// Who knows if it helps, but it probably doesn't hurt
if (!force_minimized)
SetForegroundWindow (mainwindow);
hdc = GetDC (NULL);
if (GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE)
vid_palettized = true;
else
vid_palettized = false;
VID_SetPalette (palette);
ReleaseDC (NULL, hdc);
vid_modenum = modenum;
Cvar_SetValue (vid_mode, vid_modenum);
if (!VID_AllocBuffers (vid.width, vid.height)) {
// couldn't get memory for this mode; try to fall back to previous
// mode
VID_RestoreOldMode (original_mode);
return false;
}
D_InitCaches (vid_surfcache, vid_surfcachesize);
while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage (&msg);
DispatchMessage (&msg);
}
Sleep (100);
if (!force_minimized) {
SetWindowPos (mainwindow, HWND_TOP, 0, 0, 0, 0,
SWP_DRAWFRAME | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW |
SWP_NOCOPYBITS);
SetForegroundWindow (mainwindow);
}
// fix the leftover Alt from any Alt-Tab or the like that switched us away
ClearAllStates ();
if (!msg_suppress_1)
Con_Printf ("Video mode %s initialized\n",
VID_GetModeDescription (vid_modenum));
VID_SetPalette (palette);
in_mode_set = false;
vid.recalc_refdef = 1;
return true;
}
void
VID_LockBuffer (void)
{
if (dibdc)
return;
lockcount++;
if (lockcount > 1)
return;
MGL_beginDirectAccess ();
if (memdc) {
// Update surface pointer for linear access modes
vid.buffer = vid.conbuffer = vid.direct = memdc->surface;
vid.rowbytes = vid.conrowbytes = memdc->mi.bytesPerLine;
} else if (mgldc) {
// Update surface pointer for linear access modes
vid.buffer = vid.conbuffer = vid.direct = mgldc->surface;
vid.rowbytes = vid.conrowbytes = mgldc->mi.bytesPerLine;
}
if (r_dowarp)
d_viewbuffer = r_warpbuffer;
else
d_viewbuffer = (void *) (byte *) vid.buffer;
if (r_dowarp)
screenwidth = WARP_WIDTH;
else
screenwidth = vid.rowbytes;
}
void
VID_UnlockBuffer (void)
{
if (dibdc)
return;
lockcount--;
if (lockcount > 0)
return;
if (lockcount < 0)
Sys_Error ("Unbalanced unlock");
MGL_endDirectAccess ();
// to turn up any unlocked accesses
vid.buffer = vid.conbuffer = vid.direct = d_viewbuffer = NULL;
}
int
VID_ForceUnlockedAndReturnState (void)
{
int lk;
if (!lockcount)
return 0;
lk = lockcount;
if (dibdc) {
lockcount = 0;
} else {
lockcount = 1;
VID_UnlockBuffer ();
}
return lk;
}
void
VID_ForceLockState (int lk)
{
if (!dibdc && lk) {
lockcount = 0;
VID_LockBuffer ();
}
lockcount = lk;
}
void
VID_SetPalette (unsigned char *palette)
{
INT i;
palette_t pal[256];
HDC hdc;
if (!Minimized) {
palette_changed = true;
// make sure we have the static colors if we're the active app
hdc = GetDC (NULL);
if (vid_palettized && ActiveApp) {
if (GetSystemPaletteUse (hdc) == SYSPAL_STATIC) {
// switch to SYSPAL_NOSTATIC and remap the colors
SetSystemPaletteUse (hdc, SYSPAL_NOSTATIC);
syscolchg = true;
pal_is_nostatic = true;
}
}
ReleaseDC (NULL, hdc);
// Translate the palette values to an MGL palette array and
// set the values.
for (i = 0; i < 256; i++) {
pal[i].red = palette[i * 3];
pal[i].green = palette[i * 3 + 1];
pal[i].blue = palette[i * 3 + 2];
}
if (DDActive) {
if (!mgldc)
return;
MGL_setPalette (mgldc, pal, 256, 0);
MGL_realizePalette (mgldc, 256, 0, false);
if (memdc)
MGL_setPalette (memdc, pal, 256, 0);
} else {
if (!windc)
return;
MGL_setPalette (windc, pal, 256, 0);
MGL_realizePalette (windc, 256, 0, false);
if (dibdc) {
MGL_setPalette (dibdc, pal, 256, 0);
MGL_realizePalette (dibdc, 256, 0, false);
}
}
}
memcpy (vid_curpal, palette, sizeof (vid_curpal));
if (syscolchg) {
PostMessage (HWND_BROADCAST, WM_SYSCOLORCHANGE, (WPARAM) 0, (LPARAM) 0);
syscolchg = false;
}
}
void
VID_ShiftPalette (unsigned char *palette)
{
VID_SetPalette (palette);
}
/*
VID_DescribeCurrentMode_f
*/
void
VID_DescribeCurrentMode_f (void)
{
Con_Printf ("%s\n", VID_GetExtModeDescription (vid_modenum));
}
/*
VID_NumModes_f
*/
void
VID_NumModes_f (void)
{
if (nummodes == 1)
Con_Printf ("%d video mode is available\n", nummodes);
else
Con_Printf ("%d video modes are available\n", nummodes);
}
/*
VID_DescribeMode_f
*/
void
VID_DescribeMode_f (void)
{
int modenum;
modenum = atoi (Cmd_Argv (1));
Con_Printf ("%s\n", VID_GetExtModeDescription (modenum));
}
/*
VID_DescribeModes_f
*/
void
VID_DescribeModes_f (void)
{
int i, lnummodes;
char *pinfo;
qboolean na;
vmode_t *pv;
na = false;
lnummodes = VID_NumModes ();
for (i = 0; i < lnummodes; i++) {
pv = VID_GetModePtr (i);
pinfo = VID_GetExtModeDescription (i);
if (VID_CheckAdequateMem (pv->width, pv->height)) {
Con_Printf ("%2d: %s\n", i, pinfo);
} else {
Con_Printf ("**: %s\n", pinfo);
na = true;
}
}
if (na) {
Con_Printf ("\n[**: not enough system RAM for mode]\n");
}
}
/*
VID_TestMode_f
*/
void
VID_TestMode_f (void)
{
int modenum;
double testduration;
if (!vid_testingmode) {
modenum = atoi (Cmd_Argv (1));
if (VID_SetMode (modenum, vid_curpal)) {
vid_testingmode = 1;
testduration = atof (Cmd_Argv (2));
if (testduration == 0)
testduration = 5.0;
vid_testendtime = realtime + testduration;
}
}
}
/*
VID_Windowed_f
*/
void
VID_Windowed_f (void)
{
VID_SetMode (vid_windowed_mode->int_val, vid_curpal);
}
/*
VID_Fullscreen_f
*/
void
VID_Fullscreen_f (void)
{
VID_SetMode (vid_fullscreen_mode->int_val, vid_curpal);
}
/*
VID_Minimize_f
*/
void
VID_Minimize_f (void)
{
// we only support minimizing windows; if you're fullscreen,
// switch to windowed first
if (modestate == MS_WINDOWED)
ShowWindow (mainwindow, SW_MINIMIZE);
}
/*
VID_ForceMode_f
*/
void
VID_ForceMode_f (void)
{
int modenum;
if (!vid_testingmode) {
modenum = atoi (Cmd_Argv (1));
force_mode_set = 1;
VID_SetMode (modenum, vid_curpal);
force_mode_set = 0;
}
}
void
VID_Init (unsigned char *palette)
{
int i, bestmatch = 0, bestmatchmetric, t, dr, dg, db;
int basenummodes;
byte *ptmp;
Cmd_AddCommand ("vid_testmode", VID_TestMode_f, "Switch to another video mode temporarily for 5-seconds to test it.\n"
"(vid_testmode (mode))");
Cmd_AddCommand ("vid_nummodes", VID_NumModes_f, "Reports the total number of video modes available");
Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f, "Report current video mode.");
Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f, "Report information on specified video mode, default is current.\n"
"(vid_describemode (mode))");
Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f, "Report information on all video modes.");
Cmd_AddCommand ("vid_forcemode", VID_ForceMode_f, "Force QuakeWorld to use a certain video mode. (vid_forcemode (mode))");
Cmd_AddCommand ("vid_windowed", VID_Windowed_f, "Switch to windowed mode");
Cmd_AddCommand ("vid_fullscreen", VID_Fullscreen_f, "Switch to full screen mode");
Cmd_AddCommand ("vid_minimize", VID_Minimize_f, "Minimize windowed Quake");
if (COM_CheckParm ("-dibonly"))
dibonly = true;
VID_InitMGLDIB (global_hInstance);
basenummodes = nummodes;
if (!dibonly)
VID_InitMGLFull (global_hInstance);
// if there are no non-windowed modes, or only windowed and mode 0x13, then use
// fullscreen DIBs as well
if (((nummodes == basenummodes) ||
((nummodes == (basenummodes + 1)) && is_mode0x13)) &&
!COM_CheckParm ("-nofulldib"))
{
VID_InitFullDIB (global_hInstance);
}
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.colormap = host_colormap;
vid.fullbright = 256 - LittleLong (*((int *) vid.colormap + 2048));
vid_testingmode = 0;
// GDI doesn't let us remap palette index 0, so we'll remap color
// mappings from that black to another one
bestmatchmetric = 256 * 256 * 3;
for (i = 1; i < 256; i++) {
dr = palette[0] - palette[i * 3];
dg = palette[1] - palette[i * 3 + 1];
db = palette[2] - palette[i * 3 + 2];
t = (dr * dr) + (dg * dg) + (db * db);
if (t < bestmatchmetric) {
bestmatchmetric = t;
bestmatch = i;
if (t == 0)
break;
}
}
for (i = 0, ptmp = vid.colormap; i < (1 << (VID_CBITS + 8)); i++, ptmp++) {
if (*ptmp == 0)
*ptmp = bestmatch;
}
if (COM_CheckParm ("-startwindowed") || COM_CheckParm ("-window")) {
startwindowed = 1;
vid_default = windowed_default;
}
#ifdef SPLASH_SCREEN
if (hwnd_dialog)
DestroyWindow (hwnd_dialog);
#endif
// sound initialization has to go here, preceded by a windowed mode set,
// so there's a window for DirectSound to work with but we're not yet
// fullscreen so the "hardware already in use" dialog is visible if it
// gets displayed
// keep the window minimized until we're ready for the first real mode set
hide_window = true;
VID_SetMode (MODE_WINDOWED, palette);
hide_window = false;
// S_Init ();
vid_initialized = true;
force_mode_set = true;
VID_SetMode (vid_default, palette);
force_mode_set = false;
vid_realmode = vid_modenum;
VID_SetPalette (palette);
vid_menudrawfn = VID_MenuDraw;
vid_menukeyfn = VID_MenuKey;
strcpy (badmode.modedesc, "Bad mode");
}
void
VID_Init_Cvars ()
{
vid_mode = Cvar_Get ("vid_mode", "0", CVAR_NONE, "Set the video mode");
vid_nopageflip = Cvar_Get ("vid_nopageflip", "0", CVAR_ARCHIVE, "Toggles the use of page flipping");
_vid_default_mode_win =
Cvar_Get ("_vid_default_mode_win", "3", CVAR_ARCHIVE, "Default windowed video mode");
vid_config_x = Cvar_Get ("vid_config_x", "800", CVAR_ARCHIVE, "Maximum x-axis screen size");
vid_config_y = Cvar_Get ("vid_config_y", "600", CVAR_ARCHIVE, "Maximum y-axis screen size");
vid_stretch_by_2 = Cvar_Get ("vid_stretch_by_2", "1", CVAR_ARCHIVE, "Stretch the pixles by a two fold to acheive proper view");
_windowed_mouse = Cvar_Get ("_windowed_mouse", "0", CVAR_ARCHIVE, "Have quake grab the mouse from X when you play");
vid_fullscreen_mode =
Cvar_Get ("vid_fullscreen_mode", "3", CVAR_ARCHIVE, "Set the full screen video mode.");
vid_windowed_mode =
Cvar_Get ("vid_windowed_mode", "0", CVAR_ARCHIVE, "Set the windowed video mode");
block_switch = Cvar_Get ("block_switch", "0", CVAR_ARCHIVE, "If set, won't allow you to task switch while playing");
vid_window_x = Cvar_Get ("vid_window_x", "0", CVAR_ARCHIVE, "The x-axis location of the window, if windowed");
vid_window_y = Cvar_Get ("vid_window_y", "0", CVAR_ARCHIVE, "The y-axis location of the window, if windowed");
}
void
VID_Shutdown (void)
{
#ifdef SPLASH_SCREEN
if (hwnd_dialog)
DestroyWindow (hwnd_dialog);
#endif
if (vid_initialized) {
if (modestate == MS_FULLDIB)
ChangeDisplaySettings (NULL, CDS_FULLSCREEN);
PostMessage (HWND_BROADCAST, WM_PALETTECHANGED, (WPARAM) mainwindow,
(LPARAM) 0);
PostMessage (HWND_BROADCAST, WM_SYSCOLORCHANGE, (WPARAM) 0, (LPARAM) 0);
AppActivate (false, false);
DestroyDIBWindow ();
DestroyFullscreenWindow ();
DestroyFullDIBWindow ();
if (mainwindow)
DestroyWindow (mainwindow);
MGL_exit ();
vid_testingmode = 0;
vid_initialized = 0;
}
}
/*
FlipScreen
*/
void
FlipScreen (vrect_t *rects)
{
/* Flip the surfaces */
if (DDActive) {
if (mgldc) {
if (memdc) {
while (rects) {
if (vid_stretched) {
MGL_stretchBltCoord (mgldc, memdc,
rects->x,
rects->y,
rects->x + rects->width,
rects->y + rects->height,
rects->x << 1,
rects->y << 1,
(rects->x + rects->width) << 1,
(rects->y + rects->height) << 1);
} else {
MGL_bitBltCoord (mgldc, memdc,
rects->x, rects->y,
(rects->x + rects->width),
(rects->y + rects->height),
rects->x, rects->y, MGL_REPLACE_MODE);
}
rects = rects->pnext;
}
}
if (vid.numpages > 1) {
// We have a flipping surface, so do a hard page flip
aPage = (aPage + 1) % vid.numpages;
vPage = (vPage + 1) % vid.numpages;
MGL_setActivePage (mgldc, aPage);
MGL_setVisualPage (mgldc, vPage, waitVRT);
}
}
} else {
HDC hdcScreen;
hdcScreen = GetDC (mainwindow);
if (windc && dibdc) {
MGL_setWinDC (windc, hdcScreen);
while (rects) {
if (vid_stretched) {
MGL_stretchBltCoord (windc, dibdc,
rects->x, rects->y,
rects->x + rects->width,
rects->y + rects->height,
rects->x << 1, rects->y << 1,
(rects->x + rects->width) << 1,
(rects->y + rects->height) << 1);
} else {
MGL_bitBltCoord (windc, dibdc,
rects->x, rects->y,
rects->x + rects->width,
rects->y + rects->height, rects->x,
rects->y, MGL_REPLACE_MODE);
}
rects = rects->pnext;
}
}
ReleaseDC (mainwindow, hdcScreen);
}
}
void
VID_Update (vrect_t *rects)
{
vrect_t rect;
RECT trect;
if (!vid_palettized && palette_changed) {
palette_changed = false;
rect.x = 0;
rect.y = 0;
rect.width = vid.width;
rect.height = vid.height;
rect.pnext = NULL;
rects = &rect;
}
if (firstupdate) {
if (modestate == MS_WINDOWED) {
GetWindowRect (mainwindow, &trect);
if ((trect.left != vid_window_x->int_val) ||
(trect.top != vid_window_y->int_val)) {
if (COM_CheckParm ("-resetwinpos")) {
Cvar_SetValue (vid_window_x, 0.0);
Cvar_SetValue (vid_window_y, 0.0);
}
VID_CheckWindowXY ();
SetWindowPos (mainwindow, NULL, vid_window_x->int_val,
vid_window_y->int_val, 0, 0,
SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW |
SWP_DRAWFRAME);
}
}
if ((_vid_default_mode_win->int_val != vid_default) &&
(!startwindowed
|| (_vid_default_mode_win->int_val < MODE_FULLSCREEN_DEFAULT))) {
firstupdate = 0;
if (COM_CheckParm ("-resetwinpos")) {
Cvar_SetValue (vid_window_x, 0.0);
Cvar_SetValue (vid_window_y, 0.0);
}
if ((_vid_default_mode_win->int_val < 0) ||
(_vid_default_mode_win->int_val >= nummodes)) {
Cvar_SetValue (_vid_default_mode_win, windowed_default);
}
Cvar_SetValue (vid_mode, _vid_default_mode_win->int_val);
}
}
// We've drawn the frame; copy it to the screen
FlipScreen (rects);
if (vid_testingmode) {
if (realtime >= vid_testendtime) {
VID_SetMode (vid_realmode, vid_curpal);
vid_testingmode = 0;
}
} else {
if (vid_mode->int_val != vid_realmode) {
VID_SetMode (vid_mode->int_val, vid_curpal);
Cvar_SetValue (vid_mode, vid_modenum);
// so if mode set fails, we don't keep on
// trying to set that mode
vid_realmode = vid_modenum;
}
}
// handle the mouse state when windowed if that's changed
if (modestate == MS_WINDOWED) {
if (!_windowed_mouse->int_val) {
if (windowed_mouse) {
IN_DeactivateMouse ();
IN_ShowMouse ();
}
windowed_mouse = false;
} else {
windowed_mouse = true;
if (key_dest == key_game && !mouseactive && ActiveApp) {
IN_ActivateMouse ();
IN_HideMouse ();
} else if (mouseactive && key_dest != key_game) {
IN_DeactivateMouse ();
IN_ShowMouse ();
}
}
}
}
/*
D_BeginDirectRect
*/
void
D_BeginDirectRect (int x, int y, byte * pbitmap, int width, int height)
{
int i, j, reps, repshift;
vrect_t rect;
if (!vid_initialized)
return;
if (vid.aspect > 1.5) {
reps = 2;
repshift = 1;
} else {
reps = 1;
repshift = 0;
}
if (vid.numpages == 1) {
VID_LockBuffer ();
if (!vid.direct)
Sys_Error ("NULL vid.direct pointer");
for (i = 0; i < (height << repshift); i += reps) {
for (j = 0; j < reps; j++) {
memcpy (&backingbuf[(i + j) * 24],
vid.direct + x + ((y << repshift) + i +
j) * vid.rowbytes, width);
memcpy (vid.direct + x +
((y << repshift) + i + j) * vid.rowbytes,
&pbitmap[(i >> repshift) * width], width);
}
}
VID_UnlockBuffer ();
rect.x = x;
rect.y = y;
rect.width = width;
rect.height = height << repshift;
rect.pnext = NULL;
FlipScreen (&rect);
} else {
// unlock if locked
if (lockcount > 0)
MGL_endDirectAccess ();
// set the active page to the displayed page
MGL_setActivePage (mgldc, vPage);
// lock the screen
MGL_beginDirectAccess ();
// save from and draw to screen
for (i = 0; i < (height << repshift); i += reps) {
for (j = 0; j < reps; j++) {
memcpy (&backingbuf[(i + j) * 24],
(byte *) mgldc->surface + x +
((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
width);
memcpy ((byte *) mgldc->surface + x +
((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
&pbitmap[(i >> repshift) * width], width);
}
}
// unlock the screen
MGL_endDirectAccess ();
// restore the original active page
MGL_setActivePage (mgldc, aPage);
// relock the screen if it was locked
if (lockcount > 0)
MGL_beginDirectAccess ();
}
}
/*
D_EndDirectRect
*/
void
D_EndDirectRect (int x, int y, int width, int height)
{
int i, j, reps, repshift;
vrect_t rect;
if (!vid_initialized)
return;
if (vid.aspect > 1.5) {
reps = 2;
repshift = 1;
} else {
reps = 1;
repshift = 0;
}
if (vid.numpages == 1) {
VID_LockBuffer ();
if (!vid.direct)
Sys_Error ("NULL vid.direct pointer");
for (i = 0; i < (height << repshift); i += reps) {
for (j = 0; j < reps; j++) {
memcpy (vid.direct + x +
((y << repshift) + i + j) * vid.rowbytes,
&backingbuf[(i + j) * 24], width);
}
}
VID_UnlockBuffer ();
rect.x = x;
rect.y = y;
rect.width = width;
rect.height = height << repshift;
rect.pnext = NULL;
FlipScreen (&rect);
} else {
// unlock if locked
if (lockcount > 0)
MGL_endDirectAccess ();
// set the active page to the displayed page
MGL_setActivePage (mgldc, vPage);
// lock the screen
MGL_beginDirectAccess ();
// restore to the screen
for (i = 0; i < (height << repshift); i += reps) {
for (j = 0; j < reps; j++) {
memcpy ((byte *) mgldc->surface + x +
((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
&backingbuf[(i + j) * 24], width);
}
}
// unlock the screen
MGL_endDirectAccess ();
// restore the original active page
MGL_setActivePage (mgldc, aPage);
// relock the screen if it was locked
if (lockcount > 0)
MGL_beginDirectAccess ();
}
}
//==========================================================================
byte scantokey[128] = {
// 0 1 2 3 4 5 6 7
// 8 9 A B C D E F
0, 27, '1', '2', '3', '4', '5', '6',
'7', '8', '9', '0', '-', '=', K_BACKSPACE, 9, // 0
'q', 'w', 'e', 'r', 't', 'y', 'u', 'i',
'o', 'p', '[', ']', 13, K_CTRL, 'a', 's', // 1
'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
'\'', '`', K_SHIFT, '\\', 'z', 'x', 'c', 'v', // 2
'b', 'n', 'm', ',', '.', '/', K_SHIFT, KP_MULTIPLY,
K_ALT, ' ', K_CAPSLOCK, K_F1, K_F2, K_F3, K_F4, K_F5, // 3
K_F6, K_F7, K_F8, K_F9, K_F10, K_PAUSE, K_SCRLCK, KP_HOME,
KP_UPARROW, KP_PGUP, KP_MINUS, KP_LEFTARROW, KP_5, KP_RIGHTARROW, KP_PLUS, KP_END, // 4
KP_DOWNARROW, KP_PGDN, KP_INS, KP_DEL, 0, 0, 0, K_F11,
K_F12, 0, 0, 0, 0, 0, 0, 0, // 5
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
byte extscantokey[128] = {
// 0 1 2 3 4 5 6 7
// 8 9 A B C D E F
0, 27, '1', '2', '3', '4', '5', '6',
'7', '8', '9', '0', '-', '=', K_BACKSPACE, 9, // 0
'q', 'w', 'e', 'r', 't', 'y', 'u', 'i',
'o', 'p', '[', ']', KP_ENTER, K_CTRL, 'a', 's', // 1
'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
'\'', '`', K_SHIFT, '\\', 'z', 'x', 'c', 'v', // 2
'b', 'n', 'm', ',', '.', KP_DIVIDE, K_SHIFT, '*',
K_ALT, ' ', K_CAPSLOCK, K_F1, K_F2, K_F3, K_F4, K_F5, // 3
K_F6, K_F7, K_F8, K_F9, K_F10, KP_NUMLCK, 0, K_HOME,
K_UPARROW, K_PGUP, '-', K_LEFTARROW, '5', K_RIGHTARROW, '+', K_END, // 4
K_DOWNARROW, K_PGDN, K_INS, K_DEL, 0, 0, 0, K_F11,
K_F12, 0, 0, 0, 0, 0, 0, 0, // 5
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
/*
MapKey
Map from windows to quake keynums
*/
int
MapKey (int key)
{
int extended;
extended = (key >> 24) & 1;
key = (key >> 16) & 255;
if (key > 127)
return 0;
if (extended)
return extscantokey[key];
else
return scantokey[key];
}
void
AppActivate (BOOL fActive, BOOL minimize)
/****************************************************************************
*
* Function: AppActivate
* Parameters: fActive - True if app is activating
*
* Description: If the application is activating, then swap the system
* into SYSPAL_NOSTATIC mode so that our palettes will display
* correctly.
*
****************************************************************************/
{
HDC hdc;
int i, t;
static BOOL sound_active;
ActiveApp = fActive;
// messy, but it seems to work
if (vid_fulldib_on_focus_mode) {
Minimized = minimize;
if (Minimized)
ActiveApp = false;
}
MGL_appActivate (windc, ActiveApp);
if (vid_initialized) {
// yield the palette if we're losing the focus
hdc = GetDC (NULL);
if (GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
if (ActiveApp) {
if ((modestate == MS_WINDOWED) || (modestate == MS_FULLDIB)) {
if (GetSystemPaletteUse (hdc) == SYSPAL_STATIC) {
// switch to SYSPAL_NOSTATIC and remap the colors
SetSystemPaletteUse (hdc, SYSPAL_NOSTATIC);
syscolchg = true;
pal_is_nostatic = true;
}
}
} else if (pal_is_nostatic) {
if (GetSystemPaletteUse (hdc) == SYSPAL_NOSTATIC) {
// switch back to SYSPAL_STATIC and the old mapping
SetSystemPaletteUse (hdc, SYSPAL_STATIC);
syscolchg = true;
}
pal_is_nostatic = false;
}
}
if (!Minimized)
VID_SetPalette (vid_curpal);
scr_fullupdate = 0;
ReleaseDC (NULL, hdc);
}
// enable/disable sound on focus gain/loss
if (!ActiveApp && sound_active) {
S_BlockSound ();
S_ClearBuffer ();
sound_active = false;
} else if (ActiveApp && !sound_active) {
S_UnblockSound ();
S_ClearBuffer ();
sound_active = true;
}
// minimize/restore fulldib windows/mouse-capture normal windows on demand
if (!in_mode_set) {
if (ActiveApp) {
if (vid_fulldib_on_focus_mode) {
if (vid_initialized) {
msg_suppress_1 = true; // don't want to see normal mode
// set message
VID_SetMode (vid_fulldib_on_focus_mode, vid_curpal);
msg_suppress_1 = false;
t = in_mode_set;
in_mode_set = true;
AppActivate (true, false);
in_mode_set = t;
}
IN_ActivateMouse ();
IN_HideMouse ();
}
else if ((modestate == MS_WINDOWED) && _windowed_mouse->int_val
&& key_dest == key_game) {
IN_ActivateMouse ();
IN_HideMouse ();
}
}
if (!ActiveApp) {
if (modestate == MS_FULLDIB) {
if (vid_initialized) {
force_minimized = true;
i = vid_fulldib_on_focus_mode;
msg_suppress_1 = true; // don't want to see normal mode
// set message
VID_SetMode (windowed_default, vid_curpal);
msg_suppress_1 = false;
vid_fulldib_on_focus_mode = i;
force_minimized = false;
// we never seem to get WM_ACTIVATE inactive from this
// mode set, so we'll
// do it manually
t = in_mode_set;
in_mode_set = true;
AppActivate (false, true);
in_mode_set = t;
}
IN_DeactivateMouse ();
IN_ShowMouse ();
} else if ((modestate == MS_WINDOWED) && _windowed_mouse->int_val /* &&
mouseactive
*/ ) {
IN_DeactivateMouse ();
IN_ShowMouse ();
}
}
}
}
/*
VID_HandlePause
*/
void
VID_HandlePause (qboolean pause)
{
#if 0
if ((modestate == MS_WINDOWED) && _windowed_mouse->int_val) {
if (pause) {
IN_DeactivateMouse ();
IN_ShowMouse ();
} else {
IN_ActivateMouse ();
IN_HideMouse ();
}
}
#endif
}
/*
MAIN WINDOW
*/
LONG CDAudio_MessageHandler (HWND hWnd, UINT uMsg, WPARAM wParam,
LPARAM lParam);
/* main window procedure */
LONG WINAPI
MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
int fActive, fMinimized, temp;
HDC hdc;
PAINTSTRUCT ps;
extern unsigned int uiWheelMessage;
if (uMsg == uiWheelMessage) {
uMsg = WM_MOUSEWHEEL;
wParam <<= 16;
}
switch (uMsg) {
case WM_CREATE:
break;
case WM_SYSCOMMAND:
// Check for maximize being hit
switch (wParam & ~0x0F) {
case SC_MAXIMIZE:
// if minimized, bring up as a window before going
// fullscreen,
// so MGL will have the right state to restore
if (Minimized) {
force_mode_set = true;
VID_SetMode (vid_modenum, vid_curpal);
force_mode_set = false;
}
VID_SetMode (vid_fullscreen_mode->int_val, vid_curpal);
break;
case SC_SCREENSAVE:
case SC_MONITORPOWER:
if (modestate != MS_WINDOWED) {
// don't call DefWindowProc() because we don't want
// to start
// the screen saver fullscreen
break;
}
// fall through windowed and allow the screen saver to
// start
default:
if (!in_mode_set) {
S_BlockSound ();
S_ClearBuffer ();
}
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
if (!in_mode_set) {
S_UnblockSound ();
}
}
break;
case WM_MOVE:
window_x = (int) LOWORD (lParam);
window_y = (int) HIWORD (lParam);
VID_UpdateWindowStatus ();
if ((modestate == MS_WINDOWED) && !in_mode_set && !Minimized)
VID_RememberWindowPos ();
break;
case WM_SIZE:
Minimized = false;
if (!(wParam & SIZE_RESTORED)) {
if (wParam & SIZE_MINIMIZED)
Minimized = true;
}
break;
case WM_SYSCHAR:
// keep Alt-Space from happening
break;
case WM_ACTIVATE:
fActive = LOWORD (wParam);
fMinimized = (BOOL) HIWORD (wParam);
AppActivate (!(fActive == WA_INACTIVE), fMinimized);
// fix the leftover Alt from any Alt-Tab or the like that
// switched us away
ClearAllStates ();
if (!in_mode_set) {
if (windc)
MGL_activatePalette (windc, true);
VID_SetPalette (vid_curpal);
}
break;
case WM_PAINT:
hdc = BeginPaint (hWnd, &ps);
if (!in_mode_set && host_initialized)
SCR_UpdateWholeScreen ();
EndPaint (hWnd, &ps);
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
if (!in_mode_set)
Key_Event (MapKey (lParam), -1, true);
break;
case WM_KEYUP:
case WM_SYSKEYUP:
if (!in_mode_set)
Key_Event (MapKey (lParam), -1, false);
break;
// this is complicated because Win32 seems to pack multiple mouse
// events into
// one update sometimes, so we always check all states and look
// for events
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_MOUSEMOVE:
if (!in_mode_set) {
temp = 0;
if (wParam & MK_LBUTTON)
temp |= 1;
if (wParam & MK_RBUTTON)
temp |= 2;
if (wParam & MK_MBUTTON)
temp |= 4;
IN_MouseEvent (temp);
}
break;
// JACK: This is the mouse wheel with the Intellimouse
// Its delta is either positive or neg, and we generate the
// proper
// Event.
case WM_MOUSEWHEEL:
if ((short) HIWORD (wParam) > 0) {
Key_Event (K_MWHEELUP, -1, true);
Key_Event (K_MWHEELUP, -1, false);
} else {
Key_Event (K_MWHEELDOWN, -1, true);
Key_Event (K_MWHEELDOWN, -1, false);
}
break;
// KJB: Added these new palette functions
case WM_PALETTECHANGED:
if ((HWND) wParam == hWnd)
break;
/* Fall through to WM_QUERYNEWPALETTE */
case WM_QUERYNEWPALETTE:
hdc = GetDC (NULL);
if (GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE)
vid_palettized = true;
else
vid_palettized = false;
ReleaseDC (NULL, hdc);
scr_fullupdate = 0;
if (vid_initialized && !in_mode_set && windc
&& MGL_activatePalette (windc, false) && !Minimized) {
VID_SetPalette (vid_curpal);
InvalidateRect (mainwindow, NULL, false);
// specifically required if WM_QUERYNEWPALETTE realizes a new
// palette
lRet = TRUE;
}
break;
case WM_DISPLAYCHANGE:
if (!in_mode_set && (modestate == MS_WINDOWED)
&& !vid_fulldib_on_focus_mode) {
force_mode_set = true;
VID_SetMode (vid_modenum, vid_curpal);
force_mode_set = false;
}
break;
case WM_CLOSE:
// this causes Close in the right-click task bar menu not to
// work, but right
// now bad things happen if Close is handled in that case
// (garbage and a
// crash on Win95)
if (!in_mode_set) {
if (MessageBox
(mainwindow, "Are you sure you want to quit?",
"Confirm Exit",
MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION) == IDYES) {
Sys_Quit ();
}
}
break;
case MM_MCINOTIFY:
lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam);
break;
default:
/* pass all unhandled messages to DefWindowProc */
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
/* return 0 if handled message, 1 if not */
return lRet;
}
extern void M_Menu_Options_f (void);
extern void M_Print (int cx, int cy, char *str);
extern void M_PrintWhite (int cx, int cy, char *str);
extern void M_DrawCharacter (int cx, int line, int num);
extern void M_DrawTransPic (int x, int y, qpic_t *pic);
extern void M_DrawPic (int x, int y, qpic_t *pic);
static int vid_line, vid_wmodes;
typedef struct {
int modenum;
char *desc;
int iscur;
int ismode13;
int width;
} modedesc_t;
#define MAX_COLUMN_SIZE 5
#define MODE_AREA_HEIGHT (MAX_COLUMN_SIZE + 6)
#define MAX_MODEDESCS (MAX_COLUMN_SIZE*3)
static modedesc_t modedescs[MAX_MODEDESCS];
/*
VID_MenuDraw
*/
void
VID_MenuDraw (void)
{
qpic_t *p;
char *ptr;
int lnummodes, i, j, k, column, row, dup, dupmode = 0;
char temp[100];
vmode_t *pv;
modedesc_t tmodedesc;
p = Draw_CachePic ("gfx/vidmodes.lmp");
M_DrawPic ((320 - p->width) / 2, 4, p);
for (i = 0; i < 3; i++) {
ptr = VID_GetModeDescriptionMemCheck (i);
modedescs[i].modenum = modelist[i].modenum;
modedescs[i].desc = ptr;
modedescs[i].ismode13 = 0;
modedescs[i].iscur = 0;
if (vid_modenum == i)
modedescs[i].iscur = 1;
}
vid_wmodes = 3;
lnummodes = VID_NumModes ();
for (i = 3; i < lnummodes; i++) {
ptr = VID_GetModeDescriptionMemCheck (i);
pv = VID_GetModePtr (i);
// we only have room for 15 fullscreen modes, so don't allow
// 360-wide modes, because if there are 5 320-wide modes and
// 5 360-wide modes, we'll run out of space
if (ptr && ((pv->width != 360) || COM_CheckParm ("-allow360"))) {
dup = 0;
for (j = 3; j < vid_wmodes; j++) {
if (!strcmp (modedescs[j].desc, ptr)) {
dup = 1;
dupmode = j;
break;
}
}
if (dup || (vid_wmodes < MAX_MODEDESCS)) {
if (!dup || !modedescs[dupmode].ismode13
|| COM_CheckParm ("-noforcevga")) {
if (dup) {
k = dupmode;
} else {
k = vid_wmodes;
}
modedescs[k].modenum = i;
modedescs[k].desc = ptr;
modedescs[k].ismode13 = pv->mode13;
modedescs[k].iscur = 0;
modedescs[k].width = pv->width;
if (i == vid_modenum)
modedescs[k].iscur = 1;
if (!dup)
vid_wmodes++;
}
}
}
}
// sort the modes on width (to handle picking up oddball dibonly modes
// after all the others)
for (i = 3; i < (vid_wmodes - 1); i++) {
for (j = (i + 1); j < vid_wmodes; j++) {
if (modedescs[i].width > modedescs[j].width) {
tmodedesc = modedescs[i];
modedescs[i] = modedescs[j];
modedescs[j] = tmodedesc;
}
}
}
M_Print (13 * 8, 36, "Windowed Modes");
column = 16;
row = 36 + 2 * 8;
for (i = 0; i < 3; i++) {
if (modedescs[i].iscur)
M_PrintWhite (column, row, modedescs[i].desc);
else
M_Print (column, row, modedescs[i].desc);
column += 13 * 8;
}
if (vid_wmodes > 3) {
M_Print (12 * 8, 36 + 4 * 8, "Fullscreen Modes");
column = 16;
row = 36 + 6 * 8;
for (i = 3; i < vid_wmodes; i++) {
if (modedescs[i].iscur)
M_PrintWhite (column, row, modedescs[i].desc);
else
M_Print (column, row, modedescs[i].desc);
column += 13 * 8;
if (((i - 3) % VID_ROW_SIZE) == (VID_ROW_SIZE - 1)) {
column = 16;
row += 8;
}
}
}
// line cursor
if (vid_testingmode) {
snprintf (temp, sizeof (temp), "TESTING %s", modedescs[vid_line].desc);
M_Print (13 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 4, temp);
M_Print (9 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 6,
"Please wait 5 seconds...");
} else {
M_Print (9 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8,
"Press Enter to set mode");
M_Print (6 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 3,
"T to test mode for 5 seconds");
ptr = VID_GetModeDescription2 (vid_modenum);
if (ptr) {
snprintf (temp, sizeof (temp), "D to set default: %s", ptr);
M_Print (2 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 5, temp);
}
ptr = VID_GetModeDescription2 (_vid_default_mode_win->int_val);
if (ptr) {
snprintf (temp, sizeof (temp), "Current default: %s", ptr);
M_Print (3 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 6, temp);
}
M_Print (15 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 8, "Esc to exit");
row = 36 + 2 * 8 + (vid_line / VID_ROW_SIZE) * 8;
column = 8 + (vid_line % VID_ROW_SIZE) * 13 * 8;
if (vid_line >= 3)
row += 3 * 8;
M_DrawCharacter (column, row, 12 + ((int) (realtime * 4) & 1));
}
}
/*
VID_MenuKey
*/
void
VID_MenuKey (int key)
{
if (vid_testingmode)
return;
switch (key) {
case K_ESCAPE:
S_LocalSound ("misc/menu1.wav");
M_Menu_Options_f ();
break;
case K_LEFTARROW:
S_LocalSound ("misc/menu1.wav");
vid_line = ((vid_line / VID_ROW_SIZE) * VID_ROW_SIZE) +
((vid_line + 2) % VID_ROW_SIZE);
if (vid_line >= vid_wmodes)
vid_line = vid_wmodes - 1;
break;
case K_RIGHTARROW:
S_LocalSound ("misc/menu1.wav");
vid_line = ((vid_line / VID_ROW_SIZE) * VID_ROW_SIZE) +
((vid_line + 4) % VID_ROW_SIZE);
if (vid_line >= vid_wmodes)
vid_line = (vid_line / VID_ROW_SIZE) * VID_ROW_SIZE;
break;
case K_UPARROW:
S_LocalSound ("misc/menu1.wav");
vid_line -= VID_ROW_SIZE;
if (vid_line < 0) {
vid_line += ((vid_wmodes + (VID_ROW_SIZE - 1)) /
VID_ROW_SIZE) * VID_ROW_SIZE;
while (vid_line >= vid_wmodes)
vid_line -= VID_ROW_SIZE;
}
break;
case K_DOWNARROW:
S_LocalSound ("misc/menu1.wav");
vid_line += VID_ROW_SIZE;
if (vid_line >= vid_wmodes) {
vid_line -= ((vid_wmodes + (VID_ROW_SIZE - 1)) /
VID_ROW_SIZE) * VID_ROW_SIZE;
while (vid_line < 0)
vid_line += VID_ROW_SIZE;
}
break;
case K_ENTER:
S_LocalSound ("misc/menu1.wav");
VID_SetMode (modedescs[vid_line].modenum, vid_curpal);
break;
case 'T':
case 't':
S_LocalSound ("misc/menu1.wav");
// have to set this before setting the mode because WM_PAINT
// happens during the mode set and does a VID_Update, which
// checks vid_testingmode
vid_testingmode = 1;
vid_testendtime = realtime + 5.0;
if (!VID_SetMode (modedescs[vid_line].modenum, vid_curpal)) {
vid_testingmode = 0;
}
break;
case 'D':
case 'd':
S_LocalSound ("misc/menu1.wav");
firstupdate = 0;
Cvar_SetValue (_vid_default_mode_win, vid_modenum);
break;
default:
break;
}
}
void
VID_SetCaption (char *text)
{
if (text && *text) {
char *temp = strdup (text);
SetWindowText (mainwindow,
(LPSTR) va ("%s %s: %s", PROGRAM, VERSION, text));
free (temp);
} else {
SetWindowText (mainwindow, (LPSTR) va ("%s %s", PROGRAM, VERSION));
}
}
Reference in a new issue View git blame Copy permalink