#include "quakedef.h"
#include "cdaudio.h"
-#ifdef SUPPORTCG
-#include <Cg/cgGL.h>
-#endif
-
#ifdef SUPPORTD3D
#include <d3d9.h>
#ifdef _MSC_VER
// let go of the mouse, turn off sound, and restore system gamma ramps...
qboolean vid_activewindow = true;
+// cvars for DPSOFTRAST
+cvar_t vid_soft = {CVAR_SAVE, "vid_soft", "0", "enables use of the DarkPlaces Software Rasterizer rather than OpenGL or Direct3D"};
+cvar_t vid_soft_threads = {CVAR_SAVE, "vid_soft_threads", "2", "the number of threads the DarkPlaces Software Rasterizer should use"};
+cvar_t vid_soft_interlace = {CVAR_SAVE, "vid_soft_interlace", "1", "whether the DarkPlaces Software Rasterizer should interlace the screen bands occupied by each thread"};
+
// we don't know until we try it!
cvar_t vid_hardwaregammasupported = {CVAR_READONLY,"vid_hardwaregammasupported","1", "indicates whether hardware gamma is supported (updated by attempts to set hardware gamma ramps)"};
cvar_t vid_minheight = {0, "vid_minheight", "0", "minimum vid_height that is acceptable (to be set in default.cfg in mods)"};
cvar_t vid_gl13 = {0, "vid_gl13", "1", "enables faster rendering using OpenGL 1.3 features (such as GL_ARB_texture_env_combine extension)"};
cvar_t vid_gl20 = {0, "vid_gl20", "1", "enables faster rendering using OpenGL 2.0 features (such as GL_ARB_fragment_shader extension)"};
-#ifdef SUPPORTCG
-cvar_t vid_cggl = {0, "vid_glcg", "1", "enables faster rendering using the Cg shader library"};
-#endif
cvar_t gl_finish = {0, "gl_finish", "0", "make the cpu wait for the graphics processor at the end of each rendered frame (can help with strange input or video lag problems on some machines)"};
+cvar_t vid_touchscreen = {0, "vid_touchscreen", "0", "Use touchscreen-style input (no mouse grab, track mouse motion only while button is down, screen areas for mimicing joystick axes and buttons"};
cvar_t vid_stick_mouse = {CVAR_SAVE, "vid_stick_mouse", "0", "have the mouse stuck in the center of the screen" };
cvar_t vid_resizable = {CVAR_SAVE, "vid_resizable", "0", "0: window not resizable, 1: resizable, 2: window can be resized but the framebuffer isn't adjusted" };
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_glslgamma = {CVAR_SAVE, "v_glslgamma", "0", "enables use of GLSL to apply gamma correction ramps if available (note: overrides v_hwgamma)"};
-cvar_t v_psycho = {0, "v_psycho", "0", "easter egg (does not work on Windows2000 or above)"};
+cvar_t v_psycho = {0, "v_psycho", "0", "easter egg"};
// brand of graphics chip
const char *gl_vendor;
void (GLAPIENTRY *qglDeleteShader)(GLuint obj);
void (GLAPIENTRY *qglDeleteProgram)(GLuint obj);
-GLuint (GLAPIENTRY *qglGetHandle)(GLenum pname);
+//GLuint (GLAPIENTRY *qglGetHandle)(GLenum pname);
void (GLAPIENTRY *qglDetachShader)(GLuint containerObj, GLuint attachedObj);
GLuint (GLAPIENTRY *qglCreateShader)(GLenum shaderType);
void (GLAPIENTRY *qglShaderSource)(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length);
void (GLAPIENTRY *qglEnableVertexAttribArray)(GLuint index);
void (GLAPIENTRY *qglDisableVertexAttribArray)(GLuint index);
void (GLAPIENTRY *qglBindAttribLocation)(GLuint programObj, GLuint index, const GLchar *name);
+void (GLAPIENTRY *qglBindFragDataLocation)(GLuint programObj, GLuint index, const GLchar *name);
void (GLAPIENTRY *qglGetActiveAttrib)(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
GLint (GLAPIENTRY *qglGetAttribLocation)(GLuint programObj, const GLchar *name);
void (GLAPIENTRY *qglGetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params);
#define sscanf sscanf_s
#endif
-#ifndef __IPHONEOS__
qboolean GL_CheckExtension(const char *minglver_or_ext, const dllfunction_t *funcs, const char *disableparm, int silent)
{
int failed = false;
{
{"glDeleteShader", (void **) &qglDeleteShader},
{"glDeleteProgram", (void **) &qglDeleteProgram},
- {"glGetHandle", (void **) &qglGetHandle},
+// {"glGetHandle", (void **) &qglGetHandle},
{"glDetachShader", (void **) &qglDetachShader},
{"glCreateShader", (void **) &qglCreateShader},
{"glShaderSource", (void **) &qglShaderSource},
{NULL, NULL}
};
+static dllfunction_t glsl130funcs[] =
+{
+ {"glBindFragDataLocation", (void **) &qglBindFragDataLocation},
+ {NULL, NULL}
+};
+
static dllfunction_t vbofuncs[] =
{
{"glBindBufferARB" , (void **) &qglBindBufferARB},
void VID_CheckExtensions(void)
{
- if (!GL_CheckExtension("1.1", opengl110funcs, NULL, false))
+ if (!GL_CheckExtension("glbase", opengl110funcs, NULL, false))
Sys_Error("OpenGL 1.1.0 functions not found");
- vid.support.gl20shaders = GL_CheckExtension("2.0", gl20shaderfuncs, "-noshaders", false);
+ vid.support.gl20shaders = GL_CheckExtension("GL_ARB_fragment_shader", gl20shaderfuncs, "-noshaders", true);
CHECKGLERROR
Con_DPrint("Checking OpenGL extensions...\n");
+ if (vid.support.gl20shaders)
+ {
+ // this one is purely optional, needed for GLSL 1.3 support (#version 130), so we don't even check the return value of GL_CheckExtension
+ vid.support.gl20shaders130 = GL_CheckExtension("glshaders130", glsl130funcs, "-noglsl130", true);
+ if(vid.support.gl20shaders130)
+ {
+ char *s = (char *) qglGetString(GL_SHADING_LANGUAGE_VERSION);
+ if(!s || atof(s) < 1.30 - 0.00001)
+ vid.support.gl20shaders130 = 0;
+ }
+ if(vid.support.gl20shaders130)
+ Con_DPrintf("Using GLSL 1.30\n");
+ else
+ Con_DPrintf("Using GLSL 1.00\n");
+ }
+
+ // GL drivers generally prefer GL_BGRA
+ vid.forcetextype = GL_BGRA;
+
vid.support.amd_texture_texture4 = GL_CheckExtension("GL_AMD_texture_texture4", NULL, "-notexture4", false);
vid.support.arb_depth_texture = GL_CheckExtension("GL_ARB_depth_texture", NULL, "-nodepthtexture", false);
vid.support.arb_draw_buffers = GL_CheckExtension("GL_ARB_draw_buffers", drawbuffersfuncs, "-nodrawbuffers", false);
vid.support.arb_texture_gather = GL_CheckExtension("GL_ARB_texture_gather", NULL, "-notexturegather", false);
vid.support.arb_texture_non_power_of_two = GL_CheckExtension("GL_ARB_texture_non_power_of_two", NULL, "-notexturenonpoweroftwo", false);
vid.support.arb_vertex_buffer_object = GL_CheckExtension("GL_ARB_vertex_buffer_object", vbofuncs, "-novbo", false);
- vid.support.ati_separate_stencil = GL_CheckExtension("2.0", gl2separatestencilfuncs, "-noseparatestencil", true) || GL_CheckExtension("GL_ATI_separate_stencil", atiseparatestencilfuncs, "-noseparatestencil", false);
+ vid.support.ati_separate_stencil = GL_CheckExtension("separatestencil", gl2separatestencilfuncs, "-noseparatestencil", true) || GL_CheckExtension("GL_ATI_separate_stencil", atiseparatestencilfuncs, "-noseparatestencil", false);
vid.support.ext_blend_minmax = GL_CheckExtension("GL_EXT_blend_minmax", blendequationfuncs, "-noblendminmax", false);
vid.support.ext_blend_subtract = GL_CheckExtension("GL_EXT_blend_subtract", blendequationfuncs, "-noblendsubtract", false);
- vid.support.ext_draw_range_elements = GL_CheckExtension("1.2", drawrangeelementsfuncs, "-nodrawrangeelements", true) || GL_CheckExtension("GL_EXT_draw_range_elements", drawrangeelementsextfuncs, "-nodrawrangeelements", false);
+ vid.support.ext_draw_range_elements = GL_CheckExtension("drawrangeelements", drawrangeelementsfuncs, "-nodrawrangeelements", true) || GL_CheckExtension("GL_EXT_draw_range_elements", drawrangeelementsextfuncs, "-nodrawrangeelements", false);
vid.support.ext_framebuffer_object = GL_CheckExtension("GL_EXT_framebuffer_object", fbofuncs, "-nofbo", false);
vid.support.ext_stencil_two_side = GL_CheckExtension("GL_EXT_stencil_two_side", stenciltwosidefuncs, "-nostenciltwoside", false);
vid.support.ext_texture_3d = GL_CheckExtension("GL_EXT_texture3D", texture3dextfuncs, "-notexture3d", false);
vid.support.ext_texture_compression_s3tc = GL_CheckExtension("GL_EXT_texture_compression_s3tc", NULL, "-nos3tc", false);
vid.support.ext_texture_edge_clamp = GL_CheckExtension("GL_EXT_texture_edge_clamp", NULL, "-noedgeclamp", false) || GL_CheckExtension("GL_SGIS_texture_edge_clamp", NULL, "-noedgeclamp", false);
vid.support.ext_texture_filter_anisotropic = GL_CheckExtension("GL_EXT_texture_filter_anisotropic", NULL, "-noanisotropy", false);
+ vid.support.ext_texture_srgb = GL_CheckExtension("GL_EXT_texture_sRGB", NULL, "-nosrgb", false);
// COMMANDLINEOPTION: GL: -noshaders disables use of OpenGL 2.0 shaders (which allow pixel shader effects, can improve per pixel lighting performance and capabilities)
// COMMANDLINEOPTION: GL: -noanisotropy disables GL_EXT_texture_filter_anisotropic (allows higher quality texturing)
// COMMANDLINEOPTION: GL: -noblendminmax disables GL_EXT_blend_minmax
// COMMANDLINEOPTION: GL: -notexturegather disables GL_ARB_texture_gather (which provides fetch4 sampling)
// COMMANDLINEOPTION: GL: -notexturenonpoweroftwo disables GL_ARB_texture_non_power_of_two (which saves video memory if it is supported, but crashes on some buggy drivers)
// COMMANDLINEOPTION: GL: -novbo disables GL_ARB_vertex_buffer_object (which accelerates rendering)
+// COMMANDLINEOPTION: GL: -nosrgb disables GL_EXT_texture_sRGB (which is used for higher quality non-linear texture gamma)
if (vid.support.arb_draw_buffers)
qglGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, (GLint*)&vid.maxdrawbuffers);
vid.renderpath = RENDERPATH_GL20;
vid.useinterleavedarrays = false;
}
-#ifdef SUPPORTCG
- else if (vid_cggl.integer && (vid.cgcontext = cgCreateContext()))
- {
- vid.texunits = 4;
- vid.teximageunits = 16;
- vid.texarrayunits = 8;
- Con_DPrintf("Using NVIDIA Cg 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_CGGL;
- vid.useinterleavedarrays = false;
- }
-#endif
else if (vid.support.arb_texture_env_combine && vid.texunits >= 2 && vid_gl13.integer)
{
qglGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&vid.texunits);
Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
Cvar_SetQuick(&gl_info_driver, gl_driver);
}
-#endif // __IPHONEOS__
void Force_CenterView_f (void)
{
switch(vid.renderpath)
{
case RENDERPATH_GL20:
- case RENDERPATH_CGGL:
case RENDERPATH_D3D9:
case RENDERPATH_D3D10:
case RENDERPATH_D3D11:
case RENDERPATH_SOFT:
+ case RENDERPATH_GLES2:
if (v_glslgamma.integer)
wantgamma = 0;
break;
- case RENDERPATH_GL13:
case RENDERPATH_GL11:
+ case RENDERPATH_GL13:
+ case RENDERPATH_GLES1:
break;
}
if(!vid_activewindow)
void VID_Shared_Init(void)
{
+#ifdef SSE_POSSIBLE
+ if (Sys_HaveSSE2())
+ {
+ Con_Printf("DPSOFTRAST available (SSE2 instructions detected)\n");
+ Cvar_RegisterVariable(&vid_soft);
+ Cvar_RegisterVariable(&vid_soft_threads);
+ Cvar_RegisterVariable(&vid_soft_interlace);
+ }
+ else
+ Con_Printf("DPSOFTRAST not available (SSE2 disabled or not detected)\n");
+#else
+ Con_Printf("DPSOFTRAST not available (SSE2 not compiled in)\n");
+#endif
+
Cvar_RegisterVariable(&vid_hardwaregammasupported);
Cvar_RegisterVariable(&gl_info_vendor);
Cvar_RegisterVariable(&gl_info_renderer);
Cvar_RegisterVariable(&vid_vsync);
Cvar_RegisterVariable(&vid_mouse);
Cvar_RegisterVariable(&vid_grabkeyboard);
+ Cvar_RegisterVariable(&vid_touchscreen);
Cvar_RegisterVariable(&vid_stick_mouse);
Cvar_RegisterVariable(&vid_resizable);
Cvar_RegisterVariable(&vid_minwidth);
Cvar_RegisterVariable(&vid_minheight);
Cvar_RegisterVariable(&vid_gl13);
Cvar_RegisterVariable(&vid_gl20);
-#ifdef SUPPORTCG
- Cvar_RegisterVariable(&vid_cggl);
-#endif
Cvar_RegisterVariable(&gl_finish);
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)");
vid.stereobuffer = vid.mode.stereobuffer;
vid.samples = vid.mode.samples;
vid.stencil = vid.mode.bitsperpixel > 16;
+
Con_Printf("Video Mode: %s %dx%dx%dx%.2fhz%s%s\n", mode.fullscreen ? "fullscreen" : "window", mode.width, mode.height, mode.bitsperpixel, mode.refreshrate, mode.stereobuffer ? " stereo" : "", mode.samples > 1 ? va(" (%ix AA)", mode.samples) : "");
Cvar_SetValueQuick(&vid_fullscreen, vid.mode.fullscreen);
}
qboolean vid_commandlinecheck = true;
+extern qboolean vid_opened;
void VID_Restart_f(void)
{
if (vid_commandlinecheck)
return;
+ if (!vid_opened)
+ {
+ SCR_BeginLoadingPlaque();
+ return;
+ }
+
Con_Printf("VID_Restart: changing from %s %dx%dx%dbpp%s%s, to %s %dx%dx%dbpp%s%s.\n",
vid.mode.fullscreen ? "fullscreen" : "window", vid.mode.width, vid.mode.height, vid.mode.bitsperpixel, vid.mode.fullscreen && vid.mode.userefreshrate ? va("x%.2fhz", vid.mode.refreshrate) : "", vid.mode.samples > 1 ? va(" (%ix AA)", vid.mode.samples) : "",
vid_fullscreen.integer ? "fullscreen" : "window", vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, vid_fullscreen.integer && vid_userefreshrate.integer ? va("x%.2fhz", vid_refreshrate.value) : "", vid_samples.integer > 1 ? va(" (%ix AA)", vid_samples.integer) : "");
{NULL, NULL}
};
-// this is only called once by Host_StartVideo
+// this is only called once by Host_StartVideo and again on each FS_GameDir_f
void VID_Start(void)
{
int i, width, height, success;
VID_OpenSystems();
}
+void VID_Stop(void)
+{
+ VID_CloseSystems();
+ VID_Shutdown();
+}
+
int VID_SortModes_Compare(const void *a_, const void *b_)
{
vid_mode_t *a = (vid_mode_t *) a_;
}
return count;
}
+
+void VID_Soft_SharedSetup(void)
+{
+ gl_platform = "DPSOFTRAST";
+ gl_platformextensions = "";
+
+ gl_renderer = "DarkPlaces-Soft";
+ gl_vendor = "Forest Hale";
+ gl_version = "0.0";
+ gl_extensions = "";
+
+ // clear the extension flags
+ memset(&vid.support, 0, sizeof(vid.support));
+ Cvar_SetQuick(&gl_info_extensions, "");
+
+ // DPSOFTRAST requires BGRA
+ vid.forcetextype = TEXTYPE_BGRA;
+
+ vid.forcevbo = false;
+ vid.support.arb_depth_texture = true;
+ vid.support.arb_draw_buffers = true;
+ vid.support.arb_occlusion_query = true;
+ vid.support.arb_shadow = true;
+ //vid.support.arb_texture_compression = true;
+ vid.support.arb_texture_cube_map = true;
+ vid.support.arb_texture_non_power_of_two = false;
+ vid.support.arb_vertex_buffer_object = true;
+ vid.support.ext_blend_subtract = true;
+ vid.support.ext_draw_range_elements = true;
+ vid.support.ext_framebuffer_object = true;
+ vid.support.ext_texture_3d = true;
+ //vid.support.ext_texture_compression_s3tc = true;
+ vid.support.ext_texture_filter_anisotropic = true;
+ vid.support.ati_separate_stencil = true;
+ vid.support.ext_texture_srgb = false;
+
+ vid.maxtexturesize_2d = 16384;
+ vid.maxtexturesize_3d = 512;
+ vid.maxtexturesize_cubemap = 16384;
+ vid.texunits = 4;
+ vid.teximageunits = 32;
+ vid.texarrayunits = 8;
+ vid.max_anisotropy = 1;
+ vid.maxdrawbuffers = 4;
+
+ vid.texunits = bound(4, vid.texunits, MAX_TEXTUREUNITS);
+ vid.teximageunits = bound(16, vid.teximageunits, MAX_TEXTUREUNITS);
+ vid.texarrayunits = bound(8, vid.texarrayunits, MAX_TEXTUREUNITS);
+ Con_DPrintf("Using DarkPlaces Software Rasterizer rendering path\n");
+ vid.renderpath = RENDERPATH_SOFT;
+ vid.useinterleavedarrays = false;
+
+ 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);
+
+ // 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 );
+
+ // clear to black (loading plaque will be seen over this)
+ GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
+}