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

Fix for fullbright bump not working in deferred render. 

Fix for shadow artifacts around split frusta.
Tweak for shadow aliasing with projectors.
Fix for crash on exit in mesh thread.
(transplanted from 6dcf09cd3e524016c8130a0c8af3d9fc95f2d411)
meow-7.2.2
Dave Parks 2010-05-12 03:59:01 -05:00
parent 1928970c6b
commit 6c086be016
11 changed files with 364 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
indra/newview/app_settings/settings.xml
View File

@ -6592,7 +6592,7 @@
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>-0.0005</real>
<real>0.0</real>
</map>
<key>RenderSpotShadowOffset</key>
<map>
@ -6603,7 +6603,7 @@
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>-0.01</real>
<real>0.04</real>
</map>
<key>RenderShadowResolutionScale</key>
@ -6739,7 +6739,7 @@
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1</real>
<real>8</real>
</map>
<key>RenderDeferred</key>

3
indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
View File

@ -77,7 +77,6 @@ float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl)
{
stc.z += spot_shadow_offset;
stc.xyz /= stc.w;
stc.z += spot_shadow_bias*scl;
@ -183,7 +182,7 @@ void main()
gl_FragColor[0] = shadow;
gl_FragColor[1] = 1.0;
spos = vec4(shadow_pos, 1.0);
spos = vec4(shadow_pos+norm*spot_shadow_offset, 1.0);
//spotlight shadow 1
vec4 lpos = shadow_matrix[4]*spos;

1
indra/newview/lldrawpool.h
View File

@ -133,6 +133,7 @@ public:
PASS_FULLBRIGHT_SHINY,
PASS_SHINY,
PASS_BUMP,
PASS_POST_BUMP,
PASS_GLOW,
PASS_ALPHA,
PASS_ALPHA_MASK,

44
indra/newview/lldrawpoolbump.cpp
View File

@ -618,9 +618,9 @@ BOOL LLDrawPoolBump::bindBumpMap(LLDrawInfo& params, S32 channel)
}
//static
void LLDrawPoolBump::beginBump()
void LLDrawPoolBump::beginBump(U32 pass)
{
if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
if (!gPipeline.hasRenderBatches(pass))
{
return;
}
@ -663,9 +663,9 @@ void LLDrawPoolBump::beginBump()
}
//static
void LLDrawPoolBump::renderBump()
void LLDrawPoolBump::renderBump(U32 pass)
{
if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
if (!gPipeline.hasRenderBatches(pass))
{
return;
}
@ -678,13 +678,13 @@ void LLDrawPoolBump::renderBump()
/// Get rid of z-fighting with non-bump pass.
LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1.0f, -1.0f);
renderBump(LLRenderPass::PASS_BUMP, sVertexMask);
renderBump(pass, sVertexMask);
}
//static
void LLDrawPoolBump::endBump()
void LLDrawPoolBump::endBump(U32 pass)
{
if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
if (!gPipeline.hasRenderBatches(pass))
{
return;
}
@ -767,17 +767,41 @@ void LLDrawPoolBump::renderDeferred(S32 pass)
void LLDrawPoolBump::beginPostDeferredPass(S32 pass)
{
beginFullbrightShiny();
switch (pass)
{
case 0:
beginFullbrightShiny();
break;
case 1:
beginBump(LLRenderPass::PASS_POST_BUMP);
break;
}
}
void LLDrawPoolBump::endPostDeferredPass(S32 pass)
{
endFullbrightShiny();
switch (pass)
{
case 0:
endFullbrightShiny();
break;
case 1:
endBump(LLRenderPass::PASS_POST_BUMP);
break;
}
}
void LLDrawPoolBump::renderPostDeferred(S32 pass)
{
renderFullbrightShiny();
switch (pass)
{
case 0:
renderFullbrightShiny();
break;
case 1:
renderBump(LLRenderPass::PASS_POST_BUMP);
break;
}
}
////////////////////////////////////////////////////////////////

8
indra/newview/lldrawpoolbump.h
View File

@ -75,16 +75,16 @@ public:
void renderFullbrightShiny();
void endFullbrightShiny();
void beginBump();
void renderBump();
void endBump();
void beginBump(U32 pass = LLRenderPass::PASS_BUMP);
void renderBump(U32 pass = LLRenderPass::PASS_BUMP);
void endBump(U32 pass = LLRenderPass::PASS_BUMP);
virtual S32 getNumDeferredPasses();
/*virtual*/ void beginDeferredPass(S32 pass);
/*virtual*/ void endDeferredPass(S32 pass);
/*virtual*/ void renderDeferred(S32 pass);
virtual S32 getNumPostDeferredPasses() { return 1; }
virtual S32 getNumPostDeferredPasses() { return 2; }
/*virtual*/ void beginPostDeferredPass(S32 pass);
/*virtual*/ void endPostDeferredPass(S32 pass);
/*virtual*/ void renderPostDeferred(S32 pass);

3
indra/newview/lldrawpoolsimple.cpp
View File

@ -151,7 +151,8 @@ void LLDrawPoolSimple::render(S32 pass)
renderTexture(LLRenderPass::PASS_SIMPLE, getVertexDataMask());
if (LLPipeline::sRenderDeferred)
{
{ //if deferred rendering is enabled, bump faces aren't reigstered as simple
//render bump faces here as simple so bump faces will appear under water
renderTexture(LLRenderPass::PASS_BUMP, getVertexDataMask());
}
}

3
indra/newview/llviewercontrol.cpp
View File

@ -505,6 +505,9 @@ void settings_setup_listeners()
gSavedSettings.getControl("RenderAvatarVP")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
gSavedSettings.getControl("VertexShaderEnable")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
gSavedSettings.getControl("RenderUIBuffer")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
gSavedSettings.getControl("RenderSpecularResX")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
gSavedSettings.getControl("RenderSpecularResY")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
gSavedSettings.getControl("RenderSpecularExponent")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
gSavedSettings.getControl("RenderFSAASamples")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
gSavedSettings.getControl("RenderShadowResolutionScale")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
gSavedSettings.getControl("RenderGlow")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));

