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

Mats.

Browse Source
This commit is contained in:
Shyotl
2013-11-02 01:20:05 -05:00
parent 5e8c7264da
commit af8f8bb040
121 changed files with 8416 additions and 3292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

309
indra/newview/lldrawpoolsimple.cpp
View File

@@ -37,6 +37,7 @@
#include "llviewershadermgr.h"
#include "llrender.h"
#define GE_FORCE_WORKAROUND LL_DARWIN
static LLGLSLShader* simple_shader = NULL;
static LLGLSLShader* fullbright_shader = NULL;
@@ -47,6 +48,7 @@ static LLFastTimer::DeclareTimer FTM_RENDER_GRASS_DEFERRED("Deferred Grass");
void LLDrawPoolGlow::beginPostDeferredPass(S32 pass)
{
gDeferredEmissiveProgram.bind();
gDeferredEmissiveProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
static LLFastTimer::DeclareTimer FTM_RENDER_GLOW_PUSH("Glow Push");
@@ -110,6 +112,14 @@ void LLDrawPoolGlow::render(S32 pass)
LLGLSLShader* shader = LLPipeline::sUnderWaterRender ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
shader->bind();
if (LLPipeline::sRenderDeferred)
{
shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
else
{
shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
}
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
@@ -146,7 +156,11 @@ void LLDrawPoolSimple::beginRenderPass(S32 pass)
{
LLFastTimer t(FTM_RENDER_SIMPLE);
if (LLPipeline::sUnderWaterRender)
if (LLPipeline::sImpostorRender)
{
simple_shader = &gObjectSimpleImpostorProgram;
}
else if (LLPipeline::sUnderWaterRender)
{
simple_shader = &gObjectSimpleWaterProgram;
}
@@ -198,7 +212,11 @@ void LLDrawPoolSimple::render(S32 pass)
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);
pushBatches(LLRenderPass::PASS_BUMP, mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_MATERIAL, mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_SPECMAP, mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_NORMMAP, mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_NORMSPEC, mask, TRUE, TRUE);
}
}
else
@@ -210,6 +228,169 @@ void LLDrawPoolSimple::render(S32 pass)
}
}
static LLFastTimer::DeclareTimer FTM_RENDER_ALPHA_MASK("Alpha Mask");
LLDrawPoolAlphaMask::LLDrawPoolAlphaMask() :
LLRenderPass(POOL_ALPHA_MASK)
{
}
void LLDrawPoolAlphaMask::prerender()
{
mVertexShaderLevel = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
void LLDrawPoolAlphaMask::beginRenderPass(S32 pass)
{
LLFastTimer t(FTM_RENDER_ALPHA_MASK);
if (LLPipeline::sUnderWaterRender)
{
simple_shader = &gObjectSimpleWaterAlphaMaskProgram;
}
else
{
simple_shader = &gObjectSimpleAlphaMaskProgram;
}
if (mVertexShaderLevel > 0)
{
simple_shader->bind();
}
else
{
// don't use shaders!
if (gGLManager.mHasShaderObjects)
{
LLGLSLShader::bindNoShader();
}
}
}
void LLDrawPoolAlphaMask::endRenderPass(S32 pass)
{
LLFastTimer t(FTM_RENDER_ALPHA_MASK);
stop_glerror();
LLRenderPass::endRenderPass(pass);
stop_glerror();
if (mVertexShaderLevel > 0)
{
simple_shader->unbind();
}
}
void LLDrawPoolAlphaMask::render(S32 pass)
{
LLGLDisable blend(GL_BLEND);
LLFastTimer t(FTM_RENDER_ALPHA_MASK);
if (mVertexShaderLevel > 0)
{
simple_shader->bind();
simple_shader->setMinimumAlpha(0.33f);
pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
pushMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
pushMaskBatches(LLRenderPass::PASS_SPECMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
pushMaskBatches(LLRenderPass::PASS_NORMMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
pushMaskBatches(LLRenderPass::PASS_NORMSPEC_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
}
else
{
LLGLEnable test(GL_ALPHA_TEST);
pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask(), TRUE, FALSE);
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); //OK
}
}
LLDrawPoolFullbrightAlphaMask::LLDrawPoolFullbrightAlphaMask() :
LLRenderPass(POOL_FULLBRIGHT_ALPHA_MASK)
{
}
void LLDrawPoolFullbrightAlphaMask::prerender()
{
mVertexShaderLevel = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
void LLDrawPoolFullbrightAlphaMask::beginRenderPass(S32 pass)
{
LLFastTimer t(FTM_RENDER_ALPHA_MASK);
if (LLPipeline::sUnderWaterRender)
{
simple_shader = &gObjectFullbrightWaterAlphaMaskProgram;
}
else
{
simple_shader = &gObjectFullbrightAlphaMaskProgram;
}
if (mVertexShaderLevel > 0)
{
simple_shader->bind();
}
else
{
// don't use shaders!
if (gGLManager.mHasShaderObjects)
{
LLGLSLShader::bindNoShader();
}
}
}
void LLDrawPoolFullbrightAlphaMask::endRenderPass(S32 pass)
{
LLFastTimer t(FTM_RENDER_ALPHA_MASK);
stop_glerror();
LLRenderPass::endRenderPass(pass);
stop_glerror();
if (mVertexShaderLevel > 0)
{
simple_shader->unbind();
}
}
void LLDrawPoolFullbrightAlphaMask::render(S32 pass)
{
LLFastTimer t(FTM_RENDER_ALPHA_MASK);
if (mVertexShaderLevel > 0)
{
if (simple_shader)
{
simple_shader->bind();
simple_shader->setMinimumAlpha(0.33f);
if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
{
simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
} else {
simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
}
pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
//LLGLSLShader::bindNoShader();
}
else
{
LLGLEnable test(GL_ALPHA_TEST);
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask(), TRUE, FALSE);
gPipeline.enableLightsDynamic();
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); //OK
}
}
//===============================
//DEFERRED IMPLEMENTATION
//===============================
@@ -239,6 +420,28 @@ void LLDrawPoolSimple::renderDeferred(S32 pass)
}
}
static LLFastTimer::DeclareTimer FTM_RENDER_ALPHA_MASK_DEFERRED("Deferred Alpha Mask");
void LLDrawPoolAlphaMask::beginDeferredPass(S32 pass)
{
}
void LLDrawPoolAlphaMask::endDeferredPass(S32 pass)
{
}
void LLDrawPoolAlphaMask::renderDeferred(S32 pass)
{
LLFastTimer t(FTM_RENDER_ALPHA_MASK_DEFERRED);
gDeferredDiffuseAlphaMaskProgram.bind();
gDeferredDiffuseAlphaMaskProgram.setMinimumAlpha(0.33f);
pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
gDeferredDiffuseAlphaMaskProgram.unbind();
}
// grass drawpool
LLDrawPoolGrass::LLDrawPoolGrass() :
LLRenderPass(POOL_GRASS)
@@ -345,7 +548,15 @@ void LLDrawPoolFullbright::prerender()
void LLDrawPoolFullbright::beginPostDeferredPass(S32 pass)
{
gDeferredFullbrightProgram.bind();
if (LLPipeline::sUnderWaterRender)
{
gDeferredFullbrightWaterProgram.bind();
}
else
{
gDeferredFullbrightProgram.bind();
}
}
void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
@@ -362,9 +573,15 @@ void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
void LLDrawPoolFullbright::endPostDeferredPass(S32 pass)
{
gDeferredFullbrightProgram.unbind();
if (LLPipeline::sUnderWaterRender)
{
gDeferredFullbrightWaterProgram.unbind();
}
else
{
gDeferredFullbrightProgram.unbind();
}
LLRenderPass::endRenderPass(pass);
}
void LLDrawPoolFullbright::beginRenderPass(S32 pass)
@@ -407,14 +624,24 @@ void LLDrawPoolFullbright::render(S32 pass)
{
fullbright_shader->bind();
fullbright_shader->uniform1f(LLViewerShaderMgr::FULLBRIGHT, 1.f);
fullbright_shader->uniform1f(LLViewerShaderMgr::TEXTURE_GAMMA, 1.f);
U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
pushBatches(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE, fullbright_mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE, fullbright_mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE, fullbright_mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE, fullbright_mask, TRUE, TRUE);
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR;
renderTexture(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask);
pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE, fullbright_mask);
pushBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE, fullbright_mask);
pushBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE, fullbright_mask);
pushBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE, fullbright_mask);
}
stop_glerror();
@@ -425,3 +652,75 @@ S32 LLDrawPoolFullbright::getNumPasses()
return 1;
}
void LLDrawPoolFullbrightAlphaMask::beginPostDeferredPass(S32 pass)
{
if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
{
gObjectFullbrightAlphaMaskProgram.bind();
gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
}
else
{
// Work-around until we can figure out why the right shader causes
// the GeForce driver to go tango uniform on OS X 10.6.8 only
//
#if GE_FORCE_WORKAROUND
gObjectFullbrightAlphaMaskProgram.bind();
gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
#else
if (LLPipeline::sUnderWaterRender)
{
gDeferredFullbrightAlphaMaskWaterProgram.bind();
gDeferredFullbrightAlphaMaskWaterProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
else
{
gDeferredFullbrightAlphaMaskProgram.bind();
gDeferredFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
#endif
}
}
void LLDrawPoolFullbrightAlphaMask::renderPostDeferred(S32 pass)
{
LLFastTimer t(FTM_RENDER_FULLBRIGHT);
LLGLDisable blend(GL_BLEND);
U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, fullbright_mask, TRUE, TRUE);
}
void LLDrawPoolFullbrightAlphaMask::endPostDeferredPass(S32 pass)
{
if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
{
gObjectFullbrightAlphaMaskProgram.unbind();
}
else
{
// Work-around until we can figure out why the right shader causes
// the GeForce driver to go tango uniform on OS X 10.6.8 only
//
#if GE_FORCE_WORKAROUND
gObjectFullbrightAlphaMaskProgram.unbind();
#else
if (LLPipeline::sUnderWaterRender)
{
gDeferredFullbrightAlphaMaskWaterProgram.unbind();
}
else
{
gDeferredFullbrightAlphaMaskProgram.unbind();
}
#endif
}
LLRenderPass::endRenderPass(pass);
}