mirror of
https://git.code.sf.net/p/quake/quake2forge
synced 2024-12-14 06:31:20 +00:00
492 lines
11 KiB
C
492 lines
11 KiB
C
// Main windowed and fullscreen graphics interface module. This module
|
|
// is used for both the software and OpenGL rendering versions of the
|
|
// Quake refresh engine.
|
|
|
|
#define SO_FILE "/etc/quake2.conf"
|
|
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
#include <dlfcn.h> // ELF dl loader
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include "../client/client.h"
|
|
|
|
#include "../linux/rw_linux.h"
|
|
|
|
// Structure containing functions exported from refresh DLL
|
|
refexport_t re;
|
|
|
|
#ifdef REF_HARD_LINKED
|
|
refexport_t GetRefAPI (refimport_t rimp);
|
|
#endif
|
|
|
|
// Console variables that we need to access from this module
|
|
cvar_t *vid_gamma;
|
|
cvar_t *vid_ref; // Name of Refresh DLL loaded
|
|
cvar_t *vid_xpos; // X coordinate of window position
|
|
cvar_t *vid_ypos; // Y coordinate of window position
|
|
cvar_t *vid_fullscreen;
|
|
|
|
// Global variables used internally by this module
|
|
viddef_t viddef; // global video state; used by other modules
|
|
void *reflib_library; // Handle to refresh DLL
|
|
qboolean reflib_active = 0;
|
|
|
|
#define VID_NUM_MODES ( sizeof( vid_modes ) / sizeof( vid_modes[0] ) )
|
|
|
|
/** KEYBOARD **************************************************************/
|
|
|
|
void Do_Key_Event(int key, qboolean down);
|
|
|
|
void (*KBD_Update_fp)(void);
|
|
void (*KBD_Init_fp)(Key_Event_fp_t fp);
|
|
void (*KBD_Close_fp)(void);
|
|
|
|
/** MOUSE *****************************************************************/
|
|
|
|
in_state_t in_state;
|
|
|
|
void (*RW_IN_Init_fp)(in_state_t *in_state_p);
|
|
void (*RW_IN_Shutdown_fp)(void);
|
|
void (*RW_IN_Activate_fp)(qboolean active);
|
|
void (*RW_IN_Commands_fp)(void);
|
|
void (*RW_IN_Move_fp)(usercmd_t *cmd);
|
|
void (*RW_IN_Frame_fp)(void);
|
|
|
|
void Real_IN_Init (void);
|
|
|
|
/*
|
|
==========================================================================
|
|
|
|
DLL GLUE
|
|
|
|
==========================================================================
|
|
*/
|
|
|
|
#define MAXPRINTMSG 4096
|
|
void VID_Printf (int print_level, char *fmt, ...)
|
|
{
|
|
va_list argptr;
|
|
char msg[MAXPRINTMSG];
|
|
static qboolean inupdate;
|
|
|
|
va_start (argptr,fmt);
|
|
vsprintf (msg,fmt,argptr);
|
|
va_end (argptr);
|
|
|
|
if (print_level == PRINT_ALL)
|
|
Com_Printf ("%s", msg);
|
|
else
|
|
Com_DPrintf ("%s", msg);
|
|
}
|
|
|
|
void VID_Error (int err_level, char *fmt, ...)
|
|
{
|
|
va_list argptr;
|
|
char msg[MAXPRINTMSG];
|
|
static qboolean inupdate;
|
|
|
|
va_start (argptr,fmt);
|
|
vsprintf (msg,fmt,argptr);
|
|
va_end (argptr);
|
|
|
|
Com_Error (err_level,"%s", msg);
|
|
}
|
|
|
|
//==========================================================================
|
|
|
|
/*
|
|
============
|
|
VID_Restart_f
|
|
|
|
Console command to re-start the video mode and refresh DLL. We do this
|
|
simply by setting the modified flag for the vid_ref variable, which will
|
|
cause the entire video mode and refresh DLL to be reset on the next frame.
|
|
============
|
|
*/
|
|
void VID_Restart_f (void)
|
|
{
|
|
vid_ref->modified = true;
|
|
}
|
|
|
|
/*
|
|
** VID_GetModeInfo
|
|
*/
|
|
typedef struct vidmode_s
|
|
{
|
|
const char *description;
|
|
int width, height;
|
|
int mode;
|
|
} vidmode_t;
|
|
|
|
vidmode_t vid_modes[] =
|
|
{
|
|
{ "Mode 0: 320x240", 320, 240, 0 },
|
|
{ "Mode 1: 400x300", 400, 300, 1 },
|
|
{ "Mode 2: 512x384", 512, 384, 2 },
|
|
{ "Mode 3: 640x480", 640, 480, 3 },
|
|
{ "Mode 4: 800x600", 800, 600, 4 },
|
|
{ "Mode 5: 960x720", 960, 720, 5 },
|
|
{ "Mode 6: 1024x768", 1024, 768, 6 },
|
|
{ "Mode 7: 1152x864", 1152, 864, 7 },
|
|
{ "Mode 8: 1280x1024", 1280, 1024, 8 },
|
|
{ "Mode 9: 1600x1200", 1600, 1200, 9 }
|
|
};
|
|
|
|
qboolean VID_GetModeInfo( int *width, int *height, int mode )
|
|
{
|
|
if ( mode < 0 || mode >= VID_NUM_MODES )
|
|
return false;
|
|
|
|
*width = vid_modes[mode].width;
|
|
*height = vid_modes[mode].height;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
** VID_NewWindow
|
|
*/
|
|
void VID_NewWindow ( int width, int height)
|
|
{
|
|
viddef.width = width;
|
|
viddef.height = height;
|
|
}
|
|
|
|
void VID_FreeReflib (void)
|
|
{
|
|
if (reflib_library) {
|
|
if (KBD_Close_fp)
|
|
KBD_Close_fp();
|
|
if (RW_IN_Shutdown_fp)
|
|
RW_IN_Shutdown_fp();
|
|
#ifndef REF_HARD_LINKED
|
|
dlclose(reflib_library);
|
|
#endif
|
|
}
|
|
|
|
KBD_Init_fp = NULL;
|
|
KBD_Update_fp = NULL;
|
|
KBD_Close_fp = NULL;
|
|
RW_IN_Init_fp = NULL;
|
|
RW_IN_Shutdown_fp = NULL;
|
|
RW_IN_Activate_fp = NULL;
|
|
RW_IN_Commands_fp = NULL;
|
|
RW_IN_Move_fp = NULL;
|
|
RW_IN_Frame_fp = NULL;
|
|
|
|
memset (&re, 0, sizeof(re));
|
|
reflib_library = NULL;
|
|
reflib_active = false;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
VID_LoadRefresh
|
|
==============
|
|
*/
|
|
qboolean VID_LoadRefresh( char *name )
|
|
{
|
|
refimport_t ri;
|
|
#ifndef REF_HARD_LINKED
|
|
GetRefAPI_t GetRefAPI;
|
|
#endif
|
|
char fn[MAX_OSPATH];
|
|
struct stat st;
|
|
extern uid_t saved_euid;
|
|
FILE *fp;
|
|
char *path;
|
|
char curpath[MAX_OSPATH];
|
|
|
|
if ( reflib_active )
|
|
{
|
|
if (KBD_Close_fp)
|
|
KBD_Close_fp();
|
|
if (RW_IN_Shutdown_fp)
|
|
RW_IN_Shutdown_fp();
|
|
KBD_Close_fp = NULL;
|
|
RW_IN_Shutdown_fp = NULL;
|
|
re.Shutdown();
|
|
VID_FreeReflib ();
|
|
}
|
|
|
|
#ifndef REF_HARD_LINKED
|
|
getcwd(curpath, sizeof(curpath));
|
|
|
|
Com_Printf( "------- Loading %s -------\n", name );
|
|
|
|
// now run through the search paths
|
|
path = NULL;
|
|
while (1)
|
|
{
|
|
path = FS_NextPath (path);
|
|
if (!path)
|
|
return NULL; // couldn't find one anywhere
|
|
sprintf (fn, "%s/%s/%s", curpath, path, name);
|
|
Com_Printf ("Trying to load library (%s)\n", fn);
|
|
|
|
reflib_library = dlopen( fn, RTLD_NOW );
|
|
if (reflib_library)
|
|
{
|
|
Com_DPrintf ("LoadLibrary (%s)\n",name);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
ri.Cmd_AddCommand = Cmd_AddCommand;
|
|
ri.Cmd_RemoveCommand = Cmd_RemoveCommand;
|
|
ri.Cmd_Argc = Cmd_Argc;
|
|
ri.Cmd_Argv = Cmd_Argv;
|
|
ri.Cmd_ExecuteText = Cbuf_ExecuteText;
|
|
ri.Con_Printf = VID_Printf;
|
|
ri.Sys_Error = VID_Error;
|
|
ri.FS_LoadFile = FS_LoadFile;
|
|
ri.FS_FreeFile = FS_FreeFile;
|
|
ri.FS_Gamedir = FS_Gamedir;
|
|
ri.Cvar_Get = Cvar_Get;
|
|
ri.Cvar_Set = Cvar_Set;
|
|
ri.Cvar_SetValue = Cvar_SetValue;
|
|
ri.Vid_GetModeInfo = VID_GetModeInfo;
|
|
ri.Vid_MenuInit = VID_MenuInit;
|
|
ri.Vid_NewWindow = VID_NewWindow;
|
|
|
|
#ifndef REF_HARD_LINKED
|
|
if ( ( GetRefAPI = (void *) dlsym( reflib_library, "GetRefAPI" ) ) == 0 )
|
|
Com_Error( ERR_FATAL, "dlsym failed on %s", name );
|
|
#endif
|
|
re = GetRefAPI( ri );
|
|
|
|
if (re.api_version != API_VERSION)
|
|
{
|
|
VID_FreeReflib ();
|
|
Com_Error (ERR_FATAL, "%s has incompatible api_version", name);
|
|
}
|
|
|
|
/* Init IN (Mouse) */
|
|
in_state.IN_CenterView_fp = IN_CenterView;
|
|
in_state.Key_Event_fp = Do_Key_Event;
|
|
in_state.viewangles = cl.viewangles;
|
|
in_state.in_strafe_state = &in_strafe.state;
|
|
|
|
#ifndef REF_HARD_LINKED
|
|
if ((RW_IN_Init_fp = dlsym(reflib_library, "RW_IN_Init")) == NULL ||
|
|
(RW_IN_Shutdown_fp = dlsym(reflib_library, "RW_IN_Shutdown")) == NULL ||
|
|
(RW_IN_Activate_fp = dlsym(reflib_library, "RW_IN_Activate")) == NULL ||
|
|
(RW_IN_Commands_fp = dlsym(reflib_library, "RW_IN_Commands")) == NULL ||
|
|
(RW_IN_Move_fp = dlsym(reflib_library, "RW_IN_Move")) == NULL ||
|
|
(RW_IN_Frame_fp = dlsym(reflib_library, "RW_IN_Frame")) == NULL)
|
|
Sys_Error("No RW_IN functions in REF.\n");
|
|
#else
|
|
{
|
|
void RW_IN_Init(in_state_t *in_state_p);
|
|
void RW_IN_Shutdown(void);
|
|
void RW_IN_Commands (void);
|
|
void RW_IN_Move (usercmd_t *cmd);
|
|
void RW_IN_Frame (void);
|
|
void RW_IN_Activate(void);
|
|
|
|
RW_IN_Init_fp = RW_IN_Init;
|
|
RW_IN_Shutdown_fp = RW_IN_Shutdown;
|
|
RW_IN_Activate_fp = RW_IN_Activate;
|
|
RW_IN_Commands_fp = RW_IN_Commands;
|
|
RW_IN_Move_fp = RW_IN_Move;
|
|
RW_IN_Frame_fp = RW_IN_Frame;
|
|
}
|
|
#endif
|
|
|
|
if ( re.Init( 0, 0 ) == -1 )
|
|
{
|
|
re.Shutdown();
|
|
VID_FreeReflib ();
|
|
return false;
|
|
}
|
|
|
|
// give up root now
|
|
setreuid(getuid(), getuid());
|
|
setegid(getgid());
|
|
|
|
/* Init KBD */
|
|
#ifndef REF_HARD_LINKED
|
|
if ((KBD_Init_fp = dlsym(reflib_library, "KBD_Init")) == NULL ||
|
|
(KBD_Update_fp = dlsym(reflib_library, "KBD_Update")) == NULL ||
|
|
(KBD_Close_fp = dlsym(reflib_library, "KBD_Close")) == NULL)
|
|
Sys_Error("No KBD functions in REF.\n");
|
|
#else
|
|
{
|
|
void KBD_Init(void);
|
|
void KBD_Update(void);
|
|
void KBD_Close(void);
|
|
|
|
KBD_Init_fp = KBD_Init;
|
|
KBD_Update_fp = KBD_Update;
|
|
KBD_Close_fp = KBD_Close;
|
|
}
|
|
#endif
|
|
KBD_Init_fp(Do_Key_Event);
|
|
Real_IN_Init();
|
|
|
|
Com_Printf( "------------------------------------\n");
|
|
reflib_active = true;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
VID_CheckChanges
|
|
|
|
This function gets called once just before drawing each frame, and it's sole purpose in life
|
|
is to check to see if any of the video mode parameters have changed, and if they have to
|
|
update the rendering DLL and/or video mode to match.
|
|
============
|
|
*/
|
|
void VID_CheckChanges (void)
|
|
{
|
|
char name[100];
|
|
cvar_t *sw_mode;
|
|
|
|
if ( vid_ref->modified )
|
|
{
|
|
S_StopAllSounds();
|
|
}
|
|
|
|
while (vid_ref->modified)
|
|
{
|
|
/*
|
|
** refresh has changed
|
|
*/
|
|
vid_ref->modified = false;
|
|
vid_fullscreen->modified = true;
|
|
cl.refresh_prepped = false;
|
|
cls.disable_screen = true;
|
|
|
|
sprintf( name, "ref_%s.so", vid_ref->string );
|
|
if ( !VID_LoadRefresh( name ) )
|
|
{
|
|
if ( strcmp (vid_ref->string, "soft") == 0 ) {
|
|
Com_Printf("Refresh failed\n");
|
|
sw_mode = Cvar_Get( "sw_mode", "0", 0 );
|
|
if (sw_mode->value != 0) {
|
|
Com_Printf("Trying mode 0\n");
|
|
Cvar_SetValue("sw_mode", 0);
|
|
if ( !VID_LoadRefresh( name ) )
|
|
Com_Error (ERR_FATAL, "Couldn't fall back to software refresh!");
|
|
} else
|
|
Com_Error (ERR_FATAL, "Couldn't fall back to software refresh!");
|
|
}
|
|
|
|
Cvar_Set( "vid_ref", "soft" );
|
|
|
|
/*
|
|
** drop the console if we fail to load a refresh
|
|
*/
|
|
if ( cls.key_dest != key_console )
|
|
{
|
|
Con_ToggleConsole_f();
|
|
}
|
|
}
|
|
cls.disable_screen = false;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
============
|
|
VID_Init
|
|
============
|
|
*/
|
|
void VID_Init (void)
|
|
{
|
|
/* Create the video variables so we know how to start the graphics drivers */
|
|
vid_ref = Cvar_Get ("vid_ref", "soft", CVAR_ARCHIVE);
|
|
vid_xpos = Cvar_Get ("vid_xpos", "3", CVAR_ARCHIVE);
|
|
vid_ypos = Cvar_Get ("vid_ypos", "22", CVAR_ARCHIVE);
|
|
vid_fullscreen = Cvar_Get ("vid_fullscreen", "0", CVAR_ARCHIVE);
|
|
vid_gamma = Cvar_Get( "vid_gamma", "1", CVAR_ARCHIVE );
|
|
|
|
/* Add some console commands that we want to handle */
|
|
Cmd_AddCommand ("vid_restart", VID_Restart_f);
|
|
|
|
/* Disable the 3Dfx splash screen */
|
|
putenv("FX_GLIDE_NO_SPLASH=0");
|
|
|
|
/* Start the graphics mode and load refresh DLL */
|
|
VID_CheckChanges();
|
|
}
|
|
|
|
/*
|
|
============
|
|
VID_Shutdown
|
|
============
|
|
*/
|
|
void VID_Shutdown (void)
|
|
{
|
|
if ( reflib_active )
|
|
{
|
|
if (KBD_Close_fp)
|
|
KBD_Close_fp();
|
|
if (RW_IN_Shutdown_fp)
|
|
RW_IN_Shutdown_fp();
|
|
KBD_Close_fp = NULL;
|
|
RW_IN_Shutdown_fp = NULL;
|
|
re.Shutdown ();
|
|
VID_FreeReflib ();
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* INPUT */
|
|
/*****************************************************************************/
|
|
|
|
cvar_t *in_joystick;
|
|
|
|
// This if fake, it's acutally done by the Refresh load
|
|
void IN_Init (void)
|
|
{
|
|
in_joystick = Cvar_Get ("in_joystick", "0", CVAR_ARCHIVE);
|
|
}
|
|
|
|
void Real_IN_Init (void)
|
|
{
|
|
if (RW_IN_Init_fp)
|
|
RW_IN_Init_fp(&in_state);
|
|
}
|
|
|
|
void IN_Shutdown (void)
|
|
{
|
|
if (RW_IN_Shutdown_fp)
|
|
RW_IN_Shutdown_fp();
|
|
}
|
|
|
|
void IN_Commands (void)
|
|
{
|
|
if (RW_IN_Commands_fp)
|
|
RW_IN_Commands_fp();
|
|
}
|
|
|
|
void IN_Move (usercmd_t *cmd)
|
|
{
|
|
if (RW_IN_Move_fp)
|
|
RW_IN_Move_fp(cmd);
|
|
}
|
|
|
|
void IN_Frame (void)
|
|
{
|
|
if (RW_IN_Frame_fp)
|
|
RW_IN_Frame_fp();
|
|
}
|
|
|
|
void IN_Activate (qboolean active)
|
|
{
|
|
if (RW_IN_Activate_fp)
|
|
RW_IN_Activate_fp(active);
|
|
}
|
|
|
|
void Do_Key_Event(int key, qboolean down)
|
|
{
|
|
Key_Event(key, down, Sys_Milliseconds());
|
|
}
|
|
|