void LLDrawPoolSimple::render(S32 pass)
{
LLGLDisable blend(GL_BLEND);
{ //render simple
LLFastTimer t(FTM_RENDER_SIMPLE);
gPipeline.enableLightsDynamic();
if (mVertexShaderLevel > 0)
{
U32 mask = getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX;
pushBatches(LLRenderPass::PASS_SIMPLE, mask, TRUE, TRUE);
if (LLPipeline::sRenderDeferred)
{ //if deferred rendering is enabled, bump faces aren't registered as simple
//render bump faces here as simple so bump faces will appear under water
pushBatches(LLRenderPass::PASS_BUMP, mask, TRUE, TRUE);
}
}
else
{
LLGLDisable alpha_test(GL_ALPHA_TEST);
renderTexture(LLRenderPass::PASS_SIMPLE, getVertexDataMask());
}
}
}
void LLDrawPoolGlow::render(S32 pass)
{
S32 mode = gViewerWindow->getMaskMode();
LLFastTimer t(FTM_RENDER_GLOW);
LLGLEnable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.flush();
/// Get rid of z-fighting with non-glow pass.
LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1.0f, -1.0f);
gGL.setSceneBlendType(LLRender::BT_ADD);
U32 shader_level = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
if (shader_level > 0 && fullbright_shader)
{
fullbright_shader->bind();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
}
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
if (shader_level > 1)
{
pushBatches(LLRenderPass::PASS_GLOW, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
}
else
{
renderTexture(LLRenderPass::PASS_GLOW, getVertexDataMask());
}
if(mode == MASK_MODE_RIGHT)
{
gGL.setColorMask(false,true,true,false);
}
if(mode == MASK_MODE_LEFT)
{
gGL.setColorMask(true,false,false,false);
}
if(mode == MASK_MODE_NONE)
{
gGL.setColorMask(true, false);
}
gGL.setSceneBlendType(LLRender::BT_ALPHA);
if (shader_level > 0 && fullbright_shader)
{
fullbright_shader->unbind();
}
}
void LLDrawPoolAlpha::render(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_ALPHA);
LLGLSPipelineAlpha gls_pipeline_alpha;
if (LLPipeline::sFastAlpha && !deferred_render)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.33f);
if (mVertexShaderLevel > 0)
{
if (!LLPipeline::sRenderDeferred)
{
simple_shader->bind();
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
}
fullbright_shader->bind();
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask());
LLGLSLShader::bindNoShader();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask());
gPipeline.enableLightsDynamic();
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
LLGLDepthTest depth(GL_TRUE, LLDrawPoolWater::sSkipScreenCopy ? GL_TRUE : GL_FALSE);
renderAlpha(getVertexDataMask());
if (deferred_render && current_shader != NULL)
{
gPipeline.unbindDeferredShader(*current_shader);
}
if (sShowDebugAlpha)
{
if(gPipeline.canUseWindLightShaders())
{
LLGLSLShader::bindNoShader();
}
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
glColor4f(1,0,0,1);
LLViewerImage::sSmokeImagep->addTextureStats(1024.f*1024.f);
gGL.getTexUnit(0)->bind(LLViewerImage::sSmokeImagep.get(), TRUE);
renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
LLVertexBuffer::MAP_TEXCOORD0);
}
}
void LLDrawPoolGlow::render(S32 pass)
{
LLFastTimer t(FTM_RENDER_GLOW);
LLGLEnable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.flush();
/// Get rid of z-fighting with non-glow pass.
LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1.0f, -1.0f);
gGL.setSceneBlendType(LLRender::BT_ADD);
U32 shader_level = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
//should never get here without basic shaders enabled
llassert(shader_level > 0);
LLGLSLShader* shader = LLPipeline::sUnderWaterRender ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
shader->bind();
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
pushBatches(LLRenderPass::PASS_GLOW, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
gGL.setColorMask(true, false);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
if (shader_level > 0 && fullbright_shader)
{
shader->unbind();
}
}
void LLDrawPoolGlow::render(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_GLOW);
LLGLEnable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.setSceneBlendType(LLRender::BT_ADD);
U32 shader_level = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
if (shader_level > 0 && fullbright_shader)
{
fullbright_shader->bind();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
}
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
renderTexture(LLRenderPass::PASS_GLOW, getVertexDataMask());
gGL.setColorMask(true, false);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
if (shader_level > 0 && fullbright_shader)
{
fullbright_shader->unbind();
}
}
void LLDrawPoolSimple::renderDeferred(S32 pass)
{
LLGLDisable blend(GL_BLEND);
LLGLDisable alpha_test(GL_ALPHA_TEST);
{ //render simple
LLFastTimer t(FTM_RENDER_SIMPLE_DEFERRED);
pushBatches(LLRenderPass::PASS_SIMPLE, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
}
}
void LLDrawPoolAlpha::renderDeferred(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_GRASS);
gDeferredDiffuseAlphaMaskProgram.bind();
gDeferredDiffuseAlphaMaskProgram.setAlphaRange(0.33f, 1.f);
//render alpha masked objects
LLRenderPass::pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
gDeferredDiffuseAlphaMaskProgram.unbind();
}
void LLDrawPoolGrass::renderDeferred(S32 pass)
{
{
LLFastTimer t(FTM_RENDER_GRASS_DEFERRED);
gDeferredNonIndexedDiffuseAlphaMaskProgram.bind();
gDeferredNonIndexedDiffuseAlphaMaskProgram.setMinimumAlpha(0.5f);
//render grass
LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
}
void LLDrawPoolGrass::render(S32 pass)
{
LLGLDisable blend(GL_BLEND);
{
LLFastTimer t(FTM_RENDER_GRASS);
LLGLEnable test(GL_ALPHA_TEST);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
//render grass
LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
}
void LLDrawPoolAlpha::endDeferredPass(S32 pass)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.4f);
{
LLFastTimer t(LLFastTimer::FTM_RENDER_GRASS);
gDeferredTreeProgram.bind();
LLGLEnable test(GL_ALPHA_TEST);
//render alpha masked objects
LLRenderPass::renderTexture(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
void LLDrawPoolSimple::render(S32 pass)
{
LLGLDisable blend(GL_BLEND);
LLGLState alpha_test(GL_ALPHA_TEST, gPipeline.canUseWindLightShadersOnObjects());
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
{ //render simple
LLFastTimer t(LLFastTimer::FTM_RENDER_SIMPLE);
gPipeline.enableLightsDynamic();
renderTexture(LLRenderPass::PASS_SIMPLE, getVertexDataMask());
}
{
LLFastTimer t(LLFastTimer::FTM_RENDER_GRASS);
LLGLEnable test(GL_ALPHA_TEST);
LLGLEnable blend(GL_BLEND);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
//render grass
LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
{ //render fullbright
if (mVertexShaderLevel > 0)
{
fullbright_shader->bind();
fullbright_shader->uniform1f(LLViewerShaderMgr::FULLBRIGHT, 1.f);
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
}
LLFastTimer t(LLFastTimer::FTM_RENDER_FULLBRIGHT);
U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD | LLVertexBuffer::MAP_COLOR;
renderTexture(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask);
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
void LLDrawPoolGrass::renderDeferred(S32 pass)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.f);
{
LLFastTimer t(FTM_RENDER_GRASS_DEFERRED);
gDeferredTreeProgram.bind();
LLGLEnable test(GL_ALPHA_TEST);
//render grass
LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
void LLDrawPoolGlow::renderPostDeferred(S32 pass)
{
LLFastTimer t(FTM_RENDER_GLOW);
LLGLEnable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.flush();
/// Get rid of z-fighting with non-glow pass.
LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1.0f, -1.0f);
gGL.setSceneBlendType(LLRender::BT_ADD);
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
pushBatches(LLRenderPass::PASS_GLOW, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
gGL.setColorMask(true, false);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
void LLDrawPoolAlpha::render(std::vector<LLSpatialGroup*>& groups)
{
LLGLDepthTest gls_depth(GL_TRUE);
LLGLSPipelineAlpha gls_pipeline_alpha;
gPipeline.enableLightsDynamic(1.f);
renderAlpha(getVertexDataMask(), groups);
if (sShowDebugAlpha)
{
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
glColor4f(1,0,0,1);
LLViewerImage::sSmokeImagep->addTextureStats(1024.f*1024.f);
LLViewerImage::sSmokeImagep->bind();
renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
LLVertexBuffer::MAP_TEXCOORD, groups);
}
}
void LLDrawPoolAlpha::render(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_ALPHA);
LLGLSPipelineAlpha gls_pipeline_alpha;
gGL.setColorMask(true, true);
if (LLPipeline::sFastAlpha && !deferred_render)
{
mColorSFactor = LLRender::BF_ONE; // }
mColorDFactor = LLRender::BF_ZERO; // } these are like disabling blend on the color channels, but we're still blending on the alpha channel so that we can suppress glow
mAlphaSFactor = LLRender::BF_ZERO;
mAlphaDFactor = LLRender::BF_ZERO; // block (zero-out) glow where the alpha test succeeds
gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.33f);
if (mVertexShaderLevel > 0)
{
if (!LLPipeline::sRenderDeferred)
{
simple_shader->bind();
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
}
fullbright_shader->bind();
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask());
LLGLSLShader::bindNoShader();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask());
gPipeline.enableLightsDynamic();
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
LLGLDepthTest depth(GL_TRUE, LLDrawPoolWater::sSkipScreenCopy ? 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);
renderAlpha(getVertexDataMask());
gGL.setColorMask(true, false);
if (deferred_render && current_shader != NULL)
{
gPipeline.unbindDeferredShader(*current_shader);
}
if (sShowDebugAlpha)
{
if(gPipeline.canUseWindLightShaders())
{
LLGLSLShader::bindNoShader();
}
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
glColor4f(1,0,0,1);
LLViewerImage::sSmokeImagep->addTextureStats(1024.f*1024.f);
gGL.getTexUnit(0)->bind(LLViewerImage::sSmokeImagep.get(), TRUE);
renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
LLVertexBuffer::MAP_TEXCOORD0);
}
}
void LLDrawPoolAlpha::render(S32 pass)
{
LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA);
LLGLSPipelineAlpha gls_pipeline_alpha;
if (deferred_render && pass == 1)
{ //depth only
gGL.setColorMask(false, false);
}
else
{
gGL.setColorMask(true, true);
}
bool write_depth = LLDrawPoolWater::sSkipScreenCopy
|| (deferred_render && pass == 1)
// we want depth written so that rendered alpha will
// contribute to the alpha mask used for impostors
|| LLPipeline::sImpostorRenderAlphaDepthPass;
LLGLDepthTest depth(GL_TRUE, write_depth ? GL_TRUE : GL_FALSE);
if (deferred_render && pass == 1)
{
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);
if (mVertexShaderLevel > 0)
{
if (LLPipeline::sImpostorRender)
{
fullbright_shader->bind();
fullbright_shader->setMinimumAlpha(0.5f);
simple_shader->bind();
simple_shader->setMinimumAlpha(0.5f);
}
else
{
fullbright_shader->bind();
fullbright_shader->setMinimumAlpha(0.f);
simple_shader->bind();
simple_shader->setMinimumAlpha(0.f);
}
}
else
{
if (LLPipeline::sImpostorRender)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f); //OK
}
else
{
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); //OK
}
}
}
if (mVertexShaderLevel > 0)
{
renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2, pass);
}
else
{
renderAlpha(getVertexDataMask(), pass);
}
gGL.setColorMask(true, false);
if (deferred_render && pass == 1)
{
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
if (sShowDebugAlpha)
{
BOOL shaders = gPipeline.canUseVertexShaders();
if(shaders)
{
gHighlightProgram.bind();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
}
gGL.diffuseColor4f(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);
pushBatches(LLRenderPass::PASS_ALPHA_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
pushBatches(LLRenderPass::PASS_ALPHA_INVISIBLE, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
if(shaders)
{
gHighlightProgram.unbind();
}
}
}
void LLDrawPoolAlpha::render(S32 pass)
{
LLFastTimer t(FTM_RENDER_ALPHA);
S32 mode = gViewerWindow->getMaskMode();
LLGLSPipelineAlpha gls_pipeline_alpha;
if (deferred_render && pass == 1)
{ //depth only
gGL.setColorMask(false, false);
}
else
{
if(mode == MASK_MODE_RIGHT)
{
gGL.setColorMask(false,true,true,true);
}
if(mode == MASK_MODE_LEFT)
{
gGL.setColorMask(true,false,false,true);
}
if(mode == MASK_MODE_NONE)
{
gGL.setColorMask(true, true);
}
}
if (LLPipeline::sAutoMaskAlphaNonDeferred)
{
mColorSFactor = LLRender::BF_ONE; // }
mColorDFactor = LLRender::BF_ZERO; // } these are like disabling blend on the color channels, but we're still blending on the alpha channel so that we can suppress glow
mAlphaSFactor = LLRender::BF_ZERO;
mAlphaDFactor = LLRender::BF_ZERO; // block (zero-out) glow where the alpha test succeeds
gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.33f);
if (mVertexShaderLevel > 0)
{
if (!LLPipeline::sRenderDeferred)
{
simple_shader->bind();
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() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
LLGLSLShader::bindNoShader();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask());
gPipeline.enableLightsDynamic();
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
LLGLDepthTest depth(GL_TRUE, LLDrawPoolWater::sSkipScreenCopy ||
(deferred_render && pass == 1) ? GL_TRUE : GL_FALSE);
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);
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());
}
if(mode == MASK_MODE_RIGHT)
{
gGL.setColorMask(false,true,true,false);
}
if(mode == MASK_MODE_LEFT)
{
gGL.setColorMask(true,false,false,false);
}
if(mode == MASK_MODE_NONE)
{
gGL.setColorMask(true, false);
}
if (deferred_render && pass == 1)
{
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
if (sShowDebugAlpha)
{
if(mVertexShaderLevel > 0)
{ // KL we are using anything above basic shaders so use this ... as we are most likely batching textures
renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
LLVertexBuffer::MAP_TEXTURE_INDEX);
}
else
{ // KL This is the old method
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);
}
}
}
void LLDrawPoolAlpha::render(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_ALPHA);
LLGLSPipelineAlpha gls_pipeline_alpha;
if (deferred_render && pass == 1)
{ //depth only
gGL.setColorMask(false, false);
}
else
{
gGL.setColorMask(true, true);
}
if (LLPipeline::sFastAlpha)
{
mColorSFactor = LLRender::BF_ONE; // }
mColorDFactor = LLRender::BF_ZERO; // } these are like disabling blend on the color channels, but we're still blending on the alpha channel so that we can suppress glow
mAlphaSFactor = LLRender::BF_ZERO;
mAlphaDFactor = LLRender::BF_ZERO; // block (zero-out) glow where the alpha test succeeds
gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
if (mVertexShaderLevel > 0)
{
if (!LLPipeline::sRenderDeferred || !deferred_render)
{
simple_shader->bind();
simple_shader->setAlphaRange(0.33f, 1.f);
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
}
if (fullbright_shader)
{
fullbright_shader->bind();
fullbright_shader->setAlphaRange(0.33f, 1.f);
}
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
//LLGLSLShader::bindNoShader();
}
else
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.33f); //OK
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask());
gPipeline.enableLightsDynamic();
pushBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask());
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); //OK
}
}
LLGLDepthTest depth(GL_TRUE, (LLDrawPoolWater::sSkipScreenCopy ||
(deferred_render && pass == 1)) ? GL_TRUE : GL_FALSE);
if (deferred_render && pass == 1)
{
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);
if (mVertexShaderLevel > 0)
{
if (LLPipeline::sImpostorRender)
{
fullbright_shader->bind();
fullbright_shader->setAlphaRange(0.5f, 1.f);
simple_shader->bind();
simple_shader->setAlphaRange(0.5f, 1.f);
}
else
{
fullbright_shader->bind();
fullbright_shader->setAlphaRange(0.f, 1.f);
simple_shader->bind();
simple_shader->setAlphaRange(0.f, 1.f);
}
}
else
{
if (LLPipeline::sImpostorRender)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f); //OK
}
else
{
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); //OK
}
}
}
if (mVertexShaderLevel > 0)
{
renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX);
}
else
{
renderAlpha(getVertexDataMask());
}
gGL.setColorMask(true, false);
if (deferred_render && pass == 1)
{
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
if (sShowDebugAlpha)
{
BOOL shaders = gPipeline.canUseVertexShaders();
if(shaders)
{
gObjectFullbrightNonIndexedProgram.bind();
}
else
{
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();
}
}
}
