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(); } } }