livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move the shader to renderFinalize (and also stop doing that oopsie of writing to the buffer we were reading from)

meow-7.2.2
Kitty Barnett 2021-01-13 22:08:57 +01:00
parent 98179f5c6f
commit 89c729455d
4 changed files with 124 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
indra/newview/llviewerdisplay.cpp
View File

@ -1031,15 +1031,6 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
{
gPipeline.renderDeferredLighting(&gPipeline.mScreen);
}
// [RLVa:KB] - @setsphere
else if (LLRenderTarget::sUseFBO && LLPipeline::sUseDepthTexture)
{
if (RlvActions::hasBehaviour(RLV_BHVR_SETSPHERE))
{
LLVfxManager::instance().runEffect(EVisualEffect::RlvSphere);
}
}
// [/RLVa:KB]
LLPipeline::sUnderWaterRender = FALSE;

96
indra/newview/pipeline.cpp
View File

@ -1003,6 +1003,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
const U32 occlusion_divisor = 3;
if (!mDeferredDepth.allocate(resX, resY, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
if (!mOcclusionDepth.allocate(resX / occlusion_divisor, resY / occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
if (RlvActions::isRlvEnabled() && !mDeferredLight.allocate(resX, resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE)) return false;
}
// [/RLVa:KB]
// mDeferredDepth.release();
@ -7788,6 +7789,9 @@ void LLPipeline::renderFinalize()
LLVertexBuffer::unbind();
// [RLVa:KB] - @setsphere
LLRenderTarget* pRenderBuffer = (RlvActions::hasBehaviour(RLV_BHVR_SETSPHERE)) ? &mDeferredLight : nullptr;
// [/RLVa:KB]
if (LLPipeline::sRenderDeferred)
{
@ -7796,6 +7800,12 @@ void LLPipeline::renderFinalize()
RenderDepthOfField;
bool multisample = RenderFSAASamples > 1 && mFXAABuffer.isComplete();
// [RLVa:KB] - @setsphere
if (multisample && !pRenderBuffer)
{
pRenderBuffer = &mDeferredLight;
}
// [/RLVa:KB]
gViewerWindow->setup3DViewport();
@ -7976,11 +7986,18 @@ void LLPipeline::renderFinalize()
}
{ // combine result based on alpha
if (multisample)
// if (multisample)
// {
// mDeferredLight.bindTarget();
// glViewport(0, 0, mDeferredScreen.getWidth(), mDeferredScreen.getHeight());
// }
// [RLVa:KB] - @setsphere
if (pRenderBuffer)
{
mDeferredLight.bindTarget();
pRenderBuffer->bindTarget();
glViewport(0, 0, mDeferredScreen.getWidth(), mDeferredScreen.getHeight());
}
// [/RLVa:KB]
else
{
gGLViewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;
@ -8018,18 +8035,30 @@ void LLPipeline::renderFinalize()
unbindDeferredShader(*shader);
if (multisample)
// [RLVa:KB] - @setsphere
if (pRenderBuffer)
{
mDeferredLight.flush();
pRenderBuffer->flush();
}
// [/RLVa:KB]
// if (multisample)
// {
// mDeferredLight.flush();
// }
}
}
else
{
if (multisample)
// if (multisample)
// {
// mDeferredLight.bindTarget();
// }
// [RLVa:KB] - @setsphere
if (pRenderBuffer)
{
mDeferredLight.bindTarget();
pRenderBuffer->bindTarget();
}
// [/RLVa:KB]
LLGLSLShader *shader = &gDeferredPostNoDoFProgram;
bindDeferredShader(*shader);
@ -8054,12 +8083,27 @@ void LLPipeline::renderFinalize()
unbindDeferredShader(*shader);
if (multisample)
// [RLVa:KB] - @setsphere
if (pRenderBuffer)
{
mDeferredLight.flush();
pRenderBuffer->flush();
}
// [/RLVa:KB]
// if (multisample)
// {
// mDeferredLight.flush();
// }
}
// [RLVa:KB] - @setsphere
if (RlvActions::hasBehaviour(RLV_BHVR_SETSPHERE))
{
LLShaderEffectParams params(pRenderBuffer, (multisample) ? &mScreen : nullptr);
LLVfxManager::instance().runEffect(EVisualEffect::RlvSphere, &params);
pRenderBuffer = params.m_pDstBuffer;
}
// [/RLVa:KB]
if (multisample)
{
// bake out texture2D with RGBL for FXAA shader
@ -8074,11 +8118,18 @@ void LLPipeline::renderFinalize()
shader->bind();
shader->uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, width, height);
S32 channel = shader->enableTexture(LLShaderMgr::DEFERRED_DIFFUSE, mDeferredLight.getUsage());
// S32 channel = shader->enableTexture(LLShaderMgr::DEFERRED_DIFFUSE, mDeferredLight.getUsage());
// if (channel > -1)
// {
// mDeferredLight.bindTexture(0, channel);
// }
// [RLVa:KB] - @setsphere
S32 channel = shader->enableTexture(LLShaderMgr::DEFERRED_DIFFUSE, pRenderBuffer->getUsage());
if (channel > -1)
{
mDeferredLight.bindTexture(0, channel);
pRenderBuffer->bindTexture(0, channel);
}
// [RLVa:KB]
gGL.begin(LLRender::TRIANGLE_STRIP);
gGL.vertex2f(-1, -1);
@ -8088,7 +8139,10 @@ void LLPipeline::renderFinalize()
gGL.flush();
shader->disableTexture(LLShaderMgr::DEFERRED_DIFFUSE, mDeferredLight.getUsage());
// [RLVa:KB] - @setsphere
shader->disableTexture(LLShaderMgr::DEFERRED_DIFFUSE, pRenderBuffer->getUsage());
// [/RLVa:KB]
// shader->disableTexture(LLShaderMgr::DEFERRED_DIFFUSE, mDeferredLight.getUsage());
shader->unbind();
mFXAABuffer.flush();
@ -8129,6 +8183,15 @@ void LLPipeline::renderFinalize()
}
else // not deferred
{
// [RLVa:KB] - @setsphere
if (RlvActions::hasBehaviour(RLV_BHVR_SETSPHERE))
{
LLShaderEffectParams params(&mScreen, &mDeferredLight);
LLVfxManager::instance().runEffect(EVisualEffect::RlvSphere, &params);
pRenderBuffer = params.m_pDstBuffer;
}
// [/RLVa:KB]
U32 mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_TEXCOORD1;
LLPointer<LLVertexBuffer> buff = new LLVertexBuffer(mask, 0);
buff->allocateBuffer(3, 0, TRUE);
@ -8171,7 +8234,10 @@ void LLPipeline::renderFinalize()
}
gGL.getTexUnit(0)->bind(&mGlow[1]);
gGL.getTexUnit(1)->bind(&mScreen);
// [RLVa:KB] - @setsphere
gGL.getTexUnit(1)->bind( pRenderBuffer ? pRenderBuffer : &mScreen );
// [/RLVa:KB]
// gGL.getTexUnit(1)->bind(&mScreen);
LLGLEnable multisample(RenderFSAASamples > 0 ? GL_MULTISAMPLE_ARB : 0);
@ -9142,12 +9208,6 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target)
}
screen_target->flush();
// [RLVa:KB] - @setsphere
if (RlvActions::hasBehaviour(RLV_BHVR_SETSPHERE))
{
LLVfxManager::instance().runEffect(EVisualEffect::RlvSphere);
}
// [/RLVa:KB]
}
void LLPipeline::setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep)

