#include "quakedef.h"
+#include "cdaudio.h"
// global video state
viddef_t vid;
int gl_combine_extension = false;
// GL_EXT_compiled_vertex_array
int gl_supportslockarrays = false;
-// GLX_SGI_video_sync or WGL_EXT_swap_control
+// GLX_SGI_swap_control or WGL_EXT_swap_control
int gl_videosyncavailable = false;
// stencil available
int gl_stencil = false;
int gl_support_fragment_shader = false;
// LordHavoc: if window is hidden, don't update screen
-int vid_hidden = true;
+qboolean vid_hidden = true;
// LordHavoc: if window is not the active window, don't hog as much CPU time,
// let go of the mouse, turn off sound, and restore system gamma ramps...
-int vid_activewindow = true;
+qboolean vid_activewindow = true;
// we don't know until we try it!
cvar_t vid_hardwaregammasupported = {CVAR_READONLY,"vid_hardwaregammasupported","1"};
// whether hardware gamma ramps are currently in effect
-int vid_usinghwgamma = false;
+qboolean vid_usinghwgamma = false;
unsigned short vid_gammaramps[768];
unsigned short vid_systemgammaramps[768];
cvar_t vid_height = {CVAR_SAVE, "vid_height", "480"};
cvar_t vid_bitsperpixel = {CVAR_SAVE, "vid_bitsperpixel", "32"};
-cvar_t vid_vsync = {CVAR_SAVE, "vid_vsync", "1"};
+cvar_t vid_vsync = {CVAR_SAVE, "vid_vsync", "0"};
cvar_t vid_mouse = {CVAR_SAVE, "vid_mouse", "1"};
-cvar_t gl_combine = {CVAR_SAVE, "gl_combine", "1"};
+cvar_t gl_combine = {0, "gl_combine", "1"};
cvar_t gl_finish = {0, "gl_finish", "0"};
-cvar_t in_pitch_min = {0, "in_pitch_min", "-70"};
-cvar_t in_pitch_max = {0, "in_pitch_max", "80"};
-
-cvar_t m_filter = {CVAR_SAVE, "m_filter","0"};
-
cvar_t v_gamma = {CVAR_SAVE, "v_gamma", "1"};
cvar_t v_contrast = {CVAR_SAVE, "v_contrast", "1"};
cvar_t v_brightness = {CVAR_SAVE, "v_brightness", "0"};
char gl_driver[256];
// GL_ARB_multitexture
+void (GLAPIENTRY *qglMultiTexCoord1f) (GLenum, GLfloat);
void (GLAPIENTRY *qglMultiTexCoord2f) (GLenum, GLfloat, GLfloat);
void (GLAPIENTRY *qglMultiTexCoord3f) (GLenum, GLfloat, GLfloat, GLfloat);
+void (GLAPIENTRY *qglMultiTexCoord4f) (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
void (GLAPIENTRY *qglActiveTexture) (GLenum);
void (GLAPIENTRY *qglClientActiveTexture) (GLenum);
void (GLAPIENTRY *qglArrayElement)(GLint i);
void (GLAPIENTRY *qglColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-void (GLAPIENTRY *qglTexCoord2f)(GLfloat s, GLfloat t);
+void (GLAPIENTRY *qglTexCoord1f)(GLfloat s);
void (GLAPIENTRY *qglTexCoord2f)(GLfloat s, GLfloat t);
void (GLAPIENTRY *qglTexCoord3f)(GLfloat s, GLfloat t, GLfloat r);
+void (GLAPIENTRY *qglTexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
void (GLAPIENTRY *qglVertex2f)(GLfloat x, GLfloat y);
void (GLAPIENTRY *qglVertex3f)(GLfloat x, GLfloat y, GLfloat z);
void (GLAPIENTRY *qglBegin)(GLenum mode);
int failed = false;
const dllfunction_t *func;
- Con_DPrintf("checking for %s... ", name);
+ Con_Printf("checking for %s... ", name);
for (func = funcs;func && func->name;func++)
*func->funcvariable = NULL;
if (disableparm && (COM_CheckParm(disableparm) || COM_CheckParm("-safe")))
{
- Con_DPrint("disabled by commandline\n");
+ Con_Print("disabled by commandline\n");
return false;
}
// delay the return so it prints all missing functions
if (failed)
return false;
- Con_DPrint("enabled\n");
+ Con_Print("enabled\n");
return true;
}
else
{
- Con_DPrint("not detected\n");
+ Con_Print("not detected\n");
return false;
}
}
{"glTexCoordPointer", (void **) &qglTexCoordPointer},
{"glArrayElement", (void **) &qglArrayElement},
{"glColor4f", (void **) &qglColor4f},
+ {"glTexCoord1f", (void **) &qglTexCoord1f},
{"glTexCoord2f", (void **) &qglTexCoord2f},
{"glTexCoord3f", (void **) &qglTexCoord3f},
+ {"glTexCoord4f", (void **) &qglTexCoord4f},
{"glVertex2f", (void **) &qglVertex2f},
{"glVertex3f", (void **) &qglVertex3f},
{"glBegin", (void **) &qglBegin},
static dllfunction_t multitexturefuncs[] =
{
+ {"glMultiTexCoord1fARB", (void **) &qglMultiTexCoord1f},
{"glMultiTexCoord2fARB", (void **) &qglMultiTexCoord2f},
{"glMultiTexCoord3fARB", (void **) &qglMultiTexCoord3f},
+ {"glMultiTexCoord4fARB", (void **) &qglMultiTexCoord4f},
{"glActiveTextureARB", (void **) &qglActiveTexture},
{"glClientActiveTextureARB", (void **) &qglClientActiveTexture},
{NULL, NULL}
if (!GL_CheckExtension("OpenGL 1.1.0", opengl110funcs, NULL, false))
Sys_Error("OpenGL 1.1.0 functions not found\n");
- Con_DPrintf("GL_VENDOR: %s\n", gl_vendor);
- Con_DPrintf("GL_RENDERER: %s\n", gl_renderer);
- Con_DPrintf("GL_VERSION: %s\n", gl_version);
- Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
- Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, 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_Printf("GL_EXTENSIONS: %s\n", gl_extensions);
+ Con_Printf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
- Con_DPrint("Checking OpenGL extensions...\n");
+ Con_Print("Checking OpenGL extensions...\n");
+// COMMANDLINEOPTION: GL: -nodrawrangeelements disables GL_EXT_draw_range_elements (renders faster)
if (!GL_CheckExtension("glDrawRangeElements", drawrangeelementsfuncs, "-nodrawrangeelements", true))
GL_CheckExtension("GL_EXT_draw_range_elements", drawrangeelementsextfuncs, "-nodrawrangeelements", false);
+// COMMANDLINEOPTION: GL: -nomtex disables GL_ARB_multitexture (required for faster map rendering)
if (GL_CheckExtension("GL_ARB_multitexture", multitexturefuncs, "-nomtex", false))
{
qglGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_textureunits);
+// COMMANDLINEOPTION: GL: -nocombine disables GL_ARB_texture_env_combine or GL_EXT_texture_env_combine (required for bumpmapping and faster map rendering)
gl_combine_extension = GL_CheckExtension("GL_ARB_texture_env_combine", NULL, "-nocombine", false) || GL_CheckExtension("GL_EXT_texture_env_combine", NULL, "-nocombine", false);
+// COMMANDLINEOPTION: GL: -nodot3 disables GL_ARB_texture_env_dot3 (required for bumpmapping)
if (gl_combine_extension)
gl_dot3arb = GL_CheckExtension("GL_ARB_texture_env_dot3", NULL, "-nodot3", false);
}
+// COMMANDLINEOPTION: GL: -notexture3d disables GL_EXT_texture3D (required for spherical lights, otherwise they render as a column)
gl_texture3d = GL_CheckExtension("GL_EXT_texture3D", texture3dextfuncs, "-notexture3d", false);
+// COMMANDLINEOPTION: GL: -nocubemap disables GL_ARB_texture_cube_map (required for bumpmapping)
gl_texturecubemap = GL_CheckExtension("GL_ARB_texture_cube_map", NULL, "-nocubemap", false);
+// COMMANDLINEOPTION: GL: -nocva disables GL_EXT_compiled_vertex_array (renders faster)
gl_supportslockarrays = GL_CheckExtension("GL_EXT_compiled_vertex_array", compiledvertexarrayfuncs, "-nocva", false);
+// COMMANDLINEOPTION: GL: -noedgeclamp disables GL_EXT_texture_edge_clamp or GL_SGIS_texture_edge_clamp (recommended, some cards do not support the other texture clamp method)
gl_support_clamptoedge = GL_CheckExtension("GL_EXT_texture_edge_clamp", NULL, "-noedgeclamp", false) || GL_CheckExtension("GL_SGIS_texture_edge_clamp", NULL, "-noedgeclamp", false);
+// COMMANDLINEOPTION: GL: -noanisotropy disables GL_EXT_texture_filter_anisotropic (allows higher quality texturing)
if ((gl_support_anisotropy = GL_CheckExtension("GL_EXT_texture_filter_anisotropic", NULL, "-noanisotropy", false)))
qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max_anisotropy);
+// COMMANDLINEOPTION: GL: -notextureshader disables GL_NV_texture_shader (required for the Geforce3 water shader, NVIDIA only)
gl_textureshader = GL_CheckExtension("GL_NV_texture_shader", NULL, "-notextureshader", false);
+// COMMANDLINEOPTION: GL: -nostenciltwoside disables GL_EXT_stencil_two_side (accelerates shadow rendering)
gl_support_stenciltwoside = GL_CheckExtension("GL_EXT_stencil_two_side", stenciltwosidefuncs, "-nostenciltwoside", false);
// we don't care if it's an extension or not, they are identical functions, so keep it simple in the rendering code
if (qglDrawRangeElements == NULL)
qglDrawRangeElements = qglDrawRangeElementsEXT;
+// COMMANDLINEOPTION: GL: -noshaderobjects disables GL_ARB_shader_objects (required for vertex shader and fragment shader)
+// COMMANDLINEOPTION: GL: -noshadinglanguage100 disables GL_ARB_shading_language_100 (required for vertex shader and fragment shader)
+// COMMANDLINEOPTION: GL: -novertexshader disables GL_ARB_vertex_shader (currently unused, allows vertex shader effects)
+// COMMANDLINEOPTION: GL: -nofragmentshader disables GL_ARB_fragment_shader (currently unused, allows pixel shader effects)
if ((gl_support_shader_objects = GL_CheckExtension("GL_ARB_shader_objects", shaderobjectsfuncs, "-noshaderobjects", false)))
if ((gl_support_shading_language_100 = GL_CheckExtension("GL_ARB_shading_language_100", NULL, "-noshadinglanguage100", false)))
if ((gl_support_vertex_shader = GL_CheckExtension("GL_ARB_vertex_shader", vertexshaderfuncs, "-novertexshader", false)))
gl_support_fragment_shader = GL_CheckExtension("GL_ARB_fragment_shader", NULL, "-nofragmentshader", false);
}
-int vid_vertexarrays_are_var = false;
+qboolean vid_vertexarrays_are_var = false;
void *VID_AllocVertexArrays(mempool_t *pool, int size, int fast, float readfrequency, float writefrequency, float priority)
{
void *m;
cl.viewangles[PITCH] = 0;
}
-void IN_PreMove(void)
-{
-}
-
-void CL_AdjustAngles(void);
-void IN_PostMove(void)
-{
- // clamp after the move as well to prevent messed up rendering angles
- CL_AdjustAngles();
-}
-
-/*
-===========
-IN_DoMove
-===========
-*/
-void IN_ProcessMove(usercmd_t *cmd)
-{
- // get basic movement from keyboard
- CL_BaseMove(cmd);
-
- // OS independent code
- IN_PreMove();
-
- // allow mice or other external controllers to add to the move
- IN_Move(cmd);
-
- // OS independent code
- IN_PostMove();
-}
-
-
-void IN_Mouse(usercmd_t *cmd, float mx, float my)
-{
- int mouselook = (in_mlook.state & 1) || freelook.integer;
- float mouse_x, mouse_y;
- static float old_mouse_x = 0, old_mouse_y = 0;
-
- 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;
-
- in_mouse_x = (float) mouse_x * vid.conwidth / vid.realwidth;
- in_mouse_y = (float) mouse_y * vid.conheight / vid.realheight;
-
- // AK: eveything else is client stuff
- // BTW, this should be seperated somewhen
- if(!in_client_mouse)
- return;
-
- // LordHavoc: viewzoom affects mouse sensitivity for sniping
- mouse_x *= sensitivity.value * cl.viewzoom;
- mouse_y *= sensitivity.value * cl.viewzoom;
-
- // Add mouse X/Y movement to cmd
- if ((in_strafe.state & 1) || (lookstrafe.integer && mouselook))
- cmd->sidemove += m_side.value * mouse_x;
- else
- cl.viewangles[YAW] -= m_yaw.value * mouse_x;
-
- if (mouselook)
- V_StopPitchDrift();
-
- if (mouselook && !(in_strafe.state & 1))
- cl.viewangles[PITCH] += m_pitch.value * mouse_y;
- else
- {
- if ((in_strafe.state & 1) && noclip_anglehack)
- cmd->upmove -= m_forward.value * mouse_y;
- else
- cmd->forwardmove -= m_forward.value * mouse_y;
- }
-}
-
static float cachegamma, cachebrightness, cachecontrast, cacheblack[3], cachegrey[3], cachewhite[3];
static int cachecolorenable, cachehwgamma;
#define BOUNDCVAR(cvar, m1, m2) c = &(cvar);f = bound(m1, c->value, m2);if (c->value != f) Cvar_SetValueQuick(c, f);
&& cachewhite[1] == v_color_white_g.value
&& cachewhite[2] == v_color_white_b.value)
return;
-
+
forcenextframe = false;
if (vid_activewindow && v_hwgamma.integer)
nt[x] = lhrandom(1, 8.2);
}
}
-
+
for (x = 0;x < 3;x++)
{
nt[x] -= host_realframetime;
n[x] += nd[x] * host_realframetime;
n[x] -= floor(n[x]);
}
-
+
for (x = 0, ramp = vid_gammaramps;x < 3;x++)
for (y = 0, t = n[x] - 0.75f;y < 256;y++, t += 0.75f * (2.0f / 256.0f))
*ramp++ = cos(t*(M_PI*2.0)) * 32767.0f + 32767.0f;
}
Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_SetGamma(vid_gammaramps));
+ // if custom gamma ramps failed (Windows stupidity), restore to system gamma
+ if(!vid_hardwaregammasupported.integer)
+ VID_SetGamma(vid_systemgammaramps);
}
else
{
Cvar_RegisterVariable(&v_color_white_b);
Cvar_RegisterVariable(&v_hwgamma);
-
+
Cvar_RegisterVariable(&v_psycho);
Cvar_RegisterVariable(&vid_fullscreen);
Cvar_RegisterVariable(&vid_mouse);
Cvar_RegisterVariable(&gl_combine);
Cvar_RegisterVariable(&gl_finish);
- Cvar_RegisterVariable(&in_pitch_min);
- Cvar_RegisterVariable(&in_pitch_max);
- Cvar_RegisterVariable(&m_filter);
Cmd_AddCommand("force_centerview", Force_CenterView_f);
Cmd_AddCommand("vid_restart", VID_Restart_f);
if (gamemode == GAME_GOODVSBAD2)
Cvar_Set("gl_combine", "0");
}
-int current_vid_fullscreen;
-int current_vid_width;
-int current_vid_height;
-int current_vid_bitsperpixel;
int VID_Mode(int fullscreen, int width, int height, int bpp)
{
Con_Printf("Video: %s %dx%dx%d\n", fullscreen ? "fullscreen" : "window", width, height, bpp);
if (VID_InitMode(fullscreen, width, height, bpp))
{
- current_vid_fullscreen = fullscreen;
- current_vid_width = width;
- current_vid_height = height;
- current_vid_bitsperpixel = bpp;
+ vid.fullscreen = fullscreen;
+ vid.width = width;
+ vid.height = height;
+ vid.bitsperpixel = bpp;
Cvar_SetValueQuick(&vid_fullscreen, fullscreen);
Cvar_SetValueQuick(&vid_width, width);
Cvar_SetValueQuick(&vid_height, height);
{
R_Modules_Start();
S_Startup();
- CDAudio_Startup();
}
static void VID_CloseSystems(void)
{
- CDAudio_Shutdown();
S_Shutdown();
R_Modules_Shutdown();
}
-int vid_commandlinecheck = true;
+qboolean vid_commandlinecheck = true;
void VID_Restart_f(void)
{
return;
Con_Printf("VID_Restart: changing from %s %dx%dx%dbpp, to %s %dx%dx%dbpp.\n",
- current_vid_fullscreen ? "fullscreen" : "window", current_vid_width, current_vid_height, current_vid_bitsperpixel,
+ vid.fullscreen ? "fullscreen" : "window", vid.width, vid.height, vid.bitsperpixel,
vid_fullscreen.integer ? "fullscreen" : "window", vid_width.integer, vid_height.integer, vid_bitsperpixel.integer);
- VID_Close();
+ VID_CloseSystems();
+ VID_Shutdown();
if (!VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer))
{
Con_Print("Video mode change failed\n");
- if (!VID_Mode(current_vid_fullscreen, current_vid_width, current_vid_height, current_vid_bitsperpixel))
+ if (!VID_Mode(vid.fullscreen, vid.width, vid.height, vid.bitsperpixel))
Sys_Error("Unable to restore to last working video mode\n");
}
VID_OpenSystems();
}
-void VID_Open(void)
+// this is only called once by Host_StartVideo
+void VID_Start(void)
{
int i, width, height, success;
if (vid_commandlinecheck)
{
// interpret command-line parameters
vid_commandlinecheck = false;
+// COMMANDLINEOPTION: Video: -window performs +vid_fullscreen 0
if (COM_CheckParm("-window") || COM_CheckParm("-safe"))
Cvar_SetValueQuick(&vid_fullscreen, false);
+// COMMANDLINEOPTION: Video: -fullscreen performs +vid_fullscreen 1
if (COM_CheckParm("-fullscreen"))
Cvar_SetValueQuick(&vid_fullscreen, true);
width = 0;
height = 0;
+// COMMANDLINEOPTION: Video: -width <pixels> performs +vid_width <pixels> and also +vid_height <pixels*3/4> if only -width is specified (example: -width 1024 sets 1024x768 mode)
if ((i = COM_CheckParm("-width")) != 0)
width = atoi(com_argv[i+1]);
+// COMMANDLINEOPTION: Video: -height <pixels> performs +vid_height <pixels> and also +vid_width <pixels*4/3> if only -height is specified (example: -height 768 sets 1024x768 mode)
if ((i = COM_CheckParm("-height")) != 0)
height = atoi(com_argv[i+1]);
if (width == 0)
Cvar_SetValueQuick(&vid_width, width);
if (height)
Cvar_SetValueQuick(&vid_height, height);
+// COMMANDLINEOPTION: Video: -bpp <bits> performs +vid_bitsperpixel <bits> (example -bpp 32 or -bpp 16)
if ((i = COM_CheckParm("-bpp")) != 0)
Cvar_SetQuick(&vid_bitsperpixel, com_argv[i+1]);
}
- Con_DPrint("Starting video system\n");
+ Con_Print("Starting video system\n");
success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer);
if (!success)
{
VID_OpenSystems();
}
-void VID_Close(void)
-{
- VID_CloseSystems();
- VID_Shutdown();
-}
-