diff --git a/doom64ex-plus.wad b/doom64ex-plus.wad index e83a1463..393d4e40 100644 Binary files a/doom64ex-plus.wad and b/doom64ex-plus.wad differ diff --git a/src/engine/am_draw.c b/src/engine/am_draw.c index 494687e9..145ca038 100644 --- a/src/engine/am_draw.c +++ b/src/engine/am_draw.c @@ -47,6 +47,7 @@ static angle_t am_viewangle; CVAR_EXTERNAL(am_fulldraw); CVAR_EXTERNAL(am_ssect); +CVAR_EXTERNAL(r_texturecombiner); // // AM_BeginDraw @@ -55,6 +56,16 @@ CVAR_EXTERNAL(am_ssect); void AM_BeginDraw(angle_t view, fixed_t x, fixed_t y) { am_viewangle = view; + if(r_texturecombiner.value > 0 && am_overlay.value) { + GL_SetState(GLSTATE_BLEND, 1); + + // + // increase the rgb scale so the automap can look good while transparent (overlay mode) + // + GL_SetTextureMode(GL_COMBINE); + dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 4); + } + dglDepthRange(0.0f, 0.0f); dglMatrixMode(GL_PROJECTION); dglLoadIdentity(); @@ -77,10 +88,16 @@ void AM_BeginDraw(angle_t view, fixed_t x, fixed_t y) { // void AM_EndDraw(void) { - dglPopMatrix(); - dglDepthRange(0.0f, 1.0f); + dglPopMatrix(); + dglDepthRange(0.0f, 1.0f); - GL_SetDefaultCombiner(); + if(r_texturecombiner.value > 0 && am_overlay.value) { + GL_SetState(GLSTATE_BLEND, 0); + GL_SetTextureMode(GL_COMBINE); + GL_SetColorScale(); + } + + GL_SetDefaultCombiner(); } // @@ -233,14 +250,24 @@ void AM_DrawLeafs(float scale) { // // process draw list // - DL_BeginDrawList(!am_ssect.value && 1); - - if (!nolights) { - GL_SetTextureMode(GL_MODULATE); - } - else { - GL_SetTextureMode(GL_REPLACE); - } + DL_BeginDrawList(!am_ssect.value && r_fillmode.value, 0); + + if(r_texturecombiner.value > 0) { + if(!nolights) { + dglTexCombModulate(GL_TEXTURE0_ARB, GL_PRIMARY_COLOR); + } + else { + dglTexCombReplace(); + } + } + else { + if(!nolights) { + GL_SetTextureMode(GL_MODULATE); + } + else { + GL_SetTextureMode(GL_REPLACE); + } + } DL_ProcessDrawList(DLT_AMAP, DL_ProcessAutomap); } @@ -314,7 +341,9 @@ void AM_DrawTriangle(mobj_t* mobj, float scale, boolean solid, byte r, byte g, b return; } - dglPolygonMode(GL_FRONT_AND_BACK, (solid == 1) ? GL_LINE : GL_FILL); + if(r_fillmode.value) { + dglPolygonMode(GL_FRONT_AND_BACK, (solid == 1) ? GL_LINE : GL_FILL); + } dglSetVertex(tri); RB_AddTriangle(0, 1, 2); @@ -322,7 +351,9 @@ void AM_DrawTriangle(mobj_t* mobj, float scale, boolean solid, byte r, byte g, b dglDrawGeometry(3, tri); dglEnable(GL_TEXTURE_2D); - dglPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + if(r_fillmode.value) { + dglPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + } if (devparm) { vertCount += 3; diff --git a/src/engine/dgl.c b/src/engine/dgl.c index f23b588c..9583cb45 100644 --- a/src/engine/dgl.c +++ b/src/engine/dgl.c @@ -219,3 +219,124 @@ void dglGetColorf(rcolor color, float* argb) { argb[1] = (float)((color >> 8) & 0xff) / 255.0f; argb[0] = (float)(color & 0xff) / 255.0f; } + +// +// dglTexCombReplace +// + +void dglTexCombReplace(void) { +#ifdef LOG_GLFUNC_CALLS + I_Printf("dglTexCombReplace\n"); +#endif + GL_SetTextureMode(GL_COMBINE_ARB); + GL_SetCombineState(GL_REPLACE); + GL_SetCombineSourceRGB(0, GL_TEXTURE); + GL_SetCombineOperandRGB(0, GL_SRC_COLOR); +} + +// +// dglTexCombColor +// + +void dglTexCombColor(int t, rcolor c, int func) { + float f[4]; +#ifdef LOG_GLFUNC_CALLS + I_Printf("dglTexCombColor(t=0x%x, c=0x%x)\n", t, c); +#endif + dglGetColorf(c, f); + GL_SetTextureMode(GL_COMBINE_ARB); + GL_SetEnvColor(f); + GL_SetCombineState(func); + GL_SetCombineSourceRGB(0, t); + GL_SetCombineOperandRGB(0, GL_SRC_COLOR); + GL_SetCombineSourceRGB(1, GL_CONSTANT); + GL_SetCombineOperandRGB(1, GL_SRC_COLOR); +} + +// +// dglTexCombColorf +// + +void dglTexCombColorf(int t, float* f, int func) { +#ifdef LOG_GLFUNC_CALLS + I_Printf("dglTexCombColorf(t=0x%x, f=%p)\n", t, f); +#endif + GL_SetTextureMode(GL_COMBINE_ARB); + GL_SetEnvColor(f); + GL_SetCombineState(func); + GL_SetCombineSourceRGB(0, t); + GL_SetCombineOperandRGB(0, GL_SRC_COLOR); + GL_SetCombineSourceRGB(1, GL_CONSTANT); + GL_SetCombineOperandRGB(1, GL_SRC_COLOR); +} + +// +// dglTexCombModulate +// + +void dglTexCombModulate(int t, int s) { +#ifdef LOG_GLFUNC_CALLS + I_Printf("dglTexCombFinalize(t=0x%x)\n", t); +#endif + GL_SetTextureMode(GL_COMBINE_ARB); + GL_SetCombineState(GL_MODULATE); + GL_SetCombineSourceRGB(0, t); + GL_SetCombineOperandRGB(0, GL_SRC_COLOR); + GL_SetCombineSourceRGB(1, s); + GL_SetCombineOperandRGB(1, GL_SRC_COLOR); +} + +// +// dglTexCombAdd +// + +void dglTexCombAdd(int t, int s) { +#ifdef LOG_GLFUNC_CALLS + I_Printf("dglTexCombFinalize(t=0x%x)\n", t); +#endif + GL_SetTextureMode(GL_COMBINE_ARB); + GL_SetCombineState(GL_ADD); + GL_SetCombineSourceRGB(0, t); + GL_SetCombineOperandRGB(0, GL_SRC_COLOR); + GL_SetCombineSourceRGB(1, s); + GL_SetCombineOperandRGB(1, GL_SRC_COLOR); +} + +// +// dglTexCombInterpolate +// + +void dglTexCombInterpolate(int t, float a) { + float f[4]; +#ifdef LOG_GLFUNC_CALLS + I_Printf("dglTexCombInterpolate(t=0x%x, a=%f)\n", t, a); +#endif + f[0] = f[1] = f[2] = 0.0f; + f[3] = a; + + GL_SetTextureMode(GL_COMBINE_ARB); + GL_SetCombineState(GL_INTERPOLATE); + GL_SetEnvColor(f); + GL_SetCombineSourceRGB(0, GL_TEXTURE); + GL_SetCombineOperandRGB(0, GL_SRC_COLOR); + GL_SetCombineSourceRGB(1, t); + GL_SetCombineOperandRGB(1, GL_SRC_COLOR); + GL_SetCombineSourceRGB(2, GL_CONSTANT); + GL_SetCombineOperandRGB(2, GL_SRC_ALPHA); +} + +// +// dglTexCombReplaceAlpha +// + +void dglTexCombReplaceAlpha(int t) { +#ifdef LOG_GLFUNC_CALLS + I_Printf("dglTexCombReplaceAlpha(t=0x%x)\n", t); +#endif + GL_SetTextureMode(GL_COMBINE_ARB); + GL_SetCombineStateAlpha(GL_MODULATE); + GL_SetCombineSourceAlpha(0, t); + GL_SetCombineOperandAlpha(0, GL_SRC_ALPHA); + GL_SetCombineSourceAlpha(1, GL_PRIMARY_COLOR); + GL_SetCombineOperandAlpha(1, GL_SRC_ALPHA); +} diff --git a/src/engine/gl_draw.c b/src/engine/gl_draw.c index ab36c539..ce3fb57c 100644 --- a/src/engine/gl_draw.c +++ b/src/engine/gl_draw.c @@ -133,6 +133,7 @@ int Draw_Text(int x, int y, rcolor color, float scale, char msg[MAX_MESSAGE_SIZE]; va_list va; const int ix = x; + boolean fill = false; va_start(va, string); vsprintf(msg, string, va); @@ -140,6 +141,13 @@ int Draw_Text(int x, int y, rcolor color, float scale, GL_SetState(GLSTATE_BLEND, 1); + if(!r_fillmode.value) { + dglEnable(GL_TEXTURE_2D); + dglPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + r_fillmode.value = 1.0f; + fill = true; + } + GL_BindGfxTexture("SFONT", true); dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, DGL_CLAMP); @@ -214,6 +222,12 @@ int Draw_Text(int x, int y, rcolor color, float scale, GL_ResetViewport(); + if(fill) { + dglDisable(GL_TEXTURE_2D); + dglPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + r_fillmode.value = 0.0f; + } + GL_SetState(GLSTATE_BLEND, 0); GL_SetOrthoScale(1.0f); diff --git a/src/engine/gl_main.c b/src/engine/gl_main.c index 0dab67ea..ae78af8e 100644 --- a/src/engine/gl_main.c +++ b/src/engine/gl_main.c @@ -45,20 +45,19 @@ #include "con_console.h" #include "m_misc.h" #include "g_actions.h" -#include "i_sdlinput.h" int ViewWindowX = 0; int ViewWindowY = 0; -int ViewWidth = 0; -int ViewHeight = 0; +int ViewWidth = 0; +int ViewHeight = 0; int gl_max_texture_units; int gl_max_texture_size; boolean gl_has_combiner; -const char* gl_vendor; -const char* gl_renderer; -const char* gl_version; +const char *gl_vendor; +const char *gl_renderer; +const char *gl_version; static float glScaleFactor = 1.0f; @@ -69,99 +68,108 @@ boolean widescreen = false; CVAR_EXTERNAL(v_vsync); CVAR_EXTERNAL(r_filter); +CVAR_EXTERNAL(r_texturecombiner); CVAR_EXTERNAL(r_anisotropic); CVAR_EXTERNAL(st_flashoverlay); +CVAR_EXTERNAL(r_colorscale); // // CMD_DumpGLExtensions // static CMD(DumpGLExtensions) { - char* string; - int i = 0; - int len = 0; + char *string; + int i = 0; + int len = 0; - string = (char*)dglGetString(GL_EXTENSIONS); - len = dstrlen(string); + string = (char*)dglGetString(GL_EXTENSIONS); + len = dstrlen(string); - for (i = 0; i < len; i++) { - if (string[i] == 0x20) { - string[i] = '\n'; - } - } + for(i = 0; i < len; i++) { + if(string[i] == 0x20) { + string[i] = '\n'; + } + } - M_WriteTextFile("GL_EXTENSIONS.TXT", string, len); - CON_Printf(WHITE, "Written GL_EXTENSIONS.TXT\n"); + M_WriteTextFile("GL_EXTENSIONS.TXT", string, len); + CON_Printf(WHITE, "Written GL_EXTENSIONS.TXT\n"); } // ======================== OGL Extensions =================================== GL_ARB_multitexture_Define(); +//GL_EXT_compiled_vertex_array_Define(); +//GL_EXT_multi_draw_arrays_Define(); +//GL_EXT_fog_coord_Define(); +//GL_ARB_vertex_buffer_object_Define(); +//GL_ARB_texture_non_power_of_two_Define(); +GL_ARB_texture_env_combine_Define(); +GL_EXT_texture_env_combine_Define(); GL_EXT_texture_filter_anisotropic_Define(); // // FindExtension // -static boolean FindExtension(const char* ext) { - const char* extensions = NULL; - const char* start; - const char* where, * terminator; - - // Extension names should not have spaces. - where = strrchr(ext, ' '); - if (where || *ext == '\0') { - return 0; - } - - extensions = dglGetString(GL_EXTENSIONS); - - start = extensions; - for (;;) { - where = strstr(start, ext); - if (!where) { - break; - } - terminator = where + dstrlen(ext); - if (where == start || *(where - 1) == ' ') { - if (*terminator == ' ' || *terminator == '\0') { - return true; - } - start = terminator; - } - } - return false; +static boolean FindExtension(const char *ext) { + const char *extensions = NULL; + const char *start; + const char *where, *terminator; + + // Extension names should not have spaces. + where = strrchr(ext, ' '); + if(where || *ext == '\0') { + return 0; + } + + extensions = dglGetString(GL_EXTENSIONS); + + start = extensions; + for(;;) { + where = strstr(start, ext); + if(!where) { + break; + } + terminator = where + dstrlen(ext); + if(where == start || *(where - 1) == ' ') { + if(*terminator == ' ' || *terminator == '\0') { + return true; + } + start = terminator; + } + } + return false; } // // GL_CheckExtension // -boolean GL_CheckExtension(const char* ext) { - if (FindExtension(ext)) { - CON_Printf(WHITE, "GL Extension: %s = true\n", ext); - return true; - } - else { - CON_Printf(YELLOW, "GL Extension: %s = false\n", ext); - } +boolean GL_CheckExtension(const char *ext) { + if(FindExtension(ext)) { + CON_Printf(WHITE, "GL Extension: %s = true\n", ext); + return true; + } + else { + CON_Printf(YELLOW, "GL Extension: %s = false\n", ext); + } - return false; + return false; } // // GL_RegisterProc // -void* GL_RegisterProc(const char* address) { - void* proc = SDL_GL_GetProcAddress(address); +void* GL_RegisterProc(const char *address) { + void *proc = SDL_GL_GetProcAddress(address); - if (!proc) { - CON_Warnf("GL_RegisterProc: Failed to get proc address: %s", address); - return NULL; - } + if(!proc) { + CON_Warnf("GL_RegisterProc: Failed to get proc address: %s", address); + return NULL; + } - return proc; + return proc; } // @@ -171,44 +179,44 @@ void* GL_RegisterProc(const char* address) { static byte checkortho = 0; void GL_SetOrtho(boolean stretch) { - float width; - float height; - - if (checkortho) { - if (widescreen) { - if (stretch && checkortho == 2) { - return; - } - } - else { - return; - } - } - - dglMatrixMode(GL_MODELVIEW); - dglLoadIdentity(); - dglMatrixMode(GL_PROJECTION); - dglLoadIdentity(); - - if (widescreen && !stretch) { - const float ratio = (4.0f / 3.0f); - float fitwidth = ViewHeight * ratio; - float fitx = (ViewWidth - fitwidth) / 2.0f; - - dglViewport(ViewWindowX + (int)fitx, ViewWindowY, (int)fitwidth, ViewHeight); - } + float width; + float height; + + if(checkortho) { + if(widescreen) { + if(stretch && checkortho == 2) { + return; + } + } + else { + return; + } + } + + dglMatrixMode(GL_MODELVIEW); + dglLoadIdentity(); + dglMatrixMode(GL_PROJECTION); + dglLoadIdentity(); + + if(widescreen && !stretch) { + const float ratio = (4.0f / 3.0f); + float fitwidth = ViewHeight * ratio; + float fitx = (ViewWidth - fitwidth) / 2.0f; + + dglViewport(ViewWindowX + (int)fitx, ViewWindowY, (int)fitwidth, ViewHeight); + } width = SCREENWIDTH & (int)~3; height = SCREENHEIGHT; - if (glScaleFactor != 1.0f) { - width /= glScaleFactor; - height /= glScaleFactor; - } + if(glScaleFactor != 1.0f) { + width /= glScaleFactor; + height /= glScaleFactor; + } - dglOrtho(0, width, height, 0, -1, 1); + dglOrtho(0, width, height, 0, -1, 1); - checkortho = (stretch && widescreen) ? 2 : 1; + checkortho = (stretch && widescreen) ? 2 : 1; } // @@ -216,9 +224,9 @@ void GL_SetOrtho(boolean stretch) { // void GL_ResetViewport(void) { - if (widescreen) { - dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight); - } + if(widescreen) { + dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight); + } } // @@ -226,8 +234,8 @@ void GL_ResetViewport(void) { // void GL_SetOrthoScale(float scale) { - glScaleFactor = scale; - checkortho = 0; + glScaleFactor = scale; + checkortho = 0; } // @@ -235,7 +243,7 @@ void GL_SetOrthoScale(float scale) { // float GL_GetOrthoScale(void) { - return glScaleFactor; + return glScaleFactor; } // @@ -243,7 +251,7 @@ float GL_GetOrthoScale(void) { // void GL_SwapBuffers(void) { - I_FinishUpdate(); + I_FinishUpdate(); } // @@ -251,46 +259,46 @@ void GL_SwapBuffers(void) { // byte* GL_GetScreenBuffer(int x, int y, int width, int height) { - byte* buffer; - byte* data; - int i; - int j; - int offset1; - int offset2; - int pack; - int col; - - col = (width * 3); - data = (byte*)Z_Calloc(height * width * 3, PU_STATIC, 0); - buffer = (byte*)Z_Calloc(col, PU_STATIC, 0); - - // - // 20120313 villsa - force pack alignment to 1 - // - dglGetIntegerv(GL_PACK_ALIGNMENT, &pack); - dglPixelStorei(GL_PACK_ALIGNMENT, 1); - dglFlush(); - dglReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, data); - dglPixelStorei(GL_PACK_ALIGNMENT, pack); - - // - // Need to vertically flip the image - // 20120313 villsa - better method to flip image. uses one buffer instead of two - // - for (i = 0; i < height / 2; i++) { - for (j = 0; j < col; j++) { - offset1 = (i * col) + j; - offset2 = ((height - (i + 1)) * col) + j; - - buffer[j] = data[offset1]; - data[offset1] = data[offset2]; - data[offset2] = buffer[j]; - } - } - - Z_Free(buffer); - - return data; + byte* buffer; + byte* data; + int i; + int j; + int offset1; + int offset2; + int pack; + int col; + + col = (width * 3); + data = (byte*)Z_Calloc(height * width * 3, PU_STATIC, 0); + buffer = (byte*)Z_Calloc(col, PU_STATIC, 0); + + // + // 20120313 villsa - force pack alignment to 1 + // + dglGetIntegerv(GL_PACK_ALIGNMENT, &pack); + dglPixelStorei(GL_PACK_ALIGNMENT, 1); + dglFlush(); + dglReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, data); + dglPixelStorei(GL_PACK_ALIGNMENT, pack); + + // + // Need to vertically flip the image + // 20120313 villsa - better method to flip image. uses one buffer instead of two + // + for(i = 0; i < height / 2; i++) { + for(j = 0; j < col; j++) { + offset1 = (i * col) + j; + offset2 = ((height - (i + 1)) * col) + j; + + buffer[j] = data[offset1]; + data[offset1] = data[offset2]; + data[offset2] = buffer[j]; + } + } + + Z_Free(buffer); + + return data; } // @@ -298,21 +306,21 @@ byte* GL_GetScreenBuffer(int x, int y, int width, int height) { // void GL_SetTextureFilter(void) { - if (!usingGL) { - return; - } - - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST); - - if (GL_EXT_texture_filter_anisotropic) { - if (r_anisotropic.value) { - dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropic); - } - else { - dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0); - } - } + if(!usingGL) { + return; + } + + dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST); + dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST); + + if(has_GL_EXT_texture_filter_anisotropic) { + if(r_anisotropic.value) { + dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropic); + } + else { + dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0); + } + } } // @@ -320,70 +328,100 @@ void GL_SetTextureFilter(void) { // void GL_SetDefaultCombiner(void) { - if (!usingGL) { + if (!usingGL) { + return; + } + + if(has_GL_ARB_multitexture) { + GL_SetTextureUnit(1, false); + GL_SetTextureUnit(2, false); + GL_SetTextureUnit(3, false); + GL_SetTextureUnit(0, true); + } + + GL_CheckFillMode(); + + if(r_texturecombiner.value > 0) { + dglTexCombModulate(GL_TEXTURE0_ARB, GL_PRIMARY_COLOR); + } + else { + GL_SetTextureMode(GL_MODULATE); + } +} + +// +// GL_SetColorScale +// + +void GL_SetColorScale(void) { + if (!usingGL) { return; } - - if (GL_ARB_multitexture) { - GL_SetTextureUnit(1, false); - GL_SetTextureUnit(2, false); - GL_SetTextureUnit(3, false); - GL_SetTextureUnit(0, true); - } - - GL_CheckFillMode(); - GL_SetTextureMode(GL_MODULATE); + + int cs = (int)r_colorscale.value; + + switch(cs) { + case 1: + dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 2); + break; + case 2: + dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 4); + break; + default: + dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 1); + break; + } } // // GL_Set2DQuad // -void GL_Set2DQuad(vtx_t* v, float x, float y, int width, int height, - float u1, float u2, float v1, float v2, rcolor c) { - float left, right, top, bottom; +void GL_Set2DQuad(vtx_t *v, float x, float y, int width, int height, + float u1, float u2, float v1, float v2, rcolor c) { + float left, right, top, bottom; - left = ViewWindowX + x * ViewWidth / video_width; - right = left + (width * ViewWidth / video_width); - top = ViewWindowY + y * ViewHeight / video_height; - bottom = top + (height * ViewHeight / video_height); + left = ViewWindowX + x * ViewWidth / video_width; + right = left + (width * ViewWidth / video_width); + top = ViewWindowY + y * ViewHeight / video_height; + bottom = top + (height * ViewHeight / video_height); - v[0].x = v[2].x = left; - v[1].x = v[3].x = right; - v[0].y = v[1].y = top; - v[2].y = v[3].y = bottom; + v[0].x = v[2].x = left; + v[1].x = v[3].x = right; + v[0].y = v[1].y = top; + v[2].y = v[3].y = bottom; - v[0].z = v[1].z = v[2].z = v[3].z = 0.0f; + v[0].z = v[1].z = v[2].z = v[3].z = 0.0f; - v[0].tu = u1; - v[2].tu = u1; - v[1].tu = u2; - v[3].tu = u2; - v[0].tv = v1; - v[1].tv = v1; - v[2].tv = v2; - v[3].tv = v2; + v[0].tu = u1; + v[2].tu = u1; + v[1].tu = u2; + v[3].tu = u2; + v[0].tv = v1; + v[1].tv = v1; + v[2].tv = v2; + v[3].tv = v2; - dglSetVertexColor(v, c, 4); + dglSetVertexColor(v, c, 4); } // // GL_Draw2DQuad // -void GL_Draw2DQuad(vtx_t* v, boolean stretch) { - GL_SetOrtho(stretch); +void GL_Draw2DQuad(vtx_t *v, boolean stretch) { + GL_SetOrtho(stretch); - dglSetVertex(v); - RB_AddTriangle(0, 1, 2); - RB_AddTriangle(3, 2, 1); - dglDrawGeometry(4, v); + dglSetVertex(v); + RB_AddTriangle(0, 1, 2); + RB_AddTriangle(3, 2, 1); + dglDrawGeometry(4, v); - GL_ResetViewport(); + GL_ResetViewport(); - if (devparm) { - vertCount += 4; - } + if(devparm) { + vertCount += 4; + } } // @@ -391,11 +429,11 @@ void GL_Draw2DQuad(vtx_t* v, boolean stretch) { // void GL_SetupAndDraw2DQuad(float x, float y, int width, int height, - float u1, float u2, float v1, float v2, rcolor c, boolean stretch) { - vtx_t v[4]; + float u1, float u2, float v1, float v2, rcolor c, boolean stretch) { + vtx_t v[4]; - GL_Set2DQuad(v, x, y, width, height, u1, u2, v1, v2, c); - GL_Draw2DQuad(v, stretch); + GL_Set2DQuad(v, x, y, width, height, u1, u2, v1, v2, c); + GL_Draw2DQuad(v, stretch); }; // @@ -417,29 +455,29 @@ void GL_SetState(int bit, boolean enable) { glstate_flag &= ~(1 << flag); \ } - switch (bit) { - case GLSTATE_BLEND: - TOGGLEGLBIT(GLSTATE_BLEND, GL_BLEND); - break; - case GLSTATE_CULL: - TOGGLEGLBIT(GLSTATE_CULL, GL_CULL_FACE); - break; - case GLSTATE_TEXTURE0: - TOGGLEGLBIT(GLSTATE_TEXTURE0, GL_TEXTURE_2D); - break; - case GLSTATE_TEXTURE1: - TOGGLEGLBIT(GLSTATE_TEXTURE1, GL_TEXTURE_2D); - break; - case GLSTATE_TEXTURE2: - TOGGLEGLBIT(GLSTATE_TEXTURE2, GL_TEXTURE_2D); - break; - case GLSTATE_TEXTURE3: - TOGGLEGLBIT(GLSTATE_TEXTURE3, GL_TEXTURE_2D); - break; - default: - CON_Warnf("GL_SetState: unknown bit flag: %i\n", bit); - break; - } + switch(bit) { + case GLSTATE_BLEND: + TOGGLEGLBIT(GLSTATE_BLEND, GL_BLEND); + break; + case GLSTATE_CULL: + TOGGLEGLBIT(GLSTATE_CULL, GL_CULL_FACE); + break; + case GLSTATE_TEXTURE0: + TOGGLEGLBIT(GLSTATE_TEXTURE0, GL_TEXTURE_2D); + break; + case GLSTATE_TEXTURE1: + TOGGLEGLBIT(GLSTATE_TEXTURE1, GL_TEXTURE_2D); + break; + case GLSTATE_TEXTURE2: + TOGGLEGLBIT(GLSTATE_TEXTURE2, GL_TEXTURE_2D); + break; + case GLSTATE_TEXTURE3: + TOGGLEGLBIT(GLSTATE_TEXTURE3, GL_TEXTURE_2D); + break; + default: + CON_Warnf("GL_SetState: unknown bit flag: %i\n", bit); + break; + } #undef TOGGLEGLBIT } @@ -449,7 +487,12 @@ void GL_SetState(int bit, boolean enable) { // void GL_CheckFillMode(void) { - GL_SetState(GLSTATE_TEXTURE0, 1); + if(r_fillmode.value <= 0) { + GL_SetState(GLSTATE_TEXTURE0, 0); + } + else if(r_fillmode.value > 0) { + GL_SetState(GLSTATE_TEXTURE0, 1); + } } // @@ -457,13 +500,13 @@ void GL_CheckFillMode(void) { // void GL_ClearView(rcolor clearcolor) { - float f[4]; + float f[4]; - dglGetColorf(clearcolor, f); - dglClearColor(f[0], f[1], f[2], f[3]); - dglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight); - dglScissor(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight); + dglGetColorf(clearcolor, f); + dglClearColor(f[0], f[1], f[2], f[3]); + dglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight); + dglScissor(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight); } // @@ -471,10 +514,10 @@ void GL_ClearView(rcolor clearcolor) { // boolean GL_GetBool(int x) { - byte b; - dglGetBooleanv(x, &b); + byte b; + dglGetBooleanv(x, &b); - return (boolean)b; + return (boolean)b; } // @@ -482,79 +525,152 @@ boolean GL_GetBool(int x) { // static void CalcViewSize(void) { - ViewWidth = video_width; - ViewHeight = video_height; + ViewWidth = video_width; + ViewHeight = video_height; - widescreen = !dfcmp(((float)ViewWidth / (float)ViewHeight), (4.0f / 3.0f)); + widescreen = !dfcmp(((float)ViewWidth / (float)ViewHeight), (4.0f / 3.0f)); - ViewWindowX = (video_width - ViewWidth) / 2; + ViewWindowX = (video_width - ViewWidth) / 2; - if (ViewWidth == video_width) { - ViewWindowY = 0; - } - else { - ViewWindowY = (ViewHeight) / 2; - } + if(ViewWidth == video_width) { + ViewWindowY = 0; + } + else { + ViewWindowY = (ViewHeight) / 2; + } } // -void GL_Init(void) { - - gl_vendor = glGetString(GL_VENDOR); - I_Printf("GL_VENDOR: %s\n", gl_vendor); - gl_version = glGetString(GL_VERSION); - I_Printf("GL_VERSION: %s\n", gl_version); - glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max_texture_size); - I_Printf("GL_MAX_TEXTURE_SIZE: %i\n", gl_max_texture_size); - glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max_texture_units); - I_Printf("GL_MAX_TEXTURE_UNITS_ARB: %i\n", gl_max_texture_units); +// GetVersionInt +// Borrowed from prboom+ +// + +typedef enum { + OPENGL_VERSION_1_0, + OPENGL_VERSION_1_1, + OPENGL_VERSION_1_2, + OPENGL_VERSION_1_3, + OPENGL_VERSION_1_4, + OPENGL_VERSION_1_5, + OPENGL_VERSION_2_0, + OPENGL_VERSION_2_1, +} glversion_t; + +static int GetVersionInt(const char* version) { + int MajorVersion; + int MinorVersion; + int versionvar; + + versionvar = OPENGL_VERSION_1_0; + + if(sscanf(version, "%d.%d", &MajorVersion, &MinorVersion) == 2) { + if(MajorVersion > 1) { + versionvar = OPENGL_VERSION_2_0; + + if(MinorVersion > 0) { + versionvar = OPENGL_VERSION_2_1; + } + } + else { + versionvar = OPENGL_VERSION_1_0; + + if(MinorVersion > 0) { + versionvar = OPENGL_VERSION_1_1; + } + if(MinorVersion > 1) { + versionvar = OPENGL_VERSION_1_2; + } + if(MinorVersion > 2) { + versionvar = OPENGL_VERSION_1_3; + } + if(MinorVersion > 3) { + versionvar = OPENGL_VERSION_1_4; + } + if(MinorVersion > 4) { + versionvar = OPENGL_VERSION_1_5; + } + } + } - if (gl_max_texture_units <= 2) { - CON_Warnf("Not enough texture units supported...\n"); - } + return versionvar; +} - CalcViewSize(); +// +// GL_Init +// - dglViewport(0, 0, video_width, video_height); - dglClearDepth(1.0f); - dglDisable(GL_TEXTURE_2D); - dglEnable(GL_CULL_FACE); - dglCullFace(GL_FRONT); - dglShadeModel(GL_SMOOTH); - dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - dglDepthFunc(GL_LEQUAL); - dglAlphaFunc(GL_GEQUAL, ALPHACLEARGLOBAL); - dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - dglFogi(GL_FOG_MODE, GL_LINEAR); - dglHint(GL_FOG_HINT, GL_NICEST); - dglEnable(GL_SCISSOR_TEST); - dglEnable(GL_DITHER); +void GL_Init(void) { + gl_vendor = dglGetString(GL_VENDOR); + I_Printf("GL_VENDOR: %s\n", gl_vendor); + gl_renderer = dglGetString(GL_RENDERER); + I_Printf("GL_RENDERER: %s\n", gl_renderer); + gl_version = dglGetString(GL_VERSION); + I_Printf("GL_VERSION: %s\n", gl_version); + dglGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max_texture_size); + I_Printf("GL_MAX_TEXTURE_SIZE: %i\n", gl_max_texture_size); + dglGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max_texture_units); + I_Printf("GL_MAX_TEXTURE_UNITS_ARB: %i\n", gl_max_texture_units); + + if(gl_max_texture_units <= 2) { + CON_Warnf("Not enough texture units supported...\n"); + } - GL_SetTextureFilter(); - GL_SetDefaultCombiner(); + CalcViewSize(); + + dglViewport(0, 0, video_width, video_height); + dglClearDepth(1.0f); + dglDisable(GL_TEXTURE_2D); + dglEnable(GL_CULL_FACE); + dglCullFace(GL_FRONT); + dglShadeModel(GL_SMOOTH); + dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); + dglDepthFunc(GL_LEQUAL); + dglAlphaFunc(GL_GEQUAL, ALPHACLEARGLOBAL); + dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + dglFogi(GL_FOG_MODE, GL_LINEAR); + dglHint(GL_FOG_HINT, GL_NICEST); + dglEnable(GL_SCISSOR_TEST); + dglEnable(GL_DITHER); + + GL_SetTextureFilter(); + GL_SetDefaultCombiner(); + + r_fillmode.value = 1.0f; + + GL_ARB_multitexture_Init(); + //GL_EXT_compiled_vertex_array_Init(); + //GL_ARB_texture_non_power_of_two_Init(); + GL_ARB_texture_env_combine_Init(); + GL_EXT_texture_env_combine_Init(); + GL_EXT_texture_filter_anisotropic_Init(); + + if(!has_GL_ARB_multitexture) { + CON_Warnf("GL_ARB_multitexture not supported...\n"); + } - GL_ARB_multitexture_Init(); - GL_EXT_texture_filter_anisotropic_Init(); + gl_has_combiner = (has_GL_ARB_texture_env_combine | has_GL_EXT_texture_env_combine); - if (!GL_ARB_multitexture) { - CON_Warnf("GL_ARB_multitexture not supported...\n"); - } + if(!gl_has_combiner) { + CON_Warnf("Texture combiners not supported...\n"); + CON_Warnf("Setting r_texturecombiner to 0\n"); + CON_CvarSetValue(r_texturecombiner.name, 0.0f); + } - dglEnableClientState(GL_VERTEX_ARRAY); - dglEnableClientState(GL_TEXTURE_COORD_ARRAY); - dglEnableClientState(GL_COLOR_ARRAY); + dglEnableClientState(GL_VERTEX_ARRAY); + dglEnableClientState(GL_TEXTURE_COORD_ARRAY); + dglEnableClientState(GL_COLOR_ARRAY); - DGL_CLAMP = gl_version ? GL_CLAMP_TO_EDGE : GL_CLAMP; + DGL_CLAMP = (GetVersionInt(gl_version) >= OPENGL_VERSION_1_2 ? GL_CLAMP_TO_EDGE : GL_CLAMP); - glScaleFactor = 1.0f; + glScaleFactor = 1.0f; - if (GL_EXT_texture_filter_anisotropic) { - dglGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropic); - } + if(has_GL_EXT_texture_filter_anisotropic) { + dglGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropic); + } - usingGL = true; + usingGL = true; - G_AddCommand("dumpglext", CMD_DumpGLExtensions, 0); + G_AddCommand("dumpglext", CMD_DumpGLExtensions, 0); SDL_GL_SetSwapInterval((int)v_vsync.value); -} +} \ No newline at end of file diff --git a/src/engine/gl_main.h b/src/engine/gl_main.h index 6d8e1bd0..fa5cb66d 100644 --- a/src/engine/gl_main.h +++ b/src/engine/gl_main.h @@ -104,6 +104,7 @@ void GL_SetOrthoScale(float scale); float GL_GetOrthoScale(void); void GL_SetState(int bit, boolean enable); void GL_SetDefaultCombiner(void); +void GL_SetColorScale(void); void GL_Set2DQuad(vtx_t* v, float x, float y, int width, int height, float u1, float u2, float v1, float v2, rcolor c); void GL_Draw2DQuad(vtx_t* v, boolean stretch); diff --git a/src/engine/gl_texture.c b/src/engine/gl_texture.c index 4d0929f1..935b3a91 100644 --- a/src/engine/gl_texture.c +++ b/src/engine/gl_texture.c @@ -1,9 +1,8 @@ -// Emacs style mode select -*- C -*- +// Emacs style mode select -*- C++ -*- //----------------------------------------------------------------------------- // // Copyright(C) 2007-2012 Samuel Villarreal -// Copyright(C) 2022 André Gulherme -// +// // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation; either version 2 @@ -25,7 +24,6 @@ // //----------------------------------------------------------------------------- -#include "gl_shader.h" #include "doomstat.h" #include "r_local.h" #include "i_png.h" @@ -95,6 +93,17 @@ typedef struct { static gl_env_state_t gl_env_state[GL_MAX_TEX_UNITS]; static int curunit = -1; +CVAR_EXTERNAL(r_fillmode); +CVAR_CMD(r_texturecombiner, 1) { + int i; + + curunit = -1; + + for (i = 0; i < GL_MAX_TEX_UNITS; i++) { + dmemset(&gl_env_state[i], 0, sizeof(gl_env_state_t)); + } +} + // // CMD_DumpTextures // @@ -166,6 +175,10 @@ void GL_BindWorldTexture(int texnum, int* width, int* height) { int w; int h; + if (r_fillmode.value <= 0) { + return; + } + // get translation index texnum = texturetranslation[texnum]; @@ -197,8 +210,6 @@ void GL_BindWorldTexture(int texnum, int* width, int* height) { png = I_PNGReadData(t_start + texnum, false, true, true, &w, &h, NULL, palettetranslation[texnum]); - //GL_LoadShader("GLSL/D64EXPLUS.vert", "GLSL/D64EXPLUS.frag"); - crashes - dglGenTextures(1, &textureptr[texnum][palettetranslation[texnum]]); dglBindTexture(GL_TEXTURE_2D, textureptr[texnum][palettetranslation[texnum]]); dglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, png); @@ -230,6 +241,7 @@ void GL_BindWorldTexture(int texnum, int* width, int* height) { // // GL_SetNewPalette // + void GL_SetNewPalette(int id, byte palID) { palettetranslation[id] = palID; /*if(textureptr[id]) @@ -271,10 +283,10 @@ static void InitGfxTextures(void) { g_end = W_GetNumForName("MOUNTC"); numgfx = (g_end - g_start) + 1; gfxptr = Z_Calloc(numgfx * sizeof(dtexture), PU_STATIC, NULL); - gfxwidth = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL); - gfxorigwidth = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL); - gfxheight = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL); - gfxorigheight = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL); + gfxwidth = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL); + gfxorigwidth = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL); + gfxheight = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL); + gfxorigheight = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL); for (i = 0; i < numgfx; i++) { byte* png; @@ -401,7 +413,7 @@ static void InitSpriteTextures(void) { byte* png; int w; int h; - unsigned int x; + size_t x; // allocate # of sprites per pointer spriteptr[i] = (dtexture*)Z_Malloc(spritecount[i] * sizeof(dtexture), PU_STATIC, 0); @@ -432,6 +444,10 @@ void GL_BindSpriteTexture(int spritenum, int pal) { int w; int h; + if (r_fillmode.value <= 0) { + return; + } + if ((spritenum == cursprite) && (pal == curtrans)) { return; } @@ -561,6 +577,10 @@ static dtexture envtexture = 0; void GL_BindEnvTexture(void) { rcolor rgb[16]; + if (r_fillmode.value <= 0) { + return; + } + dmemset(rgb, 0xff, sizeof(rcolor) * 16); if (envtexture == 0) { @@ -594,6 +614,10 @@ void GL_UpdateEnvTexture(rcolor color) { return; } + if (r_fillmode.value <= 0) { + return; + } + if (lastenvcolor == color) { return; } @@ -648,6 +672,10 @@ void GL_SetTextureUnit(int unit, boolean enable) { return; } + if (r_fillmode.value <= 0) { + return; + } + if (unit > 3) { return; } @@ -679,6 +707,40 @@ void GL_SetTextureMode(int mode) { dglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, state->mode); } +// +// GL_SetCombineState +// + +void GL_SetCombineState(int combine) { + gl_env_state_t* state; + + state = &gl_env_state[curunit]; + + if (state->combine_rgb == combine) { + return; + } + + state->combine_rgb = combine; + dglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, state->combine_rgb); +} + +// +// GL_SetCombineStateAlpha +// + +void GL_SetCombineStateAlpha(int combine) { + gl_env_state_t* state; + + state = &gl_env_state[curunit]; + + if (state->combine_alpha == combine) { + return; + } + + state->combine_alpha = combine; + dglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, state->combine_alpha); +} + // // GL_SetEnvColor // @@ -856,4 +918,4 @@ void GL_DumpTextures(void) { void GL_ResetTextures(void) { curtexture = cursprite = curgfx = -1; -} +} \ No newline at end of file diff --git a/src/engine/gl_texture.h b/src/engine/gl_texture.h index 98b67b47..493dec62 100644 --- a/src/engine/gl_texture.h +++ b/src/engine/gl_texture.h @@ -63,6 +63,8 @@ void GL_InitTextures(void); void GL_UnloadTexture(dtexture* texture); void GL_SetTextureUnit(int unit, boolean enable); void GL_SetTextureMode(int mode); +void GL_SetCombineState(int combine); +void GL_SetCombineStateAlpha(int combine); void GL_SetEnvColor(float* param); void GL_SetCombineSourceRGB(int source, int target); void GL_SetCombineSourceAlpha(int source, int target); diff --git a/src/engine/r_bsp.c b/src/engine/r_bsp.c index d61f0ad0..5fc7c4ed 100644 --- a/src/engine/r_bsp.c +++ b/src/engine/r_bsp.c @@ -49,6 +49,7 @@ static void R_AddLine(seg_t* line); static void AddSegToDrawlist(drawlist_t* dl, seg_t* line, int texid, int sidetype); CVAR_EXTERNAL(i_interpolateframes); +CVAR_EXTERNAL(r_texturecombiner); // // R_AddClipLine diff --git a/src/engine/r_drawlist.c b/src/engine/r_drawlist.c index 652ba36d..fb56adef 100644 --- a/src/engine/r_drawlist.c +++ b/src/engine/r_drawlist.c @@ -41,6 +41,8 @@ static float envcolor[4] = { 0, 0, 0, 0 }; drawlist_t drawlist[NUMDRAWLISTS]; +CVAR_EXTERNAL(r_texturecombiner); + // // DL_AddVertexList // @@ -186,11 +188,18 @@ void DL_ProcessDrawList(int tag, boolean(*procfunc)(vtxlist_t*, int*)) { dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, head->flags & DLF_MIRRORT ? GL_MIRRORED_REPEAT : GL_REPEAT); } + + if(r_texturecombiner.value > 0) { + envcolor[0] = envcolor[1] = envcolor[2] = ((float)head->params / 255.0f); + GL_SetEnvColor(envcolor); + } + else { + int l = (head->params >> 1); - int l = (head->params >> 1); + GL_UpdateEnvTexture(D_RGBA(l, l, l, 0xff)); + } - GL_UpdateEnvTexture(D_RGBA(l, l, l, 0xff)); - dglDrawGeometry(drawcount, drawVertex); + dglDrawGeometry(drawcount, drawVertex); // count vertex size if (devparm) { @@ -228,9 +237,14 @@ int DL_GetDrawListSize(int tag) { // DL_BeginDrawList // -void DL_BeginDrawList(boolean t) { - dglSetVertex(drawVertex); - GL_SetTextureUnit(0, t); +void DL_BeginDrawList(boolean t, boolean a) { + dglSetVertex(drawVertex); + + GL_SetTextureUnit(0, t); + + if(a) { + dglTexCombColorf(GL_TEXTURE0_ARB, envcolor, GL_ADD); + } } // diff --git a/src/engine/r_drawlist.h b/src/engine/r_drawlist.h index 82e8b95e..90221f1b 100644 --- a/src/engine/r_drawlist.h +++ b/src/engine/r_drawlist.h @@ -70,7 +70,7 @@ boolean DL_ProcessSprites(vtxlist_t* vl, int* drawcount); vtxlist_t* DL_AddVertexList(drawlist_t* dl); int DL_GetDrawListSize(int tag); -void DL_BeginDrawList(boolean t); +void DL_BeginDrawList(boolean t, boolean a); void DL_ProcessDrawList(int tag, boolean(*procfunc)(vtxlist_t*, int*)); void DL_RenderDrawList(void); void DL_Init(void); diff --git a/src/engine/r_lights.c b/src/engine/r_lights.c index 48cc6f5e..4b0cef1c 100644 --- a/src/engine/r_lights.c +++ b/src/engine/r_lights.c @@ -39,6 +39,8 @@ CVAR_CMD(i_brightness, 100) { R_RefreshBrightness(); } +CVAR_EXTERNAL(r_texturecombiner); + // // R_LightToVertex // diff --git a/src/engine/r_main.c b/src/engine/r_main.c index 48a8095c..d1d3c81c 100644 --- a/src/engine/r_main.c +++ b/src/engine/r_main.c @@ -81,12 +81,18 @@ unsigned int glBindCalls = 0; boolean bRenderSky = false; CVAR(r_fov, 74.0); +CVAR(r_fillmode, 1); CVAR(r_fog, 1); CVAR(r_wipe, 1); CVAR(r_drawmobjbox, 0); +CVAR(r_rendersprites, 1); CVAR(r_skybox, 0); CVAR(hud_disablesecretmessages, 0); +CVAR_CMD(r_colorscale, 0) { + GL_SetColorScale(); +} + CVAR_CMD(r_filter, 0) { GL_DumpTextures(); GL_SetTextureFilter(); @@ -97,6 +103,7 @@ CVAR_CMD(r_anisotropic, 0) { GL_SetTextureFilter(); } +CVAR_EXTERNAL(r_texturecombiner); CVAR_EXTERNAL(i_interpolateframes); CVAR_EXTERNAL(p_usecontext); @@ -681,6 +688,10 @@ static void R_DrawContextWall(line_t* line) { void R_RenderPlayerView(player_t* player) { + if(!r_fillmode.value) { + dglPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + } + if (devparm) { renderTic = I_GetTimeMS(); } @@ -781,11 +792,15 @@ void R_RenderPlayerView(player_t* player) { void R_RegisterCvars(void) { CON_CvarRegister(&r_fov); + CON_CvarRegister(&r_fillmode); CON_CvarRegister(&r_fog); CON_CvarRegister(&r_filter); CON_CvarRegister(&r_anisotropic); CON_CvarRegister(&r_wipe); CON_CvarRegister(&r_drawmobjbox); + CON_CvarRegister(&r_rendersprites); CON_CvarRegister(&r_skybox); + CON_CvarRegister(&r_colorscale); + CON_CvarRegister(&r_texturecombiner); CON_CvarRegister(&hud_disablesecretmessages); } diff --git a/src/engine/r_main.h b/src/engine/r_main.h index e4e5f73c..930aebcc 100644 --- a/src/engine/r_main.h +++ b/src/engine/r_main.h @@ -59,6 +59,7 @@ extern unsigned int glBindCalls; extern boolean bRenderSky; CVAR_EXTERNAL(r_fov); +CVAR_EXTERNAL(r_fillmode); void R_Init(void); void R_RenderPlayerView(player_t* player); diff --git a/src/engine/r_scene.c b/src/engine/r_scene.c index 65b59def..ece679be 100644 --- a/src/engine/r_scene.c +++ b/src/engine/r_scene.c @@ -32,8 +32,10 @@ #include "r_sky.h" #include "r_drawlist.h" +CVAR_EXTERNAL(r_texturecombiner); CVAR_EXTERNAL(i_interpolateframes); CVAR_EXTERNAL(r_fog); +CVAR_EXTERNAL(r_rendersprites); CVAR_EXTERNAL(st_flashoverlay); // @@ -208,6 +210,11 @@ static boolean ProcessSprites(vtxlist_t* vl, int* drawcount) { static void SetupFog(void) { dglFogi(GL_FOG_MODE, GL_LINEAR); + // don't render fog in wireframe mode + if(r_fillmode.value <= 0) { + return; + } + if (!skyflatnum) { dglDisable(GL_FOG); } @@ -286,59 +293,77 @@ void R_SetViewMatrix(void) { // void R_RenderWorld(void) { - SetupFog(); + SetupFog(); - dglEnable(GL_DEPTH_TEST); + dglEnable(GL_DEPTH_TEST); - DL_BeginDrawList(1); + DL_BeginDrawList(r_fillmode.value >= 1, r_texturecombiner.value >= 1); - // setup texture environment for effects + // setup texture environment for effects + if(r_texturecombiner.value) { + if(!nolights) { + GL_UpdateEnvTexture(WHITE); + GL_SetTextureUnit(1, true); + dglTexCombModulate(GL_PREVIOUS, GL_PRIMARY_COLOR); + } - GL_SetTextureUnit(1, true); - GL_SetTextureMode(GL_ADD); - GL_SetTextureUnit(0, true); + if(st_flashoverlay.value <= 0) { + GL_SetTextureUnit(2, true); + dglTexCombColor(GL_PREVIOUS, flashcolor, GL_ADD); + } - if (nolights) - { - GL_SetTextureMode(GL_REPLACE); - } + dglTexCombReplaceAlpha(GL_TEXTURE0_ARB); - dglEnable(GL_ALPHA_TEST); + GL_SetTextureUnit(0, true); + } + else { + GL_SetTextureUnit(1, true); + GL_SetTextureMode(GL_ADD); + GL_SetTextureUnit(0, true); - // begin draw list loop + if(nolights) { + GL_SetTextureMode(GL_REPLACE); + } + } - // -------------- Draw walls (segs) -------------------------- + dglEnable(GL_ALPHA_TEST); - DL_ProcessDrawList(DLT_WALL, ProcessWalls); + // begin draw list loop - // -------------- Draw floors/ceilings (leafs) --------------- + // -------------- Draw walls (segs) -------------------------- - GL_SetState(GLSTATE_BLEND, 1); - DL_ProcessDrawList(DLT_FLAT, ProcessFlats); + DL_ProcessDrawList(DLT_WALL, ProcessWalls); - // -------------- Draw things (sprites) ---------------------- + // -------------- Draw floors/ceilings (leafs) --------------- - if (devparm) { - spriteRenderTic = I_GetTimeMS(); - } + GL_SetState(GLSTATE_BLEND, 1); + DL_ProcessDrawList(DLT_FLAT, ProcessFlats); + + // -------------- Draw things (sprites) ---------------------- + + if(devparm) { + spriteRenderTic = I_GetTimeMS(); + } - R_SetupSprites(); + if(r_rendersprites.value) { + R_SetupSprites(); + } - dglDepthMask(GL_FALSE); - DL_ProcessDrawList(DLT_SPRITE, ProcessSprites); + dglDepthMask(GL_FALSE); + DL_ProcessDrawList(DLT_SPRITE, ProcessSprites); - // -------------- Restore states ----------------------------- + // -------------- Restore states ----------------------------- - dglDisable(GL_ALPHA_TEST); - dglDepthMask(GL_TRUE); - dglDisable(GL_FOG); - dglDisable(GL_DEPTH_TEST); + dglDisable(GL_ALPHA_TEST); + dglDepthMask(GL_TRUE); + dglDisable(GL_FOG); + dglDisable(GL_DEPTH_TEST); - GL_SetOrthoScale(1.0f); - GL_SetState(GLSTATE_BLEND, 0); - GL_SetState(GLSTATE_CULL, 1); - GL_SetDefaultCombiner(); + GL_SetOrthoScale(1.0f); + GL_SetState(GLSTATE_BLEND, 0); + GL_SetState(GLSTATE_CULL, 1); + GL_SetDefaultCombiner(); - // villsa 12152013 - make sure we're using the default blend function - dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + // villsa 12152013 - make sure we're using the default blend function + dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } diff --git a/src/engine/r_sky.c b/src/engine/r_sky.c index 07792b3c..34bb93fa 100644 --- a/src/engine/r_sky.c +++ b/src/engine/r_sky.c @@ -64,6 +64,7 @@ static float sky_cloudpan2 = 0; #define FIRESKY_WIDTH 64 #define FIRESKY_HEIGHT 64 +CVAR_EXTERNAL(r_texturecombiner); CVAR_EXTERNAL(r_skybox); #define SKYVIEWPOS(angle, amount, x) x = -(angle / (float)ANG90 * amount); while(x < 1.0f) x += 1.0f @@ -494,64 +495,83 @@ static void R_DrawTitleSky(void) { // static void R_DrawClouds(void) { - rfloat pos = 0.0f; - vtx_t v[4]; - - GL_SetTextureUnit(0, true); - GL_BindGfxTexture(lumpinfo[skypicnum].name, false); - - pos = (TRUEANGLES(viewangle) / 360.0f) * 2.0f; - - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - - dglSetVertex(v); - - GL_Set2DQuad(v, 0, 0, SCREENWIDTH, 120, 0, 0, 0, 0, 0); - dglSetVertexColor(&v[0], sky->skycolor[0], 2); - dglSetVertexColor(&v[2], sky->skycolor[1], 2); - - glDisable(GL_TEXTURE_2D); - - GL_Draw2DQuad(v, true); - - glEnable(GL_TEXTURE_2D); - - GL_SetTextureUnit(1, true); - GL_SetTextureMode(GL_ADD); - GL_UpdateEnvTexture(sky->skycolor[1]); - GL_SetTextureUnit(0, true); - - dglSetVertexColor(&v[0], sky->skycolor[2], 4); - v[0].a = v[1].a = v[2].a = v[3].a = 0x60; - - v[3].x = v[1].x = 1.1025f; - v[0].x = v[2].x = -1.1025f; - v[2].y = v[3].y = 0; - v[0].y = v[1].y = 0.4315f; - v[0].z = v[1].z = 0; - v[2].z = v[3].z = -1.0f; - v[0].tu = v[2].tu = F2D3D(CloudOffsetX) - pos; - v[1].tu = v[3].tu = (F2D3D(CloudOffsetX) + 1.5f) - pos; - v[0].tv = v[1].tv = F2D3D(CloudOffsetY); - v[2].tv = v[3].tv = F2D3D(CloudOffsetY) + 2.0f; - - GL_SetOrthoScale(1.0f); // force ortho mode to be set - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - dglViewFrustum(SCREENWIDTH, SCREENHEIGHT, 45.0f, 0.1f); - glMatrixMode(GL_MODELVIEW); - glEnable(GL_ALPHA); - glPushMatrix(); - glTranslated(0.0f, 0.0f, -1.0f); - RB_AddTriangle(0, 1, 2); - RB_AddTriangle(3, 2, 1); - dglDrawGeometry(4, v); - glPopMatrix(); - glDisable(GL_ALPHA); - - GL_SetDefaultCombiner(); + rfloat pos = 0.0f; + vtx_t v[4]; + + GL_SetTextureUnit(0, true); + GL_BindGfxTexture(lumpinfo[skypicnum].name, false); + + pos = (TRUEANGLES(viewangle) / 360.0f) * 2.0f; + + dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + dglSetVertex(v); + + if(r_texturecombiner.value > 0 && gl_max_texture_units > 2) { + dglSetVertexColor(&v[0], sky->skycolor[0], 2); + dglSetVertexColor(&v[2], sky->skycolor[1], 2); + + GL_UpdateEnvTexture(WHITE); + + // pass 1: texture * skycolor + dglTexCombColor(GL_TEXTURE, sky->skycolor[2], GL_MODULATE); + + // pass 2: result * const (though the original game uses the texture's alpha) + GL_SetTextureUnit(1, true); + dglTexCombColor(GL_PREVIOUS, 0xFF909090, GL_MODULATE); + + // pass 3: result + fragment color + GL_SetTextureUnit(2, true); + dglTexCombAdd(GL_PREVIOUS, GL_PRIMARY_COLOR); + } + else { + GL_Set2DQuad(v, 0, 0, SCREENWIDTH, 120, 0, 0, 0, 0, 0); + dglSetVertexColor(&v[0], sky->skycolor[0], 2); + dglSetVertexColor(&v[2], sky->skycolor[1], 2); + + dglDisable(GL_TEXTURE_2D); + + GL_Draw2DQuad(v, true); + + dglEnable(GL_TEXTURE_2D); + + GL_SetTextureUnit(1, true); + GL_SetTextureMode(GL_ADD); + GL_UpdateEnvTexture(sky->skycolor[1]); + GL_SetTextureUnit(0, true); + + dglSetVertexColor(&v[0], sky->skycolor[2], 4); + v[0].a = v[1].a = v[2].a = v[3].a = 0x60; + } + + v[3].x = v[1].x = 1.1025f; + v[0].x = v[2].x = -1.1025f; + v[2].y = v[3].y = 0; + v[0].y = v[1].y = 0.4315f; + v[0].z = v[1].z = 0; + v[2].z = v[3].z = -1.0f; + v[0].tu = v[2].tu = F2D3D(CloudOffsetX) - pos; + v[1].tu = v[3].tu = (F2D3D(CloudOffsetX) + 1.5f) - pos; + v[0].tv = v[1].tv = F2D3D(CloudOffsetY); + v[2].tv = v[3].tv = F2D3D(CloudOffsetY) + 2.0f; + + GL_SetOrthoScale(1.0f); // force ortho mode to be set + + dglMatrixMode(GL_PROJECTION); + dglLoadIdentity(); + dglViewFrustum(SCREENWIDTH, SCREENHEIGHT, 45.0f, 0.1f); + dglMatrixMode(GL_MODELVIEW); + dglEnable(GL_BLEND); + dglPushMatrix(); + dglTranslated(0.0f, 0.0f, -1.0f); + RB_AddTriangle(0, 1, 2); + RB_AddTriangle(3, 2, 1); + dglDrawGeometry(4, v); + dglPopMatrix(); + dglDisable(GL_BLEND); + + GL_SetDefaultCombiner(); } // diff --git a/src/engine/r_things.c b/src/engine/r_things.c index 6a7376b5..4b614263 100644 --- a/src/engine/r_things.c +++ b/src/engine/r_things.c @@ -55,9 +55,11 @@ char* spritename; static visspritelist_t visspritelist[MAX_SPRITES]; static visspritelist_t* vissprite = NULL; +CVAR_EXTERNAL(r_texturecombiner); CVAR_EXTERNAL(st_flashoverlay); CVAR_EXTERNAL(i_interpolateframes); CVAR_EXTERNAL(v_accessibility); +CVAR_EXTERNAL(r_rendersprites); static void AddSpriteDrawlist(drawlist_t* dl, visspritelist_t* vis, int texid); @@ -638,20 +640,43 @@ void R_DrawPSprite(pspdef_t* psp, sector_t* sector, player_t* player) { GL_SetTextureUnit(0, true); GL_CheckFillMode(); - // - // setup texture environment for effects - // - int lightlevel = (sector->lightlevel + 64); // haleyjd: slightly brighter + // + // setup texture environment for effects + // + if(r_texturecombiner.value) { + float f[4]; - if (lightlevel > 0xff) - { - GL_SetTextureMode(GL_BLEND); - } + f[0] = f[1] = f[2] = ((float)sector->lightlevel / 255.0f); - if (nolights) - { - GL_SetTextureMode(GL_REPLACE); - } + dglTexCombColorf(GL_TEXTURE0_ARB, f, GL_ADD); + + if(!nolights) { + GL_UpdateEnvTexture(WHITE); + GL_SetTextureUnit(1, true); + dglTexCombModulate(GL_PREVIOUS, GL_PRIMARY_COLOR); + } + + if(st_flashoverlay.value <= 0) { + GL_SetTextureUnit(2, true); + dglTexCombColor(GL_PREVIOUS, flashcolor, GL_ADD); + } + + dglTexCombReplaceAlpha(GL_TEXTURE0_ARB); + + GL_SetTextureUnit(0, true); + } + else { + int l = (sector->lightlevel >> 1); + + GL_SetTextureUnit(1, true); + GL_SetTextureMode(GL_ADD); + GL_UpdateEnvTexture(D_RGBA(l, l, l, 0xff)); + GL_SetTextureUnit(0, true); + + if(nolights) { + GL_SetTextureMode(GL_REPLACE); + } + } // render dglSetVertex(v); diff --git a/src/engine/st_stuff.c b/src/engine/st_stuff.c index c448ff3b..b26e77a0 100644 --- a/src/engine/st_stuff.c +++ b/src/engine/st_stuff.c @@ -70,6 +70,7 @@ CVAR(st_hud_color, 0); CVAR_EXTERNAL(p_usecontext); CVAR_EXTERNAL(p_damageindicator); CVAR_EXTERNAL(v_accessibility); +CVAR_EXTERNAL(r_texturecombiner); // // STATUS BAR DATA @@ -742,11 +743,11 @@ void ST_Drawer(void) { // flash overlay // - if ((st_flashoverlay.value || - gl_max_texture_units <= 2 || - flashcolor)) { - ST_FlashingScreen(st_flash_r, st_flash_g, st_flash_b, st_flash_a); - } + if((st_flashoverlay.value || + gl_max_texture_units <= 2 || + r_texturecombiner.value <= 0) && flashcolor) { + ST_FlashingScreen(st_flash_r, st_flash_g, st_flash_b, st_flash_a); + } if (iwadDemo) { return;