From ecab3830789daa673e156f4f182a413a09b9286d Mon Sep 17 00:00:00 2001 From: Alug Date: Thu, 12 Nov 2026 20:32:38 +0100 Subject: [PATCH] gl: use shaders for underwater / heatwave effect basically ported over from RR water was massively toned down and adjusted, it visually almost matches software at default res (note that the software effects are not properly scaled lol) the heat effect is just the water effect adjusted to look like the fixed function version from before but slightly slower to accomidate the slower water effect here this should speed things up a little since we now only need ONE draw call instead of 20 per effect small note: this does not zoom into the image like the shaderless version, which was quite jarring tbh but there can be some very slight "stretch" marks at screen border, but theyre extremely unnoticable --- src/hardware/hw_defs.h | 4 ++ src/hardware/hw_gl.h | 1 + src/hardware/hw_main.cpp | 73 +++++++++++++++++++------------- src/hardware/hw_shaders.c | 9 ++++ src/hardware/hw_shaders.h | 66 +++++++++++++++++++++++++++++ src/hardware/r_opengl/r_opengl.c | 63 ++++++++++++++++++++++++++- 6 files changed, 186 insertions(+), 30 deletions(-) diff --git a/src/hardware/hw_defs.h b/src/hardware/hw_defs.h index ed4bff5a2..d225bddcd 100644 --- a/src/hardware/hw_defs.h +++ b/src/hardware/hw_defs.h @@ -196,6 +196,10 @@ enum SHADER_PALETTE_POSTPROCESS, SHADER_UI_COLORMAP_FADE, + SHADER_POSTPROCESS_WATER, + SHADER_POSTPROCESS_HEAT, + + NUMSHADERTARGETS }; diff --git a/src/hardware/hw_gl.h b/src/hardware/hw_gl.h index b808ed09a..c48338350 100644 --- a/src/hardware/hw_gl.h +++ b/src/hardware/hw_gl.h @@ -70,6 +70,7 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height); void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]); +void GL_DoPostProcessor(INT32 type); boolean GL_InitShaders(void); void GL_LoadShader(int slot, char *code, hwdshaderstage_t stage); diff --git a/src/hardware/hw_main.cpp b/src/hardware/hw_main.cpp index 5f7e6838f..1ca4856d2 100644 --- a/src/hardware/hw_main.cpp +++ b/src/hardware/hw_main.cpp @@ -5992,8 +5992,7 @@ void HWR_RenderPlayerView(void) if (HWR_UseShader()) { - if (cv_ripplewater.value) - GL_SetShaderInfo(HWD_SHADERINFO_LEVELTIME, (INT32)leveltime); // The water surface shader needs the leveltime. + GL_SetShaderInfo(HWD_SHADERINFO_LEVELTIME, (INT32)leveltime); // The water surface shader needs the leveltime. if (cv_glmdls.value) { @@ -6002,7 +6001,7 @@ void HWR_RenderPlayerView(void) const angle_t light_angle = maplighting.angle - viewangle + ANGLE_90; // I fucking hate OGL's coordinate system GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_X, FINECOSINE(light_angle >> ANGLETOFINESHIFT)); GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_Y, 0); - GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_Z, -FINESINE(light_angle >> ANGLETOFINESHIFT)); + GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_Z, -FINESINE(light_angle >> ANGLETOFINESHIFT)); } GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_CONTRAST, maplighting.contrast); @@ -6352,42 +6351,58 @@ static void HWR_DoPostProcessor(void) GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1); // Drunken vision! WooOOooo~ - // 10 by 10 grid. 2 coordinates (xy) - float v[SCREENVERTS][SCREENVERTS][2]; - float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL)); - UINT8 x, y; - float WAVELENGTH; - float AMPLITUDE; - float FREQUENCY; - - // Modifies the wave. - if (thiscam->postimg & POSTIMG_WATER) + // shader based, should be a bit faster! + if (HWR_UseShader()) { - WAVELENGTH = 5.0f; - AMPLITUDE = 40.0f; - FREQUENCY = 8.0f; + if (thiscam->postimg & POSTIMG_WATER) + { + GL_DoPostProcessor(POSTIMG_WATER); + } + else if (thiscam->postimg & POSTIMG_HEAT) + { + GL_DoPostProcessor(POSTIMG_HEAT); + } } else { - WAVELENGTH = 10.0f; - AMPLITUDE = 60.0f; - FREQUENCY = 4.0f; - } + // 10 by 10 grid. 2 coordinates (xy) + float v[SCREENVERTS][SCREENVERTS][2]; + float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL)); - //static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek + UINT8 x, y; + float WAVELENGTH; + float AMPLITUDE; + float FREQUENCY; - for (x = 0; x < SCREENVERTS; x++) - { - for (y = 0; y < SCREENVERTS; y++) + // Modifies the wave. + if (thiscam->postimg & POSTIMG_WATER) { - // Change X position based on its Y position. - v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale) - v[x][y][1] = y-4.5f; // (y / scale) + WAVELENGTH = 5.0f; + AMPLITUDE = 40.0f; + FREQUENCY = 8.0f; + } + else + { + WAVELENGTH = 10.0f; + AMPLITUDE = 60.0f; + FREQUENCY = 4.0f; } - } - GL_PostImgRedraw(v); + //static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek + + for (x = 0; x < SCREENVERTS; x++) + { + for (y = 0; y < SCREENVERTS; y++) + { + // Change X position based on its Y position. + v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale) + v[x][y][1] = y-4.5f; // (y / scale) + } + } + + GL_PostImgRedraw(v); + } // Capture the screen again for screen waving on the intermission if (gamestate != GS_INTERMISSION) diff --git a/src/hardware/hw_shaders.c b/src/hardware/hw_shaders.c index 31723eab1..2bbd635ad 100644 --- a/src/hardware/hw_shaders.c +++ b/src/hardware/hw_shaders.c @@ -53,6 +53,13 @@ static struct { // UI colormap fade shader {GLSL_DEFAULT_VERTEX_SHADER, GLSL_UI_COLORMAP_FADE_FRAGMENT_SHADER}, + // water postprocess shader + {GLSL_DEFAULT_VERTEX_SHADER, GLSL_POSTPROCESS_FRAGMENT_WATER}, + + // heat postprocess shader + {GLSL_DEFAULT_VERTEX_SHADER, GLSL_POSTPROCESS_FRAGMENT_HEAT}, + + {NULL, NULL}, }; @@ -444,6 +451,8 @@ customshaderxlat_t shaderxlat[] = {"Sky", SHADER_SKY}, {"PalettePostprocess", SHADER_PALETTE_POSTPROCESS}, {"UIColormapFade", SHADER_UI_COLORMAP_FADE}, + {"PostProcessWater", SHADER_POSTPROCESS_WATER}, + {"PostProcessHeat", SHADER_POSTPROCESS_HEAT}, {NULL, 0}, }; diff --git a/src/hardware/hw_shaders.h b/src/hardware/hw_shaders.h index 51c0ec001..86ddd8cb7 100644 --- a/src/hardware/hw_shaders.h +++ b/src/hardware/hw_shaders.h @@ -337,6 +337,72 @@ "gl_FragColor = texture2D(lighttable_tex, lighttable_coord);\n" \ "}\0" \ +// these are RRs postprocess shaders +// for water and heat +/* +#define GLSL_POSTPROCESS_FRAGMENT_WATER \ + "uniform sampler2D tex;\n" \ + "uniform float leveltime;\n" \ + "void main(void) {\n" \ + "vec2 uv = gl_TexCoord[0].st;\n" \ + "float y = 1.0 - uv.y;\n" \ + "uv.x += sin(leveltime * 2.0 + y * 20.0) * 0.01;\n" \ + "uv = clamp(uv, vec2(0.0), vec2(0.9999));\n" \ + "gl_FragColor = texture2D(tex, uv);\n" \ + "}\0" + +#define GLSL_POSTPROCESS_FRAGMENT_HEAT \ + "uniform sampler2D tex;\n" \ + "uniform float leveltime;\n" \ + "void main(void) {\n" \ + "vec2 uv = gl_TexCoord[0].st;\n" \ + "float y = 1.0 - uv.y;\n" \ + "float time = leveltime * 35.0;\n" \ + "uv.x += max(sin((time / 35.0) * 1.2 - y * 5.0) - 0.995, 0.0);\n" \ + "uv.x -= max(sin(((time + 24.0) / 35.0) * 0.2 - y * 1.5) - 0.990, 0.0);\n" \ + "uv = clamp(uv, vec2(0.0), vec2(0.9999));\n" \ + "gl_FragColor = texture2D(tex, uv);\n" \ + "}\0" +*/ + +// for reference +// sin(leveltime * X + (y) + Y) * Z +// X = Speed, Y = Vertical phase, Z = Amplitude + +// this matches software at 720p wonderfully +#define GLSL_POSTPROCESS_FRAGMENT_WATER \ + "#version 120\n" \ + "uniform sampler2D tex;\n" \ + "uniform vec2 scr_resolution;\n" \ + "uniform vec2 scr_tex_size;\n" \ + "uniform float leveltime;\n" \ + "void main(void) {\n" \ + "vec2 uv = gl_TexCoord[0].st;\n" \ + "vec2 maxuv = scr_resolution / scr_tex_size;\n" \ + "float y = 1.0 - uv.y;\n" \ + "uv.x += sin(leveltime * 3.0 + y * 15.0) * 0.0025;\n" \ + "uv = clamp(uv, vec2(0.0), maxuv - vec2(0.0001));\n" \ + "gl_FragColor = texture2D(tex, uv);\n" \ + "}\0" + +// like the fixed function version, this is just the water wave again +// a bit readjusted since the shader wave is more lean +// makes it less neausiating anyways :p +#define GLSL_POSTPROCESS_FRAGMENT_HEAT \ + "#version 120\n" \ + "uniform sampler2D tex;\n" \ + "uniform vec2 scr_resolution;\n" \ + "uniform vec2 scr_tex_size;\n" \ + "uniform float leveltime;\n" \ + "void main(void) {\n" \ + "vec2 uv = gl_TexCoord[0].st;\n" \ + "vec2 maxuv = scr_resolution / scr_tex_size;\n" \ + "float y = 1.0 - uv.y;\n" \ + "uv.x += sin(leveltime * 6.0 + y * 22.5) * 0.00125;\n" \ + "uv = clamp(uv, vec2(0.0), maxuv - vec2(0.0001));\n" \ + "gl_FragColor = texture2D(tex, uv);\n" \ + "}\0" + // ================ // Fallback shaders // ================ diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c index dd6252ce7..48a6b3ab3 100644 --- a/src/hardware/r_opengl/r_opengl.c +++ b/src/hardware/r_opengl/r_opengl.c @@ -761,6 +761,10 @@ typedef enum gluniform_scr_resolution, + // postprocess stuff + gluniform_scr_dup, + gluniform_scr_tex_size, + gluniform_max, } gluniform_t; @@ -2329,6 +2333,10 @@ static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRG UNIFORM_1(shader->uniforms[gluniform_leveltime], shader_leveltime, pglUniform1f); UNIFORM_2(shader->uniforms[gluniform_scr_resolution], (GLfloat)screen_width, (GLfloat)screen_height, pglUniform2f); + // udup is before highres scale adjustments + UNIFORM_1(shader->uniforms[gluniform_scr_dup], (GLfloat)vid.udup, pglUniform1f); + // grrrrr stupid 2.0 support.. used similar to yfix, xfix + UNIFORM_2(shader->uniforms[gluniform_scr_tex_size], (GLfloat)screen_texsizew, (GLfloat)screen_texsizeh, pglUniform2f); #undef UNIFORM_1 #undef UNIFORM_2 @@ -2461,6 +2469,11 @@ static boolean GL_Shader_CompileProgram(gl_shader_t *shader, GLint i) // misc. shader->uniforms[gluniform_leveltime] = GETUNI("leveltime"); + + // postprocessor stuff (water/heat effect) + shader->uniforms[gluniform_scr_dup] = GETUNI("scr_dup"); + shader->uniforms[gluniform_scr_tex_size] = GETUNI("scr_tex_size"); + #undef GETUNI // set permanent uniform values @@ -3597,6 +3610,55 @@ INT32 GL_GetTextureUsed(void) return res; } +void GL_DoPostProcessor(INT32 type) +{ + float fix[8]; + float xfix, yfix; + + if (gl_enable_screen_textures != 2) + return; + + xfix = 1/((float)screen_texsizew/(float)screen_width); + yfix = 1/((float)screen_texsizeh/(float)screen_height); + + fix[0] = fix[1] = + fix[2] = fix[7] = 0.0f; + + fix[3] = fix[5] = yfix; + fix[4] = fix[6] = xfix; + + // this shouldnt be necessary, since this comes after level draw + // but somehow it breaks without this?? + pglMatrixMode(GL_PROJECTION); + pglPushMatrix(); + pglLoadIdentity(); + pglMatrixMode(GL_MODELVIEW); + pglPushMatrix(); + pglLoadIdentity(); + + GL_SetBlend(PF_NoDepthTest); + + pglActiveTexture(GL_TEXTURE0); + pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_GENERIC1]); + tex_downloaded = screenTextures[HWD_SCREENTEXTURE_GENERIC1]; + + int shader = (type == POSTIMG_WATER) ? SHADER_POSTPROCESS_WATER : SHADER_POSTPROCESS_HEAT; + GL_SetShader(HWR_GetShaderFromTarget(shader)); + GL_Shader_SetUniforms(NULL, NULL, NULL, NULL); + pglColor4ubv(white); + + pglTexCoordPointer(2, GL_FLOAT, 0, fix); + pglVertexPointer(3, GL_FLOAT, 0, defaultscreenVerts); + pglDrawArrays(GL_TRIANGLE_FAN, 0, 4); + + GL_UnSetShader(); + + pglMatrixMode(GL_PROJECTION); + pglPopMatrix(); + pglMatrixMode(GL_MODELVIEW); + pglPopMatrix(); +} + void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]) { INT32 x, y; @@ -3716,7 +3778,6 @@ void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags) tex_downloaded = screenTextures[tex]; } - // Do screen fades! void GL_DoScreenWipe(int wipeStart, int wipeEnd) {