diff options
Diffstat (limited to 'src/engine/rendergl.cpp')
| -rw-r--r-- | src/engine/rendergl.cpp | 2388 |
1 files changed, 2388 insertions, 0 deletions
diff --git a/src/engine/rendergl.cpp b/src/engine/rendergl.cpp new file mode 100644 index 0000000..6049951 --- /dev/null +++ b/src/engine/rendergl.cpp @@ -0,0 +1,2388 @@ +// rendergl.cpp: core opengl rendering stuff + +#include "engine.h" + +bool hasVAO = false, hasFBO = false, hasAFBO = false, hasDS = false, hasTF = false, hasTRG = false, hasTSW = false, hasS3TC = false, hasFXT1 = false, hasLATC = false, hasRGTC = false, hasAF = false, hasFBB = false, hasUBO = false, hasMBR = false; + +VAR(glversion, 1, 0, 0); +VAR(glslversion, 1, 0, 0); +VAR(glcompat, 1, 0, 0); + +// OpenGL 1.3 +#ifdef WIN32 +PFNGLACTIVETEXTUREPROC glActiveTexture_ = NULL; + +PFNGLBLENDEQUATIONEXTPROC glBlendEquation_ = NULL; +PFNGLBLENDCOLOREXTPROC glBlendColor_ = NULL; + +PFNGLTEXIMAGE3DPROC glTexImage3D_ = NULL; +PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D_ = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D_ = NULL; + +PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D_ = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D_ = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D_ = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D_ = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage_ = NULL; + +PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements_ = NULL; +#endif + +// OpenGL 2.0 +#ifndef __APPLE__ +PFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays_ = NULL; +PFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements_ = NULL; + +PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate_ = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate_ = NULL; +PFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate_ = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate_ = NULL; +PFNGLSTENCILMASKSEPARATEPROC glStencilMaskSeparate_ = NULL; + +PFNGLGENBUFFERSPROC glGenBuffers_ = NULL; +PFNGLBINDBUFFERPROC glBindBuffer_ = NULL; +PFNGLMAPBUFFERPROC glMapBuffer_ = NULL; +PFNGLUNMAPBUFFERPROC glUnmapBuffer_ = NULL; +PFNGLBUFFERDATAPROC glBufferData_ = NULL; +PFNGLBUFFERSUBDATAPROC glBufferSubData_ = NULL; +PFNGLDELETEBUFFERSPROC glDeleteBuffers_ = NULL; +PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData_ = NULL; + +PFNGLGENQUERIESPROC glGenQueries_ = NULL; +PFNGLDELETEQUERIESPROC glDeleteQueries_ = NULL; +PFNGLBEGINQUERYPROC glBeginQuery_ = NULL; +PFNGLENDQUERYPROC glEndQuery_ = NULL; +PFNGLGETQUERYIVPROC glGetQueryiv_ = NULL; +PFNGLGETQUERYOBJECTIVPROC glGetQueryObjectiv_ = NULL; +PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv_ = NULL; + +PFNGLCREATEPROGRAMPROC glCreateProgram_ = NULL; +PFNGLDELETEPROGRAMPROC glDeleteProgram_ = NULL; +PFNGLUSEPROGRAMPROC glUseProgram_ = NULL; +PFNGLCREATESHADERPROC glCreateShader_ = NULL; +PFNGLDELETESHADERPROC glDeleteShader_ = NULL; +PFNGLSHADERSOURCEPROC glShaderSource_ = NULL; +PFNGLCOMPILESHADERPROC glCompileShader_ = NULL; +PFNGLGETSHADERIVPROC glGetShaderiv_ = NULL; +PFNGLGETPROGRAMIVPROC glGetProgramiv_ = NULL; +PFNGLATTACHSHADERPROC glAttachShader_ = NULL; +PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog_ = NULL; +PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog_ = NULL; +PFNGLLINKPROGRAMPROC glLinkProgram_ = NULL; +PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation_ = NULL; +PFNGLUNIFORM1FPROC glUniform1f_ = NULL; +PFNGLUNIFORM2FPROC glUniform2f_ = NULL; +PFNGLUNIFORM3FPROC glUniform3f_ = NULL; +PFNGLUNIFORM4FPROC glUniform4f_ = NULL; +PFNGLUNIFORM1FVPROC glUniform1fv_ = NULL; +PFNGLUNIFORM2FVPROC glUniform2fv_ = NULL; +PFNGLUNIFORM3FVPROC glUniform3fv_ = NULL; +PFNGLUNIFORM4FVPROC glUniform4fv_ = NULL; +PFNGLUNIFORM1IPROC glUniform1i_ = NULL; +PFNGLUNIFORM2IPROC glUniform2i_ = NULL; +PFNGLUNIFORM3IPROC glUniform3i_ = NULL; +PFNGLUNIFORM4IPROC glUniform4i_ = NULL; +PFNGLUNIFORM1IVPROC glUniform1iv_ = NULL; +PFNGLUNIFORM2IVPROC glUniform2iv_ = NULL; +PFNGLUNIFORM3IVPROC glUniform3iv_ = NULL; +PFNGLUNIFORM4IVPROC glUniform4iv_ = NULL; +PFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv_ = NULL; +PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv_ = NULL; +PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv_ = NULL; +PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation_ = NULL; +PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform_ = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray_ = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray_ = NULL; + +PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f_ = NULL; +PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv_ = NULL; +PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s_ = NULL; +PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv_ = NULL; +PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f_ = NULL; +PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv_ = NULL; +PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s_ = NULL; +PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv_ = NULL; +PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f_ = NULL; +PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv_ = NULL; +PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s_ = NULL; +PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv_ = NULL; +PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f_ = NULL; +PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv_ = NULL; +PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s_ = NULL; +PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv_ = NULL; +PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv_ = NULL; +PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv_ = NULL; +PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv_ = NULL; +PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv_ = NULL; +PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv_ = NULL; +PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv_ = NULL; +PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv_ = NULL; +PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub_ = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv_ = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv_ = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv_ = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer_ = NULL; + +PFNGLDRAWBUFFERSPROC glDrawBuffers_ = NULL; +#endif + +// OpenGL 3.0 +PFNGLGETSTRINGIPROC glGetStringi_ = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation_ = NULL; + +// GL_EXT_framebuffer_object +PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer_ = NULL; +PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers_ = NULL; +PFNGLGENFRAMEBUFFERSPROC glGenRenderbuffers_ = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage_ = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus_ = NULL; +PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer_ = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers_ = NULL; +PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers_ = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D_ = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer_ = NULL; +PFNGLGENERATEMIPMAPPROC glGenerateMipmap_ = NULL; + +// GL_EXT_framebuffer_blit +PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer_ = NULL; + +// GL_ARB_uniform_buffer_object +PFNGLGETUNIFORMINDICESPROC glGetUniformIndices_ = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv_ = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex_ = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv_ = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding_ = NULL; +PFNGLBINDBUFFERBASEPROC glBindBufferBase_ = NULL; +PFNGLBINDBUFFERRANGEPROC glBindBufferRange_ = NULL; + +// GL_ARB_map_buffer_range +PFNGLMAPBUFFERRANGEPROC glMapBufferRange_ = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glFlushMappedBufferRange_ = NULL; + +// GL_ARB_vertex_array_object +PFNGLBINDVERTEXARRAYPROC glBindVertexArray_ = NULL; +PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays_ = NULL; +PFNGLGENVERTEXARRAYSPROC glGenVertexArrays_ = NULL; +PFNGLISVERTEXARRAYPROC glIsVertexArray_ = NULL; + +void *getprocaddress(const char *name) +{ + return SDL_GL_GetProcAddress(name); +} + +VARP(ati_skybox_bug, 0, 0, 1); +VAR(ati_minmax_bug, 0, 0, 1); +VAR(ati_cubemap_bug, 0, 0, 1); +VAR(intel_vertexarray_bug, 0, 0, 1); +VAR(intel_mapbufferrange_bug, 0, 0, 1); +VAR(mesa_swap_bug, 0, 0, 1); +VAR(minimizetcusage, 1, 0, 0); +VAR(useubo, 1, 0, 0); +VAR(usetexcompress, 1, 0, 0); +VAR(rtscissor, 0, 1, 1); +VAR(blurtile, 0, 1, 1); +VAR(rtsharefb, 0, 1, 1); + +VAR(dbgexts, 0, 0, 1); + +hashset<const char *> glexts; + +void parseglexts() +{ + if(glversion >= 300) + { + GLint numexts = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &numexts); + loopi(numexts) + { + const char *ext = (const char *)glGetStringi_(GL_EXTENSIONS, i); + glexts.add(newstring(ext)); + } + } + else + { + const char *exts = (const char *)glGetString(GL_EXTENSIONS); + for(;;) + { + while(*exts == ' ') exts++; + if(!*exts) break; + const char *ext = exts; + while(*exts && *exts != ' ') exts++; + if(exts > ext) glexts.add(newstring(ext, size_t(exts-ext))); + } + } +} + +bool hasext(const char *ext) +{ + return glexts.access(ext)!=NULL; +} + +void gl_checkextensions() +{ + const char *vendor = (const char *)glGetString(GL_VENDOR); + const char *renderer = (const char *)glGetString(GL_RENDERER); + const char *version = (const char *)glGetString(GL_VERSION); + conoutf(CON_INIT, "Renderer: %s (%s)", renderer, vendor); + conoutf(CON_INIT, "Driver: %s", version); + + bool mesa = false, intel = false, ati = false, nvidia = false; + if(strstr(renderer, "Mesa") || strstr(version, "Mesa")) + { + mesa = true; + if(strstr(renderer, "Intel")) intel = true; + } + else if(strstr(vendor, "NVIDIA")) + nvidia = true; + else if(strstr(vendor, "ATI") || strstr(vendor, "Advanced Micro Devices")) + ati = true; + else if(strstr(vendor, "Intel")) + intel = true; + + uint glmajorversion, glminorversion; + if(sscanf(version, " %u.%u", &glmajorversion, &glminorversion) != 2) glversion = 100; + else glversion = glmajorversion*100 + glminorversion*10; + + if(glversion < 200) fatal("OpenGL 2.0 or greater is required!"); + +#ifdef WIN32 + glActiveTexture_ = (PFNGLACTIVETEXTUREPROC) getprocaddress("glActiveTexture"); + + glBlendEquation_ = (PFNGLBLENDEQUATIONPROC) getprocaddress("glBlendEquation"); + glBlendColor_ = (PFNGLBLENDCOLORPROC) getprocaddress("glBlendColor"); + + glTexImage3D_ = (PFNGLTEXIMAGE3DPROC) getprocaddress("glTexImage3D"); + glTexSubImage3D_ = (PFNGLTEXSUBIMAGE3DPROC) getprocaddress("glTexSubImage3D"); + glCopyTexSubImage3D_ = (PFNGLCOPYTEXSUBIMAGE3DPROC) getprocaddress("glCopyTexSubImage3D"); + + glCompressedTexImage3D_ = (PFNGLCOMPRESSEDTEXIMAGE3DPROC) getprocaddress("glCompressedTexImage3D"); + glCompressedTexImage2D_ = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) getprocaddress("glCompressedTexImage2D"); + glCompressedTexSubImage3D_ = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) getprocaddress("glCompressedTexSubImage3D"); + glCompressedTexSubImage2D_ = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) getprocaddress("glCompressedTexSubImage2D"); + glGetCompressedTexImage_ = (PFNGLGETCOMPRESSEDTEXIMAGEPROC) getprocaddress("glGetCompressedTexImage"); + + glDrawRangeElements_ = (PFNGLDRAWRANGEELEMENTSPROC) getprocaddress("glDrawRangeElements"); +#endif + +#ifndef __APPLE__ + glMultiDrawArrays_ = (PFNGLMULTIDRAWARRAYSPROC) getprocaddress("glMultiDrawArrays"); + glMultiDrawElements_ = (PFNGLMULTIDRAWELEMENTSPROC) getprocaddress("glMultiDrawElements"); + + glBlendFuncSeparate_ = (PFNGLBLENDFUNCSEPARATEPROC) getprocaddress("glBlendFuncSeparate"); + glBlendEquationSeparate_ = (PFNGLBLENDEQUATIONSEPARATEPROC) getprocaddress("glBlendEquationSeparate"); + glStencilOpSeparate_ = (PFNGLSTENCILOPSEPARATEPROC) getprocaddress("glStencilOpSeparate"); + glStencilFuncSeparate_ = (PFNGLSTENCILFUNCSEPARATEPROC) getprocaddress("glStencilFuncSeparate"); + glStencilMaskSeparate_ = (PFNGLSTENCILMASKSEPARATEPROC) getprocaddress("glStencilMaskSeparate"); + + glGenBuffers_ = (PFNGLGENBUFFERSPROC) getprocaddress("glGenBuffers"); + glBindBuffer_ = (PFNGLBINDBUFFERPROC) getprocaddress("glBindBuffer"); + glMapBuffer_ = (PFNGLMAPBUFFERPROC) getprocaddress("glMapBuffer"); + glUnmapBuffer_ = (PFNGLUNMAPBUFFERPROC) getprocaddress("glUnmapBuffer"); + glBufferData_ = (PFNGLBUFFERDATAPROC) getprocaddress("glBufferData"); + glBufferSubData_ = (PFNGLBUFFERSUBDATAPROC) getprocaddress("glBufferSubData"); + glDeleteBuffers_ = (PFNGLDELETEBUFFERSPROC) getprocaddress("glDeleteBuffers"); + glGetBufferSubData_ = (PFNGLGETBUFFERSUBDATAPROC) getprocaddress("glGetBufferSubData"); + + glGetQueryiv_ = (PFNGLGETQUERYIVPROC) getprocaddress("glGetQueryiv"); + glGenQueries_ = (PFNGLGENQUERIESPROC) getprocaddress("glGenQueries"); + glDeleteQueries_ = (PFNGLDELETEQUERIESPROC) getprocaddress("glDeleteQueries"); + glBeginQuery_ = (PFNGLBEGINQUERYPROC) getprocaddress("glBeginQuery"); + glEndQuery_ = (PFNGLENDQUERYPROC) getprocaddress("glEndQuery"); + glGetQueryObjectiv_ = (PFNGLGETQUERYOBJECTIVPROC) getprocaddress("glGetQueryObjectiv"); + glGetQueryObjectuiv_ = (PFNGLGETQUERYOBJECTUIVPROC) getprocaddress("glGetQueryObjectuiv"); + + glCreateProgram_ = (PFNGLCREATEPROGRAMPROC) getprocaddress("glCreateProgram"); + glDeleteProgram_ = (PFNGLDELETEPROGRAMPROC) getprocaddress("glDeleteProgram"); + glUseProgram_ = (PFNGLUSEPROGRAMPROC) getprocaddress("glUseProgram"); + glCreateShader_ = (PFNGLCREATESHADERPROC) getprocaddress("glCreateShader"); + glDeleteShader_ = (PFNGLDELETESHADERPROC) getprocaddress("glDeleteShader"); + glShaderSource_ = (PFNGLSHADERSOURCEPROC) getprocaddress("glShaderSource"); + glCompileShader_ = (PFNGLCOMPILESHADERPROC) getprocaddress("glCompileShader"); + glGetShaderiv_ = (PFNGLGETSHADERIVPROC) getprocaddress("glGetShaderiv"); + glGetProgramiv_ = (PFNGLGETPROGRAMIVPROC) getprocaddress("glGetProgramiv"); + glAttachShader_ = (PFNGLATTACHSHADERPROC) getprocaddress("glAttachShader"); + glGetProgramInfoLog_ = (PFNGLGETPROGRAMINFOLOGPROC) getprocaddress("glGetProgramInfoLog"); + glGetShaderInfoLog_ = (PFNGLGETSHADERINFOLOGPROC) getprocaddress("glGetShaderInfoLog"); + glLinkProgram_ = (PFNGLLINKPROGRAMPROC) getprocaddress("glLinkProgram"); + glGetUniformLocation_ = (PFNGLGETUNIFORMLOCATIONPROC) getprocaddress("glGetUniformLocation"); + glUniform1f_ = (PFNGLUNIFORM1FPROC) getprocaddress("glUniform1f"); + glUniform2f_ = (PFNGLUNIFORM2FPROC) getprocaddress("glUniform2f"); + glUniform3f_ = (PFNGLUNIFORM3FPROC) getprocaddress("glUniform3f"); + glUniform4f_ = (PFNGLUNIFORM4FPROC) getprocaddress("glUniform4f"); + glUniform1fv_ = (PFNGLUNIFORM1FVPROC) getprocaddress("glUniform1fv"); + glUniform2fv_ = (PFNGLUNIFORM2FVPROC) getprocaddress("glUniform2fv"); + glUniform3fv_ = (PFNGLUNIFORM3FVPROC) getprocaddress("glUniform3fv"); + glUniform4fv_ = (PFNGLUNIFORM4FVPROC) getprocaddress("glUniform4fv"); + glUniform1i_ = (PFNGLUNIFORM1IPROC) getprocaddress("glUniform1i"); + glUniform2i_ = (PFNGLUNIFORM2IPROC) getprocaddress("glUniform2i"); + glUniform3i_ = (PFNGLUNIFORM3IPROC) getprocaddress("glUniform3i"); + glUniform4i_ = (PFNGLUNIFORM4IPROC) getprocaddress("glUniform4i"); + glUniform1iv_ = (PFNGLUNIFORM1IVPROC) getprocaddress("glUniform1iv"); + glUniform2iv_ = (PFNGLUNIFORM2IVPROC) getprocaddress("glUniform2iv"); + glUniform3iv_ = (PFNGLUNIFORM3IVPROC) getprocaddress("glUniform3iv"); + glUniform4iv_ = (PFNGLUNIFORM4IVPROC) getprocaddress("glUniform4iv"); + glUniformMatrix2fv_ = (PFNGLUNIFORMMATRIX2FVPROC) getprocaddress("glUniformMatrix2fv"); + glUniformMatrix3fv_ = (PFNGLUNIFORMMATRIX3FVPROC) getprocaddress("glUniformMatrix3fv"); + glUniformMatrix4fv_ = (PFNGLUNIFORMMATRIX4FVPROC) getprocaddress("glUniformMatrix4fv"); + glBindAttribLocation_ = (PFNGLBINDATTRIBLOCATIONPROC) getprocaddress("glBindAttribLocation"); + glGetActiveUniform_ = (PFNGLGETACTIVEUNIFORMPROC) getprocaddress("glGetActiveUniform"); + glEnableVertexAttribArray_ = (PFNGLENABLEVERTEXATTRIBARRAYPROC) getprocaddress("glEnableVertexAttribArray"); + glDisableVertexAttribArray_ = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) getprocaddress("glDisableVertexAttribArray"); + + glVertexAttrib1f_ = (PFNGLVERTEXATTRIB1FPROC) getprocaddress("glVertexAttrib1f"); + glVertexAttrib1fv_ = (PFNGLVERTEXATTRIB1FVPROC) getprocaddress("glVertexAttrib1fv"); + glVertexAttrib1s_ = (PFNGLVERTEXATTRIB1SPROC) getprocaddress("glVertexAttrib1s"); + glVertexAttrib1sv_ = (PFNGLVERTEXATTRIB1SVPROC) getprocaddress("glVertexAttrib1sv"); + glVertexAttrib2f_ = (PFNGLVERTEXATTRIB2FPROC) getprocaddress("glVertexAttrib2f"); + glVertexAttrib2fv_ = (PFNGLVERTEXATTRIB2FVPROC) getprocaddress("glVertexAttrib2fv"); + glVertexAttrib2s_ = (PFNGLVERTEXATTRIB2SPROC) getprocaddress("glVertexAttrib2s"); + glVertexAttrib2sv_ = (PFNGLVERTEXATTRIB2SVPROC) getprocaddress("glVertexAttrib2sv"); + glVertexAttrib3f_ = (PFNGLVERTEXATTRIB3FPROC) getprocaddress("glVertexAttrib3f"); + glVertexAttrib3fv_ = (PFNGLVERTEXATTRIB3FVPROC) getprocaddress("glVertexAttrib3fv"); + glVertexAttrib3s_ = (PFNGLVERTEXATTRIB3SPROC) getprocaddress("glVertexAttrib3s"); + glVertexAttrib3sv_ = (PFNGLVERTEXATTRIB3SVPROC) getprocaddress("glVertexAttrib3sv"); + glVertexAttrib4f_ = (PFNGLVERTEXATTRIB4FPROC) getprocaddress("glVertexAttrib4f"); + glVertexAttrib4fv_ = (PFNGLVERTEXATTRIB4FVPROC) getprocaddress("glVertexAttrib4fv"); + glVertexAttrib4s_ = (PFNGLVERTEXATTRIB4SPROC) getprocaddress("glVertexAttrib4s"); + glVertexAttrib4sv_ = (PFNGLVERTEXATTRIB4SVPROC) getprocaddress("glVertexAttrib4sv"); + glVertexAttrib4bv_ = (PFNGLVERTEXATTRIB4BVPROC) getprocaddress("glVertexAttrib4bv"); + glVertexAttrib4iv_ = (PFNGLVERTEXATTRIB4IVPROC) getprocaddress("glVertexAttrib4iv"); + glVertexAttrib4ubv_ = (PFNGLVERTEXATTRIB4UBVPROC) getprocaddress("glVertexAttrib4ubv"); + glVertexAttrib4uiv_ = (PFNGLVERTEXATTRIB4UIVPROC) getprocaddress("glVertexAttrib4uiv"); + glVertexAttrib4usv_ = (PFNGLVERTEXATTRIB4USVPROC) getprocaddress("glVertexAttrib4usv"); + glVertexAttrib4Nbv_ = (PFNGLVERTEXATTRIB4NBVPROC) getprocaddress("glVertexAttrib4Nbv"); + glVertexAttrib4Niv_ = (PFNGLVERTEXATTRIB4NIVPROC) getprocaddress("glVertexAttrib4Niv"); + glVertexAttrib4Nub_ = (PFNGLVERTEXATTRIB4NUBPROC) getprocaddress("glVertexAttrib4Nub"); + glVertexAttrib4Nubv_ = (PFNGLVERTEXATTRIB4NUBVPROC) getprocaddress("glVertexAttrib4Nubv"); + glVertexAttrib4Nuiv_ = (PFNGLVERTEXATTRIB4NUIVPROC) getprocaddress("glVertexAttrib4Nuiv"); + glVertexAttrib4Nusv_ = (PFNGLVERTEXATTRIB4NUSVPROC) getprocaddress("glVertexAttrib4Nusv"); + glVertexAttribPointer_ = (PFNGLVERTEXATTRIBPOINTERPROC) getprocaddress("glVertexAttribPointer"); + + glDrawBuffers_ = (PFNGLDRAWBUFFERSPROC) getprocaddress("glDrawBuffers"); +#endif + + if(glversion >= 300) + { + glGetStringi_ = (PFNGLGETSTRINGIPROC) getprocaddress("glGetStringi"); + glBindFragDataLocation_ = (PFNGLBINDFRAGDATALOCATIONPROC)getprocaddress("glBindFragDataLocation"); + } + + const char *glslstr = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION); + uint glslmajorversion, glslminorversion; + if(glslstr && sscanf(glslstr, " %u.%u", &glslmajorversion, &glslminorversion) == 2) glslversion = glslmajorversion*100 + glslminorversion; + + if(glslversion < 120) fatal("GLSL 1.20 or greater is required!"); + + parseglexts(); + + GLint val; + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &val); + hwtexsize = val; + glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &val); + hwcubetexsize = val; + + if(glversion >= 300 || hasext("GL_ARB_texture_float") || hasext("GL_ATI_texture_float")) + { + hasTF = true; + if(glversion < 300 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_texture_float extension."); + shadowmap = 1; + extern int smoothshadowmappeel; + smoothshadowmappeel = 1; + } + + if(glversion >= 300 || hasext("GL_ARB_texture_rg")) + { + hasTRG = true; + if(glversion < 300 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_texture_rg extension."); + } + + if(glversion >= 300 || hasext("GL_ARB_framebuffer_object")) + { + glBindRenderbuffer_ = (PFNGLBINDRENDERBUFFERPROC) getprocaddress("glBindRenderbuffer"); + glDeleteRenderbuffers_ = (PFNGLDELETERENDERBUFFERSPROC) getprocaddress("glDeleteRenderbuffers"); + glGenRenderbuffers_ = (PFNGLGENFRAMEBUFFERSPROC) getprocaddress("glGenRenderbuffers"); + glRenderbufferStorage_ = (PFNGLRENDERBUFFERSTORAGEPROC) getprocaddress("glRenderbufferStorage"); + glCheckFramebufferStatus_ = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) getprocaddress("glCheckFramebufferStatus"); + glBindFramebuffer_ = (PFNGLBINDFRAMEBUFFERPROC) getprocaddress("glBindFramebuffer"); + glDeleteFramebuffers_ = (PFNGLDELETEFRAMEBUFFERSPROC) getprocaddress("glDeleteFramebuffers"); + glGenFramebuffers_ = (PFNGLGENFRAMEBUFFERSPROC) getprocaddress("glGenFramebuffers"); + glFramebufferTexture2D_ = (PFNGLFRAMEBUFFERTEXTURE2DPROC) getprocaddress("glFramebufferTexture2D"); + glFramebufferRenderbuffer_ = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)getprocaddress("glFramebufferRenderbuffer"); + glGenerateMipmap_ = (PFNGLGENERATEMIPMAPPROC) getprocaddress("glGenerateMipmap"); + glBlitFramebuffer_ = (PFNGLBLITFRAMEBUFFERPROC) getprocaddress("glBlitFramebuffer"); + hasAFBO = hasFBO = hasFBB = hasDS = true; + if(glversion < 300 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_framebuffer_object extension."); + } + else if(hasext("GL_EXT_framebuffer_object")) + { + glBindRenderbuffer_ = (PFNGLBINDRENDERBUFFERPROC) getprocaddress("glBindRenderbufferEXT"); + glDeleteRenderbuffers_ = (PFNGLDELETERENDERBUFFERSPROC) getprocaddress("glDeleteRenderbuffersEXT"); + glGenRenderbuffers_ = (PFNGLGENFRAMEBUFFERSPROC) getprocaddress("glGenRenderbuffersEXT"); + glRenderbufferStorage_ = (PFNGLRENDERBUFFERSTORAGEPROC) getprocaddress("glRenderbufferStorageEXT"); + glCheckFramebufferStatus_ = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) getprocaddress("glCheckFramebufferStatusEXT"); + glBindFramebuffer_ = (PFNGLBINDFRAMEBUFFERPROC) getprocaddress("glBindFramebufferEXT"); + glDeleteFramebuffers_ = (PFNGLDELETEFRAMEBUFFERSPROC) getprocaddress("glDeleteFramebuffersEXT"); + glGenFramebuffers_ = (PFNGLGENFRAMEBUFFERSPROC) getprocaddress("glGenFramebuffersEXT"); + glFramebufferTexture2D_ = (PFNGLFRAMEBUFFERTEXTURE2DPROC) getprocaddress("glFramebufferTexture2DEXT"); + glFramebufferRenderbuffer_ = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)getprocaddress("glFramebufferRenderbufferEXT"); + glGenerateMipmap_ = (PFNGLGENERATEMIPMAPPROC) getprocaddress("glGenerateMipmapEXT"); + hasFBO = true; + if(dbgexts) conoutf(CON_INIT, "Using GL_EXT_framebuffer_object extension."); + + if(hasext("GL_EXT_framebuffer_blit")) + { + glBlitFramebuffer_ = (PFNGLBLITFRAMEBUFFERPROC) getprocaddress("glBlitFramebufferEXT"); + hasFBB = true; + if(dbgexts) conoutf(CON_INIT, "Using GL_EXT_framebuffer_blit extension."); + } + + if(hasext("GL_EXT_packed_depth_stencil") || hasext("GL_NV_packed_depth_stencil")) + { + hasDS = true; + if(dbgexts) conoutf(CON_INIT, "Using GL_EXT_packed_depth_stencil extension."); + } + } + else fatal("Framebuffer object support is required!"); + + extern int fpdepthfx; + if(ati) + { + //conoutf(CON_WARN, "WARNING: ATI cards may show garbage in skybox. (use \"/ati_skybox_bug 1\" to fix)"); + + minimizetcusage = 1; + if(hasTF && hasTRG) fpdepthfx = 1; + // On Catalyst 10.2, issuing an occlusion query on the first draw using a given cubemap texture causes a nasty crash + ati_cubemap_bug = 1; + } + else if(nvidia) + { + reservevpparams = 10; + rtsharefb = 0; // work-around for strange driver stalls involving when using many FBOs + extern int filltjoints; + if(glversion < 300 && !hasext("GL_EXT_gpu_shader4")) filltjoints = 0; // DX9 or less NV cards seem to not cause many sparklies + + if(hasTF && hasTRG) fpdepthfx = 1; + } + else + { + if(intel) + { +#ifdef WIN32 + intel_vertexarray_bug = 1; + // MapBufferRange is buggy on older Intel drivers on Windows + if(glversion <= 310) intel_mapbufferrange_bug = 1; +#endif + } + + reservevpparams = 20; + + if(mesa) mesa_swap_bug = 1; + } + + if(glversion >= 300 || hasext("GL_ARB_map_buffer_range")) + { + glMapBufferRange_ = (PFNGLMAPBUFFERRANGEPROC) getprocaddress("glMapBufferRange"); + glFlushMappedBufferRange_ = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)getprocaddress("glFlushMappedBufferRange"); + hasMBR = true; + if(glversion < 300 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_map_buffer_range."); + } + + if(glversion >= 310 || hasext("GL_ARB_uniform_buffer_object")) + { + glGetUniformIndices_ = (PFNGLGETUNIFORMINDICESPROC) getprocaddress("glGetUniformIndices"); + glGetActiveUniformsiv_ = (PFNGLGETACTIVEUNIFORMSIVPROC) getprocaddress("glGetActiveUniformsiv"); + glGetUniformBlockIndex_ = (PFNGLGETUNIFORMBLOCKINDEXPROC) getprocaddress("glGetUniformBlockIndex"); + glGetActiveUniformBlockiv_ = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)getprocaddress("glGetActiveUniformBlockiv"); + glUniformBlockBinding_ = (PFNGLUNIFORMBLOCKBINDINGPROC) getprocaddress("glUniformBlockBinding"); + glBindBufferBase_ = (PFNGLBINDBUFFERBASEPROC) getprocaddress("glBindBufferBase"); + glBindBufferRange_ = (PFNGLBINDBUFFERRANGEPROC) getprocaddress("glBindBufferRange"); + + useubo = 1; + hasUBO = true; + if(glversion < 310 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_uniform_buffer_object extension."); + } + + if(glversion >= 300 || hasext("GL_ARB_vertex_array_object")) + { + glBindVertexArray_ = (PFNGLBINDVERTEXARRAYPROC) getprocaddress("glBindVertexArray"); + glDeleteVertexArrays_ = (PFNGLDELETEVERTEXARRAYSPROC)getprocaddress("glDeleteVertexArrays"); + glGenVertexArrays_ = (PFNGLGENVERTEXARRAYSPROC) getprocaddress("glGenVertexArrays"); + glIsVertexArray_ = (PFNGLISVERTEXARRAYPROC) getprocaddress("glIsVertexArray"); + hasVAO = true; + if(glversion < 300 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_vertex_array_object extension."); + } + else if(hasext("GL_APPLE_vertex_array_object")) + { + glBindVertexArray_ = (PFNGLBINDVERTEXARRAYPROC) getprocaddress("glBindVertexArrayAPPLE"); + glDeleteVertexArrays_ = (PFNGLDELETEVERTEXARRAYSPROC)getprocaddress("glDeleteVertexArraysAPPLE"); + glGenVertexArrays_ = (PFNGLGENVERTEXARRAYSPROC) getprocaddress("glGenVertexArraysAPPLE"); + glIsVertexArray_ = (PFNGLISVERTEXARRAYPROC) getprocaddress("glIsVertexArrayAPPLE"); + hasVAO = true; + if(dbgexts) conoutf(CON_INIT, "Using GL_APPLE_vertex_array_object extension."); + } + + if(glversion >= 330 || hasext("GL_ARB_texture_swizzle") || hasext("GL_EXT_texture_swizzle")) + { + hasTSW = true; + if(glversion < 330 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_texture_swizzle extension."); + } + + if(hasext("GL_EXT_texture_compression_s3tc")) + { + hasS3TC = true; +#ifdef __APPLE__ + usetexcompress = 1; +#else + if(!mesa) usetexcompress = 2; +#endif + if(dbgexts) conoutf(CON_INIT, "Using GL_EXT_texture_compression_s3tc extension."); + } + else if(hasext("GL_EXT_texture_compression_dxt1") && hasext("GL_ANGLE_texture_compression_dxt3") && hasext("GL_ANGLE_texture_compression_dxt5")) + { + hasS3TC = true; + if(dbgexts) conoutf(CON_INIT, "Using GL_EXT_texture_compression_dxt1 extension."); + } + if(hasext("GL_3DFX_texture_compression_FXT1")) + { + hasFXT1 = true; + if(mesa) usetexcompress = max(usetexcompress, 1); + if(dbgexts) conoutf(CON_INIT, "Using GL_3DFX_texture_compression_FXT1."); + } + if(hasext("GL_EXT_texture_compression_latc")) + { + hasLATC = true; + if(dbgexts) conoutf(CON_INIT, "Using GL_EXT_texture_compression_latc extension."); + } + if(glversion >= 300 || hasext("GL_ARB_texture_compression_rgtc") || hasext("GL_EXT_texture_compression_rgtc")) + { + hasRGTC = true; + if(glversion < 300 && dbgexts) conoutf(CON_INIT, "Using GL_ARB_texture_compression_rgtc extension."); + } + + if(hasext("GL_EXT_texture_filter_anisotropic")) + { + GLint val; + glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &val); + hwmaxaniso = val; + hasAF = true; + if(dbgexts) conoutf(CON_INIT, "Using GL_EXT_texture_filter_anisotropic extension."); + } + + if(glversion >= 300 || hasext("GL_EXT_gpu_shader4")) + { + // on DX10 or above class cards (i.e. GF8 or RadeonHD) enable expensive features + extern int grass, glare, maxdynlights, depthfxsize, blurdepthfx, texcompress; + grass = 1; + waterfallrefract = 1; + glare = 1; + maxdynlights = MAXDYNLIGHTS; + depthfxsize = 10; + blurdepthfx = 0; + texcompress = max(texcompress, 1024 + 1); + } +} + +void glext(char *ext) +{ + intret(hasext(ext) ? 1 : 0); +} +COMMAND(glext, "s"); + +void gl_resize() +{ + glViewport(0, 0, screenw, screenh); +} + +void gl_init() +{ + glClearColor(0, 0, 0, 0); + glClearDepth(1); + glDepthFunc(GL_LESS); + glDisable(GL_DEPTH_TEST); + + glEnable(GL_LINE_SMOOTH); + //glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); + + glFrontFace(GL_CW); + glCullFace(GL_BACK); + glDisable(GL_CULL_FACE); + + gle::setup(); + + setupshaders(); + + setuptexcompress(); + + gl_resize(); +} + +VAR(wireframe, 0, 0, 1); + +ICOMMAND(getcamyaw, "", (), floatret(camera1->yaw)); +ICOMMAND(getcampitch, "", (), floatret(camera1->pitch)); +ICOMMAND(getcamroll, "", (), floatret(camera1->roll)); +ICOMMAND(getcampos, "", (), +{ + defformatstring(pos, "%s %s %s", floatstr(camera1->o.x), floatstr(camera1->o.y), floatstr(camera1->o.z)); + result(pos); +}); + +vec worldpos, camdir, camright, camup; + +void setcammatrix() +{ + // move from RH to Z-up LH quake style worldspace + cammatrix = viewmatrix; + cammatrix.rotate_around_y(camera1->roll*RAD); + cammatrix.rotate_around_x(camera1->pitch*-RAD); + cammatrix.rotate_around_z(camera1->yaw*-RAD); + cammatrix.translate(vec(camera1->o).neg()); + + cammatrix.transposedtransformnormal(vec(viewmatrix.b), camdir); + cammatrix.transposedtransformnormal(vec(viewmatrix.a).neg(), camright); + cammatrix.transposedtransformnormal(vec(viewmatrix.c), camup); + + if(!drawtex) + { + if(raycubepos(camera1->o, camdir, worldpos, 0, RAY_CLIPMAT|RAY_SKIPFIRST) == -1) + worldpos = vec(camdir).mul(2*worldsize).add(camera1->o); // if nothing is hit, just far away in the view direction + } +} + +void setcamprojmatrix(bool init = true, bool flush = false) +{ + if(init) + { + setcammatrix(); + } + + camprojmatrix.muld(projmatrix, cammatrix); + + if(init) + { + invcammatrix.invert(cammatrix); + invcamprojmatrix.invert(camprojmatrix); + } + + GLOBALPARAM(camprojmatrix, camprojmatrix); + + if(fogging) + { + vec fogplane(cammatrix.c); + fogplane.x /= projmatrix.a.x; + fogplane.y /= projmatrix.b.y; + fogplane.z /= projmatrix.c.w; + GLOBALPARAMF(fogplane, fogplane.x, fogplane.y, 0, fogplane.z); + } + else + { + vec2 lineardepthscale = projmatrix.lineardepthscale(); + GLOBALPARAMF(fogplane, 0, 0, lineardepthscale.x, lineardepthscale.y); + } + + if(flush && Shader::lastshader) Shader::lastshader->flushparams(); +} + +matrix4 hudmatrix, hudmatrixstack[64]; +int hudmatrixpos = 0; + +void resethudmatrix() +{ + hudmatrixpos = 0; + GLOBALPARAM(hudmatrix, hudmatrix); +} + +void pushhudmatrix() +{ + if(hudmatrixpos >= 0 && hudmatrixpos < int(sizeof(hudmatrixstack)/sizeof(hudmatrixstack[0]))) hudmatrixstack[hudmatrixpos] = hudmatrix; + ++hudmatrixpos; +} + +void flushhudmatrix(bool flushparams) +{ + GLOBALPARAM(hudmatrix, hudmatrix); + if(flushparams && Shader::lastshader) Shader::lastshader->flushparams(); +} + +void pophudmatrix(bool flush, bool flushparams) +{ + --hudmatrixpos; + if(hudmatrixpos >= 0 && hudmatrixpos < int(sizeof(hudmatrixstack)/sizeof(hudmatrixstack[0]))) + { + hudmatrix = hudmatrixstack[hudmatrixpos]; + if(flush) flushhudmatrix(flushparams); + } +} + +void pushhudscale(float sx, float sy) +{ + if(!sy) sy = sx; + pushhudmatrix(); + hudmatrix.scale(sx, sy, 1); + flushhudmatrix(); +} + +void pushhudtranslate(float tx, float ty, float sx, float sy) +{ + if(!sy) sy = sx; + pushhudmatrix(); + hudmatrix.translate(tx, ty, 0); + if(sy) hudmatrix.scale(sx, sy, 1); + flushhudmatrix(); +} + +float curfov = 100, curavatarfov = 65, fovy, aspect; +int farplane; +VARP(zoominvel, 0, 250, 5000); +VARP(zoomoutvel, 0, 100, 5000); +VARP(zoomfov, 10, 35, 60); +VARP(fov, 10, 100, 150); +VAR(avatarzoomfov, 10, 25, 60); +VAR(avatarfov, 10, 65, 150); +FVAR(avatardepth, 0, 0.5f, 1); +FVARNP(aspect, forceaspect, 0, 0, 1e3f); + +static float zoomprogress = 0; +VAR(zoom, -1, 0, 1); + +void disablezoom() +{ + zoom = 0; + zoomprogress = 0; +} + +void computezoom() +{ + if(!zoom) { zoomprogress = 0; curfov = fov; curavatarfov = avatarfov; return; } + if(zoom > 0) zoomprogress = zoominvel ? min(zoomprogress + float(elapsedtime) / zoominvel, 1.0f) : 1; + else + { + zoomprogress = zoomoutvel ? max(zoomprogress - float(elapsedtime) / zoomoutvel, 0.0f) : 0; + if(zoomprogress <= 0) zoom = 0; + } + curfov = zoomfov*zoomprogress + fov*(1 - zoomprogress); + curavatarfov = avatarzoomfov*zoomprogress + avatarfov*(1 - zoomprogress); +} + +FVARP(zoomsens, 1e-3f, 1, 1000); +FVARP(zoomaccel, 0, 0, 1000); +VARP(zoomautosens, 0, 1, 1); +FVARP(sensitivity, 1e-3f, 3, 1000); +FVARP(sensitivityscale, 1e-3f, 1, 1000); +VARP(invmouse, 0, 0, 1); +FVARP(mouseaccel, 0, 0, 1000); + +VAR(thirdperson, 0, 0, 2); +FVAR(thirdpersondistance, 0, 20, 50); +FVAR(thirdpersonup, -25, 0, 25); +FVAR(thirdpersonside, -25, 0, 25); +physent *camera1 = NULL; +bool detachedcamera = false; +bool isthirdperson() { return player!=camera1 || detachedcamera || reflecting; } + +void fixcamerarange() +{ + const float MAXPITCH = 90.0f; + if(camera1->pitch>MAXPITCH) camera1->pitch = MAXPITCH; + if(camera1->pitch<-MAXPITCH) camera1->pitch = -MAXPITCH; + while(camera1->yaw<0.0f) camera1->yaw += 360.0f; + while(camera1->yaw>=360.0f) camera1->yaw -= 360.0f; +} + +void mousemove(int dx, int dy) +{ + if(!game::allowmouselook()) return; + float cursens = sensitivity, curaccel = mouseaccel; + if(zoom) + { + if(zoomautosens) + { + cursens = float(sensitivity*zoomfov)/fov; + curaccel = float(mouseaccel*zoomfov)/fov; + } + else + { + cursens = zoomsens; + curaccel = zoomaccel; + } + } + if(curaccel && curtime && (dx || dy)) cursens += curaccel * sqrtf(dx*dx + dy*dy)/curtime; + cursens /= 33.0f*sensitivityscale; + camera1->yaw += dx*cursens; + camera1->pitch -= dy*cursens*(invmouse ? -1 : 1); + fixcamerarange(); + if(camera1!=player && !detachedcamera) + { + player->yaw = camera1->yaw; + player->pitch = camera1->pitch; + } +} + +void recomputecamera() +{ + game::setupcamera(); + computezoom(); + + bool allowthirdperson = game::allowthirdperson(); + bool shoulddetach = (allowthirdperson && thirdperson > 1) || game::detachcamera(); + if((!allowthirdperson || !thirdperson) && !shoulddetach) + { + camera1 = player; + detachedcamera = false; + } + else + { + static physent tempcamera; + camera1 = &tempcamera; + if(detachedcamera && shoulddetach) camera1->o = player->o; + else + { + *camera1 = *player; + detachedcamera = shoulddetach; + } + camera1->reset(); + camera1->type = ENT_CAMERA; + camera1->move = -1; + camera1->eyeheight = camera1->aboveeye = camera1->radius = camera1->xradius = camera1->yradius = 2; + + matrix3 orient; + orient.identity(); + orient.rotate_around_z(camera1->yaw*RAD); + orient.rotate_around_x(camera1->pitch*RAD); + orient.rotate_around_y(camera1->roll*-RAD); + vec dir = vec(orient.b).neg(), side = vec(orient.a).neg(), up = orient.c; + + if(game::collidecamera()) + { + movecamera(camera1, dir, thirdpersondistance, 1); + movecamera(camera1, dir, clamp(thirdpersondistance - camera1->o.dist(player->o), 0.0f, 1.0f), 0.1f); + if(thirdpersonup) + { + vec pos = camera1->o; + float dist = fabs(thirdpersonup); + if(thirdpersonup < 0) up.neg(); + movecamera(camera1, up, dist, 1); + movecamera(camera1, up, clamp(dist - camera1->o.dist(pos), 0.0f, 1.0f), 0.1f); + } + if(thirdpersonside) + { + vec pos = camera1->o; + float dist = fabs(thirdpersonside); + if(thirdpersonside < 0) side.neg(); + movecamera(camera1, side, dist, 1); + movecamera(camera1, side, clamp(dist - camera1->o.dist(pos), 0.0f, 1.0f), 0.1f); + } + } + else + { + camera1->o.add(vec(dir).mul(thirdpersondistance)); + if(thirdpersonup) camera1->o.add(vec(up).mul(thirdpersonup)); + if(thirdpersonside) camera1->o.add(vec(side).mul(thirdpersonside)); + } + } + + setviewcell(camera1->o); +} + +extern const matrix4 viewmatrix(vec(-1, 0, 0), vec(0, 0, 1), vec(0, -1, 0)); +matrix4 cammatrix, projmatrix, camprojmatrix, invcammatrix, invcamprojmatrix; + +FVAR(nearplane, 0.01f, 0.54f, 2.0f); + +vec calcavatarpos(const vec &pos, float dist) +{ + vec eyepos; + cammatrix.transform(pos, eyepos); + GLdouble ydist = nearplane * tan(curavatarfov/2*RAD), xdist = ydist * aspect; + vec4 scrpos; + scrpos.x = eyepos.x*nearplane/xdist; + scrpos.y = eyepos.y*nearplane/ydist; + scrpos.z = (eyepos.z*(farplane + nearplane) - 2*nearplane*farplane) / (farplane - nearplane); + scrpos.w = -eyepos.z; + + vec worldpos = invcamprojmatrix.perspectivetransform(scrpos); + vec dir = vec(worldpos).sub(camera1->o).rescale(dist); + return dir.add(camera1->o); +} + +VAR(reflectclip, 0, 6, 64); +VAR(reflectclipavatar, -64, 0, 64); + +matrix4 clipmatrix, noclipmatrix; + +void renderavatar() +{ + if(isthirdperson()) return; + + matrix4 oldprojmatrix = projmatrix; + projmatrix.perspective(curavatarfov, aspect, nearplane, farplane); + projmatrix.scalez(avatardepth); + setcamprojmatrix(false); + + game::renderavatar(); + + projmatrix = oldprojmatrix; + setcamprojmatrix(false); +} + +FVAR(polygonoffsetfactor, -1e4f, -3.0f, 1e4f); +FVAR(polygonoffsetunits, -1e4f, -3.0f, 1e4f); +FVAR(depthoffset, -1e4f, 0.01f, 1e4f); + +matrix4 nooffsetmatrix; + +void enablepolygonoffset(GLenum type) +{ + if(!depthoffset) + { + glPolygonOffset(polygonoffsetfactor, polygonoffsetunits); + glEnable(type); + return; + } + + bool clipped = reflectz < 1e15f && reflectclip; + + nooffsetmatrix = projmatrix; + projmatrix.d.z += depthoffset * (clipped ? noclipmatrix.c.z : projmatrix.c.z); + setcamprojmatrix(false, true); +} + +void disablepolygonoffset(GLenum type) +{ + if(!depthoffset) + { + glDisable(type); + return; + } + + projmatrix = nooffsetmatrix; + setcamprojmatrix(false, true); +} + +void calcspherescissor(const vec ¢er, float size, float &sx1, float &sy1, float &sx2, float &sy2) +{ + vec worldpos(center), e; + if(reflecting) worldpos.z = 2*reflectz - worldpos.z; + cammatrix.transform(worldpos, e); + if(e.z > 2*size) { sx1 = sy1 = 1; sx2 = sy2 = -1; return; } + float zzrr = e.z*e.z - size*size, + dx = e.x*e.x + zzrr, dy = e.y*e.y + zzrr, + focaldist = 1.0f/tan(fovy*0.5f*RAD); + sx1 = sy1 = -1; + sx2 = sy2 = 1; + #define CHECKPLANE(c, dir, focaldist, low, high) \ + do { \ + float nzc = (cz*cz + 1) / (cz dir drt) - cz, \ + pz = (d##c)/(nzc*e.c - e.z); \ + if(pz > 0) \ + { \ + float c = (focaldist)*nzc, \ + pc = pz*nzc; \ + if(pc < e.c) low = c; \ + else if(pc > e.c) high = c; \ + } \ + } while(0) + if(dx > 0) + { + float cz = e.x/e.z, drt = sqrtf(dx)/size; + CHECKPLANE(x, -, focaldist/aspect, sx1, sx2); + CHECKPLANE(x, +, focaldist/aspect, sx1, sx2); + } + if(dy > 0) + { + float cz = e.y/e.z, drt = sqrtf(dy)/size; + CHECKPLANE(y, -, focaldist, sy1, sy2); + CHECKPLANE(y, +, focaldist, sy1, sy2); + } +} + +static int scissoring = 0; +static GLint oldscissor[4]; + +int pushscissor(float sx1, float sy1, float sx2, float sy2) +{ + scissoring = 0; + + if(sx1 <= -1 && sy1 <= -1 && sx2 >= 1 && sy2 >= 1) return 0; + + sx1 = max(sx1, -1.0f); + sy1 = max(sy1, -1.0f); + sx2 = min(sx2, 1.0f); + sy2 = min(sy2, 1.0f); + + GLint viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + int sx = viewport[0] + int(floor((sx1+1)*0.5f*viewport[2])), + sy = viewport[1] + int(floor((sy1+1)*0.5f*viewport[3])), + sw = viewport[0] + int(ceil((sx2+1)*0.5f*viewport[2])) - sx, + sh = viewport[1] + int(ceil((sy2+1)*0.5f*viewport[3])) - sy; + if(sw <= 0 || sh <= 0) return 0; + + if(glIsEnabled(GL_SCISSOR_TEST)) + { + glGetIntegerv(GL_SCISSOR_BOX, oldscissor); + sw += sx; + sh += sy; + sx = max(sx, int(oldscissor[0])); + sy = max(sy, int(oldscissor[1])); + sw = min(sw, int(oldscissor[0] + oldscissor[2])) - sx; + sh = min(sh, int(oldscissor[1] + oldscissor[3])) - sy; + if(sw <= 0 || sh <= 0) return 0; + scissoring = 2; + } + else scissoring = 1; + + glScissor(sx, sy, sw, sh); + if(scissoring<=1) glEnable(GL_SCISSOR_TEST); + + return scissoring; +} + +void popscissor() +{ + if(scissoring>1) glScissor(oldscissor[0], oldscissor[1], oldscissor[2], oldscissor[3]); + else if(scissoring) glDisable(GL_SCISSOR_TEST); + scissoring = 0; +} + +static GLuint screenquadvbo = 0; + +static void setupscreenquad() +{ + if(!screenquadvbo) + { + glGenBuffers_(1, &screenquadvbo); + gle::bindvbo(screenquadvbo); + vec2 verts[4] = { vec2(1, -1), vec2(-1, -1), vec2(1, 1), vec2(-1, 1) }; + glBufferData_(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW); + gle::clearvbo(); + } +} + +static void cleanupscreenquad() +{ + if(screenquadvbo) { glDeleteBuffers_(1, &screenquadvbo); screenquadvbo = 0; } +} + +void screenquad() +{ + setupscreenquad(); + gle::bindvbo(screenquadvbo); + gle::enablevertex(); + gle::vertexpointer(sizeof(vec2), (const vec2 *)0, GL_FLOAT, 2); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + gle::disablevertex(); + gle::clearvbo(); +} + +static LocalShaderParam screentexcoord[2] = { LocalShaderParam("screentexcoord0"), LocalShaderParam("screentexcoord1") }; + +static inline void setscreentexcoord(int i, float w, float h, float x = 0, float y = 0) +{ + screentexcoord[i].setf(w*0.5f, h*0.5f, x + w*0.5f, y + fabs(h)*0.5f); +} + +void screenquad(float sw, float sh) +{ + setscreentexcoord(0, sw, sh); + screenquad(); +} + +void screenquadflipped(float sw, float sh) +{ + setscreentexcoord(0, sw, -sh); + screenquad(); +} + +void screenquad(float sw, float sh, float sw2, float sh2) +{ + setscreentexcoord(0, sw, sh); + setscreentexcoord(1, sw2, sh2); + screenquad(); +} + +void screenquadoffset(float x, float y, float w, float h) +{ + setscreentexcoord(0, w, h, x, y); + screenquad(); +} + +void screenquadoffset(float x, float y, float w, float h, float x2, float y2, float w2, float h2) +{ + setscreentexcoord(0, w, h, x, y); + setscreentexcoord(1, w2, h2, x2, y2); + screenquad(); +} + +#define HUDQUAD(x1, y1, x2, y2, sx1, sy1, sx2, sy2) { \ + gle::defvertex(2); \ + gle::deftexcoord0(); \ + gle::begin(GL_TRIANGLE_STRIP); \ + gle::attribf(x2, y1); gle::attribf(sx2, sy1); \ + gle::attribf(x1, y1); gle::attribf(sx1, sy1); \ + gle::attribf(x2, y2); gle::attribf(sx2, sy2); \ + gle::attribf(x1, y2); gle::attribf(sx1, sy2); \ + gle::end(); \ +} + +void hudquad(float x, float y, float w, float h, float tx, float ty, float tw, float th) +{ + HUDQUAD(x, y, x+w, y+h, tx, ty, tx+tw, ty+th); +} + +VARR(fog, 16, 4000, 1000024); +bvec fogcolor(0x80, 0x99, 0xB3); +HVARFR(fogcolour, 0, 0x8099B3, 0xFFFFFF, +{ + fogcolor = bvec((fogcolour>>16)&0xFF, (fogcolour>>8)&0xFF, fogcolour&0xFF); +}); + +static float findsurface(int fogmat, const vec &v, int &abovemat) +{ + fogmat &= MATF_VOLUME; + ivec o(v), co; + int csize; + do + { + cube &c = lookupcube(o, 0, co, csize); + int mat = c.material&MATF_VOLUME; + if(mat != fogmat) + { + abovemat = isliquid(mat) ? c.material : MAT_AIR; + return o.z; + } + o.z = co.z + csize; + } + while(o.z < worldsize); + abovemat = MAT_AIR; + return worldsize; +} + +static void blendfog(int fogmat, float blend, float logblend, float &start, float &end, vec &fogc) +{ + switch(fogmat&MATF_VOLUME) + { + case MAT_WATER: + { + const bvec &wcol = getwatercolor(fogmat); + int wfog = getwaterfog(fogmat); + fogc.madd(wcol.tocolor(), blend); + end += logblend*min(fog, max(wfog*4, 32)); + break; + } + + case MAT_LAVA: + { + const bvec &lcol = getlavacolor(fogmat); + int lfog = getlavafog(fogmat); + fogc.madd(lcol.tocolor(), blend); + end += logblend*min(fog, max(lfog*4, 32)); + break; + } + + default: + fogc.madd(fogcolor.tocolor(), blend); + start += logblend*(fog+64)/8; + end += logblend*fog; + break; + } +} + +vec oldfogcolor(0, 0, 0), curfogcolor(0, 0, 0); +float oldfogstart = 0, oldfogend = 1000000, curfogstart = 0, curfogend = 1000000; + +void setfogcolor(const vec &v) +{ + GLOBALPARAM(fogcolor, v); +} + +void zerofogcolor() +{ + setfogcolor(vec(0, 0, 0)); +} + +void resetfogcolor() +{ + setfogcolor(curfogcolor); +} + +void pushfogcolor(const vec &v) +{ + oldfogcolor = curfogcolor; + curfogcolor = v; + resetfogcolor(); +} + +void popfogcolor() +{ + curfogcolor = oldfogcolor; + resetfogcolor(); +} + +void setfogdist(float start, float end) +{ + GLOBALPARAMF(fogparams, 1/(end - start), end/(end - start)); +} + +void clearfogdist() +{ + setfogdist(0, 1000000); +} + +void resetfogdist() +{ + setfogdist(curfogstart, curfogend); +} + +void pushfogdist(float start, float end) +{ + oldfogstart = curfogstart; + oldfogend = curfogend; + curfogstart = start; + curfogend = end; + resetfogdist(); +} + +void popfogdist() +{ + curfogstart = oldfogstart; + curfogend = oldfogend; + resetfogdist(); +} + +static void resetfog() +{ + resetfogcolor(); + resetfogdist(); + + glClearColor(curfogcolor.r, curfogcolor.g, curfogcolor.b, 1.0f); +} + +static void setfog(int fogmat, float below = 1, int abovemat = MAT_AIR) +{ + float logscale = 256, logblend = log(1 + (logscale - 1)*below) / log(logscale); + + curfogstart = curfogend = 0; + curfogcolor = vec(0, 0, 0); + blendfog(fogmat, below, logblend, curfogstart, curfogend, curfogcolor); + if(below < 1) blendfog(abovemat, 1-below, 1-logblend, curfogstart, curfogend, curfogcolor); + + resetfog(); +} + +static void setnofog(const vec &color = vec(0, 0, 0)) +{ + curfogstart = 0; + curfogend = 1000000; + curfogcolor = color; + + resetfog(); +} + +static void blendfogoverlay(int fogmat, float blend, vec &overlay) +{ + float maxc; + switch(fogmat&MATF_VOLUME) + { + case MAT_WATER: + { + const bvec &wcol = getwatercolor(fogmat); + maxc = max(wcol.r, max(wcol.g, wcol.b)); + overlay.madd(vec(wcol.r, wcol.g, wcol.b).div(min(32.0f + maxc*7.0f/8.0f, 255.0f)).max(0.4f), blend); + break; + } + + case MAT_LAVA: + { + const bvec &lcol = getlavacolor(fogmat); + maxc = max(lcol.r, max(lcol.g, lcol.b)); + overlay.madd(vec(lcol.r, lcol.g, lcol.b).div(min(32.0f + maxc*7.0f/8.0f, 255.0f)).max(0.4f), blend); + break; + } + + default: + overlay.add(blend); + break; + } +} + +void drawfogoverlay(int fogmat, float fogblend, int abovemat) +{ + SETSHADER(fogoverlay); + + glEnable(GL_BLEND); + glBlendFunc(GL_ZERO, GL_SRC_COLOR); + vec overlay(0, 0, 0); + blendfogoverlay(fogmat, fogblend, overlay); + blendfogoverlay(abovemat, 1-fogblend, overlay); + + gle::color(overlay); + screenquad(); + + glDisable(GL_BLEND); +} + +bool renderedgame = false; + +void rendergame(bool mainpass) +{ + game::rendergame(mainpass); + if(!shadowmapping) renderedgame = true; +} + +VARP(skyboxglare, 0, 1, 1); + +void drawglare() +{ + glaring = true; + refracting = -1; + + pushfogcolor(vec(0, 0, 0)); + + glClearColor(0, 0, 0, 1); + glClear((skyboxglare && !shouldclearskyboxglare() ? 0 : GL_COLOR_BUFFER_BIT) | GL_DEPTH_BUFFER_BIT); + + rendergeom(); + + if(skyboxglare) drawskybox(farplane, false); + + renderreflectedmapmodels(); + rendergame(); + renderavatar(); + + renderwater(); + rendermaterials(); + renderalphageom(); + renderparticles(); + + popfogcolor(); + + refracting = 0; + glaring = false; +} + +VARP(reflectmms, 0, 1, 1); +VARR(refractsky, 0, 0, 1); + +matrix4 noreflectmatrix; + +void drawreflection(float z, bool refract, int fogdepth, const bvec &col) +{ + reflectz = z < 0 ? 1e16f : z; + reflecting = !refract; + refracting = refract ? (z < 0 || camera1->o.z >= z ? -1 : 1) : 0; + fading = waterrefract && waterfade && z>=0; + fogging = refracting<0 && z>=0; + refractfog = fogdepth; + + if(fogging) + { + pushfogdist(camera1->o.z - z, camera1->o.z - (z - max(refractfog, 1))); + pushfogcolor(col.tocolor()); + } + else + { + vec color(0, 0, 0); + float start = 0, end = 0; + blendfog(MAT_AIR, 1, 1, start, end, color); + pushfogdist(start, end); + pushfogcolor(color); + } + + if(fading) + { + float scale = fogging ? -0.25f : 0.25f, offset = 2*fabs(scale) - scale*z; + GLOBALPARAMF(waterfadeparams, scale, offset, -scale, offset + camera1->o.z*scale); + } + + if(reflecting) + { + noreflectmatrix = cammatrix; + cammatrix.reflectz(z); + + glFrontFace(GL_CCW); + } + + if(reflectclip && z>=0) + { + float zoffset = reflectclip/4.0f, zclip; + if(refracting<0) + { + zclip = z+zoffset; + if(camera1->o.z<=zclip) zclip = z; + } + else + { + zclip = z-zoffset; + if(camera1->o.z>=zclip && camera1->o.z<=z+4.0f) zclip = z; + if(reflecting) zclip = 2*z - zclip; + } + plane clipplane; + invcammatrix.transposedtransform(plane(0, 0, refracting>0 ? 1 : -1, refracting>0 ? -zclip : zclip), clipplane); + clipmatrix.clip(clipplane, projmatrix); + noclipmatrix = projmatrix; + projmatrix = clipmatrix; + } + + setcamprojmatrix(false, true); + + renderreflectedgeom(refracting<0 && z>=0 && caustics, fogging); + + if(reflecting || refracting>0 || (refracting<0 && refractsky) || z<0) + { + if(fading) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + if(reflectclip && z>=0) + { + projmatrix = noclipmatrix; + setcamprojmatrix(false, true); + } + drawskybox(farplane, false); + if(reflectclip && z>=0) + { + projmatrix = clipmatrix; + setcamprojmatrix(false, true); + } + if(fading) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); + } + else if(fading) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); + + renderdecals(); + + if(reflectmms) renderreflectedmapmodels(); + rendergame(); + + if(refracting && z>=0 && !isthirdperson() && fabs(camera1->o.z-z) <= 0.5f*(player->eyeheight + player->aboveeye)) + { + matrix4 oldprojmatrix = projmatrix, avatarproj; + avatarproj.perspective(curavatarfov, aspect, nearplane, farplane); + if(reflectclip) + { + matrix4 avatarclip; + plane clipplane; + invcammatrix.transposedtransform(plane(0, 0, refracting, reflectclipavatar/4.0f - refracting*z), clipplane); + avatarclip.clip(clipplane, avatarproj); + projmatrix = avatarclip; + } + else projmatrix = avatarproj; + setcamprojmatrix(false, true); + game::renderavatar(); + projmatrix = oldprojmatrix; + setcamprojmatrix(false, true); + } + + if(refracting) rendergrass(); + rendermaterials(); + renderalphageom(fogging); + renderparticles(); + + if(fading) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + + if(reflectclip && z>=0) projmatrix = noclipmatrix; + + if(reflecting) + { + cammatrix = noreflectmatrix; + + glFrontFace(GL_CW); + } + + popfogdist(); + popfogcolor(); + + reflectz = 1e16f; + refracting = 0; + reflecting = fading = fogging = false; + + setcamprojmatrix(false, true); +} + +int drawtex = 0; + +void drawcubemap(int size, const vec &o, float yaw, float pitch, const cubemapside &side, bool onlysky) +{ + drawtex = DRAWTEX_ENVMAP; + + physent *oldcamera = camera1; + static physent cmcamera; + cmcamera = *player; + cmcamera.reset(); + cmcamera.type = ENT_CAMERA; + cmcamera.o = o; + cmcamera.yaw = yaw; + cmcamera.pitch = pitch; + cmcamera.roll = 0; + camera1 = &cmcamera; + setviewcell(camera1->o); + + int fogmat = lookupmaterial(o)&(MATF_VOLUME|MATF_INDEX); + + setfog(fogmat); + + int farplane = worldsize*2; + + projmatrix.perspective(90.0f, 1.0f, nearplane, farplane); + if(!side.flipx || !side.flipy) projmatrix.scalexy(!side.flipx ? -1 : 1, !side.flipy ? -1 : 1); + if(side.swapxy) + { + swap(projmatrix.a.x, projmatrix.a.y); + swap(projmatrix.b.x, projmatrix.b.y); + swap(projmatrix.c.x, projmatrix.c.y); + swap(projmatrix.d.x, projmatrix.d.y); + } + setcamprojmatrix(); + + xtravertsva = xtraverts = glde = gbatches = 0; + + visiblecubes(); + + if(onlysky) drawskybox(farplane, false, true); + else + { + glClear(GL_DEPTH_BUFFER_BIT); + + glEnable(GL_CULL_FACE); + glEnable(GL_DEPTH_TEST); + + if(limitsky()) drawskybox(farplane, true); + + rendergeom(); + + if(!limitsky()) drawskybox(farplane, false); + +// queryreflections(); + + rendermapmodels(); + renderalphageom(); + +// drawreflections(); + +// renderwater(); +// rendermaterials(); + + glDisable(GL_DEPTH_TEST); + glDisable(GL_CULL_FACE); + } + + camera1 = oldcamera; + drawtex = 0; +} + +VAR(modelpreviewfov, 10, 20, 100); +VAR(modelpreviewpitch, -90, -15, 90); + +namespace modelpreview +{ + physent *oldcamera; + physent camera; + + float oldaspect, oldfovy, oldfov; + int oldfarplane; + matrix4 oldprojmatrix; + + void start(int x, int y, int w, int h, bool background) + { + drawtex = DRAWTEX_MODELPREVIEW; + + glViewport(x, y, w, h); + glScissor(x, y, w, h); + glEnable(GL_SCISSOR_TEST); + + oldcamera = camera1; + camera = *camera1; + camera.reset(); + camera.type = ENT_CAMERA; + camera.o = vec(0, 0, 0); + camera.yaw = 0; + camera.pitch = modelpreviewpitch; + camera.roll = 0; + camera1 = &camera; + + oldaspect = aspect; + oldfovy = fovy; + oldfov = curfov; + oldfarplane = farplane; + oldprojmatrix = projmatrix; + + aspect = w/float(h); + fovy = modelpreviewfov; + curfov = 2*atan2(tan(fovy/2*RAD), 1/aspect)/RAD; + farplane = 1024; + + clearfogdist(); + zerofogcolor(); + glClearColor(0, 0, 0, 1); + + glClear((background ? GL_COLOR_BUFFER_BIT : 0) | GL_DEPTH_BUFFER_BIT); + + projmatrix.perspective(fovy, aspect, nearplane, farplane); + setcamprojmatrix(); + + glEnable(GL_CULL_FACE); + glEnable(GL_DEPTH_TEST); + } + + void end() + { + glDisable(GL_CULL_FACE); + glDisable(GL_DEPTH_TEST); + + resetfogdist(); + resetfogcolor(); + glClearColor(curfogcolor.r, curfogcolor.g, curfogcolor.b, 1); + + aspect = oldaspect; + fovy = oldfovy; + curfov = oldfov; + farplane = oldfarplane; + + camera1 = oldcamera; + drawtex = 0; + + glDisable(GL_SCISSOR_TEST); + glViewport(0, 0, screenw, screenh); + + projmatrix = oldprojmatrix; + setcamprojmatrix(); + } +} + +vec calcmodelpreviewpos(const vec &radius, float &yaw) +{ + yaw = fmod(lastmillis/10000.0f*360.0f, 360.0f); + float dist = 1.15f*max(radius.magnitude2()/aspect, radius.magnitude())/sinf(fovy/2*RAD); + return vec(0, dist, 0).rotate_around_x(camera1->pitch*RAD); +} + +GLuint minimaptex = 0; +vec minimapcenter(0, 0, 0), minimapradius(0, 0, 0), minimapscale(0, 0, 0); + +void clearminimap() +{ + if(minimaptex) { glDeleteTextures(1, &minimaptex); minimaptex = 0; } +} + +VARR(minimapheight, 0, 0, 2<<16); +bvec minimapcolor(0, 0, 0); +HVARFR(minimapcolour, 0, 0, 0xFFFFFF, +{ + minimapcolor = bvec((minimapcolour>>16)&0xFF, (minimapcolour>>8)&0xFF, minimapcolour&0xFF); +}); +VARR(minimapclip, 0, 0, 1); +VARFP(minimapsize, 7, 8, 10, { if(minimaptex) drawminimap(); }); + +void bindminimap() +{ + glBindTexture(GL_TEXTURE_2D, minimaptex); +} + +void clipminimap(ivec &bbmin, ivec &bbmax, cube *c = worldroot, const ivec &co = ivec(0, 0, 0), int size = worldsize>>1) +{ + loopi(8) + { + ivec o(i, co, size); + if(c[i].children) clipminimap(bbmin, bbmax, c[i].children, o, size>>1); + else if(!isentirelysolid(c[i]) && (c[i].material&MATF_CLIP)!=MAT_CLIP) + { + loopk(3) bbmin[k] = min(bbmin[k], o[k]); + loopk(3) bbmax[k] = max(bbmax[k], o[k] + size); + } + } +} + +void drawminimap() +{ + if(!game::needminimap()) { clearminimap(); return; } + + renderprogress(0, "generating mini-map...", 0, !renderedframe); + + int size = 1<<minimapsize, sizelimit = min(hwtexsize, min(screenw, screenh)); + while(size > sizelimit) size /= 2; + if(!minimaptex) glGenTextures(1, &minimaptex); + + ivec bbmin(worldsize, worldsize, worldsize), bbmax(0, 0, 0); + loopv(valist) + { + vtxarray *va = valist[i]; + loopk(3) + { + if(va->geommin[k]>va->geommax[k]) continue; + bbmin[k] = min(bbmin[k], va->geommin[k]); + bbmax[k] = max(bbmax[k], va->geommax[k]); + } + } + if(minimapclip) + { + ivec clipmin(worldsize, worldsize, worldsize), clipmax(0, 0, 0); + clipminimap(clipmin, clipmax); + loopk(2) bbmin[k] = max(bbmin[k], clipmin[k]); + loopk(2) bbmax[k] = min(bbmax[k], clipmax[k]); + } + + minimapradius = vec(bbmax).sub(vec(bbmin)).mul(0.5f); + minimapcenter = vec(bbmin).add(minimapradius); + minimapradius.x = minimapradius.y = max(minimapradius.x, minimapradius.y); + minimapscale = vec((0.5f - 1.0f/size)/minimapradius.x, (0.5f - 1.0f/size)/minimapradius.y, 1.0f); + + drawtex = DRAWTEX_MINIMAP; + + physent *oldcamera = camera1; + static physent cmcamera; + cmcamera = *player; + cmcamera.reset(); + cmcamera.type = ENT_CAMERA; + cmcamera.o = vec(minimapcenter.x, minimapcenter.y, max(minimapcenter.z + minimapradius.z + 1, float(minimapheight))); + cmcamera.yaw = 0; + cmcamera.pitch = -90; + cmcamera.roll = 0; + camera1 = &cmcamera; + setviewcell(vec(-1, -1, -1)); + + projmatrix.ortho(-minimapradius.x, minimapradius.x, -minimapradius.y, minimapradius.y, 0, camera1->o.z + 1); + projmatrix.a.mul(-1); + setcamprojmatrix(); + + setnofog(minimapcolor.tocolor()); + + glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); + + glViewport(0, 0, size, size); + + glEnable(GL_CULL_FACE); + glEnable(GL_DEPTH_TEST); + + glFrontFace(GL_CCW); + + xtravertsva = xtraverts = glde = gbatches = 0; + + visiblecubes(false); + queryreflections(); + drawreflections(); + + loopi(minimapheight > 0 && minimapheight < minimapcenter.z + minimapradius.z ? 2 : 1) + { + if(i) + { + glClear(GL_DEPTH_BUFFER_BIT); + camera1->o.z = minimapheight; + setcamprojmatrix(); + } + rendergeom(); + rendermapmodels(); + renderwater(); + rendermaterials(); + renderalphageom(); + } + + glFrontFace(GL_CW); + + glDisable(GL_DEPTH_TEST); + glDisable(GL_CULL_FACE); + + glViewport(0, 0, screenw, screenh); + + camera1 = oldcamera; + drawtex = 0; + + glBindTexture(GL_TEXTURE_2D, minimaptex); + glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, 0, 0, size, size, 0); + setuptexparameters(minimaptex, NULL, 3, 1, GL_RGB5, GL_TEXTURE_2D); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + GLfloat border[4] = { minimapcolor.x/255.0f, minimapcolor.y/255.0f, minimapcolor.z/255.0f, 1.0f }; + glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border); + glBindTexture(GL_TEXTURE_2D, 0); +} + +bool deferdrawtextures = false; + +void drawtextures() +{ + if(minimized) { deferdrawtextures = true; return; } + deferdrawtextures = false; + genenvmaps(); + drawminimap(); +} + +GLuint motiontex = 0; +int motionw = 0, motionh = 0, lastmotion = 0; + +void cleanupmotionblur() +{ + if(motiontex) { glDeleteTextures(1, &motiontex); motiontex = 0; } + motionw = motionh = 0; + lastmotion = 0; +} + +VARFP(motionblur, 0, 0, 1, { if(!motionblur) cleanupmotionblur(); }); +VARP(motionblurmillis, 1, 5, 1000); +FVARP(motionblurscale, 0, 0.5f, 1); + +void addmotionblur() +{ + if(!motionblur || max(screenw, screenh) > hwtexsize) return; + + if(game::ispaused()) { lastmotion = 0; return; } + + if(!motiontex || motionw != screenw || motionh != screenh) + { + if(!motiontex) glGenTextures(1, &motiontex); + motionw = screenw; + motionh = screenh; + lastmotion = 0; + createtexture(motiontex, motionw, motionh, NULL, 3, 0, GL_RGB); + } + + glBindTexture(GL_TEXTURE_2D, motiontex); + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + SETSHADER(screenrect); + + gle::colorf(1, 1, 1, lastmotion ? pow(motionblurscale, max(float(lastmillis - lastmotion)/motionblurmillis, 1.0f)) : 0); + screenquad(1, 1); + + glDisable(GL_BLEND); + + if(lastmillis - lastmotion >= motionblurmillis) + { + lastmotion = lastmillis - lastmillis%motionblurmillis; + + glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screenw, screenh); + } +} + +bool dopostfx = false; + +void invalidatepostfx() +{ + dopostfx = false; +} + +int xtraverts, xtravertsva; + +void gl_drawframe() +{ + if(deferdrawtextures) drawtextures(); + + updatedynlights(); + + int w = screenw, h = screenh; + aspect = forceaspect ? forceaspect : w/float(h); + fovy = 2*atan2(tan(curfov/2*RAD), aspect)/RAD; + + int fogmat = lookupmaterial(camera1->o)&(MATF_VOLUME|MATF_INDEX), abovemat = MAT_AIR; + float fogblend = 1.0f, causticspass = 0.0f; + if(isliquid(fogmat&MATF_VOLUME)) + { + float z = findsurface(fogmat, camera1->o, abovemat) - WATER_OFFSET; + if(camera1->o.z < z + 1) fogblend = min(z + 1 - camera1->o.z, 1.0f); + else fogmat = abovemat; + if(caustics && (fogmat&MATF_VOLUME)==MAT_WATER && camera1->o.z < z) + causticspass = min(z - camera1->o.z, 1.0f); + } + else fogmat = MAT_AIR; + setfog(fogmat, fogblend, abovemat); + if(fogmat!=MAT_AIR) + { + float blend = abovemat==MAT_AIR ? fogblend : 1.0f; + fovy += blend*sinf(lastmillis/1000.0)*2.0f; + aspect += blend*sinf(lastmillis/1000.0+M_PI)*0.1f; + } + + farplane = worldsize*2; + + projmatrix.perspective(fovy, aspect, nearplane, farplane); + setcamprojmatrix(); + + glEnable(GL_CULL_FACE); + glEnable(GL_DEPTH_TEST); + + xtravertsva = xtraverts = glde = gbatches = 0; + + visiblecubes(); + + glClear(GL_DEPTH_BUFFER_BIT|(wireframe && editmode ? GL_COLOR_BUFFER_BIT : 0)); + + if(wireframe && editmode) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + + if(limitsky()) drawskybox(farplane, true); + + rendergeom(causticspass); + + extern int outline; + if(!wireframe && editmode && outline) renderoutline(); + + queryreflections(); + + generategrass(); + + if(!limitsky()) drawskybox(farplane, false); + + renderdecals(true); + + rendermapmodels(); + rendergame(true); + renderavatar(); + + if(wireframe && editmode) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + + drawglaretex(); + drawdepthfxtex(); + drawreflections(); + + if(wireframe && editmode) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + + renderwater(); + rendergrass(); + + rendermaterials(); + renderalphageom(); + + if(wireframe && editmode) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + + renderparticles(true); + + glDisable(GL_CULL_FACE); + glDisable(GL_DEPTH_TEST); + + addmotionblur(); + addglare(); + if(isliquid(fogmat&MATF_VOLUME)) drawfogoverlay(fogmat, fogblend, abovemat); + renderpostfx(); + + gl_drawhud(); + + renderedgame = false; +} + +void gl_drawmainmenu() +{ + xtravertsva = xtraverts = glde = gbatches = 0; + + renderbackground(NULL, NULL, NULL, NULL, true, true); + renderpostfx(); + + gl_drawhud(); +} + +VARNP(damagecompass, usedamagecompass, 0, 1, 1); +VARP(damagecompassfade, 1, 1000, 10000); +VARP(damagecompasssize, 1, 30, 100); +VARP(damagecompassalpha, 1, 25, 100); +VARP(damagecompassmin, 1, 25, 1000); +VARP(damagecompassmax, 1, 200, 1000); + +float damagedirs[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +void damagecompass(int n, const vec &loc) +{ + if(!usedamagecompass || minimized) return; + vec delta(loc); + delta.sub(camera1->o); + float yaw = 0, pitch; + if(delta.magnitude() > 4) + { + vectoyawpitch(delta, yaw, pitch); + yaw -= camera1->yaw; + } + if(yaw >= 360) yaw = fmod(yaw, 360); + else if(yaw < 0) yaw = 360 - fmod(-yaw, 360); + int dir = (int(yaw+22.5f)%360)/45; + damagedirs[dir] += max(n, damagecompassmin)/float(damagecompassmax); + if(damagedirs[dir]>1) damagedirs[dir] = 1; +} + +void drawdamagecompass(int w, int h) +{ + hudnotextureshader->set(); + + int dirs = 0; + float size = damagecompasssize/100.0f*min(h, w)/2.0f; + loopi(8) if(damagedirs[i]>0) + { + if(!dirs) + { + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gle::colorf(1, 0, 0, damagecompassalpha/100.0f); + gle::defvertex(); + gle::begin(GL_TRIANGLES); + } + dirs++; + + float logscale = 32, + scale = log(1 + (logscale - 1)*damagedirs[i]) / log(logscale), + offset = -size/2.0f-min(h, w)/4.0f; + matrix4x3 m; + m.identity(); + m.settranslation(w/2, h/2, 0); + m.rotate_around_z(i*45*RAD); + m.translate(0, offset, 0); + m.scale(size*scale); + + gle::attrib(m.transform(vec2(1, 1))); + gle::attrib(m.transform(vec2(-1, 1))); + gle::attrib(m.transform(vec2(0, 0))); + + // fade in log space so short blips don't disappear too quickly + scale -= float(curtime)/damagecompassfade; + damagedirs[i] = scale > 0 ? (pow(logscale, scale) - 1) / (logscale - 1) : 0; + } + if(dirs) gle::end(); +} + +int damageblendmillis = 0; + +VARFP(damagescreen, 0, 1, 1, { if(!damagescreen) damageblendmillis = 0; }); +VARP(damagescreenfactor, 1, 7, 100); +VARP(damagescreenalpha, 1, 45, 100); +VARP(damagescreenfade, 0, 125, 1000); +VARP(damagescreenmin, 1, 10, 1000); +VARP(damagescreenmax, 1, 100, 1000); + +void damageblend(int n) +{ + if(!damagescreen || minimized) return; + if(lastmillis > damageblendmillis) damageblendmillis = lastmillis; + damageblendmillis += clamp(n, damagescreenmin, damagescreenmax)*damagescreenfactor; +} + +void drawdamagescreen(int w, int h) +{ + if(lastmillis >= damageblendmillis) return; + + hudshader->set(); + + static Texture *damagetex = NULL; + if(!damagetex) damagetex = textureload("packages/hud/damage.png", 3); + + glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + glBindTexture(GL_TEXTURE_2D, damagetex->id); + float fade = damagescreenalpha/100.0f; + if(damageblendmillis - lastmillis < damagescreenfade) + fade *= float(damageblendmillis - lastmillis)/damagescreenfade; + gle::colorf(fade, fade, fade, fade); + + hudquad(0, 0, w, h); +} + +void cleardamagescreen() +{ + damageblendmillis = 0; + loopi(8) damagedirs[i] = 0; +} + +VAR(hidestats, 0, 0, 1); +VAR(hidehud, 0, 0, 1); + +VARP(crosshairsize, 0, 15, 50); +VARP(cursorsize, 0, 30, 50); +VARP(crosshairfx, 0, 1, 1); +VARP(crosshaircolors, 0, 1, 1); + +#define MAXCROSSHAIRS 4 +static Texture *crosshairs[MAXCROSSHAIRS] = { NULL, NULL, NULL, NULL }; + +void loadcrosshair(const char *name, int i) +{ + if(i < 0 || i >= MAXCROSSHAIRS) return; + crosshairs[i] = name ? textureload(name, 3, true) : notexture; + if(crosshairs[i] == notexture) + { + name = game::defaultcrosshair(i); + if(!name) name = "data/crosshair.png"; + crosshairs[i] = textureload(name, 3, true); + } +} + +void loadcrosshair_(const char *name, int *i) +{ + loadcrosshair(name, *i); +} + +COMMANDN(loadcrosshair, loadcrosshair_, "si"); + +ICOMMAND(getcrosshair, "i", (int *i), +{ + const char *name = ""; + if(*i >= 0 && *i < MAXCROSSHAIRS) + { + name = crosshairs[*i] ? crosshairs[*i]->name : game::defaultcrosshair(*i); + if(!name) name = "data/crosshair.png"; + } + result(name); +}); + +void writecrosshairs(stream *f) +{ + loopi(MAXCROSSHAIRS) if(crosshairs[i] && crosshairs[i]!=notexture) + f->printf("loadcrosshair %s %d\n", escapestring(crosshairs[i]->name), i); + f->printf("\n"); +} + +void drawcrosshair(int w, int h) +{ + bool windowhit = g3d_windowhit(true, false); + if(!windowhit && (hidehud || mainmenu)) return; //(hidehud || player->state==CS_SPECTATOR || player->state==CS_DEAD)) return; + + vec color(1, 1, 1); + float cx = 0.5f, cy = 0.5f, chsize; + Texture *crosshair; + if(windowhit) + { + static Texture *cursor = NULL; + if(!cursor) cursor = textureload("data/guicursor.png", 3, true); + crosshair = cursor; + chsize = cursorsize*w/900.0f; + g3d_cursorpos(cx, cy); + } + else + { + int index = game::selectcrosshair(color); + if(index < 0) return; + if(!crosshairfx) index = 0; + if(!crosshairfx || !crosshaircolors) color = vec(1, 1, 1); + crosshair = crosshairs[index]; + if(!crosshair) + { + loadcrosshair(NULL, index); + crosshair = crosshairs[index]; + } + chsize = crosshairsize*w/900.0f; + } + if(crosshair->type&Texture::ALPHA) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + else glBlendFunc(GL_ONE, GL_ONE); + float x = cx*w - (windowhit ? 0 : chsize/2.0f); + float y = cy*h - (windowhit ? 0 : chsize/2.0f); + glBindTexture(GL_TEXTURE_2D, crosshair->id); + + hudshader->set(); + gle::color(color); + hudquad(x, y, chsize, chsize); +} + +VARP(wallclock, 0, 0, 1); +VARP(wallclock24, 0, 0, 1); +VARP(wallclocksecs, 0, 0, 1); + +static time_t walltime = 0; + +VARP(showfps, 0, 1, 1); +VARP(showfpsrange, 0, 0, 1); +VAR(showeditstats, 0, 0, 1); +VAR(statrate, 1, 200, 1000); + +FVARP(conscale, 1e-3f, 0.33f, 1e3f); + +void gl_drawhud() +{ + g3d_render(); + + int w = screenw, h = screenh; + if(forceaspect) w = int(ceil(h*forceaspect)); + + if(editmode && !hidehud && !mainmenu) + { + glEnable(GL_DEPTH_TEST); + glDepthMask(GL_FALSE); + + renderblendbrush(); + + rendereditcursor(); + + glDepthMask(GL_TRUE); + glDisable(GL_DEPTH_TEST); + } + + gettextres(w, h); + + hudmatrix.ortho(0, w, h, 0, -1, 1); + resethudmatrix(); + + gle::colorf(1, 1, 1); + + extern int debugsm; + if(debugsm) + { + extern void viewshadowmap(); + viewshadowmap(); + } + + extern int debugglare; + if(debugglare) + { + extern void viewglaretex(); + viewglaretex(); + } + + extern int debugdepthfx; + if(debugdepthfx) + { + extern void viewdepthfxtex(); + viewdepthfxtex(); + } + + glEnable(GL_BLEND); + + extern void debugparticles(); + debugparticles(); + + if(!mainmenu) + { + drawdamagescreen(w, h); + drawdamagecompass(w, h); + } + + hudshader->set(); + + int conw = int(w/conscale), conh = int(h/conscale), abovehud = conh - FONTH, limitgui = abovehud; + if(!hidehud && !mainmenu) + { + if(!hidestats) + { + pushhudmatrix(); + hudmatrix.scale(conscale, conscale, 1); + flushhudmatrix(); + + int roffset = 0; + if(showfps) + { + static int lastfps = 0, prevfps[3] = { 0, 0, 0 }, curfps[3] = { 0, 0, 0 }; + if(totalmillis - lastfps >= statrate) + { + memcpy(prevfps, curfps, sizeof(prevfps)); + lastfps = totalmillis - (totalmillis%statrate); + } + int nextfps[3]; + getfps(nextfps[0], nextfps[1], nextfps[2]); + loopi(3) if(prevfps[i]==curfps[i]) curfps[i] = nextfps[i]; + if(showfpsrange) draw_textf("fps %d+%d-%d", conw-7*FONTH, conh-FONTH*3/2, curfps[0], curfps[1], curfps[2]); + else draw_textf("fps %d", conw-5*FONTH, conh-FONTH*3/2, curfps[0]); + roffset += FONTH; + } + + if(wallclock) + { + if(!walltime) { walltime = time(NULL); walltime -= totalmillis/1000; if(!walltime) walltime++; } + time_t walloffset = walltime + totalmillis/1000; + struct tm *localvals = localtime(&walloffset); + static string buf; + if(localvals && strftime(buf, sizeof(buf), wallclocksecs ? (wallclock24 ? "%H:%M:%S" : "%I:%M:%S%p") : (wallclock24 ? "%H:%M" : "%I:%M%p"), localvals)) + { + // hack because not all platforms (windows) support %P lowercase option + // also strip leading 0 from 12 hour time + char *dst = buf; + const char *src = &buf[!wallclock24 && buf[0]=='0' ? 1 : 0]; + while(*src) *dst++ = tolower(*src++); + *dst++ = '\0'; + draw_text(buf, conw-5*FONTH, conh-FONTH*3/2-roffset); + roffset += FONTH; + } + } + + if(editmode || showeditstats) + { + static int laststats = 0, prevstats[8] = { 0, 0, 0, 0, 0, 0, 0 }, curstats[8] = { 0, 0, 0, 0, 0, 0, 0 }; + if(totalmillis - laststats >= statrate) + { + memcpy(prevstats, curstats, sizeof(prevstats)); + laststats = totalmillis - (totalmillis%statrate); + } + int nextstats[8] = + { + vtris*100/max(wtris, 1), + vverts*100/max(wverts, 1), + xtraverts/1024, + xtravertsva/1024, + glde, + gbatches, + getnumqueries(), + rplanes + }; + loopi(8) if(prevstats[i]==curstats[i]) curstats[i] = nextstats[i]; + + abovehud -= 2*FONTH; + draw_textf("wtr:%dk(%d%%) wvt:%dk(%d%%) evt:%dk eva:%dk", FONTH/2, abovehud, wtris/1024, curstats[0], wverts/1024, curstats[1], curstats[2], curstats[3]); + draw_textf("ond:%d va:%d gl:%d(%d) oq:%d lm:%d rp:%d pvs:%d", FONTH/2, abovehud+FONTH, allocnodes*8, allocva, curstats[4], curstats[5], curstats[6], lightmaps.length(), curstats[7], getnumviewcells()); + limitgui = abovehud; + } + + if(editmode) + { + abovehud -= FONTH; + draw_textf("cube %s%d%s", FONTH/2, abovehud, selchildcount<0 ? "1/" : "", abs(selchildcount), showmat && selchildmat > 0 ? getmaterialdesc(selchildmat, ": ") : ""); + + if(char *editinfo = execidentstr("edithud")) + { + if(editinfo[0]) + { + int tw, th; + text_bounds(editinfo, tw, th); + th += FONTH-1; th -= th%FONTH; + abovehud -= max(th, FONTH); + draw_text(editinfo, FONTH/2, abovehud); + } + DELETEA(editinfo); + } + } + else if(char *gameinfo = execidentstr("gamehud")) + { + if(gameinfo[0]) + { + int tw, th; + text_bounds(gameinfo, tw, th); + th += FONTH-1; th -= th%FONTH; + roffset += max(th, FONTH); + draw_text(gameinfo, conw-max(5*FONTH, 2*FONTH+tw), conh-FONTH/2-roffset); + } + DELETEA(gameinfo); + } + + pophudmatrix(); + } + + if(hidestats || (!editmode && !showeditstats)) + { + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + game::gameplayhud(w, h); + limitgui = abovehud = min(abovehud, int(conh*game::abovegameplayhud(w, h))); + } + + rendertexturepanel(w, h); + } + + glDisable(GL_BLEND); + + g3d_limitscale((2*limitgui - conh) / float(conh)); + g3d_render2d(); + + glEnable(GL_BLEND); + + hudmatrix.ortho(0, w, h, 0, -1, 1); + resethudmatrix(); + + pushhudmatrix(); + hudmatrix.scale(conscale, conscale, 1); + flushhudmatrix(); + abovehud -= rendercommand(FONTH/2, abovehud - FONTH/2, conw-FONTH); + extern int fullconsole; + if(!hidehud || fullconsole) renderconsole(conw, conh, abovehud - FONTH/2); + pophudmatrix(); + + drawcrosshair(w, h); + + glDisable(GL_BLEND); +} + +void cleanupgl() +{ + cleanupmotionblur(); + + clearminimap(); + + cleanupscreenquad(); + + gle::cleanup(); +} + + |