/**
* @sa R_Shutdown
*/
void VID_Init (void)
{
vid_stretch = Cvar_Get("vid_stretch", "0", CVAR_ARCHIVE | CVAR_R_CONTEXT, "Backward compatibility to stretch the screen with a 4:3 ratio");
vid_fullscreen = Cvar_Get("vid_fullscreen", "1", CVAR_ARCHIVE | CVAR_R_CONTEXT, "Run the game in fullscreen mode");
vid_mode = Cvar_Get("vid_mode", "-1", CVAR_ARCHIVE | CVAR_R_CONTEXT, "The video mode - set to -1 and use vid_width and vid_height to use a custom resolution");
Cvar_SetCheckFunction("vid_mode", CL_CvarCheckVidMode);
vid_grabmouse = Cvar_Get("vid_grabmouse", "0", CVAR_ARCHIVE, "Grab the mouse in the game window - open the console to switch back to your desktop via Alt+Tab");
vid_gamma = Cvar_Get("vid_gamma", "1", CVAR_ARCHIVE, "Controls the gamma settings");
vid_ignoregamma = Cvar_Get("vid_ignoregamma", "0", CVAR_ARCHIVE, "Don't control the gamma settings if set to 1");
Cvar_SetCheckFunction("vid_gamma", CL_CvarCheckVidGamma);
vid_height = Cvar_Get("vid_height", "-1", CVAR_ARCHIVE, "Custom video height - set vid_mode to -1 to use this");
vid_width = Cvar_Get("vid_width", "-1", CVAR_ARCHIVE, "Custom video width - set vid_mode to -1 to use this");
Cmd_AddCommand("vid_restart", VID_Restart_f, "Restart the renderer - or change the resolution");
Cmd_AddCommand("vid_minimize", VID_Minimize, "Minimize the game window");
/* memory pools */
vid_genericPool = Mem_CreatePool("Vid: Generic");
vid_imagePool = Mem_CreatePool("Vid: Image system");
vid_lightPool = Mem_CreatePool("Vid: Light system");
vid_modelPool = Mem_CreatePool("Vid: Model system");
/* Start the graphics mode */
R_Init();
}
/**
* @brief Only called once at startup, not for each game
*/
void SV_Init (void)
{
Com_Printf("\n------ server initialization -------\n");
sv_genericPool = Mem_CreatePool("Server: Generic");
OBJZERO(svs);
sv = (serverInstanceGame_t *) Mem_PoolAlloc(sizeof(*sv), sv_genericPool, 0);
SV_InitOperatorCommands();
rcon_password = Cvar_Get("rcon_password", "", 0, NULL);
Cvar_Get("sv_cheats", "0", CVAR_SERVERINFO | CVAR_LATCH, NULL);
Cvar_Get("sv_protocol", DOUBLEQUOTE(PROTOCOL_VERSION), CVAR_SERVERINFO | CVAR_NOSET, NULL);
/* this cvar will become a latched cvar when you start the server */
sv_maxclients = Cvar_Get("sv_maxclients", "1", CVAR_SERVERINFO, "Max. connected clients");
sv_hostname = Cvar_Get("sv_hostname", "noname", CVAR_SERVERINFO | CVAR_ARCHIVE, "The name of the server that is displayed in the serverlist");
sv_http_downloadserver = Cvar_Get("sv_http_downloadserver", "", CVAR_ARCHIVE, "URL to a location where clients can download game content over HTTP");
sv_enablemorale = Cvar_Get("sv_enablemorale", "1", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_LATCH, "Enable morale changes in multiplayer");
sv_maxsoldiersperteam = Cvar_Get("sv_maxsoldiersperteam", "4", CVAR_ARCHIVE | CVAR_SERVERINFO, "Max. amount of soldiers per team (see sv_maxsoldiersperplayer and sv_teamplay)");
sv_maxsoldiersperplayer = Cvar_Get("sv_maxsoldiersperplayer", "8", CVAR_ARCHIVE | CVAR_SERVERINFO, "Max. amount of soldiers each player can controll (see maxsoldiers and sv_teamplay)");
Cvar_SetCheckFunction("sv_maxsoldiersperplayer", SV_CheckMaxSoldiersPerPlayer);
sv_dumpmapassembly = Cvar_Get("sv_dumpmapassembly", "0", CVAR_ARCHIVE, "Dump map assembly information to game console");
sv_threads = Cvar_Get("sv_threads", "1", CVAR_LATCH | CVAR_ARCHIVE, "Run the server threaded");
sv_public = Cvar_Get("sv_public", "1", 0, "Should heartbeats be send to the masterserver");
sv_reconnect_limit = Cvar_Get("sv_reconnect_limit", "3", CVAR_ARCHIVE, "Minimum seconds between connect messages");
SV_MapcycleInit();
}
/**
* @brief Init function
* @sa Com_ParseScripts
* @sa Qcommon_Shutdown
* @sa Sys_Init
* @sa CL_Init
*/
void Qcommon_Init (int argc, char** argv)
{
logfile_active = nullptr;
developer = nullptr;
Sys_InitSignals();
/* random seed */
Com_SetRandomSeed(time(nullptr));
com_aliasSysPool = Mem_CreatePool("Common: Alias system for commands and enums");
com_cmdSysPool = Mem_CreatePool("Common: Command system");
com_cmodelSysPool = Mem_CreatePool("Common: Collision model");
com_cvarSysPool = Mem_CreatePool("Common: Cvar system");
com_fileSysPool = Mem_CreatePool("Common: File system");
com_genericPool = Mem_CreatePool("Generic");
com_networkPool = Mem_CreatePool("Network");
try {
OBJZERO(csi);
/* prepare enough of the subsystems to handle
* cvar and command buffer management */
Com_InitArgv(argc, argv);
Swap_Init();
Cbuf_Init();
Cmd_Init();
Cvar_Init();
uploadcrashdump = Cvar_Get("uploadcrashdump", "1", 0, "upload crashdumps to the developers");
Key_Init();
/* we need to add the early commands twice, because
* a basedir needs to be set before executing
* config files, but we want other parms to override
* the settings of the config files */
Cbuf_AddEarlyCommands(false);
Cbuf_Execute();
FS_InitFilesystem(true);
Cbuf_AddText("exec default.cfg\n");
#ifdef DEDICATED_ONLY
Cbuf_AddText("exec dedconfig.cfg\n");
#else
Cbuf_AddText("exec config.cfg\n");
#endif
Cbuf_AddEarlyCommands(true);
Cbuf_Execute();
Com_SetRenderModified(false);
Com_SetUserinfoModified(false);
/* init commands and vars */
Cmd_AddCommand("saveconfig", Com_WriteConfig_f, "Write the configuration to file");
Cmd_AddCommand("gametypelist", Com_GameTypeList_f, "List all available multiplayer game types");
#ifdef DEBUG
Cmd_AddCommand("debug_help", Com_DebugHelp_f, "Show some debugging help");
Cmd_AddCommand("debug_error", Com_DebugError_f, "Just throw a fatal error to test error shutdown procedures");
#endif
Cmd_AddCommand("setdeveloper", Com_DeveloperSet_f, "Set the developer cvar to only get the debug output you want");
developer = Cvar_Get("developer", "0", 0, "Activate developer output to logfile and gameconsole");
#ifdef DEBUG
logfile_active = Cvar_Get("logfile", "2", 0, "0 = deactivate logfile, 1 = write normal logfile, 2 = flush on every new line, 3 = always append to existing file");
#else
logfile_active = Cvar_Get("logfile", "1", 0, "0 = deactivate logfile, 1 = write normal logfile, 2 = flush on every new line, 3 = always append to existing file");
#endif
sv_gametype = Cvar_Get("sv_gametype", "fight1on1", CVAR_ARCHIVE | CVAR_SERVERINFO, "Sets the multiplayer gametype - see gametypelist command for a list of all gametypes");
http_proxy = Cvar_Get("http_proxy", "", CVAR_ARCHIVE, "Use this proxy for http transfers");
http_timeout = Cvar_Get("http_timeout", "3", CVAR_ARCHIVE, "Http connection and read timeout");
port = Cvar_Get("port", DOUBLEQUOTE(PORT_SERVER), CVAR_NOSET);
masterserver_url = Cvar_Get("masterserver_url", MASTER_SERVER, CVAR_ARCHIVE, "URL of UFO:AI masterserver");
#ifdef DEDICATED_ONLY
sv_dedicated = Cvar_Get("sv_dedicated", "1", CVAR_SERVERINFO | CVAR_NOSET, "Is this a dedicated server?");
/* don't allow to override this from commandline of config */
Cvar_ForceSet("sv_dedicated", "1");
#else
sv_dedicated = Cvar_Get("sv_dedicated", "0", CVAR_SERVERINFO | CVAR_NOSET, "Is this a dedicated server?");
/* set this to false for client - otherwise Qcommon_Frame would set the initial values to multiplayer */
sv_gametype->modified = false;
s_language = Cvar_Get("s_language", "", CVAR_ARCHIVE, "Game language - full language string e.g. en_EN.UTF-8");
s_language->modified = false;
cl_maxfps = Cvar_Get("cl_maxfps", "50", CVAR_ARCHIVE);
Cvar_SetCheckFunction("cl_maxfps", Com_CvarCheckMaxFPS);
#endif
// 5 is an i7 with a medium gfx-card
// 3 dual core with 2 GB
// 2 EeePc with 1 GB
// 1 smartphone
const char* hwclassVal = "5";
#ifdef __ANDROID__
/** get the hardware class of the machine we are running on. */
hwclassVal = "1";
#endif
hwclass = Cvar_Get("hwclass", hwclassVal, 0, "Defines the hardware class of this machine. 1 is the lowest, 5 is the highest.");
const char* s = va("UFO: Alien Invasion %s %s %s %s", UFO_VERSION, CPUSTRING, __DATE__, BUILDSTRING);
Cvar_Get("version", s, CVAR_NOSET, "Full version string");
Cvar_Get("ver", UFO_VERSION, CVAR_SERVERINFO | CVAR_NOSET, "Version number");
if (sv_dedicated->integer)
Cmd_AddCommand("quit", Com_Quit, "Quits the game");
Mem_Init();
Sys_Init();
NET_Init();
#ifndef NO_HTTP
curl_global_init(CURL_GLOBAL_NOTHING);
Com_Printf("%s initialized.\n", curl_version());
#endif
SV_Init();
/* e.g. init the client hunk that is used in script parsing */
CL_Init();
Com_ParseScripts(sv_dedicated->integer);
#ifndef DEDICATED_ONLY
Cbuf_AddText("exec keys.cfg\n");
#endif
if (!sv_dedicated->integer)
Cbuf_AddText("init\n");
else
Cbuf_AddText("dedicated_start\n");
Cbuf_Execute();
FS_ExecAutoexec();
/* add + commands from command line
* if the user didn't give any commands, run default action */
if (Cbuf_AddLateCommands()) {
/* the user asked for something explicit
* so drop the loading plaque */
SCR_EndLoadingPlaque();
}
const cvar_t* com_pipefile = Cvar_Get("com_pipefile", "", CVAR_ARCHIVE, "Filename of the pipe that is used to send commands to the game");
if (com_pipefile->string[0] != '\0') {
FS_CreateOpenPipeFile(com_pipefile->string, &pipefile);
}
CL_InitAfter();
/* Check memory integrity */
Mem_CheckGlobalIntegrity();
#ifndef DEDICATED_ONLY
if (!sv_dedicated->integer) {
Schedule_Timer(cl_maxfps, &CL_Frame, nullptr, nullptr);
Schedule_Timer(Cvar_Get("cl_slowfreq", "10", 0, nullptr), &CL_SlowFrame, nullptr, nullptr);
/* now hide the console */
Sys_ShowConsole(false);
}
#endif
Schedule_Timer(Cvar_Get("sv_freq", "10", CVAR_NOSET, nullptr), &SV_Frame, nullptr, nullptr);
/** @todo This line wants to be removed */
Schedule_Timer(Cvar_Get("cbuf_freq", "10", 0, nullptr), &Cbuf_Execute_timer, nullptr, nullptr);
Com_Printf("====== UFO Initialized ======\n");
Com_Printf("=============================\n");
} catch (comDrop_t const&) {
Sys_Error("Error during initialization");
}
}
/**
* @brief Check and load all needed and supported opengl extensions
* @sa R_Init
*/
static void R_InitExtensions (void)
{
GLenum err;
int tmpInteger;
/* Get OpenGL version.*/
sscanf(r_config.versionString, "%d.%d", &r_config.glVersionMajor, &r_config.glVersionMinor);
/* multitexture */
qglActiveTexture = NULL;
qglClientActiveTexture = NULL;
/* vertex buffer */
qglGenBuffers = NULL;
qglDeleteBuffers = NULL;
qglBindBuffer = NULL;
qglBufferData = NULL;
/* glsl */
qglCreateShader = NULL;
qglDeleteShader = NULL;
qglShaderSource = NULL;
qglCompileShader = NULL;
qglGetShaderiv = NULL;
qglGetShaderInfoLog = NULL;
qglCreateProgram = NULL;
qglDeleteProgram = NULL;
qglAttachShader = NULL;
qglDetachShader = NULL;
qglLinkProgram = NULL;
qglUseProgram = NULL;
qglGetActiveUniform = NULL;
qglGetProgramiv = NULL;
qglGetProgramInfoLog = NULL;
qglGetUniformLocation = NULL;
qglUniform1i = NULL;
qglUniform1f = NULL;
qglUniform1fv = NULL;
qglUniform2fv = NULL;
qglUniform3fv = NULL;
qglUniform4fv = NULL;
qglGetAttribLocation = NULL;
qglUniformMatrix4fv = NULL;
/* vertex attribute arrays */
qglEnableVertexAttribArray = NULL;
qglDisableVertexAttribArray = NULL;
qglVertexAttribPointer = NULL;
/* framebuffer objects */
qglIsRenderbufferEXT = NULL;
qglBindRenderbufferEXT = NULL;
qglDeleteRenderbuffersEXT = NULL;
qglGenRenderbuffersEXT = NULL;
qglRenderbufferStorageEXT = NULL;
qglRenderbufferStorageMultisampleEXT = NULL;
qglGetRenderbufferParameterivEXT = NULL;
qglIsFramebufferEXT = NULL;
qglBindFramebufferEXT = NULL;
qglDeleteFramebuffersEXT = NULL;
qglGenFramebuffersEXT = NULL;
qglCheckFramebufferStatusEXT = NULL;
qglFramebufferTexture1DEXT = NULL;
qglFramebufferTexture2DEXT = NULL;
qglFramebufferTexture3DEXT = NULL;
qglFramebufferRenderbufferEXT = NULL;
qglGetFramebufferAttachmentParameterivEXT = NULL;
qglGenerateMipmapEXT = NULL;
qglDrawBuffers = NULL;
/* multitexture */
if (R_CheckExtension("GL_ARB_multitexture")) {
qglActiveTexture = (ActiveTexture_t)R_GetProcAddress("glActiveTexture");
qglClientActiveTexture = (ClientActiveTexture_t)R_GetProcAddress("glClientActiveTexture");
}
if (R_CheckExtension("GL_ARB_texture_compression")) {
if (r_ext_texture_compression->integer) {
Com_Printf("using GL_ARB_texture_compression\n");
if (r_ext_s3tc_compression->integer && strstr(r_config.extensionsString, "GL_EXT_texture_compression_s3tc")) {
r_config.gl_compressed_solid_format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
r_config.gl_compressed_alpha_format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
} else {
r_config.gl_compressed_solid_format = GL_COMPRESSED_RGB_ARB;
r_config.gl_compressed_alpha_format = GL_COMPRESSED_RGBA_ARB;
}
}
}
if (R_CheckExtension("GL_ARB_texture_non_power_of_two")) {
if (r_ext_nonpoweroftwo->integer) {
Com_Printf("using GL_ARB_texture_non_power_of_two\n");
r_config.nonPowerOfTwo = true;
} else {
r_config.nonPowerOfTwo = false;
Com_Printf("ignoring GL_ARB_texture_non_power_of_two\n");
}
} else {
if (R_CheckGLVersion(2, 0)) {
r_config.nonPowerOfTwo = r_ext_nonpoweroftwo->integer == 1;
} else {
r_config.nonPowerOfTwo = false;
}
}
/* anisotropy */
if (R_CheckExtension("GL_EXT_texture_filter_anisotropic")) {
if (r_anisotropic->integer) {
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &r_config.maxAnisotropic);
R_CheckError();
if (r_anisotropic->integer > r_config.maxAnisotropic) {
Com_Printf("max GL_EXT_texture_filter_anisotropic value is %i\n", r_config.maxAnisotropic);
Cvar_SetValue("r_anisotropic", r_config.maxAnisotropic);
}
if (r_config.maxAnisotropic)
r_config.anisotropic = true;
}
}
if (R_CheckExtension("GL_EXT_texture_lod_bias"))
r_config.lod_bias = true;
/* vertex buffer objects */
if (R_CheckExtension("GL_ARB_vertex_buffer_object")) {
qglGenBuffers = (GenBuffers_t)R_GetProcAddress("glGenBuffers");
qglDeleteBuffers = (DeleteBuffers_t)R_GetProcAddress("glDeleteBuffers");
qglBindBuffer = (BindBuffer_t)R_GetProcAddress("glBindBuffer");
qglBufferData = (BufferData_t)R_GetProcAddress("glBufferData");
glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &r_config.maxVertexBufferSize);
Com_Printf("using GL_ARB_vertex_buffer_object\nmax vertex buffer size: %i\n", r_config.maxVertexBufferSize);
}
/* glsl vertex and fragment shaders and programs */
if (R_CheckExtension("GL_ARB_fragment_shader")) {
qglCreateShader = (CreateShader_t)R_GetProcAddress("glCreateShader");
qglDeleteShader = (DeleteShader_t)R_GetProcAddress("glDeleteShader");
qglShaderSource = (ShaderSource_t)R_GetProcAddress("glShaderSource");
qglCompileShader = (CompileShader_t)R_GetProcAddress("glCompileShader");
qglGetShaderiv = (GetShaderiv_t)R_GetProcAddress("glGetShaderiv");
qglGetShaderInfoLog = (GetShaderInfoLog_t)R_GetProcAddress("glGetShaderInfoLog");
qglCreateProgram = (CreateProgram_t)R_GetProcAddress("glCreateProgram");
qglDeleteProgram = (DeleteProgram_t)R_GetProcAddress("glDeleteProgram");
qglAttachShader = (AttachShader_t)R_GetProcAddress("glAttachShader");
qglDetachShader = (DetachShader_t)R_GetProcAddress("glDetachShader");
qglLinkProgram = (LinkProgram_t)R_GetProcAddress("glLinkProgram");
qglUseProgram = (UseProgram_t)R_GetProcAddress("glUseProgram");
qglGetActiveUniform = (GetActiveUniforms_t)R_GetProcAddress("glGetActiveUniform");
qglGetProgramiv = (GetProgramiv_t)R_GetProcAddress("glGetProgramiv");
qglGetProgramInfoLog = (GetProgramInfoLog_t)R_GetProcAddress("glGetProgramInfoLog");
qglGetUniformLocation = (GetUniformLocation_t)R_GetProcAddress("glGetUniformLocation");
qglUniform1i = (Uniform1i_t)R_GetProcAddress("glUniform1i");
qglUniform1f = (Uniform1f_t)R_GetProcAddress("glUniform1f");
qglUniform1fv = (Uniform1fv_t)R_GetProcAddress("glUniform1fv");
qglUniform2fv = (Uniform2fv_t)R_GetProcAddress("glUniform2fv");
qglUniform3fv = (Uniform3fv_t)R_GetProcAddress("glUniform3fv");
qglUniform4fv = (Uniform4fv_t)R_GetProcAddress("glUniform4fv");
qglGetAttribLocation = (GetAttribLocation_t)R_GetProcAddress("glGetAttribLocation");
qglUniformMatrix4fv = (UniformMatrix4fv_t)R_GetProcAddress("glUniformMatrix4fv");
/* vertex attribute arrays */
qglEnableVertexAttribArray = (EnableVertexAttribArray_t)R_GetProcAddress("glEnableVertexAttribArray");
qglDisableVertexAttribArray = (DisableVertexAttribArray_t)R_GetProcAddress("glDisableVertexAttribArray");
qglVertexAttribPointer = (VertexAttribPointer_t)R_GetProcAddress("glVertexAttribPointer");
}
if (R_CheckExtension("GL_ARB_shading_language_100") || r_config.glVersionMajor >= 2) {
/* The GL_ARB_shading_language_100 extension was added to core specification since OpenGL 2.0;
* it is ideally listed in the extensions for backwards compatibility. If it isn't there and OpenGL > v2.0
* then enable shaders as the implementation supports the shading language!*/
const char *shadingVersion = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
sscanf(shadingVersion, "%d.%d", &r_config.glslVersionMajor, &r_config.glslVersionMinor);
Com_Printf("GLSL version guaranteed to be supported by OpenGL implementation postfixed by vender supplied info: %i.%i\n",
r_config.glslVersionMajor, r_config.glslVersionMinor);
} else {
/* The shading language is not supported.*/
Com_Printf("GLSL shaders unsupported by OpenGL implementation.\n");
}
/* framebuffer objects */
if (R_CheckExtension("GL_###_framebuffer_object")) {
qglIsRenderbufferEXT = (IsRenderbufferEXT_t)R_GetProcAddressExt("glIsRenderbuffer###");
qglBindRenderbufferEXT = (BindRenderbufferEXT_t)R_GetProcAddressExt("glBindRenderbuffer###");
qglDeleteRenderbuffersEXT = (DeleteRenderbuffersEXT_t)R_GetProcAddressExt("glDeleteRenderbuffers###");
qglGenRenderbuffersEXT = (GenRenderbuffersEXT_t)R_GetProcAddressExt("glGenRenderbuffers###");
qglRenderbufferStorageEXT = (RenderbufferStorageEXT_t)R_GetProcAddressExt("glRenderbufferStorage###");
qglRenderbufferStorageMultisampleEXT = (RenderbufferStorageMultisampleEXT_t)R_GetProcAddressExt("glRenderbufferStorageMultisample###");
qglGetRenderbufferParameterivEXT = (GetRenderbufferParameterivEXT_t)R_GetProcAddressExt("glGetRenderbufferParameteriv###");
qglIsFramebufferEXT = (IsFramebufferEXT_t)R_GetProcAddressExt("glIsFramebuffer###");
qglBindFramebufferEXT = (BindFramebufferEXT_t)R_GetProcAddressExt("glBindFramebuffer###");
qglDeleteFramebuffersEXT = (DeleteFramebuffersEXT_t)R_GetProcAddressExt("glDeleteFramebuffers###");
qglGenFramebuffersEXT = (GenFramebuffersEXT_t)R_GetProcAddressExt("glGenFramebuffers###");
qglCheckFramebufferStatusEXT = (CheckFramebufferStatusEXT_t)R_GetProcAddressExt("glCheckFramebufferStatus###");
qglFramebufferTexture1DEXT = (FramebufferTexture1DEXT_t)R_GetProcAddressExt("glFramebufferTexture1D###");
qglFramebufferTexture2DEXT = (FramebufferTexture2DEXT_t)R_GetProcAddressExt("glFramebufferTexture2D###");
qglFramebufferTexture3DEXT = (FramebufferTexture3DEXT_t)R_GetProcAddressExt("glFramebufferTexture3D###");
qglFramebufferRenderbufferEXT = (FramebufferRenderbufferEXT_t)R_GetProcAddressExt("glFramebufferRenderbuffer###");
qglGetFramebufferAttachmentParameterivEXT = (GetFramebufferAttachmentParameterivEXT_t)R_GetProcAddressExt("glGetFramebufferAttachmentParameteriv###");
qglGenerateMipmapEXT = (GenerateMipmapEXT_t)R_GetProcAddressExt("glGenerateMipmap###");
qglDrawBuffers = (DrawBuffers_t)R_GetProcAddress("glDrawBuffers");
qglBlitFramebuffer = (BlitFramebuffer_t)R_GetProcAddress("glBlitFramebuffer");
if (qglDeleteRenderbuffersEXT && qglDeleteFramebuffersEXT && qglGenFramebuffersEXT && qglBindFramebufferEXT
&& qglFramebufferTexture2DEXT && qglBindRenderbufferEXT && qglRenderbufferStorageEXT && qglCheckFramebufferStatusEXT) {
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &r_config.maxDrawBuffers);
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &r_config.maxColorAttachments);
glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE_EXT, &r_config.maxRenderbufferSize);
r_config.frameBufferObject = true;
Com_Printf("using GL_ARB_framebuffer_object\n");
Com_Printf("max draw buffers: %i\n", r_config.maxDrawBuffers);
Com_Printf("max render buffer size: %i\n", r_config.maxRenderbufferSize);
Com_Printf("max color attachments: %i\n", r_config.maxColorAttachments);
} else {
Com_Printf("skipping GL_ARB_framebuffer_object - not every needed extension is supported\n");
}
if (r_config.maxDrawBuffers > 1 && R_CheckExtension("GL_###_draw_buffers")) {
Com_Printf("using GL_ARB_draw_buffers\n");
r_config.drawBuffers = true;
} else {
r_config.drawBuffers = false;
}
} else {
Com_Printf("Framebuffer objects unsupported by OpenGL implementation.\n");
}
r_programs = Cvar_Get("r_programs", "1", CVAR_ARCHIVE | CVAR_R_PROGRAMS, "GLSL shaders level: 0 - disabled, 1 - low, 2 - medium, 3 - high");
r_programs->modified = false;
Cvar_SetCheckFunction("r_programs", R_CvarPrograms);
r_glsl_version = Cvar_Get("r_glsl_version", "1.10", CVAR_ARCHIVE | CVAR_R_PROGRAMS, "GLSL Version");
Cvar_SetCheckFunction("r_glsl_version", R_CvarGLSLVersionCheck);
r_postprocess = Cvar_Get("r_postprocess", "1", CVAR_ARCHIVE | CVAR_R_PROGRAMS, "Activate postprocessing shader effects");
Cvar_SetCheckFunction("r_postprocess", R_CvarPostProcess);
/* reset gl error state */
R_CheckError();
glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &r_config.maxVertexTextureImageUnits);
Com_Printf("max supported vertex texture units: %i\n", r_config.maxVertexTextureImageUnits);
glGetIntegerv(GL_MAX_LIGHTS, &r_config.maxLights);
Com_Printf("max supported lights: %i\n", r_config.maxLights);
r_dynamic_lights = Cvar_Get("r_dynamic_lights", "1", CVAR_ARCHIVE | CVAR_R_PROGRAMS, "Sets max number of GL lightsources to use in shaders");
Cvar_SetCheckFunction("r_dynamic_lights", R_CvarCheckDynamicLights);
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &r_config.maxTextureUnits);
Com_Printf("max texture units: %i\n", r_config.maxTextureUnits);
if (r_config.maxTextureUnits < 2)
Com_Error(ERR_FATAL, "You need at least 2 texture units to run " GAME_TITLE);
glGetIntegerv(GL_MAX_TEXTURE_COORDS, &r_config.maxTextureCoords);
Com_Printf("max texture coords: %i\n", r_config.maxTextureCoords);
r_config.maxTextureCoords = std::max(r_config.maxTextureUnits, r_config.maxTextureCoords);
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &r_config.maxVertexAttribs);
Com_Printf("max vertex attributes: %i\n", r_config.maxVertexAttribs);
glGetIntegerv(GL_MAX_VARYING_FLOATS, &tmpInteger);
Com_Printf("max varying floats: %i\n", tmpInteger);
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &tmpInteger);
Com_Printf("max fragment uniform components: %i\n", tmpInteger);
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &tmpInteger);
Com_Printf("max vertex uniform components: %i\n", tmpInteger);
/* reset gl error state */
R_CheckError();
/* check max texture size */
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &r_config.maxTextureSize);
/* stubbed or broken drivers may have reported 0 */
if (r_config.maxTextureSize <= 0)
r_config.maxTextureSize = 256;
if ((err = glGetError()) != GL_NO_ERROR) {
Com_Printf("max texture size: cannot detect - using %i! (%s)\n", r_config.maxTextureSize, R_TranslateError(err));
Cvar_SetValue("r_maxtexres", r_config.maxTextureSize);
} else {
Com_Printf("max texture size: detected %d\n", r_config.maxTextureSize);
if (r_maxtexres->integer > r_config.maxTextureSize) {
Com_Printf("...downgrading from %i\n", r_maxtexres->integer);
Cvar_SetValue("r_maxtexres", r_config.maxTextureSize);
/* check for a minimum */
} else if (r_maxtexres->integer >= 128 && r_maxtexres->integer < r_config.maxTextureSize) {
Com_Printf("...but using %i as requested\n", r_maxtexres->integer);
r_config.maxTextureSize = r_maxtexres->integer;
}
}
if (r_config.maxTextureSize > 4096 && R_ImageExists("pics/geoscape/%s/map_earth_season_00", "high")) {
Q_strncpyz(r_config.lodDir, "high", sizeof(r_config.lodDir));
Com_Printf("Using high resolution globe textures as requested.\n");
} else if (r_config.maxTextureSize > 2048 && R_ImageExists("pics/geoscape/med/map_earth_season_00")) {
if (r_config.maxTextureSize > 4096) {
Com_Printf("Warning: high resolution globe textures requested, but could not be found; falling back to medium resolution globe textures.\n");
} else {
Com_Printf("Using medium resolution globe textures as requested.\n");
}
Q_strncpyz(r_config.lodDir, "med", sizeof(r_config.lodDir));
} else {
if (r_config.maxTextureSize > 2048) {
Com_Printf("Warning: medium resolution globe textures requested, but could not be found; falling back to low resolution globe textures.\n");
} else {
Com_Printf("Using low resolution globe textures as requested.\n");
}
Q_strncpyz(r_config.lodDir, "low", sizeof(r_config.lodDir));
}
}
static void R_RegisterSystemVars (void)
{
const cmdList_t *commands;
r_driver = Cvar_Get("r_driver", "", CVAR_ARCHIVE | CVAR_R_CONTEXT, "You can define the opengl driver you want to use - empty if you want to use the system default");
r_drawentities = Cvar_Get("r_drawentities", "1", 0, "Draw the local entities");
r_drawworld = Cvar_Get("r_drawworld", "1", 0, "Draw the world brushes");
r_isometric = Cvar_Get("r_isometric", "0", CVAR_ARCHIVE, "Draw the world in isometric mode");
r_nocull = Cvar_Get("r_nocull", "0", 0, "Don't perform culling for brushes and entities");
r_anisotropic = Cvar_Get("r_anisotropic", "1", CVAR_ARCHIVE);
r_texture_lod = Cvar_Get("r_texture_lod", "0", CVAR_ARCHIVE);
r_screenshot_format = Cvar_Get("r_screenshot_format", "jpg", CVAR_ARCHIVE, "png, jpg or tga are valid screenshot formats");
r_screenshot_jpeg_quality = Cvar_Get("r_screenshot_jpeg_quality", "75", CVAR_ARCHIVE, "jpeg quality in percent for jpeg screenshots");
r_threads = Cvar_Get("r_threads", "0", CVAR_ARCHIVE, "Activate threads for the renderer");
r_materials = Cvar_Get("r_materials", "1", CVAR_ARCHIVE, "Activate material subsystem");
r_default_specular = Cvar_Get("r_default_specular", "0.2", CVAR_R_CONTEXT, "Default specular exponent");
r_default_hardness = Cvar_Get("r_default_hardness", "0.2", CVAR_R_CONTEXT, "Default specular brightness");
Cvar_RegisterChangeListener("r_default_specular", R_UpdateDefaultMaterial);
Cvar_RegisterChangeListener("r_default_hardness", R_UpdateDefaultMaterial);
r_checkerror = Cvar_Get("r_checkerror", "0", CVAR_ARCHIVE, "Check for opengl errors");
r_shadows = Cvar_Get("r_shadows", "1", CVAR_ARCHIVE, "Multiplier for the alpha of the shadows");
r_stencilshadows = Cvar_Get("r_stencilshadows", "0", CVAR_ARCHIVE, "Activate or deactivate stencil shadows");
r_maxtexres = Cvar_Get("r_maxtexres", "2048", CVAR_ARCHIVE | CVAR_R_IMAGES, "The maximum texture resolution UFO should use");
r_texturemode = Cvar_Get("r_texturemode", "GL_LINEAR_MIPMAP_LINEAR", CVAR_ARCHIVE, "change the filtering and mipmapping for textures");
r_texturealphamode = Cvar_Get("r_texturealphamode", "GL_RGBA", CVAR_ARCHIVE);
r_texturesolidmode = Cvar_Get("r_texturesolidmode", "GL_RGB", CVAR_ARCHIVE);
r_wire = Cvar_Get("r_wire", "0", 0, "Draw the scene in wireframe mode");
r_showbox = Cvar_Get("r_showbox", "0", CVAR_ARCHIVE, "1=Shows model bounding box, 2=show also the brushes bounding boxes");
r_lightmap = Cvar_Get("r_lightmap", "0", CVAR_R_PROGRAMS, "Draw only the lightmap");
r_lightmap->modified = false;
r_deluxemap = Cvar_Get("r_deluxemap", "0", CVAR_R_PROGRAMS, "Draw only the deluxemap");
r_deluxemap->modified = false;
r_debug_normals = Cvar_Get("r_debug_normals", "0", CVAR_R_PROGRAMS, "Draw dot(normal, light_0 direction)");
r_debug_normals->modified = false;
r_debug_tangents = Cvar_Get("r_debug_tangents", "0", CVAR_R_PROGRAMS, "Draw tangent, bitangent, and normal dotted with light dir as RGB espectively");
r_debug_tangents->modified = false;
r_debug_lights = Cvar_Get("r_debug_lights", "0", CVAR_ARCHIVE, "Draw active light sources");
r_ext_texture_compression = Cvar_Get("r_ext_texture_compression", "0", CVAR_ARCHIVE | CVAR_R_CONTEXT);
r_ext_nonpoweroftwo = Cvar_Get("r_ext_nonpoweroftwo", "1", CVAR_ARCHIVE, "Enable or disable the non power of two extension");
r_ext_s3tc_compression = Cvar_Get("r_ext_s3tc_compression", "1", CVAR_ARCHIVE, "Also see r_ext_texture_compression");
r_intel_hack = Cvar_Get("r_intel_hack", "1", CVAR_ARCHIVE, "Intel cards have activated texture compression and no shaders until this is set to 0");
r_vertexbuffers = Cvar_Get("r_vertexbuffers", "0", CVAR_ARCHIVE | CVAR_R_CONTEXT, "Controls usage of OpenGL Vertex Buffer Objects (VBO) versus legacy vertex arrays.");
r_maxlightmap = Cvar_Get("r_maxlightmap", "2048", CVAR_ARCHIVE | CVAR_LATCH, "Reduce this value on older hardware");
Cvar_SetCheckFunction("r_maxlightmap", R_CvarCheckMaxLightmap);
r_drawbuffer = Cvar_Get("r_drawbuffer", "GL_BACK");
r_swapinterval = Cvar_Get("r_swapinterval", "0", CVAR_ARCHIVE | CVAR_R_CONTEXT, "Controls swap interval synchronization (V-Sync). Values between 0 and 2");
r_multisample = Cvar_Get("r_multisample", "0", CVAR_ARCHIVE | CVAR_R_CONTEXT, "Controls multisampling (anti-aliasing). Values between 0 and 4");
r_warp = Cvar_Get("r_warp", "1", CVAR_ARCHIVE, "Activates or deactivates warping surface rendering");
r_shownormals = Cvar_Get("r_shownormals", "0", CVAR_ARCHIVE, "Show normals on bsp surfaces");
r_bumpmap = Cvar_Get("r_bumpmap", "1.0", CVAR_ARCHIVE | CVAR_R_PROGRAMS, "Activate bump mapping");
r_specular = Cvar_Get("r_specular", "1.0", CVAR_ARCHIVE, "Controls specular parameters");
r_hardness = Cvar_Get("r_hardness", "1.0", CVAR_ARCHIVE, "Hardness control for GLSL shaders (specular, bump, ...)");
r_parallax = Cvar_Get("r_parallax", "1.0", CVAR_ARCHIVE, "Controls parallax parameters");
r_fog = Cvar_Get("r_fog", "1", CVAR_ARCHIVE | CVAR_R_PROGRAMS, "Activate or deactivate fog");
r_flares = Cvar_Get("r_flares", "1", CVAR_ARCHIVE, "Activate or deactivate flares");
r_coronas = Cvar_Get("r_coronas", "1", CVAR_ARCHIVE, "Activate or deactivate coronas");
r_particles = Cvar_Get("r_particles", "1", 0, "Activate or deactivate particle rendering");
r_drawtags = Cvar_Get("r_drawtags", "0", 0, "Activate or deactivate tag rendering");
for (commands = r_commands; commands->name; commands++)
Cmd_AddCommand(commands->name, commands->function, commands->description);
}