62
indra/newview/rlveffects.cpp
View File

@ -118,7 +118,7 @@ void RlvOverlayEffect::setImage(const LLUUID& idTexture)
m_pImage->forceToSaveRawImage(0);
}
void RlvOverlayEffect::run()
void RlvOverlayEffect::run(const LLVisualEffectParams*)
{
if (m_pImage)
{
@ -310,10 +310,10 @@ ERlvCmdRet RlvSphereEffect::onValueMaxChanged(const LLUUID& idRlvObj, const boos
return RLV_RET_SUCCESS;
}
void RlvSphereEffect::setShaderUniforms(LLGLSLShader* pShader, LLRenderTarget* pRenderTarget)
void RlvSphereEffect::setShaderUniforms(LLGLSLShader* pShader)
{
pShader->uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, FALSE, get_current_projection().inverse().m);
pShader->uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, pRenderTarget->getWidth(), pRenderTarget->getHeight());
pShader->uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, gPipeline.mScreen.getWidth(), gPipeline.mScreen.getHeight());
pShader->uniform1i(LLShaderMgr::RLV_EFFECT_MODE, llclamp((int)m_eMode, 0, (int)ESphereMode::Count));
// Pass the sphere origin to the shader
@ -329,7 +329,7 @@ void RlvSphereEffect::setShaderUniforms(LLGLSLShader* pShader, LLRenderTarget* p
break;
}
glh::vec4f posSphereOriginGl(posSphereOrigin.mV);
const glh::matrix4f& mvMatrix = gGL.getModelviewMatrix();
const glh::matrix4f& mvMatrix = gGLModelView;
mvMatrix.mult_matrix_vec(posSphereOriginGl);
pShader->uniform4fv(LLShaderMgr::RLV_EFFECT_PARAM1, 1, posSphereOriginGl.v);
@ -347,14 +347,26 @@ void RlvSphereEffect::setShaderUniforms(LLGLSLShader* pShader, LLRenderTarget* p
pShader->uniform4fv(LLShaderMgr::RLV_EFFECT_PARAM4, 1, effectParams.v);
}
void RlvSphereEffect::renderPass(LLGLSLShader* pShader) const
void RlvSphereEffect::renderPass(LLGLSLShader* pShader, const LLShaderEffectParams* pParams) const
{
gPipeline.mScreen.bindTarget();
if (pParams->m_pDstBuffer)
{
pParams->m_pDstBuffer->bindTarget();
}
else
{
gGLViewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;
gGLViewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom;
gGLViewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth();
gGLViewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight();
glViewport(gGLViewport[0], gGLViewport[1], gGLViewport[2], gGLViewport[3]);
}
RLV_ASSERT_DBG(pParams->m_pSrcBuffer);
S32 nDiffuseChannel = pShader->enableTexture(LLShaderMgr::DEFERRED_DIFFUSE, gPipeline.mScreen.getUsage());
S32 nDiffuseChannel = pShader->enableTexture(LLShaderMgr::DEFERRED_DIFFUSE, pParams->m_pSrcBuffer->getUsage());
if (nDiffuseChannel > -1)
{
gPipeline.mScreen.bindTexture(0, nDiffuseChannel);
pParams->m_pSrcBuffer->bindTexture(0, nDiffuseChannel);
gGL.getTexUnit(nDiffuseChannel)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
}
@ -371,45 +383,55 @@ void RlvSphereEffect::renderPass(LLGLSLShader* pShader) const
gGL.pushMatrix();
gGL.loadMatrix(gGLModelView);
gPipeline.mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
gPipeline.mDeferredVB->drawArrays(LLRender::TRIANGLES, 0, 3);
LLVector2 tc1(0, 0);
LLVector2 tc2((F32)gPipeline.mScreen.getWidth() * 2, (F32)gPipeline.mScreen.getHeight() * 2);
gGL.begin(LLRender::TRIANGLE_STRIP);
gGL.texCoord2f(tc1.mV[0], tc1.mV[1]);
gGL.vertex2f(-1, -1);
gGL.texCoord2f(tc1.mV[0], tc2.mV[1]);
gGL.vertex2f(-1, 3);
gGL.texCoord2f(tc2.mV[0], tc1.mV[1]);
gGL.vertex2f(3, -1);
gGL.end();
gGL.matrixMode(LLRender::MM_PROJECTION);
gGL.popMatrix();
gGL.matrixMode(LLRender::MM_MODELVIEW);
gGL.popMatrix();
pShader->disableTexture(LLShaderMgr::DEFERRED_DIFFUSE, gPipeline.mScreen.getUsage());
pShader->disableTexture(LLShaderMgr::DEFERRED_DEPTH, gPipeline.mScreen.getUsage());
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gGL.getTexUnit(0)->activate();
pShader->disableTexture(LLShaderMgr::DEFERRED_DIFFUSE, pParams->m_pSrcBuffer->getUsage());
pShader->disableTexture(LLShaderMgr::DEFERRED_DEPTH, gPipeline.mDeferredDepth.getUsage());
gPipeline.mScreen.flush();
if (pParams->m_pDstBuffer)
{
pParams->m_pDstBuffer->flush();
}
}
LLTrace::BlockTimerStatHandle FTM_RLV_EFFECT_SPHERE("Post-process (RLVa sphere)");
void RlvSphereEffect::run()
void RlvSphereEffect::run(const LLVisualEffectParams* pParams)
{
LL_RECORD_BLOCK_TIME(FTM_RLV_EFFECT_SPHERE);
LLGLDepthTest depth(GL_FALSE, GL_FALSE);
gRlvSphereProgram.bind();
setShaderUniforms(&gRlvSphereProgram, &gPipeline.mScreen);
setShaderUniforms(&gRlvSphereProgram);
const LLShaderEffectParams* pShaderParams = static_cast<const LLShaderEffectParams*>(pParams);
switch (m_eMode)
{
case ESphereMode::Blend:
case ESphereMode::ChromaticAberration:
case ESphereMode::Pixelate:
renderPass(&gRlvSphereProgram);
renderPass(&gRlvSphereProgram, pShaderParams);
break;
case ESphereMode::Blur:
case ESphereMode::BlurVariable:
gRlvSphereProgram.uniform2f(LLShaderMgr::RLV_EFFECT_PARAM5, 1.f, 0.f);
renderPass(&gRlvSphereProgram);
renderPass(&gRlvSphereProgram, pShaderParams);
gRlvSphereProgram.uniform2f(LLShaderMgr::RLV_EFFECT_PARAM5, 0.f, 1.f);
renderPass(&gRlvSphereProgram);
renderPass(&gRlvSphereProgram, pShaderParams);
break;
}

8
indra/newview/rlveffects.h
View File

@ -37,7 +37,7 @@ public:
public:
bool hitTest(const LLCoordGL& ptMouse) const;
void run() override;
void run(const LLVisualEffectParams*) override;
void tweenAlpha(float endAlpha, double duration) { m_nAlpha.start(endAlpha, duration); }
void tweenColor(LLColor3 endColor, double duration) { m_Color.start(endColor, duration); }
static ERlvCmdRet onAlphaValueChanged(const LLUUID& idRlvObj, const boost::optional<RlvBehaviourModifierValue> newValue);
@ -71,7 +71,7 @@ public:
~RlvSphereEffect();
public:
void run() override;
void run(const LLVisualEffectParams* pParams) override;
static ERlvCmdRet onModeChanged(const LLUUID& idRlvObj, const boost::optional<RlvBehaviourModifierValue> newValue);
static ERlvCmdRet onOriginChanged(const LLUUID& idRlvObj, const boost::optional<RlvBehaviourModifierValue> newValue);
static ERlvCmdRet onColorChanged(const LLUUID& idRlvObj, const boost::optional<RlvBehaviourModifierValue> newValue);
@ -83,8 +83,8 @@ public:
static ERlvCmdRet onValueMinChanged(const LLUUID& idRlvObj, const boost::optional<RlvBehaviourModifierValue> newValue);
static ERlvCmdRet onValueMaxChanged(const LLUUID& idRlvObj, const boost::optional<RlvBehaviourModifierValue> newValue);
protected:
void renderPass(LLGLSLShader* pShader) const;
void setShaderUniforms(LLGLSLShader* pShader, LLRenderTarget* pRenderTarget);
void renderPass(LLGLSLShader* pShader, const LLShaderEffectParams* pParams) const;
void setShaderUniforms(LLGLSLShader* pShader);
/*
* Member variables