Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Batch indexing/no-fixed-function WIP.

Browse Source
This commit is contained in:
Shyotl
2011-08-09 01:11:05 -05:00
parent 1e7415095c
commit 9bda97786f
225 changed files with 2120 additions and 729 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
indra/newview/lldrawpoolalpha.cpp
View File

@@ -110,16 +110,43 @@ void LLDrawPoolAlpha::renderDeferred(S32 pass)
S32 LLDrawPoolAlpha::getNumPostDeferredPasses()
{
return 1;
if (LLPipeline::sImpostorRender)
{ //skip depth buffer filling pass when rendering impostors
return 1;
}
else if (gSavedSettings.getBOOL("RenderDepthOfField"))
{
return 2;
}
else
{
return 1;
}
}
void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_ALPHA);
simple_shader = &gDeferredAlphaProgram;
fullbright_shader = &gDeferredFullbrightProgram;
if (pass == 0)
{
simple_shader = &gDeferredAlphaProgram;
fullbright_shader = &gObjectFullbrightProgram;
//prime simple shader (loads shadow relevant uniforms)
gPipeline.bindDeferredShader(*simple_shader);
}
else
{
//update depth buffer sampler
gPipeline.mScreen.flush();
gPipeline.mDeferredDepth.copyContents(gPipeline.mDeferredScreen, 0, 0, gPipeline.mDeferredScreen.getWidth(), gPipeline.mDeferredScreen.getHeight(),
0, 0, gPipeline.mDeferredDepth.getWidth(), gPipeline.mDeferredDepth.getHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST);
gPipeline.mDeferredDepth.bindTarget();
simple_shader = NULL;
fullbright_shader = NULL;
gObjectFullbrightProgram.bind();
}
deferred_render = TRUE;
if (mVertexShaderLevel > 0)
{
@@ -131,6 +158,13 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
void LLDrawPoolAlpha::endPostDeferredPass(S32 pass)
{
if (pass == 1)
{
gPipeline.mDeferredDepth.flush();
gPipeline.mScreen.bindTarget();
gObjectFullbrightProgram.unbind();
}
deferred_render = FALSE;
endRenderPass(pass);
}
@@ -181,7 +215,14 @@ void LLDrawPoolAlpha::render(S32 pass)
LLGLSPipelineAlpha gls_pipeline_alpha;
gGL.setColorMask(true, true);
if (deferred_render && pass == 1)
{ //depth only
gGL.setColorMask(false, false);
}
else
{
gGL.setColorMask(true, true);
}
if (LLPipeline::sFastAlpha && !deferred_render)
{
mColorSFactor = LLRender::BF_ONE; // }
@@ -196,14 +237,14 @@ void LLDrawPoolAlpha::render(S32 pass)
if (!LLPipeline::sRenderDeferred)
{
simple_shader->bind();
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
}
if (fullbright_shader)
{
fullbright_shader->bind();
}
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask());
LLGLSLShader::bindNoShader();
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
//LLGLSLShader::bindNoShader();
}
else
{
@@ -215,35 +256,69 @@ void LLDrawPoolAlpha::render(S32 pass)
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
LLGLDepthTest depth(GL_TRUE, LLDrawPoolWater::sSkipScreenCopy ? GL_TRUE : GL_FALSE);
LLGLDepthTest depth(GL_TRUE, LLDrawPoolWater::sSkipScreenCopy ||
(deferred_render && pass == 1) ? GL_TRUE : GL_FALSE);
mColorSFactor = LLRender::BF_SOURCE_ALPHA; // } regular alpha blend
mColorDFactor = LLRender::BF_ONE_MINUS_SOURCE_ALPHA; // }
mAlphaSFactor = LLRender::BF_ZERO; // } glow suppression
mAlphaDFactor = LLRender::BF_ONE_MINUS_SOURCE_ALPHA; // }
gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
if (deferred_render && pass == 1)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.33f);
gGL.blendFunc(LLRender::BF_SOURCE_ALPHA, LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
}
else
{
mColorSFactor = LLRender::BF_SOURCE_ALPHA; // } regular alpha blend
mColorDFactor = LLRender::BF_ONE_MINUS_SOURCE_ALPHA; // }
mAlphaSFactor = LLRender::BF_ZERO; // } glow suppression
mAlphaDFactor = LLRender::BF_ONE_MINUS_SOURCE_ALPHA; // }
gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
renderAlpha(getVertexDataMask());
if (LLPipeline::sImpostorRender)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
}
else
{
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
}
if (mVertexShaderLevel > 0)
{
renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX);
}
else
{
renderAlpha(getVertexDataMask());
}
gGL.setColorMask(true, false);
if (deferred_render && current_shader != NULL)
if (deferred_render && pass == 1)
{
gPipeline.unbindDeferredShader(*current_shader);
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
if (sShowDebugAlpha)
{
if(gPipeline.canUseWindLightShaders())
BOOL shaders = gPipeline.canUseVertexShaders();
if(shaders)
{
LLGLSLShader::bindNoShader();
gObjectFullbrightNonIndexedProgram.bind();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
}
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
glColor4f(1,0,0,1);
LLViewerFetchedTexture::sSmokeImagep->addTextureStats(1024.f*1024.f);
gGL.getTexUnit(0)->bind(LLViewerFetchedTexture::sSmokeImagep, TRUE) ;
renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
LLVertexBuffer::MAP_TEXCOORD0);
if(shaders)
{
gObjectFullbrightNonIndexedProgram.unbind();
}
}
}
@@ -283,24 +358,9 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
{
BOOL initialized_lighting = FALSE;
BOOL light_enabled = TRUE;
S32 diffuse_channel = 0;
//BOOL is_particle = FALSE;
BOOL use_shaders = (LLPipeline::sUnderWaterRender && gPipeline.canUseVertexShaders())
|| gPipeline.canUseWindLightShadersOnObjects();
// check to see if it's a particle and if it's "close"
{
if (LLPipeline::sImpostorRender)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
}
else
{
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
}
BOOL use_shaders = gPipeline.canUseVertexShaders();
for (LLCullResult::sg_list_t::iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i)
{
LLSpatialGroup* group = *i;
@@ -357,36 +417,18 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
}
// If we need shaders, and we're not ALREADY using the proper shader, then bind it
// (this way we won't rebind shaders unnecessarily).
if(use_shaders && (current_shader != target_shader))
{
llassert(target_shader != NULL);
if (deferred_render && current_shader != NULL)
{
gPipeline.unbindDeferredShader(*current_shader);
diffuse_channel = 0;
}
current_shader = target_shader;
if (deferred_render)
{
gPipeline.bindDeferredShader(*current_shader);
diffuse_channel = current_shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
}
else
{
current_shader->bind();
}
}
else if (!use_shaders && current_shader != NULL)
{
if (deferred_render)
{
gPipeline.unbindDeferredShader(*current_shader);
diffuse_channel = 0;
}
LLGLSLShader::bindNoShader();
current_shader = NULL;
}
// (this way we won't rebind shaders unnecessarily).
if(use_shaders && (current_shader != target_shader))
{
llassert(target_shader != NULL);
current_shader = target_shader;
current_shader->bind();
}
else if (!use_shaders && current_shader != NULL)
{
LLGLSLShader::bindNoShader();
current_shader = NULL;
}
if (params.mGroup)
{
@@ -394,14 +436,23 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
}
bool tex_setup = false;
if (use_shaders && params.mTextureList.size() > 1)
{
for (U32 i = 0; i < params.mTextureList.size(); ++i)
{
if (params.mTextureList[i].notNull())
{
gGL.getTexUnit(i)->bind(params.mTextureList[i], TRUE);
}
}
}
else
{ //not batching textures or batch has only 1 texture -- might need a texture matrix
if (params.mTexture.notNull())
{
gGL.getTexUnit(diffuse_channel)->bind(params.mTexture.get());
if(params.mTexture.notNull())
{
params.mTexture->addTextureStats(params.mVSize);
}
params.mTexture->addTextureStats(params.mVSize);
gGL.getTexUnit(0)->bind(params.mTexture, TRUE) ;
if (params.mTextureMatrix)
{
tex_setup = true;
@@ -411,6 +462,11 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
gPipeline.mTextureMatrixOps++;
}
}
else
{
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
}
}
params.mVertexBuffer->setBuffer(mask);
params.mVertexBuffer->drawRange(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
gPipeline.addTrianglesDrawn(params.mCount/3);
@@ -445,15 +501,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
}
}
if (deferred_render && current_shader != NULL)
{
gPipeline.unbindDeferredShader(*current_shader);
LLVertexBuffer::unbind();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
}
LLVertexBuffer::unbind();
if (!light_enabled)
{
gPipeline.enableLightsDynamic();