游戏引擎

开发平台：

C++ Builder

pipeline.cpp：源码内容

/**
* @file pipeline.cpp
* @brief Rendering pipeline.
*
* $LicenseInfo:firstyear=2005&license=viewergpl$
*
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "pipeline.h"
// library includes
#include "llaudioengine.h" // For debugging.
#include "imageids.h"
#include "llerror.h"
#include "llviewercontrol.h"
#include "llfasttimer.h"
#include "llfontgl.h"
#include "llmemtype.h"
#include "llnamevalue.h"
#include "llpointer.h"
#include "llprimitive.h"
#include "llvolume.h"
#include "material_codes.h"
#include "timing.h"
#include "v3color.h"
#include "llui.h"
#include "llglheaders.h"
#include "llrender.h"
#include "llwindow.h" // swapBuffers()
// newview includes
#include "llagent.h"
#include "lldrawable.h"
#include "lldrawpoolalpha.h"
#include "lldrawpoolavatar.h"
#include "lldrawpoolground.h"
#include "lldrawpoolbump.h"
#include "lldrawpooltree.h"
#include "lldrawpoolwater.h"
#include "llface.h"
#include "llfeaturemanager.h"
#include "llfloatertelehub.h"
#include "llfloaterreg.h"
#include "llgldbg.h"
#include "llhudmanager.h"
#include "lllightconstants.h"
#include "llresmgr.h"
#include "llselectmgr.h"
#include "llsky.h"
#include "lltracker.h"
#include "lltool.h"
#include "lltoolmgr.h"
#include "llviewercamera.h"
#include "llviewertexturelist.h"
#include "llviewerobject.h"
#include "llviewerobjectlist.h"
#include "llviewerparcelmgr.h"
#include "llviewerregion.h" // for audio debugging.
#include "llviewerwindow.h" // For getSpinAxis
#include "llvoavatarself.h"
#include "llvoground.h"
#include "llvosky.h"
#include "llvotree.h"
#include "llvovolume.h"
#include "llvosurfacepatch.h"
#include "llvowater.h"
#include "llvotree.h"
#include "llvopartgroup.h"
#include "llworld.h"
#include "llcubemap.h"
#include "llviewershadermgr.h"
#include "llviewerstats.h"
#include "llviewerjoystick.h"
#include "llviewerdisplay.h"
#include "llwlparammanager.h"
#include "llwaterparammanager.h"
#include "llspatialpartition.h"
#include "llmutelist.h"
#include "lltoolpie.h"
#ifdef _DEBUG
// Debug indices is disabled for now for debug performance - djs 4/24/02
//#define DEBUG_INDICES
#else
//#define DEBUG_INDICES
#endif
const F32 BACKLIGHT_DAY_MAGNITUDE_AVATAR = 0.2f;
const F32 BACKLIGHT_NIGHT_MAGNITUDE_AVATAR = 0.1f;
const F32 BACKLIGHT_DAY_MAGNITUDE_OBJECT = 0.1f;
const F32 BACKLIGHT_NIGHT_MAGNITUDE_OBJECT = 0.08f;
const S32 MAX_ACTIVE_OBJECT_QUIET_FRAMES = 40;
const S32 MAX_OFFSCREEN_GEOMETRY_CHANGES_PER_FRAME = 10;
const U32 REFLECTION_MAP_RES = 128;
// Max number of occluders to search for. JC
const S32 MAX_OCCLUDER_COUNT = 2;
extern S32 gBoxFrame;
//extern BOOL gHideSelectedObjects;
extern BOOL gDisplaySwapBuffers;
extern BOOL gDebugGL;
// hack counter for rendering a fixed number of frames after toggling
// fullscreen to work around DEV-5361
static S32 sDelayedVBOEnable = 0;
BOOL gAvatarBacklight = FALSE;
BOOL gRenderForSelect = FALSE;
BOOL gDebugPipeline = FALSE;
LLPipeline gPipeline;
const LLMatrix4* gGLLastMatrix = NULL;
LLFastTimer::DeclareTimer FTM_RENDER_GEOMETRY("Geometry");
LLFastTimer::DeclareTimer FTM_RENDER_GRASS("Grass");
LLFastTimer::DeclareTimer FTM_RENDER_INVISIBLE("Invisible");
LLFastTimer::DeclareTimer FTM_RENDER_OCCLUSION("Occlusion");
LLFastTimer::DeclareTimer FTM_RENDER_SHINY("Shiny");
LLFastTimer::DeclareTimer FTM_RENDER_SIMPLE("Simple");
LLFastTimer::DeclareTimer FTM_RENDER_TERRAIN("Terrain");
LLFastTimer::DeclareTimer FTM_RENDER_TREES("Trees");
LLFastTimer::DeclareTimer FTM_RENDER_UI("UI");
LLFastTimer::DeclareTimer FTM_RENDER_WATER("Water");
LLFastTimer::DeclareTimer FTM_RENDER_WL_SKY("Windlight Sky");
LLFastTimer::DeclareTimer FTM_RENDER_ALPHA("Alpha Objects");
LLFastTimer::DeclareTimer FTM_RENDER_CHARACTERS("Avatars");
LLFastTimer::DeclareTimer FTM_RENDER_BUMP("Bump");
LLFastTimer::DeclareTimer FTM_RENDER_FULLBRIGHT("Fullbright");
LLFastTimer::DeclareTimer FTM_RENDER_GLOW("Glow");
LLFastTimer::DeclareTimer FTM_GEO_UPDATE("Geo Update");
LLFastTimer::DeclareTimer FTM_POOLRENDER("RenderPool");
LLFastTimer::DeclareTimer FTM_POOLS("Pools");
LLFastTimer::DeclareTimer FTM_RENDER_BLOOM_FBO("First FBO");
LLFastTimer::DeclareTimer FTM_STATESORT("Sort Draw State");
LLFastTimer::DeclareTimer FTM_PIPELINE("Pipeline");
LLFastTimer::DeclareTimer FTM_CLIENT_COPY("Client Copy");
LLFastTimer::DeclareTimer FTM_RENDER_DEFERRED("Deferred Shading");
static LLFastTimer::DeclareTimer FTM_STATESORT_DRAWABLE("Sort Drawables");
static LLFastTimer::DeclareTimer FTM_STATESORT_POSTSORT("Post Sort");
//----------------------------------------
std::string gPoolNames[] =
{
// Correspond to LLDrawpool enum render type
"NONE",
"POOL_SIMPLE",
"POOL_TERRAIN",
"POOL_BUMP",
"POOL_TREE",
"POOL_SKY",
"POOL_WL_SKY",
"POOL_GROUND",
"POOL_INVISIBLE",
"POOL_AVATAR",
"POOL_WATER",
"POOL_GRASS",
"POOL_FULLBRIGHT",
"POOL_GLOW",
"POOL_ALPHA",
};
void drawBox(const LLVector3& c, const LLVector3& r);
U32 nhpo2(U32 v)
{
U32 r = 1;
while (r < v) {
r *= 2;
}
return r;
}
glh::matrix4f glh_copy_matrix(GLdouble* src)
{
glh::matrix4f ret;
for (U32 i = 0; i < 16; i++)
{
ret.m[i] = (F32) src[i];
}
return ret;
}
glh::matrix4f glh_get_current_modelview()
{
return glh_copy_matrix(gGLModelView);
}
glh::matrix4f glh_get_current_projection()
{
return glh_copy_matrix(gGLProjection);
}
void glh_copy_matrix(const glh::matrix4f& src, GLdouble* dst)
{
for (U32 i = 0; i < 16; i++)
{
dst[i] = src.m[i];
}
}
void glh_set_current_modelview(const glh::matrix4f& mat)
{
glh_copy_matrix(mat, gGLModelView);
}
void glh_set_current_projection(glh::matrix4f& mat)
{
glh_copy_matrix(mat, gGLProjection);
}
glh::matrix4f gl_ortho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat znear, GLfloat zfar)
{
glh::matrix4f ret(
2.f/(right-left), 0.f, 0.f, -(right+left)/(right-left),
0.f, 2.f/(top-bottom), 0.f, -(top+bottom)/(top-bottom),
0.f, 0.f, -2.f/(zfar-znear), -(zfar+znear)/(zfar-znear),
0.f, 0.f, 0.f, 1.f);
return ret;
}
void display_update_camera();
//----------------------------------------
S32 LLPipeline::sCompiles = 0;
BOOL LLPipeline::sPickAvatar = TRUE;
BOOL LLPipeline::sDynamicLOD = TRUE;
BOOL LLPipeline::sShowHUDAttachments = TRUE;
BOOL LLPipeline::sRenderPhysicalBeacons = TRUE;
BOOL LLPipeline::sRenderScriptedBeacons = FALSE;
BOOL LLPipeline::sRenderScriptedTouchBeacons = TRUE;
BOOL LLPipeline::sRenderParticleBeacons = FALSE;
BOOL LLPipeline::sRenderSoundBeacons = FALSE;
BOOL LLPipeline::sRenderBeacons = FALSE;
BOOL LLPipeline::sRenderHighlight = TRUE;
BOOL LLPipeline::sForceOldBakedUpload = FALSE;
S32 LLPipeline::sUseOcclusion = 0;
BOOL LLPipeline::sDelayVBUpdate = TRUE;
BOOL LLPipeline::sFastAlpha = TRUE;
BOOL LLPipeline::sDisableShaders = FALSE;
BOOL LLPipeline::sRenderBump = TRUE;
BOOL LLPipeline::sUseFarClip = TRUE;
BOOL LLPipeline::sShadowRender = FALSE;
BOOL LLPipeline::sWaterReflections = FALSE;
BOOL LLPipeline::sRenderGlow = FALSE;
BOOL LLPipeline::sReflectionRender = FALSE;
BOOL LLPipeline::sImpostorRender = FALSE;
BOOL LLPipeline::sUnderWaterRender = FALSE;
BOOL LLPipeline::sTextureBindTest = FALSE;
BOOL LLPipeline::sRenderFrameTest = FALSE;
BOOL LLPipeline::sRenderAttachedLights = TRUE;
BOOL LLPipeline::sRenderAttachedParticles = TRUE;
BOOL LLPipeline::sRenderDeferred = FALSE;
S32 LLPipeline::sVisibleLightCount = 0;
F32 LLPipeline::sMinRenderSize = 0.f;
static LLCullResult* sCull = NULL;
static const U32 gl_cube_face[] =
{
GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB,
};
void validate_framebuffer_object();
void addDeferredAttachments(LLRenderTarget& target)
{
target.addColorAttachment(GL_RGBA); //specular
target.addColorAttachment(GL_RGBA); //normal+z
}
LLPipeline::LLPipeline() :
mBackfaceCull(FALSE),
mBatchCount(0),
mMatrixOpCount(0),
mTextureMatrixOps(0),
mMaxBatchSize(0),
mMinBatchSize(0),
mMeanBatchSize(0),
mTrianglesDrawn(0),
mNumVisibleNodes(0),
mVerticesRelit(0),
mLightingChanges(0),
mGeometryChanges(0),
mNumVisibleFaces(0),
mInitialized(FALSE),
mVertexShadersEnabled(FALSE),
mVertexShadersLoaded(0),
mRenderTypeMask(0),
mRenderDebugFeatureMask(0),
mRenderDebugMask(0),
mOldRenderDebugMask(0),
mLastRebuildPool(NULL),
mAlphaPool(NULL),
mSkyPool(NULL),
mTerrainPool(NULL),
mWaterPool(NULL),
mGroundPool(NULL),
mSimplePool(NULL),
mFullbrightPool(NULL),
mInvisiblePool(NULL),
mGlowPool(NULL),
mBumpPool(NULL),
mWLSkyPool(NULL),
mLightMask(0),
mLightMovingMask(0),
mLightingDetail(0),
mScreenWidth(0),
mScreenHeight(0)
{
mNoiseMap = 0;
mTrueNoiseMap = 0;
mLightFunc = 0;
}
void LLPipeline::init()
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_INIT);
sDynamicLOD = gSavedSettings.getBOOL("RenderDynamicLOD");
sRenderBump = gSavedSettings.getBOOL("RenderObjectBump");
sRenderAttachedLights = gSavedSettings.getBOOL("RenderAttachedLights");
sRenderAttachedParticles = gSavedSettings.getBOOL("RenderAttachedParticles");
mInitialized = TRUE;
stop_glerror();
//create render pass pools
getPool(LLDrawPool::POOL_ALPHA);
getPool(LLDrawPool::POOL_SIMPLE);
getPool(LLDrawPool::POOL_GRASS);
getPool(LLDrawPool::POOL_FULLBRIGHT);
getPool(LLDrawPool::POOL_INVISIBLE);
getPool(LLDrawPool::POOL_BUMP);
getPool(LLDrawPool::POOL_GLOW);
LLViewerStats::getInstance()->mTrianglesDrawnStat.reset();
resetFrameStats();
mRenderTypeMask = 0xffffffff; // All render types start on
mRenderDebugFeatureMask = 0xffffffff; // All debugging features on
mRenderDebugMask = 0; // All debug starts off
// Don't turn on ground when this is set
// Mac Books with intel 950s need this
if(!gSavedSettings.getBOOL("RenderGround"))
{
toggleRenderType(RENDER_TYPE_GROUND);
}
mOldRenderDebugMask = mRenderDebugMask;
mBackfaceCull = TRUE;
stop_glerror();
// Enable features
LLViewerShaderMgr::instance()->setShaders();
stop_glerror();
for (U32 i = 0; i < 2; ++i)
{
mSpotLightFade[i] = 1.f;
}
}
LLPipeline::~LLPipeline()
{
}
void LLPipeline::cleanup()
{
assertInitialized();
mGroupQ1.clear() ;
mGroupQ2.clear() ;
for(pool_set_t::iterator iter = mPools.begin();
iter != mPools.end(); )
{
pool_set_t::iterator curiter = iter++;
LLDrawPool* poolp = *curiter;
if (poolp->isFacePool())
{
LLFacePool* face_pool = (LLFacePool*) poolp;
if (face_pool->mReferences.empty())
{
mPools.erase(curiter);
removeFromQuickLookup( poolp );
delete poolp;
}
}
else
{
mPools.erase(curiter);
removeFromQuickLookup( poolp );
delete poolp;
}
}
if (!mTerrainPools.empty())
{
llwarns << "Terrain Pools not cleaned up" << llendl;
}
if (!mTreePools.empty())
{
llwarns << "Tree Pools not cleaned up" << llendl;
}
delete mAlphaPool;
mAlphaPool = NULL;
delete mSkyPool;
mSkyPool = NULL;
delete mTerrainPool;
mTerrainPool = NULL;
delete mWaterPool;
mWaterPool = NULL;
delete mGroundPool;
mGroundPool = NULL;
delete mSimplePool;
mSimplePool = NULL;
delete mFullbrightPool;
mFullbrightPool = NULL;
delete mInvisiblePool;
mInvisiblePool = NULL;
delete mGlowPool;
mGlowPool = NULL;
delete mBumpPool;
mBumpPool = NULL;
// don't delete wl sky pool it was handled above in the for loop
//delete mWLSkyPool;
mWLSkyPool = NULL;
releaseGLBuffers();
mFaceSelectImagep = NULL;
mMovedBridge.clear();
mInitialized = FALSE;
}
//============================================================================
void LLPipeline::destroyGL()
{
stop_glerror();
unloadShaders();
mHighlightFaces.clear();
resetDrawOrders();
resetVertexBuffers();
releaseGLBuffers();
if (LLVertexBuffer::sEnableVBOs)
{
// render 30 frames after switching to work around DEV-5361
sDelayedVBOEnable = 30;
LLVertexBuffer::sEnableVBOs = FALSE;
}
}
static LLFastTimer::DeclareTimer FTM_RESIZE_SCREEN_TEXTURE("Resize Screen Texture");
void LLPipeline::resizeScreenTexture()
{
LLFastTimer ft(FTM_RESIZE_SCREEN_TEXTURE);
if (gPipeline.canUseVertexShaders() && assertInitialized())
{
GLuint resX = gViewerWindow->getWorldViewWidthRaw();
GLuint resY = gViewerWindow->getWorldViewHeightRaw();
allocateScreenBuffer(resX,resY);
}
}
void LLPipeline::allocateScreenBuffer(U32 resX, U32 resY)
{
// remember these dimensions
mScreenWidth = resX;
mScreenHeight = resY;
U32 samples = gSavedSettings.getU32("RenderFSAASamples");
U32 res_mod = gSavedSettings.getU32("RenderResolutionDivisor");
if (res_mod > 1 && res_mod < resX && res_mod < resY)
{
resX /= res_mod;
resY /= res_mod;
}
if (gSavedSettings.getBOOL("RenderUIBuffer"))
{
mUIScreen.allocate(resX,resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE);
}
if (LLPipeline::sRenderDeferred)
{
//allocate deferred rendering color buffers
mDeferredScreen.allocate(resX, resY, GL_RGBA, TRUE, TRUE, LLTexUnit::TT_RECT_TEXTURE, FALSE);
mDeferredDepth.allocate(resX, resY, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE);
addDeferredAttachments(mDeferredScreen);
// always set viewport to desired size, since allocate resets the viewport
mScreen.allocate(resX, resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE);
mEdgeMap.allocate(resX, resY, GL_ALPHA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE);
for (U32 i = 0; i < 3; i++)
{
mDeferredLight[i].allocate(resX, resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE);
}
for (U32 i = 0; i < 2; i++)
{
mGIMapPost[i].allocate(resX,resY, GL_RGB, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE);
}
F32 scale = gSavedSettings.getF32("RenderShadowResolutionScale");
for (U32 i = 0; i < 4; i++)
{
mShadow[i].allocate(U32(resX*scale),U32(resY*scale), 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE);
}
U32 width = nhpo2(U32(resX*scale))/2;
U32 height = width;
for (U32 i = 4; i < 6; i++)
{
mShadow[i].allocate(width, height, 0, TRUE, FALSE);
}
width = nhpo2(resX)/2;
height = nhpo2(resY)/2;
mLuminanceMap.allocate(width,height, GL_RGBA, FALSE, FALSE);
}
else
{
mScreen.allocate(resX, resY, GL_RGBA, TRUE, TRUE, LLTexUnit::TT_RECT_TEXTURE, FALSE);
}
if (gGLManager.mHasFramebufferMultisample && samples > 1)
{
mSampleBuffer.allocate(resX,resY,GL_RGBA,TRUE,TRUE,LLTexUnit::TT_RECT_TEXTURE,FALSE,samples);
if (LLPipeline::sRenderDeferred)
{
addDeferredAttachments(mSampleBuffer);
mDeferredScreen.setSampleBuffer(&mSampleBuffer);
}
mScreen.setSampleBuffer(&mSampleBuffer);
stop_glerror();
}
if (LLPipeline::sRenderDeferred)
{ //share depth buffer between deferred targets
mDeferredScreen.shareDepthBuffer(mScreen);
for (U32 i = 0; i < 3; i++)
{ //share stencil buffer with screen space lightmap to stencil out sky
mDeferredScreen.shareDepthBuffer(mDeferredLight[i]);
}
}
gGL.getTexUnit(0)->disable();
stop_glerror();
}
//static
void LLPipeline::updateRenderDeferred()
{
BOOL deferred = (gSavedSettings.getBOOL("RenderDeferred") &&
LLRenderTarget::sUseFBO &&
gSavedSettings.getBOOL("VertexShaderEnable") &&
gSavedSettings.getBOOL("RenderAvatarVP") &&
gSavedSettings.getBOOL("WindLightUseAtmosShaders")) ? TRUE : FALSE;
sRenderDeferred = deferred;
}
void LLPipeline::releaseGLBuffers()
{
assertInitialized();
if (mNoiseMap)
{
LLImageGL::deleteTextures(1, &mNoiseMap);
mNoiseMap = 0;
}
if (mTrueNoiseMap)
{
LLImageGL::deleteTextures(1, &mTrueNoiseMap);
mTrueNoiseMap = 0;
}
if (mLightFunc)
{
LLImageGL::deleteTextures(1, &mLightFunc);
mLightFunc = 0;
}
mWaterRef.release();
mWaterDis.release();
mScreen.release();
mUIScreen.release();
mSampleBuffer.releaseSampleBuffer();
mDeferredScreen.release();
mDeferredDepth.release();
for (U32 i = 0; i < 3; i++)
{
mDeferredLight[i].release();
}
mEdgeMap.release();
mGIMap.release();
mGIMapPost[0].release();
mGIMapPost[1].release();
mHighlight.release();
mLuminanceMap.release();
for (U32 i = 0; i < 6; i++)
{
mShadow[i].release();
}
for (U32 i = 0; i < 3; i++)
{
mGlow[i].release();
}
LLVOAvatar::resetImpostors();
}
void LLPipeline::createGLBuffers()
{
LLMemType mt_cb(LLMemType::MTYPE_PIPELINE_CREATE_BUFFERS);
assertInitialized();
updateRenderDeferred();
if (LLPipeline::sWaterReflections)
{ //water reflection texture
U32 res = (U32) gSavedSettings.getS32("RenderWaterRefResolution");
mWaterRef.allocate(res,res,GL_RGBA,TRUE,FALSE);
mWaterDis.allocate(res,res,GL_RGBA,TRUE,FALSE);
}
mHighlight.allocate(256,256,GL_RGBA, FALSE, FALSE);
stop_glerror();
GLuint resX = gViewerWindow->getWorldViewWidthRaw();
GLuint resY = gViewerWindow->getWorldViewHeightRaw();
if (LLPipeline::sRenderGlow)
{ //screen space glow buffers
const U32 glow_res = llmax(1,
llmin(512, 1 << gSavedSettings.getS32("RenderGlowResolutionPow")));
for (U32 i = 0; i < 3; i++)
{
mGlow[i].allocate(512,glow_res,GL_RGBA,FALSE,FALSE);
}
allocateScreenBuffer(resX,resY);
mScreenWidth = 0;
mScreenHeight = 0;
}
if (sRenderDeferred)
{
if (!mNoiseMap)
{
const U32 noiseRes = 128;
LLVector3 noise[noiseRes*noiseRes];
F32 scaler = gSavedSettings.getF32("RenderDeferredNoise")/100.f;
for (U32 i = 0; i < noiseRes*noiseRes; ++i)
{
noise[i] = LLVector3(ll_frand()-0.5f, ll_frand()-0.5f, 0.f);
noise[i].normVec();
noise[i].mV[2] = ll_frand()*scaler+1.f-scaler/2.f;
}
LLImageGL::generateTextures(1, &mNoiseMap);
gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mNoiseMap);
LLImageGL::setManualImage(LLTexUnit::getInternalType(LLTexUnit::TT_TEXTURE), 0, GL_RGB16F_ARB, noiseRes, noiseRes, GL_RGB, GL_FLOAT, noise);
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
}
if (!mTrueNoiseMap)
{
const U32 noiseRes = 128;
F32 noise[noiseRes*noiseRes*3];
for (U32 i = 0; i < noiseRes*noiseRes*3; i++)
{
noise[i] = ll_frand()*2.0-1.0;
}
LLImageGL::generateTextures(1, &mTrueNoiseMap);
gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mTrueNoiseMap);
LLImageGL::setManualImage(LLTexUnit::getInternalType(LLTexUnit::TT_TEXTURE), 0, GL_RGB16F_ARB, noiseRes, noiseRes, GL_RGB,GL_FLOAT, noise);
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
}
if (!mLightFunc)
{
U32 lightResX = gSavedSettings.getU32("RenderSpecularResX");
U32 lightResY = gSavedSettings.getU32("RenderSpecularResY");
U8* lg = new U8[lightResX*lightResY];
for (U32 y = 0; y < lightResY; ++y)
{
for (U32 x = 0; x < lightResX; ++x)
{
//spec func
F32 sa = (F32) x/(lightResX-1);
F32 spec = (F32) y/(lightResY-1);
//lg[y*lightResX+x] = (U8) (powf(sa, 128.f*spec*spec)*255);
//F32 sp = acosf(sa)/(1.f-spec);
sa = powf(sa, gSavedSettings.getF32("RenderSpecularExponent"));
F32 a = acosf(sa*0.25f+0.75f);
F32 m = llmax(0.5f-spec*0.5f, 0.001f);
F32 t2 = tanf(a)/m;
t2 *= t2;
F32 c4a = (3.f+4.f*cosf(2.f*a)+cosf(4.f*a))/8.f;
F32 bd = 1.f/(4.f*m*m*c4a)*powf(F_E, -t2);
lg[y*lightResX+x] = (U8) (llclamp(bd, 0.f, 1.f)*255);
}
}
LLImageGL::generateTextures(1, &mLightFunc);
gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mLightFunc);
LLImageGL::setManualImage(LLTexUnit::getInternalType(LLTexUnit::TT_TEXTURE), 0, GL_ALPHA, lightResX, lightResY, GL_ALPHA, GL_UNSIGNED_BYTE, lg);
gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_TRILINEAR);
delete [] lg;
}
if (gSavedSettings.getBOOL("RenderDeferredGI"))
{
mGIMap.allocate(512,512,GL_RGBA, TRUE, FALSE);
addDeferredAttachments(mGIMap);
}
}
}
void LLPipeline::restoreGL()
{
LLMemType mt_cb(LLMemType::MTYPE_PIPELINE_RESTORE_GL);
assertInitialized();
if (mVertexShadersEnabled)
{
LLViewerShaderMgr::instance()->setShaders();
}
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
part->restoreGL();
}
}
}
}
BOOL LLPipeline::canUseVertexShaders()
{
if (sDisableShaders ||
!gGLManager.mHasVertexShader ||
!gGLManager.mHasFragmentShader ||
!LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") ||
(assertInitialized() && mVertexShadersLoaded != 1) )
{
return FALSE;
}
else
{
return TRUE;
}
}
BOOL LLPipeline::canUseWindLightShaders() const
{
return (!LLPipeline::sDisableShaders &&
gWLSkyProgram.mProgramObject != 0 &&
LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_WINDLIGHT) > 1);
}
BOOL LLPipeline::canUseWindLightShadersOnObjects() const
{
return (canUseWindLightShaders()
&& LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT) > 0);
}
void LLPipeline::unloadShaders()
{
LLMemType mt_us(LLMemType::MTYPE_PIPELINE_UNLOAD_SHADERS);
LLViewerShaderMgr::instance()->unloadShaders();
mVertexShadersLoaded = 0;
}
void LLPipeline::assertInitializedDoError()
{
llerrs << "LLPipeline used when uninitialized." << llendl;
}
//============================================================================
void LLPipeline::enableShadows(const BOOL enable_shadows)
{
//should probably do something here to wrangle shadows....
}
S32 LLPipeline::getMaxLightingDetail() const
{
/*if (mVertexShaderLevel[SHADER_OBJECT] >= LLDrawPoolSimple::SHADER_LEVEL_LOCAL_LIGHTS)
{
return 3;
}
else*/
{
return 1;
}
}
S32 LLPipeline::setLightingDetail(S32 level)
{
LLMemType mt_ld(LLMemType::MTYPE_PIPELINE_LIGHTING_DETAIL);
assertInitialized();
if (level < 0)
{
level = gSavedSettings.getS32("RenderLightingDetail");
}
level = llclamp(level, 0, getMaxLightingDetail());
if (level != mLightingDetail)
{
gSavedSettings.setS32("RenderLightingDetail", level);
mLightingDetail = level;
if (mVertexShadersLoaded == 1)
{
LLViewerShaderMgr::instance()->setShaders();
}
}
return mLightingDetail;
}
class LLOctreeDirtyTexture : public LLOctreeTraveler<LLDrawable>
{
public:
const std::set<LLViewerFetchedTexture*>& mTextures;
LLOctreeDirtyTexture(const std::set<LLViewerFetchedTexture*>& textures) : mTextures(textures) { }
virtual void visit(const LLOctreeNode<LLDrawable>* node)
{
LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
if (!group->isState(LLSpatialGroup::GEOM_DIRTY) && !group->getData().empty())
{
for (LLSpatialGroup::draw_map_t::iterator i = group->mDrawMap.begin(); i != group->mDrawMap.end(); ++i)
{
for (LLSpatialGroup::drawmap_elem_t::iterator j = i->second.begin(); j != i->second.end(); ++j)
{
LLDrawInfo* params = *j;
LLViewerFetchedTexture* tex = LLViewerTextureManager::staticCastToFetchedTexture(params->mTexture);
if (tex && mTextures.find(tex) != mTextures.end())
{
group->setState(LLSpatialGroup::GEOM_DIRTY);
}
}
}
}
for (LLSpatialGroup::bridge_list_t::iterator i = group->mBridgeList.begin(); i != group->mBridgeList.end(); ++i)
{
LLSpatialBridge* bridge = *i;
traverse(bridge->mOctree);
}
}
};
// Called when a texture changes # of channels (causes faces to move to alpha pool)
void LLPipeline::dirtyPoolObjectTextures(const std::set<LLViewerFetchedTexture*>& textures)
{
assertInitialized();
// *TODO: This is inefficient and causes frame spikes; need a better way to do this
// Most of the time is spent in dirty.traverse.
for (pool_set_t::iterator iter = mPools.begin(); iter != mPools.end(); ++iter)
{
LLDrawPool *poolp = *iter;
if (poolp->isFacePool())
{
((LLFacePool*) poolp)->dirtyTextures(textures);
}
}
LLOctreeDirtyTexture dirty(textures);
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
dirty.traverse(part->mOctree);
}
}
}
}
LLDrawPool *LLPipeline::findPool(const U32 type, LLViewerTexture *tex0)
{
assertInitialized();
LLDrawPool *poolp = NULL;
switch( type )
{
case LLDrawPool::POOL_SIMPLE:
poolp = mSimplePool;
break;
case LLDrawPool::POOL_GRASS:
poolp = mGrassPool;
break;
case LLDrawPool::POOL_FULLBRIGHT:
poolp = mFullbrightPool;
break;
case LLDrawPool::POOL_INVISIBLE:
poolp = mInvisiblePool;
break;
case LLDrawPool::POOL_GLOW:
poolp = mGlowPool;
break;
case LLDrawPool::POOL_TREE:
poolp = get_if_there(mTreePools, (uintptr_t)tex0, (LLDrawPool*)0 );
break;
case LLDrawPool::POOL_TERRAIN:
poolp = get_if_there(mTerrainPools, (uintptr_t)tex0, (LLDrawPool*)0 );
break;
case LLDrawPool::POOL_BUMP:
poolp = mBumpPool;
break;
case LLDrawPool::POOL_ALPHA:
poolp = mAlphaPool;
break;
case LLDrawPool::POOL_AVATAR:
break; // Do nothing
case LLDrawPool::POOL_SKY:
poolp = mSkyPool;
break;
case LLDrawPool::POOL_WATER:
poolp = mWaterPool;
break;
case LLDrawPool::POOL_GROUND:
poolp = mGroundPool;
break;
case LLDrawPool::POOL_WL_SKY:
poolp = mWLSkyPool;
break;
default:
llassert(0);
llerrs << "Invalid Pool Type in LLPipeline::findPool() type=" << type << llendl;
break;
}
return poolp;
}
LLDrawPool *LLPipeline::getPool(const U32 type, LLViewerTexture *tex0)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLDrawPool *poolp = findPool(type, tex0);
if (poolp)
{
return poolp;
}
LLDrawPool *new_poolp = LLDrawPool::createPool(type, tex0);
addPool( new_poolp );
return new_poolp;
}
// static
LLDrawPool* LLPipeline::getPoolFromTE(const LLTextureEntry* te, LLViewerTexture* imagep)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
U32 type = getPoolTypeFromTE(te, imagep);
return gPipeline.getPool(type, imagep);
}
//static
U32 LLPipeline::getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* imagep)
{
LLMemType mt_gpt(LLMemType::MTYPE_PIPELINE_GET_POOL_TYPE);
if (!te || !imagep)
{
return 0;
}
bool alpha = te->getColor().mV[3] < 0.999f;
if (imagep)
{
alpha = alpha || (imagep->getComponents() == 4 && imagep->getType() != LLViewerTexture::MEDIA_TEXTURE) || (imagep->getComponents() == 2);
}
if (alpha)
{
return LLDrawPool::POOL_ALPHA;
}
else if ((te->getBumpmap() || te->getShiny()))
{
return LLDrawPool::POOL_BUMP;
}
else
{
return LLDrawPool::POOL_SIMPLE;
}
}
void LLPipeline::addPool(LLDrawPool *new_poolp)
{
LLMemType mt_a(LLMemType::MTYPE_PIPELINE_ADD_POOL);
assertInitialized();
mPools.insert(new_poolp);
addToQuickLookup( new_poolp );
}
void LLPipeline::allocDrawable(LLViewerObject *vobj)
{
LLMemType mt_ad(LLMemType::MTYPE_PIPELINE_ALLOCATE_DRAWABLE);
LLDrawable *drawable = new LLDrawable();
vobj->mDrawable = drawable;
drawable->mVObjp = vobj;
//encompass completely sheared objects by taking
//the most extreme point possible (<1,1,0.5>)
drawable->setRadius(LLVector3(1,1,0.5f).scaleVec(vobj->getScale()).length());
if (vobj->isOrphaned())
{
drawable->setState(LLDrawable::FORCE_INVISIBLE);
}
drawable->updateXform(TRUE);
}
void LLPipeline::unlinkDrawable(LLDrawable *drawable)
{
LLFastTimer t(FTM_PIPELINE);
assertInitialized();
LLPointer<LLDrawable> drawablep = drawable; // make sure this doesn't get deleted before we are done
// Based on flags, remove the drawable from the queues that it's on.
if (drawablep->isState(LLDrawable::ON_MOVE_LIST))
{
LLDrawable::drawable_vector_t::iterator iter = std::find(mMovedList.begin(), mMovedList.end(), drawablep);
if (iter != mMovedList.end())
{
mMovedList.erase(iter);
}
}
if (drawablep->getSpatialGroup())
{
if (!drawablep->getSpatialGroup()->mSpatialPartition->remove(drawablep, drawablep->getSpatialGroup()))
{
#ifdef LL_RELEASE_FOR_DOWNLOAD
llwarns << "Couldn't remove object from spatial group!" << llendl;
#else
llerrs << "Couldn't remove object from spatial group!" << llendl;
#endif
}
}
mLights.erase(drawablep);
for (light_set_t::iterator iter = mNearbyLights.begin();
iter != mNearbyLights.end(); iter++)
{
if (iter->drawable == drawablep)
{
mNearbyLights.erase(iter);
break;
}
}
{
HighlightItem item(drawablep);
mHighlightSet.erase(item);
if (mHighlightObject == drawablep)
{
mHighlightObject = NULL;
}
}
for (U32 i = 0; i < 2; ++i)
{
if (mShadowSpotLight[i] == drawablep)
{
mShadowSpotLight[i] = NULL;
}
if (mTargetShadowSpotLight[i] == drawablep)
{
mTargetShadowSpotLight[i] = NULL;
}
}
}
U32 LLPipeline::addObject(LLViewerObject *vobj)
{
LLMemType mt_ao(LLMemType::MTYPE_PIPELINE_ADD_OBJECT);
if (gNoRender)
{
return 0;
}
if (gSavedSettings.getBOOL("RenderDelayCreation"))
{
mCreateQ.push_back(vobj);
}
else
{
createObject(vobj);
}
return 1;
}
void LLPipeline::createObjects(F32 max_dtime)
{
LLFastTimer ftm(FTM_GEO_UPDATE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_CREATE_OBJECTS);
LLTimer update_timer;
while (!mCreateQ.empty() && update_timer.getElapsedTimeF32() < max_dtime)
{
LLViewerObject* vobj = mCreateQ.front();
if (!vobj->isDead())
{
createObject(vobj);
}
mCreateQ.pop_front();
}
//for (LLViewerObject::vobj_list_t::iterator iter = mCreateQ.begin(); iter != mCreateQ.end(); ++iter)
//{
// createObject(*iter);
//}
//mCreateQ.clear();
}
void LLPipeline::createObject(LLViewerObject* vobj)
{
LLDrawable* drawablep = vobj->mDrawable;
if (!drawablep)
{
drawablep = vobj->createDrawable(this);
}
else
{
llerrs << "Redundant drawable creation!" << llendl;
}
llassert(drawablep);
if (vobj->getParent())
{
vobj->setDrawableParent(((LLViewerObject*)vobj->getParent())->mDrawable); // LLPipeline::addObject 1
}
else
{
vobj->setDrawableParent(NULL); // LLPipeline::addObject 2
}
markRebuild(drawablep, LLDrawable::REBUILD_ALL, TRUE);
if (drawablep->getVOVolume() && gSavedSettings.getBOOL("RenderAnimateRes"))
{
// fun animated res
drawablep->updateXform(TRUE);
drawablep->clearState(LLDrawable::MOVE_UNDAMPED);
drawablep->setScale(LLVector3(0,0,0));
drawablep->makeActive();
}
}
void LLPipeline::resetFrameStats()
{
assertInitialized();
LLViewerStats::getInstance()->mTrianglesDrawnStat.addValue(mTrianglesDrawn/1000.f);
if (mBatchCount > 0)
{
mMeanBatchSize = gPipeline.mTrianglesDrawn/gPipeline.mBatchCount;
}
mTrianglesDrawn = 0;
sCompiles = 0;
mVerticesRelit = 0;
mLightingChanges = 0;
mGeometryChanges = 0;
mNumVisibleFaces = 0;
if (mOldRenderDebugMask != mRenderDebugMask)
{
gObjectList.clearDebugText();
mOldRenderDebugMask = mRenderDebugMask;
}
}
//external functions for asynchronous updating
void LLPipeline::updateMoveDampedAsync(LLDrawable* drawablep)
{
if (gSavedSettings.getBOOL("FreezeTime"))
{
return;
}
if (!drawablep)
{
llerrs << "updateMove called with NULL drawablep" << llendl;
return;
}
if (drawablep->isState(LLDrawable::EARLY_MOVE))
{
return;
}
assertInitialized();
// update drawable now
drawablep->clearState(LLDrawable::MOVE_UNDAMPED); // force to DAMPED
drawablep->updateMove(); // returns done
drawablep->setState(LLDrawable::EARLY_MOVE); // flag says we already did an undamped move this frame
// Put on move list so that EARLY_MOVE gets cleared
if (!drawablep->isState(LLDrawable::ON_MOVE_LIST))
{
mMovedList.push_back(drawablep);
drawablep->setState(LLDrawable::ON_MOVE_LIST);
}
}
void LLPipeline::updateMoveNormalAsync(LLDrawable* drawablep)
{
if (gSavedSettings.getBOOL("FreezeTime"))
{
return;
}
if (!drawablep)
{
llerrs << "updateMove called with NULL drawablep" << llendl;
return;
}
if (drawablep->isState(LLDrawable::EARLY_MOVE))
{
return;
}
assertInitialized();
// update drawable now
drawablep->setState(LLDrawable::MOVE_UNDAMPED); // force to UNDAMPED
drawablep->updateMove();
drawablep->setState(LLDrawable::EARLY_MOVE); // flag says we already did an undamped move this frame
// Put on move list so that EARLY_MOVE gets cleared
if (!drawablep->isState(LLDrawable::ON_MOVE_LIST))
{
mMovedList.push_back(drawablep);
drawablep->setState(LLDrawable::ON_MOVE_LIST);
}
}
void LLPipeline::updateMovedList(LLDrawable::drawable_vector_t& moved_list)
{
for (LLDrawable::drawable_vector_t::iterator iter = moved_list.begin();
iter != moved_list.end(); )
{
LLDrawable::drawable_vector_t::iterator curiter = iter++;
LLDrawable *drawablep = *curiter;
BOOL done = TRUE;
if (!drawablep->isDead() && (!drawablep->isState(LLDrawable::EARLY_MOVE)))
{
done = drawablep->updateMove();
}
drawablep->clearState(LLDrawable::EARLY_MOVE | LLDrawable::MOVE_UNDAMPED);
if (done)
{
drawablep->clearState(LLDrawable::ON_MOVE_LIST);
iter = moved_list.erase(curiter);
}
}
}
static LLFastTimer::DeclareTimer FTM_OCTREE_BALANCE("Balance Octree");
static LLFastTimer::DeclareTimer FTM_UPDATE_MOVE("Update Move");
void LLPipeline::updateMove()
{
LLFastTimer t(FTM_UPDATE_MOVE);
LLMemType mt_um(LLMemType::MTYPE_PIPELINE_UPDATE_MOVE);
if (gSavedSettings.getBOOL("FreezeTime"))
{
return;
}
assertInitialized();
for (LLDrawable::drawable_set_t::iterator iter = mRetexturedList.begin();
iter != mRetexturedList.end(); ++iter)
{
LLDrawable* drawablep = *iter;
if (drawablep && !drawablep->isDead())
{
drawablep->updateTexture();
}
}
mRetexturedList.clear();
updateMovedList(mMovedList);
for (LLDrawable::drawable_set_t::iterator iter = mActiveQ.begin();
iter != mActiveQ.end(); )
{
LLDrawable::drawable_set_t::iterator curiter = iter++;
LLDrawable* drawablep = *curiter;
if (drawablep && !drawablep->isDead())
{
if (drawablep->isRoot() &&
drawablep->mQuietCount++ > MAX_ACTIVE_OBJECT_QUIET_FRAMES &&
(!drawablep->getParent() || !drawablep->getParent()->isActive()))
{
drawablep->makeStatic(); // removes drawable and its children from mActiveQ
iter = mActiveQ.upper_bound(drawablep); // next valid entry
}
}
else
{
mActiveQ.erase(curiter);
}
}
//balance octrees
{
LLFastTimer ot(FTM_OCTREE_BALANCE);
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
part->mOctree->balance();
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
// Culling and occlusion testing
/////////////////////////////////////////////////////////////////////////////
//static
F32 LLPipeline::calcPixelArea(LLVector3 center, LLVector3 size, LLCamera &camera)
{
LLVector3 lookAt = center - camera.getOrigin();
F32 dist = lookAt.length();
//ramp down distance for nearby objects
//shrink dist by dist/16.
if (dist < 16.f)
{
dist /= 16.f;
dist *= dist;
dist *= 16.f;
}
//get area of circle around node
F32 app_angle = atanf(size.length()/dist);
F32 radius = app_angle*LLDrawable::sCurPixelAngle;
return radius*radius * F_PI;
}
void LLPipeline::grabReferences(LLCullResult& result)
{
sCull = &result;
}
BOOL LLPipeline::visibleObjectsInFrustum(LLCamera& camera)
{
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
if (hasRenderType(part->mDrawableType))
{
if (part->visibleObjectsInFrustum(camera))
{
return TRUE;
}
}
}
}
}
return FALSE;
}
BOOL LLPipeline::getVisibleExtents(LLCamera& camera, LLVector3& min, LLVector3& max)
{
min = LLVector3(F32_MAX, F32_MAX, F32_MAX);
max = LLVector3(-F32_MAX, -F32_MAX, -F32_MAX);
U32 saved_camera_id = LLViewerCamera::sCurCameraID;
LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD;
BOOL res = TRUE;
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
if (hasRenderType(part->mDrawableType))
{
if (!part->getVisibleExtents(camera, min, max))
{
res = FALSE;
}
}
}
}
}
LLViewerCamera::sCurCameraID = saved_camera_id;
return res;
}
static LLFastTimer::DeclareTimer FTM_CULL("Object Culling");
void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip)
{
LLFastTimer t(FTM_CULL);
LLMemType mt_uc(LLMemType::MTYPE_PIPELINE_UPDATE_CULL);
grabReferences(result);
sCull->clear();
BOOL to_texture = LLPipeline::sUseOcclusion > 1 &&
!hasRenderType(LLPipeline::RENDER_TYPE_HUD) &&
LLViewerCamera::sCurCameraID == LLViewerCamera::CAMERA_WORLD &&
gPipeline.canUseVertexShaders() &&
sRenderGlow;
if (to_texture)
{
mScreen.bindTarget();
}
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadMatrixd(gGLLastProjection);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gGLLastMatrix = NULL;
glLoadMatrixd(gGLLastModelView);
LLVertexBuffer::unbind();
LLGLDisable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
if (sUseOcclusion > 1)
{
gGL.setColorMask(false, false);
}
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
if (water_clip != 0)
{
LLPlane plane(LLVector3(0,0, (F32) -water_clip), (F32) water_clip*region->getWaterHeight());
camera.setUserClipPlane(plane);
}
else
{
camera.disableUserClipPlane();
}
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
if (hasRenderType(part->mDrawableType))
{
part->cull(camera);
}
}
}
}
camera.disableUserClipPlane();
if (gSky.mVOSkyp.notNull() && gSky.mVOSkyp->mDrawable.notNull())
{
// Hack for sky - always visible.
if (hasRenderType(LLPipeline::RENDER_TYPE_SKY))
{
gSky.mVOSkyp->mDrawable->setVisible(camera);
sCull->pushDrawable(gSky.mVOSkyp->mDrawable);
gSky.updateCull();
stop_glerror();
}
}
else
{
llinfos << "No sky drawable!" << llendl;
}
if (hasRenderType(LLPipeline::RENDER_TYPE_GROUND) &&
!gPipeline.canUseWindLightShaders() &&
gSky.mVOGroundp.notNull() &&
gSky.mVOGroundp->mDrawable.notNull() &&
!LLPipeline::sWaterReflections)
{
gSky.mVOGroundp->mDrawable->setVisible(camera);
sCull->pushDrawable(gSky.mVOGroundp->mDrawable);
}
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
if (sUseOcclusion > 1)
{
gGL.setColorMask(true, false);
}
if (to_texture)
{
mScreen.flush();
}
}
void LLPipeline::markNotCulled(LLSpatialGroup* group, LLCamera& camera)
{
if (group->getData().empty())
{
return;
}
group->setVisible();
if (LLViewerCamera::sCurCameraID == LLViewerCamera::CAMERA_WORLD)
{
group->updateDistance(camera);
}
const F32 MINIMUM_PIXEL_AREA = 16.f;
if (group->mPixelArea < MINIMUM_PIXEL_AREA)
{
return;
}
if (sMinRenderSize > 0.f &&
llmax(llmax(group->mBounds[1].mV[0], group->mBounds[1].mV[1]), group->mBounds[1].mV[2]) < sMinRenderSize)
{
return;
}
assertInitialized();
if (!group->mSpatialPartition->mRenderByGroup)
{ //render by drawable
sCull->pushDrawableGroup(group);
}
else
{ //render by group
sCull->pushVisibleGroup(group);
}
mNumVisibleNodes++;
}
void LLPipeline::markOccluder(LLSpatialGroup* group)
{
if (sUseOcclusion > 1 && group && !group->isOcclusionState(LLSpatialGroup::ACTIVE_OCCLUSION))
{
LLSpatialGroup* parent = group->getParent();
if (!parent || !parent->isOcclusionState(LLSpatialGroup::OCCLUDED))
{ //only mark top most occluders as active occlusion
sCull->pushOcclusionGroup(group);
group->setOcclusionState(LLSpatialGroup::ACTIVE_OCCLUSION);
if (parent &&
!parent->isOcclusionState(LLSpatialGroup::ACTIVE_OCCLUSION) &&
parent->getElementCount() == 0 &&
parent->needsUpdate())
{
sCull->pushOcclusionGroup(group);
parent->setOcclusionState(LLSpatialGroup::ACTIVE_OCCLUSION);
}
}
}
}
void LLPipeline::doOcclusion(LLCamera& camera)
{
LLVertexBuffer::unbind();
if (hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCCLUSION))
{
gGL.setColorMask(true, false, false, false);
}
else
{
gGL.setColorMask(false, false);
}
LLGLDisable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
LLGLDisable cull(GL_CULL_FACE);
if (LLPipeline::sUseOcclusion > 1)
{
for (LLCullResult::sg_list_t::iterator iter = sCull->beginOcclusionGroups(); iter != sCull->endOcclusionGroups(); ++iter)
{
LLSpatialGroup* group = *iter;
group->doOcclusion(&camera);
group->clearOcclusionState(LLSpatialGroup::ACTIVE_OCCLUSION);
}
}
gGL.setColorMask(true, false);
}
BOOL LLPipeline::updateDrawableGeom(LLDrawable* drawablep, BOOL priority)
{
BOOL update_complete = drawablep->updateGeometry(priority);
if (update_complete && assertInitialized())
{
drawablep->setState(LLDrawable::BUILT);
mGeometryChanges++;
}
return update_complete;
}
void LLPipeline::updateGL()
{
while (!LLGLUpdate::sGLQ.empty())
{
LLGLUpdate* glu = LLGLUpdate::sGLQ.front();
glu->updateGL();
glu->mInQ = FALSE;
LLGLUpdate::sGLQ.pop_front();
}
}
void LLPipeline::rebuildPriorityGroups()
{
LLTimer update_timer;
LLMemType mt(LLMemType::MTYPE_PIPELINE);
assertInitialized();
// Iterate through all drawables on the priority build queue,
for (LLSpatialGroup::sg_list_t::iterator iter = mGroupQ1.begin();
iter != mGroupQ1.end(); ++iter)
{
LLSpatialGroup* group = *iter;
group->rebuildGeom();
group->clearState(LLSpatialGroup::IN_BUILD_Q1);
}
mGroupQ1.clear();
}
void LLPipeline::rebuildGroups()
{
llpushcallstacks ;
// Iterate through some drawables on the non-priority build queue
S32 size = (S32) mGroupQ2.size();
S32 min_count = llclamp((S32) ((F32) (size * size)/4096*0.25f), 1, size);
S32 count = 0;
std::sort(mGroupQ2.begin(), mGroupQ2.end(), LLSpatialGroup::CompareUpdateUrgency());
LLSpatialGroup::sg_vector_t::iterator iter;
for (iter = mGroupQ2.begin();
iter != mGroupQ2.end(); ++iter)
{
LLSpatialGroup* group = *iter;
if (group->isDead())
{
continue;
}
group->rebuildGeom();
if (group->mSpatialPartition->mRenderByGroup)
{
count++;
}
group->clearState(LLSpatialGroup::IN_BUILD_Q2);
if (count > min_count)
{
++iter;
break;
}
}
mGroupQ2.erase(mGroupQ2.begin(), iter);
updateMovedList(mMovedBridge);
}
void LLPipeline::updateGeom(F32 max_dtime)
{
LLTimer update_timer;
LLMemType mt(LLMemType::MTYPE_PIPELINE_UPDATE_GEOM);
LLPointer<LLDrawable> drawablep;
LLFastTimer t(FTM_GEO_UPDATE);
assertInitialized();
if (sDelayedVBOEnable > 0)
{
if (--sDelayedVBOEnable <= 0)
{
resetVertexBuffers();
LLVertexBuffer::sEnableVBOs = TRUE;
}
}
// notify various object types to reset internal cost metrics, etc.
// for now, only LLVOVolume does this to throttle LOD changes
LLVOVolume::preUpdateGeom();
// Iterate through all drawables on the priority build queue,
for (LLDrawable::drawable_list_t::iterator iter = mBuildQ1.begin();
iter != mBuildQ1.end();)
{
LLDrawable::drawable_list_t::iterator curiter = iter++;
LLDrawable* drawablep = *curiter;
if (drawablep && !drawablep->isDead())
{
if (drawablep->isState(LLDrawable::IN_REBUILD_Q2))
{
drawablep->clearState(LLDrawable::IN_REBUILD_Q2);
LLDrawable::drawable_list_t::iterator find = std::find(mBuildQ2.begin(), mBuildQ2.end(), drawablep);
if (find != mBuildQ2.end())
{
mBuildQ2.erase(find);
}
}
if (updateDrawableGeom(drawablep, TRUE))
{
drawablep->clearState(LLDrawable::IN_REBUILD_Q1);
mBuildQ1.erase(curiter);
}
}
else
{
mBuildQ1.erase(curiter);
}
}
// Iterate through some drawables on the non-priority build queue
S32 min_count = 16;
S32 size = (S32) mBuildQ2.size();
if (size > 1024)
{
min_count = llclamp((S32) (size * (F32) size/4096), 16, size);
}
S32 count = 0;
max_dtime = llmax(update_timer.getElapsedTimeF32()+0.001f, max_dtime);
LLSpatialGroup* last_group = NULL;
LLSpatialBridge* last_bridge = NULL;
for (LLDrawable::drawable_list_t::iterator iter = mBuildQ2.begin();
iter != mBuildQ2.end(); )
{
LLDrawable::drawable_list_t::iterator curiter = iter++;
LLDrawable* drawablep = *curiter;
LLSpatialBridge* bridge = drawablep->isRoot() ? drawablep->getSpatialBridge() :
drawablep->getParent()->getSpatialBridge();
if (drawablep->getSpatialGroup() != last_group &&
(!last_bridge || bridge != last_bridge) &&
(update_timer.getElapsedTimeF32() >= max_dtime) && count > min_count)
{
break;
}
//make sure updates don't stop in the middle of a spatial group
//to avoid thrashing (objects are enqueued by group)
last_group = drawablep->getSpatialGroup();
last_bridge = bridge;
BOOL update_complete = TRUE;
if (!drawablep->isDead())
{
update_complete = updateDrawableGeom(drawablep, FALSE);
count++;
}
if (update_complete)
{
drawablep->clearState(LLDrawable::IN_REBUILD_Q2);
mBuildQ2.erase(curiter);
}
}
updateMovedList(mMovedBridge);
}
void LLPipeline::markVisible(LLDrawable *drawablep, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_VISIBLE);
if(!drawablep || drawablep->isDead())
{
return;
}
if (drawablep->isSpatialBridge())
{
LLDrawable* root = ((LLSpatialBridge*) drawablep)->mDrawable;
if (root && root->getParent() && root->getVObj() && root->getVObj()->isAttachment())
{
LLVOAvatar* av = root->getParent()->getVObj()->asAvatar();
if (av && av->isImpostor())
{
return;
}
}
sCull->pushBridge((LLSpatialBridge*) drawablep);
}
else
{
sCull->pushDrawable(drawablep);
}
drawablep->setVisible(camera);
}
void LLPipeline::markMoved(LLDrawable *drawablep, BOOL damped_motion)
{
LLMemType mt_mm(LLMemType::MTYPE_PIPELINE_MARK_MOVED);
if (!drawablep)
{
//llerrs << "Sending null drawable to moved list!" << llendl;
return;
}
if (drawablep->isDead())
{
llwarns << "Marking NULL or dead drawable moved!" << llendl;
return;
}
if (drawablep->getParent())
{
//ensure that parent drawables are moved first
markMoved(drawablep->getParent(), damped_motion);
}
assertInitialized();
if (!drawablep->isState(LLDrawable::ON_MOVE_LIST))
{
if (drawablep->isSpatialBridge())
{
mMovedBridge.push_back(drawablep);
}
else
{
mMovedList.push_back(drawablep);
}
drawablep->setState(LLDrawable::ON_MOVE_LIST);
}
if (damped_motion == FALSE)
{
drawablep->setState(LLDrawable::MOVE_UNDAMPED); // UNDAMPED trumps DAMPED
}
else if (drawablep->isState(LLDrawable::MOVE_UNDAMPED))
{
drawablep->clearState(LLDrawable::MOVE_UNDAMPED);
}
}
void LLPipeline::markShift(LLDrawable *drawablep)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_SHIFT);
if (!drawablep || drawablep->isDead())
{
return;
}
assertInitialized();
if (!drawablep->isState(LLDrawable::ON_SHIFT_LIST))
{
drawablep->getVObj()->setChanged(LLXform::SHIFTED | LLXform::SILHOUETTE);
if (drawablep->getParent())
{
markShift(drawablep->getParent());
}
mShiftList.push_back(drawablep);
drawablep->setState(LLDrawable::ON_SHIFT_LIST);
}
}
void LLPipeline::shiftObjects(const LLVector3 &offset)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_SHIFT_OBJECTS);
assertInitialized();
glClear(GL_DEPTH_BUFFER_BIT);
gDepthDirty = TRUE;
for (LLDrawable::drawable_vector_t::iterator iter = mShiftList.begin();
iter != mShiftList.end(); iter++)
{
LLDrawable *drawablep = *iter;
if (drawablep->isDead())
{
continue;
}
drawablep->shiftPos(offset);
drawablep->clearState(LLDrawable::ON_SHIFT_LIST);
}
mShiftList.resize(0);
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
part->shift(offset);
}
}
}
LLHUDText::shiftAll(offset);
display_update_camera();
}
void LLPipeline::markTextured(LLDrawable *drawablep)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_TEXTURED);
if (drawablep && !drawablep->isDead() && assertInitialized())
{
mRetexturedList.insert(drawablep);
}
}
void LLPipeline::markGLRebuild(LLGLUpdate* glu)
{
if (glu && !glu->mInQ)
{
LLGLUpdate::sGLQ.push_back(glu);
glu->mInQ = TRUE;
}
}
void LLPipeline::markRebuild(LLSpatialGroup* group, BOOL priority)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
//assert_main_thread();
if (group && !group->isDead() && group->mSpatialPartition)
{
if (group->mSpatialPartition->mPartitionType == LLViewerRegion::PARTITION_HUD)
{
priority = TRUE;
}
if (priority)
{
if (!group->isState(LLSpatialGroup::IN_BUILD_Q1))
{
mGroupQ1.push_back(group);
group->setState(LLSpatialGroup::IN_BUILD_Q1);
if (group->isState(LLSpatialGroup::IN_BUILD_Q2))
{
LLSpatialGroup::sg_vector_t::iterator iter = std::find(mGroupQ2.begin(), mGroupQ2.end(), group);
if (iter != mGroupQ2.end())
{
mGroupQ2.erase(iter);
}
group->clearState(LLSpatialGroup::IN_BUILD_Q2);
}
}
}
else if (!group->isState(LLSpatialGroup::IN_BUILD_Q2 | LLSpatialGroup::IN_BUILD_Q1))
{
//llerrs << "Non-priority updates not yet supported!" << llendl;
if (std::find(mGroupQ2.begin(), mGroupQ2.end(), group) != mGroupQ2.end())
{
llerrs << "WTF?" << llendl;
}
mGroupQ2.push_back(group);
group->setState(LLSpatialGroup::IN_BUILD_Q2);
}
}
}
void LLPipeline::markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags flag, BOOL priority)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_REBUILD);
if (drawablep && !drawablep->isDead() && assertInitialized())
{
if (!drawablep->isState(LLDrawable::BUILT))
{
priority = TRUE;
}
if (priority)
{
if (!drawablep->isState(LLDrawable::IN_REBUILD_Q1))
{
mBuildQ1.push_back(drawablep);
drawablep->setState(LLDrawable::IN_REBUILD_Q1); // mark drawable as being in priority queue
}
}
else if (!drawablep->isState(LLDrawable::IN_REBUILD_Q2))
{
mBuildQ2.push_back(drawablep);
drawablep->setState(LLDrawable::IN_REBUILD_Q2); // need flag here because it is just a list
}
if (flag & (LLDrawable::REBUILD_VOLUME | LLDrawable::REBUILD_POSITION))
{
drawablep->getVObj()->setChanged(LLXform::SILHOUETTE);
}
drawablep->setState(flag);
}
}
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)
{
//clear faces from face pools
LLFastTimer t(FTM_RESET_DRAWORDER);
gPipeline.resetDrawOrders();
}
LLFastTimer ftm(FTM_STATESORT);
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
//LLVertexBuffer::unbind();
grabReferences(result);
for (LLCullResult::sg_list_t::iterator iter = sCull->beginDrawableGroups(); iter != sCull->endDrawableGroups(); ++iter)
{
LLSpatialGroup* group = *iter;
group->checkOcclusion();
if (sUseOcclusion > 1 && group->isOcclusionState(LLSpatialGroup::OCCLUDED))
{
markOccluder(group);
}
else
{
group->setVisible();
for (LLSpatialGroup::element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
{
markVisible(*i, camera);
}
}
}
for (LLCullResult::sg_list_t::iterator iter = sCull->beginVisibleGroups(); iter != sCull->endVisibleGroups(); ++iter)
{
LLSpatialGroup* group = *iter;
group->checkOcclusion();
if (sUseOcclusion > 1 && group->isOcclusionState(LLSpatialGroup::OCCLUDED))
{
markOccluder(group);
}
else
{
group->setVisible();
stateSort(group, camera);
}
}
if (LLViewerCamera::sCurCameraID == LLViewerCamera::CAMERA_WORLD)
{
for (LLCullResult::bridge_list_t::iterator i = sCull->beginVisibleBridge(); i != sCull->endVisibleBridge(); ++i)
{
LLCullResult::bridge_list_t::iterator cur_iter = i;
LLSpatialBridge* bridge = *cur_iter;
LLSpatialGroup* group = bridge->getSpatialGroup();
if (!bridge->isDead() && group && !group->isOcclusionState(LLSpatialGroup::OCCLUDED))
{
stateSort(bridge, camera);
}
}
}
{
LLFastTimer ftm(FTM_STATESORT_DRAWABLE);
for (LLCullResult::drawable_list_t::iterator iter = sCull->beginVisibleList();
iter != sCull->endVisibleList(); ++iter)
{
LLDrawable *drawablep = *iter;
if (!drawablep->isDead())
{
stateSort(drawablep, camera);
}
}
}
{
LLFastTimer ftm(FTM_CLIENT_COPY);
LLVertexBuffer::clientCopy();
}
postSort(camera);
}
void LLPipeline::stateSort(LLSpatialGroup* group, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
if (group->changeLOD())
{
for (LLSpatialGroup::element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
{
LLDrawable* drawablep = *i;
stateSort(drawablep, camera);
}
}
}
void LLPipeline::stateSort(LLSpatialBridge* bridge, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
if (!sShadowRender && bridge->getSpatialGroup()->changeLOD())
{
bool force_update = false;
bridge->updateDistance(camera, force_update);
}
}
void LLPipeline::stateSort(LLDrawable* drawablep, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
if (!drawablep
|| drawablep->isDead()
|| !hasRenderType(drawablep->getRenderType()))
{
return;
}
if (LLSelectMgr::getInstance()->mHideSelectedObjects)
{
if (drawablep->getVObj().notNull() &&
drawablep->getVObj()->isSelected())
{
return;
}
}
if (drawablep->isAvatar())
{ //don't draw avatars beyond render distance or if we don't have a spatial group.
if ((drawablep->getSpatialGroup() == NULL) ||
(drawablep->getSpatialGroup()->mDistance > LLVOAvatar::sRenderDistance))
{
return;
}
LLVOAvatar* avatarp = (LLVOAvatar*) drawablep->getVObj().get();
if (!avatarp->isVisible())
{
return;
}
}
assertInitialized();
if (hasRenderType(drawablep->mRenderType))
{
if (!drawablep->isState(LLDrawable::INVISIBLE|LLDrawable::FORCE_INVISIBLE))
{
drawablep->setVisible(camera, NULL, FALSE);
}
else if (drawablep->isState(LLDrawable::CLEAR_INVISIBLE))
{
// clear invisible flag here to avoid single frame glitch
drawablep->clearState(LLDrawable::FORCE_INVISIBLE|LLDrawable::CLEAR_INVISIBLE);
}
}
if (LLViewerCamera::sCurCameraID == LLViewerCamera::CAMERA_WORLD)
{
LLSpatialGroup* group = drawablep->getSpatialGroup();
if (!group || group->changeLOD())
{
if (drawablep->isVisible())
{
if (!drawablep->isActive())
{
bool force_update = false;
drawablep->updateDistance(camera, force_update);
}
else if (drawablep->isAvatar())
{
bool force_update = false;
drawablep->updateDistance(camera, force_update); // calls vobj->updateLOD() which calls LLVOAvatar::updateVisibility()
}
}
}
}
if (!drawablep->getVOVolume())
{
for (LLDrawable::face_list_t::iterator iter = drawablep->mFaces.begin();
iter != drawablep->mFaces.end(); iter++)
{
LLFace* facep = *iter;
if (facep->hasGeometry())
{
if (facep->getPool())
{
facep->getPool()->enqueue(facep);
}
else
{
break;
}
}
}
}
mNumVisibleFaces += drawablep->getNumFaces();
}
void forAllDrawables(LLCullResult::sg_list_t::iterator begin,
LLCullResult::sg_list_t::iterator end,
void (*func)(LLDrawable*))
{
for (LLCullResult::sg_list_t::iterator i = begin; i != end; ++i)
{
for (LLSpatialGroup::element_iter j = (*i)->getData().begin(); j != (*i)->getData().end(); ++j)
{
func(*j);
}
}
}
void LLPipeline::forAllVisibleDrawables(void (*func)(LLDrawable*))
{
forAllDrawables(sCull->beginDrawableGroups(), sCull->endDrawableGroups(), func);
forAllDrawables(sCull->beginVisibleGroups(), sCull->endVisibleGroups(), func);
}
//function for creating scripted beacons
void renderScriptedBeacons(LLDrawable* drawablep)
{
LLViewerObject *vobj = drawablep->getVObj();
if (vobj
&& !vobj->isAvatar()
&& !vobj->getParent()
&& vobj->flagScripted())
{
if (gPipeline.sRenderBeacons)
{
gObjectList.addDebugBeacon(vobj->getPositionAgent(), "", LLColor4(1.f, 0.f, 0.f, 0.5f), LLColor4(1.f, 1.f, 1.f, 0.5f), gSavedSettings.getS32("DebugBeaconLineWidth"));
}
if (gPipeline.sRenderHighlight)
{
S32 face_id;
S32 count = drawablep->getNumFaces();
for (face_id = 0; face_id < count; face_id++)
{
gPipeline.mHighlightFaces.push_back(drawablep->getFace(face_id) );
}
}
}
}
void renderScriptedTouchBeacons(LLDrawable* drawablep)
{
LLViewerObject *vobj = drawablep->getVObj();
if (vobj
&& !vobj->isAvatar()
&& !vobj->getParent()
&& vobj->flagScripted()
&& vobj->flagHandleTouch())
{
if (gPipeline.sRenderBeacons)
{
gObjectList.addDebugBeacon(vobj->getPositionAgent(), "", LLColor4(1.f, 0.f, 0.f, 0.5f), LLColor4(1.f, 1.f, 1.f, 0.5f), gSavedSettings.getS32("DebugBeaconLineWidth"));
}
if (gPipeline.sRenderHighlight)
{
S32 face_id;
S32 count = drawablep->getNumFaces();
for (face_id = 0; face_id < count; face_id++)
{
gPipeline.mHighlightFaces.push_back(drawablep->getFace(face_id) );
}
}
}
}
void renderPhysicalBeacons(LLDrawable* drawablep)
{
LLViewerObject *vobj = drawablep->getVObj();
if (vobj
&& !vobj->isAvatar()
//&& !vobj->getParent()
&& vobj->usePhysics())
{
if (gPipeline.sRenderBeacons)
{
gObjectList.addDebugBeacon(vobj->getPositionAgent(), "", LLColor4(0.f, 1.f, 0.f, 0.5f), LLColor4(1.f, 1.f, 1.f, 0.5f), gSavedSettings.getS32("DebugBeaconLineWidth"));
}
if (gPipeline.sRenderHighlight)
{
S32 face_id;
S32 count = drawablep->getNumFaces();
for (face_id = 0; face_id < count; face_id++)
{
gPipeline.mHighlightFaces.push_back(drawablep->getFace(face_id) );
}
}
}
}
void renderParticleBeacons(LLDrawable* drawablep)
{
// Look for attachments, objects, etc.
LLViewerObject *vobj = drawablep->getVObj();
if (vobj
&& vobj->isParticleSource())
{
if (gPipeline.sRenderBeacons)
{
LLColor4 light_blue(0.5f, 0.5f, 1.f, 0.5f);
gObjectList.addDebugBeacon(vobj->getPositionAgent(), "", light_blue, LLColor4(1.f, 1.f, 1.f, 0.5f), gSavedSettings.getS32("DebugBeaconLineWidth"));
}
if (gPipeline.sRenderHighlight)
{
S32 face_id;
S32 count = drawablep->getNumFaces();
for (face_id = 0; face_id < count; face_id++)
{
gPipeline.mHighlightFaces.push_back(drawablep->getFace(face_id) );
}
}
}
}
void renderSoundHighlights(LLDrawable* drawablep)
{
// Look for attachments, objects, etc.
LLViewerObject *vobj = drawablep->getVObj();
if (vobj && vobj->isAudioSource())
{
if (gPipeline.sRenderHighlight)
{
S32 face_id;
S32 count = drawablep->getNumFaces();
for (face_id = 0; face_id < count; face_id++)
{
gPipeline.mHighlightFaces.push_back(drawablep->getFace(face_id) );
}
}
}
}
void LLPipeline::postSort(LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_POST_SORT);
LLFastTimer ftm(FTM_STATESORT_POSTSORT);
assertInitialized();
//rebuild drawable geometry
for (LLCullResult::sg_list_t::iterator i = sCull->beginDrawableGroups(); i != sCull->endDrawableGroups(); ++i)
{
LLSpatialGroup* group = *i;
if (!sUseOcclusion ||
!group->isOcclusionState(LLSpatialGroup::OCCLUDED))
{
group->rebuildGeom();
}
}
//rebuild groups
sCull->assertDrawMapsEmpty();
/*LLSpatialGroup::sNoDelete = FALSE;
for (LLCullResult::sg_list_t::iterator i = sCull->beginVisibleGroups(); i != sCull->endVisibleGroups(); ++i)
{
LLSpatialGroup* group = *i;
if (sUseOcclusion &&
group->isState(LLSpatialGroup::OCCLUDED))
{
continue;
}
group->rebuildGeom();
}
LLSpatialGroup::sNoDelete = TRUE;*/
rebuildPriorityGroups();
const S32 bin_count = 1024*8;
static LLCullResult::drawinfo_list_t alpha_bins[bin_count];
static U32 bin_size[bin_count];
//clear one bin per frame to avoid memory bloat
static S32 clear_idx = 0;
clear_idx = (1+clear_idx)%bin_count;
alpha_bins[clear_idx].clear();
for (U32 j = 0; j < bin_count; j++)
{
bin_size[j] = 0;
}
//build render map
for (LLCullResult::sg_list_t::iterator i = sCull->beginVisibleGroups(); i != sCull->endVisibleGroups(); ++i)
{
LLSpatialGroup* group = *i;
if (sUseOcclusion &&
group->isOcclusionState(LLSpatialGroup::OCCLUDED))
{
continue;
}
if (group->isState(LLSpatialGroup::NEW_DRAWINFO) && group->isState(LLSpatialGroup::GEOM_DIRTY))
{ //no way this group is going to be drawable without a rebuild
group->rebuildGeom();
}
for (LLSpatialGroup::draw_map_t::iterator j = group->mDrawMap.begin(); j != group->mDrawMap.end(); ++j)
{
LLSpatialGroup::drawmap_elem_t& src_vec = j->second;
if (!hasRenderType(j->first))
{
continue;
}
for (LLSpatialGroup::drawmap_elem_t::iterator k = src_vec.begin(); k != src_vec.end(); ++k)
{
if (sMinRenderSize > 0.f)
{
LLVector3 bounds = (*k)->mExtents[1]-(*k)->mExtents[0];
if (llmax(llmax(bounds.mV[0], bounds.mV[1]), bounds.mV[2]) > sMinRenderSize)
{
sCull->pushDrawInfo(j->first, *k);
}
}
else
{
sCull->pushDrawInfo(j->first, *k);
}
}
}
if (hasRenderType(LLPipeline::RENDER_TYPE_PASS_ALPHA))
{
LLSpatialGroup::draw_map_t::iterator alpha = group->mDrawMap.find(LLRenderPass::PASS_ALPHA);
if (alpha != group->mDrawMap.end())
{ //store alpha groups for sorting
LLSpatialBridge* bridge = group->mSpatialPartition->asBridge();
if (LLViewerCamera::sCurCameraID == LLViewerCamera::CAMERA_WORLD)
{
if (bridge)
{
LLCamera trans_camera = bridge->transformCamera(camera);
group->updateDistance(trans_camera);
}
else
{
group->updateDistance(camera);
}
}
if (hasRenderType(LLDrawPool::POOL_ALPHA))
{
sCull->pushAlphaGroup(group);
}
}
}
}
if (!sShadowRender)
{
//sort by texture or bump map
for (U32 i = 0; i < LLRenderPass::NUM_RENDER_TYPES; ++i)
{
if (i == LLRenderPass::PASS_BUMP)
{
std::sort(sCull->beginRenderMap(i), sCull->endRenderMap(i), LLDrawInfo::CompareBump());
}
else
{
std::sort(sCull->beginRenderMap(i), sCull->endRenderMap(i), LLDrawInfo::CompareTexturePtrMatrix());
}
}
std::sort(sCull->beginAlphaGroups(), sCull->endAlphaGroups(), LLSpatialGroup::CompareDepthGreater());
}
// only render if the flag is set. The flag is only set if we are in edit mode or the toggle is set in the menus
if (LLFloaterReg::instanceVisible("beacons") && !sShadowRender)
{
if (sRenderScriptedTouchBeacons)
{
// Only show the beacon on the root object.
forAllVisibleDrawables(renderScriptedTouchBeacons);
}
else
if (sRenderScriptedBeacons)
{
// Only show the beacon on the root object.
forAllVisibleDrawables(renderScriptedBeacons);
}
if (sRenderPhysicalBeacons)
{
// Only show the beacon on the root object.
forAllVisibleDrawables(renderPhysicalBeacons);
}
if (sRenderParticleBeacons)
{
forAllVisibleDrawables(renderParticleBeacons);
}
// If god mode, also show audio cues
if (sRenderSoundBeacons && gAudiop)
{
// Walk all sound sources and render out beacons for them. Note, this isn't done in the ForAllVisibleDrawables function, because some are not visible.
LLAudioEngine::source_map::iterator iter;
for (iter = gAudiop->mAllSources.begin(); iter != gAudiop->mAllSources.end(); ++iter)
{
LLAudioSource *sourcep = iter->second;
LLVector3d pos_global = sourcep->getPositionGlobal();
LLVector3 pos = gAgent.getPosAgentFromGlobal(pos_global);
if (gPipeline.sRenderBeacons)
{
//pos += LLVector3(0.f, 0.f, 0.2f);
gObjectList.addDebugBeacon(pos, "", LLColor4(1.f, 1.f, 0.f, 0.5f), LLColor4(1.f, 1.f, 1.f, 0.5f), gSavedSettings.getS32("DebugBeaconLineWidth"));
}
}
// now deal with highlights for all those seeable sound sources
forAllVisibleDrawables(renderSoundHighlights);
}
}
// If managing your telehub, draw beacons at telehub and currently selected spawnpoint.
if (LLFloaterTelehub::renderBeacons())
{
LLFloaterTelehub::addBeacons();
}
if (!sShadowRender)
{
mSelectedFaces.clear();
// Draw face highlights for selected faces.
if (LLSelectMgr::getInstance()->getTEMode())
{
struct f : public LLSelectedTEFunctor
{
virtual bool apply(LLViewerObject* object, S32 te)
{
if (object->mDrawable)
{
gPipeline.mSelectedFaces.push_back(object->mDrawable->getFace(te));
}
return true;
}
} func;
LLSelectMgr::getInstance()->getSelection()->applyToTEs(&func);
}
}
//LLSpatialGroup::sNoDelete = FALSE;
}
void render_hud_elements()
{
LLMemType mt_rhe(LLMemType::MTYPE_PIPELINE_RENDER_HUD_ELS);
LLFastTimer t(FTM_RENDER_UI);
gPipeline.disableLights();
LLGLDisable fog(GL_FOG);
LLGLSUIDefault gls_ui;
LLGLEnable stencil(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 255, 0xFFFFFFFF);
glStencilMask(0xFFFFFFFF);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
gGL.color4f(1,1,1,1);
if (!LLPipeline::sReflectionRender && gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
{
LLGLEnable multisample(GL_MULTISAMPLE_ARB);
gViewerWindow->renderSelections(FALSE, FALSE, FALSE); // For HUD version in render_ui_3d()
// Draw the tracking overlays
LLTracker::render3D();
// Show the property lines
LLWorld::getInstance()->renderPropertyLines();
LLViewerParcelMgr::getInstance()->render();
LLViewerParcelMgr::getInstance()->renderParcelCollision();
// Render name tags.
LLHUDObject::renderAll();
}
else if (gForceRenderLandFence)
{
// This is only set when not rendering the UI, for parcel snapshots
LLViewerParcelMgr::getInstance()->render();
}
else if (gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_HUD))
{
LLHUDText::renderAllHUD();
}
gGL.flush();
}
void LLPipeline::renderHighlights()
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_RENDER_HL);
assertInitialized();
// Draw 3D UI elements here (before we clear the Z buffer in POOL_HUD)
// Render highlighted faces.
LLGLSPipelineAlpha gls_pipeline_alpha;
LLColor4 color(1.f, 1.f, 1.f, 0.5f);
LLGLEnable color_mat(GL_COLOR_MATERIAL);
disableLights();
if (!hasRenderType(LLPipeline::RENDER_TYPE_HUD) && !mHighlightSet.empty())
{ //draw blurry highlight image over screen
LLGLEnable blend(GL_BLEND);
LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_ALWAYS);
LLGLDisable test(GL_ALPHA_TEST);
LLGLEnable stencil(GL_STENCIL_TEST);
gGL.flush();
glStencilMask(0xFFFFFFFF);
glClearStencil(1);
glClear(GL_STENCIL_BUFFER_BIT);
glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
gGL.setColorMask(false, false);
for (std::set<HighlightItem>::iterator iter = mHighlightSet.begin(); iter != mHighlightSet.end(); ++iter)
{
renderHighlight(iter->mItem->getVObj(), 1.f);
}
gGL.setColorMask(true, false);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
//gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
gGL.pushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
gGL.pushMatrix();
glLoadIdentity();
gGL.getTexUnit(0)->bind(&mHighlight);
LLVector2 tc1;
LLVector2 tc2;
tc1.setVec(0,0);
tc2.setVec(2,2);
gGL.begin(LLRender::TRIANGLES);
F32 scale = gSavedSettings.getF32("RenderHighlightBrightness");
LLColor4 color = gSavedSettings.getColor4("RenderHighlightColor");
F32 thickness = gSavedSettings.getF32("RenderHighlightThickness");
for (S32 pass = 0; pass < 2; ++pass)
{
if (pass == 0)
{
gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
}
else
{
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
for (S32 i = 0; i < 8; ++i)
{
for (S32 j = 0; j < 8; ++j)
{
LLVector2 tc(i-4+0.5f, j-4+0.5f);
F32 dist = 1.f-(tc.length()/sqrtf(32.f));
dist *= scale/64.f;
tc *= thickness;
tc.mV[0] = (tc.mV[0])/mHighlight.getWidth();
tc.mV[1] = (tc.mV[1])/mHighlight.getHeight();
gGL.color4f(color.mV[0],
color.mV[1],
color.mV[2],
color.mV[3]*dist);
gGL.texCoord2f(tc.mV[0]+tc1.mV[0], tc.mV[1]+tc2.mV[1]);
gGL.vertex2f(-1,3);
gGL.texCoord2f(tc.mV[0]+tc1.mV[0], tc.mV[1]+tc1.mV[1]);
gGL.vertex2f(-1,-1);
gGL.texCoord2f(tc.mV[0]+tc2.mV[0], tc.mV[1]+tc1.mV[1]);
gGL.vertex2f(3,-1);
}
}
}
gGL.end();
gGL.popMatrix();
glMatrixMode(GL_MODELVIEW);
gGL.popMatrix();
//gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
if ((LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_INTERFACE) > 0))
{
gHighlightProgram.bind();
gHighlightProgram.vertexAttrib4f(LLViewerShaderMgr::MATERIAL_COLOR,1,1,1,0.5f);
}
if (hasRenderDebugFeatureMask(RENDER_DEBUG_FEATURE_SELECTED))
{
// Make sure the selection image gets downloaded and decoded
if (!mFaceSelectImagep)
{
mFaceSelectImagep = LLViewerTextureManager::getFetchedTexture(IMG_FACE_SELECT);
}
mFaceSelectImagep->addTextureStats((F32)MAX_IMAGE_AREA);
U32 count = mSelectedFaces.size();
for (U32 i = 0; i < count; i++)
{
LLFace *facep = mSelectedFaces[i];
if (!facep || facep->getDrawable()->isDead())
{
llerrs << "Bad face on selection" << llendl;
return;
}
facep->renderSelected(mFaceSelectImagep, color);
}
}
if (hasRenderDebugFeatureMask(RENDER_DEBUG_FEATURE_SELECTED))
{
// Paint 'em red!
color.setVec(1.f, 0.f, 0.f, 0.5f);
if ((LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_INTERFACE) > 0))
{
gHighlightProgram.vertexAttrib4f(LLViewerShaderMgr::MATERIAL_COLOR,1,0,0,0.5f);
}
int count = mHighlightFaces.size();
for (S32 i = 0; i < count; i++)
{
LLFace* facep = mHighlightFaces[i];
facep->renderSelected(LLViewerTexture::sNullImagep, color);
}
}
// Contains a list of the faces of objects that are physical or
// have touch-handlers.
mHighlightFaces.clear();
if (LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_INTERFACE) > 0)
{
gHighlightProgram.unbind();
}
}
void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_RENDER_GEOM);
LLFastTimer t(FTM_RENDER_GEOMETRY);
assertInitialized();
F64 saved_modelview[16];
F64 saved_projection[16];
//HACK: preserve/restore matrices around HUD render
if (gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_HUD))
{
for (U32 i = 0; i < 16; i++)
{
saved_modelview[i] = gGLModelView[i];
saved_projection[i] = gGLProjection[i];
}
}
///////////////////////////////////////////
//
// Sync and verify GL state
//
//
stop_glerror();
LLVertexBuffer::unbind();
// Do verification of GL state
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
if (mRenderDebugMask & RENDER_DEBUG_VERIFY)
{
if (!verify())
{
llerrs << "Pipeline verification failed!" << llendl;
}
}
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:ForceVBO");
// Initialize lots of GL state to "safe" values
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
LLGLSPipeline gls_pipeline;
LLGLEnable multisample(GL_MULTISAMPLE_ARB);
LLGLState gls_color_material(GL_COLOR_MATERIAL, mLightingDetail < 2);
// Toggle backface culling for debugging
LLGLEnable cull_face(mBackfaceCull ? GL_CULL_FACE : 0);
// Set fog
BOOL use_fog = hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_FOG);
LLGLEnable fog_enable(use_fog &&
!gPipeline.canUseWindLightShadersOnObjects() ? GL_FOG : 0);
gSky.updateFog(camera.getFar());
if (!use_fog)
{
sUnderWaterRender = FALSE;
}
gGL.getTexUnit(0)->bind(LLViewerFetchedTexture::sDefaultImagep);
LLViewerFetchedTexture::sDefaultImagep->setAddressMode(LLTexUnit::TAM_WRAP);
//////////////////////////////////////////////
//
// Actually render all of the geometry
//
//
stop_glerror();
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderDrawPools");
for (pool_set_t::iterator iter = mPools.begin(); iter != mPools.end(); ++iter)
{
LLDrawPool *poolp = *iter;
if (hasRenderType(poolp->getType()))
{
poolp->prerender();
}
}
if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_PICKING))
{
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderForSelect");
gObjectList.renderObjectsForSelect(camera, gViewerWindow->getWindowRectScaled());
}
else
{
LLFastTimer t(FTM_POOLS);
// HACK: don't calculate local lights if we're rendering the HUD!
// Removing this check will cause bad flickering when there are
// HUD elements being rendered AND the user is in flycam mode -nyx
if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_HUD))
{
calcNearbyLights(camera);
setupHWLights(NULL);
}
BOOL occlude = sUseOcclusion > 1;
U32 cur_type = 0;
pool_set_t::iterator iter1 = mPools.begin();
while ( iter1 != mPools.end() )
{
LLDrawPool *poolp = *iter1;
cur_type = poolp->getType();
if (occlude && cur_type >= LLDrawPool::POOL_GRASS)
{
occlude = FALSE;
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
doOcclusion(camera);
}
pool_set_t::iterator iter2 = iter1;
if (hasRenderType(poolp->getType()) && poolp->getNumPasses() > 0)
{
LLFastTimer t(FTM_POOLRENDER);
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
for( S32 i = 0; i < poolp->getNumPasses(); i++ )
{
LLVertexBuffer::unbind();
poolp->beginRenderPass(i);
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
p->render(i);
}
poolp->endRenderPass(i);
LLVertexBuffer::unbind();
if (gDebugGL || gDebugPipeline)
{
GLint depth;
glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &depth);
if (depth > 3)
{
if (gDebugSession)
{
ll_fail("GL matrix stack corrupted.");
}
llerrs << "GL matrix stack corrupted!" << llendl;
}
std::string msg = llformat("%s pass %d", gPoolNames[cur_type].c_str(), i);
LLGLState::checkStates(msg);
LLGLState::checkTextureChannels(msg);
LLGLState::checkClientArrays(msg);
}
}
}
else
{
// Skip all pools of this type
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
}
}
iter1 = iter2;
stop_glerror();
}
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderDrawPoolsEnd");
LLVertexBuffer::unbind();
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
if (occlude)
{
occlude = FALSE;
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
doOcclusion(camera);
}
}
LLVertexBuffer::unbind();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
stop_glerror();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderHighlights");
if (!sReflectionRender)
{
renderHighlights();
}
// Contains a list of the faces of objects that are physical or
// have touch-handlers.
mHighlightFaces.clear();
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderDebug");
renderDebug();
LLVertexBuffer::unbind();
if (!LLPipeline::sReflectionRender && !LLPipeline::sRenderDeferred && gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
{
// Render debugging beacons.
gObjectList.renderObjectBeacons();
gObjectList.resetObjectBeacons();
}
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderGeomEnd");
//HACK: preserve/restore matrices around HUD render
if (gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_HUD))
{
for (U32 i = 0; i < 16; i++)
{
gGLModelView[i] = saved_modelview[i];
gGLProjection[i] = saved_projection[i];
}
}
LLVertexBuffer::unbind();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
}
void LLPipeline::renderGeomDeferred(LLCamera& camera)
{
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderGeomDeferred");
LLMemType mt_rgd(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_DEFFERRED);
LLFastTimer t(FTM_RENDER_GEOMETRY);
LLFastTimer t2(FTM_POOLS);
LLGLEnable cull(GL_CULL_FACE);
LLGLEnable stencil(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
stop_glerror();
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
stop_glerror();
for (pool_set_t::iterator iter = mPools.begin(); iter != mPools.end(); ++iter)
{
LLDrawPool *poolp = *iter;
if (hasRenderType(poolp->getType()))
{
poolp->prerender();
}
}
LLGLEnable multisample(GL_MULTISAMPLE_ARB);
LLVertexBuffer::unbind();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
U32 cur_type = 0;
gGL.setColorMask(true, true);
pool_set_t::iterator iter1 = mPools.begin();
while ( iter1 != mPools.end() )
{
LLDrawPool *poolp = *iter1;
cur_type = poolp->getType();
pool_set_t::iterator iter2 = iter1;
if (hasRenderType(poolp->getType()) && poolp->getNumDeferredPasses() > 0)
{
LLFastTimer t(FTM_POOLRENDER);
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
for( S32 i = 0; i < poolp->getNumDeferredPasses(); i++ )
{
LLVertexBuffer::unbind();
poolp->beginDeferredPass(i);
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
p->renderDeferred(i);
}
poolp->endDeferredPass(i);
LLVertexBuffer::unbind();
if (gDebugGL || gDebugPipeline)
{
GLint depth;
glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &depth);
if (depth > 3)
{
llerrs << "GL matrix stack corrupted!" << llendl;
}
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
}
}
}
else
{
// Skip all pools of this type
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
}
}
iter1 = iter2;
stop_glerror();
}
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
gGL.setColorMask(true, false);
}
void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
{
LLMemType mt_rgpd(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_POST_DEF);
LLFastTimer t(FTM_POOLS);
U32 cur_type = 0;
LLGLEnable cull(GL_CULL_FACE);
LLGLEnable multisample(GL_MULTISAMPLE_ARB);
calcNearbyLights(camera);
setupHWLights(NULL);
gGL.setColorMask(true, false);
pool_set_t::iterator iter1 = mPools.begin();
BOOL occlude = LLPipeline::sUseOcclusion > 1;
while ( iter1 != mPools.end() )
{
LLDrawPool *poolp = *iter1;
cur_type = poolp->getType();
if (occlude && cur_type >= LLDrawPool::POOL_GRASS)
{
occlude = FALSE;
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
doOcclusion(camera);
gGL.setColorMask(true, false);
}
pool_set_t::iterator iter2 = iter1;
if (hasRenderType(poolp->getType()) && poolp->getNumPostDeferredPasses() > 0)
{
LLFastTimer t(FTM_POOLRENDER);
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
for( S32 i = 0; i < poolp->getNumPostDeferredPasses(); i++ )
{
LLVertexBuffer::unbind();
poolp->beginPostDeferredPass(i);
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
p->renderPostDeferred(i);
}
poolp->endPostDeferredPass(i);
LLVertexBuffer::unbind();
if (gDebugGL || gDebugPipeline)
{
GLint depth;
glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &depth);
if (depth > 3)
{
llerrs << "GL matrix stack corrupted!" << llendl;
}
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
}
}
}
else
{
// Skip all pools of this type
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
}
}
iter1 = iter2;
stop_glerror();
}
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
renderHighlights();
mHighlightFaces.clear();
renderDebug();
LLVertexBuffer::unbind();
if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
{
// Render debugging beacons.
gObjectList.renderObjectBeacons();
gObjectList.resetObjectBeacons();
}
if (occlude)
{
occlude = FALSE;
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
doOcclusion(camera);
}
}
void LLPipeline::renderGeomShadow(LLCamera& camera)
{
LLMemType mt_rgs(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_SHADOW);
U32 cur_type = 0;
LLGLEnable cull(GL_CULL_FACE);
LLVertexBuffer::unbind();
pool_set_t::iterator iter1 = mPools.begin();
while ( iter1 != mPools.end() )
{
LLDrawPool *poolp = *iter1;
cur_type = poolp->getType();
pool_set_t::iterator iter2 = iter1;
if (hasRenderType(poolp->getType()) && poolp->getNumShadowPasses() > 0)
{
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
for( S32 i = 0; i < poolp->getNumShadowPasses(); i++ )
{
LLVertexBuffer::unbind();
poolp->beginShadowPass(i);
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
p->renderShadow(i);
}
poolp->endShadowPass(i);
LLVertexBuffer::unbind();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
}
}
else
{
// Skip all pools of this type
for (iter2 = iter1; iter2 != mPools.end(); iter2++)
{
LLDrawPool *p = *iter2;
if (p->getType() != cur_type)
{
break;
}
}
}
iter1 = iter2;
stop_glerror();
}
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
}
void LLPipeline::addTrianglesDrawn(S32 count)
{
assertInitialized();
mTrianglesDrawn += count;
mBatchCount++;
mMaxBatchSize = llmax(mMaxBatchSize, count);
mMinBatchSize = llmin(mMinBatchSize, count);
if (LLPipeline::sRenderFrameTest)
{
gViewerWindow->getWindow()->swapBuffers();
ms_sleep(16);
}
}
void LLPipeline::renderDebug()
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
assertInitialized();
gGL.color4f(1,1,1,1);
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
gGL.setColorMask(true, false);
// Debug stuff.
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
if (hasRenderType(part->mDrawableType))
{
part->renderDebug();
}
}
}
}
for (LLCullResult::bridge_list_t::const_iterator i = sCull->beginVisibleBridge(); i != sCull->endVisibleBridge(); ++i)
{
LLSpatialBridge* bridge = *i;
if (!bridge->isDead() && hasRenderType(bridge->mDrawableType))
{
glPushMatrix();
glMultMatrixf((F32*)bridge->mDrawable->getRenderMatrix().mMatrix);
bridge->renderDebug();
glPopMatrix();
}
}
if (hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA))
{
LLGLEnable blend(GL_BLEND);
LLGLDepthTest depth(TRUE, FALSE);
LLGLDisable cull(GL_CULL_FACE);
gGL.color4f(1,1,1,1);
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
F32 a = 0.1f;
F32 col[] =
{
1,0,0,a,
0,1,0,a,
0,0,1,a,
1,0,1,a,
1,1,0,a,
0,1,1,a,
1,1,1,a,
1,0,1,a,
};
for (U32 i = 0; i < 8; i++)
{
if (i > 3)
{
gGL.color4fv(col+(i-4)*4);
LLVector3* frust = mShadowCamera[i].mAgentFrustum;
gGL.begin(LLRender::TRIANGLE_STRIP);
gGL.vertex3fv(frust[0].mV); gGL.vertex3fv(frust[4].mV);
gGL.vertex3fv(frust[1].mV); gGL.vertex3fv(frust[5].mV);
gGL.vertex3fv(frust[2].mV); gGL.vertex3fv(frust[6].mV);
gGL.vertex3fv(frust[3].mV); gGL.vertex3fv(frust[7].mV);
gGL.vertex3fv(frust[0].mV); gGL.vertex3fv(frust[4].mV);
gGL.end();
gGL.begin(LLRender::TRIANGLE_STRIP);
gGL.vertex3fv(frust[0].mV);
gGL.vertex3fv(frust[1].mV);
gGL.vertex3fv(frust[3].mV);
gGL.vertex3fv(frust[2].mV);
gGL.end();
gGL.begin(LLRender::TRIANGLE_STRIP);
gGL.vertex3fv(frust[4].mV);
gGL.vertex3fv(frust[5].mV);
gGL.vertex3fv(frust[7].mV);
gGL.vertex3fv(frust[6].mV);
gGL.end();
}
if (i < 4)
{
gGL.begin(LLRender::LINES);
F32* c = col+i*4;
for (U32 j = 0; j < mShadowFrustPoints[i].size(); ++j)
{
gGL.color3fv(c);
for (U32 k = 0; k < mShadowFrustPoints[i].size(); ++k)
{
if (j != k)
{
gGL.vertex3fv(mShadowFrustPoints[i][j].mV);
gGL.vertex3fv(mShadowFrustPoints[i][k].mV);
}
}
if (!mShadowFrustOrigin[i].isExactlyZero())
{
gGL.vertex3fv(mShadowFrustPoints[i][j].mV);
gGL.color4f(1,1,1,1);
gGL.vertex3fv(mShadowFrustOrigin[i].mV);
}
}
gGL.end();
}
/*for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 j = 0; j < LLViewerRegion::NUM_PARTITIONS; j++)
{
LLSpatialPartition* part = region->getSpatialPartition(j);
if (part)
{
if (hasRenderType(part->mDrawableType))
{
part->renderIntersectingBBoxes(&mShadowCamera[i]);
}
}
}
}*/
}
}
if (mRenderDebugMask & RENDER_DEBUG_COMPOSITION)
{
// Debug composition layers
F32 x, y;
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
if (gAgent.getRegion())
{
gGL.begin(LLRender::POINTS);
// Draw the composition layer for the region that I'm in.
for (x = 0; x <= 260; x++)
{
for (y = 0; y <= 260; y++)
{
if ((x > 255) || (y > 255))
{
gGL.color4f(1.f, 0.f, 0.f, 1.f);
}
else
{
gGL.color4f(0.f, 0.f, 1.f, 1.f);
}
F32 z = gAgent.getRegion()->getCompositionXY((S32)x, (S32)y);
z *= 5.f;
z += 50.f;
gGL.vertex3f(x, y, z);
}
}
gGL.end();
}
}
if (mRenderDebugMask & LLPipeline::RENDER_DEBUG_BUILD_QUEUE)
{
U32 count = 0;
U32 size = mBuildQ2.size();
LLColor4 col;
LLGLEnable blend(GL_BLEND);
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.getTexUnit(0)->bind(LLViewerFetchedTexture::sWhiteImagep);
for (LLSpatialGroup::sg_vector_t::iterator iter = mGroupQ2.begin(); iter != mGroupQ2.end(); ++iter)
{
LLSpatialGroup* group = *iter;
if (group->isDead())
{
continue;
}
LLSpatialBridge* bridge = group->mSpatialPartition->asBridge();
if (bridge && (!bridge->mDrawable || bridge->mDrawable->isDead()))
{
continue;
}
if (bridge)
{
gGL.pushMatrix();
glMultMatrixf((F32*)bridge->mDrawable->getRenderMatrix().mMatrix);
}
F32 alpha = (F32) (size-count)/size;
LLVector2 c(1.f-alpha, alpha);
c.normVec();
++count;
col.set(c.mV[0], c.mV[1], 0, alpha*0.5f+0.1f);
group->drawObjectBox(col);
if (bridge)
{
gGL.popMatrix();
}
}
}
gGL.flush();
}
void LLPipeline::renderForSelect(std::set<LLViewerObject*>& objects, BOOL render_transparent, const LLRect& screen_rect)
{
assertInitialized();
gGL.setColorMask(true, false);
gPipeline.resetDrawOrders();
LLViewerCamera* camera = LLViewerCamera::getInstance();
for (std::set<LLViewerObject*>::iterator iter = objects.begin(); iter != objects.end(); ++iter)
{
stateSort((*iter)->mDrawable, *camera);
}
LLMemType mt(LLMemType::MTYPE_PIPELINE_RENDER_SELECT);
glMatrixMode(GL_MODELVIEW);
LLGLSDefault gls_default;
LLGLSObjectSelect gls_object_select;
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
LLGLDepthTest gls_depth(GL_TRUE,GL_TRUE);
disableLights();
LLVertexBuffer::unbind();
//for each drawpool
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
U32 last_type = 0;
// If we don't do this, we crash something on changing graphics settings
// from Medium -> Low, because we unload all the shaders and the
// draw pools aren't aware. I don't know if this has to be a separate
// loop before actual rendering. JC
for (pool_set_t::iterator iter = mPools.begin(); iter != mPools.end(); ++iter)
{
LLDrawPool *poolp = *iter;
if (poolp->isFacePool() && hasRenderType(poolp->getType()))
{
poolp->prerender();
}
}
for (pool_set_t::iterator iter = mPools.begin(); iter != mPools.end(); ++iter)
{
LLDrawPool *poolp = *iter;
if (poolp->isFacePool() && hasRenderType(poolp->getType()))
{
LLFacePool* face_pool = (LLFacePool*) poolp;
face_pool->renderForSelect();
LLVertexBuffer::unbind();
gGLLastMatrix = NULL;
glLoadMatrixd(gGLModelView);
if (poolp->getType() != last_type)
{
last_type = poolp->getType();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
}
}
}
LLGLEnable alpha_test(GL_ALPHA_TEST);
if (render_transparent)
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER_EQUAL, 0.f);
}
else
{
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.2f);
}
gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_VERT_COLOR);
gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_ALPHA, LLTexUnit::TBS_VERT_ALPHA);
U32 prim_mask = LLVertexBuffer::MAP_VERTEX |
LLVertexBuffer::MAP_TEXCOORD0;
for (std::set<LLViewerObject*>::iterator i = objects.begin(); i != objects.end(); ++i)
{
LLViewerObject* vobj = *i;
LLDrawable* drawable = vobj->mDrawable;
if (vobj->isDead() ||
vobj->isHUDAttachment() ||
(LLSelectMgr::getInstance()->mHideSelectedObjects && vobj->isSelected()) ||
drawable->isDead() ||
!hasRenderType(drawable->getRenderType()))
{
continue;
}
for (S32 j = 0; j < drawable->getNumFaces(); ++j)
{
LLFace* facep = drawable->getFace(j);
if (!facep->getPool())
{
facep->renderForSelect(prim_mask);
}
}
}
// pick HUD objects
LLVOAvatar* avatarp = gAgent.getAvatarObject();
if (avatarp && sShowHUDAttachments)
{
glh::matrix4f save_proj(glh_get_current_projection());
glh::matrix4f save_model(glh_get_current_modelview());
setup_hud_matrices(screen_rect);
for (LLVOAvatar::attachment_map_t::iterator iter = avatarp->mAttachmentPoints.begin();
iter != avatarp->mAttachmentPoints.end(); )
{
LLVOAvatar::attachment_map_t::iterator curiter = iter++;
LLViewerJointAttachment* attachment = curiter->second;
if (attachment->getIsHUDAttachment())
{
for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
attachment_iter != attachment->mAttachedObjects.end();
++attachment_iter)
{
if (LLViewerObject* attached_object = (*attachment_iter))
{
LLDrawable* drawable = attached_object->mDrawable;
if (drawable->isDead())
{
continue;
}
for (S32 j = 0; j < drawable->getNumFaces(); ++j)
{
LLFace* facep = drawable->getFace(j);
if (!facep->getPool())
{
facep->renderForSelect(prim_mask);
}
}
//render child faces
LLViewerObject::const_child_list_t& child_list = attached_object->getChildren();
for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
iter != child_list.end(); iter++)
{
LLViewerObject* child = *iter;
LLDrawable* child_drawable = child->mDrawable;
for (S32 l = 0; l < child_drawable->getNumFaces(); ++l)
{
LLFace* facep = child_drawable->getFace(l);
if (!facep->getPool())
{
facep->renderForSelect(prim_mask);
}
}
}
}
}
}
}
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(save_proj.m);
glh_set_current_projection(save_proj);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(save_model.m);
glh_set_current_modelview(save_model);
}
gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
LLVertexBuffer::unbind();
gGL.setColorMask(true, true);
}
void LLPipeline::rebuildPools()
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_REBUILD_POOLS);
assertInitialized();
S32 max_count = mPools.size();
pool_set_t::iterator iter1 = mPools.upper_bound(mLastRebuildPool);
while(max_count > 0 && mPools.size() > 0) // && num_rebuilds < MAX_REBUILDS)
{
if (iter1 == mPools.end())
{
iter1 = mPools.begin();
}
LLDrawPool* poolp = *iter1;
if (poolp->isDead())
{
mPools.erase(iter1++);
removeFromQuickLookup( poolp );
if (poolp == mLastRebuildPool)
{
mLastRebuildPool = NULL;
}
delete poolp;
}
else
{
mLastRebuildPool = poolp;
iter1++;
}
max_count--;
}
if (gAgent.getAvatarObject())
{
gAgent.getAvatarObject()->rebuildHUD();
}
}
void LLPipeline::addToQuickLookup( LLDrawPool* new_poolp )
{
LLMemType mt(LLMemType::MTYPE_PIPELINE_QUICK_LOOKUP);
assertInitialized();
switch( new_poolp->getType() )
{
case LLDrawPool::POOL_SIMPLE:
if (mSimplePool)
{
llassert(0);
llwarns << "Ignoring duplicate simple pool." << llendl;
}
else
{
mSimplePool = (LLRenderPass*) new_poolp;
}
break;
case LLDrawPool::POOL_GRASS:
if (mGrassPool)
{
llassert(0);
llwarns << "Ignoring duplicate grass pool." << llendl;
}
else
{
mGrassPool = (LLRenderPass*) new_poolp;
}
break;
case LLDrawPool::POOL_FULLBRIGHT:
if (mFullbrightPool)
{
llassert(0);
llwarns << "Ignoring duplicate simple pool." << llendl;
}
else
{
mFullbrightPool = (LLRenderPass*) new_poolp;
}
break;
case LLDrawPool::POOL_INVISIBLE:
if (mInvisiblePool)
{
llassert(0);
llwarns << "Ignoring duplicate simple pool." << llendl;
}
else
{
mInvisiblePool = (LLRenderPass*) new_poolp;
}
break;
case LLDrawPool::POOL_GLOW:
if (mGlowPool)
{
llassert(0);
llwarns << "Ignoring duplicate glow pool." << llendl;
}
else
{
mGlowPool = (LLRenderPass*) new_poolp;
}
break;
case LLDrawPool::POOL_TREE:
mTreePools[ uintptr_t(new_poolp->getTexture()) ] = new_poolp ;
break;
case LLDrawPool::POOL_TERRAIN:
mTerrainPools[ uintptr_t(new_poolp->getTexture()) ] = new_poolp ;
break;
case LLDrawPool::POOL_BUMP:
if (mBumpPool)
{
llassert(0);
llwarns << "Ignoring duplicate bump pool." << llendl;
}
else
{
mBumpPool = new_poolp;
}
break;
case LLDrawPool::POOL_ALPHA:
if( mAlphaPool )
{
llassert(0);
llwarns << "LLPipeline::addPool(): Ignoring duplicate Alpha pool" << llendl;
}
else
{
mAlphaPool = new_poolp;
}
break;
case LLDrawPool::POOL_AVATAR:
break; // Do nothing
case LLDrawPool::POOL_SKY:
if( mSkyPool )
{
llassert(0);
llwarns << "LLPipeline::addPool(): Ignoring duplicate Sky pool" << llendl;
}
else
{
mSkyPool = new_poolp;
}
break;
case LLDrawPool::POOL_WATER:
if( mWaterPool )
{
llassert(0);
llwarns << "LLPipeline::addPool(): Ignoring duplicate Water pool" << llendl;
}
else
{
mWaterPool = new_poolp;
}
break;
case LLDrawPool::POOL_GROUND:
if( mGroundPool )
{
llassert(0);
llwarns << "LLPipeline::addPool(): Ignoring duplicate Ground Pool" << llendl;
}
else
{
mGroundPool = new_poolp;
}
break;
case LLDrawPool::POOL_WL_SKY:
if( mWLSkyPool )
{
llassert(0);
llwarns << "LLPipeline::addPool(): Ignoring duplicate WLSky Pool" << llendl;
}
else
{
mWLSkyPool = new_poolp;
}
break;
default:
llassert(0);
llwarns << "Invalid Pool Type in LLPipeline::addPool()" << llendl;
break;
}
}
void LLPipeline::removePool( LLDrawPool* poolp )
{
assertInitialized();
removeFromQuickLookup(poolp);
mPools.erase(poolp);
delete poolp;
}
void LLPipeline::removeFromQuickLookup( LLDrawPool* poolp )
{
assertInitialized();
LLMemType mt(LLMemType::MTYPE_PIPELINE);
switch( poolp->getType() )
{
case LLDrawPool::POOL_SIMPLE:
llassert(mSimplePool == poolp);
mSimplePool = NULL;
break;
case LLDrawPool::POOL_GRASS:
llassert(mGrassPool == poolp);
mGrassPool = NULL;
break;
case LLDrawPool::POOL_FULLBRIGHT:
llassert(mFullbrightPool == poolp);
mFullbrightPool = NULL;
break;
case LLDrawPool::POOL_INVISIBLE:
llassert(mInvisiblePool == poolp);
mInvisiblePool = NULL;
break;
case LLDrawPool::POOL_WL_SKY:
llassert(mWLSkyPool == poolp);
mWLSkyPool = NULL;
break;
case LLDrawPool::POOL_GLOW:
llassert(mGlowPool == poolp);
mGlowPool = NULL;
break;
case LLDrawPool::POOL_TREE:
#ifdef _DEBUG
{
BOOL found = mTreePools.erase( (uintptr_t)poolp->getTexture() );
llassert( found );
}
#else
mTreePools.erase( (uintptr_t)poolp->getTexture() );
#endif
break;
case LLDrawPool::POOL_TERRAIN:
#ifdef _DEBUG
{
BOOL found = mTerrainPools.erase( (uintptr_t)poolp->getTexture() );
llassert( found );
}
#else
mTerrainPools.erase( (uintptr_t)poolp->getTexture() );
#endif
break;
case LLDrawPool::POOL_BUMP:
llassert( poolp == mBumpPool );
mBumpPool = NULL;
break;
case LLDrawPool::POOL_ALPHA:
llassert( poolp == mAlphaPool );
mAlphaPool = NULL;
break;
case LLDrawPool::POOL_AVATAR:
break; // Do nothing
case LLDrawPool::POOL_SKY:
llassert( poolp == mSkyPool );
mSkyPool = NULL;
break;
case LLDrawPool::POOL_WATER:
llassert( poolp == mWaterPool );
mWaterPool = NULL;
break;
case LLDrawPool::POOL_GROUND:
llassert( poolp == mGroundPool );
mGroundPool = NULL;
break;
default:
llassert(0);
llwarns << "Invalid Pool Type in LLPipeline::removeFromQuickLookup() type=" << poolp->getType() << llendl;
break;
}
}
void LLPipeline::resetDrawOrders()
{
assertInitialized();
// Iterate through all of the draw pools and rebuild them.
for (pool_set_t::iterator iter = mPools.begin(); iter != mPools.end(); ++iter)
{
LLDrawPool *poolp = *iter;
poolp->resetDrawOrders();
}
}
//============================================================================
// Once-per-frame setup of hardware lights,
// including sun/moon, avatar backlight, and up to 6 local lights
void LLPipeline::setupAvatarLights(BOOL for_edit)
{
assertInitialized();
if (for_edit)
{
LLColor4 diffuse(1.f, 1.f, 1.f, 0.f);
LLVector4 light_pos_cam(-8.f, 0.25f, 10.f, 0.f); // w==0 => directional light
LLMatrix4 camera_mat = LLViewerCamera::getInstance()->getModelview();
LLMatrix4 camera_rot(camera_mat.getMat3());
camera_rot.invert();
LLVector4 light_pos = light_pos_cam * camera_rot;
light_pos.normalize();
mHWLightColors[1] = diffuse;
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse.mV);
glLightfv(GL_LIGHT1, GL_AMBIENT, LLColor4::black.mV);
glLightfv(GL_LIGHT1, GL_SPECULAR, LLColor4::black.mV);
glLightfv(GL_LIGHT1, GL_POSITION, light_pos.mV);
glLightf (GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.0f);
glLightf (GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0f);
glLightf (GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0f);
glLightf (GL_LIGHT1, GL_SPOT_EXPONENT, 0.0f);
glLightf (GL_LIGHT1, GL_SPOT_CUTOFF, 180.0f);
}
else if (gAvatarBacklight) // Always true (unless overridden in a devs .ini)
{
LLVector3 opposite_pos = -1.f * mSunDir;
LLVector3 orthog_light_pos = mSunDir % LLVector3::z_axis;
LLVector4 backlight_pos = LLVector4(lerp(opposite_pos, orthog_light_pos, 0.3f), 0.0f);
backlight_pos.normalize();
LLColor4 light_diffuse = mSunDiffuse;
LLColor4 backlight_diffuse(1.f - light_diffuse.mV[VRED], 1.f - light_diffuse.mV[VGREEN], 1.f - light_diffuse.mV[VBLUE], 1.f);
F32 max_component = 0.001f;
for (S32 i = 0; i < 3; i++)
{
if (backlight_diffuse.mV[i] > max_component)
{
max_component = backlight_diffuse.mV[i];
}
}
F32 backlight_mag;
if (gSky.getSunDirection().mV[2] >= LLSky::NIGHTTIME_ELEVATION_COS)
{
backlight_mag = BACKLIGHT_DAY_MAGNITUDE_OBJECT;
}
else
{
backlight_mag = BACKLIGHT_NIGHT_MAGNITUDE_OBJECT;
}
backlight_diffuse *= backlight_mag / max_component;
mHWLightColors[1] = backlight_diffuse;
glLightfv(GL_LIGHT1, GL_POSITION, backlight_pos.mV); // this is just sun/moon direction
glLightfv(GL_LIGHT1, GL_DIFFUSE, backlight_diffuse.mV);
glLightfv(GL_LIGHT1, GL_AMBIENT, LLColor4::black.mV);
glLightfv(GL_LIGHT1, GL_SPECULAR, LLColor4::black.mV);
glLightf (GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.0f);
glLightf (GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0f);
glLightf (GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0f);
glLightf (GL_LIGHT1, GL_SPOT_EXPONENT, 0.0f);
glLightf (GL_LIGHT1, GL_SPOT_CUTOFF, 180.0f);
}
else
{
mHWLightColors[1] = LLColor4::black;
glLightfv(GL_LIGHT1, GL_DIFFUSE, LLColor4::black.mV);
glLightfv(GL_LIGHT1, GL_AMBIENT, LLColor4::black.mV);
glLightfv(GL_LIGHT1, GL_SPECULAR, LLColor4::black.mV);
}
}
static F32 calc_light_dist(LLVOVolume* light, const LLVector3& cam_pos, F32 max_dist)
{
F32 inten = light->getLightIntensity();
if (inten < .001f)
{
return max_dist;
}
F32 radius = light->getLightRadius();
BOOL selected = light->isSelected();
LLVector3 dpos = light->getRenderPosition() - cam_pos;
F32 dist2 = dpos.lengthSquared();
if (!selected && dist2 > (max_dist + radius)*(max_dist + radius))
{
return max_dist;
}
F32 dist = fsqrtf(dist2);
dist *= 1.f / inten;
dist -= radius;
if (selected)
{
dist -= 10000.f; // selected lights get highest priority
}
if (light->mDrawable.notNull() && light->mDrawable->isState(LLDrawable::ACTIVE))
{
// moving lights get a little higher priority (too much causes artifacts)
dist -= light->getLightRadius()*0.25f;
}
return dist;
}
void LLPipeline::calcNearbyLights(LLCamera& camera)
{
assertInitialized();
if (LLPipeline::sReflectionRender)
{
return;
}
if (mLightingDetail >= 1)
{
// mNearbyLight (and all light_set_t's) are sorted such that
// begin() == the closest light and rbegin() == the farthest light
const S32 MAX_LOCAL_LIGHTS = 6;
// LLVector3 cam_pos = gAgent.getCameraPositionAgent();
LLVector3 cam_pos = LLViewerJoystick::getInstance()->getOverrideCamera() ?
camera.getOrigin() :
gAgent.getPositionAgent();
F32 max_dist = LIGHT_MAX_RADIUS * 4.f; // ignore enitrely lights > 4 * max light rad
// UPDATE THE EXISTING NEARBY LIGHTS
light_set_t cur_nearby_lights;
for (light_set_t::iterator iter = mNearbyLights.begin();
iter != mNearbyLights.end(); iter++)
{
const Light* light = &(*iter);
LLDrawable* drawable = light->drawable;
LLVOVolume* volight = drawable->getVOVolume();
if (!volight || !drawable->isState(LLDrawable::LIGHT))
{
drawable->clearState(LLDrawable::NEARBY_LIGHT);
continue;
}
if (light->fade <= -LIGHT_FADE_TIME)
{
drawable->clearState(LLDrawable::NEARBY_LIGHT);
continue;
}
if (!sRenderAttachedLights && volight && volight->isAttachment())
{
drawable->clearState(LLDrawable::NEARBY_LIGHT);
continue;
}
F32 dist = calc_light_dist(volight, cam_pos, max_dist);
cur_nearby_lights.insert(Light(drawable, dist, light->fade));
}
mNearbyLights = cur_nearby_lights;
// FIND NEW LIGHTS THAT ARE IN RANGE
light_set_t new_nearby_lights;
for (LLDrawable::drawable_set_t::iterator iter = mLights.begin();
iter != mLights.end(); ++iter)
{
LLDrawable* drawable = *iter;
LLVOVolume* light = drawable->getVOVolume();
if (!light || drawable->isState(LLDrawable::NEARBY_LIGHT))
{
continue;
}
if (light->isHUDAttachment())
{
continue; // no lighting from HUD objects
}
F32 dist = calc_light_dist(light, cam_pos, max_dist);
if (dist >= max_dist)
{
continue;
}
if (!sRenderAttachedLights && light && light->isAttachment())
{
continue;
}
new_nearby_lights.insert(Light(drawable, dist, 0.f));
if (new_nearby_lights.size() > (U32)MAX_LOCAL_LIGHTS)
{
new_nearby_lights.erase(--new_nearby_lights.end());
const Light& last = *new_nearby_lights.rbegin();
max_dist = last.dist;
}
}
// INSERT ANY NEW LIGHTS
for (light_set_t::iterator iter = new_nearby_lights.begin();
iter != new_nearby_lights.end(); iter++)
{
const Light* light = &(*iter);