void BGM_Update (void)
{
if (old_volume != bgmvolume.value)
{
if (bgmvolume.value < 0)
Cvar_SetQuick (&bgmvolume, "0");
else if (bgmvolume.value > 1)
Cvar_SetQuick (&bgmvolume, "1");
old_volume = bgmvolume.value;
}
if (bgmstream)
BGM_UpdateStream ();
}
/*
=================
SCR_CalcRefdef
Must be called whenever vid changes
Internal use only
=================
*/
static void SCR_CalcRefdef (void)
{
float size, scale; //johnfitz -- scale
// force the status bar to redraw
Sbar_Changed ();
scr_tileclear_updates = 0; //johnfitz
// bound viewsize
if (scr_viewsize.value < 30)
Cvar_SetQuick (&scr_viewsize, "30");
if (scr_viewsize.value > 120)
Cvar_SetQuick (&scr_viewsize, "120");
// bound fov
if (scr_fov.value < 10)
Cvar_SetQuick (&scr_fov, "10");
if (scr_fov.value > 170)
Cvar_SetQuick (&scr_fov, "170");
vid.recalc_refdef = 0;
//johnfitz -- rewrote this section
size = scr_viewsize.value;
scale = CLAMP (1.0, scr_sbarscale.value, (float)glwidth / 320.0);
if (size >= 120 || cl.intermission || scr_sbaralpha.value < 1) //johnfitz -- scr_sbaralpha.value
sb_lines = 0;
else if (size >= 110)
sb_lines = 24 * scale;
else
sb_lines = 48 * scale;
size = q_min(scr_viewsize.value, 100) / 100;
//johnfitz
//johnfitz -- rewrote this section
r_refdef.vrect.width = q_max(glwidth * size, 96); //no smaller than 96, for icons
r_refdef.vrect.height = q_min(glheight * size, glheight - sb_lines); //make room for sbar
r_refdef.vrect.x = (glwidth - r_refdef.vrect.width)/2;
r_refdef.vrect.y = (glheight - sb_lines - r_refdef.vrect.height)/2;
//johnfitz
r_refdef.fov_x = AdaptFovx(scr_fov.value, vid.width, vid.height);
r_refdef.fov_y = CalcFovy (r_refdef.fov_x, r_refdef.vrect.width, r_refdef.vrect.height);
scr_vrect = r_refdef.vrect;
}
/*
================
VID_Test -- johnfitz -- like vid_restart, but asks for confirmation after switching modes
================
*/
static void VID_Test (void)
{
int old_width, old_height, old_bpp, old_fullscreen;
if (vid_locked || !vid_changed)
return;
//
// now try the switch
//
old_width = draw_context->w;
old_height = draw_context->h;
old_bpp = draw_context->format->BitsPerPixel;
old_fullscreen = draw_context->flags & SDL_FULLSCREEN ? true : false;
VID_Restart ();
//pop up confirmation dialoge
if (!SCR_ModalMessage("Would you like to keep this\nvideo mode? (y/n)\n", 5.0f))
{
//revert cvars and mode
Cvar_SetValueQuick (&vid_width, old_width);
Cvar_SetValueQuick (&vid_height, old_height);
Cvar_SetValueQuick (&vid_bpp, old_bpp);
Cvar_SetQuick (&vid_fullscreen, old_fullscreen ? "1" : "0");
VID_Restart ();
}
}
// new proc by S.A., called by alt-return key binding.
void VID_Toggle (void)
{
static qboolean vid_toggle_works = true;
S_ClearBuffer ();
if (!vid_toggle_works)
goto vrestart;
if (SDL_WM_ToggleFullScreen(draw_context) == 1)
{
Sbar_Changed (); // Sbar seems to need refreshing
modestate = draw_context->flags & SDL_FULLSCREEN ? MS_FULLSCREEN : MS_WINDOWED;
VID_SyncCvars();
// update mouse grab
if (key_dest == key_console || key_dest == key_menu)
{
if (modestate == MS_WINDOWED)
IN_Deactivate(true);
else if (modestate == MS_FULLSCREEN)
IN_Activate();
}
}
else
{
vid_toggle_works = false;
Con_DPrintf ("SDL_WM_ToggleFullScreen failed, attempting VID_Restart\n");
vrestart:
Cvar_SetQuick (&vid_fullscreen, draw_context-> flags & SDL_FULLSCREEN ? "0" : "1");
Cbuf_AddText ("vid_restart\n");
}
}
static void Host_InitSession(void)
{
int i;
Cvar_RegisterVariable(&sessionid);
Cvar_RegisterVariable(&locksession);
// load the session ID into the read-only cvar
if ((i = COM_CheckParm("-sessionid")) && (i + 1 < com_argc))
{
char vabuf[1024];
if(com_argv[i+1][0] == '.')
Cvar_SetQuick(&sessionid, com_argv[i+1]);
else
Cvar_SetQuick(&sessionid, va(vabuf, sizeof(vabuf), ".%s", com_argv[i+1]));
}
}
/*
================
VID_SyncCvars -- johnfitz -- set vid cvars to match current video mode
================
*/
void VID_SyncCvars (void)
{
int swap_control;
if (draw_context)
{
Cvar_SetValueQuick (&vid_width, draw_context->w);
Cvar_SetValueQuick (&vid_height, draw_context->h);
Cvar_SetValueQuick (&vid_bpp, draw_context->format->BitsPerPixel);
Cvar_SetQuick (&vid_fullscreen, draw_context->flags & SDL_FULLSCREEN ? "1" : "0");
if (SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL, &swap_control) == 0)
Cvar_SetQuick (&vid_vsync, (swap_control > 0)? "1" : "0");
}
vid_changed = false;
}
static void SND_Callback_snd_filterquality (cvar_t *var)
{
if (snd_filterquality.value < 1 || snd_filterquality.value > 5)
{
Con_Printf ("snd_filterquality must be between 1 and 5\n");
Cvar_SetQuick (&snd_filterquality, SND_FILTERQUALITY_DEFAULT);
}
}
/*
================
Host_FindMaxClients
================
*/
void Host_FindMaxClients (void)
{
int i;
svs.maxclients = 1;
i = COM_CheckParm ("-dedicated");
if (i)
{
cls.state = ca_dedicated;
if (i != (com_argc - 1))
{
svs.maxclients = Q_atoi (com_argv[i+1]);
}
else
svs.maxclients = 8;
}
else
cls.state = ca_disconnected;
i = COM_CheckParm ("-listen");
if (i)
{
if (cls.state == ca_dedicated)
Sys_Error ("Only one of -dedicated or -listen can be specified");
if (i != (com_argc - 1))
svs.maxclients = Q_atoi (com_argv[i+1]);
else
svs.maxclients = 8;
}
if (svs.maxclients < 1)
svs.maxclients = 8;
else if (svs.maxclients > MAX_SCOREBOARD)
svs.maxclients = MAX_SCOREBOARD;
svs.maxclientslimit = svs.maxclients;
if (svs.maxclientslimit < 4)
svs.maxclientslimit = 4;
svs.clients = (struct client_s *) Hunk_AllocName (svs.maxclientslimit*sizeof(client_t), "clients");
if (svs.maxclients > 1)
Cvar_SetQuick (&deathmatch, "1");
else
Cvar_SetQuick (&deathmatch, "0");
}
/*
====================
IRC_Shutdown
Shutdown the IRC module and close all connections.
====================
*/
void IRC_Shutdown(void) {
int handle;
for(handle = 0; handle < IRC_MAX_SESSIONS; ++handle)
if(IS_VALID_IRC_SESSION(handle))
IRC_TerminateSession(handle);
IRC_CloseLibrary();
Cvar_SetQuick(&irc_initialized, "0");
}
/*
============
Cvar_SetValue
============
*/
void Cvar_SetValueQuick(cvar_t *var, float value)
{
char val[32];
if ((float)((int)value) == value)
sprintf(val, "%i", (int)value);
else
sprintf(val, "%f", value);
Cvar_SetQuick(var, val);
}
void BGM_Update (void)
{
if (old_volume != bgmvolume.value)
{
if (bgmvolume.value < 0)
Cvar_SetQuick (&bgmvolume, "0");
else if (bgmvolume.value > 1)
Cvar_SetQuick (&bgmvolume, "1");
old_volume = bgmvolume.value;
if (midi_handle.handle)
{
midi_handle.driver->mididrv_setvol (& midi_handle.handle, bgmvolume.value);
if (bgmvolume.value == 0.0f) /* don't bother advancing */
midi_handle.driver->mididrv_pause (& midi_handle.handle);
else
midi_handle.driver->mididrv_resume(& midi_handle.handle);
}
}
if (midi_handle.handle)
midi_handle.driver->mididrv_advance (& midi_handle.handle);
if (bgmstream)
BGM_UpdateStream ();
}
/*
====================
IRC_Init
Initialize the IRC module.
====================
*/
void IRC_Init(void) {
int handle;
Cvar_RegisterVariable(&irc_initialized);
if(IRC_OpenLibrary()) {
Cvar_SetQuick(&irc_initialized, "1");
Cvar_RegisterVariable(&irc_eventlog);
Cvar_RegisterVariable(&irc_enabled);
Cvar_RegisterVariable(&irc_translate_dp2irc_qfont);
Cvar_RegisterVariable(&irc_translate_dp2irc_color);
Cvar_RegisterVariable(&irc_translate_irc2dp_color);
Cmd_AddCommand("irc_create", IRC_Cmd_Create_f, "Creates a new IRC session");
Cmd_AddCommand("irc_connect", IRC_Cmd_Connect_f, "Connects to an IRC server");
Cmd_AddCommand("irc_raw", IRC_Cmd_Raw_f, "Sends a raw message to the IRC server");
Cmd_AddCommand("irc_quit", IRC_Cmd_Quit_f, "Disconnects from the IRC server");
Cmd_AddCommand("irc_terminate", IRC_Cmd_Terminate_f, "Terminates an IRC session");
for(handle = 0; handle < IRC_MAX_SESSIONS; ++handle)
irc_sessions[handle].handle = handle;
}
}
/*
===============
Host_SaveConfig_f
Writes key bindings and archived cvars to config.cfg
===============
*/
static void Host_SaveConfig_to(const char *file)
{
qfile_t *f;
Cvar_SetQuick(&sys_first_run, "0");
// 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);
}
}
void GLES_Init(void)
{
gl_renderer = (const char *)qglGetString(GL_RENDERER);
gl_vendor = (const char *)qglGetString(GL_VENDOR);
gl_version = (const char *)qglGetString(GL_VERSION);
gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
if (!gl_extensions)
gl_extensions = "";
if (!gl_platformextensions)
gl_platformextensions = "";
Con_Printf("GL_VENDOR: %s\n", gl_vendor);
Con_Printf("GL_RENDERER: %s\n", gl_renderer);
Con_Printf("GL_VERSION: %s\n", gl_version);
Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
// LordHavoc: report supported extensions
Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
// GLES devices in general do not like GL_BGRA, so use GL_RGBA
vid.forcetextype = TEXTYPE_RGBA;
vid.support.gl20shaders = true;
vid.support.amd_texture_texture4 = false;
vid.support.arb_depth_texture = false;
vid.support.arb_draw_buffers = false;
vid.support.arb_multitexture = false;
vid.support.arb_occlusion_query = false;
vid.support.arb_shadow = false;
vid.support.arb_texture_compression = SDL_GL_ExtensionSupported("GL_EXT_texture_compression_s3tc");
vid.support.arb_texture_cube_map = true;
vid.support.arb_texture_env_combine = false;
vid.support.arb_texture_gather = false;
vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
vid.support.arb_vertex_buffer_object = true;
vid.support.arb_uniform_buffer_object = false;
vid.support.ati_separate_stencil = false;
vid.support.ext_blend_minmax = false;
vid.support.ext_blend_subtract = true;
vid.support.ext_draw_range_elements = true;
vid.support.ext_framebuffer_object = false;
// FIXME remove this workaround once FBO + npot texture mapping is fixed
if(!vid.support.arb_texture_non_power_of_two)
{
vid.support.arb_framebuffer_object = false;
vid.support.ext_framebuffer_object = false;
}
vid.support.ext_packed_depth_stencil = false;
vid.support.ext_stencil_two_side = false;
vid.support.ext_texture_3d = SDL_GL_ExtensionSupported("GL_OES_texture_3D");
vid.support.ext_texture_compression_s3tc = SDL_GL_ExtensionSupported("GL_EXT_texture_compression_s3tc");
vid.support.ext_texture_edge_clamp = true;
vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
vid.support.ext_texture_srgb = false;
qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
if (vid.support.ext_texture_filter_anisotropic)
qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
if (vid.support.arb_texture_cube_map)
qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_cubemap);
Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
{
#define GL_ALPHA_BITS 0x0D55
#define GL_RED_BITS 0x0D52
#define GL_GREEN_BITS 0x0D53
#define GL_BLUE_BITS 0x0D54
#define GL_DEPTH_BITS 0x0D56
#define GL_STENCIL_BITS 0x0D57
int fb_r = -1, fb_g = -1, fb_b = -1, fb_a = -1, fb_d = -1, fb_s = -1;
qglGetIntegerv(GL_RED_BITS , &fb_r);
qglGetIntegerv(GL_GREEN_BITS , &fb_g);
qglGetIntegerv(GL_BLUE_BITS , &fb_b);
qglGetIntegerv(GL_ALPHA_BITS , &fb_a);
qglGetIntegerv(GL_DEPTH_BITS , &fb_d);
qglGetIntegerv(GL_STENCIL_BITS, &fb_s);
if ((fb_r+fb_g+fb_b+fb_a)>=24) is32bit=1;
Con_Printf("Framebuffer depth is R%iG%iB%iA%iD%iS%i\n", fb_r, fb_g, fb_b, fb_a, fb_d, fb_s);
}
// verify that cubemap textures are really supported
if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
vid.support.arb_texture_cube_map = false;
// verify that 3d textures are really supported
if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
{
vid.support.ext_texture_3d = false;
Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
}
vid.texunits = 4;
vid.teximageunits = 8;
vid.texarrayunits = 5;
vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
Con_DPrintf("Using GLES2.0 rendering path - %i texture matrix, %i texture images, %i texcoords%s\n", vid.texunits, vid.teximageunits, vid.texarrayunits, vid.support.ext_framebuffer_object ? ", shadowmapping supported" : "");
vid.renderpath = RENDERPATH_GLES2;
vid.useinterleavedarrays = false;
vid.sRGBcapable2D = false;
vid.sRGBcapable3D = false;
// VorteX: set other info (maybe place them in VID_InitMode?)
extern cvar_t gl_info_vendor;
extern cvar_t gl_info_renderer;
extern cvar_t gl_info_version;
extern cvar_t gl_info_platform;
extern cvar_t gl_info_driver;
Cvar_SetQuick(&gl_info_vendor, gl_vendor);
Cvar_SetQuick(&gl_info_renderer, gl_renderer);
Cvar_SetQuick(&gl_info_version, gl_version);
Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
Cvar_SetQuick(&gl_info_driver, gl_driver);
}
/*
================
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);
}