8
indra/newview/llviewerdisplay.cpp
View File

@ -930,9 +930,10 @@ void render_hud_attachments()
bool render_particles = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) && gSavedSettings.getBOOL("RenderHUDParticles");
//only render hud objects
U32 mask = gPipeline.getRenderTypeMask();
gPipeline.pushRenderTypeMask();
// turn off everything
gPipeline.setRenderTypeMask(0);
gPipeline.andRenderTypeMask(LLPipeline::END_RENDER_TYPES);
// turn on HUD
gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_HUD);
// turn on HUD particles
@ -986,7 +987,8 @@ void render_hud_attachments()
render_hud_elements();
//restore type mask
gPipeline.setRenderTypeMask(mask);
gPipeline.popRenderTypeMask();
if (has_ui)
{
gPipeline.toggleRenderDebugFeature((void*) LLPipeline::RENDER_DEBUG_FEATURE_UI);

39
indra/newview/llvovolume.cpp
View File

@ -3225,7 +3225,8 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
model_mat = &(drawable->getRegion()->mRenderMatrix);
}
U8 bump = (type == LLRenderPass::PASS_BUMP ? facep->getTextureEntry()->getBumpmap() : 0);
U8 bump = (type == LLRenderPass::PASS_BUMP || type == LLRenderPass::PASS_POST_BUMP) ? facep->getTextureEntry()->getBumpmap() : 0;
LLViewerTexture* tex = facep->getTexture();
@ -3794,66 +3795,76 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
&& group->mSpatialPartition->mPartitionType != LLViewerRegion::PARTITION_HUD
&& LLPipeline::sRenderBump
&& te->getShiny())
{
{ //shiny
if (tex->getPrimaryFormat() == GL_ALPHA)
{
{ //invisiprim+shiny
registerFace(group, facep, LLRenderPass::PASS_INVISI_SHINY);
registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
}
else if (LLPipeline::sRenderDeferred)
{
{ //deferred rendering
if (te->getFullbright())
{
{ //register in post deferred fullbright shiny pass
registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
if (te->getBumpmap())
{ //register in post deferred bump pass
registerFace(group, facep, LLRenderPass::PASS_POST_BUMP);
}
}
else if (te->getBumpmap())
{
{ //register in deferred bump pass
registerFace(group, facep, LLRenderPass::PASS_BUMP);
}
else
{
{ //register in deferred simple pass (deferred simple includes shiny)
llassert(mask & LLVertexBuffer::MAP_NORMAL);
registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
}
}
else if (fullbright)
{
{ //not deferred, register in standard fullbright shiny pass
registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
}
else
{
{ //not deferred or fullbright, register in standard shiny pass
registerFace(group, facep, LLRenderPass::PASS_SHINY);
}
}
else
{
{ //not alpha and not shiny
if (!is_alpha && tex->getPrimaryFormat() == GL_ALPHA)
{
{ //invisiprim
registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
}
else if (fullbright)
{
{ //fullbright
registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT);
if (LLPipeline::sRenderDeferred && LLPipeline::sRenderBump && te->getBumpmap())
{ //if this is the deferred render and a bump map is present, register in post deferred bump
registerFace(group, facep, LLRenderPass::PASS_POST_BUMP);
}
}
else
{
if (LLPipeline::sRenderDeferred && LLPipeline::sRenderBump && te->getBumpmap())
{
{ //non-shiny or fullbright deferred bump
registerFace(group, facep, LLRenderPass::PASS_BUMP);
}
else
{
{ //all around simple
llassert(mask & LLVertexBuffer::MAP_NORMAL);
registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
}
}
//not sure why this is here -- shiny HUD attachments maybe? -- davep 5/11/2010
if (!is_alpha && te->getShiny() && LLPipeline::sRenderBump)
{
registerFace(group, facep, LLRenderPass::PASS_SHINY);
}
}
//not sure why this is here, and looks like it might cause bump mapped objects to get rendered redundantly -- davep 5/11/2010
if (!is_alpha && !LLPipeline::sRenderDeferred)
{
llassert((mask & LLVertexBuffer::MAP_NORMAL) || fullbright);

395
indra/newview/pipeline.cpp
View File

@ -329,7 +329,6 @@ LLPipeline::LLPipeline() :
mInitialized(FALSE),
mVertexShadersEnabled(FALSE),
mVertexShadersLoaded(0),
mRenderTypeMask(0),
mRenderDebugFeatureMask(0),
mRenderDebugMask(0),
mOldRenderDebugMask(0),
@ -383,7 +382,11 @@ void LLPipeline::init()
LLViewerStats::getInstance()->mTrianglesDrawnStat.reset();
resetFrameStats();
mRenderTypeMask = 0xffffffff; // All render types start on
for (U32 i = 0; i < NUM_RENDER_TYPES; ++i)
{
mRenderTypeEnabled[i] = TRUE; //all rendering types start enabled
}
mRenderDebugFeatureMask = 0xffffffff; // All debugging features on
mRenderDebugMask = 0; // All debug starts off
@ -2205,14 +2208,13 @@ static LLFastTimer::DeclareTimer FTM_RESET_DRAWORDER("Reset Draw Order");
void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
{
const U32 face_mask = (1 << LLPipeline::RENDER_TYPE_AVATAR) |
(1 << LLPipeline::RENDER_TYPE_GROUND) |
(1 << LLPipeline::RENDER_TYPE_TERRAIN) |
(1 << LLPipeline::RENDER_TYPE_TREE) |
(1 << LLPipeline::RENDER_TYPE_SKY) |
(1 << LLPipeline::RENDER_TYPE_WATER);
if (mRenderTypeMask & face_mask)
if (hasAnyRenderType(LLPipeline::RENDER_TYPE_AVATAR,
LLPipeline::RENDER_TYPE_GROUND,
LLPipeline::RENDER_TYPE_TERRAIN,
LLPipeline::RENDER_TYPE_TREE,
LLPipeline::RENDER_TYPE_SKY,
LLPipeline::RENDER_TYPE_WATER,
LLPipeline::END_RENDER_TYPES))
{
//clear faces from face pools
LLFastTimer t(FTM_RESET_DRAWORDER);
@ -4990,8 +4992,7 @@ void LLPipeline::setLight(LLDrawable *drawablep, BOOL is_light)
//static
void LLPipeline::toggleRenderType(U32 type)
{
U32 bit = (1<<type);
gPipeline.mRenderTypeMask ^= bit;
gPipeline.mRenderTypeEnabled[type] = !gPipeline.mRenderTypeEnabled[type];
}
//static
@ -6617,15 +6618,16 @@ void LLPipeline::renderDeferredLighting()
LLGLDisable stencil(GL_STENCIL_TEST);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
U32 render_mask = mRenderTypeMask;
mRenderTypeMask = mRenderTypeMask &
((1 << LLPipeline::RENDER_TYPE_SKY) |
(1 << LLPipeline::RENDER_TYPE_CLOUDS) |
(1 << LLPipeline::RENDER_TYPE_WL_SKY));
gPipeline.pushRenderTypeMask();
gPipeline.andRenderTypeMask(LLPipeline::RENDER_TYPE_SKY,
LLPipeline::RENDER_TYPE_CLOUDS,
LLPipeline::RENDER_TYPE_WL_SKY,
LLPipeline::END_RENDER_TYPES);
renderGeomPostDeferred(*LLViewerCamera::getInstance());
mRenderTypeMask = render_mask;
gPipeline.popRenderTypeMask();
}
BOOL render_local = gSavedSettings.getBOOL("RenderDeferredLocalLights");
@ -6947,29 +6949,30 @@ void LLPipeline::renderDeferredLighting()
LLGLDisable blend(GL_BLEND);
LLGLDisable stencil(GL_STENCIL_TEST);
U32 render_mask = mRenderTypeMask;
mRenderTypeMask = mRenderTypeMask &
((1 << LLPipeline::RENDER_TYPE_ALPHA) |
(1 << LLPipeline::RENDER_TYPE_FULLBRIGHT) |
(1 << LLPipeline::RENDER_TYPE_VOLUME) |
(1 << LLPipeline::RENDER_TYPE_GLOW) |
(1 << LLPipeline::RENDER_TYPE_BUMP) |
(1 << LLPipeline::RENDER_TYPE_PASS_SIMPLE) |
(1 << LLPipeline::RENDER_TYPE_PASS_ALPHA) |
(1 << LLPipeline::RENDER_TYPE_PASS_ALPHA_MASK) |
(1 << LLPipeline::RENDER_TYPE_PASS_BUMP) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY) |
(1 << LLPipeline::RENDER_TYPE_PASS_GLOW) |
(1 << LLPipeline::RENDER_TYPE_PASS_GRASS) |
(1 << LLPipeline::RENDER_TYPE_PASS_SHINY) |
(1 << LLPipeline::RENDER_TYPE_PASS_INVISIBLE) |
(1 << LLPipeline::RENDER_TYPE_PASS_INVISI_SHINY) |
(1 << LLPipeline::RENDER_TYPE_AVATAR));
pushRenderTypeMask();
andRenderTypeMask(LLPipeline::RENDER_TYPE_ALPHA,
LLPipeline::RENDER_TYPE_FULLBRIGHT,
LLPipeline::RENDER_TYPE_VOLUME,
LLPipeline::RENDER_TYPE_GLOW,
LLPipeline::RENDER_TYPE_BUMP,
LLPipeline::RENDER_TYPE_PASS_SIMPLE,
LLPipeline::RENDER_TYPE_PASS_ALPHA,
LLPipeline::RENDER_TYPE_PASS_ALPHA_MASK,
LLPipeline::RENDER_TYPE_PASS_BUMP,
LLPipeline::RENDER_TYPE_PASS_POST_BUMP,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY,
LLPipeline::RENDER_TYPE_PASS_GLOW,
LLPipeline::RENDER_TYPE_PASS_GRASS,
LLPipeline::RENDER_TYPE_PASS_SHINY,
LLPipeline::RENDER_TYPE_PASS_INVISIBLE,
LLPipeline::RENDER_TYPE_PASS_INVISI_SHINY,
LLPipeline::RENDER_TYPE_AVATAR,
END_RENDER_TYPES);
renderGeomPostDeferred(*LLViewerCamera::getInstance());
mRenderTypeMask = render_mask;
popRenderTypeMask();
}
{
@ -7224,8 +7227,8 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
LLPipeline::sUseOcclusion = llmin(occlusion, 1);
U32 type_mask = gPipeline.mRenderTypeMask;
gPipeline.pushRenderTypeMask();
glh::matrix4f projection = glh_get_current_projection();
glh::matrix4f mat;
@ -7293,43 +7296,48 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
glCullFace(GL_FRONT);
static LLCullResult ref_result;
U32 ref_mask = 0;
if (LLDrawPoolWater::sNeedsDistortionUpdate)
{
//initial sky pass (no user clip plane)
{ //mask out everything but the sky
U32 tmp = mRenderTypeMask;
mRenderTypeMask = tmp & ((1 << LLPipeline::RENDER_TYPE_SKY) |
(1 << LLPipeline::RENDER_TYPE_WL_SKY));
gPipeline.pushRenderTypeMask();
gPipeline.andRenderTypeMask(LLPipeline::RENDER_TYPE_SKY,
LLPipeline::RENDER_TYPE_WL_SKY,
LLPipeline::END_RENDER_TYPES);
static LLCullResult result;
updateCull(camera, result);
llpushcallstacks ;
stateSort(camera, result);
mRenderTypeMask = tmp & ((1 << LLPipeline::RENDER_TYPE_SKY) |
(1 << LLPipeline::RENDER_TYPE_CLOUDS) |
(1 << LLPipeline::RENDER_TYPE_WL_SKY));
andRenderTypeMask(LLPipeline::RENDER_TYPE_SKY,
LLPipeline::RENDER_TYPE_CLOUDS,
LLPipeline::RENDER_TYPE_WL_SKY,
LLPipeline::END_RENDER_TYPES);
renderGeom(camera, TRUE);
mRenderTypeMask = tmp;
gPipeline.popRenderTypeMask();
}
U32 mask = mRenderTypeMask;
mRenderTypeMask &= ~((1<<LLPipeline::RENDER_TYPE_WATER) |
(1<<LLPipeline::RENDER_TYPE_GROUND) |
(1<<LLPipeline::RENDER_TYPE_SKY) |
(1<<LLPipeline::RENDER_TYPE_CLOUDS));
gPipeline.pushRenderTypeMask();
clearRenderTypeMask(LLPipeline::RENDER_TYPE_WATER,
LLPipeline::RENDER_TYPE_GROUND,
LLPipeline::RENDER_TYPE_SKY,
LLPipeline::RENDER_TYPE_CLOUDS,
LLPipeline::END_RENDER_TYPES);
S32 detail = gSavedSettings.getS32("RenderReflectionDetail");
if (detail > 0)
{ //mask out selected geometry based on reflection detail
if (detail < 4)
{
mRenderTypeMask &= ~(1 << LLPipeline::RENDER_TYPE_PARTICLES);
clearRenderTypeMask(LLPipeline::RENDER_TYPE_PARTICLES, END_RENDER_TYPES);
if (detail < 3)
{
mRenderTypeMask &= ~(1 << LLPipeline::RENDER_TYPE_AVATAR);
clearRenderTypeMask(LLPipeline::RENDER_TYPE_AVATAR, END_RENDER_TYPES);
if (detail < 2)
{
mRenderTypeMask &= ~(1 << LLPipeline::RENDER_TYPE_VOLUME);
clearRenderTypeMask(LLPipeline::RENDER_TYPE_VOLUME, END_RENDER_TYPES);
}
}
}
@ -7341,18 +7349,17 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
stateSort(camera, ref_result);
}
ref_mask = mRenderTypeMask;
mRenderTypeMask = mask;
}
if (LLDrawPoolWater::sNeedsDistortionUpdate)
{
mRenderTypeMask = ref_mask;
if (gSavedSettings.getS32("RenderReflectionDetail") > 0)
if (LLDrawPoolWater::sNeedsDistortionUpdate)
{
gPipeline.grabReferences(ref_result);
LLGLUserClipPlane clip_plane(plane, mat, projection);
renderGeom(camera);
if (gSavedSettings.getS32("RenderReflectionDetail") > 0)
{
gPipeline.grabReferences(ref_result);
LLGLUserClipPlane clip_plane(plane, mat, projection);
renderGeom(camera);
}
}
gPipeline.popRenderTypeMask();
}
glCullFace(GL_BACK);
glPopMatrix();
@ -7366,18 +7373,20 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
if (last_update)
{
camera.setFar(camera_in.getFar());
mRenderTypeMask = type_mask & (~(1<<LLPipeline::RENDER_TYPE_WATER) |
(1<<LLPipeline::RENDER_TYPE_GROUND));
clearRenderTypeMask(LLPipeline::RENDER_TYPE_WATER,
LLPipeline::RENDER_TYPE_GROUND,
END_RENDER_TYPES);
stop_glerror();
LLPipeline::sUnderWaterRender = LLViewerCamera::getInstance()->cameraUnderWater() ? FALSE : TRUE;
if (LLPipeline::sUnderWaterRender)
{
mRenderTypeMask &= ~((1<<LLPipeline::RENDER_TYPE_GROUND) |
(1<<LLPipeline::RENDER_TYPE_SKY) |
(1<<LLPipeline::RENDER_TYPE_CLOUDS) |
(1<<LLPipeline::RENDER_TYPE_WL_SKY));
clearRenderTypeMask(LLPipeline::RENDER_TYPE_GROUND,
LLPipeline::RENDER_TYPE_SKY,
LLPipeline::RENDER_TYPE_CLOUDS,
LLPipeline::RENDER_TYPE_WL_SKY,
END_RENDER_TYPES);
}
LLViewerCamera::updateFrustumPlanes(camera);
@ -7419,7 +7428,7 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
}
glClearColor(0.f, 0.f, 0.f, 0.f);
gViewerWindow->setup3DViewport();
mRenderTypeMask = type_mask;
gPipeline.popRenderTypeMask();
LLDrawPoolWater::sNeedsReflectionUpdate = FALSE;
LLDrawPoolWater::sNeedsDistortionUpdate = FALSE;
LLViewerCamera::getInstance()->setUserClipPlane(LLPlane(-pnorm, -pd));
@ -7874,21 +7883,22 @@ void LLPipeline::generateGI(LLCamera& camera, LLVector3& lightDir, std::vector<L
sun_cam.ignoreAgentFrustumPlane(LLCamera::AGENT_PLANE_NEAR);
static LLCullResult result;
U32 type_mask = mRenderTypeMask;
pushRenderTypeMask();
mRenderTypeMask = type_mask & ((1<<LLPipeline::RENDER_TYPE_SIMPLE) |
(1<<LLPipeline::RENDER_TYPE_FULLBRIGHT) |
(1<<LLPipeline::RENDER_TYPE_BUMP) |
(1<<LLPipeline::RENDER_TYPE_VOLUME) |
(1<<LLPipeline::RENDER_TYPE_TREE) |
(1<<LLPipeline::RENDER_TYPE_TERRAIN) |
(1<<LLPipeline::RENDER_TYPE_WATER) |
(1<<LLPipeline::RENDER_TYPE_PASS_ALPHA_SHADOW) |
(1<<LLPipeline::RENDER_TYPE_AVATAR) |
(1 << LLPipeline::RENDER_TYPE_PASS_SIMPLE) |
(1 << LLPipeline::RENDER_TYPE_PASS_BUMP) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT) |
(1 << LLPipeline::RENDER_TYPE_PASS_SHINY));
andRenderTypeMask(LLPipeline::RENDER_TYPE_SIMPLE,
LLPipeline::RENDER_TYPE_FULLBRIGHT,
LLPipeline::RENDER_TYPE_BUMP,
LLPipeline::RENDER_TYPE_VOLUME,
LLPipeline::RENDER_TYPE_TREE,
LLPipeline::RENDER_TYPE_TERRAIN,
LLPipeline::RENDER_TYPE_WATER,
LLPipeline::RENDER_TYPE_PASS_ALPHA_SHADOW,
LLPipeline::RENDER_TYPE_AVATAR,
LLPipeline::RENDER_TYPE_PASS_SIMPLE,
LLPipeline::RENDER_TYPE_PASS_BUMP,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT,
LLPipeline::RENDER_TYPE_PASS_SHINY,
END_RENDER_TYPES);
@ -7957,7 +7967,7 @@ void LLPipeline::generateGI(LLCamera& camera, LLVector3& lightDir, std::vector<L
LLPipeline::sShadowRender = FALSE;
sMinRenderSize = 0.f;
mRenderTypeMask = type_mask;
popRenderTypeMask();
}
@ -8054,23 +8064,24 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
last_projection[i] = gGLLastProjection[i];
}
U32 type_mask = mRenderTypeMask;
mRenderTypeMask = type_mask & ((1<<LLPipeline::RENDER_TYPE_SIMPLE) |
(1<<LLPipeline::RENDER_TYPE_ALPHA) |
(1<<LLPipeline::RENDER_TYPE_GRASS) |
(1<<LLPipeline::RENDER_TYPE_FULLBRIGHT) |
(1<<LLPipeline::RENDER_TYPE_BUMP) |
(1<<LLPipeline::RENDER_TYPE_VOLUME) |
(1<<LLPipeline::RENDER_TYPE_AVATAR) |
(1<<LLPipeline::RENDER_TYPE_TREE) |
(1<<LLPipeline::RENDER_TYPE_TERRAIN) |
(1<<LLPipeline::RENDER_TYPE_WATER) |
(1<<LLPipeline::RENDER_TYPE_PASS_ALPHA_SHADOW) |
(1 << LLPipeline::RENDER_TYPE_PASS_SIMPLE) |
(1 << LLPipeline::RENDER_TYPE_PASS_BUMP) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT) |
(1 << LLPipeline::RENDER_TYPE_PASS_SHINY) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY));
pushRenderTypeMask();
andRenderTypeMask(LLPipeline::RENDER_TYPE_SIMPLE,
LLPipeline::RENDER_TYPE_ALPHA,
LLPipeline::RENDER_TYPE_GRASS,
LLPipeline::RENDER_TYPE_FULLBRIGHT,
LLPipeline::RENDER_TYPE_BUMP,
LLPipeline::RENDER_TYPE_VOLUME,
LLPipeline::RENDER_TYPE_AVATAR,
LLPipeline::RENDER_TYPE_TREE,
LLPipeline::RENDER_TYPE_TERRAIN,
LLPipeline::RENDER_TYPE_WATER,
LLPipeline::RENDER_TYPE_PASS_ALPHA_SHADOW,
LLPipeline::RENDER_TYPE_PASS_SIMPLE,
LLPipeline::RENDER_TYPE_PASS_BUMP,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT,
LLPipeline::RENDER_TYPE_PASS_SHINY,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY,
END_RENDER_TYPES);
gGL.setColorMask(false, false);
@ -8147,7 +8158,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
mShadowFrustPoints[2].clear();
mShadowFrustPoints[3].clear();
}
mRenderTypeMask = type_mask;
popRenderTypeMask();
return;
}
@ -8233,10 +8244,11 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
for (U32 i = 0; i < 4; i++)
{
LLVector3 delta = frust[i+4]-eye;
delta += (frust[i+4]-frust[(i+2)%4+4])*0.05f;
delta.normVec();
F32 dp = delta*pn;
frust[i] = eye + (delta*dist[j])/dp;
frust[i+4] = eye + (delta*dist[j+1])/dp;
frust[i] = eye + (delta*dist[j]*0.95f)/dp;
frust[i+4] = eye + (delta*dist[j+1]*1.05f)/dp;
}
shadow_cam.calcAgentFrustumPlanes(frust);
@ -8748,7 +8760,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
gGLLastProjection[i] = last_projection[i];
}
mRenderTypeMask = type_mask;
popRenderTypeMask();
}
void LLPipeline::renderGroups(LLRenderPass* pass, U32 type, U32 mask, BOOL texture)
@ -8784,38 +8796,36 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
assertInitialized();
U32 mask;
BOOL muted = LLMuteList::getInstance()->isMuted(avatar->getID());
pushRenderTypeMask();
if (muted)
{
mask = 1 << LLPipeline::RENDER_TYPE_AVATAR;
andRenderTypeMask(LLPipeline::RENDER_TYPE_AVATAR, END_RENDER_TYPES);
}
else
{
mask = (1<<LLPipeline::RENDER_TYPE_VOLUME) |
(1<<LLPipeline::RENDER_TYPE_AVATAR) |
(1<<LLPipeline::RENDER_TYPE_BUMP) |
(1<<LLPipeline::RENDER_TYPE_GRASS) |
(1<<LLPipeline::RENDER_TYPE_SIMPLE) |
(1<<LLPipeline::RENDER_TYPE_FULLBRIGHT) |
(1<<LLPipeline::RENDER_TYPE_ALPHA) |
(1<<LLPipeline::RENDER_TYPE_INVISIBLE) |
(1 << LLPipeline::RENDER_TYPE_PASS_SIMPLE) |
(1 << LLPipeline::RENDER_TYPE_PASS_ALPHA) |
(1 << LLPipeline::RENDER_TYPE_PASS_ALPHA_MASK) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK) |
(1 << LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY) |
(1 << LLPipeline::RENDER_TYPE_PASS_SHINY) |
(1 << LLPipeline::RENDER_TYPE_PASS_INVISIBLE) |
(1 << LLPipeline::RENDER_TYPE_PASS_INVISI_SHINY);
andRenderTypeMask(LLPipeline::RENDER_TYPE_VOLUME,
LLPipeline::RENDER_TYPE_AVATAR,
LLPipeline::RENDER_TYPE_BUMP,
LLPipeline::RENDER_TYPE_GRASS,
LLPipeline::RENDER_TYPE_SIMPLE,
LLPipeline::RENDER_TYPE_FULLBRIGHT,
LLPipeline::RENDER_TYPE_ALPHA,
LLPipeline::RENDER_TYPE_INVISIBLE,
LLPipeline::RENDER_TYPE_PASS_SIMPLE,
LLPipeline::RENDER_TYPE_PASS_ALPHA,
LLPipeline::RENDER_TYPE_PASS_ALPHA_MASK,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY,
LLPipeline::RENDER_TYPE_PASS_SHINY,
LLPipeline::RENDER_TYPE_PASS_INVISIBLE,
LLPipeline::RENDER_TYPE_PASS_INVISI_SHINY,
END_RENDER_TYPES);
}
mask = mask & gPipeline.getRenderTypeMask();
U32 saved_mask = gPipeline.mRenderTypeMask;
gPipeline.mRenderTypeMask = mask;
S32 occlusion = sUseOcclusion;
sUseOcclusion = 0;
sReflectionRender = sRenderDeferred ? FALSE : TRUE;
@ -8989,7 +8999,7 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
sReflectionRender = FALSE;
sImpostorRender = FALSE;
sShadowRender = FALSE;
gPipeline.mRenderTypeMask = saved_mask;
popRenderTypeMask();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
@ -9030,4 +9040,121 @@ LLCullResult::sg_list_t::iterator LLPipeline::endAlphaGroups()
return sCull->endAlphaGroups();
}
BOOL LLPipeline::hasRenderType(const U32 type) const
{
return mRenderTypeEnabled[type];
}
void LLPipeline::setRenderTypeMask(U32 type, ...)
{
va_list args;
va_start(args, type);
while (type < END_RENDER_TYPES)
{
mRenderTypeEnabled[type] = TRUE;
type = va_arg(args, U32);
}
va_end(args);
if (type > END_RENDER_TYPES)
{
llerrs << "Invalid render type." << llendl;
}
}
BOOL LLPipeline::hasAnyRenderType(U32 type, ...) const
{
va_list args;
va_start(args, type);
while (type < END_RENDER_TYPES)
{
if (mRenderTypeEnabled[type])
{
return TRUE;
}
type = va_arg(args, U32);
}
va_end(args);
if (type > END_RENDER_TYPES)
{
llerrs << "Invalid render type." << llendl;
}
return FALSE;
}
void LLPipeline::pushRenderTypeMask()
{
std::string cur_mask;
cur_mask.assign((const char*) mRenderTypeEnabled, sizeof(mRenderTypeEnabled));
mRenderTypeEnableStack.push(cur_mask);
}
void LLPipeline::popRenderTypeMask()
{
if (mRenderTypeEnableStack.empty())
{
llerrs << "Depleted render type stack." << llendl;
}
memcpy(mRenderTypeEnabled, mRenderTypeEnableStack.top().data(), sizeof(mRenderTypeEnabled));
mRenderTypeEnableStack.pop();
}
void LLPipeline::andRenderTypeMask(U32 type, ...)
{
va_list args;
BOOL tmp[NUM_RENDER_TYPES];
for (U32 i = 0; i < NUM_RENDER_TYPES; ++i)
{
tmp[i] = FALSE;
}
va_start(args, type);
while (type < END_RENDER_TYPES)
{
if (mRenderTypeEnabled[type])
{
tmp[type] = TRUE;
}
type = va_arg(args, U32);
}
va_end(args);
if (type > END_RENDER_TYPES)
{
llerrs << "Invalid render type." << llendl;
}
for (U32 i = 0; i < LLPipeline::NUM_RENDER_TYPES; ++i)
{
mRenderTypeEnabled[i] = tmp[i];
}
}
void LLPipeline::clearRenderTypeMask(U32 type, ...)
{
va_list args;
va_start(args, type);
while (type < END_RENDER_TYPES)
{
mRenderTypeEnabled[type] = FALSE;
type = va_arg(args, U32);
}
va_end(args);
if (type > END_RENDER_TYPES)
{
llerrs << "Invalid render type." << llendl;
}
}

30
indra/newview/pipeline.h
View File

@ -46,6 +46,8 @@
#include "lldrawable.h"
#include "llrendertarget.h"
#include <stack>
class LLViewerTexture;
class LLEdge;
class LLFace;
@ -277,12 +279,25 @@ public:
LLCullResult::sg_list_t::iterator beginAlphaGroups();
LLCullResult::sg_list_t::iterator endAlphaGroups();
void addTrianglesDrawn(S32 index_count, U32 render_type = LLRender::TRIANGLES);
BOOL hasRenderType(const U32 type) const { return (type && (mRenderTypeMask & (1<<type))) ? TRUE : FALSE; }
BOOL hasRenderDebugFeatureMask(const U32 mask) const { return (mRenderDebugFeatureMask & mask) ? TRUE : FALSE; }
BOOL hasRenderDebugMask(const U32 mask) const { return (mRenderDebugMask & mask) ? TRUE : FALSE; }
void setRenderTypeMask(const U32 mask) { mRenderTypeMask = mask; }
U32 getRenderTypeMask() const { return mRenderTypeMask; }
BOOL hasRenderType(const U32 type) const;
BOOL hasAnyRenderType(const U32 type, ...) const;
void setRenderTypeMask(U32 type, ...);
void orRenderTypeMask(U32 type, ...);
void andRenderTypeMask(U32 type, ...);
void clearRenderTypeMask(U32 type, ...);
void pushRenderTypeMask();
void popRenderTypeMask();
static void toggleRenderType(U32 type);
// For UI control of render features
@ -360,6 +375,7 @@ public:
RENDER_TYPE_PASS_FULLBRIGHT_SHINY = LLRenderPass::PASS_FULLBRIGHT_SHINY,
RENDER_TYPE_PASS_SHINY = LLRenderPass::PASS_SHINY,
RENDER_TYPE_PASS_BUMP = LLRenderPass::PASS_BUMP,
RENDER_TYPE_PASS_POST_BUMP = LLRenderPass::PASS_POST_BUMP,
RENDER_TYPE_PASS_GLOW = LLRenderPass::PASS_GLOW,
RENDER_TYPE_PASS_ALPHA = LLRenderPass::PASS_ALPHA,
RENDER_TYPE_PASS_ALPHA_MASK = LLRenderPass::PASS_ALPHA_MASK,
@ -370,7 +386,9 @@ public:
RENDER_TYPE_VOLUME,
RENDER_TYPE_PARTICLES,
RENDER_TYPE_CLOUDS,
RENDER_TYPE_HUD_PARTICLES
RENDER_TYPE_HUD_PARTICLES,
NUM_RENDER_TYPES,
END_RENDER_TYPES = NUM_RENDER_TYPES
};
enum LLRenderDebugFeatureMask
@ -533,7 +551,9 @@ public:
S32 mVertexShadersLoaded; // 0 = no, 1 = yes, -1 = failed
protected:
U32 mRenderTypeMask;
BOOL mRenderTypeEnabled[NUM_RENDER_TYPES];
std::stack<std::string> mRenderTypeEnableStack;
U32 mRenderDebugFeatureMask;
U32 mRenderDebugMask;