ubergames/ioef
0
0
Fork 0
mirror of https://github.com/UberGames/ioef.git synced 2025-02-14 07:41:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

OpenGL2: Some FBO cleanup, and add non-depth blur to blur shader.

Browse source
This commit is contained in:
SmileTheory 2016-04-05 02:37:05 -07:00
parent 60f56670d6
commit 1f6703821f
8 changed files with 148 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
code/renderergl2/glsl/depthblur_fp.glsl
View file

@ -9,7 +9,10 @@ varying vec2 var_ScreenTex;
float gauss[4] = float[4](0.40, 0.24, 0.054, 0.0044); float gauss[4] = float[4](0.40, 0.24, 0.054, 0.0044);
//float gauss[3] = float[3](0.60, 0.19, 0.0066); //float gauss[3] = float[3](0.60, 0.19, 0.0066);
#define BLUR_SIZE 4 #define BLUR_SIZE 4
#if !defined(USE_DEPTH)
//#define USE_GAUSS //#define USE_GAUSS
#endif
float getLinearDepth(sampler2D depthMap, const vec2 tex, const float zFarDivZNear) float getLinearDepth(sampler2D depthMap, const vec2 tex, const float zFarDivZNear)
{ {
@ -19,21 +22,21 @@ float getLinearDepth(sampler2D depthMap, const vec2 tex, const float zFarDivZNea
vec4 depthGaussian1D(sampler2D imageMap, sampler2D depthMap, vec2 tex, float zFarDivZNear, float zFar, vec2 scale) vec4 depthGaussian1D(sampler2D imageMap, sampler2D depthMap, vec2 tex, float zFarDivZNear, float zFar, vec2 scale)
{ {
float depthCenter = getLinearDepth(depthMap, tex, zFarDivZNear);
// enable for less blurring for farther objects #if defined(USE_DEPTH)
float depthCenter = getLinearDepth(depthMap, tex, zFarDivZNear);
vec2 slope = vec2(dFdx(depthCenter), dFdy(depthCenter)) / vec2(dFdx(tex.x), dFdy(tex.y));
scale /= clamp(zFarDivZNear * depthCenter / 32.0, 1.0, 2.0); scale /= clamp(zFarDivZNear * depthCenter / 32.0, 1.0, 2.0);
#endif
#if defined(USE_HORIZONTAL_BLUR) #if defined(USE_HORIZONTAL_BLUR)
vec2 direction = vec2(scale.x * 2.0, 0.0); vec2 direction = vec2(scale.x * 2.0, 0.0);
vec2 nudge = vec2(0.0, scale.y * 0.5); vec2 nudge = vec2(0.0, scale.y * 0.5);
#else // if defined(USE_VERTICAL_BLUR) #else // if defined(USE_VERTICAL_BLUR)
vec2 direction = vec2(0.0, scale.y * 2.0); vec2 direction = vec2(0.0, scale.y * 2.0);
vec2 nudge = vec2(scale.x * 0.5, 0.0); vec2 nudge = vec2(-scale.x * 0.5, 0.0);
#endif #endif
vec2 slope = vec2(dFdx(depthCenter), dFdy(depthCenter)) / vec2(dFdx(tex.x), dFdy(tex.y));
#if defined(USE_GAUSS) #if defined(USE_GAUSS)
vec4 result = texture2D(imageMap, tex) * gauss[0]; vec4 result = texture2D(imageMap, tex) * gauss[0];
float total = gauss[0]; float total = gauss[0];
@ -49,9 +52,13 @@ vec4 depthGaussian1D(sampler2D imageMap, sampler2D depthMap, vec2 tex, float zFa
for (j = 1; j < BLUR_SIZE; j++) for (j = 1; j < BLUR_SIZE; j++)
{ {
vec2 offset = direction * (float(j) - 0.25) + nudge; vec2 offset = direction * (float(j) - 0.25) + nudge;
#if defined(USE_DEPTH)
float depthSample = getLinearDepth(depthMap, tex + offset, zFarDivZNear); float depthSample = getLinearDepth(depthMap, tex + offset, zFarDivZNear);
float depthExpected = depthCenter + dot(slope, offset); float depthExpected = depthCenter + dot(slope, offset);
float useSample = float(abs(depthSample - depthExpected) < zLimit); float useSample = float(abs(depthSample - depthExpected) < zLimit);
#else
float useSample = 1.0;
#endif
#if defined(USE_GAUSS) #if defined(USE_GAUSS)
result += texture2D(imageMap, tex + offset) * (gauss[j] * useSample); result += texture2D(imageMap, tex + offset) * (gauss[j] * useSample);
total += gauss[j] * useSample; total += gauss[j] * useSample;

3
code/renderergl2/glsl/depthblur_vp.glsl
View file

@ -8,7 +8,8 @@ varying vec2 var_ScreenTex;
void main() void main()
{ {
gl_Position = attr_Position; gl_Position = attr_Position;
var_ScreenTex = (floor(attr_TexCoord0.xy * (1.0 / u_ViewInfo.zw - vec2(1.0))) + vec2(0.5)) * u_ViewInfo.zw; vec2 wh = vec2(1.0) / u_ViewInfo.zw - vec2(1.0);
var_ScreenTex = (floor(attr_TexCoord0.xy * wh) + vec2(0.5)) * u_ViewInfo.zw;
//vec2 screenCoords = gl_Position.xy / gl_Position.w; //vec2 screenCoords = gl_Position.xy / gl_Position.w;
//var_ScreenTex = screenCoords * 0.5 + 0.5; //var_ScreenTex = screenCoords * 0.5 + 0.5;

71
code/renderergl2/tr_backend.c
View file

@ -980,11 +980,11 @@ const void *RB_DrawSurfs( const void *data ) {
if (tr.hdrDepthFbo) if (tr.hdrDepthFbo)
{ {
// need the depth in a texture we can do GL_LINEAR sampling on, so copy it to an HDR image // need the depth in a texture we can do GL_LINEAR sampling on, so copy it to an HDR image
ivec4_t srcBox; vec4_t srcTexCoords;
VectorSet4(srcBox, 0, tr.renderDepthImage->height, tr.renderDepthImage->width, -tr.renderDepthImage->height); VectorSet4(srcTexCoords, 0.0f, 0.0f, 1.0f, 1.0f);
FBO_BlitFromTexture(tr.renderDepthImage, srcBox, NULL, tr.hdrDepthFbo, NULL, NULL, NULL, 0); FBO_BlitFromTexture(tr.renderDepthImage, srcTexCoords, NULL, tr.hdrDepthFbo, NULL, NULL, NULL, 0);
} }
if (r_sunlightMode->integer && backEnd.viewParms.flags & VPF_USESUNLIGHT) if (r_sunlightMode->integer && backEnd.viewParms.flags & VPF_USESUNLIGHT)
@ -1584,6 +1584,71 @@ const void *RB_PostProcess(const void *data)
else else
RB_GaussianBlur(backEnd.refdef.blurFactor); RB_GaussianBlur(backEnd.refdef.blurFactor);
#if 0
if (0)
{
vec4_t quadVerts[4];
vec2_t texCoords[4];
ivec4_t iQtrBox;
vec4_t box;
vec4_t viewInfo;
static float scale = 5.0f;
scale -= 0.005f;
if (scale < 0.01f)
scale = 5.0f;
FBO_FastBlit(NULL, NULL, tr.quarterFbo[0], NULL, GL_COLOR_BUFFER_BIT, GL_LINEAR);
iQtrBox[0] = backEnd.viewParms.viewportX * tr.quarterImage[0]->width / (float)glConfig.vidWidth;
iQtrBox[1] = backEnd.viewParms.viewportY * tr.quarterImage[0]->height / (float)glConfig.vidHeight;
iQtrBox[2] = backEnd.viewParms.viewportWidth * tr.quarterImage[0]->width / (float)glConfig.vidWidth;
iQtrBox[3] = backEnd.viewParms.viewportHeight * tr.quarterImage[0]->height / (float)glConfig.vidHeight;
qglViewport(iQtrBox[0], iQtrBox[1], iQtrBox[2], iQtrBox[3]);
qglScissor(iQtrBox[0], iQtrBox[1], iQtrBox[2], iQtrBox[3]);
VectorSet4(box, 0.0f, 0.0f, 1.0f, 1.0f);
texCoords[0][0] = box[0]; texCoords[0][1] = box[3];
texCoords[1][0] = box[2]; texCoords[1][1] = box[3];
texCoords[2][0] = box[2]; texCoords[2][1] = box[1];
texCoords[3][0] = box[0]; texCoords[3][1] = box[1];
VectorSet4(box, -1.0f, -1.0f, 1.0f, 1.0f);
VectorSet4(quadVerts[0], box[0], box[3], 0, 1);
VectorSet4(quadVerts[1], box[2], box[3], 0, 1);
VectorSet4(quadVerts[2], box[2], box[1], 0, 1);
VectorSet4(quadVerts[3], box[0], box[1], 0, 1);
GL_State(GLS_DEPTHTEST_DISABLE);
VectorSet4(viewInfo, backEnd.viewParms.zFar / r_znear->value, backEnd.viewParms.zFar, 0.0, 0.0);
viewInfo[2] = scale / (float)(tr.quarterImage[0]->width);
viewInfo[3] = scale / (float)(tr.quarterImage[0]->height);
FBO_Bind(tr.quarterFbo[1]);
GLSL_BindProgram(&tr.depthBlurShader[2]);
GL_BindToTMU(tr.quarterImage[0], TB_COLORMAP);
GLSL_SetUniformVec4(&tr.depthBlurShader[2], UNIFORM_VIEWINFO, viewInfo);
RB_InstantQuad2(quadVerts, texCoords);
FBO_Bind(tr.quarterFbo[0]);
GLSL_BindProgram(&tr.depthBlurShader[3]);
GL_BindToTMU(tr.quarterImage[1], TB_COLORMAP);
GLSL_SetUniformVec4(&tr.depthBlurShader[3], UNIFORM_VIEWINFO, viewInfo);
RB_InstantQuad2(quadVerts, texCoords);
SetViewportAndScissor();
FBO_FastBlit(tr.quarterFbo[1], NULL, NULL, NULL, GL_COLOR_BUFFER_BIT, GL_LINEAR);
FBO_Bind(NULL);
}
#endif
if (0 && r_sunlightMode->integer) if (0 && r_sunlightMode->integer)
{ {
ivec4_t dstBox; ivec4_t dstBox;

120
code/renderergl2/tr_fbo.c
View file

@ -487,10 +487,9 @@ void R_FBOList_f(void)
ri.Printf(PRINT_ALL, " %i FBOs\n", tr.numFBOs); ri.Printf(PRINT_ALL, " %i FBOs\n", tr.numFBOs);
} }
void FBO_BlitFromTexture(struct image_s *src, ivec4_t inSrcBox, vec2_t inSrcTexScale, FBO_t *dst, ivec4_t inDstBox, struct shaderProgram_s *shaderProgram, vec4_t inColor, int blend) void FBO_BlitFromTexture(struct image_s *src, vec4_t inSrcTexCorners, vec2_t inSrcTexScale, FBO_t *dst, ivec4_t inDstBox, struct shaderProgram_s *shaderProgram, vec4_t inColor, int blend)
{ {
ivec4_t dstBox, srcBox; ivec4_t dstBox;
vec2_t srcTexScale;
vec4_t color; vec4_t color;
vec4_t quadVerts[4]; vec4_t quadVerts[4];
vec2_t texCoords[4]; vec2_t texCoords[4];
@ -505,49 +504,44 @@ void FBO_BlitFromTexture(struct image_s *src, ivec4_t inSrcBox, vec2_t inSrcTexS
return; return;
} }
if (inSrcBox) width = dst ? dst->width : glConfig.vidWidth;
height = dst ? dst->height : glConfig.vidHeight;
if (inSrcTexCorners)
{ {
VectorSet4(srcBox, inSrcBox[0], inSrcBox[1], inSrcBox[0] + inSrcBox[2], inSrcBox[1] + inSrcBox[3]); VectorSet2(texCoords[0], inSrcTexCorners[0], inSrcTexCorners[1]);
VectorSet2(texCoords[1], inSrcTexCorners[2], inSrcTexCorners[1]);
VectorSet2(texCoords[2], inSrcTexCorners[2], inSrcTexCorners[3]);
VectorSet2(texCoords[3], inSrcTexCorners[0], inSrcTexCorners[3]);
} }
else else
{ {
VectorSet4(srcBox, 0, 0, src->width, src->height); VectorSet2(texCoords[0], 0.0f, 1.0f);
VectorSet2(texCoords[1], 1.0f, 1.0f);
VectorSet2(texCoords[2], 1.0f, 0.0f);
VectorSet2(texCoords[3], 0.0f, 0.0f);
} }
// framebuffers are 0 bottom, Y up. // framebuffers are 0 bottom, Y up.
if (inDstBox) if (inDstBox)
{ {
if (dst) dstBox[0] = inDstBox[0];
{ dstBox[1] = height - inDstBox[1] - inDstBox[3];
dstBox[0] = inDstBox[0]; dstBox[2] = inDstBox[0] + inDstBox[2];
dstBox[1] = dst->height - inDstBox[1] - inDstBox[3]; dstBox[3] = height - inDstBox[1];
dstBox[2] = inDstBox[0] + inDstBox[2];
dstBox[3] = dst->height - inDstBox[1];
}
else
{
dstBox[0] = inDstBox[0];
dstBox[1] = glConfig.vidHeight - inDstBox[1] - inDstBox[3];
dstBox[2] = inDstBox[0] + inDstBox[2];
dstBox[3] = glConfig.vidHeight - inDstBox[1];
}
}
else if (dst)
{
VectorSet4(dstBox, 0, dst->height, dst->width, 0);
} }
else else
{ {
VectorSet4(dstBox, 0, glConfig.vidHeight, glConfig.vidWidth, 0); VectorSet4(dstBox, 0, height, width, 0);
} }
if (inSrcTexScale) if (inSrcTexScale)
{ {
VectorCopy2(inSrcTexScale, srcTexScale); VectorCopy2(inSrcTexScale, invTexRes);
} }
else else
{ {
srcTexScale[0] = srcTexScale[1] = 1.0f; VectorSet2(invTexRes, 1.0f, 1.0f);
} }
if (inColor) if (inColor)
@ -566,17 +560,6 @@ void FBO_BlitFromTexture(struct image_s *src, ivec4_t inSrcBox, vec2_t inSrcTexS
FBO_Bind(dst); FBO_Bind(dst);
if (glState.currentFBO)
{
width = glState.currentFBO->width;
height = glState.currentFBO->height;
}
else
{
width = glConfig.vidWidth;
height = glConfig.vidHeight;
}
qglViewport( 0, 0, width, height ); qglViewport( 0, 0, width, height );
qglScissor( 0, 0, width, height ); qglScissor( 0, 0, width, height );
@ -586,18 +569,13 @@ void FBO_BlitFromTexture(struct image_s *src, ivec4_t inSrcBox, vec2_t inSrcTexS
GL_BindToTMU(src, TB_COLORMAP); GL_BindToTMU(src, TB_COLORMAP);
VectorSet4(quadVerts[0], dstBox[0], dstBox[1], 0, 1); VectorSet4(quadVerts[0], dstBox[0], dstBox[1], 0.0f, 1.0f);
VectorSet4(quadVerts[1], dstBox[2], dstBox[1], 0, 1); VectorSet4(quadVerts[1], dstBox[2], dstBox[1], 0.0f, 1.0f);
VectorSet4(quadVerts[2], dstBox[2], dstBox[3], 0, 1); VectorSet4(quadVerts[2], dstBox[2], dstBox[3], 0.0f, 1.0f);
VectorSet4(quadVerts[3], dstBox[0], dstBox[3], 0, 1); VectorSet4(quadVerts[3], dstBox[0], dstBox[3], 0.0f, 1.0f);
texCoords[0][0] = srcBox[0] / (float)src->width; texCoords[0][1] = 1.0f - srcBox[1] / (float)src->height; invTexRes[0] /= src->width;
texCoords[1][0] = srcBox[2] / (float)src->width; texCoords[1][1] = 1.0f - srcBox[1] / (float)src->height; invTexRes[1] /= src->height;
texCoords[2][0] = srcBox[2] / (float)src->width; texCoords[2][1] = 1.0f - srcBox[3] / (float)src->height;
texCoords[3][0] = srcBox[0] / (float)src->width; texCoords[3][1] = 1.0f - srcBox[3] / (float)src->height;
invTexRes[0] = 1.0f / src->width * srcTexScale[0];
invTexRes[1] = 1.0f / src->height * srcTexScale[1];
GL_State( blend ); GL_State( blend );
@ -609,14 +587,14 @@ void FBO_BlitFromTexture(struct image_s *src, ivec4_t inSrcBox, vec2_t inSrcTexS
GLSL_SetUniformVec2(shaderProgram, UNIFORM_AUTOEXPOSUREMINMAX, tr.refdef.autoExposureMinMax); GLSL_SetUniformVec2(shaderProgram, UNIFORM_AUTOEXPOSUREMINMAX, tr.refdef.autoExposureMinMax);
GLSL_SetUniformVec3(shaderProgram, UNIFORM_TONEMINAVGMAXLINEAR, tr.refdef.toneMinAvgMaxLinear); GLSL_SetUniformVec3(shaderProgram, UNIFORM_TONEMINAVGMAXLINEAR, tr.refdef.toneMinAvgMaxLinear);
RB_InstantQuad2(quadVerts, texCoords); //, color, shaderProgram, invTexRes); RB_InstantQuad2(quadVerts, texCoords);
FBO_Bind(oldFbo); FBO_Bind(oldFbo);
} }
void FBO_Blit(FBO_t *src, ivec4_t inSrcBox, vec2_t srcTexScale, FBO_t *dst, ivec4_t dstBox, struct shaderProgram_s *shaderProgram, vec4_t color, int blend) void FBO_Blit(FBO_t *src, ivec4_t inSrcBox, vec2_t srcTexScale, FBO_t *dst, ivec4_t dstBox, struct shaderProgram_s *shaderProgram, vec4_t color, int blend)
{ {
ivec4_t srcBox; vec4_t srcTexCorners;
if (!src) if (!src)
{ {
@ -624,20 +602,19 @@ void FBO_Blit(FBO_t *src, ivec4_t inSrcBox, vec2_t srcTexScale, FBO_t *dst, ivec
return; return;
} }
// framebuffers are 0 bottom, Y up.
if (inSrcBox) if (inSrcBox)
{ {
srcBox[0] = inSrcBox[0]; srcTexCorners[0] = inSrcBox[0] / (float)src->width;
srcBox[1] = src->height - inSrcBox[1] - inSrcBox[3]; srcTexCorners[1] = (inSrcBox[1] + inSrcBox[3]) / (float)src->height;
srcBox[2] = inSrcBox[2]; srcTexCorners[2] = (inSrcBox[0] + inSrcBox[2]) / (float)src->width;
srcBox[3] = inSrcBox[3]; srcTexCorners[3] = inSrcBox[1] / (float)src->height;
} }
else else
{ {
VectorSet4(srcBox, 0, src->height, src->width, -src->height); VectorSet4(srcTexCorners, 0.0f, 0.0f, 1.0f, 1.0f);
} }
FBO_BlitFromTexture(src->colorImage[0], srcBox, srcTexScale, dst, dstBox, shaderProgram, color, blend | GLS_DEPTHTEST_DISABLE); FBO_BlitFromTexture(src->colorImage[0], srcTexCorners, srcTexScale, dst, dstBox, shaderProgram, color, blend | GLS_DEPTHTEST_DISABLE);
} }
void FBO_FastBlit(FBO_t *src, ivec4_t srcBox, FBO_t *dst, ivec4_t dstBox, int buffers, int filter) void FBO_FastBlit(FBO_t *src, ivec4_t srcBox, FBO_t *dst, ivec4_t dstBox, int buffers, int filter)
@ -651,22 +628,15 @@ void FBO_FastBlit(FBO_t *src, ivec4_t srcBox, FBO_t *dst, ivec4_t dstBox, int bu
return; return;
} }
// get to a neutral state first
//FBO_Bind(NULL);
srcFb = src ? src->frameBuffer : 0; srcFb = src ? src->frameBuffer : 0;
dstFb = dst ? dst->frameBuffer : 0; dstFb = dst ? dst->frameBuffer : 0;
if (!srcBox) if (!srcBox)
{ {
if (src) int width = src ? src->width : glConfig.vidWidth;
{ int height = src ? src->height : glConfig.vidHeight;
VectorSet4(srcBoxFinal, 0, 0, src->width, src->height);
} VectorSet4(srcBoxFinal, 0, 0, width, height);
else
{
VectorSet4(srcBoxFinal, 0, 0, glConfig.vidWidth, glConfig.vidHeight);
}
} }
else else
{ {
@ -675,14 +645,10 @@ void FBO_FastBlit(FBO_t *src, ivec4_t srcBox, FBO_t *dst, ivec4_t dstBox, int bu
if (!dstBox) if (!dstBox)
{ {
if (dst) int width = dst ? dst->width : glConfig.vidWidth;
{ int height = dst ? dst->height : glConfig.vidHeight;
VectorSet4(dstBoxFinal, 0, 0, dst->width, dst->height);
} VectorSet4(dstBoxFinal, 0, 0, width, height);
else
{
VectorSet4(dstBoxFinal, 0, 0, glConfig.vidWidth, glConfig.vidHeight);
}
} }
else else
{ {

2
code/renderergl2/tr_fbo.h
View file

@ -57,7 +57,7 @@ void FBO_Bind(FBO_t *fbo);
void FBO_Init(void); void FBO_Init(void);
void FBO_Shutdown(void); void FBO_Shutdown(void);
void FBO_BlitFromTexture(struct image_s *src, ivec4_t srcBox, vec2_t srcTexScale, FBO_t *dst, ivec4_t dstBox, struct shaderProgram_s *shaderProgram, vec4_t color, int blend); void FBO_BlitFromTexture(struct image_s *src, vec4_t inSrcTexCorners, vec2_t inSrcTexScale, FBO_t *dst, ivec4_t inDstBox, struct shaderProgram_s *shaderProgram, vec4_t inColor, int blend);
void FBO_Blit(FBO_t *src, ivec4_t srcBox, vec2_t srcTexScale, FBO_t *dst, ivec4_t dstBox, struct shaderProgram_s *shaderProgram, vec4_t color, int blend); void FBO_Blit(FBO_t *src, ivec4_t srcBox, vec2_t srcTexScale, FBO_t *dst, ivec4_t dstBox, struct shaderProgram_s *shaderProgram, vec4_t color, int blend);
void FBO_FastBlit(FBO_t *src, ivec4_t srcBox, FBO_t *dst, ivec4_t dstBox, int buffers, int filter); void FBO_FastBlit(FBO_t *src, ivec4_t srcBox, FBO_t *dst, ivec4_t dstBox, int buffers, int filter);

7
code/renderergl2/tr_glsl.c
View file

@ -1284,7 +1284,7 @@ void GLSL_InitGPUShaders(void)
numEtcShaders++; numEtcShaders++;
for (i = 0; i < 2; i++) for (i = 0; i < 4; i++)
{ {
attribs = ATTR_POSITION | ATTR_TEXCOORD; attribs = ATTR_POSITION | ATTR_TEXCOORD;
extradefines[0] = '\0'; extradefines[0] = '\0';
@ -1294,6 +1294,9 @@ void GLSL_InitGPUShaders(void)
else else
Q_strcat(extradefines, 1024, "#define USE_HORIZONTAL_BLUR\n"); Q_strcat(extradefines, 1024, "#define USE_HORIZONTAL_BLUR\n");
if (!(i & 2))
Q_strcat(extradefines, 1024, "#define USE_DEPTH\n");
if (!GLSL_InitGPUShader(&tr.depthBlurShader[i], "depthBlur", attribs, qtrue, extradefines, qtrue, fallbackShader_depthblur_vp, fallbackShader_depthblur_fp)) if (!GLSL_InitGPUShader(&tr.depthBlurShader[i], "depthBlur", attribs, qtrue, extradefines, qtrue, fallbackShader_depthblur_vp, fallbackShader_depthblur_fp))
{ {
@ -1373,7 +1376,7 @@ void GLSL_ShutdownGPUShaders(void)
GLSL_DeleteGPUShader(&tr.shadowmaskShader); GLSL_DeleteGPUShader(&tr.shadowmaskShader);
GLSL_DeleteGPUShader(&tr.ssaoShader); GLSL_DeleteGPUShader(&tr.ssaoShader);
for ( i = 0; i < 2; i++) for ( i = 0; i < 4; i++)
GLSL_DeleteGPUShader(&tr.depthBlurShader[i]); GLSL_DeleteGPUShader(&tr.depthBlurShader[i]);
} }

2
code/renderergl2/tr_local.h
View file

@ -1591,7 +1591,7 @@ typedef struct {
shaderProgram_t calclevels4xShader[2]; shaderProgram_t calclevels4xShader[2];
shaderProgram_t shadowmaskShader; shaderProgram_t shadowmaskShader;
shaderProgram_t ssaoShader; shaderProgram_t ssaoShader;
shaderProgram_t depthBlurShader[2]; shaderProgram_t depthBlurShader[4];
shaderProgram_t testcubeShader; shaderProgram_t testcubeShader;

51
code/renderergl2/tr_postprocess.c
View file

@ -227,6 +227,7 @@ void RB_BokehBlur(FBO_t *src, ivec4_t srcBox, FBO_t *dst, ivec4_t dstBox, float
static void RB_RadialBlur(FBO_t *srcFbo, FBO_t *dstFbo, int passes, float stretch, float x, float y, float w, float h, float xcenter, float ycenter, float alpha) static void RB_RadialBlur(FBO_t *srcFbo, FBO_t *dstFbo, int passes, float stretch, float x, float y, float w, float h, float xcenter, float ycenter, float alpha)
{ {
ivec4_t srcBox, dstBox; ivec4_t srcBox, dstBox;
int srcWidth, srcHeight;
vec4_t color; vec4_t color;
const float inc = 1.f / passes; const float inc = 1.f / passes;
const float mul = powf(stretch, inc); const float mul = powf(stretch, inc);
@ -235,10 +236,10 @@ static void RB_RadialBlur(FBO_t *srcFbo, FBO_t *dstFbo, int passes, float stretc
alpha *= inc; alpha *= inc;
VectorSet4(color, alpha, alpha, alpha, 1.0f); VectorSet4(color, alpha, alpha, alpha, 1.0f);
if (srcFbo) srcWidth = srcFbo ? srcFbo->width : glConfig.vidWidth;
VectorSet4(srcBox, 0, 0, srcFbo->width, srcFbo->height); srcHeight = srcFbo ? srcFbo->height : glConfig.vidHeight;
else
VectorSet4(srcBox, 0, 0, glConfig.vidWidth, glConfig.vidHeight); VectorSet4(srcBox, 0, 0, srcWidth, srcHeight);
VectorSet4(dstBox, x, y, w, h); VectorSet4(dstBox, x, y, w, h);
FBO_Blit(srcFbo, srcBox, NULL, dstFbo, dstBox, NULL, color, 0); FBO_Blit(srcFbo, srcBox, NULL, dstFbo, dstBox, NULL, color, 0);
@ -251,20 +252,10 @@ static void RB_RadialBlur(FBO_t *srcFbo, FBO_t *dstFbo, int passes, float stretc
float s0 = xcenter * (1.f - iscale); float s0 = xcenter * (1.f - iscale);
float t0 = (1.0f - ycenter) * (1.f - iscale); float t0 = (1.0f - ycenter) * (1.f - iscale);
if (srcFbo) srcBox[0] = s0 * srcWidth;
{ srcBox[1] = t0 * srcHeight;
srcBox[0] = s0 * srcFbo->width; srcBox[2] = iscale * srcWidth;
srcBox[1] = t0 * srcFbo->height; srcBox[3] = iscale * srcHeight;
srcBox[2] = iscale * srcFbo->width;
srcBox[3] = iscale * srcFbo->height;
}
else
{
srcBox[0] = s0 * glConfig.vidWidth;
srcBox[1] = t0 * glConfig.vidHeight;
srcBox[2] = iscale * glConfig.vidWidth;
srcBox[3] = iscale * glConfig.vidHeight;
}
FBO_Blit(srcFbo, srcBox, NULL, dstFbo, dstBox, NULL, color, GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE ); FBO_Blit(srcFbo, srcBox, NULL, dstFbo, dstBox, NULL, color, GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE );
@ -349,23 +340,15 @@ void RB_SunRays(FBO_t *srcFbo, ivec4_t srcBox, FBO_t *dstFbo, ivec4_t dstBox)
{ {
float mul = 1.f; float mul = 1.f;
ivec4_t rayBox, quarterBox; ivec4_t rayBox, quarterBox;
int srcWidth = srcFbo ? srcFbo->width : glConfig.vidWidth;
int srcHeight = srcFbo ? srcFbo->height : glConfig.vidHeight;
VectorSet4(color, mul, mul, mul, 1); VectorSet4(color, mul, mul, mul, 1);
if (srcFbo) rayBox[0] = srcBox[0] * tr.sunRaysFbo->width / srcWidth;
{ rayBox[1] = srcBox[1] * tr.sunRaysFbo->height / srcHeight;
rayBox[0] = srcBox[0] * tr.sunRaysFbo->width / srcFbo->width; rayBox[2] = srcBox[2] * tr.sunRaysFbo->width / srcWidth;
rayBox[1] = srcBox[1] * tr.sunRaysFbo->height / srcFbo->height; rayBox[3] = srcBox[3] * tr.sunRaysFbo->height / srcHeight;
rayBox[2] = srcBox[2] * tr.sunRaysFbo->width / srcFbo->width;
rayBox[3] = srcBox[3] * tr.sunRaysFbo->height / srcFbo->height;
}
else
{
rayBox[0] = srcBox[0] * tr.sunRaysFbo->width / glConfig.vidWidth;
rayBox[1] = srcBox[1] * tr.sunRaysFbo->height / glConfig.vidHeight;
rayBox[2] = srcBox[2] * tr.sunRaysFbo->width / glConfig.vidWidth;
rayBox[3] = srcBox[3] * tr.sunRaysFbo->height / glConfig.vidHeight;
}
quarterBox[0] = 0; quarterBox[0] = 0;
quarterBox[1] = tr.quarterFbo[0]->height; quarterBox[1] = tr.quarterFbo[0]->height;
@ -483,10 +466,8 @@ void RB_GaussianBlur(float blur)
FBO_FastBlit(tr.quarterFbo[0], NULL, tr.textureScratchFbo[0], NULL, GL_COLOR_BUFFER_BIT, GL_LINEAR); FBO_FastBlit(tr.quarterFbo[0], NULL, tr.textureScratchFbo[0], NULL, GL_COLOR_BUFFER_BIT, GL_LINEAR);
// set the alpha channel // set the alpha channel
VectorSet4(srcBox, 0, 0, tr.whiteImage->width, tr.whiteImage->height);
VectorSet4(dstBox, 0, 0, tr.textureScratchFbo[0]->width, tr.textureScratchFbo[0]->height);
qglColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); qglColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
FBO_BlitFromTexture(tr.whiteImage, srcBox, NULL, tr.textureScratchFbo[0], dstBox, NULL, color, GLS_DEPTHTEST_DISABLE); FBO_BlitFromTexture(tr.whiteImage, NULL, NULL, tr.textureScratchFbo[0], NULL, NULL, color, GLS_DEPTHTEST_DISABLE);
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// blur the tiny buffer horizontally and vertically // blur the tiny buffer horizontally and vertically