// AK where should it be placed ?
float in_mouse_x, in_mouse_y;
+// value of GL_MAX_TEXTURE_<various>_SIZE
+int gl_max_texture_size = 0;
+int gl_max_3d_texture_size = 0;
+int gl_max_cube_map_texture_size = 0;
// GL_ARB_multitexture
int gl_textureunits = 1;
// GL_ARB_texture_env_combine or GL_EXT_texture_env_combine
// GL_EXT_texture_filter_anisotropic
int gl_support_anisotropy = false;
int gl_max_anisotropy = 1;
-// GL_NV_texture_shader
-int gl_textureshader = false;
// GL_EXT_stencil_two_side
int gl_support_stenciltwoside = false;
// GL_ARB_shader_objects
qboolean vid_activewindow = true;
// we don't know until we try it!
-cvar_t vid_hardwaregammasupported = {CVAR_READONLY,"vid_hardwaregammasupported","1"};
+cvar_t vid_hardwaregammasupported = {CVAR_READONLY,"vid_hardwaregammasupported","1", "indicates whether hardware gamma is supported (updated by attempts to set hardware gamma ramps)"};
// whether hardware gamma ramps are currently in effect
qboolean vid_usinghwgamma = false;
-unsigned short vid_gammaramps[768];
-unsigned short vid_systemgammaramps[768];
-
-cvar_t vid_fullscreen = {CVAR_SAVE, "vid_fullscreen", "1"};
-cvar_t vid_width = {CVAR_SAVE, "vid_width", "640"};
-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", "0"};
-cvar_t vid_mouse = {CVAR_SAVE, "vid_mouse", "1"};
-cvar_t gl_combine = {CVAR_SAVE, "gl_combine", "1"};
-cvar_t gl_finish = {0, "gl_finish", "0"};
-
-cvar_t in_pitch_min = {0, "in_pitch_min", "-90"}; // quake used -70
-cvar_t in_pitch_max = {0, "in_pitch_max", "90"}; // quake used 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"};
-cvar_t v_color_enable = {CVAR_SAVE, "v_color_enable", "0"};
-cvar_t v_color_black_r = {CVAR_SAVE, "v_color_black_r", "0"};
-cvar_t v_color_black_g = {CVAR_SAVE, "v_color_black_g", "0"};
-cvar_t v_color_black_b = {CVAR_SAVE, "v_color_black_b", "0"};
-cvar_t v_color_grey_r = {CVAR_SAVE, "v_color_grey_r", "0.5"};
-cvar_t v_color_grey_g = {CVAR_SAVE, "v_color_grey_g", "0.5"};
-cvar_t v_color_grey_b = {CVAR_SAVE, "v_color_grey_b", "0.5"};
-cvar_t v_color_white_r = {CVAR_SAVE, "v_color_white_r", "1"};
-cvar_t v_color_white_g = {CVAR_SAVE, "v_color_white_g", "1"};
-cvar_t v_color_white_b = {CVAR_SAVE, "v_color_white_b", "1"};
-cvar_t v_hwgamma = {CVAR_SAVE, "v_hwgamma", "1"};
-cvar_t v_psycho = {0, "v_psycho", "0"};
+int vid_gammarampsize = 0;
+unsigned short *vid_gammaramps = NULL;
+unsigned short *vid_systemgammaramps = NULL;
+
+cvar_t vid_fullscreen = {CVAR_SAVE, "vid_fullscreen", "1", "use fullscreen (1) or windowed (0)"};
+cvar_t vid_width = {CVAR_SAVE, "vid_width", "640", "resolution"};
+cvar_t vid_height = {CVAR_SAVE, "vid_height", "480", "resolution"};
+cvar_t vid_bitsperpixel = {CVAR_SAVE, "vid_bitsperpixel", "32", "how many bits per pixel to render at (32 or 16, 32 is recommended)"};
+cvar_t vid_refreshrate = {CVAR_SAVE, "vid_refreshrate", "60", "refresh rate to use, in hz (higher values flicker less, if supported by your monitor)"};
+
+cvar_t vid_vsync = {CVAR_SAVE, "vid_vsync", "0", "sync to vertical blank, prevents 'tearing' (seeing part of one frame and part of another on the screen at the same time), automatically disabled when doing timedemo benchmarks"};
+cvar_t vid_mouse = {CVAR_SAVE, "vid_mouse", "1", "whether to use the mouse in windowed mode (fullscreen always does)"};
+cvar_t vid_minwidth = {0, "vid_minwidth", "0", "minimum vid_width that is acceptable (to be set in default.cfg in mods)"};
+cvar_t vid_minheight = {0, "vid_minheight", "0", "minimum vid_height that is acceptable (to be set in default.cfg in mods)"};
+cvar_t gl_combine = {0, "gl_combine", "1", "faster rendering by using GL_ARB_texture_env_combine extension (part of OpenGL 1.3 and above)"};
+cvar_t gl_finish = {0, "gl_finish", "0", "make the cpu wait for the graphics processor at the end of each frame render (can help with strange input or video lag problems on some machines)"};
+
+cvar_t v_gamma = {CVAR_SAVE, "v_gamma", "1", "inverse gamma correction value, a brightness effect that does not affect white or black, and tends to make the image grey and dull"};
+cvar_t v_contrast = {CVAR_SAVE, "v_contrast", "1", "brightness of white (values above 1 give a brighter image with increased color saturation, unlike v_gamma)"};
+cvar_t v_brightness = {CVAR_SAVE, "v_brightness", "0", "brightness of black, useful for monitors that are too dark"};
+cvar_t v_color_enable = {CVAR_SAVE, "v_color_enable", "0", "enables black-grey-white color correction curve controls"};
+cvar_t v_color_black_r = {CVAR_SAVE, "v_color_black_r", "0", "desired color of black"};
+cvar_t v_color_black_g = {CVAR_SAVE, "v_color_black_g", "0", "desired color of black"};
+cvar_t v_color_black_b = {CVAR_SAVE, "v_color_black_b", "0", "desired color of black"};
+cvar_t v_color_grey_r = {CVAR_SAVE, "v_color_grey_r", "0.5", "desired color of grey"};
+cvar_t v_color_grey_g = {CVAR_SAVE, "v_color_grey_g", "0.5", "desired color of grey"};
+cvar_t v_color_grey_b = {CVAR_SAVE, "v_color_grey_b", "0.5", "desired color of grey"};
+cvar_t v_color_white_r = {CVAR_SAVE, "v_color_white_r", "1", "desired color of white"};
+cvar_t v_color_white_g = {CVAR_SAVE, "v_color_white_g", "1", "desired color of white"};
+cvar_t v_color_white_b = {CVAR_SAVE, "v_color_white_b", "1", "desired color of white"};
+cvar_t v_hwgamma = {CVAR_SAVE, "v_hwgamma", "1", "enables use of hardware gamma correction ramps if available (note: does not work very well on Windows2000 and above), values are 0 = off, 1 = attempt to use hardware gamma, 2 = use hardware gamma whether it works or not"};
+cvar_t v_psycho = {0, "v_psycho", "0", "easter egg (does not work on Windows2000 or above)"};
// brand of graphics chip
const char *gl_vendor;
void (GLAPIENTRY *qglLockArraysEXT) (GLint first, GLint count);
void (GLAPIENTRY *qglUnlockArraysEXT) (void);
-//GL_NV_vertex_array_range
-GLvoid *(GLAPIENTRY *qglAllocateMemoryNV)(GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
-GLvoid (GLAPIENTRY *qglFreeMemoryNV)(GLvoid *pointer);
-GLvoid (GLAPIENTRY *qglVertexArrayRangeNV)(GLsizei length, GLvoid *pointer);
-GLvoid (GLAPIENTRY *qglFlushVertexArrayRangeNV)(GLvoid);
-
// general GL functions
void (GLAPIENTRY *qglClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
void (GLAPIENTRY *qglScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
void (GLAPIENTRY *qglPolygonOffset)(GLfloat factor, GLfloat units);
+void (GLAPIENTRY *qglPolygonMode)(GLenum face, GLenum mode);
+
+//[515]: added on 29.07.2005
+void (GLAPIENTRY *qglLineWidth)(GLfloat width);
+void (GLAPIENTRY *qglPointSize)(GLfloat size);
void (GLAPIENTRY *qglActiveStencilFaceEXT)(GLenum);
{"glVertex3f", (void **) &qglVertex3f},
{"glBegin", (void **) &qglBegin},
{"glEnd", (void **) &qglEnd},
+//[515]: added on 29.07.2005
+ {"glLineWidth", (void**) &qglLineWidth},
+ {"glPointSize", (void**) &qglPointSize},
+//
{"glMatrixMode", (void **) &qglMatrixMode},
{"glOrtho", (void **) &qglOrtho},
{"glFrustum", (void **) &qglFrustum},
{"glCopyTexSubImage2D", (void **) &qglCopyTexSubImage2D},
{"glScissor", (void **) &qglScissor},
{"glPolygonOffset", (void **) &qglPolygonOffset},
+ {"glPolygonMode", (void **) &qglPolygonMode},
{NULL, NULL}
};
// reset all the gl extension variables here
// this should match the declarations
+ gl_max_texture_size = 0;
+ gl_max_3d_texture_size = 0;
+ gl_max_cube_map_texture_size = 0;
gl_textureunits = 1;
gl_combine_extension = false;
gl_supportslockarrays = false;
gl_support_clamptoedge = false;
gl_support_anisotropy = false;
gl_max_anisotropy = 1;
- gl_textureshader = false;
gl_support_stenciltwoside = false;
gl_support_shader_objects = false;
gl_support_shading_language_100 = false;
gl_support_fragment_shader = false;
if (!GL_CheckExtension("OpenGL 1.1.0", opengl110funcs, NULL, false))
- Sys_Error("OpenGL 1.1.0 functions not found\n");
+ Sys_Error("OpenGL 1.1.0 functions not found");
Con_Printf("GL_VENDOR: %s\n", gl_vendor);
Con_Printf("GL_RENDERER: %s\n", gl_renderer);
Con_Printf("GL_EXTENSIONS: %s\n", gl_extensions);
Con_Printf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
+ CHECKGLERROR
+ qglGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max_texture_size);
+
Con_Print("Checking OpenGL extensions...\n");
// COMMANDLINEOPTION: GL: -nodrawrangeelements disables GL_EXT_draw_range_elements (renders faster)
}
// 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);
+ if ((gl_texture3d = GL_CheckExtension("GL_EXT_texture3D", texture3dextfuncs, "-notexture3d", false)))
+ {
+ qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &gl_max_3d_texture_size);
+ if (gl_max_3d_texture_size < 32)
+ {
+ gl_texture3d = false;
+ Con_Printf("GL_EXT_texture3D reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
+ }
+ }
// COMMANDLINEOPTION: GL: -nocubemap disables GL_ARB_texture_cube_map (required for bumpmapping)
- gl_texturecubemap = GL_CheckExtension("GL_ARB_texture_cube_map", NULL, "-nocubemap", false);
+ if ((gl_texturecubemap = GL_CheckExtension("GL_ARB_texture_cube_map", NULL, "-nocubemap", false)))
+ qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &gl_max_cube_map_texture_size);
// 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)
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);
// 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)
+// COMMANDLINEOPTION: GL: -novertexshader disables GL_ARB_vertex_shader (allows vertex shader effects)
+// COMMANDLINEOPTION: GL: -nofragmentshader disables GL_ARB_fragment_shader (allows pixel shader effects, can improve per pixel lighting performance and capabilities)
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);
-}
-
-qboolean vid_vertexarrays_are_var = false;
-void *VID_AllocVertexArrays(mempool_t *pool, int size, int fast, float readfrequency, float writefrequency, float priority)
-{
- void *m;
- vid_vertexarrays_are_var = false;
- if (fast && qglAllocateMemoryNV)
- {
- CHECKGLERROR
- m = qglAllocateMemoryNV(size, readfrequency, writefrequency, priority);
- CHECKGLERROR
- if (m)
- {
- vid_vertexarrays_are_var = true;
- return m;
- }
- }
- return Mem_Alloc(pool, size);
-}
-
-void VID_FreeVertexArrays(void *pointer)
-{
- if (vid_vertexarrays_are_var)
- {
- CHECKGLERROR
- qglFreeMemoryNV(pointer);
- CHECKGLERROR
- }
- else
- Mem_Free(pointer);
- vid_vertexarrays_are_var = false;
+ CHECKGLERROR
}
void Force_CenterView_f (void)
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(void)
-{
- // get basic movement from keyboard
- CL_BaseMove();
-
- // OS independent code
- IN_PreMove();
-
- // allow mice or other external controllers to add to the move
- IN_Move();
-
- // OS independent code
- IN_PostMove();
-}
-
-
-void IN_Mouse(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;
-
- if (cl_prydoncursor.integer)
- {
- cl.cmd.cursor_screen[0] += mouse_x * sensitivity.value / vid.realwidth;
- cl.cmd.cursor_screen[1] += mouse_y * sensitivity.value / vid.realheight;
- V_StopPitchDrift();
- 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))
- cl.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)
- cl.cmd.upmove -= m_forward.value * mouse_y;
- else
- cl.cmd.forwardmove -= m_forward.value * mouse_y;
- }
-}
-
+static int gamma_forcenextframe = false;
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);
-void VID_UpdateGamma(qboolean force)
+void VID_UpdateGamma(qboolean force, int rampsize)
{
cvar_t *c;
float f;
- static int forcenextframe = false;
// LordHavoc: don't mess with gamma tables if running dedicated
if (cls.state == ca_dedicated)
return;
if (!force
- && !forcenextframe
+ && !gamma_forcenextframe
&& !v_psycho.integer
- && vid_usinghwgamma == (vid_activewindow && v_hwgamma.integer)
+ && cachehwgamma == (vid_activewindow && v_hwgamma.integer)
&& v_gamma.value == cachegamma
&& v_contrast.value == cachecontrast
&& v_brightness.value == cachebrightness
&& cachewhite[2] == v_color_white_b.value)
return;
- forcenextframe = false;
-
- if (vid_activewindow && v_hwgamma.integer)
+ BOUNDCVAR(v_gamma, 0.1, 5);cachegamma = v_gamma.value;
+ BOUNDCVAR(v_contrast, 1, 5);cachecontrast = v_contrast.value;
+ BOUNDCVAR(v_brightness, 0, 0.8);cachebrightness = v_brightness.value;
+ BOUNDCVAR(v_color_black_r, 0, 0.8);cacheblack[0] = v_color_black_r.value;
+ BOUNDCVAR(v_color_black_g, 0, 0.8);cacheblack[1] = v_color_black_g.value;
+ BOUNDCVAR(v_color_black_b, 0, 0.8);cacheblack[2] = v_color_black_b.value;
+ BOUNDCVAR(v_color_grey_r, 0, 0.95);cachegrey[0] = v_color_grey_r.value;
+ BOUNDCVAR(v_color_grey_g, 0, 0.95);cachegrey[1] = v_color_grey_g.value;
+ BOUNDCVAR(v_color_grey_b, 0, 0.95);cachegrey[2] = v_color_grey_b.value;
+ BOUNDCVAR(v_color_white_r, 1, 5);cachewhite[0] = v_color_white_r.value;
+ BOUNDCVAR(v_color_white_g, 1, 5);cachewhite[1] = v_color_white_g.value;
+ BOUNDCVAR(v_color_white_b, 1, 5);cachewhite[2] = v_color_white_b.value;
+ cachecolorenable = v_color_enable.integer;
+ cachehwgamma = vid_activewindow && v_hwgamma.integer;
+
+ gamma_forcenextframe = false;
+
+ if (cachehwgamma)
{
if (!vid_usinghwgamma)
{
vid_usinghwgamma = true;
- Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_GetGamma(vid_systemgammaramps));
+ if (vid_gammarampsize != rampsize || !vid_gammaramps)
+ {
+ vid_gammarampsize = rampsize;
+ if (vid_gammaramps)
+ Z_Free(vid_gammaramps);
+ vid_gammaramps = (unsigned short *)Z_Malloc(6 * vid_gammarampsize * sizeof(unsigned short));
+ vid_systemgammaramps = vid_gammaramps + 3 * vid_gammarampsize;
+ }
+ VID_GetGamma(vid_systemgammaramps, vid_gammarampsize);
}
- BOUNDCVAR(v_gamma, 0.1, 5);cachegamma = v_gamma.value;
- BOUNDCVAR(v_contrast, 1, 5);cachecontrast = v_contrast.value;
- BOUNDCVAR(v_brightness, 0, 0.8);cachebrightness = v_brightness.value;
- BOUNDCVAR(v_color_black_r, 0, 0.8);cacheblack[0] = v_color_black_r.value;
- BOUNDCVAR(v_color_black_g, 0, 0.8);cacheblack[1] = v_color_black_g.value;
- BOUNDCVAR(v_color_black_b, 0, 0.8);cacheblack[2] = v_color_black_b.value;
- BOUNDCVAR(v_color_grey_r, 0, 0.95);cachegrey[0] = v_color_grey_r.value;
- BOUNDCVAR(v_color_grey_g, 0, 0.95);cachegrey[1] = v_color_grey_g.value;
- BOUNDCVAR(v_color_grey_b, 0, 0.95);cachegrey[2] = v_color_grey_b.value;
- BOUNDCVAR(v_color_white_r, 1, 5);cachewhite[0] = v_color_white_r.value;
- BOUNDCVAR(v_color_white_g, 1, 5);cachewhite[1] = v_color_white_g.value;
- BOUNDCVAR(v_color_white_b, 1, 5);cachewhite[2] = v_color_white_b.value;
- cachecolorenable = v_color_enable.integer;
- cachehwgamma = v_hwgamma.integer;
-
if (cachecolorenable)
{
- BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[0]), cachewhite[0], cacheblack[0], vid_gammaramps);
- BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[1]), cachewhite[1], cacheblack[1], vid_gammaramps + 256);
- BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[2]), cachewhite[2], cacheblack[2], vid_gammaramps + 512);
+ BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[0]), cachewhite[0], cacheblack[0], vid_gammaramps, rampsize);
+ BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[1]), cachewhite[1], cacheblack[1], vid_gammaramps + vid_gammarampsize, rampsize);
+ BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[2]), cachewhite[2], cacheblack[2], vid_gammaramps + vid_gammarampsize*2, rampsize);
}
else
{
- BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, vid_gammaramps);
- BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, vid_gammaramps + 256);
- BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, vid_gammaramps + 512);
+ BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, vid_gammaramps, rampsize);
+ BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, vid_gammaramps + vid_gammarampsize, rampsize);
+ BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, vid_gammaramps + vid_gammarampsize*2, rampsize);
}
// LordHavoc: this code came from Ben Winslow and Zinx Verituse, I have
static float n[3], nd[3], nt[3];
static int init = true;
unsigned short *ramp;
- forcenextframe = true;
+ gamma_forcenextframe = true;
if (init)
{
init = false;
for (x = 0;x < 3;x++)
{
- nt[x] -= host_realframetime;
+ nt[x] -= cl.realframetime;
if (nt[x] < 0)
{
nd[x] = -nd[x];
nt[x] += lhrandom(1, 8.2);
}
- n[x] += nd[x] * host_realframetime;
+ n[x] += nd[x] * cl.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;
+ for (y = 0, t = n[x] - 0.75f;y < vid_gammarampsize;y++, t += 0.75f * (2.0f / vid_gammarampsize))
+ *ramp++ = (unsigned short)(cos(t*(M_PI*2.0)) * 32767.0f + 32767.0f);
}
- Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_SetGamma(vid_gammaramps));
+ // set vid_hardwaregammasupported to true if VID_SetGamma succeeds, OR if vid_hwgamma is >= 2 (forced gamma - ignores driver return value)
+ Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_SetGamma(vid_gammaramps, vid_gammarampsize) || v_hwgamma.integer >= 2);
// if custom gamma ramps failed (Windows stupidity), restore to system gamma
if(!vid_hardwaregammasupported.integer)
- VID_SetGamma(vid_systemgammaramps);
+ {
+ if (vid_usinghwgamma)
+ {
+ vid_usinghwgamma = false;
+ VID_SetGamma(vid_systemgammaramps, vid_gammarampsize);
+ }
+ }
}
else
{
if (vid_usinghwgamma)
{
vid_usinghwgamma = false;
- Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_SetGamma(vid_systemgammaramps));
+ VID_SetGamma(vid_systemgammaramps, vid_gammarampsize);
}
}
}
if (vid_usinghwgamma)
{
vid_usinghwgamma = false;
- VID_SetGamma(vid_systemgammaramps);
+ Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_SetGamma(vid_systemgammaramps, vid_gammarampsize));
+ // force gamma situation to be reexamined next frame
+ gamma_forcenextframe = true;
}
}
Cvar_RegisterVariable(&vid_width);
Cvar_RegisterVariable(&vid_height);
Cvar_RegisterVariable(&vid_bitsperpixel);
+ Cvar_RegisterVariable(&vid_refreshrate);
Cvar_RegisterVariable(&vid_vsync);
Cvar_RegisterVariable(&vid_mouse);
+ Cvar_RegisterVariable(&vid_minwidth);
+ Cvar_RegisterVariable(&vid_minheight);
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);
+ Cmd_AddCommand("force_centerview", Force_CenterView_f, "recenters view (stops looking up/down)");
+ Cmd_AddCommand("vid_restart", VID_Restart_f, "restarts video system (closes and reopens the window, restarts renderer)");
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)
+int VID_Mode(int fullscreen, int width, int height, int bpp, int refreshrate)
{
- Con_Printf("Video: %s %dx%dx%d\n", fullscreen ? "fullscreen" : "window", width, height, bpp);
- if (VID_InitMode(fullscreen, width, height, bpp))
+ Con_Printf("Video: %s %dx%dx%dx%dhz\n", fullscreen ? "fullscreen" : "window", width, height, bpp, refreshrate);
+ if (VID_InitMode(fullscreen, width, height, bpp, refreshrate))
{
- 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;
+ vid.refreshrate = refreshrate;
Cvar_SetValueQuick(&vid_fullscreen, fullscreen);
Cvar_SetValueQuick(&vid_width, width);
Cvar_SetValueQuick(&vid_height, height);
Cvar_SetValueQuick(&vid_bitsperpixel, bpp);
+ Cvar_SetValueQuick(&vid_refreshrate, refreshrate);
return true;
}
else
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();
- if (!VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer))
+ VID_CloseSystems();
+ VID_Shutdown();
+ if (!VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, vid_refreshrate.integer))
{
Con_Print("Video mode change failed\n");
- if (!VID_Mode(current_vid_fullscreen, current_vid_width, current_vid_height, current_vid_bitsperpixel))
- Sys_Error("Unable to restore to last working video mode\n");
+ if (!VID_Mode(vid.fullscreen, vid.width, vid.height, vid.bitsperpixel, vid.refreshrate))
+ Sys_Error("Unable to restore to last working video mode");
}
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)
}
Con_Print("Starting video system\n");
- success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer);
+ success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, vid_refreshrate.integer);
if (!success)
{
Con_Print("Desired video mode fail, trying fallbacks...\n");
+ success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, 60);
if (!success && vid_bitsperpixel.integer > 16)
- success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, 16);
+ success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, 16, 60);
if (!success && (vid_width.integer > 640 || vid_height.integer > 480))
- success = VID_Mode(vid_fullscreen.integer, 640, 480, 16);
+ success = VID_Mode(vid_fullscreen.integer, 640, 480, 16, 60);
if (!success && vid_fullscreen.integer)
- success = VID_Mode(false, 640, 480, 16);
+ success = VID_Mode(false, 640, 480, 16, 60);
if (!success)
- Sys_Error("Video modes failed\n");
+ Sys_Error("Video modes failed");
}
VID_OpenSystems();
}
-void VID_Close(void)
-{
- VID_CloseSystems();
- VID_Shutdown();
-}
-
projects / xonotic / darkplaces.git / blobdiff