void VR_Init()
{
// This is only called once at game start
Cvar_RegisterVariable (&vr_enabled);
Cvar_SetCallback (&vr_enabled, VR_Enabled_f);
Cvar_RegisterVariable (&vr_crosshair);
Cvar_RegisterVariable (&vr_crosshair_depth);
Cvar_RegisterVariable (&vr_crosshair_size);
Cvar_RegisterVariable (&vr_aimmode);
Cvar_RegisterVariable (&vr_deadzone);
Cvar_SetCallback (&vr_deadzone, VR_Deadzone_f);
}
/*
===============
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");
Cvar_RegisterVariable (&r_particles); //johnfitz
Cvar_SetCallback (&r_particles, R_SetParticleTexture_f);
R_InitParticleTextures (); //johnfitz
}
/*
================
VID_Gamma_Init -- call on init
================
*/
static void VID_Gamma_Init (void)
{
vid_gammaworks = false;
if (SDL_GetGammaRamp (&vid_sysgamma_red[0], &vid_sysgamma_green[0], &vid_sysgamma_blue[0]) != -1)
vid_gammaworks = true;
Cvar_RegisterVariable (&vid_gamma);
Cvar_SetCallback (&vid_gamma, VID_Gamma_f);
}
/*
================
VID_Gamma_Init -- call on init
================
*/
static void VID_Gamma_Init (void)
{
vid_gammaworks = false;
#if !defined(__APPLE__) // TODO: jeremiah sypult, crashes on OS X 10.9
if (SDL_GetGammaRamp (&vid_sysgamma_red[0], &vid_sysgamma_green[0], &vid_sysgamma_blue[0]) != -1)
vid_gammaworks = true;
#endif
Cvar_RegisterVariable (&vid_gamma);
Cvar_SetCallback (&vid_gamma, VID_Gamma_f);
}
/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal (void)
{
Cmd_AddCommand ("version", Host_Version_f);
Host_InitCommands ();
Cvar_RegisterVariable (&host_framerate);
Cvar_RegisterVariable (&host_speeds);
Cvar_RegisterVariable (&host_maxfps); //johnfitz
Cvar_RegisterVariable (&host_timescale); //johnfitz
Cvar_RegisterVariable (&max_edicts); //johnfitz
Cvar_SetCallback (&max_edicts, Max_Edicts_f);
Cvar_RegisterVariable (&devstats); //johnfitz
Cvar_RegisterVariable (&sys_ticrate);
Cvar_RegisterVariable (&sys_throttle);
Cvar_RegisterVariable (&serverprofile);
Cvar_RegisterVariable (&fraglimit);
Cvar_RegisterVariable (&timelimit);
Cvar_RegisterVariable (&teamplay);
Cvar_SetCallback (&fraglimit, Host_Callback_Notify);
Cvar_SetCallback (&timelimit, Host_Callback_Notify);
Cvar_SetCallback (&teamplay, Host_Callback_Notify);
Cvar_RegisterVariable (&samelevel);
Cvar_RegisterVariable (&noexit);
Cvar_SetCallback (&noexit, Host_Callback_Notify);
Cvar_RegisterVariable (&skill);
Cvar_RegisterVariable (&developer);
Cvar_RegisterVariable (&coop);
Cvar_RegisterVariable (&deathmatch);
Cvar_RegisterVariable (&pausable);
Cvar_RegisterVariable (&temp1);
Host_FindMaxClients ();
}
/*
===============
SV_Init
===============
*/
void SV_Init (void)
{
int i;
extern cvar_t sv_maxvelocity;
extern cvar_t sv_gravity;
extern cvar_t sv_nostep;
extern cvar_t sv_freezenonclients;
extern cvar_t sv_friction;
extern cvar_t sv_edgefriction;
extern cvar_t sv_stopspeed;
extern cvar_t sv_maxspeed;
extern cvar_t sv_accelerate;
extern cvar_t sv_idealpitchscale;
extern cvar_t sv_aim;
extern cvar_t sv_altnoclip; //johnfitz
Cvar_RegisterVariable (&sv_maxvelocity);
Cvar_RegisterVariable (&sv_gravity);
Cvar_RegisterVariable (&sv_friction);
Cvar_SetCallback (&sv_gravity, Host_Callback_Notify);
Cvar_SetCallback (&sv_friction, Host_Callback_Notify);
Cvar_RegisterVariable (&sv_edgefriction);
Cvar_RegisterVariable (&sv_stopspeed);
Cvar_RegisterVariable (&sv_maxspeed);
Cvar_SetCallback (&sv_maxspeed, Host_Callback_Notify);
Cvar_RegisterVariable (&sv_accelerate);
Cvar_RegisterVariable (&sv_idealpitchscale);
Cvar_RegisterVariable (&sv_aim);
Cvar_RegisterVariable (&sv_nostep);
Cvar_RegisterVariable (&sv_freezenonclients);
Cvar_RegisterVariable (&sv_altnoclip); //johnfitz
Cmd_AddCommand ("sv_protocol", &SV_Protocol_f); //johnfitz
for (i=0 ; i<MAX_MODELS ; i++)
sprintf (localmodels[i], "*%i", i);
}
/*
==================
SCR_Init
==================
*/
void SCR_Init (void)
{
//johnfitz -- new cvars
Cvar_RegisterVariable (&scr_menuscale);
Cvar_RegisterVariable (&scr_sbarscale);
Cvar_SetCallback (&scr_sbaralpha, SCR_Callback_refdef);
Cvar_RegisterVariable (&scr_sbaralpha);
Cvar_SetCallback (&scr_conwidth, &SCR_Conwidth_f);
Cvar_SetCallback (&scr_conscale, &SCR_Conwidth_f);
Cvar_RegisterVariable (&scr_conwidth);
Cvar_RegisterVariable (&scr_conscale);
Cvar_RegisterVariable (&scr_crosshairscale);
Cvar_RegisterVariable (&scr_showfps);
Cvar_RegisterVariable (&scr_clock);
//johnfitz
Cvar_SetCallback (&scr_fov, SCR_Callback_refdef);
Cvar_SetCallback (&scr_fov_adapt, SCR_Callback_refdef);
Cvar_SetCallback (&scr_viewsize, SCR_Callback_refdef);
Cvar_RegisterVariable (&scr_fov);
Cvar_RegisterVariable (&scr_fov_adapt);
Cvar_RegisterVariable (&scr_viewsize);
Cvar_RegisterVariable (&scr_conspeed);
Cvar_RegisterVariable (&scr_showram);
Cvar_RegisterVariable (&scr_showturtle);
Cvar_RegisterVariable (&scr_showpause);
Cvar_RegisterVariable (&scr_centertime);
Cvar_RegisterVariable (&scr_printspeed);
Cvar_RegisterVariable (&gl_triplebuffer);
Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
SCR_LoadPics (); //johnfitz
scr_initialized = true;
}
/*
===================
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;
}
static struct InputEvent *IN_KeyboardHandlerFunc()
{
struct InputEvent *moo = (struct InputEvent *)REG_A0;
struct inputdata *id = (struct inputdata *)REG_A1;
#else
HANDLERPROTO(IN_KeyboardHandler, struct InputEvent *, struct InputEvent *moo, APTR id)
{
#endif
struct InputEvent *coin;
ULONG screeninfront;
if (!window || !(window->Flags & WFLG_WINDOWACTIVE))
return moo;
if (window->WScreen)
{
#ifdef __MORPHOS__
if (IntuitionBase->LibNode.lib_Version > 50 || (IntuitionBase->LibNode.lib_Version == 50 && IntuitionBase->LibNode.lib_Revision >= 56))
GetAttr(SA_Displayed, window->WScreen, &screeninfront);
else
#endif
screeninfront = (window->WScreen == IntuitionBase->FirstScreen);
}
else
screeninfront = 1;
for (coin = moo; coin; coin = coin->ie_NextEvent)
{
if (coin->ie_Class == IECLASS_RAWKEY)
{
int code;
// mouse button 4, mouse wheel and keyboard
code = coin->ie_Code & ~IECODE_UP_PREFIX;
if (code >= NM_WHEEL_UP && code <= NM_BUTTON_FOURTH)
{
// we don't need these, they will be handled under IECLASS_NEWMOUSE
/*if (mouseactive && screeninfront)
{
IN_AddEvent(coin);
coin->ie_Code = IECODE_NOBUTTON;
}*/
}
else
{
IN_AddEvent(coin);
}
}
else if (coin->ie_Class == IECLASS_RAWMOUSE && mouseactive && screeninfront)
{
// mouse buttons 1-3
if (coin->ie_Code != IECODE_NOBUTTON)
{
IN_AddEvent(coin);
coin->ie_Code = IECODE_NOBUTTON;
}
// mouse movement
mx += coin->ie_position.ie_xy.ie_x;
my += coin->ie_position.ie_xy.ie_y;
coin->ie_position.ie_xy.ie_x = 0;
coin->ie_position.ie_xy.ie_y = 0;
}
else if (coin->ie_Class == IECLASS_NEWMOUSE && mouseactive && screeninfront)
{
// mouse button 4, mouse wheel
IN_AddEvent(coin);
coin->ie_Code = IECODE_NOBUTTON;
}
}
return moo;
}
//MakeHandlerPri(InputHandler, &IN_KeyboardHandler, "Hexen II input handler", NULL, 100);
/*
===========
IN_Init
===========
*/
void IN_Init (void)
{
static char handler_name[] = "Hexen II input handler";
/* mouse variables */
Cvar_RegisterVariable (&m_filter);
/* joystick variables */
Cvar_RegisterVariable (&in_joystick);
Cvar_RegisterVariable (&joy_index);
Cvar_SetCallback (&in_joystick, IN_Callback_JoyEnable);
Cvar_SetCallback (&joy_index, IN_Callback_JoyIndex);
Cmd_AddCommand ("force_centerview", Force_CenterView_f);
pointermem = (UWORD *) AllocVec(2 * 6, MEMF_CHIP | MEMF_CLEAR);
IN_StartupMouse ();
IN_StartupJoystick ();
imsglow = imsghigh = 0;
inputport = CreateMsgPort();
if (inputport)
{
//inputreq = (struct IOStdReq *) CreateIORequest(inputport, sizeof(*inputreq));
inputreq = CreateStdIO(inputport);
if (inputreq)
{
if (!OpenDevice("input.device", 0, (struct IORequest *)inputreq, 0))
{
InputHandler.is_Node.ln_Type = NT_INTERRUPT;
InputHandler.is_Node.ln_Pri = 100;
InputHandler.is_Node.ln_Name = handler_name;
InputHandler.is_Code = (void (*)())&IN_KeyboardHandler;
inputreq->io_Data = (void *)&InputHandler;
inputreq->io_Command = IND_ADDHANDLER;
DoIO((struct IORequest *)inputreq);
return;
}
//DeleteIORequest(inputreq);
DeleteStdIO(inputreq);
}
DeleteMsgPort(inputport);
}
Sys_Error ("Couldn't install input handler");
}
/*
===========
IN_Shutdown
===========
*/
void IN_Shutdown (void)
{
if (inputreq)
{
inputreq->io_Data = (void *)&InputHandler;
inputreq->io_Command = IND_REMHANDLER;
DoIO((struct IORequest *)inputreq);
CloseDevice((struct IORequest *)inputreq);
//DeleteIORequest(inputreq);
DeleteStdIO(inputreq);
}
if (inputport)
{
DeleteMsgPort(inputport);
}
IN_DeactivateMouse ();
/*IN_ShowMouse ();*/
if (pointermem)
{
FreeVec(pointermem);
}
mouseinitialized = false;
if (LowLevelBase)
{
CloseLibrary(LowLevelBase);
LowLevelBase = NULL;
}
joy_port = -1;
joy_available = 0;
oldjoyflag = 0;
#ifdef __CLIB2__
if (KeymapBase) {
CloseLibrary(KeymapBase);
KeymapBase = NULL;
}
#endif
}
/*
===========
IN_ReInit
===========
*/
void IN_ReInit (void)
{
IN_StartupMouse ();
}
/*
===========
IN_MouseMove
===========
*/
static void IN_MouseMove (usercmd_t *cmd/*, int mx, int my*/)
{
if (m_filter.integer)
{
mouse_x = (mx + old_mouse_x) * 0.5;
mouse_y = (my + old_mouse_y) * 0.5;
}
else
{
mouse_x = mx;
mouse_y = my;
}
old_mouse_x = mx;
old_mouse_y = my;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
/* add mouse X/Y movement to cmd */
if ( (in_strafe.state & 1) || (lookstrafe.integer && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
if (in_mlook.state & 1)
{
if (mx || my)
V_StopPitchDrift ();
}
if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
{
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
}
else
{
if ((in_strafe.state & 1) && (cl.v.movetype == MOVETYPE_NOCLIP))
cmd->upmove -= m_forward.value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
}
if (cl.idealroll == 0) /* Did keyboard set it already?? */
{
if (cl.v.movetype == MOVETYPE_FLY)
{
if (mouse_x < 0)
cl.idealroll = -10;
else if (mouse_x > 0)
cl.idealroll = 10;
}
}
}
static void IN_DiscardMove (void)
{
if (mouseinitialized)
{
mx = my = old_mouse_x = old_mouse_y = 0;
}
}
/*
===========
IN_Move
===========
*/
void IN_Move (usercmd_t *cmd)
{
if (cl.v.cameramode)
{
/* stuck in a different camera so don't move */
memset (cmd, 0, sizeof(*cmd));
/* ignore any mouse movements in camera mode */
IN_DiscardMove ();
return;
}
if (mx != 0 || my != 0)
{
IN_MouseMove (cmd/*, x, y*/);
mx = my = 0;
}
}
static const char *JoystickName(int port)
{
ULONG joyflag = ReadJoyPort(port);
switch (joyflag & JP_TYPE_MASK)
{
case JP_TYPE_GAMECTLR:
return "game controller";
case JP_TYPE_JOYSTK:
return "joystick controller";
case JP_TYPE_MOUSE:
return "mouse";
case JP_TYPE_NOTAVAIL:
return "not available";
case JP_TYPE_UNKNOWN:
return "unknown device";
default:
return "<unknown>";
}
}
/*
================
S_Init
================
*/
void S_Init (void)
{
int i;
if (snd_initialized)
{
Con_Printf("Sound is already initialized\n");
return;
}
Cvar_RegisterVariable(&nosound);
Cvar_RegisterVariable(&sfxvolume);
Cvar_RegisterVariable(&precache);
Cvar_RegisterVariable(&loadas8bit);
Cvar_RegisterVariable(&bgmvolume);
Cvar_RegisterVariable(&ambient_level);
Cvar_RegisterVariable(&ambient_fade);
Cvar_RegisterVariable(&snd_noextraupdate);
Cvar_RegisterVariable(&snd_show);
Cvar_RegisterVariable(&_snd_mixahead);
Cvar_RegisterVariable(&sndspeed);
Cvar_RegisterVariable(&snd_mixspeed);
Cvar_RegisterVariable(&snd_filterquality);
if (safemode || COM_CheckParm("-nosound"))
return;
Con_Printf("\nSound Initialization\n");
Cmd_AddCommand("play", S_Play);
Cmd_AddCommand("playvol", S_PlayVol);
Cmd_AddCommand("stopsound", S_StopAllSoundsC);
Cmd_AddCommand("soundlist", S_SoundList);
Cmd_AddCommand("soundinfo", S_SoundInfo_f);
i = COM_CheckParm("-sndspeed");
if (i && i < com_argc-1)
{
Cvar_SetQuick (&sndspeed, com_argv[i+1]);
}
i = COM_CheckParm("-mixspeed");
if (i && i < com_argc-1)
{
Cvar_SetQuick (&snd_mixspeed, com_argv[i+1]);
}
if (host_parms->memsize < 0x800000)
{
Cvar_SetQuick (&loadas8bit, "1");
Con_Printf ("loading all sounds as 8bit\n");
}
Cvar_SetCallback(&sfxvolume, SND_Callback_sfxvolume);
Cvar_SetCallback(&snd_filterquality, &SND_Callback_snd_filterquality);
SND_InitScaletable ();
known_sfx = (sfx_t *) Hunk_AllocName (MAX_SFX*sizeof(sfx_t), "sfx_t");
num_sfx = 0;
snd_initialized = true;
S_Startup ();
if (sound_started == 0)
return;
// provides a tick sound until washed clean
// if (shm->buffer)
// shm->buffer[4] = shm->buffer[5] = 0x7f; // force a pop for debugging
ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");
S_CodecInit ();
S_StopAllSounds (true);
}