/*
===============
R_InitParticles
===============
*/
void R_InitParticles (void)
{
int i;
i = COM_CheckParm ("-particles");
if (i)
{
r_numparticles = (int)(Q_atoi(com_argv[i+1]));
if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
r_numparticles = ABSOLUTE_MIN_PARTICLES;
}
else
{
r_numparticles = MAX_PARTICLES;
}
particles = (particle_t *)
Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
}
/*
================
Sys_InitFloatTime
================
*/
void Sys_InitFloatTime(void)
{
int j;
Sys_FloatTime();
oldtime = curtime;
j = COM_CheckParm("-starttime");
if (j)
{
curtime = (double)(Q_atof(com_argv[j+1]));
}
else
{
curtime = 0.0;
}
lastcurtime = curtime;
}
void InitHWGamma (void)
{
#ifdef USE_VMODE
int xf86vm_gammaramp_size;
if (COM_CheckParm("-nohwgamma"))
return;
XF86VidModeGetGammaRampSize(x_disp, scrnum, &xf86vm_gammaramp_size);
vid_gammaworks = (xf86vm_gammaramp_size == 256);
if (vid_gammaworks)
{
XF86VidModeGetGammaRamp(x_disp,scrnum,xf86vm_gammaramp_size,
systemgammaramp[0], systemgammaramp[1], systemgammaramp[2]);
}
vid_hwgamma_enabled = vid_hwgammacontrol.value && vid_gammaworks; // && fullscreen?
#endif
}
/*
===============
R_InitParticles
===============
*/
void R_InitParticles (void)
{
int i;
FILE *f;
i = COM_CheckParm ("-particles");
MyTable[0] = 254;
if (i)
{
r_numparticles = (int)(atoi(com_argv[i+1]));
if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
r_numparticles = ABSOLUTE_MIN_PARTICLES;
}
else
{
r_numparticles = MAX_PARTICLES;
}
particles = (particle_t *)
Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
Cvar_RegisterVariable (&leak_color);
//JFM: snow test
Cvar_RegisterVariable (&snow_flurry);
Cvar_RegisterVariable (&snow_active);
transTable = (byte *)malloc(65536);
if (!transTable)
Sys_Error ("Couldn't load gfx/tinttab.lmp");
COM_FOpenFile ("gfx/tinttab.lmp", &f, false);
if (f)
{
fread(transTable,1,65536,f);
fclose(f);
}
}
/*
===================
CFG_ReadCvarOverrides
convenience function, reading the "+" command line override
values of cvars in the given list. doesn't do anything with
the config file.
===================
*/
void CFG_ReadCvarOverrides (const char **vars, int num_vars)
{
char buff[64];
int i, j;
if (num_vars < 1)
return;
buff[0] = '+';
for (i = 0; i < num_vars; i++)
{
q_strlcpy (&buff[1], vars[i], sizeof(buff) - 1);
j = COM_CheckParm(buff);
if (j != 0 && j < com_argc - 1)
{
if (com_argv[j + 1][0] != '-' && com_argv[j + 1][0] != '+')
Cvar_Set(vars[i], com_argv[j + 1]);
}
}
}
void
IN_Init(void)
{
#ifdef USE_XF86DGA
int MajorVersion, MinorVersion;
#endif
keyboard_grab_active = false;
mouse_grab_active = false;
// FIXME - do proper detection?
// - Also, look at other vid_*.c files for clues
mouse_available = (COM_CheckParm("-nomouse")) ? false : true;
if (x_disp == NULL)
Sys_Error("x_disp not initialised before input...");
#ifdef USE_XF86DGA
dga_mouse_active = false;
if (!XF86DGAQueryVersion(x_disp, &MajorVersion, &MinorVersion)) {
Con_Printf("Failed to detect XF86DGA Mouse\n");
in_dgamouse.value = 0;
dga_available = false;
} else {
dga_available = true;
}
#endif
// Need to grab the input focus at startup, just in case...
// FIXME - must be viewable or get BadMatch
XSetInputFocus(x_disp, x_win, RevertToParent, CurrentTime);
IN_InitCvars();
if (VID_IsFullScreen()) {
if (!mouse_grab_active)
IN_GrabMouse();
if (!keyboard_grab_active)
IN_GrabKeyboard();
}
}
/*
================
VID_Init
================
*/
void VID_Init (unsigned char *palette)
{
vid_mode = Cvar_Get("vid_mode", "0", CVAR_NONE, "None");
vid_wait = Cvar_Get("vid_wait", "0", CVAR_NONE, "None");
vid_nopageflip = Cvar_Get("vid_nopageflip", "0", CVAR_ARCHIVE, "None");
_vid_wait_override = Cvar_Get("_vid_wait_override", "0", CVAR_ARCHIVE, "None");
_vid_default_mode = Cvar_Get("_vid_default_mode", "0", CVAR_ARCHIVE, "None");
_vid_default_mode_win = Cvar_Get("_vid_default_mode_win", "3", CVAR_ARCHIVE, "None");
vid_config_x = Cvar_Get("vid_config_x", "800", CVAR_ARCHIVE, "None");
vid_config_y = Cvar_Get("vid_config_y", "600", CVAR_ARCHIVE, "None");
vid_stretch_by_2 = Cvar_Get("vid_stretch_by_2", "1", CVAR_ARCHIVE, "None");
_windowed_mouse = Cvar_Get("_windowed_mouse", "0", CVAR_ARCHIVE, "None");
vid_fullscreen_mode = Cvar_Get("vid_fullscreen_mode", "3", CVAR_ARCHIVE, "None");
vid_windowed_mode = Cvar_Get("vid_windowed_mode", "0", CVAR_ARCHIVE, "None");
block_switch = Cvar_Get("block_switch", "0", CVAR_ARCHIVE, "None");
Cmd_AddCommand ("vid_testmode", VID_TestMode_f);
Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f);
Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);
// set up the mode list; note that later inits link in their modes ahead of
// earlier ones, so the standard VGA modes are always first in the list. This
// is important because mode 0 must always be VGA mode 0x13
if (!COM_CheckParm ("-stdvid"))
VID_InitExtra ();
VGA_Init ();
vid_testingmode = 0;
vid_modenum = vid_mode->int_val;
VID_SetMode (vid_modenum, palette);
vid_realmode = vid_modenum;
vid_menudrawfn = VID_MenuDraw;
vid_menukeyfn = VID_MenuKey;
}
/*
================
VID_Init
================
*/
void VID_Init (unsigned char *palette)
{
Cvar_RegisterVariable (&vid_mode);
Cvar_RegisterVariable (&vid_wait);
Cvar_RegisterVariable (&vid_nopageflip);
Cvar_RegisterVariable (&_vid_wait_override);
Cvar_RegisterVariable (&_vid_default_mode);
Cvar_RegisterVariable (&_vid_default_mode_win);
Cvar_RegisterVariable (&vid_config_x);
Cvar_RegisterVariable (&vid_config_y);
Cvar_RegisterVariable (&vid_stretch_by_2);
Cvar_RegisterVariable (&_windowed_mouse);
Cvar_RegisterVariable (&vid_fullscreen_mode);
Cvar_RegisterVariable (&vid_windowed_mode);
Cvar_RegisterVariable (&block_switch);
Cmd_AddCommand ("vid_testmode", VID_TestMode_f);
Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f);
Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);
// set up the mode list; note that later inits link in their modes ahead of
// earlier ones, so the standard VGA modes are always first in the list. This
// is important because mode 0 must always be VGA mode 0x13
if (!COM_CheckParm ("-stdvid"))
VID_InitExtra ();
VGA_Init ();
vid_testingmode = 0;
vid_modenum = vid_mode.value;
VID_SetMode (vid_modenum, palette);
vid_realmode = vid_modenum;
vid_menudrawfn = VID_MenuDraw;
vid_menukeyfn = VID_MenuKey;
}
int UDP_Init (void)
{
struct hostent *local;
char buff[MAXHOSTNAMELEN];
struct qsockaddr addr;
char *colon;
if (COM_CheckParm ("-noudp"))
return -1;
// determine my name & address
gethostname(buff, MAXHOSTNAMELEN);
local = gethostbyname(buff);
myAddr = *(int *)local->h_addr_list[0];
// if the quake hostname isn't set, set it to the machine name
if (Q_strcmp(hostname.string, "UNNAMED") == 0)
{
buff[15] = 0;
Cvar_Set ("hostname", buff);
}
if ((net_controlsocket = UDP_OpenSocket (0)) == -1)
Sys_Error("UDP_Init: Unable to open control socket\n");
((struct sockaddr_in *)&broadcastaddr)->sin_family = AF_INET;
((struct sockaddr_in *)&broadcastaddr)->sin_addr.s_addr = INADDR_BROADCAST;
((struct sockaddr_in *)&broadcastaddr)->sin_port = htons(net_hostport);
UDP_GetSocketAddr (net_controlsocket, &addr);
Q_strcpy(my_tcpip_address, UDP_AddrToString (&addr));
colon = Q_strrchr (my_tcpip_address, ':');
if (colon)
*colon = 0;
Con_Printf("UDP Initialized\n");
tcpipAvailable = true;
return net_controlsocket;
}
/*
=============
Sys_Init
Quake calls this so the system can register variables before host_hunklevel
is marked
=============
*/
void Sys_Init (void)
{
qbool WinNT;
OSVERSIONINFO vinfo;
// make sure the timer is high precision, otherwise
// NT gets 18ms resolution
timeBeginPeriod( 1 );
vinfo.dwOSVersionInfoSize = sizeof(vinfo);
if (!GetVersionEx (&vinfo))
Sys_Error ("Couldn't get OS info");
if (vinfo.dwMajorVersion < 4 || vinfo.dwPlatformId == VER_PLATFORM_WIN32s)
Sys_Error (SERVER_NAME " requires at least Win95 or NT 4.0");
WinNT = (vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT ? true : false);
Cvar_Register (&sys_nostdout);
Cvar_Register (&sys_sleep);
if (COM_CheckParm ("-nopriority"))
{
Cvar_Set (&sys_sleep, "0");
}
else
{
if ( ! SetPriorityClass (GetCurrentProcess(), HIGH_PRIORITY_CLASS))
Con_Printf ("SetPriorityClass() failed\n");
else
Con_Printf ("Process priority class set to HIGH\n");
// sys_sleep > 0 seems to cause packet loss on WinNT (why?)
if (WinNT)
Cvar_Set (&sys_sleep, "0");
}
Sys_InitDoubleTime ();
}
static void S_InitSys (void)
{
if (safemode || COM_CheckParm("-nosound") || COM_CheckParm("-s"))
snd_system = S_SYS_NULL;
#if HAVE_SDL_SOUND
else if (COM_CheckParm ("-sndsdl"))
snd_system = S_SYS_SDL;
#endif
#if HAVE_ALSA_SOUND
else if (COM_CheckParm ("-sndalsa"))
snd_system = S_SYS_ALSA;
#endif
#if HAVE_OSS_SOUND
else if (COM_CheckParm ("-sndoss"))
snd_system = S_SYS_OSS;
#endif
#if HAVE_SUN_SOUND
else if (COM_CheckParm ("-sndsun") || COM_CheckParm ("-sndbsd"))
snd_system = S_SYS_SUN;
#endif
else
#if HAVE_WIN_SOUND
snd_system = S_SYS_WIN;
#elif HAVE_DOS_SOUND
snd_system = S_SYS_DOS;
#elif HAVE_OSS_SOUND
snd_system = S_SYS_OSS;
#elif HAVE_SUN_SOUND
snd_system = S_SYS_SUN;
#elif HAVE_ALSA_SOUND
snd_system = S_SYS_ALSA;
#elif HAVE_SDL_SOUND
snd_system = S_SYS_SDL;
#else
snd_system = S_SYS_NULL;
#endif
}
/*
================
Con_Init
================
*/
void Con_Init (void)
{
con_debuglog = COM_CheckParm("-condebug");
con = &con_main;
con_linewidth = -1;
Con_CheckResize ();
Con_Printf ("Console initialized.\n");
//
// register our commands
//
Cvar_RegisterVariable (&con_notifytime);
Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
Cmd_AddCommand ("togglechat", Con_ToggleChat_f);
Cmd_AddCommand ("messagemode", Con_MessageMode_f);
Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
Cmd_AddCommand ("clear", Con_Clear_f);
con_initialized = true;
}
void Rulesets_Init (void)
{
int temp;
Cvar_Register (&ruleset);
if ((temp = COM_CheckParm ("-ruleset")) && temp + 1 < COM_Argc()) {
if (!strcasecmp (COM_Argv(temp + 1), "smackdown")) {
Cvar_Set (&ruleset, "smackdown");
return;
} else if (!strcasecmp (COM_Argv(temp + 1), "mtfl")) {
Cvar_Set (&ruleset, "mtfl");
return;
} else if (strcasecmp (COM_Argv(temp + 1), "default")){
Cvar_Set (&ruleset, "default");
return;
} else {
Rulesets_Default ();
return;
}
}
}
/*
================
Sys_InitTime
================
*/
static void Sys_InitTime (void)
{
#if !USE_UCLOCK_TIME
int j;
Sys_DoubleTime ();
oldtime = curtime;
j = COM_CheckParm("-starttime");
if (j && j < com_argc - 1)
{
curtime = (double) (atof(com_argv[j+1]));
}
else
{
curtime = 0.0;
}
lastcurtime = curtime;
#endif /* ! USE_UCLOCK_TIME */
}
/*
===============
Host_SaveConfig_f
Writes key bindings and archived cvars to config.cfg
===============
*/
static void Host_SaveConfig_to(const char *file)
{
qfile_t *f;
// dedicated servers initialize the host but don't parse and set the
// config.cfg cvars
// LordHavoc: don't save a config if it crashed in startup
if (host_framecount >= 3 && cls.state != ca_dedicated && !COM_CheckParm("-benchmark") && !COM_CheckParm("-capturedemo"))
{
f = FS_OpenRealFile(file, "wb", false);
if (!f)
{
Con_Printf("Couldn't write %s.\n", file);
return;
}
Key_WriteBindings (f);
Cvar_WriteVariables (f);
FS_Close (f);
}
}
/*
========================
Memory_Init
========================
*/
void Memory_Init (void *buf, int size)
{
int p;
int zonesize = DYNAMIC_SIZE;
hunk_base = (byte *)buf;
hunk_size = size;
hunk_low_used = 0;
hunk_high_used = 0;
Cache_Init ();
p = COM_CheckParm ("-zone");
if (p)
{
if (p < com_argc-1)
zonesize = Q_atoi (com_argv[p+1]) * 1024;
else
Sys_Error ("Memory_Init: you must specify a size in KB after -zone");
}
mainzone = (memzone_t *)Hunk_AllocName (zonesize, "zone" );
Z_ClearZone (mainzone, zonesize);
}
int Datagram_Init (void)
{
int i, num_inited;
sys_socket_t csock;
#ifdef BAN_TEST
banAddr.s_addr = INADDR_ANY;
banMask.s_addr = INADDR_NONE;
#endif
myDriverLevel = net_driverlevel;
Cmd_AddCommand ("net_stats", NET_Stats_f);
if (safemode || COM_CheckParm("-nolan"))
return -1;
num_inited = 0;
for (i = 0; i < net_numlandrivers; i++)
{
csock = net_landrivers[i].Init ();
if (csock == INVALID_SOCKET)
continue;
net_landrivers[i].initialized = true;
net_landrivers[i].controlSock = csock;
num_inited++;
}
if (num_inited == 0)
return -1;
#ifdef BAN_TEST
Cmd_AddCommand ("ban", NET_Ban_f);
#endif
Cmd_AddCommand ("test", Test_f);
Cmd_AddCommand ("test2", Test2_f);
return 0;
}
/*
====================
ModPlug_OpenLibrary
Try to load the modplugFile DLL
====================
*/
qboolean ModPlug_OpenLibrary (void)
{
const char* dllnames_modplug [] =
{
#if defined(WIN32)
"libmodplug-1.dll",
"modplug.dll",
#elif defined(MACOSX)
"libmodplug.dylib",
#else
"libmodplug.so.1",
"libmodplug.so",
#endif
NULL
};
// Already loaded?
if (modplug_dll)
return true;
// COMMANDLINEOPTION: Sound: -nomodplug disables modplug sound support
if (COM_CheckParm("-nomodplug"))
return false;
// Load the DLLs
// We need to load both by hand because some OSes seem to not load
// the modplug DLL automatically when loading the modplugFile DLL
if(Sys_LoadLibrary (dllnames_modplug, &modplug_dll, modplugfuncs))
{
qModPlug_SetMasterVolume = (ModPlug_SetMasterVolume_t *) Sys_GetProcAddress(modplug_dll, "ModPlug_SetMasterVolume");
if(!qModPlug_SetMasterVolume)
Con_Print("Внимание: контроль громкости modplug не поддерживается. Попробуйте взять новую версию libmodplug.\n");
return true;
}
else
return false;
}
void NET_InitServer (void)
{
int port = PORT_SERVER;
int p;
p = COM_CheckParm ("-port");
if (p && p < COM_Argc()) {
port = atoi(COM_Argv(p+1));
}
if (svs.socketip == INVALID_SOCKET) {
svs.socketip = UDP_OpenSocket (port);
}
if (svs.socketip != INVALID_SOCKET) {
NET_GetLocalAddress (svs.socketip, &net_local_sv_ipadr);
Cvar_SetROM (&sv_local_addr, NET_AdrToString (net_local_sv_ipadr));
}
else {
// FIXME: is it right???
Cvar_SetROM (&sv_local_addr, "");
}
if (svs.socketip == INVALID_SOCKET) {
#ifdef SERVERONLY
Sys_Error
#else
Con_Printf
#endif
("WARNING: Couldn't allocate server socket\n");
}
#ifndef SERVERONLY
// init the message buffer
SZ_Init (&net_message, net_message_buffer, sizeof(net_message_buffer));
#endif
}
static int
udp_scan_iface(int sock)
{
struct ifconf ifc;
struct ifreq *ifr;
char buf[8192];
int i, n;
struct sockaddr_in *iaddr;
if (COM_CheckParm("-noifscan"))
return -1;
ifc.ifc_len = sizeof(buf);
ifc.ifc_buf = buf;
if (ioctl(sock, SIOCGIFCONF, &ifc) == -1) {
Con_Printf("%s: SIOCGIFCONF failed\n", __func__);
return -1;
}
ifr = ifc.ifc_req;
n = ifc.ifc_len / sizeof(struct ifreq);
for (i = 0; i < n; i++) {
if (ioctl(sock, SIOCGIFADDR, &ifr[i]) == -1)
continue;
iaddr = (struct sockaddr_in *)&ifr[i].ifr_addr;
Con_DPrintf("%s: %s\n", ifr[i].ifr_name, inet_ntoa(iaddr->sin_addr));
if (iaddr->sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
SockadrToNetadr(iaddr, &myAddr);
strcpy (ifname, ifr[i].ifr_name);
return 0;
}
}
return -1;
}
/*
====================
ModPlug_OpenLibrary
Try to load the modplugFile DLL
====================
*/
qboolean ModPlug_OpenLibrary (void)
{
const char* dllnames_modplug [] =
{
#if defined(WIN32)
"libmodplug-1.dll",
"modplug.dll",
#elif defined(MACOSX)
"libmodplug.dylib",
#else
"libmodplug.so.1",
"libmodplug.so",
#endif
NULL
};
// Already loaded?
if (modplug_dll)
return true;
// COMMANDLINEOPTION: Sound: -nomodplug disables modplug sound support
if (COM_CheckParm("-nomodplug"))
return false;
// Load the DLLs
// We need to load both by hand because some OSes seem to not load
// the modplug DLL automatically when loading the modplugFile DLL
if(Sys_LoadLibrary (dllnames_modplug, &modplug_dll, modplugfuncs))
{
qModPlug_SetMasterVolume = (ModPlug_SetMasterVolume_t *) Sys_GetProcAddress(modplug_dll, "ModPlug_SetMasterVolume");
if(!qModPlug_SetMasterVolume)
Con_Print("Warning: modplug volume control not supported. Try getting a newer version of libmodplug.\n");
return true;
}
else
return false;
}
void CD_FindCDAux(void)
{
UINT NumDevs,counter;
MMRESULT Result;
AUXCAPS Caps;
CD_ID = -1;
if (!COM_CheckParm("-usecdvolume"))
return;
NumDevs = auxGetNumDevs();
for(counter=0;counter<NumDevs;counter++)
{
Result = auxGetDevCaps(counter,&Caps,sizeof(Caps));
if (!Result) // valid
{
if (Caps.wTechnology == AUXCAPS_CDAUDIO)
{
CD_ID = counter;
auxGetVolume(CD_ID,&CD_OrigVolume);
return;
}
}
}
}
int CDAudio_Init (void)
{
int i;
if (cls.state == ca_dedicated)
return -1;
// COMMANDLINEOPTION: Sound: -nocdaudio disables CD audio support
if (COM_CheckParm("-nocdaudio"))
return -1;
CDAudio_SysInit();
#ifdef MAXTRACKS
for (i = 0; i < MAXTRACKS; i++)
*remap[i] = 0;
#endif
Cvar_RegisterVariable(&cdaudio);
Cvar_RegisterVariable(&cdaudioinitialized);
Cvar_SetValueQuick(&cdaudioinitialized, true);
enabled = true;
Cvar_RegisterVariable(&music_playlist_index);
for (i = 0;i < MAX_PLAYLISTS;i++)
{
Cvar_RegisterVariable(&music_playlist_list[i]);
Cvar_RegisterVariable(&music_playlist_current[i]);
Cvar_RegisterVariable(&music_playlist_random[i]);
Cvar_RegisterVariable(&music_playlist_sampleposition[i]);
}
Cmd_AddCommand("cd", CD_f, "execute a CD drive command (cd on/off/reset/remap/close/play/loop/stop/pause/resume/eject/info) - use cd by itself for usage");
return 0;
}
void FMOD_Restart (void)
{
char filename[MAX_QPATH];
if (COM_CheckParm("-nosound"))
{
SND_Initialised = false;
SND_InitialisedCD = false;
return;
}
// save music info
if(SND_MusicChannel.inuse == true)
{
strcpy(filename, SND_File.filename);
FMOD_MusicStop();
}
FMOD_Shutdown();
FMOD_Startup();
// restart music if needed
FMOD_MusicStart(filename, 0, SND_MusicChannel.looping, false, true);
}
/*
===============
R_InitParticles
===============
*/
void R_InitParticles (void)
{
int i;
i = COM_CheckParm ("-particles");
if (i && i < com_argc-1)
{
r_numparticles = atoi(com_argv[i+1]);
if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
r_numparticles = ABSOLUTE_MIN_PARTICLES;
}
else
{
r_numparticles = MAX_PARTICLES;
}
particles = (particle_t *) Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
Cvar_RegisterVariable (&leak_color);
//JFM: snow test
Cvar_RegisterVariable (&snow_flurry);
Cvar_RegisterVariable (&snow_active);
}
static void install_grabs(void)
{
int MajorVersion, MinorVersion;
input_grabbed = true;
// don't show mouse cursor icon
XDefineCursor(x_disp, x_win, CreateNullCursor(x_disp, x_win));
XGrabPointer(x_disp, x_win,
True,
0,
GrabModeAsync, GrabModeAsync,
x_win,
None,
CurrentTime);
#ifdef USE_DGA
if (!COM_CheckParm("-nodga") &&
XF86DGAQueryVersion(x_disp, &MajorVersion, &MinorVersion)) {
// let us hope XF86DGADirectMouse will work
XF86DGADirectVideo(x_disp, DefaultScreen(x_disp), XF86DGADirectMouse);
dgamouse = true;
XWarpPointer(x_disp, None, x_win, 0, 0, 0, 0, 0, 0); // oldman: this should be here really
}
else
#endif
XWarpPointer(x_disp, None, x_win,
0, 0, 0, 0,
vid.width / 2, vid.height / 2);
XGrabKeyboard(x_disp, x_win,
False,
GrabModeAsync, GrabModeAsync,
CurrentTime);
}
int Datagram_Init(void)
{
int i;
int csock;
myDriverLevel = net_driverlevel;
Cmd_AddCommand("net_stats", NET_Stats_f);
if (COM_CheckParm("-nolan"))
return -1;
for (i = 0; i < net_numlandrivers; i++) {
csock = net_landrivers[i].Init();
if (csock == -1)
continue;
net_landrivers[i].initialized = true;
net_landrivers[i].controlSock = csock;
}
Cmd_AddCommand("test", Test_f);
Cmd_AddCommand("test2", Test2_f);
return 0;
}
qboolean CL_Gecko_OpenLibrary (void)
{
const char* dllnames_gecko [] =
{
#if defined(WIN32)
"OffscreenGecko.dll",
#elif defined(MACOSX)
"OffscreenGecko.dylib",
#else
"libOffscreenGecko.so",
#endif
NULL
};
// Already loaded?
if (osgk_dll)
return true;
// COMMANDLINEOPTION: Sound: -nogecko disables gecko support (web browser support for menu and computer terminals)
if (COM_CheckParm("-nogecko"))
return false;
return Sys_LoadLibrary (dllnames_gecko, &osgk_dll, osgkFuncs);
}
/*
===============
R_Register
===============
*/
void R_Register( void )
{
int i;
extern void VID_Restart_f (void);
Cvar_SetCurrentGroup(CVAR_GROUP_VIDEO);
//
// latched and archived variables
//
Cvar_Register (&r_glDriver);
Cvar_Register (&r_allowExtensions);
// Cvar_Register (&r_texturebits);
Cvar_Register (&r_colorbits);
// Cvar_Register (&r_stereo); // qqshka: unused but saved
Cvar_Register (&r_stencilbits);
Cvar_Register (&r_depthbits);
// Cvar_Register (&r_overBrightBits);
Cvar_Register (&r_mode);
Cvar_Register (&r_fullscreen);
Cvar_Register (&r_customwidth);
Cvar_Register (&r_customheight);
// Cvar_Register (&r_customaspect); // qqshka: unused even in q3, but I keep cvar, just do not register it
//
// temporary latched variables that can only change over a restart
//
Cvar_Register (&r_displayRefresh);
AssertCvarRange( &r_displayRefresh, 0, 300, true ); // useless in most cases thought
Cvar_Register (&vid_borderless);
// Cvar_Register (&r_intensity);
//
// archived variables that can change at any time
//
Cvar_Register (&r_ignoreGLErrors);
// Cvar_Register (&r_textureMode);
Cvar_Register (&r_swapInterval);
// Cvar_Register (&r_gamma);
Cvar_Register (&vid_hwgammacontrol);
Cvar_Register (&r_verbose);
// Cvar_Register (&r_logFile);
Cvar_Register (&vid_xpos);
Cvar_Register (&vid_ypos);
Cvar_Register (&vid_minpos);
Cvar_Register (&r_conwidth);
Cvar_Register (&r_conheight);
Cvar_Register (&vid_wideaspect);
Cvar_Register (&vid_wideaspect_verbose);
Cvar_Register (&r_conaspect);
if ( !host_initialized ) // compatibility with retarded cmd line, and actually this still needed for some other reasons
{
int w = 0, h = 0;
if (COM_CheckParm("-window") || COM_CheckParm("-startwindowed"))
Cvar_LatchedSetValue(&r_fullscreen, 0);
if ((i = COM_CheckParm("-freq")) && i + 1 < COM_Argc())
Cvar_LatchedSetValue(&r_displayRefresh, Q_atoi(COM_Argv(i + 1)));
if ((i = COM_CheckParm("-bpp")) && i + 1 < COM_Argc())
Cvar_LatchedSetValue(&r_colorbits, Q_atoi(COM_Argv(i + 1)));
w = ((i = COM_CheckParm("-width")) && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;
h = ((i = COM_CheckParm("-height")) && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;
#ifdef _WIN32
if (!( // no!
strcmp (r_displayRefresh.defaultvalue, r_displayRefresh.string) || // refresh rate wasnt changed
strcmp (r_colorbits.defaultvalue, r_colorbits.string ) || // bpp wasnt changed
strcmp (r_mode.defaultvalue, r_mode.string ) || // bpp wasnt changed
w || h) // width and height wasnt changed
)
{
// ok, pseudo current
int freq = 0;
DEVMODE dm;
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
if ( EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm ) ) // FIXME: Do we need to care about which device we get this? With several monitors we might...
freq = dm.dmDisplayFrequency; // get actual frequency
w = GetSystemMetrics (SM_CXSCREEN);
h = GetSystemMetrics (SM_CYSCREEN);
Cvar_LatchedSetValue(&r_displayRefresh, freq); // current mean current
Cvar_LatchedSetValue(&r_colorbits, 0); // use desktop bpp
}
#endif // _WIN32
if ( w || h )
{
int m = R_MatchMode( w, h );
if (m == -1) { // ok, mode not found, trying custom
w = w ? w : h * 4 / 3; // guessing width from height may cause some problems thought, because 4/3 uneven
h = h ? h : w * 3 / 4;
Cvar_LatchedSetValue(&r_customwidth, w);
Cvar_LatchedSetValue(&r_customheight, h);
}
Cvar_LatchedSetValue(&r_mode, m);
}
if ((i = COM_CheckParm("-conwidth")) && i + 1 < COM_Argc())
Cvar_SetValue(&r_conwidth, (float)Q_atoi(COM_Argv(i + 1)));
else // this is ether +set vid_con... or just default value which we select in cvar initialization
Cvar_SetValue(&r_conwidth, r_conwidth.value); // must trigger callback which validate value
if ((i = COM_CheckParm("-conheight")) && i + 1 < COM_Argc())
Cvar_SetValue(&r_conheight, (float)Q_atoi(COM_Argv(i + 1)));
else // this is ether +set vid_con... or just default value which we select in cvar initialization
// also select r_conheight with proper aspect ratio if user omit it
Cvar_SetValue(&r_conheight, r_conheight.value ? r_conheight.value : r_conwidth.value * 3 / 4); // must trigger callback which validate value
}
Cvar_Register (&vid_ref);
#ifdef _WIN32
Cvar_Register (&vid_flashonactivity);
Cvar_Register (&_windowed_mouse); //that more like an input, but i have serious reason to register it here
#endif
Cvar_Register (&r_showextensions);
Cvar_ResetCurrentGroup();
if ( !host_initialized )
{
#ifdef _WIN32
void VID_ShowFreq_f(void);
Cmd_AddCommand( "vid_showfreq", VID_ShowFreq_f );
#endif
Cmd_AddCommand( "vid_modelist", R_ModeList_f );
Cmd_AddCommand( "vid_gfxinfo", GfxInfo_f );
Cmd_AddCommand( "vid_restart", VID_Restart_f );
}
}
/*
===================
VID_Init
===================
*/
void VID_Init (void)
{
static char vid_center[] = "SDL_VIDEO_CENTERED=center";
const SDL_VideoInfo *info;
int width, height, bpp;
qboolean fullscreen;
const char *read_vars[] = { "vid_fullscreen",
"vid_width",
"vid_height",
"vid_bpp",
"vid_vsync" };
#define num_readvars ( sizeof(read_vars)/sizeof(read_vars[0]) )
Cvar_RegisterVariable (&vid_fullscreen); //johnfitz
Cvar_RegisterVariable (&vid_width); //johnfitz
Cvar_RegisterVariable (&vid_height); //johnfitz
Cvar_RegisterVariable (&vid_bpp); //johnfitz
Cvar_RegisterVariable (&vid_vsync); //johnfitz
Cvar_SetCallback (&vid_fullscreen, VID_Changed_f);
Cvar_SetCallback (&vid_width, VID_Changed_f);
Cvar_SetCallback (&vid_height, VID_Changed_f);
Cvar_SetCallback (&vid_bpp, VID_Changed_f);
Cvar_SetCallback (&vid_vsync, VID_Changed_f);
Cmd_AddCommand ("vid_unlock", VID_Unlock); //johnfitz
Cmd_AddCommand ("vid_restart", VID_Restart); //johnfitz
Cmd_AddCommand ("vid_test", VID_Test); //johnfitz
Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);
putenv (vid_center); /* SDL_putenv is problematic in versions <= 1.2.9 */
if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1)
Sys_Error("Could not initialize SDL Video");
info = SDL_GetVideoInfo();
Cvar_SetValueQuick (&vid_bpp, (float)info->vfmt->BitsPerPixel);
if (CFG_OpenConfig("config.cfg") == 0)
{
CFG_ReadCvars(read_vars, num_readvars);
CFG_CloseConfig();
}
CFG_ReadCvarOverrides(read_vars, num_readvars);
VID_InitModelist();
width = (int)vid_width.value;
height = (int)vid_height.value;
bpp = (int)vid_bpp.value;
fullscreen = (int)vid_fullscreen.value;
if (COM_CheckParm("-current"))
{
width = info->current_w;
height = info->current_h;
bpp = info->vfmt->BitsPerPixel;
fullscreen = true;
}
else
{
int p;
p = COM_CheckParm("-width");
if (p && p < com_argc-1)
{
width = Q_atoi(com_argv[p+1]);
if(!COM_CheckParm("-height"))
height = width * 3 / 4;
}
p = COM_CheckParm("-height");
if (p && p < com_argc-1)
{
height = Q_atoi(com_argv[p+1]);
if(!COM_CheckParm("-width"))
width = height * 4 / 3;
}
p = COM_CheckParm("-bpp");
if (p && p < com_argc-1)
bpp = Q_atoi(com_argv[p+1]);
if (COM_CheckParm("-window") || COM_CheckParm("-w"))
fullscreen = false;
else if (COM_CheckParm("-fullscreen") || COM_CheckParm("-f"))
fullscreen = true;
}
if (!VID_ValidMode(width, height, bpp, fullscreen))
{
width = (int)vid_width.value;
height = (int)vid_height.value;
bpp = (int)vid_bpp.value;
fullscreen = (int)vid_fullscreen.value;
}
if (!VID_ValidMode(width, height, bpp, fullscreen))
{
width = 640;
height = 480;
bpp = info->vfmt->BitsPerPixel;
fullscreen = false;
}
vid_initialized = true;
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.colormap = host_colormap;
vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
// set window icon
PL_SetWindowIcon();
VID_SetMode (width, height, bpp, fullscreen);
GL_Init ();
GL_SetupState ();
Cmd_AddCommand ("gl_info", GL_Info_f); //johnfitz
//johnfitz -- removed code creating "glquake" subdirectory
vid_menucmdfn = VID_Menu_f; //johnfitz
vid_menudrawfn = VID_MenuDraw;
vid_menukeyfn = VID_MenuKey;
VID_Gamma_Init(); //johnfitz
VID_Menu_Init(); //johnfitz
//QuakeSpasm: current vid settings should override config file settings.
//so we have to lock the vid mode from now until after all config files are read.
vid_locked = true;
}
