From 4046a9082d793e71cac26a31d44c127decd6821f Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Fri, 11 Feb 2011 17:37:07 -0500
Subject: re-applying render cost changes for experimentations

---
 indra/newview/llvovolume.cpp | 237 +++++++++++++++++++++++++++++++++----------
 1 file changed, 182 insertions(+), 55 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index be987a2310..01027e6a11 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -2931,24 +2931,35 @@ const LLMatrix4 LLVOVolume::getRenderMatrix() const
 // total cost is returned value + 5 * size of the resulting set.
 // Cannot include cost of textures, as they may be re-used in linked
 // children, and cost should only be increased for unique textures  -Nyx
-U32 LLVOVolume::getRenderCost(std::set<LLUUID> &textures) const
+U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 {
-	// base cost of each prim should be 10 points
-	static const U32 ARC_PRIM_COST = 10;
+	// Get access to params we'll need at various points.  
+	// Skip if this is object doesn't have a volume (e.g. is an avatar).
+	BOOL has_volume = (getVolume() != NULL);
+	LLVolumeParams volume_params;
+	LLPathParams path_params;
+	LLProfileParams profile_params;
+
+	U32 num_triangles = 0;
+
 	// per-prim costs
-	static const U32 ARC_INVISI_COST = 1;
-	static const U32 ARC_SHINY_COST = 1;
-	static const U32 ARC_GLOW_COST = 1;
-	static const U32 ARC_FLEXI_COST = 8;
-	static const U32 ARC_PARTICLE_COST = 16;
-	static const U32 ARC_BUMP_COST = 4;
+	static const U32 ARC_PARTICLE_COST = 1;
+	static const U32 ARC_PARTICLE_MAX = 2048;
+	static const U32 ARC_TEXTURE_COST = 5;
 
-	// per-face costs
-	static const U32 ARC_PLANAR_COST = 1;
-	static const U32 ARC_ANIM_TEX_COST = 4;
-	static const U32 ARC_ALPHA_COST = 4;
+	// per-prim multipliers
+	static const F32 ARC_GLOW_MULT = 1.5f; // tested based on performance
+	static const F32 ARC_BUMP_MULT = 1.25f; // tested based on performance
+	static const F32 ARC_FLEXI_MULT = 4;
+	static const F32 ARC_SHINY_MULT = 1.6f; // tested based on performance
+	static const F32 ARC_INVISI_COST = 1.2f; // tested based on performance
+	static const F32 ARC_WEIGHTED_MESH = 1.2f; 
 
-	U32 shame = ARC_PRIM_COST;
+	static const F32 ARC_PLANAR_COST = 1.2f; // 1.2x max
+	static const F32 ARC_ANIM_TEX_COST = 1.4f; // 1.4x max
+	static const F32 ARC_ALPHA_COST = 4.f; // 4x max
+
+	F32 shame = 0;
 
 	U32 invisi = 0;
 	U32 shiny = 0;
@@ -2957,9 +2968,87 @@ U32 LLVOVolume::getRenderCost(std::set<LLUUID> &textures) const
 	U32 flexi = 0;
 	U32 animtex = 0;
 	U32 particles = 0;
-	U32 scale = 0;
 	U32 bump = 0;
 	U32 planar = 0;
+	U32 weighted_mesh = 0;
+
+	// these multipliers are variable and can be floating point
+	F32 scale = 0.f;
+
+	const LLDrawable* drawablep = mDrawable;
+	U32 num_faces = drawablep->getNumFaces();
+
+	if (has_volume)
+	{
+		volume_params = getVolume()->getParams();
+		path_params = volume_params.getPathParams();
+		profile_params = volume_params.getProfileParams();
+
+		F32 radius = getVolume()->mLODScaleBias.scaledVec(getScale()).length();
+		S32 default_detail = llclamp((S32) (sqrtf(radius)*LLVOVolume::sLODFactor*4.f), 0, 3);
+		if (default_detail == getLOD())
+		{
+			num_triangles = getTriangleCount();
+		}
+		else
+		{
+			LLVolume* default_volume = LLPrimitive::getVolumeManager()->refVolume(volume_params, default_detail);
+			if(default_volume != NULL)
+			{
+				num_triangles = default_volume->getNumTriangles();
+				LLPrimitive::getVolumeManager()->unrefVolume(default_volume);
+				default_volume = NULL;
+			}
+			else
+			{
+				has_volume = false;
+			}
+		}
+	}
+
+	if (isSculpted())
+	{
+		if (isMesh())
+		{
+			// base cost is dependent on mesh complexity
+			// note that 3 is the highest LOD as of the time of this coding.
+			S32 size = gMeshRepo.getMeshSize(volume_params.getSculptID(),3);
+			if ( size > 0)
+			{
+				num_triangles = (U32)(size / 10.f); // avg 1 triangle per 10 bytes
+				if (gMeshRepo.getSkinInfo(volume_params.getSculptID()))
+				{
+					// weighted attachment - 1 point for every 3 bytes
+					weighted_mesh = 1;
+				}
+
+				if (num_triangles == 0)
+				{
+					// someone made a really tiny mesh. Approximate with a tetrahedron.
+					num_triangles = 4;
+				}
+			}
+			else
+			{
+				// something went wrong - user should know their content isn't render-free
+				return 0;
+			}
+		}
+		else
+		{
+			const LLSculptParams *sculpt_params = (LLSculptParams *) getParameterEntry(LLNetworkData::PARAMS_SCULPT);
+			LLUUID sculpt_id = sculpt_params->getSculptTexture();
+			if (textures.find(sculpt_id) == textures.end())
+			{
+				LLViewerFetchedTexture *texture = LLViewerTextureManager::getFetchedTexture(sculpt_id);
+				if (texture)
+				{
+					S32 texture_cost = (S32)(ARC_TEXTURE_COST * (texture->getFullHeight() / 128.f + texture->getFullWidth() / 128.f + 1));
+					textures.insert(texture_cost_t::value_type(sculpt_id, texture_cost));
+				}
+			}
+		}
+	}
 
 	if (isFlexible())
 	{
@@ -2971,18 +3060,12 @@ U32 LLVOVolume::getRenderCost(std::set<LLUUID> &textures) const
 	}
 
 	const LLVector3& sc = getScale();
-	scale += (U32) sc.mV[0] + (U32) sc.mV[1] + (U32) sc.mV[2];
-
-	const LLDrawable* drawablep = mDrawable;
+	scale += (sc.mV[0] + sc.mV[1] + sc.mV[2]) / 4.f; // scale to 1/4 the sum of the size
+	// enforce scale multiplier to be in the range [1,7] (7 was determined to experimentally be a reasonable max)
+	scale = scale > 7.f ? 7.f : scale;
+	scale = scale < 1.f ? 1.f : scale;
 
-	if (isSculpted())
-	{
-		const LLSculptParams *sculpt_params = (LLSculptParams *) getParameterEntry(LLNetworkData::PARAMS_SCULPT);
-		LLUUID sculpt_id = sculpt_params->getSculptTexture();
-		textures.insert(sculpt_id);
-	}
-
-	for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
+	for (S32 i = 0; i < num_faces; ++i)
 	{
 		const LLFace* face = drawablep->getFace(i);
 		const LLTextureEntry* te = face->getTextureEntry();
@@ -2990,12 +3073,16 @@ U32 LLVOVolume::getRenderCost(std::set<LLUUID> &textures) const
 
 		if (img)
 		{
-			textures.insert(img->getID());
+			if (textures.find(img->getID()) == textures.end())
+			{
+				S32 texture_cost = (S32)(ARC_TEXTURE_COST * (img->getFullHeight() / 128.f + img->getFullWidth() / 128.f + 1));
+				textures.insert(texture_cost_t::value_type(img->getID(), texture_cost));
+			}
 		}
 
 		if (face->getPoolType() == LLDrawPool::POOL_ALPHA)
 		{
-			alpha++;
+			alpha = 1;
 		}
 		else if (img && img->getPrimaryFormat() == GL_ALPHA)
 		{
@@ -3006,58 +3093,98 @@ U32 LLVOVolume::getRenderCost(std::set<LLUUID> &textures) const
 		{
 			if (te->getBumpmap())
 			{
+				// bump is a multiplier, don't add per-face
 				bump = 1;
 			}
 			if (te->getShiny())
 			{
+				// shiny is a multiplier, don't add per-face
 				shiny = 1;
 			}
 			if (te->getGlow() > 0.f)
 			{
+				// glow is a multiplier, don't add per-face
 				glow = 1;
 			}
 			if (face->mTextureMatrix != NULL)
 			{
-				animtex++;
+				animtex = 1;
 			}
 			if (te->getTexGen())
 			{
-				planar++;
+				planar = 1;
 			}
 		}
 	}
 
+	// shame currently has the "base" cost of 1 point per 50 triangles, min 2.
+	shame = num_triangles / 50.f;
+	shame = shame < 2.f ? 2.f : shame;
 
-	shame += invisi * ARC_INVISI_COST;
-	shame += shiny * ARC_SHINY_COST;
-	shame += glow * ARC_GLOW_COST;
-	shame += alpha * ARC_ALPHA_COST;
-	shame += flexi * ARC_FLEXI_COST;
-	shame += animtex * ARC_ANIM_TEX_COST;
-	shame += particles * ARC_PARTICLE_COST;
-	shame += bump * ARC_BUMP_COST;
-	shame += planar * ARC_PLANAR_COST;
-	shame += scale;
+	// factor in scale
+	shame *= scale;
 
-	LLViewerObject::const_child_list_t& child_list = getChildren();
-	for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
-		 iter != child_list.end(); 
-		 ++iter)
+	// multiply by per-face modifiers
+	if (planar)
 	{
-		const LLViewerObject* child_objectp = *iter;
-		const LLDrawable* child_drawablep = child_objectp->mDrawable;
-		if (child_drawablep)
-		{
-			const LLVOVolume* child_volumep = child_drawablep->getVOVolume();
-			if (child_volumep)
-			{
-				shame += child_volumep->getRenderCost(textures);
-			}
-		}
+		shame *= planar * ARC_PLANAR_COST;
+	}
+
+	if (animtex)
+	{
+		shame *= animtex * ARC_ANIM_TEX_COST;
+	}
+
+	if (alpha)
+	{
+		shame *= alpha * ARC_ALPHA_COST;
+	}
+
+	if(invisi)
+	{
+		shame *= invisi * ARC_INVISI_COST;
+	}
+
+	if (glow)
+	{
+		shame *= glow * ARC_GLOW_MULT;
+	}
+
+	if (bump)
+	{
+		shame *= bump * ARC_BUMP_MULT;
+	}
+
+	if (shiny)
+	{
+		shame *= shiny * ARC_SHINY_MULT;
 	}
 
-	return shame;
 
+	// multiply shame by multipliers
+	if (weighted_mesh)
+	{
+		shame *= weighted_mesh * ARC_WEIGHTED_MESH;
+	}
+
+	if (flexi)
+	{
+		shame *= flexi * ARC_FLEXI_MULT;
+	}
+
+
+	// add additional costs
+	if (particles)
+	{
+		const LLPartSysData *part_sys_data = &(mPartSourcep->mPartSysData);
+		const LLPartData *part_data = &(part_sys_data->mPartData);
+		U32 num_particles = (U32)(part_sys_data->mBurstPartCount * llceil( part_data->mMaxAge / part_sys_data->mBurstRate));
+		num_particles = num_particles > ARC_PARTICLE_MAX ? ARC_PARTICLE_MAX : num_particles;
+		F32 part_size = (llmax(part_data->mStartScale[0], part_data->mEndScale[0]) + llmax(part_data->mStartScale[1], part_data->mEndScale[1])) / 2.f;
+		shame += num_particles * part_size * ARC_PARTICLE_COST;
+	}
+
+	return (U32)shame;
 }
 
 F32 LLVOVolume::getStreamingCost()
-- 
cgit v1.3


From c10494e370f6399deea835964760628b14f7e299 Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Wed, 16 Feb 2011 15:32:48 -0500
Subject: SH-997 FIX verify texture performance stats

Got some better, reproducible numbers, which puts 32x32 textures at 538 points and
1024x1024 textures at 1024 points.
---
 indra/newview/llfloatertools.cpp | 3 ++-
 indra/newview/llvovolume.cpp     | 6 +++---
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llfloatertools.cpp b/indra/newview/llfloatertools.cpp
index ceaf3c1449..1410facb53 100644
--- a/indra/newview/llfloatertools.cpp
+++ b/indra/newview/llfloatertools.cpp
@@ -427,7 +427,8 @@ void LLFloaterTools::refresh()
 		if (sShowObjectCost)
 		{
 			std::string prim_cost_string;
-			LLResMgr::getInstance()->getIntegerString(prim_cost_string, calcRenderCost());
+			S32 cost = LLSelectMgr::getInstance()->getSelection()->getSelectedObjectRenderCost();
+			LLResMgr::getInstance()->getIntegerString(prim_cost_string, cost);
 			getChild<LLUICtrl>("RenderingCost")->setTextArg("[COUNT]", prim_cost_string);
 		}
 		
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 01027e6a11..7703019f99 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -2945,7 +2945,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	// per-prim costs
 	static const U32 ARC_PARTICLE_COST = 1;
 	static const U32 ARC_PARTICLE_MAX = 2048;
-	static const U32 ARC_TEXTURE_COST = 5;
+	static const U32 ARC_TEXTURE_COST = 32;
 
 	// per-prim multipliers
 	static const F32 ARC_GLOW_MULT = 1.5f; // tested based on performance
@@ -3043,7 +3043,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 				LLViewerFetchedTexture *texture = LLViewerTextureManager::getFetchedTexture(sculpt_id);
 				if (texture)
 				{
-					S32 texture_cost = (S32)(ARC_TEXTURE_COST * (texture->getFullHeight() / 128.f + texture->getFullWidth() / 128.f + 1));
+					S32 texture_cost = 512 + (S32)(ARC_TEXTURE_COST * (texture->getFullHeight() / 128.f + texture->getFullWidth() / 128.f));
 					textures.insert(texture_cost_t::value_type(sculpt_id, texture_cost));
 				}
 			}
@@ -3075,7 +3075,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		{
 			if (textures.find(img->getID()) == textures.end())
 			{
-				S32 texture_cost = (S32)(ARC_TEXTURE_COST * (img->getFullHeight() / 128.f + img->getFullWidth() / 128.f + 1));
+				S32 texture_cost = 512 + (S32)(ARC_TEXTURE_COST * (img->getFullHeight() / 128.f + img->getFullWidth() / 128.f));
 				textures.insert(texture_cost_t::value_type(img->getID(), texture_cost));
 			}
 		}
-- 
cgit v1.3


From 24c353a1ad00366b9f4ce57492059ce8caf84ba0 Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Tue, 22 Feb 2011 17:29:38 -0500
Subject: first pass at clouding avatars that are too complex

---
 indra/newview/llviewercontrol.cpp |  6 ++++++
 indra/newview/llvoavatar.cpp      | 16 ++++++++++++++++
 indra/newview/llvoavatar.h        |  2 ++
 indra/newview/llvovolume.cpp      | 10 +++++-----
 4 files changed, 29 insertions(+), 5 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index e319eba0ee..d99f3b6c88 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -165,6 +165,11 @@ static bool handleRenderPerfTestChanged(const LLSD& newvalue)
        return true;
 }
 
+bool handleRenderAvatarComplexityLimitChanged(const LLSD& newvalue)
+{
+	return true;
+}
+
 bool handleRenderTransparentWaterChanged(const LLSD& newvalue)
 {
 	LLWorld::getInstance()->updateWaterObjects();
@@ -586,6 +591,7 @@ void settings_setup_listeners()
 	gSavedSettings.getControl("WindLightUseAtmosShaders")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
 	gSavedSettings.getControl("RenderGammaFull")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
 	gSavedSettings.getControl("RenderAvatarMaxVisible")->getSignal()->connect(boost::bind(&handleAvatarMaxVisibleChanged, _2));
+	gSavedSettings.getControl("RenderAvatarComplexityLimit")->getSignal()->connect(boost::bind(&handleRenderAvatarComplexityLimitChanged, _2));
 	gSavedSettings.getControl("RenderVolumeLODFactor")->getSignal()->connect(boost::bind(&handleVolumeLODChanged, _2));
 	gSavedSettings.getControl("RenderAvatarLODFactor")->getSignal()->connect(boost::bind(&handleAvatarLODChanged, _2));
 	gSavedSettings.getControl("RenderTerrainLODFactor")->getSignal()->connect(boost::bind(&handleTerrainLODChanged, _2));
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 856c068a44..be65af1e71 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -6307,6 +6307,11 @@ BOOL LLVOAvatar::getIsCloud()
 	{
 		return TRUE;
 	}
+
+	if (isTooComplex())
+	{
+		return TRUE;
+	}
 	return FALSE;
 }
 
@@ -6401,6 +6406,16 @@ BOOL LLVOAvatar::isFullyLoaded() const
 		return mFullyLoaded;
 }
 
+bool LLVOAvatar::isTooComplex() const
+{
+	if (gSavedSettings.getS32("RenderAvatarComplexityLimit") > 0 && mVisualComplexity >= gSavedSettings.getS32("RenderAvatarComplexityLimit"))
+	{
+		return true;
+	}
+
+	return false;
+}
+
 
 //-----------------------------------------------------------------------------
 // findMotion()
@@ -8338,6 +8353,7 @@ void LLVOAvatar::idleUpdateRenderCost()
 	}
 
 	setDebugText(llformat("%d", cost));
+	mVisualComplexity = cost;
 	F32 green = 1.f-llclamp(((F32) cost-(F32)ARC_LIMIT)/(F32)ARC_LIMIT, 0.f, 1.f);
 	F32 red = llmin((F32) cost/(F32)ARC_LIMIT, 1.f);
 	mText->setColor(LLColor4(red,green,0,1));
diff --git a/indra/newview/llvoavatar.h b/indra/newview/llvoavatar.h
index 1152475383..f41c385894 100644
--- a/indra/newview/llvoavatar.h
+++ b/indra/newview/llvoavatar.h
@@ -263,6 +263,7 @@ public:
 	//--------------------------------------------------------------------
 public:
 	BOOL			isFullyLoaded() const;
+	bool			isTooComplex() const;
 	bool visualParamWeightsAreDefault();
 protected:
 	virtual BOOL	getIsCloud();
@@ -275,6 +276,7 @@ private:
 	BOOL			mPreviousFullyLoaded;
 	BOOL			mFullyLoadedInitialized;
 	S32				mFullyLoadedFrameCounter;
+	S32				mVisualComplexity;
 	LLFrameTimer	mFullyLoadedTimer;
 	LLFrameTimer	mRuthTimer;
 protected:
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index e3dea5c788..f5b31d25ac 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -2943,9 +2943,9 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	U32 num_triangles = 0;
 
 	// per-prim costs
-	static const U32 ARC_PARTICLE_COST = 1;
-	static const U32 ARC_PARTICLE_MAX = 2048;
-	static const U32 ARC_TEXTURE_COST = 32;
+	static const U32 ARC_PARTICLE_COST = 1; // determined experimentally
+	static const U32 ARC_PARTICLE_MAX = 2048; // default values
+	static const U32 ARC_TEXTURE_COST = 32; // multiplier for texture resolution - performance tested
 
 	// per-prim multipliers
 	static const F32 ARC_GLOW_MULT = 1.5f; // tested based on performance
@@ -2955,9 +2955,9 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	static const F32 ARC_INVISI_COST = 1.2f; // tested based on performance
 	static const F32 ARC_WEIGHTED_MESH = 1.2f; 
 
-	static const F32 ARC_PLANAR_COST = 1.2f; // 1.2x max
+	static const F32 ARC_PLANAR_COST = 1.0f; // tested based on performance to have negligible impact
 	static const F32 ARC_ANIM_TEX_COST = 1.4f; // 1.4x max
-	static const F32 ARC_ALPHA_COST = 4.f; // 4x max
+	static const F32 ARC_ALPHA_COST = 4.f; // 4x max - based on performance
 
 	F32 shame = 0;
 
-- 
cgit v1.3


From 29dc641fbe7ab77f77fe19e2e7976980f0649b5b Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Tue, 22 Mar 2011 20:39:31 -0400
Subject: initial effort to enable a debug display to show render complexity.
 Using for internal demo, will get it code reviewed if it merges in.

---
 indra/newview/llspatialpartition.cpp               | 38 ++++++++++++++++++++++
 indra/newview/llviewermenu.cpp                     |  4 +++
 indra/newview/llviewerobjectlist.cpp               |  4 +++
 indra/newview/llvovolume.cpp                       | 18 ++++++++--
 indra/newview/llvovolume.h                         | 10 +++++-
 indra/newview/pipeline.h                           |  1 +
 indra/newview/skins/default/xui/en/menu_viewer.xml | 10 ++++++
 .../skins/default/xui/en/panel_region_terrain.xml  | 34 +++++++++++++++++++
 8 files changed, 116 insertions(+), 3 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 5e7af6bbb3..b604908474 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2792,6 +2792,40 @@ void renderUpdateType(LLDrawable* drawablep)
 	}
 }
 
+void renderComplexityDisplay(LLDrawable* drawablep)
+{
+	LLViewerObject* vobj = drawablep->getVObj();
+	if (!vobj)
+	{
+		return;
+	}
+
+	LLVOVolume *voVol = dynamic_cast<LLVOVolume*>(vobj);
+
+	if (!voVol)
+	{
+		return;
+	}
+
+	LLVOVolume::texture_cost_t textures;
+	F32 cost = (F32) voVol->getRenderCost(textures) / (F32) LLVOVolume::getRenderComplexityMax();
+	
+	LLGLEnable blend(GL_BLEND);
+
+	F32 red = cost;
+	F32 green = 1.0f - cost;
+
+	glColor4f(red,green,0,0.5f);
+
+	S32 num_faces = drawablep->getNumFaces();
+	if (num_faces)
+	{
+		for (S32 i = 0; i < num_faces; ++i)
+		{
+			pushVerts(drawablep->getFace(i), LLVertexBuffer::MAP_VERTEX);
+		}
+	}	
+}
 
 void renderBoundingBox(LLDrawable* drawable, BOOL set_color = TRUE)
 {
@@ -3906,6 +3940,10 @@ public:
 			{
 				renderUpdateType(drawable);
 			}
+			if(gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_RENDER_COMPLEXITY))
+			{
+				renderComplexityDisplay(drawable);
+			}
 
 			LLVOAvatar* avatar = dynamic_cast<LLVOAvatar*>(drawable->getVObj().get());
 			
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index f5b0857425..30be2fb8e0 100755
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -993,6 +993,10 @@ U32 info_display_from_string(std::string info_display)
 	{
 		return LLPipeline::RENDER_DEBUG_AGENT_TARGET;
 	}
+	else if ("" == info_display)
+	{
+		return LLPipeline::RENDER_DEBUG_RENDER_COMPLEXITY;
+	}
 	else
 	{
 		return 0;
diff --git a/indra/newview/llviewerobjectlist.cpp b/indra/newview/llviewerobjectlist.cpp
index 0071753831..2e8eb9f4a8 100644
--- a/indra/newview/llviewerobjectlist.cpp
+++ b/indra/newview/llviewerobjectlist.cpp
@@ -58,6 +58,7 @@
 #include "llviewerregion.h"
 #include "llviewerstats.h"
 #include "llviewerstatsrecorder.h"
+#include "llvovolume.h"
 #include "llvoavatarself.h"
 #include "lltoolmgr.h"
 #include "lltoolpie.h"
@@ -997,6 +998,9 @@ void LLViewerObjectList::update(LLAgent &agent, LLWorld &world)
 	mNumSizeCulled = 0;
 	mNumVisCulled = 0;
 
+	// update max computed render cost
+	LLVOVolume::updateRenderComplexity();
+
 	// compute all sorts of time-based stats
 	// don't factor frames that were paused into the stats
 	if (! mWasPaused)
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index e2d1850e58..7c772ce835 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -87,6 +87,8 @@ F32 LLVOVolume::sLODFactor = 1.f;
 F32	LLVOVolume::sLODSlopDistanceFactor = 0.5f; //Changing this to zero, effectively disables the LOD transition slop 
 F32 LLVOVolume::sDistanceFactor = 1.0f;
 S32 LLVOVolume::sNumLODChanges = 0;
+S32 LLVOVolume::mRenderComplexity_last = 0;
+S32 LLVOVolume::mRenderComplexity_current = 0;
 LLPointer<LLObjectMediaDataClient> LLVOVolume::sObjectMediaClient = NULL;
 LLPointer<LLObjectMediaNavigateClient> LLVOVolume::sObjectMediaNavigateClient = NULL;
 
@@ -3206,6 +3208,11 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		shame += num_particles * part_size * ARC_PARTICLE_COST;
 	}
 
+	if (shame > mRenderComplexity_current)
+	{
+		mRenderComplexity_current = (S32)shame;
+	}
+
 	return (U32)shame;
 }
 
@@ -3223,7 +3230,14 @@ F32 LLVOVolume::getStreamingCost()
 	return 0.f;
 }
 
-U32 LLVOVolume::getTriangleCount()
+//static 
+void LLVOVolume::updateRenderComplexity()
+{
+	mRenderComplexity_last = mRenderComplexity_current;
+	mRenderComplexity_current = 0;
+}
+
+U32 LLVOVolume::getTriangleCount() const
 {
 	U32 count = 0;
 	LLVolume* volume = getVolume();
@@ -4068,7 +4082,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 						if ( bindCnt > 0 )
 						{					
 							const int jointCnt = pSkinData->mJointNames.size();
-							const int pelvisZOffset = pSkinData->mPelvisOffset;
+							const int pelvisZOffset = (int)pSkinData->mPelvisOffset;
 							bool fullRig = (jointCnt>=20) ? true : false;
 							if ( fullRig )
 							{
diff --git a/indra/newview/llvovolume.h b/indra/newview/llvovolume.h
index 5af88c6cbd..57faee556f 100644
--- a/indra/newview/llvovolume.h
+++ b/indra/newview/llvovolume.h
@@ -132,7 +132,7 @@ public:
 				typedef std::map<LLUUID, S32> texture_cost_t;
 				U32 	getRenderCost(texture_cost_t &textures) const;
 	/*virtual*/	F32		getStreamingCost();
-	/*virtual*/ U32		getTriangleCount();
+	/*virtual*/ U32		getTriangleCount() const;
 	/*virtual*/ BOOL lineSegmentIntersect(const LLVector3& start, const LLVector3& end, 
 										  S32 face = -1,                        // which face to check, -1 = ALL_SIDES
 										  BOOL pick_transparent = FALSE,
@@ -320,11 +320,19 @@ protected:
 	LLFace* addFace(S32 face_index);
 	void updateTEData();
 
+	// stats tracking for render complexity
+	static S32 mRenderComplexity_last;
+	static S32 mRenderComplexity_current;
+
 	void requestMediaDataUpdate(bool isNew);
 	void cleanUpMediaImpls();
 	void addMediaImpl(LLViewerMediaImpl* media_impl, S32 texture_index) ;
 	void removeMediaImpl(S32 texture_index) ;
 public:
+
+	static S32 getRenderComplexityMax() {return mRenderComplexity_last;}
+	static void updateRenderComplexity();
+
 	LLViewerTextureAnim *mTextureAnimp;
 	U8 mTexAnimMode;
 private:
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index be58af947c..02bb6d618e 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -448,6 +448,7 @@ public:
 		RENDER_DEBUG_PHYSICS_SHAPES     = 0x1000000,
 		RENDER_DEBUG_NORMALS	        = 0x2000000,
 		RENDER_DEBUG_LOD_INFO	        = 0x4000000,
+		RENDER_DEBUG_RENDER_COMPLEXITY  = 0x8000000
 	};
 
 public:
diff --git a/indra/newview/skins/default/xui/en/menu_viewer.xml b/indra/newview/skins/default/xui/en/menu_viewer.xml
index ea40a08c95..7a227fb5f9 100644
--- a/indra/newview/skins/default/xui/en/menu_viewer.xml
+++ b/indra/newview/skins/default/xui/en/menu_viewer.xml
@@ -2338,6 +2338,16 @@
            function="Advanced.ToggleInfoDisplay"
            parameter="raycast" />
         </menu_item_check>
+        <menu_item_check
+         label="Render Complexity"
+         name="rendercomplexity">
+          <menu_item_check.on_check
+           function="Advanced.CheckInfoDisplay"
+           parameter="rendercomplexity" />
+          <menu_item_check.on_click
+           function="Advanced.ToggleInfoDisplay"
+           parameter="rendercomplexity" />
+        </menu_item_check>
       </menu>
         <menu
          create_jump_keys="true"
diff --git a/indra/newview/skins/default/xui/en/panel_region_terrain.xml b/indra/newview/skins/default/xui/en/panel_region_terrain.xml
index 5093c52129..d7a629e543 100644
--- a/indra/newview/skins/default/xui/en/panel_region_terrain.xml
+++ b/indra/newview/skins/default/xui/en/panel_region_terrain.xml
@@ -115,6 +115,40 @@
      name="apply_btn"
      top="135"
      width="90" />
+    <combo_box
+     height="23"
+     layout="topleft"
+     left="50"
+     name="SkyPresetsCombo"
+     top="165"
+     width="150" />
+    <combo_box
+     height="23"
+     layout="topleft"
+     left="200"
+     name="WaterPresetsCombo"
+     top="165"
+     width="150" />
+    <button
+     enabled="false"
+     follows="left|top"
+     height="20"
+     label="Apply"
+     layout="topleft"
+     left="370"
+     name="wes_apply_btn"
+     top="165"
+     width="90" />
+    <button
+     enabled="false"
+     follows="left|top"
+     height="20"
+     label="Edit Environment"
+     layout="topleft"
+     left="370"
+     name="env_editor_btn"
+     top="195"
+     width="120" />
     <view_border
      bevel_style="none"
      follows="top|left"
-- 
cgit v1.3


From 90486e89a2d2ab648bf2981590d86dd34b395534 Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Fri, 20 May 2011 18:41:14 -0400
Subject: SH-1564 FIX update performance cost of flexi prims.

Flexi prims are expensive - clocked in at 5x multiplier. Ouch!
---
 indra/newview/llvovolume.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index c2ccbc4c49..4c8bfaee27 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -2971,15 +2971,15 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	// per-prim costs
 	static const U32 ARC_PARTICLE_COST = 1; // determined experimentally
 	static const U32 ARC_PARTICLE_MAX = 2048; // default values
-	static const U32 ARC_TEXTURE_COST = 32; // multiplier for texture resolution - performance tested
+	static const U32 ARC_TEXTURE_COST = 16; // multiplier for texture resolution - performance tested
 
 	// per-prim multipliers
 	static const F32 ARC_GLOW_MULT = 1.5f; // tested based on performance
 	static const F32 ARC_BUMP_MULT = 1.25f; // tested based on performance
-	static const F32 ARC_FLEXI_MULT = 4;
+	static const F32 ARC_FLEXI_MULT = 5; // tested based on performance
 	static const F32 ARC_SHINY_MULT = 1.6f; // tested based on performance
 	static const F32 ARC_INVISI_COST = 1.2f; // tested based on performance
-	static const F32 ARC_WEIGHTED_MESH = 1.2f; 
+	static const F32 ARC_WEIGHTED_MESH = 1.2f; // tested based on performance
 
 	static const F32 ARC_PLANAR_COST = 1.0f; // tested based on performance to have negligible impact
 	static const F32 ARC_ANIM_TEX_COST = 1.4f; // 1.4x max
@@ -3069,7 +3069,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 				LLViewerFetchedTexture *texture = LLViewerTextureManager::getFetchedTexture(sculpt_id);
 				if (texture)
 				{
-					S32 texture_cost = 512 + (S32)(ARC_TEXTURE_COST * (texture->getFullHeight() / 128.f + texture->getFullWidth() / 128.f));
+					S32 texture_cost = 256 + (S32)(ARC_TEXTURE_COST * (texture->getFullHeight() / 128.f + texture->getFullWidth() / 128.f));
 					textures.insert(texture_cost_t::value_type(sculpt_id, texture_cost));
 				}
 			}
@@ -3101,7 +3101,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		{
 			if (textures.find(img->getID()) == textures.end())
 			{
-				S32 texture_cost = 512 + (S32)(ARC_TEXTURE_COST * (img->getFullHeight() / 128.f + img->getFullWidth() / 128.f));
+				S32 texture_cost = 256 + (S32)(ARC_TEXTURE_COST * (img->getFullHeight() / 128.f + img->getFullWidth() / 128.f));
 				textures.insert(texture_cost_t::value_type(img->getID(), texture_cost));
 			}
 		}
@@ -3143,8 +3143,8 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		}
 	}
 
-	// shame currently has the "base" cost of 1 point per 50 triangles, min 2.
-	shame = num_triangles / 50.f;
+	// shame currently has the "base" cost of 1 point per 15 triangles, min 2.
+	shame = num_triangles / 15.f;
 	shame = shame < 2.f ? 2.f : shame;
 
 	// factor in scale
-- 
cgit v1.3


From 41635a8dfda707d86acb6f38d39a699758d40a8e Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 19 Jul 2011 14:18:03 -0500
Subject: SH-2090 Make meshes that fail to load render as prim proxy.

---
 indra/newview/llvovolume.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 4723ec9bd1..a620244fab 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -966,7 +966,7 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bo
 	S32 lod = mLOD;
 
 	BOOL is404 = FALSE;
-
+	
 	if (isSculpted())
 	{
 		// if it's a mesh
@@ -1017,6 +1017,8 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bo
 	if (is404)
 	{
 		setIcon(LLViewerTextureManager::getFetchedTextureFromFile("icons/Inv_Mesh.png", TRUE, LLViewerTexture::BOOST_UI));
+		//render prim proxy when mesh loading attempts give up
+		volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_NONE);
 	}
 
 	if ((LLPrimitive::setVolume(volume_params, lod, (mVolumeImpl && mVolumeImpl->isVolumeUnique()))) || mSculptChanged)
-- 
cgit v1.3


From 53187303436d06038e40c5938219863c0d75ae5f Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Tue, 16 Aug 2011 17:51:11 -0400
Subject: FIX SH-859, SH-1274 - added fix for determining triangle count and 
 performance tested impact of animated textures

Also did some cleanup to ensure branch built and ran properly after
last merge.
---
 indra/newview/llfloatertools.cpp   |  3 ++-
 indra/newview/llmeshrepository.cpp |  9 ++++++--
 indra/newview/llmeshrepository.h   |  4 ++--
 indra/newview/llvovolume.cpp       | 44 +++++++++++++-------------------------
 indra/newview/llvovolume.h         |  2 +-
 5 files changed, 27 insertions(+), 35 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llfloatertools.cpp b/indra/newview/llfloatertools.cpp
index c3b5cd4260..e748802738 100644
--- a/indra/newview/llfloatertools.cpp
+++ b/indra/newview/llfloatertools.cpp
@@ -453,6 +453,7 @@ void LLFloaterTools::refresh()
 		F32 link_cost  = LLSelectMgr::getInstance()->getSelection()->getSelectedLinksetCost();
 		S32 prim_count = LLSelectMgr::getInstance()->getSelection()->getObjectCount();
 		S32 link_count = LLSelectMgr::getInstance()->getSelection()->getRootObjectCount();
+		S32 draw_weight = LLSelectMgr::getInstance()->getSelection()->getSelectedObjectRenderCost();
 
 		LLStringUtil::format_map_t selection_args;
 		selection_args["OBJ_COUNT"] = llformat("%.1d", link_count);
@@ -481,7 +482,7 @@ void LLFloaterTools::refresh()
 			selection_info << ",";
 
 			childSetTextArg("selection_weight", "[PHYS_WEIGHT]", llformat("%.1f", link_phys_cost));
-			childSetTextArg("selection_weight", "[DISP_WEIGHT]", llformat("%.1d", calcRenderCost()));
+			childSetTextArg("selection_weight", "[DISP_WEIGHT]", llformat("%.1d", draw_weight));
 		}
 		else
 		{
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 2b6b2a84e1..fd66d7c515 100755
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -2509,7 +2509,7 @@ S32 LLMeshRepository::getActualMeshLOD(const LLVolumeParams& mesh_params, S32 lo
 	return mThread->getActualMeshLOD(mesh_params, lod);
 }
 
-const LLMeshSkinInfo* LLMeshRepository::getSkinInfo(const LLUUID& mesh_id, LLVOVolume* requesting_obj)
+const LLMeshSkinInfo* LLMeshRepository::getSkinInfo(const LLUUID& mesh_id, const LLVOVolume* requesting_obj)
 {
 	if (mesh_id.notNull())
 	{
@@ -2765,7 +2765,7 @@ void LLMeshRepository::uploadError(LLSD& args)
 }
 
 //static
-F32 LLMeshRepository::getStreamingCost(LLSD& header, F32 radius, S32* bytes, S32* bytes_visible, S32 lod)
+F32 LLMeshRepository::getStreamingCost(LLSD& header, F32 radius, S32* bytes, S32* bytes_visible, S32 lod, F32 *unscaled_value)
 {
 	F32 max_distance = 512.f;
 
@@ -2854,6 +2854,11 @@ F32 LLMeshRepository::getStreamingCost(LLSD& header, F32 radius, S32* bytes, S32
 					   triangles_low*low_area +
 					  triangles_lowest*lowest_area;
 
+	if (unscaled_value)
+	{
+		*unscaled_value = weighted_avg;
+	}
+
 	return weighted_avg/gSavedSettings.getU32("MeshTriangleBudget")*15000.f;
 }
 
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index 35a7314cd5..31b84ea0d9 100755
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -445,7 +445,7 @@ public:
 	static U32 sCacheBytesWritten;
 	static U32 sPeakKbps;
 	
-	static F32 getStreamingCost(LLSD& header, F32 radius, S32* bytes = NULL, S32* visible_bytes = NULL, S32 detail = -1);
+	static F32 getStreamingCost(LLSD& header, F32 radius, S32* bytes = NULL, S32* visible_bytes = NULL, S32 detail = -1, F32 *unscaled_value = NULL);
 
 	LLMeshRepository();
 
@@ -464,7 +464,7 @@ public:
 
 	S32 getActualMeshLOD(const LLVolumeParams& mesh_params, S32 lod);
 	static S32 getActualMeshLOD(LLSD& header, S32 lod);
-	const LLMeshSkinInfo* getSkinInfo(const LLUUID& mesh_id, LLVOVolume* requesting_obj);
+	const LLMeshSkinInfo* getSkinInfo(const LLUUID& mesh_id, const LLVOVolume* requesting_obj);
 	LLModel::Decomposition* getDecomposition(const LLUUID& mesh_id);
 	void fetchPhysicsShape(const LLUUID& mesh_id);
 	bool hasPhysicsShape(const LLUUID& mesh_id);
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 2882e644c8..373b7f372b 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -2995,7 +2995,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	static const F32 ARC_WEIGHTED_MESH = 1.2f; // tested based on performance
 
 	static const F32 ARC_PLANAR_COST = 1.0f; // tested based on performance to have negligible impact
-	static const F32 ARC_ANIM_TEX_COST = 1.4f; // 1.4x max
+	static const F32 ARC_ANIM_TEX_COST = 4.f; // tested based on performance
 	static const F32 ARC_ALPHA_COST = 4.f; // 4x max - based on performance
 
 	F32 shame = 0;
@@ -3023,28 +3023,20 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		path_params = volume_params.getPathParams();
 		profile_params = volume_params.getProfileParams();
 
-		F32 radius = getVolume()->mLODScaleBias.scaledVec(getScale()).length();
-		S32 default_detail = llclamp((S32) (sqrtf(radius)*LLVOVolume::sLODFactor*4.f), 0, 3);
-		if (default_detail == getLOD())
-		{
-			num_triangles = getTriangleCount();
-		}
-		else
+		F32 weighted_triangles = -1.0;
+		getStreamingCost(NULL, NULL, &weighted_triangles);
+
+		if (weighted_triangles > 0.0)
 		{
-			LLVolume* default_volume = LLPrimitive::getVolumeManager()->refVolume(volume_params, default_detail);
-			if(default_volume != NULL)
-			{
-				num_triangles = default_volume->getNumTriangles();
-				LLPrimitive::getVolumeManager()->unrefVolume(default_volume);
-				default_volume = NULL;
-			}
-			else
-			{
-				has_volume = false;
-			}
+			num_triangles = (U32)weighted_triangles;
 		}
 	}
 
+	if (num_triangles == 0)
+	{
+		num_triangles = 4;
+	}
+
 	if (isSculpted())
 	{
 		if (isMesh())
@@ -3054,18 +3046,12 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 			S32 size = gMeshRepo.getMeshSize(volume_params.getSculptID(),3);
 			if ( size > 0)
 			{
-				num_triangles = (U32)(size / 10.f); // avg 1 triangle per 10 bytes
-				if (gMeshRepo.getSkinInfo(volume_params.getSculptID()))
+				if (gMeshRepo.getSkinInfo(volume_params.getSculptID(), this))
 				{
 					// weighted attachment - 1 point for every 3 bytes
 					weighted_mesh = 1;
 				}
 
-				if (num_triangles == 0)
-				{
-					// someone made a really tiny mesh. Approximate with a tetrahedron.
-					num_triangles = 4;
-				}
 			}
 			else
 			{
@@ -3231,7 +3217,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	return (U32)shame;
 }
 
-F32 LLVOVolume::getStreamingCost(S32* bytes, S32* visible_bytes)
+F32 LLVOVolume::getStreamingCost(S32* bytes, S32* visible_bytes, F32* unscaled_value) const
 {
 	F32 radius = getScale().length()*0.5f;
 
@@ -3239,7 +3225,7 @@ F32 LLVOVolume::getStreamingCost(S32* bytes, S32* visible_bytes)
 	{	
 		LLSD& header = gMeshRepo.getMeshHeader(getVolume()->getParams().getSculptID());
 
-		return LLMeshRepository::getStreamingCost(header, radius, bytes, visible_bytes, mLOD);
+		return LLMeshRepository::getStreamingCost(header, radius, bytes, visible_bytes, mLOD, unscaled_value);
 	}
 	else
 	{
@@ -3253,7 +3239,7 @@ F32 LLVOVolume::getStreamingCost(S32* bytes, S32* visible_bytes)
 		header["medium_lod"]["size"] = counts[2] * 10;
 		header["high_lod"]["size"] = counts[3] * 10;
 
-		return LLMeshRepository::getStreamingCost(header, radius);
+		return LLMeshRepository::getStreamingCost(header, radius, NULL, NULL, -1, unscaled_value);
 	}	
 }
 
diff --git a/indra/newview/llvovolume.h b/indra/newview/llvovolume.h
index 6e9c0fbcb0..556497f0fa 100644
--- a/indra/newview/llvovolume.h
+++ b/indra/newview/llvovolume.h
@@ -131,7 +131,7 @@ public:
 	/*virtual*/	const LLMatrix4	getRenderMatrix() const;
 				typedef std::map<LLUUID, S32> texture_cost_t;
 				U32 	getRenderCost(texture_cost_t &textures) const;
-	/*virtual*/	F32		getStreamingCost(S32* bytes = NULL, S32* visible_bytes = NULL);
+	/*virtual*/	F32		getStreamingCost(S32* bytes = NULL, S32* visible_bytes = NULL, F32* unscaled_value = NULL) const;
 
 	/*virtual*/ U32		getTriangleCount() const;
 	/*virtual*/ U32		getHighLODTriangleCount();
-- 
cgit v1.3


From f7d17cad5cc3784abb0dea4fb5bec967cbc1f81b Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 17 Aug 2011 12:55:32 -0500
Subject: SH-2188 Fix for generally bad vertex buffer updates for rigged
 attachments and fix for viewer always thinking meshes initially have 8
 texture entries.

---
 indra/llmath/llvolume.cpp          | 173 ++-----------------------------------
 indra/llmath/llvolume.h            |   6 +-
 indra/newview/lldrawpoolavatar.cpp |  41 ++++++---
 indra/newview/llmeshrepository.cpp |  14 ++-
 indra/newview/llvovolume.cpp       |  13 ++-
 5 files changed, 47 insertions(+), 200 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp
index a0338294c1..b2fe9ba6c2 100755
--- a/indra/llmath/llvolume.cpp
+++ b/indra/llmath/llvolume.cpp
@@ -2078,7 +2078,7 @@ LLVolume::LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL ge
 	mFaceMask = 0x0;
 	mDetail = detail;
 	mSculptLevel = -2;
-	mIsTetrahedron = FALSE;
+	mIsMeshAssetLoaded = FALSE;
 	mLODScaleBias.setVec(1,1,1);
 	mHullPoints = NULL;
 	mHullIndices = NULL;
@@ -2100,7 +2100,7 @@ LLVolume::LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL ge
 
 	generate();
 	
-	if (mParams.getSculptID().isNull() && mParams.getSculptType() == LL_SCULPT_TYPE_NONE)
+	if (mParams.getSculptID().isNull() && mParams.getSculptType() == LL_SCULPT_TYPE_NONE || mParams.getSculptType() == LL_SCULPT_TYPE_MESH)
 	{
 		createVolumeFaces();
 	}
@@ -2706,173 +2706,21 @@ bool LLVolume::unpackVolumeFaces(std::istream& is, S32 size)
 	return true;
 }
 
-void tetrahedron_set_normal(LLVolumeFace::VertexData* cv)
-{
-	LLVector4a v0;
-	v0.setSub(cv[1].getPosition(), cv[0].getNormal());
-	LLVector4a v1;
-	v1.setSub(cv[2].getNormal(), cv[0].getPosition());
-	
-	cv[0].getNormal().setCross3(v0,v1);
-	cv[0].getNormal().normalize3fast();
-	cv[1].setNormal(cv[0].getNormal());
-	cv[2].setNormal(cv[1].getNormal());
-}
 
-BOOL LLVolume::isTetrahedron()
+BOOL LLVolume::isMeshAssetLoaded()
 {
-	return mIsTetrahedron;
+	return mIsMeshAssetLoaded;
 }
 
-void LLVolume::makeTetrahedron()
+void LLVolume::setMeshAssetLoaded(BOOL loaded)
 {
-	mVolumeFaces.clear();
-
-	LLVolumeFace face;
-
-	F32 x = 0.25f;
-	LLVector4a p[] = 
-	{ //unit tetrahedron corners
-		LLVector4a(x,x,x),
-		LLVector4a(-x,-x,x),
-		LLVector4a(-x,x,-x),
-		LLVector4a(x,-x,-x)
-	};
-
-	face.mExtents[0].splat(-x);
-	face.mExtents[1].splat(x);
-	
-	LLVolumeFace::VertexData cv[3];
-
-	//set texture coordinates
-	cv[0].mTexCoord = LLVector2(0,0);
-	cv[1].mTexCoord = LLVector2(1,0);
-	cv[2].mTexCoord = LLVector2(0.5f, 0.5f*F_SQRT3);
-
-
-	//side 1
-	cv[0].setPosition(p[1]);
-	cv[1].setPosition(p[0]);
-	cv[2].setPosition(p[2]);
-
-	tetrahedron_set_normal(cv);
-
-	face.resizeVertices(12);
-	face.resizeIndices(12);
-
-	LLVector4a* v = (LLVector4a*) face.mPositions;
-	LLVector4a* n = (LLVector4a*) face.mNormals;
-	LLVector2* tc = (LLVector2*) face.mTexCoords;
-
-	v[0] = cv[0].getPosition();
-	v[1] = cv[1].getPosition();
-	v[2] = cv[2].getPosition();
-	v += 3;
-
-	n[0] = cv[0].getNormal();
-	n[1] = cv[1].getNormal();
-	n[2] = cv[2].getNormal();
-	n += 3;
-
-	if(tc)
-	{
-		tc[0] = cv[0].mTexCoord;
-		tc[1] = cv[1].mTexCoord;
-		tc[2] = cv[2].mTexCoord;
-		tc += 3;
-	}
-	
-	//side 2
-	cv[0].setPosition(p[3]);
-	cv[1].setPosition(p[0]);
-	cv[2].setPosition(p[1]);
-
-	tetrahedron_set_normal(cv);
-
-	v[0] = cv[0].getPosition();
-	v[1] = cv[1].getPosition();
-	v[2] = cv[2].getPosition();
-	v += 3;
-
-	n[0] = cv[0].getNormal();
-	n[1] = cv[1].getNormal();
-	n[2] = cv[2].getNormal();
-	n += 3;
-
-	if(tc)
-	{
-		tc[0] = cv[0].mTexCoord;
-		tc[1] = cv[1].mTexCoord;
-		tc[2] = cv[2].mTexCoord;
-		tc += 3;
-	}
-
-	//side 3
-	cv[0].setPosition(p[3]);
-	cv[1].setPosition(p[1]);
-	cv[2].setPosition(p[2]);
-
-	tetrahedron_set_normal(cv);
-
-	v[0] = cv[0].getPosition();
-	v[1] = cv[1].getPosition();
-	v[2] = cv[2].getPosition();
-	v += 3;
-
-	n[0] = cv[0].getNormal();
-	n[1] = cv[1].getNormal();
-	n[2] = cv[2].getNormal();
-	n += 3;
-
-	if(tc)
-	{
-		tc[0] = cv[0].mTexCoord;
-		tc[1] = cv[1].mTexCoord;
-		tc[2] = cv[2].mTexCoord;
-		tc += 3;
-	}
-	
-	//side 4
-	cv[0].setPosition(p[2]);
-	cv[1].setPosition(p[0]);
-	cv[2].setPosition(p[3]);
-
-	tetrahedron_set_normal(cv);
-
-	v[0] = cv[0].getPosition();
-	v[1] = cv[1].getPosition();
-	v[2] = cv[2].getPosition();
-	v += 3;
-
-	n[0] = cv[0].getNormal();
-	n[1] = cv[1].getNormal();
-	n[2] = cv[2].getNormal();
-	n += 3;
-
-	if(tc)
-	{
-		tc[0] = cv[0].mTexCoord;
-		tc[1] = cv[1].mTexCoord;
-		tc[2] = cv[2].mTexCoord;
-		tc += 3;
-	}
-	
-	//set index buffer
-	for (U16 i = 0; i < 12; i++)
-	{
-		face.mIndices[i] = i;
-	}
-	
-	mVolumeFaces.push_back(face);
-	mSculptLevel = 0;
-	mIsTetrahedron = TRUE;
+	mIsMeshAssetLoaded = loaded;
 }
 
 void LLVolume::copyVolumeFaces(const LLVolume* volume)
 {
 	mVolumeFaces = volume->mVolumeFaces;
 	mSculptLevel = 0;
-	mIsTetrahedron = FALSE;
 }
 
 void LLVolume::cacheOptimize()
@@ -2886,13 +2734,6 @@ void LLVolume::cacheOptimize()
 
 S32	LLVolume::getNumFaces() const
 {
-	U8 sculpt_type = (mParams.getSculptType() & LL_SCULPT_TYPE_MASK);
-
-	if (sculpt_type == LL_SCULPT_TYPE_MESH)
-	{
-		return LL_SCULPT_MESH_MAX_FACES;
-	}
-
 	return (S32)mProfilep->mFaces.size();
 }
 
@@ -7269,7 +7110,7 @@ BOOL LLVolumeFace::createSide(LLVolume* volume, BOOL partial_build)
 		resizeVertices(num_vertices);
 		resizeIndices(num_indices);
 
-		if ((volume->getParams().getSculptType() & LL_SCULPT_TYPE_MASK) != LL_SCULPT_TYPE_MESH)
+		if (!volume->isMeshAssetLoaded())
 		{
 			mEdge.resize(num_indices);
 		}
diff --git a/indra/llmath/llvolume.h b/indra/llmath/llvolume.h
index f67f8f644d..f0e59a3c00 100644
--- a/indra/llmath/llvolume.h
+++ b/indra/llmath/llvolume.h
@@ -1058,14 +1058,14 @@ protected:
 public:
 	virtual bool unpackVolumeFaces(std::istream& is, S32 size);
 
-	virtual void makeTetrahedron();
-	virtual BOOL isTetrahedron();
+	virtual void setMeshAssetLoaded(BOOL loaded);
+	virtual BOOL isMeshAssetLoaded();
 
  protected:
 	BOOL mUnique;
 	F32 mDetail;
 	S32 mSculptLevel;
-	BOOL mIsTetrahedron;
+	BOOL mIsMeshAssetLoaded;
 	
 	LLVolumeParams mParams;
 	LLPath *mPathp;
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 9f790d03fe..984014f309 100644
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -1283,30 +1283,38 @@ void LLDrawPoolAvatar::updateRiggedFaceVertexBuffer(LLVOAvatar* avatar, LLFace*
 		return;
 	}
 
-	LLVertexBuffer* buffer = face->getVertexBuffer();
+	LLPointer<LLVertexBuffer> buffer = face->getVertexBuffer();
+	LLDrawable* drawable = face->getDrawable();
 
 	U32 data_mask = face->getRiggedVertexBufferDataMask();
 	
-	if (!buffer || 
+	if (buffer.isNull() || 
 		buffer->getTypeMask() != data_mask ||
-		buffer->getRequestedVerts() != vol_face.mNumVertices)
+		buffer->getRequestedVerts() != vol_face.mNumVertices ||
+		buffer->getRequestedIndices() != vol_face.mNumIndices ||
+		(drawable && drawable->isState(LLDrawable::REBUILD_ALL)))
 	{
 		face->setGeomIndex(0);
 		face->setIndicesIndex(0);
-		face->setSize(vol_face.mNumVertices, vol_face.mNumIndices, true);
-
-
-		if (sShaderLevel > 0)
-		{
-			buffer = new LLVertexBuffer(data_mask, GL_DYNAMIC_DRAW_ARB);
+		
+		if (buffer.isNull() || buffer->getTypeMask() != data_mask)
+		{ //make a new buffer
+			if (sShaderLevel > 0)
+			{
+				buffer = new LLVertexBuffer(data_mask, GL_DYNAMIC_DRAW_ARB);
+			}
+			else
+			{
+				buffer = new LLVertexBuffer(data_mask, GL_STREAM_DRAW_ARB);
+			}
+			buffer->allocateBuffer(vol_face.mNumVertices, vol_face.mNumIndices, true);
 		}
 		else
-		{
-			buffer = new LLVertexBuffer(data_mask, GL_STREAM_DRAW_ARB);
+		{ //resize existing buffer
+			buffer->resizeBuffer(vol_face.mNumVertices, vol_face.mNumIndices);
 		}
 
-		buffer->allocateBuffer(face->getGeomCount(), face->getIndicesCount(), true);
-
+		face->setSize(vol_face.mNumVertices, vol_face.mNumIndices);
 		face->setVertexBuffer(buffer);
 
 		U16 offset = 0;
@@ -1407,6 +1415,11 @@ void LLDrawPoolAvatar::updateRiggedFaceVertexBuffer(LLVOAvatar* avatar, LLFace*
 			}
 		}
 	}
+
+	if (drawable && (face->getTEOffset() == drawable->getNumFaces()-1))
+	{
+		drawable->clearState(LLDrawable::REBUILD_ALL);
+	}
 }
 
 void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
@@ -1437,7 +1450,7 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 		LLVolume* volume = vobj->getVolume();
 		S32 te = face->getTEOffset();
 
-		if (!volume || volume->getNumVolumeFaces() <= te)
+		if (!volume || volume->getNumVolumeFaces() <= te || !volume->isMeshAssetLoaded())
 		{
 			continue;
 		}
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 2b6b2a84e1..90a0d5da59 100755
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -1701,6 +1701,7 @@ void LLMeshRepository::cacheOutgoingMesh(LLMeshUploadData& data, LLSD& header)
 		{
 			LLPointer<LLVolume> volume = new LLVolume(volume_params, LLVolumeLODGroup::getVolumeScaleFromDetail(i));
 			volume->copyVolumeFaces(data.mModel[i]);
+			volume->setMeshAssetLoaded(TRUE);
 		}
 	}
 
@@ -2154,11 +2155,6 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
 
 	if (volume)
 	{
-		if (volume->getNumVolumeFaces() == 0 && !volume->isTetrahedron())
-		{
-			volume->makeTetrahedron();
-		}
-
 		LLVolumeParams params = volume->getParams();
 
 		LLVolumeLODGroup* group = LLPrimitive::getVolumeManager()->getGroup(params);
@@ -2169,7 +2165,7 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
 			if (last_lod >= 0)
 			{
 				LLVolume* lod = group->refLOD(last_lod);
-				if (lod && !lod->isTetrahedron() && lod->getNumVolumeFaces() > 0)
+				if (lod && lod->isMeshAssetLoaded() && lod->getNumVolumeFaces() > 0)
 				{
 					group->derefLOD(lod);
 					return last_lod;
@@ -2181,7 +2177,7 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
 			for (S32 i = detail-1; i >= 0; --i)
 			{
 				LLVolume* lod = group->refLOD(i);
-				if (lod && !lod->isTetrahedron() && lod->getNumVolumeFaces() > 0)
+				if (lod && lod->isMeshAssetLoaded() && lod->getNumVolumeFaces() > 0)
 				{
 					group->derefLOD(lod);
 					return i;
@@ -2194,7 +2190,7 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
 			for (S32 i = detail+1; i < 4; ++i)
 			{
 				LLVolume* lod = group->refLOD(i);
-				if (lod && !lod->isTetrahedron() && lod->getNumVolumeFaces() > 0)
+				if (lod && lod->isMeshAssetLoaded() && lod->getNumVolumeFaces() > 0)
 				{
 					group->derefLOD(lod);
 					return i;
@@ -2445,7 +2441,6 @@ void LLMeshRepository::notifyMeshLoaded(const LLVolumeParams& mesh_params, LLVol
 		if (volume->getNumVolumeFaces() <= 0)
 		{
 			llwarns << "Mesh loading returned empty volume." << llendl;
-			volume->makeTetrahedron();
 		}
 		
 		{ //update system volume
@@ -2453,6 +2448,7 @@ void LLMeshRepository::notifyMeshLoaded(const LLVolumeParams& mesh_params, LLVol
 			if (sys_volume)
 			{
 				sys_volume->copyVolumeFaces(volume);
+				sys_volume->setMeshAssetLoaded(TRUE);
 				LLPrimitive::getVolumeManager()->unrefVolume(sys_volume);
 			}
 			else
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index cbfd64cffb..b097ebcc1d 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -367,6 +367,7 @@ U32 LLVOVolume::processUpdateMessage(LLMessageSystem *mesgsys,
 		//
 		// Unpack texture entry data
 		//
+
 		S32 result = unpackTEMessage(mesgsys, _PREHASH_ObjectData, block_num);
 		if (result & teDirtyBits)
 		{
@@ -972,12 +973,8 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bo
 		// if it's a mesh
 		if ((volume_params.getSculptType() & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
 		{ //meshes might not have all LODs, get the force detail to best existing LOD
-
 			LLUUID mesh_id = volume_params.getSculptID();
 
-			//profile and path params don't matter for meshes
-			volume_params.setType(LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE);
-
 			lod = gMeshRepo.getActualMeshLOD(volume_params, lod);
 			if (lod == -1)
 			{
@@ -1033,14 +1030,13 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bo
 	
 		updateSculptTexture();
 
-
 		if (isSculpted())
 		{
 			updateSculptTexture();
 			// if it's a mesh
 			if ((volume_params.getSculptType() & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
 			{
-				if (getVolume()->getNumVolumeFaces() == 0 || getVolume()->isTetrahedron())
+				if (!getVolume()->isMeshAssetLoaded())
 				{ 
 					//load request not yet issued, request pipeline load this mesh
 					LLUUID asset_id = volume_params.getSculptID();
@@ -3150,7 +3146,7 @@ U32 LLVOVolume::getHighLODTriangleCount()
 	else if (isMesh())
 	{
 		LLVolume* ref = LLPrimitive::getVolumeManager()->refVolume(volume->getParams(), 3);
-		if (ref->isTetrahedron() || ref->getNumVolumeFaces() == 0)
+		if (!ref->isMeshAssetLoaded() || ref->getNumVolumeFaces() == 0)
 		{
 			gMeshRepo.loadMesh(this, volume->getParams(), LLModel::LOD_HIGH);
 		}
@@ -3992,7 +3988,8 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 
 		LLVOVolume* vobj = drawablep->getVOVolume();
 
-		if (vobj->getVolume() && vobj->getVolume()->isTetrahedron() || (vobj->isMesh() && !gMeshRepo.meshRezEnabled()))
+		if (vobj->isMesh() &&
+			(vobj->getVolume() && !vobj->getVolume()->isMeshAssetLoaded() || !gMeshRepo.meshRezEnabled()))
 		{
 			continue;
 		}
-- 
cgit v1.3


From bc400605cab6f353ab4b952a1056c6c22784d4d9 Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Fri, 19 Aug 2011 16:57:56 -0400
Subject: FIX SH-862 SH-1246 SH-1565 SH-1566 Update render cost algorithm

render cost algorithm triangle count is now scaled to be more balanced vs
texture/particle count. In addition added factors for light-emitting and
media texture primitives. Algorithm should be near "final" at this point.
---
 indra/newview/llvovolume.cpp | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 959bce63b1..5c1694078c 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -2981,6 +2981,9 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	static const U32 ARC_PARTICLE_COST = 1; // determined experimentally
 	static const U32 ARC_PARTICLE_MAX = 2048; // default values
 	static const U32 ARC_TEXTURE_COST = 16; // multiplier for texture resolution - performance tested
+	static const U32 ARC_LIGHT_COST = 500; // static cost for light-producing prims 
+	static const U32 ARC_MEDIA_FACE_COST = 1500; // static cost per media-enabled face 
+
 
 	// per-prim multipliers
 	static const F32 ARC_GLOW_MULT = 1.5f; // tested based on performance
@@ -3006,6 +3009,8 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	U32 bump = 0;
 	U32 planar = 0;
 	U32 weighted_mesh = 0;
+	U32 produces_light = 0;
+	U32 media_faces = 0;
 
 	// these multipliers are variable and can be floating point
 	F32 scale = 0.f;
@@ -3024,7 +3029,8 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 
 		if (weighted_triangles > 0.0)
 		{
-			num_triangles = (U32)weighted_triangles;
+			num_triangles = (U32)(weighted_triangles * 2); // scale weighted triangles to match the recorded scale.
+															// a complex prim (tortured torus, sculptie) should be 1000-1200 points @ 5 m
 		}
 	}
 
@@ -3080,6 +3086,11 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		particles = 1;
 	}
 
+	if (getIsLight())
+	{
+		produces_light = 1;
+	}
+
 	const LLVector3& sc = getScale();
 	scale += (sc.mV[0] + sc.mV[1] + sc.mV[2]) / 4.f; // scale to 1/4 the sum of the size
 	// enforce scale multiplier to be in the range [1,7] (7 was determined to experimentally be a reasonable max)
@@ -3109,6 +3120,10 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		{
 			invisi = 1;
 		}
+		if (face->hasMedia())
+		{
+			media_faces++;
+		}
 
 		if (te)
 		{
@@ -3205,6 +3220,16 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		shame += num_particles * part_size * ARC_PARTICLE_COST;
 	}
 
+	if (produces_light)
+	{
+		shame += ARC_LIGHT_COST;
+	}
+
+	if (media_faces)
+	{
+		shame += media_faces * ARC_MEDIA_FACE_COST;
+	}
+
 	if (shame > mRenderComplexity_current)
 	{
 		mRenderComplexity_current = (S32)shame;
-- 
cgit v1.3


From e64b9269cb385a22c83d1c912e336aed11e40efe Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Fri, 19 Aug 2011 18:56:58 -0400
Subject: BUILDFIX fixing unix line endings on two files to pass policy checks.

---
 indra/newview/llvoavatar.h   |  2200 ++++-----
 indra/newview/llvovolume.cpp | 10124 ++++++++++++++++++++---------------------
 2 files changed, 6162 insertions(+), 6162 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llvoavatar.h b/indra/newview/llvoavatar.h
index 6f14b42513..e53b8e3f4b 100644
--- a/indra/newview/llvoavatar.h
+++ b/indra/newview/llvoavatar.h
@@ -1,1100 +1,1100 @@
-/**
- * @file llvoavatar.h
- * @brief Declaration of LLVOAvatar class which is a derivation of
- * LLViewerObject
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLVOAVATAR_H
-#define LL_LLVOAVATAR_H
-
-#include <map>
-#include <deque>
-#include <string>
-#include <vector>
-
-#include <boost/signals2.hpp>
-
-#include "imageids.h"			// IMG_INVISIBLE
-#include "llchat.h"
-#include "lldrawpoolalpha.h"
-#include "llviewerobject.h"
-#include "llcharacter.h"
-#include "llviewerjointmesh.h"
-#include "llviewerjointattachment.h"
-#include "llrendertarget.h"
-#include "llvoavatardefines.h"
-#include "lltexglobalcolor.h"
-#include "lldriverparam.h"
-#include "material_codes.h"		// LL_MCODE_END
-
-extern const LLUUID ANIM_AGENT_BODY_NOISE;
-extern const LLUUID ANIM_AGENT_BREATHE_ROT;
-extern const LLUUID ANIM_AGENT_PHYSICS_MOTION;
-extern const LLUUID ANIM_AGENT_EDITING;
-extern const LLUUID ANIM_AGENT_EYE;
-extern const LLUUID ANIM_AGENT_FLY_ADJUST;
-extern const LLUUID ANIM_AGENT_HAND_MOTION;
-extern const LLUUID ANIM_AGENT_HEAD_ROT;
-extern const LLUUID ANIM_AGENT_PELVIS_FIX;
-extern const LLUUID ANIM_AGENT_TARGET;
-extern const LLUUID ANIM_AGENT_WALK_ADJUST;
-
-class LLTexLayerSet;
-class LLVoiceVisualizer;
-class LLHUDNameTag;
-class LLHUDEffectSpiral;
-class LLTexGlobalColor;
-class LLVOAvatarBoneInfo;
-class LLVOAvatarSkeletonInfo;
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// LLVOAvatar
-// 
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-class LLVOAvatar :
-	public LLViewerObject,
-	public LLCharacter,
-	public boost::signals2::trackable
-{
-public:
-	friend class LLVOAvatarSelf;
-protected:
-	struct LLVOAvatarXmlInfo;
-	struct LLMaskedMorph;
-
-/********************************************************************************
- **                                                                            **
- **                    INITIALIZATION
- **/
-
-public:
-	LLVOAvatar(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp);
-	virtual void		markDead();
-	static void			initClass(); // Initialize data that's only init'd once per class.
-	static void			cleanupClass();	// Cleanup data that's only init'd once per class.
-	virtual void 		initInstance(); // Called after construction to initialize the class.
-protected:
-	virtual				~LLVOAvatar();
-	BOOL				loadSkeletonNode();
-	BOOL				loadMeshNodes();
-	virtual BOOL		loadLayersets();
-
-/**                    Initialization
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    INHERITED
- **/
-
-	//--------------------------------------------------------------------
-	// LLViewerObject interface and related
-	//--------------------------------------------------------------------
-public:
-	virtual void			updateGL();
-	virtual	LLVOAvatar*		asAvatar();
-	virtual U32    	 	 	processUpdateMessage(LLMessageSystem *mesgsys,
-													 void **user_data,
-													 U32 block_num,
-													 const EObjectUpdateType update_type,
-													 LLDataPacker *dp);
-	virtual BOOL   	 	 	idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
-	virtual BOOL   	 	 	updateLOD();
-	BOOL  	 	 	 	 	updateJointLODs();
-	void					updateLODRiggedAttachments( void );
-	virtual BOOL   	 	 	isActive() const; // Whether this object needs to do an idleUpdate.
-	virtual void   	 	 	updateTextures();
-	virtual S32    	 	 	setTETexture(const U8 te, const LLUUID& uuid); // If setting a baked texture, need to request it from a non-local sim.
-	virtual void   	 	 	onShift(const LLVector4a& shift_vector);
-	virtual U32    	 	 	getPartitionType() const;
-	virtual const  	 	 	LLVector3 getRenderPosition() const;
-	virtual void   	 	 	updateDrawable(BOOL force_damped);
-	virtual LLDrawable* 	createDrawable(LLPipeline *pipeline);
-	virtual BOOL   	 	 	updateGeometry(LLDrawable *drawable);
-	virtual void   	 	 	setPixelAreaAndAngle(LLAgent &agent);
-	virtual void   	 	 	updateRegion(LLViewerRegion *regionp);
-	virtual void   	 	 	updateSpatialExtents(LLVector4a& newMin, LLVector4a &newMax);
-	virtual void   	 	 	getSpatialExtents(LLVector4a& newMin, LLVector4a& newMax);
-	virtual BOOL   	 	 	lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
-												 S32 face = -1,                    // which face to check, -1 = ALL_SIDES
-												 BOOL pick_transparent = FALSE,
-												 S32* face_hit = NULL,             // which face was hit
-												 LLVector3* intersection = NULL,   // return the intersection point
-												 LLVector2* tex_coord = NULL,      // return the texture coordinates of the intersection point
-												 LLVector3* normal = NULL,         // return the surface normal at the intersection point
-												 LLVector3* bi_normal = NULL);     // return the surface bi-normal at the intersection point
-	LLViewerObject*	lineSegmentIntersectRiggedAttachments(const LLVector3& start, const LLVector3& end,
-												 S32 face = -1,                    // which face to check, -1 = ALL_SIDES
-												 BOOL pick_transparent = FALSE,
-												 S32* face_hit = NULL,             // which face was hit
-												 LLVector3* intersection = NULL,   // return the intersection point
-												 LLVector2* tex_coord = NULL,      // return the texture coordinates of the intersection point
-												 LLVector3* normal = NULL,         // return the surface normal at the intersection point
-												 LLVector3* bi_normal = NULL);     // return the surface bi-normal at the intersection point
-
-	//--------------------------------------------------------------------
-	// LLCharacter interface and related
-	//--------------------------------------------------------------------
-public:
-	virtual LLVector3    	getCharacterPosition();
-	virtual LLQuaternion 	getCharacterRotation();
-	virtual LLVector3    	getCharacterVelocity();
-	virtual LLVector3    	getCharacterAngularVelocity();
-	virtual LLJoint*		getCharacterJoint(U32 num);
-	virtual BOOL			allocateCharacterJoints(U32 num);
-
-	virtual LLUUID			remapMotionID(const LLUUID& id);
-	virtual BOOL			startMotion(const LLUUID& id, F32 time_offset = 0.f);
-	virtual BOOL			stopMotion(const LLUUID& id, BOOL stop_immediate = FALSE);
-	virtual void			stopMotionFromSource(const LLUUID& source_id);
-	virtual void			requestStopMotion(LLMotion* motion);
-	LLMotion*				findMotion(const LLUUID& id) const;
-	void					startDefaultMotions();
-	void					dumpAnimationState();
-
-	virtual LLJoint*		getJoint(const std::string &name);
-	virtual LLJoint*     	getRootJoint() { return &mRoot; }
-	
-	void					resetJointPositions( void );
-	void					resetJointPositionsToDefault( void );
-	void					resetSpecificJointPosition( const std::string& name );
-	
-	virtual const char*		getAnimationPrefix() { return "avatar"; }
-	virtual const LLUUID&   getID();
-	virtual LLVector3		getVolumePos(S32 joint_index, LLVector3& volume_offset);
-	virtual LLJoint*		findCollisionVolume(U32 volume_id);
-	virtual S32				getCollisionVolumeID(std::string &name);
-	virtual void			addDebugText(const std::string& text);
-	virtual F32          	getTimeDilation();
-	virtual void			getGround(const LLVector3 &inPos, LLVector3 &outPos, LLVector3 &outNorm);
-	virtual F32				getPixelArea() const;
-	virtual LLPolyMesh*		getHeadMesh();
-	virtual LLPolyMesh*		getUpperBodyMesh();
-	virtual LLVector3d		getPosGlobalFromAgent(const LLVector3 &position);
-	virtual LLVector3		getPosAgentFromGlobal(const LLVector3d &position);
-	virtual void			updateVisualParams();
-
-
-/**                    Inherited
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    STATE
- **/
-
-public:
-	virtual bool 	isSelf() const { return false; } // True if this avatar is for this viewer's agent
-	bool isBuilt() const { return mIsBuilt; }
-
-private: //aligned members
-	LLVector4a	mImpostorExtents[2];
-
-private:
-	BOOL			mSupportsAlphaLayers; // For backwards compatibility, TRUE for 1.23+ clients
-
-	//--------------------------------------------------------------------
-	// Updates
-	//--------------------------------------------------------------------
-public:
-	virtual BOOL 	updateCharacter(LLAgent &agent);
-	void 			idleUpdateVoiceVisualizer(bool voice_enabled);
-	void 			idleUpdateMisc(bool detailed_update);
-	virtual void	idleUpdateAppearanceAnimation();
-	void 			idleUpdateLipSync(bool voice_enabled);
-	void 			idleUpdateLoadingEffect();
-	void 			idleUpdateWindEffect();
-	void 			idleUpdateNameTag(const LLVector3& root_pos_last);
-	void			idleUpdateNameTagText(BOOL new_name);
-	LLVector3		idleUpdateNameTagPosition(const LLVector3& root_pos_last);
-	void			idleUpdateNameTagAlpha(BOOL new_name, F32 alpha);
-	LLColor4		getNameTagColor(bool is_friend);
-	void			clearNameTag();
-	static void		invalidateNameTag(const LLUUID& agent_id);
-	// force all name tags to rebuild, useful when display names turned on/off
-	static void		invalidateNameTags();
-	void			addNameTagLine(const std::string& line, const LLColor4& color, S32 style, const LLFontGL* font);
-	void 			idleUpdateRenderCost();
-	void 			idleUpdateBelowWater();
-
-	//--------------------------------------------------------------------
-	// Static preferences (controlled by user settings/menus)
-	//--------------------------------------------------------------------
-public:
-	static S32		sRenderName;
-	static BOOL		sRenderGroupTitles;
-	static U32		sMaxVisible; //(affected by control "RenderAvatarMaxVisible")
-	static F32		sRenderDistance; //distance at which avatars will render.
-	static BOOL		sShowAnimationDebug; // show animation debug info
-	static BOOL		sUseImpostors; //use impostors for far away avatars
-	static BOOL		sShowFootPlane;	// show foot collision plane reported by server
-	static BOOL		sShowCollisionVolumes;	// show skeletal collision volumes
-	static BOOL		sVisibleInFirstPerson;
-	static S32		sNumLODChangesThisFrame;
-	static S32		sNumVisibleChatBubbles;
-	static BOOL		sDebugInvisible;
-	static BOOL		sShowAttachmentPoints;
-	static F32		sLODFactor; // user-settable LOD factor
-	static F32		sPhysicsLODFactor; // user-settable physics LOD factor
-	static BOOL		sJointDebug; // output total number of joints being touched for each avatar
-	static BOOL		sDebugAvatarRotation;
-
-	//--------------------------------------------------------------------
-	// Region state
-	//--------------------------------------------------------------------
-public:
-	LLHost			getObjectHost() const;
-
-	//--------------------------------------------------------------------
-	// Loading state
-	//--------------------------------------------------------------------
-public:
-	BOOL			isFullyLoaded() const;
-	bool			isTooComplex() const;
-	bool visualParamWeightsAreDefault();
-protected:
-	virtual BOOL	getIsCloud();
-	BOOL			updateIsFullyLoaded();
-	BOOL			processFullyLoadedChange(bool loading);
-	void			updateRuthTimer(bool loading);
-	F32 			calcMorphAmount();
-private:
-	BOOL			mFullyLoaded;
-	BOOL			mPreviousFullyLoaded;
-	BOOL			mFullyLoadedInitialized;
-	S32				mFullyLoadedFrameCounter;
-	S32				mVisualComplexity;
-	LLFrameTimer	mFullyLoadedTimer;
-	LLFrameTimer	mRuthTimer;
-protected:
-	LLFrameTimer    mInvisibleTimer;
-	
-/**                    State
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    SKELETON
- **/
-
-public:
-	void				updateHeadOffset();
-	F32					getPelvisToFoot() const { return mPelvisToFoot; }
-	void				setPelvisOffset( bool hasOffset, const LLVector3& translation, F32 offset ) ;
-	bool				hasPelvisOffset( void ) { return mHasPelvisOffset; }
-	void				postPelvisSetRecalc( void );
-	void				setPelvisOffset( F32 pelvixFixupAmount );
-
-	bool				mHasPelvisOffset;
-	LLVector3			mPelvisOffset;
-	F32					mLastPelvisToFoot;
-	F32					mPelvisFixup;
-	F32					mLastPelvisFixup;
-
-	LLVector3			mHeadOffset; // current head position
-	LLViewerJoint		mRoot;
-protected:
-	static BOOL			parseSkeletonFile(const std::string& filename);
-	void				buildCharacter();
-	virtual BOOL		loadAvatar();
-
-	BOOL				setupBone(const LLVOAvatarBoneInfo* info, LLViewerJoint* parent, S32 &current_volume_num, S32 &current_joint_num);
-	BOOL				buildSkeleton(const LLVOAvatarSkeletonInfo *info);
-private:
-	BOOL				mIsBuilt; // state of deferred character building
-	S32					mNumJoints;
-	LLViewerJoint*		mSkeleton;
-	
-	//--------------------------------------------------------------------
-	// Pelvis height adjustment members.
-	//--------------------------------------------------------------------
-public:
-	LLVector3			mBodySize;
-	S32					mLastSkeletonSerialNum;
-private:
-	F32					mPelvisToFoot;
-
-	//--------------------------------------------------------------------
-	// Cached pointers to well known joints
-	//--------------------------------------------------------------------
-public:
-	LLViewerJoint* 		mPelvisp;
-	LLViewerJoint* 		mTorsop;
-	LLViewerJoint* 		mChestp;
-	LLViewerJoint* 		mNeckp;
-	LLViewerJoint* 		mHeadp;
-	LLViewerJoint* 		mSkullp;
-	LLViewerJoint* 		mEyeLeftp;
-	LLViewerJoint* 		mEyeRightp;
-	LLViewerJoint* 		mHipLeftp;
-	LLViewerJoint* 		mHipRightp;
-	LLViewerJoint* 		mKneeLeftp;
-	LLViewerJoint* 		mKneeRightp;
-	LLViewerJoint* 		mAnkleLeftp;
-	LLViewerJoint* 		mAnkleRightp;
-	LLViewerJoint* 		mFootLeftp;
-	LLViewerJoint* 		mFootRightp;
-	LLViewerJoint* 		mWristLeftp;
-	LLViewerJoint* 		mWristRightp;
-
-	//--------------------------------------------------------------------
-	// XML parse tree
-	//--------------------------------------------------------------------
-private:
-	static LLXmlTree 	sXMLTree; // avatar config file
-	static LLXmlTree 	sSkeletonXMLTree; // avatar skeleton file
-
-/**                    Skeleton
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    RENDERING
- **/
-
-public:
-	U32 		renderImpostor(LLColor4U color = LLColor4U(255,255,255,255), S32 diffuse_channel = 0);
-	U32 		renderRigid();
-	U32 		renderSkinned(EAvatarRenderPass pass);
-	F32			getLastSkinTime() { return mLastSkinTime; }
-	U32			renderSkinnedAttachments();
-	U32 		renderTransparent(BOOL first_pass);
-	void 		renderCollisionVolumes();
-	static void	deleteCachedImages(bool clearAll=true);
-	static void	destroyGL();
-	static void	restoreGL();
-	BOOL 		mIsDummy; // for special views
-	S32			mSpecialRenderMode; // special lighting
-private:
-	bool		shouldAlphaMask();
-
-	BOOL 		mNeedsSkin; // avatar has been animated and verts have not been updated
-	F32			mLastSkinTime; //value of gFrameTimeSeconds at last skin update
-
-	S32	 		mUpdatePeriod;
-	S32  		mNumInitFaces; //number of faces generated when creating the avatar drawable, does not inculde splitted faces due to long vertex buffer.
-
-	//--------------------------------------------------------------------
-	// Morph masks
-	//--------------------------------------------------------------------
-public:
-	BOOL 		morphMaskNeedsUpdate(LLVOAvatarDefines::EBakedTextureIndex index = LLVOAvatarDefines::BAKED_NUM_INDICES);
-	void 		addMaskedMorph(LLVOAvatarDefines::EBakedTextureIndex index, LLPolyMorphTarget* morph_target, BOOL invert, std::string layer);
-	void 		applyMorphMask(U8* tex_data, S32 width, S32 height, S32 num_components, LLVOAvatarDefines::EBakedTextureIndex index = LLVOAvatarDefines::BAKED_NUM_INDICES);
-
-	//--------------------------------------------------------------------
-	// Visibility
-	//--------------------------------------------------------------------
-protected:
-	void 		updateVisibility();
-private:
-	U32	 		mVisibilityRank;
-	BOOL 		mVisible;
-	
-	//--------------------------------------------------------------------
-	// Shadowing
-	//--------------------------------------------------------------------
-public:
-	void 		updateShadowFaces();
-	LLDrawable*	mShadow;
-private:
-	LLFace* 	mShadow0Facep;
-	LLFace* 	mShadow1Facep;
-	LLPointer<LLViewerTexture> mShadowImagep;
-
-	//--------------------------------------------------------------------
-	// Impostors
-	//--------------------------------------------------------------------
-public:
-	BOOL 		isImpostor() const;
-	BOOL 	    needsImpostorUpdate() const;
-	const LLVector3& getImpostorOffset() const;
-	const LLVector2& getImpostorDim() const;
-	void 		getImpostorValues(LLVector4a* extents, LLVector3& angle, F32& distance) const;
-	void 		cacheImpostorValues();
-	void 		setImpostorDim(const LLVector2& dim);
-	static void	resetImpostors();
-	static void updateImpostors();
-	LLRenderTarget mImpostor;
-	BOOL		mNeedsImpostorUpdate;
-private:
-	LLVector3	mImpostorOffset;
-	LLVector2	mImpostorDim;
-	BOOL		mNeedsAnimUpdate;
-	LLVector3	mImpostorAngle;
-	F32			mImpostorDistance;
-	F32			mImpostorPixelArea;
-	LLVector3	mLastAnimExtents[2];  
-
-	//--------------------------------------------------------------------
-	// Wind rippling in clothes
-	//--------------------------------------------------------------------
-public:
-	LLVector4	mWindVec;
-	F32			mRipplePhase;
-	BOOL		mBelowWater;
-private:
-	F32			mWindFreq;
-	LLFrameTimer mRippleTimer;
-	F32			mRippleTimeLast;
-	LLVector3	mRippleAccel;
-	LLVector3	mLastVel;
-
-	//--------------------------------------------------------------------
-	// Culling
-	//--------------------------------------------------------------------
-public:
-	static void	cullAvatarsByPixelArea();
-	BOOL		isCulled() const { return mCulled; }
-private:
-	BOOL		mCulled;
-
-	//--------------------------------------------------------------------
-	// Freeze counter
-	//--------------------------------------------------------------------
-public:
-	static void updateFreezeCounter(S32 counter = 0);
-private:
-	static S32  sFreezeCounter;
-
-	//--------------------------------------------------------------------
-	// Constants
-	//--------------------------------------------------------------------
-public:
-	virtual LLViewerTexture::EBoostLevel 	getAvatarBoostLevel() const { return LLViewerTexture::BOOST_AVATAR; }
-	virtual LLViewerTexture::EBoostLevel 	getAvatarBakedBoostLevel() const { return LLViewerTexture::BOOST_AVATAR_BAKED; }
-	virtual S32 						getTexImageSize() const;
-	virtual S32 						getTexImageArea() const { return getTexImageSize()*getTexImageSize(); }
-
-/**                    Rendering
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    TEXTURES
- **/
-
-	//--------------------------------------------------------------------
-	// Loading status
-	//--------------------------------------------------------------------
-public:
-	virtual BOOL    isTextureDefined(LLVOAvatarDefines::ETextureIndex type, U32 index = 0) const;
-	virtual BOOL	isTextureVisible(LLVOAvatarDefines::ETextureIndex type, U32 index = 0) const;
-	virtual BOOL	isTextureVisible(LLVOAvatarDefines::ETextureIndex type, LLWearable *wearable) const;
-
-protected:
-	BOOL			isFullyBaked();
-	static BOOL		areAllNearbyInstancesBaked(S32& grey_avatars);
-
-	//--------------------------------------------------------------------
-	// Baked textures
-	//--------------------------------------------------------------------
-public:
-	void			releaseComponentTextures(); // ! BACKWARDS COMPATIBILITY !
-protected:
-	static void		onBakedTextureMasksLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
-	static void		onInitialBakedTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
-	static void		onBakedTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
-	virtual void	removeMissingBakedTextures();
-	void			useBakedTexture(const LLUUID& id);
-
-	typedef std::deque<LLMaskedMorph *> 	morph_list_t;
-	struct BakedTextureData
-	{
-		LLUUID								mLastTextureIndex;
-		LLTexLayerSet* 						mTexLayerSet; // Only exists for self
-		bool								mIsLoaded;
-		bool								mIsUsed;
-		LLVOAvatarDefines::ETextureIndex 	mTextureIndex;
-		U32									mMaskTexName;
-		// Stores pointers to the joint meshes that this baked texture deals with
-		std::vector< LLViewerJointMesh * > 	mMeshes;  // std::vector<LLViewerJointMesh> mJoints[i]->mMeshParts
-		morph_list_t						mMaskedMorphs;
-	};
-	typedef std::vector<BakedTextureData> 	bakedtexturedata_vec_t;
-	bakedtexturedata_vec_t 					mBakedTextureDatas;
-	LLLoadedCallbackEntry::source_callback_list_t mCallbackTextureList ; 
-	BOOL mLoadedCallbacksPaused;
-	//--------------------------------------------------------------------
-	// Local Textures
-	//--------------------------------------------------------------------
-protected:
-	virtual void	setLocalTexture(LLVOAvatarDefines::ETextureIndex type, LLViewerTexture* tex, BOOL baked_version_exits, U32 index = 0);
-	virtual void	addLocalTextureStats(LLVOAvatarDefines::ETextureIndex type, LLViewerFetchedTexture* imagep, F32 texel_area_ratio, BOOL rendered, BOOL covered_by_baked, U32 index = 0);
-	// MULTI-WEARABLE: make self-only?
-	virtual void	setBakedReady(LLVOAvatarDefines::ETextureIndex type, BOOL baked_version_exists, U32 index = 0);
-
-	//--------------------------------------------------------------------
-	// Texture accessors
-	//--------------------------------------------------------------------
-private:
-	virtual	void				setImage(const U8 te, LLViewerTexture *imagep, const U32 index); 
-	virtual LLViewerTexture*	getImage(const U8 te, const U32 index) const;
-
-	virtual const LLTextureEntry* getTexEntry(const U8 te_num) const;
-	virtual void setTexEntry(const U8 index, const LLTextureEntry &te);
-
-	void checkTextureLoading() ;
-	//--------------------------------------------------------------------
-	// Layers
-	//--------------------------------------------------------------------
-protected:
-	void			deleteLayerSetCaches(bool clearAll = true);
-	void			addBakedTextureStats(LLViewerFetchedTexture* imagep, F32 pixel_area, F32 texel_area_ratio, S32 boost_level);
-
-	//--------------------------------------------------------------------
-	// Composites
-	//--------------------------------------------------------------------
-public:
-	virtual void	invalidateComposite(LLTexLayerSet* layerset, BOOL upload_result);
-	virtual void	invalidateAll();
-	virtual void	setCompositeUpdatesEnabled(bool b) {}
-	virtual void 	setCompositeUpdatesEnabled(U32 index, bool b) {}
-	virtual bool 	isCompositeUpdateEnabled(U32 index) { return false; }
-
-	//--------------------------------------------------------------------
-	// Static texture/mesh/baked dictionary
-	//--------------------------------------------------------------------
-public:
-	static BOOL 	isIndexLocalTexture(LLVOAvatarDefines::ETextureIndex i);
-	static BOOL 	isIndexBakedTexture(LLVOAvatarDefines::ETextureIndex i);
-private:
-	static const LLVOAvatarDefines::LLVOAvatarDictionary *getDictionary() { return sAvatarDictionary; }
-	static LLVOAvatarDefines::LLVOAvatarDictionary* sAvatarDictionary;
-	static LLVOAvatarSkeletonInfo* 					sAvatarSkeletonInfo;
-	static LLVOAvatarXmlInfo* 						sAvatarXmlInfo;
-
-	//--------------------------------------------------------------------
-	// Messaging
-	//--------------------------------------------------------------------
-public:
-	void 			onFirstTEMessageReceived();
-private:
-	BOOL			mFirstTEMessageReceived;
-	BOOL			mFirstAppearanceMessageReceived;
-	
-/**                    Textures
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    MESHES
- **/
-
-public:
-	void 			updateMeshTextures();
-	void 			updateSexDependentLayerSets(BOOL upload_bake);
-	void 			dirtyMesh(); // Dirty the avatar mesh
-	void 			updateMeshData();
-protected:
-	void 			releaseMeshData();
-	virtual void restoreMeshData();
-private:
-	void 			dirtyMesh(S32 priority); // Dirty the avatar mesh, with priority
-	S32 			mDirtyMesh; // 0 -- not dirty, 1 -- morphed, 2 -- LOD
-	BOOL			mMeshTexturesDirty;
-
-	typedef std::multimap<std::string, LLPolyMesh*> polymesh_map_t;
-	polymesh_map_t 									mMeshes;
-	std::vector<LLViewerJoint *> 					mMeshLOD;
-
-	//--------------------------------------------------------------------
-	// Destroy invisible mesh
-	//--------------------------------------------------------------------
-protected:
-	BOOL			mMeshValid;
-	LLFrameTimer	mMeshInvisibleTime;
-
-/**                    Meshes
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    APPEARANCE
- **/
-
-public:
-	void 			processAvatarAppearance(LLMessageSystem* mesgsys);
-	void 			hideSkirt();
-	void			startAppearanceAnimation();
-	
-	//--------------------------------------------------------------------
-	// Appearance morphing
-	//--------------------------------------------------------------------
-public:
-	BOOL			getIsAppearanceAnimating() const { return mAppearanceAnimating; }
-private:
-	BOOL			mAppearanceAnimating;
-	LLFrameTimer	mAppearanceMorphTimer;
-	F32				mLastAppearanceBlendTime;
-
-	//--------------------------------------------------------------------
-	// Clothing colors (convenience functions to access visual parameters)
-	//--------------------------------------------------------------------
-public:
-	void			setClothesColor(LLVOAvatarDefines::ETextureIndex te, const LLColor4& new_color, BOOL upload_bake);
-	LLColor4		getClothesColor(LLVOAvatarDefines::ETextureIndex te);
-	static BOOL			teToColorParams(LLVOAvatarDefines::ETextureIndex te, U32 *param_name);
-
-	//--------------------------------------------------------------------
-	// Global colors
-	//--------------------------------------------------------------------
-public:
-	LLColor4		getGlobalColor(const std::string& color_name ) const;
-	void			onGlobalColorChanged(const LLTexGlobalColor* global_color, BOOL upload_bake);
-private:
-	LLTexGlobalColor* mTexSkinColor;
-	LLTexGlobalColor* mTexHairColor;
-	LLTexGlobalColor* mTexEyeColor;
-
-	//--------------------------------------------------------------------
-	// Visibility
-	//--------------------------------------------------------------------
-public:
-	BOOL			isVisible() const;
-	void			setVisibilityRank(U32 rank);
-	U32				getVisibilityRank()  const { return mVisibilityRank; } // unused
-	static S32 		sNumVisibleAvatars; // Number of instances of this class
-	static LLColor4 getDummyColor();
-/**                    Appearance
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    WEARABLES
- **/
-
-public:
-	virtual BOOL			isWearingWearableType(LLWearableType::EType type ) const;
-	
-	//--------------------------------------------------------------------
-	// Attachments
-	//--------------------------------------------------------------------
-public:
-	void 				clampAttachmentPositions();
-	virtual const LLViewerJointAttachment* attachObject(LLViewerObject *viewer_object);
-	virtual BOOL 		detachObject(LLViewerObject *viewer_object);
-	void				cleanupAttachedMesh( LLViewerObject* pVO );
-	static LLVOAvatar*  findAvatarFromAttachment(LLViewerObject* obj);
-protected:
-	LLViewerJointAttachment* getTargetAttachmentPoint(LLViewerObject* viewer_object);
-	void 				lazyAttach();
-	void				rebuildRiggedAttachments( void );
-
-	//--------------------------------------------------------------------
-	// Map of attachment points, by ID
-	//--------------------------------------------------------------------
-public:
-	S32 				getAttachmentCount(); // Warning: order(N) not order(1) // currently used only by -self
-	typedef std::map<S32, LLViewerJointAttachment*> attachment_map_t;
-	attachment_map_t 								mAttachmentPoints;
-	std::vector<LLPointer<LLViewerObject> > 		mPendingAttachment;
-
-	//--------------------------------------------------------------------
-	// HUD functions
-	//--------------------------------------------------------------------
-public:
-	BOOL 				hasHUDAttachment() const;
-	LLBBox 				getHUDBBox() const;
-	void 				rebuildHUD();
-	void 				resetHUDAttachments();
-	BOOL				canAttachMoreObjects() const;
-	BOOL				canAttachMoreObjects(U32 n) const;
-protected:
-	U32					getNumAttachments() const; // O(N), not O(1)
-
-/**                    Wearables
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    ACTIONS
- **/
-
-	//--------------------------------------------------------------------
-	// Animations
-	//--------------------------------------------------------------------
-public:
-	BOOL 			isAnyAnimationSignaled(const LLUUID *anim_array, const S32 num_anims) const;
-	void 			processAnimationStateChanges();
-protected:
-	BOOL 			processSingleAnimationStateChange(const LLUUID &anim_id, BOOL start);
-	void 			resetAnimations();
-private:
-	LLTimer			mAnimTimer;
-	F32				mTimeLast;	
-
-	//--------------------------------------------------------------------
-	// Animation state data
-	//--------------------------------------------------------------------
-public:
-	typedef std::map<LLUUID, S32>::iterator AnimIterator;
-	std::map<LLUUID, S32> 					mSignaledAnimations; // requested state of Animation name/value
-	std::map<LLUUID, S32> 					mPlayingAnimations; // current state of Animation name/value
-
-	typedef std::multimap<LLUUID, LLUUID> 	AnimationSourceMap;
-	typedef AnimationSourceMap::iterator 	AnimSourceIterator;
-	AnimationSourceMap 						mAnimationSources; // object ids that triggered anim ids
-
-	//--------------------------------------------------------------------
-	// Chat
-	//--------------------------------------------------------------------
-public:
-	void			addChat(const LLChat& chat);
-	void	   		clearChat();
-	void	   		startTyping() { mTyping = TRUE; mTypingTimer.reset(); }
-	void			stopTyping() { mTyping = FALSE; }
-private:
-	BOOL			mVisibleChat;
-
-	//--------------------------------------------------------------------
-	// Lip synch morphs
-	//--------------------------------------------------------------------
-private:
-	bool 		   	mLipSyncActive; // we're morphing for lip sync
-	LLVisualParam* 	mOohMorph; // cached pointers morphs for lip sync
-	LLVisualParam* 	mAahMorph; // cached pointers morphs for lip sync
-
-	//--------------------------------------------------------------------
-	// Flight
-	//--------------------------------------------------------------------
-public:
-	BOOL			mInAir;
-	LLFrameTimer	mTimeInAir;
-
-/**                    Actions
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    PHYSICS
- **/
-
-private:
-	F32 		mSpeedAccum; // measures speed (for diagnostics mostly).
-	BOOL 		mTurning; // controls hysteresis on avatar rotation
-	F32			mSpeed; // misc. animation repeated state
-
-	//--------------------------------------------------------------------
-	// Collision volumes
-	//--------------------------------------------------------------------
-public:
-  	S32			mNumCollisionVolumes;
-	LLViewerJointCollisionVolume* mCollisionVolumes;
-protected:
-	BOOL		allocateCollisionVolumes(U32 num);
-
-	//--------------------------------------------------------------------
-	// Dimensions
-	//--------------------------------------------------------------------
-public:
-	void 		resolveHeightGlobal(const LLVector3d &inPos, LLVector3d &outPos, LLVector3 &outNorm);
-	bool		distanceToGround( const LLVector3d &startPoint, LLVector3d &collisionPoint, F32 distToIntersectionAlongRay );
-	void 		resolveHeightAgent(const LLVector3 &inPos, LLVector3 &outPos, LLVector3 &outNorm);
-	void 		resolveRayCollisionAgent(const LLVector3d start_pt, const LLVector3d end_pt, LLVector3d &out_pos, LLVector3 &out_norm);
-	void 		slamPosition(); // Slam position to transmitted position (for teleport);
-protected:
-	void 		computeBodySize();
-
-	//--------------------------------------------------------------------
-	// Material being stepped on
-	//--------------------------------------------------------------------
-private:
-	BOOL		mStepOnLand;
-	U8			mStepMaterial;
-	LLVector3	mStepObjectVelocity;
-
-/**                    Physics
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    HIERARCHY
- **/
-
-public:
-	virtual BOOL 	setParent(LLViewerObject* parent);
-	virtual void 	addChild(LLViewerObject *childp);
-	virtual void 	removeChild(LLViewerObject *childp);
-
-	//--------------------------------------------------------------------
-	// Sitting
-	//--------------------------------------------------------------------
-public:
-	void			sitDown(BOOL bSitting);
-	BOOL			isSitting(){return mIsSitting;}
-	void 			sitOnObject(LLViewerObject *sit_object);
-	void 			getOffObject();
-private:
-	// set this property only with LLVOAvatar::sitDown method
-	BOOL 			mIsSitting;
-
-/**                    Hierarchy
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    NAME
- **/
-
-public:
-	std::string		getFullname() const; // Returns "FirstName LastName"
-protected:
-	static void		getAnimLabels(LLDynamicArray<std::string>* labels);
-	static void		getAnimNames(LLDynamicArray<std::string>* names);	
-private:
-	std::string		mNameString;		// UTF-8 title + name + status
-	std::string  	mTitle;
-	bool	  		mNameAway;
-	bool	  		mNameBusy;
-	bool	  		mNameMute;
-	bool      		mNameAppearance;
-	bool			mNameFriend;
-	bool			mNameCloud;
-	F32				mNameAlpha;
-	BOOL      		mRenderGroupTitles;
-
-	//--------------------------------------------------------------------
-	// Display the name (then optionally fade it out)
-	//--------------------------------------------------------------------
-public:
-	LLFrameTimer	mChatTimer;
-	LLPointer<LLHUDNameTag> mNameText;
-private:
-	LLFrameTimer	mTimeVisible;
-	std::deque<LLChat> mChats;
-	BOOL			mTyping;
-	LLFrameTimer	mTypingTimer;
-
-/**                    Name
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    SOUNDS
- **/
-
-	//--------------------------------------------------------------------
-	// Voice visualizer
-	//--------------------------------------------------------------------
-public:
-	// Responsible for detecting the user's voice signal (and when the
-	// user speaks, it puts a voice symbol over the avatar's head) and gesticulations
-	LLPointer<LLVoiceVisualizer>  mVoiceVisualizer;
-	int					mCurrentGesticulationLevel;
-
-	//--------------------------------------------------------------------
-	// Step sound
-	//--------------------------------------------------------------------
-protected:
-	const LLUUID& 		getStepSound() const;
-private:
-	// Global table of sound ids per material, and the ground
-	const static LLUUID	sStepSounds[LL_MCODE_END];
-	const static LLUUID	sStepSoundOnLand;
-
-	//--------------------------------------------------------------------
-	// Foot step state (for generating sounds)
-	//--------------------------------------------------------------------
-public:
-	void 				setFootPlane(const LLVector4 &plane) { mFootPlane = plane; }
-	LLVector4			mFootPlane;
-private:
-	BOOL				mWasOnGroundLeft;
-	BOOL				mWasOnGroundRight;
-
-/**                    Sounds
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    DIAGNOSTICS
- **/
-	
-	//--------------------------------------------------------------------
-	// General
-	//--------------------------------------------------------------------
-public:
-	static void			dumpArchetypeXML(void*);
-	static void			dumpBakedStatus();
-	const std::string 	getBakedStatusForPrintout() const;
-	void				dumpAvatarTEs(const std::string& context) const;
-
-	static F32 			sUnbakedTime; // Total seconds with >=1 unbaked avatars
-	static F32 			sUnbakedUpdateTime; // Last time stats were updated (to prevent multiple updates per frame) 
-	static F32 			sGreyTime; // Total seconds with >=1 grey avatars	
-	static F32 			sGreyUpdateTime; // Last time stats were updated (to prevent multiple updates per frame) 
-protected:
-	S32					getUnbakedPixelAreaRank();
-	BOOL				mHasGrey;
-private:
-	F32					mMinPixelArea;
-	F32					mMaxPixelArea;
-	F32					mAdjustedPixelArea;
-	std::string  		mDebugText;
-
-
-	//--------------------------------------------------------------------
-	// Avatar Rez Metrics
-	//--------------------------------------------------------------------
-public:
-	F32				debugGetExistenceTimeElapsedF32() const { return mDebugExistenceTimer.getElapsedTimeF32(); }
-protected:
-	LLFrameTimer	mRuthDebugTimer; // For tracking how long it takes for av to rez
-	LLFrameTimer	mDebugExistenceTimer; // Debugging for how long the avatar has been in memory.
-
-/**                    Diagnostics
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    SUPPORT CLASSES
- **/
-
-protected: // Shared with LLVOAvatarSelf
-
-	struct LLVOAvatarXmlInfo
-	{
-		LLVOAvatarXmlInfo();
-		~LLVOAvatarXmlInfo();
-
-		BOOL 	parseXmlSkeletonNode(LLXmlTreeNode* root);
-		BOOL 	parseXmlMeshNodes(LLXmlTreeNode* root);
-		BOOL 	parseXmlColorNodes(LLXmlTreeNode* root);
-		BOOL 	parseXmlLayerNodes(LLXmlTreeNode* root);
-		BOOL 	parseXmlDriverNodes(LLXmlTreeNode* root);
-		BOOL	parseXmlMorphNodes(LLXmlTreeNode* root);
-
-		struct LLVOAvatarMeshInfo
-		{
-			typedef std::pair<LLPolyMorphTargetInfo*,BOOL> morph_info_pair_t;
-			typedef std::vector<morph_info_pair_t> morph_info_list_t;
-
-			LLVOAvatarMeshInfo() : mLOD(0), mMinPixelArea(.1f) {}
-			~LLVOAvatarMeshInfo()
-			{
-				morph_info_list_t::iterator iter;
-				for (iter = mPolyMorphTargetInfoList.begin(); iter != mPolyMorphTargetInfoList.end(); iter++)
-				{
-					delete iter->first;
-				}
-				mPolyMorphTargetInfoList.clear();
-			}
-
-			std::string mType;
-			S32			mLOD;
-			std::string	mMeshFileName;
-			std::string	mReferenceMeshName;
-			F32			mMinPixelArea;
-			morph_info_list_t mPolyMorphTargetInfoList;
-		};
-		typedef std::vector<LLVOAvatarMeshInfo*> mesh_info_list_t;
-		mesh_info_list_t mMeshInfoList;
-
-		typedef std::vector<LLPolySkeletalDistortionInfo*> skeletal_distortion_info_list_t;
-		skeletal_distortion_info_list_t mSkeletalDistortionInfoList;
-	
-		struct LLVOAvatarAttachmentInfo
-		{
-			LLVOAvatarAttachmentInfo()
-				: mGroup(-1), mAttachmentID(-1), mPieMenuSlice(-1), mVisibleFirstPerson(FALSE),
-				  mIsHUDAttachment(FALSE), mHasPosition(FALSE), mHasRotation(FALSE) {}
-			std::string mName;
-			std::string mJointName;
-			LLVector3 mPosition;
-			LLVector3 mRotationEuler;
-			S32 mGroup;
-			S32 mAttachmentID;
-			S32 mPieMenuSlice;
-			BOOL mVisibleFirstPerson;
-			BOOL mIsHUDAttachment;
-			BOOL mHasPosition;
-			BOOL mHasRotation;
-		};
-		typedef std::vector<LLVOAvatarAttachmentInfo*> attachment_info_list_t;
-		attachment_info_list_t mAttachmentInfoList;
-	
-		LLTexGlobalColorInfo *mTexSkinColorInfo;
-		LLTexGlobalColorInfo *mTexHairColorInfo;
-		LLTexGlobalColorInfo *mTexEyeColorInfo;
-
-		typedef std::vector<LLTexLayerSetInfo*> layer_info_list_t;
-		layer_info_list_t mLayerInfoList;
-
-		typedef std::vector<LLDriverParamInfo*> driver_info_list_t;
-		driver_info_list_t mDriverInfoList;
-
-		struct LLVOAvatarMorphInfo
-		{
-			LLVOAvatarMorphInfo()
-				: mInvert(FALSE) {}
-			std::string mName;
-			std::string mRegion;
-			std::string mLayer;
-			BOOL mInvert;
-		};
-
-		typedef std::vector<LLVOAvatarMorphInfo*> morph_info_list_t;
-		morph_info_list_t	mMorphMaskInfoList;
-	};
-
-	struct LLMaskedMorph
-	{
-		LLMaskedMorph(LLPolyMorphTarget *morph_target, BOOL invert, std::string layer) :
-			mMorphTarget(morph_target), 
-			mInvert(invert),
-			mLayer(layer)
-		{
-			morph_target->addPendingMorphMask();
-		}
-	
-		LLPolyMorphTarget	*mMorphTarget;
-		BOOL				mInvert;
-		std::string			mLayer;
-	};
-
-/**                    Support classes
- **                                                                            **
- *******************************************************************************/
-
-}; // LLVOAvatar
-extern const F32 SELF_ADDITIONAL_PRI;
-extern const S32 MAX_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL;
-
-#endif // LL_VO_AVATAR_H
+/**
+ * @file llvoavatar.h
+ * @brief Declaration of LLVOAvatar class which is a derivation of
+ * LLViewerObject
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLVOAVATAR_H
+#define LL_LLVOAVATAR_H
+
+#include <map>
+#include <deque>
+#include <string>
+#include <vector>
+
+#include <boost/signals2.hpp>
+
+#include "imageids.h"			// IMG_INVISIBLE
+#include "llchat.h"
+#include "lldrawpoolalpha.h"
+#include "llviewerobject.h"
+#include "llcharacter.h"
+#include "llviewerjointmesh.h"
+#include "llviewerjointattachment.h"
+#include "llrendertarget.h"
+#include "llvoavatardefines.h"
+#include "lltexglobalcolor.h"
+#include "lldriverparam.h"
+#include "material_codes.h"		// LL_MCODE_END
+
+extern const LLUUID ANIM_AGENT_BODY_NOISE;
+extern const LLUUID ANIM_AGENT_BREATHE_ROT;
+extern const LLUUID ANIM_AGENT_PHYSICS_MOTION;
+extern const LLUUID ANIM_AGENT_EDITING;
+extern const LLUUID ANIM_AGENT_EYE;
+extern const LLUUID ANIM_AGENT_FLY_ADJUST;
+extern const LLUUID ANIM_AGENT_HAND_MOTION;
+extern const LLUUID ANIM_AGENT_HEAD_ROT;
+extern const LLUUID ANIM_AGENT_PELVIS_FIX;
+extern const LLUUID ANIM_AGENT_TARGET;
+extern const LLUUID ANIM_AGENT_WALK_ADJUST;
+
+class LLTexLayerSet;
+class LLVoiceVisualizer;
+class LLHUDNameTag;
+class LLHUDEffectSpiral;
+class LLTexGlobalColor;
+class LLVOAvatarBoneInfo;
+class LLVOAvatarSkeletonInfo;
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// LLVOAvatar
+// 
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class LLVOAvatar :
+	public LLViewerObject,
+	public LLCharacter,
+	public boost::signals2::trackable
+{
+public:
+	friend class LLVOAvatarSelf;
+protected:
+	struct LLVOAvatarXmlInfo;
+	struct LLMaskedMorph;
+
+/********************************************************************************
+ **                                                                            **
+ **                    INITIALIZATION
+ **/
+
+public:
+	LLVOAvatar(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp);
+	virtual void		markDead();
+	static void			initClass(); // Initialize data that's only init'd once per class.
+	static void			cleanupClass();	// Cleanup data that's only init'd once per class.
+	virtual void 		initInstance(); // Called after construction to initialize the class.
+protected:
+	virtual				~LLVOAvatar();
+	BOOL				loadSkeletonNode();
+	BOOL				loadMeshNodes();
+	virtual BOOL		loadLayersets();
+
+/**                    Initialization
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    INHERITED
+ **/
+
+	//--------------------------------------------------------------------
+	// LLViewerObject interface and related
+	//--------------------------------------------------------------------
+public:
+	virtual void			updateGL();
+	virtual	LLVOAvatar*		asAvatar();
+	virtual U32    	 	 	processUpdateMessage(LLMessageSystem *mesgsys,
+													 void **user_data,
+													 U32 block_num,
+													 const EObjectUpdateType update_type,
+													 LLDataPacker *dp);
+	virtual BOOL   	 	 	idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
+	virtual BOOL   	 	 	updateLOD();
+	BOOL  	 	 	 	 	updateJointLODs();
+	void					updateLODRiggedAttachments( void );
+	virtual BOOL   	 	 	isActive() const; // Whether this object needs to do an idleUpdate.
+	virtual void   	 	 	updateTextures();
+	virtual S32    	 	 	setTETexture(const U8 te, const LLUUID& uuid); // If setting a baked texture, need to request it from a non-local sim.
+	virtual void   	 	 	onShift(const LLVector4a& shift_vector);
+	virtual U32    	 	 	getPartitionType() const;
+	virtual const  	 	 	LLVector3 getRenderPosition() const;
+	virtual void   	 	 	updateDrawable(BOOL force_damped);
+	virtual LLDrawable* 	createDrawable(LLPipeline *pipeline);
+	virtual BOOL   	 	 	updateGeometry(LLDrawable *drawable);
+	virtual void   	 	 	setPixelAreaAndAngle(LLAgent &agent);
+	virtual void   	 	 	updateRegion(LLViewerRegion *regionp);
+	virtual void   	 	 	updateSpatialExtents(LLVector4a& newMin, LLVector4a &newMax);
+	virtual void   	 	 	getSpatialExtents(LLVector4a& newMin, LLVector4a& newMax);
+	virtual BOOL   	 	 	lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
+												 S32 face = -1,                    // which face to check, -1 = ALL_SIDES
+												 BOOL pick_transparent = FALSE,
+												 S32* face_hit = NULL,             // which face was hit
+												 LLVector3* intersection = NULL,   // return the intersection point
+												 LLVector2* tex_coord = NULL,      // return the texture coordinates of the intersection point
+												 LLVector3* normal = NULL,         // return the surface normal at the intersection point
+												 LLVector3* bi_normal = NULL);     // return the surface bi-normal at the intersection point
+	LLViewerObject*	lineSegmentIntersectRiggedAttachments(const LLVector3& start, const LLVector3& end,
+												 S32 face = -1,                    // which face to check, -1 = ALL_SIDES
+												 BOOL pick_transparent = FALSE,
+												 S32* face_hit = NULL,             // which face was hit
+												 LLVector3* intersection = NULL,   // return the intersection point
+												 LLVector2* tex_coord = NULL,      // return the texture coordinates of the intersection point
+												 LLVector3* normal = NULL,         // return the surface normal at the intersection point
+												 LLVector3* bi_normal = NULL);     // return the surface bi-normal at the intersection point
+
+	//--------------------------------------------------------------------
+	// LLCharacter interface and related
+	//--------------------------------------------------------------------
+public:
+	virtual LLVector3    	getCharacterPosition();
+	virtual LLQuaternion 	getCharacterRotation();
+	virtual LLVector3    	getCharacterVelocity();
+	virtual LLVector3    	getCharacterAngularVelocity();
+	virtual LLJoint*		getCharacterJoint(U32 num);
+	virtual BOOL			allocateCharacterJoints(U32 num);
+
+	virtual LLUUID			remapMotionID(const LLUUID& id);
+	virtual BOOL			startMotion(const LLUUID& id, F32 time_offset = 0.f);
+	virtual BOOL			stopMotion(const LLUUID& id, BOOL stop_immediate = FALSE);
+	virtual void			stopMotionFromSource(const LLUUID& source_id);
+	virtual void			requestStopMotion(LLMotion* motion);
+	LLMotion*				findMotion(const LLUUID& id) const;
+	void					startDefaultMotions();
+	void					dumpAnimationState();
+
+	virtual LLJoint*		getJoint(const std::string &name);
+	virtual LLJoint*     	getRootJoint() { return &mRoot; }
+	
+	void					resetJointPositions( void );
+	void					resetJointPositionsToDefault( void );
+	void					resetSpecificJointPosition( const std::string& name );
+	
+	virtual const char*		getAnimationPrefix() { return "avatar"; }
+	virtual const LLUUID&   getID();
+	virtual LLVector3		getVolumePos(S32 joint_index, LLVector3& volume_offset);
+	virtual LLJoint*		findCollisionVolume(U32 volume_id);
+	virtual S32				getCollisionVolumeID(std::string &name);
+	virtual void			addDebugText(const std::string& text);
+	virtual F32          	getTimeDilation();
+	virtual void			getGround(const LLVector3 &inPos, LLVector3 &outPos, LLVector3 &outNorm);
+	virtual F32				getPixelArea() const;
+	virtual LLPolyMesh*		getHeadMesh();
+	virtual LLPolyMesh*		getUpperBodyMesh();
+	virtual LLVector3d		getPosGlobalFromAgent(const LLVector3 &position);
+	virtual LLVector3		getPosAgentFromGlobal(const LLVector3d &position);
+	virtual void			updateVisualParams();
+
+
+/**                    Inherited
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    STATE
+ **/
+
+public:
+	virtual bool 	isSelf() const { return false; } // True if this avatar is for this viewer's agent
+	bool isBuilt() const { return mIsBuilt; }
+
+private: //aligned members
+	LLVector4a	mImpostorExtents[2];
+
+private:
+	BOOL			mSupportsAlphaLayers; // For backwards compatibility, TRUE for 1.23+ clients
+
+	//--------------------------------------------------------------------
+	// Updates
+	//--------------------------------------------------------------------
+public:
+	virtual BOOL 	updateCharacter(LLAgent &agent);
+	void 			idleUpdateVoiceVisualizer(bool voice_enabled);
+	void 			idleUpdateMisc(bool detailed_update);
+	virtual void	idleUpdateAppearanceAnimation();
+	void 			idleUpdateLipSync(bool voice_enabled);
+	void 			idleUpdateLoadingEffect();
+	void 			idleUpdateWindEffect();
+	void 			idleUpdateNameTag(const LLVector3& root_pos_last);
+	void			idleUpdateNameTagText(BOOL new_name);
+	LLVector3		idleUpdateNameTagPosition(const LLVector3& root_pos_last);
+	void			idleUpdateNameTagAlpha(BOOL new_name, F32 alpha);
+	LLColor4		getNameTagColor(bool is_friend);
+	void			clearNameTag();
+	static void		invalidateNameTag(const LLUUID& agent_id);
+	// force all name tags to rebuild, useful when display names turned on/off
+	static void		invalidateNameTags();
+	void			addNameTagLine(const std::string& line, const LLColor4& color, S32 style, const LLFontGL* font);
+	void 			idleUpdateRenderCost();
+	void 			idleUpdateBelowWater();
+
+	//--------------------------------------------------------------------
+	// Static preferences (controlled by user settings/menus)
+	//--------------------------------------------------------------------
+public:
+	static S32		sRenderName;
+	static BOOL		sRenderGroupTitles;
+	static U32		sMaxVisible; //(affected by control "RenderAvatarMaxVisible")
+	static F32		sRenderDistance; //distance at which avatars will render.
+	static BOOL		sShowAnimationDebug; // show animation debug info
+	static BOOL		sUseImpostors; //use impostors for far away avatars
+	static BOOL		sShowFootPlane;	// show foot collision plane reported by server
+	static BOOL		sShowCollisionVolumes;	// show skeletal collision volumes
+	static BOOL		sVisibleInFirstPerson;
+	static S32		sNumLODChangesThisFrame;
+	static S32		sNumVisibleChatBubbles;
+	static BOOL		sDebugInvisible;
+	static BOOL		sShowAttachmentPoints;
+	static F32		sLODFactor; // user-settable LOD factor
+	static F32		sPhysicsLODFactor; // user-settable physics LOD factor
+	static BOOL		sJointDebug; // output total number of joints being touched for each avatar
+	static BOOL		sDebugAvatarRotation;
+
+	//--------------------------------------------------------------------
+	// Region state
+	//--------------------------------------------------------------------
+public:
+	LLHost			getObjectHost() const;
+
+	//--------------------------------------------------------------------
+	// Loading state
+	//--------------------------------------------------------------------
+public:
+	BOOL			isFullyLoaded() const;
+	bool			isTooComplex() const;
+	bool visualParamWeightsAreDefault();
+protected:
+	virtual BOOL	getIsCloud();
+	BOOL			updateIsFullyLoaded();
+	BOOL			processFullyLoadedChange(bool loading);
+	void			updateRuthTimer(bool loading);
+	F32 			calcMorphAmount();
+private:
+	BOOL			mFullyLoaded;
+	BOOL			mPreviousFullyLoaded;
+	BOOL			mFullyLoadedInitialized;
+	S32				mFullyLoadedFrameCounter;
+	S32				mVisualComplexity;
+	LLFrameTimer	mFullyLoadedTimer;
+	LLFrameTimer	mRuthTimer;
+protected:
+	LLFrameTimer    mInvisibleTimer;
+	
+/**                    State
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    SKELETON
+ **/
+
+public:
+	void				updateHeadOffset();
+	F32					getPelvisToFoot() const { return mPelvisToFoot; }
+	void				setPelvisOffset( bool hasOffset, const LLVector3& translation, F32 offset ) ;
+	bool				hasPelvisOffset( void ) { return mHasPelvisOffset; }
+	void				postPelvisSetRecalc( void );
+	void				setPelvisOffset( F32 pelvixFixupAmount );
+
+	bool				mHasPelvisOffset;
+	LLVector3			mPelvisOffset;
+	F32					mLastPelvisToFoot;
+	F32					mPelvisFixup;
+	F32					mLastPelvisFixup;
+
+	LLVector3			mHeadOffset; // current head position
+	LLViewerJoint		mRoot;
+protected:
+	static BOOL			parseSkeletonFile(const std::string& filename);
+	void				buildCharacter();
+	virtual BOOL		loadAvatar();
+
+	BOOL				setupBone(const LLVOAvatarBoneInfo* info, LLViewerJoint* parent, S32 &current_volume_num, S32 &current_joint_num);
+	BOOL				buildSkeleton(const LLVOAvatarSkeletonInfo *info);
+private:
+	BOOL				mIsBuilt; // state of deferred character building
+	S32					mNumJoints;
+	LLViewerJoint*		mSkeleton;
+	
+	//--------------------------------------------------------------------
+	// Pelvis height adjustment members.
+	//--------------------------------------------------------------------
+public:
+	LLVector3			mBodySize;
+	S32					mLastSkeletonSerialNum;
+private:
+	F32					mPelvisToFoot;
+
+	//--------------------------------------------------------------------
+	// Cached pointers to well known joints
+	//--------------------------------------------------------------------
+public:
+	LLViewerJoint* 		mPelvisp;
+	LLViewerJoint* 		mTorsop;
+	LLViewerJoint* 		mChestp;
+	LLViewerJoint* 		mNeckp;
+	LLViewerJoint* 		mHeadp;
+	LLViewerJoint* 		mSkullp;
+	LLViewerJoint* 		mEyeLeftp;
+	LLViewerJoint* 		mEyeRightp;
+	LLViewerJoint* 		mHipLeftp;
+	LLViewerJoint* 		mHipRightp;
+	LLViewerJoint* 		mKneeLeftp;
+	LLViewerJoint* 		mKneeRightp;
+	LLViewerJoint* 		mAnkleLeftp;
+	LLViewerJoint* 		mAnkleRightp;
+	LLViewerJoint* 		mFootLeftp;
+	LLViewerJoint* 		mFootRightp;
+	LLViewerJoint* 		mWristLeftp;
+	LLViewerJoint* 		mWristRightp;
+
+	//--------------------------------------------------------------------
+	// XML parse tree
+	//--------------------------------------------------------------------
+private:
+	static LLXmlTree 	sXMLTree; // avatar config file
+	static LLXmlTree 	sSkeletonXMLTree; // avatar skeleton file
+
+/**                    Skeleton
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    RENDERING
+ **/
+
+public:
+	U32 		renderImpostor(LLColor4U color = LLColor4U(255,255,255,255), S32 diffuse_channel = 0);
+	U32 		renderRigid();
+	U32 		renderSkinned(EAvatarRenderPass pass);
+	F32			getLastSkinTime() { return mLastSkinTime; }
+	U32			renderSkinnedAttachments();
+	U32 		renderTransparent(BOOL first_pass);
+	void 		renderCollisionVolumes();
+	static void	deleteCachedImages(bool clearAll=true);
+	static void	destroyGL();
+	static void	restoreGL();
+	BOOL 		mIsDummy; // for special views
+	S32			mSpecialRenderMode; // special lighting
+private:
+	bool		shouldAlphaMask();
+
+	BOOL 		mNeedsSkin; // avatar has been animated and verts have not been updated
+	F32			mLastSkinTime; //value of gFrameTimeSeconds at last skin update
+
+	S32	 		mUpdatePeriod;
+	S32  		mNumInitFaces; //number of faces generated when creating the avatar drawable, does not inculde splitted faces due to long vertex buffer.
+
+	//--------------------------------------------------------------------
+	// Morph masks
+	//--------------------------------------------------------------------
+public:
+	BOOL 		morphMaskNeedsUpdate(LLVOAvatarDefines::EBakedTextureIndex index = LLVOAvatarDefines::BAKED_NUM_INDICES);
+	void 		addMaskedMorph(LLVOAvatarDefines::EBakedTextureIndex index, LLPolyMorphTarget* morph_target, BOOL invert, std::string layer);
+	void 		applyMorphMask(U8* tex_data, S32 width, S32 height, S32 num_components, LLVOAvatarDefines::EBakedTextureIndex index = LLVOAvatarDefines::BAKED_NUM_INDICES);
+
+	//--------------------------------------------------------------------
+	// Visibility
+	//--------------------------------------------------------------------
+protected:
+	void 		updateVisibility();
+private:
+	U32	 		mVisibilityRank;
+	BOOL 		mVisible;
+	
+	//--------------------------------------------------------------------
+	// Shadowing
+	//--------------------------------------------------------------------
+public:
+	void 		updateShadowFaces();
+	LLDrawable*	mShadow;
+private:
+	LLFace* 	mShadow0Facep;
+	LLFace* 	mShadow1Facep;
+	LLPointer<LLViewerTexture> mShadowImagep;
+
+	//--------------------------------------------------------------------
+	// Impostors
+	//--------------------------------------------------------------------
+public:
+	BOOL 		isImpostor() const;
+	BOOL 	    needsImpostorUpdate() const;
+	const LLVector3& getImpostorOffset() const;
+	const LLVector2& getImpostorDim() const;
+	void 		getImpostorValues(LLVector4a* extents, LLVector3& angle, F32& distance) const;
+	void 		cacheImpostorValues();
+	void 		setImpostorDim(const LLVector2& dim);
+	static void	resetImpostors();
+	static void updateImpostors();
+	LLRenderTarget mImpostor;
+	BOOL		mNeedsImpostorUpdate;
+private:
+	LLVector3	mImpostorOffset;
+	LLVector2	mImpostorDim;
+	BOOL		mNeedsAnimUpdate;
+	LLVector3	mImpostorAngle;
+	F32			mImpostorDistance;
+	F32			mImpostorPixelArea;
+	LLVector3	mLastAnimExtents[2];  
+
+	//--------------------------------------------------------------------
+	// Wind rippling in clothes
+	//--------------------------------------------------------------------
+public:
+	LLVector4	mWindVec;
+	F32			mRipplePhase;
+	BOOL		mBelowWater;
+private:
+	F32			mWindFreq;
+	LLFrameTimer mRippleTimer;
+	F32			mRippleTimeLast;
+	LLVector3	mRippleAccel;
+	LLVector3	mLastVel;
+
+	//--------------------------------------------------------------------
+	// Culling
+	//--------------------------------------------------------------------
+public:
+	static void	cullAvatarsByPixelArea();
+	BOOL		isCulled() const { return mCulled; }
+private:
+	BOOL		mCulled;
+
+	//--------------------------------------------------------------------
+	// Freeze counter
+	//--------------------------------------------------------------------
+public:
+	static void updateFreezeCounter(S32 counter = 0);
+private:
+	static S32  sFreezeCounter;
+
+	//--------------------------------------------------------------------
+	// Constants
+	//--------------------------------------------------------------------
+public:
+	virtual LLViewerTexture::EBoostLevel 	getAvatarBoostLevel() const { return LLViewerTexture::BOOST_AVATAR; }
+	virtual LLViewerTexture::EBoostLevel 	getAvatarBakedBoostLevel() const { return LLViewerTexture::BOOST_AVATAR_BAKED; }
+	virtual S32 						getTexImageSize() const;
+	virtual S32 						getTexImageArea() const { return getTexImageSize()*getTexImageSize(); }
+
+/**                    Rendering
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    TEXTURES
+ **/
+
+	//--------------------------------------------------------------------
+	// Loading status
+	//--------------------------------------------------------------------
+public:
+	virtual BOOL    isTextureDefined(LLVOAvatarDefines::ETextureIndex type, U32 index = 0) const;
+	virtual BOOL	isTextureVisible(LLVOAvatarDefines::ETextureIndex type, U32 index = 0) const;
+	virtual BOOL	isTextureVisible(LLVOAvatarDefines::ETextureIndex type, LLWearable *wearable) const;
+
+protected:
+	BOOL			isFullyBaked();
+	static BOOL		areAllNearbyInstancesBaked(S32& grey_avatars);
+
+	//--------------------------------------------------------------------
+	// Baked textures
+	//--------------------------------------------------------------------
+public:
+	void			releaseComponentTextures(); // ! BACKWARDS COMPATIBILITY !
+protected:
+	static void		onBakedTextureMasksLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
+	static void		onInitialBakedTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
+	static void		onBakedTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
+	virtual void	removeMissingBakedTextures();
+	void			useBakedTexture(const LLUUID& id);
+
+	typedef std::deque<LLMaskedMorph *> 	morph_list_t;
+	struct BakedTextureData
+	{
+		LLUUID								mLastTextureIndex;
+		LLTexLayerSet* 						mTexLayerSet; // Only exists for self
+		bool								mIsLoaded;
+		bool								mIsUsed;
+		LLVOAvatarDefines::ETextureIndex 	mTextureIndex;
+		U32									mMaskTexName;
+		// Stores pointers to the joint meshes that this baked texture deals with
+		std::vector< LLViewerJointMesh * > 	mMeshes;  // std::vector<LLViewerJointMesh> mJoints[i]->mMeshParts
+		morph_list_t						mMaskedMorphs;
+	};
+	typedef std::vector<BakedTextureData> 	bakedtexturedata_vec_t;
+	bakedtexturedata_vec_t 					mBakedTextureDatas;
+	LLLoadedCallbackEntry::source_callback_list_t mCallbackTextureList ; 
+	BOOL mLoadedCallbacksPaused;
+	//--------------------------------------------------------------------
+	// Local Textures
+	//--------------------------------------------------------------------
+protected:
+	virtual void	setLocalTexture(LLVOAvatarDefines::ETextureIndex type, LLViewerTexture* tex, BOOL baked_version_exits, U32 index = 0);
+	virtual void	addLocalTextureStats(LLVOAvatarDefines::ETextureIndex type, LLViewerFetchedTexture* imagep, F32 texel_area_ratio, BOOL rendered, BOOL covered_by_baked, U32 index = 0);
+	// MULTI-WEARABLE: make self-only?
+	virtual void	setBakedReady(LLVOAvatarDefines::ETextureIndex type, BOOL baked_version_exists, U32 index = 0);
+
+	//--------------------------------------------------------------------
+	// Texture accessors
+	//--------------------------------------------------------------------
+private:
+	virtual	void				setImage(const U8 te, LLViewerTexture *imagep, const U32 index); 
+	virtual LLViewerTexture*	getImage(const U8 te, const U32 index) const;
+
+	virtual const LLTextureEntry* getTexEntry(const U8 te_num) const;
+	virtual void setTexEntry(const U8 index, const LLTextureEntry &te);
+
+	void checkTextureLoading() ;
+	//--------------------------------------------------------------------
+	// Layers
+	//--------------------------------------------------------------------
+protected:
+	void			deleteLayerSetCaches(bool clearAll = true);
+	void			addBakedTextureStats(LLViewerFetchedTexture* imagep, F32 pixel_area, F32 texel_area_ratio, S32 boost_level);
+
+	//--------------------------------------------------------------------
+	// Composites
+	//--------------------------------------------------------------------
+public:
+	virtual void	invalidateComposite(LLTexLayerSet* layerset, BOOL upload_result);
+	virtual void	invalidateAll();
+	virtual void	setCompositeUpdatesEnabled(bool b) {}
+	virtual void 	setCompositeUpdatesEnabled(U32 index, bool b) {}
+	virtual bool 	isCompositeUpdateEnabled(U32 index) { return false; }
+
+	//--------------------------------------------------------------------
+	// Static texture/mesh/baked dictionary
+	//--------------------------------------------------------------------
+public:
+	static BOOL 	isIndexLocalTexture(LLVOAvatarDefines::ETextureIndex i);
+	static BOOL 	isIndexBakedTexture(LLVOAvatarDefines::ETextureIndex i);
+private:
+	static const LLVOAvatarDefines::LLVOAvatarDictionary *getDictionary() { return sAvatarDictionary; }
+	static LLVOAvatarDefines::LLVOAvatarDictionary* sAvatarDictionary;
+	static LLVOAvatarSkeletonInfo* 					sAvatarSkeletonInfo;
+	static LLVOAvatarXmlInfo* 						sAvatarXmlInfo;
+
+	//--------------------------------------------------------------------
+	// Messaging
+	//--------------------------------------------------------------------
+public:
+	void 			onFirstTEMessageReceived();
+private:
+	BOOL			mFirstTEMessageReceived;
+	BOOL			mFirstAppearanceMessageReceived;
+	
+/**                    Textures
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    MESHES
+ **/
+
+public:
+	void 			updateMeshTextures();
+	void 			updateSexDependentLayerSets(BOOL upload_bake);
+	void 			dirtyMesh(); // Dirty the avatar mesh
+	void 			updateMeshData();
+protected:
+	void 			releaseMeshData();
+	virtual void restoreMeshData();
+private:
+	void 			dirtyMesh(S32 priority); // Dirty the avatar mesh, with priority
+	S32 			mDirtyMesh; // 0 -- not dirty, 1 -- morphed, 2 -- LOD
+	BOOL			mMeshTexturesDirty;
+
+	typedef std::multimap<std::string, LLPolyMesh*> polymesh_map_t;
+	polymesh_map_t 									mMeshes;
+	std::vector<LLViewerJoint *> 					mMeshLOD;
+
+	//--------------------------------------------------------------------
+	// Destroy invisible mesh
+	//--------------------------------------------------------------------
+protected:
+	BOOL			mMeshValid;
+	LLFrameTimer	mMeshInvisibleTime;
+
+/**                    Meshes
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    APPEARANCE
+ **/
+
+public:
+	void 			processAvatarAppearance(LLMessageSystem* mesgsys);
+	void 			hideSkirt();
+	void			startAppearanceAnimation();
+	
+	//--------------------------------------------------------------------
+	// Appearance morphing
+	//--------------------------------------------------------------------
+public:
+	BOOL			getIsAppearanceAnimating() const { return mAppearanceAnimating; }
+private:
+	BOOL			mAppearanceAnimating;
+	LLFrameTimer	mAppearanceMorphTimer;
+	F32				mLastAppearanceBlendTime;
+
+	//--------------------------------------------------------------------
+	// Clothing colors (convenience functions to access visual parameters)
+	//--------------------------------------------------------------------
+public:
+	void			setClothesColor(LLVOAvatarDefines::ETextureIndex te, const LLColor4& new_color, BOOL upload_bake);
+	LLColor4		getClothesColor(LLVOAvatarDefines::ETextureIndex te);
+	static BOOL			teToColorParams(LLVOAvatarDefines::ETextureIndex te, U32 *param_name);
+
+	//--------------------------------------------------------------------
+	// Global colors
+	//--------------------------------------------------------------------
+public:
+	LLColor4		getGlobalColor(const std::string& color_name ) const;
+	void			onGlobalColorChanged(const LLTexGlobalColor* global_color, BOOL upload_bake);
+private:
+	LLTexGlobalColor* mTexSkinColor;
+	LLTexGlobalColor* mTexHairColor;
+	LLTexGlobalColor* mTexEyeColor;
+
+	//--------------------------------------------------------------------
+	// Visibility
+	//--------------------------------------------------------------------
+public:
+	BOOL			isVisible() const;
+	void			setVisibilityRank(U32 rank);
+	U32				getVisibilityRank()  const { return mVisibilityRank; } // unused
+	static S32 		sNumVisibleAvatars; // Number of instances of this class
+	static LLColor4 getDummyColor();
+/**                    Appearance
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    WEARABLES
+ **/
+
+public:
+	virtual BOOL			isWearingWearableType(LLWearableType::EType type ) const;
+	
+	//--------------------------------------------------------------------
+	// Attachments
+	//--------------------------------------------------------------------
+public:
+	void 				clampAttachmentPositions();
+	virtual const LLViewerJointAttachment* attachObject(LLViewerObject *viewer_object);
+	virtual BOOL 		detachObject(LLViewerObject *viewer_object);
+	void				cleanupAttachedMesh( LLViewerObject* pVO );
+	static LLVOAvatar*  findAvatarFromAttachment(LLViewerObject* obj);
+protected:
+	LLViewerJointAttachment* getTargetAttachmentPoint(LLViewerObject* viewer_object);
+	void 				lazyAttach();
+	void				rebuildRiggedAttachments( void );
+
+	//--------------------------------------------------------------------
+	// Map of attachment points, by ID
+	//--------------------------------------------------------------------
+public:
+	S32 				getAttachmentCount(); // Warning: order(N) not order(1) // currently used only by -self
+	typedef std::map<S32, LLViewerJointAttachment*> attachment_map_t;
+	attachment_map_t 								mAttachmentPoints;
+	std::vector<LLPointer<LLViewerObject> > 		mPendingAttachment;
+
+	//--------------------------------------------------------------------
+	// HUD functions
+	//--------------------------------------------------------------------
+public:
+	BOOL 				hasHUDAttachment() const;
+	LLBBox 				getHUDBBox() const;
+	void 				rebuildHUD();
+	void 				resetHUDAttachments();
+	BOOL				canAttachMoreObjects() const;
+	BOOL				canAttachMoreObjects(U32 n) const;
+protected:
+	U32					getNumAttachments() const; // O(N), not O(1)
+
+/**                    Wearables
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    ACTIONS
+ **/
+
+	//--------------------------------------------------------------------
+	// Animations
+	//--------------------------------------------------------------------
+public:
+	BOOL 			isAnyAnimationSignaled(const LLUUID *anim_array, const S32 num_anims) const;
+	void 			processAnimationStateChanges();
+protected:
+	BOOL 			processSingleAnimationStateChange(const LLUUID &anim_id, BOOL start);
+	void 			resetAnimations();
+private:
+	LLTimer			mAnimTimer;
+	F32				mTimeLast;	
+
+	//--------------------------------------------------------------------
+	// Animation state data
+	//--------------------------------------------------------------------
+public:
+	typedef std::map<LLUUID, S32>::iterator AnimIterator;
+	std::map<LLUUID, S32> 					mSignaledAnimations; // requested state of Animation name/value
+	std::map<LLUUID, S32> 					mPlayingAnimations; // current state of Animation name/value
+
+	typedef std::multimap<LLUUID, LLUUID> 	AnimationSourceMap;
+	typedef AnimationSourceMap::iterator 	AnimSourceIterator;
+	AnimationSourceMap 						mAnimationSources; // object ids that triggered anim ids
+
+	//--------------------------------------------------------------------
+	// Chat
+	//--------------------------------------------------------------------
+public:
+	void			addChat(const LLChat& chat);
+	void	   		clearChat();
+	void	   		startTyping() { mTyping = TRUE; mTypingTimer.reset(); }
+	void			stopTyping() { mTyping = FALSE; }
+private:
+	BOOL			mVisibleChat;
+
+	//--------------------------------------------------------------------
+	// Lip synch morphs
+	//--------------------------------------------------------------------
+private:
+	bool 		   	mLipSyncActive; // we're morphing for lip sync
+	LLVisualParam* 	mOohMorph; // cached pointers morphs for lip sync
+	LLVisualParam* 	mAahMorph; // cached pointers morphs for lip sync
+
+	//--------------------------------------------------------------------
+	// Flight
+	//--------------------------------------------------------------------
+public:
+	BOOL			mInAir;
+	LLFrameTimer	mTimeInAir;
+
+/**                    Actions
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    PHYSICS
+ **/
+
+private:
+	F32 		mSpeedAccum; // measures speed (for diagnostics mostly).
+	BOOL 		mTurning; // controls hysteresis on avatar rotation
+	F32			mSpeed; // misc. animation repeated state
+
+	//--------------------------------------------------------------------
+	// Collision volumes
+	//--------------------------------------------------------------------
+public:
+  	S32			mNumCollisionVolumes;
+	LLViewerJointCollisionVolume* mCollisionVolumes;
+protected:
+	BOOL		allocateCollisionVolumes(U32 num);
+
+	//--------------------------------------------------------------------
+	// Dimensions
+	//--------------------------------------------------------------------
+public:
+	void 		resolveHeightGlobal(const LLVector3d &inPos, LLVector3d &outPos, LLVector3 &outNorm);
+	bool		distanceToGround( const LLVector3d &startPoint, LLVector3d &collisionPoint, F32 distToIntersectionAlongRay );
+	void 		resolveHeightAgent(const LLVector3 &inPos, LLVector3 &outPos, LLVector3 &outNorm);
+	void 		resolveRayCollisionAgent(const LLVector3d start_pt, const LLVector3d end_pt, LLVector3d &out_pos, LLVector3 &out_norm);
+	void 		slamPosition(); // Slam position to transmitted position (for teleport);
+protected:
+	void 		computeBodySize();
+
+	//--------------------------------------------------------------------
+	// Material being stepped on
+	//--------------------------------------------------------------------
+private:
+	BOOL		mStepOnLand;
+	U8			mStepMaterial;
+	LLVector3	mStepObjectVelocity;
+
+/**                    Physics
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    HIERARCHY
+ **/
+
+public:
+	virtual BOOL 	setParent(LLViewerObject* parent);
+	virtual void 	addChild(LLViewerObject *childp);
+	virtual void 	removeChild(LLViewerObject *childp);
+
+	//--------------------------------------------------------------------
+	// Sitting
+	//--------------------------------------------------------------------
+public:
+	void			sitDown(BOOL bSitting);
+	BOOL			isSitting(){return mIsSitting;}
+	void 			sitOnObject(LLViewerObject *sit_object);
+	void 			getOffObject();
+private:
+	// set this property only with LLVOAvatar::sitDown method
+	BOOL 			mIsSitting;
+
+/**                    Hierarchy
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    NAME
+ **/
+
+public:
+	std::string		getFullname() const; // Returns "FirstName LastName"
+protected:
+	static void		getAnimLabels(LLDynamicArray<std::string>* labels);
+	static void		getAnimNames(LLDynamicArray<std::string>* names);	
+private:
+	std::string		mNameString;		// UTF-8 title + name + status
+	std::string  	mTitle;
+	bool	  		mNameAway;
+	bool	  		mNameBusy;
+	bool	  		mNameMute;
+	bool      		mNameAppearance;
+	bool			mNameFriend;
+	bool			mNameCloud;
+	F32				mNameAlpha;
+	BOOL      		mRenderGroupTitles;
+
+	//--------------------------------------------------------------------
+	// Display the name (then optionally fade it out)
+	//--------------------------------------------------------------------
+public:
+	LLFrameTimer	mChatTimer;
+	LLPointer<LLHUDNameTag> mNameText;
+private:
+	LLFrameTimer	mTimeVisible;
+	std::deque<LLChat> mChats;
+	BOOL			mTyping;
+	LLFrameTimer	mTypingTimer;
+
+/**                    Name
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    SOUNDS
+ **/
+
+	//--------------------------------------------------------------------
+	// Voice visualizer
+	//--------------------------------------------------------------------
+public:
+	// Responsible for detecting the user's voice signal (and when the
+	// user speaks, it puts a voice symbol over the avatar's head) and gesticulations
+	LLPointer<LLVoiceVisualizer>  mVoiceVisualizer;
+	int					mCurrentGesticulationLevel;
+
+	//--------------------------------------------------------------------
+	// Step sound
+	//--------------------------------------------------------------------
+protected:
+	const LLUUID& 		getStepSound() const;
+private:
+	// Global table of sound ids per material, and the ground
+	const static LLUUID	sStepSounds[LL_MCODE_END];
+	const static LLUUID	sStepSoundOnLand;
+
+	//--------------------------------------------------------------------
+	// Foot step state (for generating sounds)
+	//--------------------------------------------------------------------
+public:
+	void 				setFootPlane(const LLVector4 &plane) { mFootPlane = plane; }
+	LLVector4			mFootPlane;
+private:
+	BOOL				mWasOnGroundLeft;
+	BOOL				mWasOnGroundRight;
+
+/**                    Sounds
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    DIAGNOSTICS
+ **/
+	
+	//--------------------------------------------------------------------
+	// General
+	//--------------------------------------------------------------------
+public:
+	static void			dumpArchetypeXML(void*);
+	static void			dumpBakedStatus();
+	const std::string 	getBakedStatusForPrintout() const;
+	void				dumpAvatarTEs(const std::string& context) const;
+
+	static F32 			sUnbakedTime; // Total seconds with >=1 unbaked avatars
+	static F32 			sUnbakedUpdateTime; // Last time stats were updated (to prevent multiple updates per frame) 
+	static F32 			sGreyTime; // Total seconds with >=1 grey avatars	
+	static F32 			sGreyUpdateTime; // Last time stats were updated (to prevent multiple updates per frame) 
+protected:
+	S32					getUnbakedPixelAreaRank();
+	BOOL				mHasGrey;
+private:
+	F32					mMinPixelArea;
+	F32					mMaxPixelArea;
+	F32					mAdjustedPixelArea;
+	std::string  		mDebugText;
+
+
+	//--------------------------------------------------------------------
+	// Avatar Rez Metrics
+	//--------------------------------------------------------------------
+public:
+	F32				debugGetExistenceTimeElapsedF32() const { return mDebugExistenceTimer.getElapsedTimeF32(); }
+protected:
+	LLFrameTimer	mRuthDebugTimer; // For tracking how long it takes for av to rez
+	LLFrameTimer	mDebugExistenceTimer; // Debugging for how long the avatar has been in memory.
+
+/**                    Diagnostics
+ **                                                                            **
+ *******************************************************************************/
+
+/********************************************************************************
+ **                                                                            **
+ **                    SUPPORT CLASSES
+ **/
+
+protected: // Shared with LLVOAvatarSelf
+
+	struct LLVOAvatarXmlInfo
+	{
+		LLVOAvatarXmlInfo();
+		~LLVOAvatarXmlInfo();
+
+		BOOL 	parseXmlSkeletonNode(LLXmlTreeNode* root);
+		BOOL 	parseXmlMeshNodes(LLXmlTreeNode* root);
+		BOOL 	parseXmlColorNodes(LLXmlTreeNode* root);
+		BOOL 	parseXmlLayerNodes(LLXmlTreeNode* root);
+		BOOL 	parseXmlDriverNodes(LLXmlTreeNode* root);
+		BOOL	parseXmlMorphNodes(LLXmlTreeNode* root);
+
+		struct LLVOAvatarMeshInfo
+		{
+			typedef std::pair<LLPolyMorphTargetInfo*,BOOL> morph_info_pair_t;
+			typedef std::vector<morph_info_pair_t> morph_info_list_t;
+
+			LLVOAvatarMeshInfo() : mLOD(0), mMinPixelArea(.1f) {}
+			~LLVOAvatarMeshInfo()
+			{
+				morph_info_list_t::iterator iter;
+				for (iter = mPolyMorphTargetInfoList.begin(); iter != mPolyMorphTargetInfoList.end(); iter++)
+				{
+					delete iter->first;
+				}
+				mPolyMorphTargetInfoList.clear();
+			}
+
+			std::string mType;
+			S32			mLOD;
+			std::string	mMeshFileName;
+			std::string	mReferenceMeshName;
+			F32			mMinPixelArea;
+			morph_info_list_t mPolyMorphTargetInfoList;
+		};
+		typedef std::vector<LLVOAvatarMeshInfo*> mesh_info_list_t;
+		mesh_info_list_t mMeshInfoList;
+
+		typedef std::vector<LLPolySkeletalDistortionInfo*> skeletal_distortion_info_list_t;
+		skeletal_distortion_info_list_t mSkeletalDistortionInfoList;
+	
+		struct LLVOAvatarAttachmentInfo
+		{
+			LLVOAvatarAttachmentInfo()
+				: mGroup(-1), mAttachmentID(-1), mPieMenuSlice(-1), mVisibleFirstPerson(FALSE),
+				  mIsHUDAttachment(FALSE), mHasPosition(FALSE), mHasRotation(FALSE) {}
+			std::string mName;
+			std::string mJointName;
+			LLVector3 mPosition;
+			LLVector3 mRotationEuler;
+			S32 mGroup;
+			S32 mAttachmentID;
+			S32 mPieMenuSlice;
+			BOOL mVisibleFirstPerson;
+			BOOL mIsHUDAttachment;
+			BOOL mHasPosition;
+			BOOL mHasRotation;
+		};
+		typedef std::vector<LLVOAvatarAttachmentInfo*> attachment_info_list_t;
+		attachment_info_list_t mAttachmentInfoList;
+	
+		LLTexGlobalColorInfo *mTexSkinColorInfo;
+		LLTexGlobalColorInfo *mTexHairColorInfo;
+		LLTexGlobalColorInfo *mTexEyeColorInfo;
+
+		typedef std::vector<LLTexLayerSetInfo*> layer_info_list_t;
+		layer_info_list_t mLayerInfoList;
+
+		typedef std::vector<LLDriverParamInfo*> driver_info_list_t;
+		driver_info_list_t mDriverInfoList;
+
+		struct LLVOAvatarMorphInfo
+		{
+			LLVOAvatarMorphInfo()
+				: mInvert(FALSE) {}
+			std::string mName;
+			std::string mRegion;
+			std::string mLayer;
+			BOOL mInvert;
+		};
+
+		typedef std::vector<LLVOAvatarMorphInfo*> morph_info_list_t;
+		morph_info_list_t	mMorphMaskInfoList;
+	};
+
+	struct LLMaskedMorph
+	{
+		LLMaskedMorph(LLPolyMorphTarget *morph_target, BOOL invert, std::string layer) :
+			mMorphTarget(morph_target), 
+			mInvert(invert),
+			mLayer(layer)
+		{
+			morph_target->addPendingMorphMask();
+		}
+	
+		LLPolyMorphTarget	*mMorphTarget;
+		BOOL				mInvert;
+		std::string			mLayer;
+	};
+
+/**                    Support classes
+ **                                                                            **
+ *******************************************************************************/
+
+}; // LLVOAvatar
+extern const F32 SELF_ADDITIONAL_PRI;
+extern const S32 MAX_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL;
+
+#endif // LL_VO_AVATAR_H
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 5c1694078c..eac2f3d1b0 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -1,5062 +1,5062 @@
-/** 
- * @file llvovolume.cpp
- * @brief LLVOVolume class implementation
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// A "volume" is a box, cylinder, sphere, or other primitive shape.
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llvovolume.h"
-
-#include <sstream>
-
-#include "llviewercontrol.h"
-#include "lldir.h"
-#include "llflexibleobject.h"
-#include "llfloatertools.h"
-#include "llmaterialtable.h"
-#include "llprimitive.h"
-#include "llvolume.h"
-#include "llvolumeoctree.h"
-#include "llvolumemgr.h"
-#include "llvolumemessage.h"
-#include "material_codes.h"
-#include "message.h"
-#include "llpluginclassmedia.h" // for code in the mediaEvent handler
-#include "object_flags.h"
-#include "llagentconstants.h"
-#include "lldrawable.h"
-#include "lldrawpoolavatar.h"
-#include "lldrawpoolbump.h"
-#include "llface.h"
-#include "llspatialpartition.h"
-#include "llhudmanager.h"
-#include "llflexibleobject.h"
-#include "llsky.h"
-#include "lltexturefetch.h"
-#include "llvector4a.h"
-#include "llviewercamera.h"
-#include "llviewertexturelist.h"
-#include "llviewerobjectlist.h"
-#include "llviewerregion.h"
-#include "llviewertextureanim.h"
-#include "llworld.h"
-#include "llselectmgr.h"
-#include "pipeline.h"
-#include "llsdutil.h"
-#include "llmatrix4a.h"
-#include "llmediaentry.h"
-#include "llmediadataclient.h"
-#include "llmeshrepository.h"
-#include "llagent.h"
-#include "llviewermediafocus.h"
-#include "lldatapacker.h"
-#include "llviewershadermgr.h"
-#include "llvoavatar.h"
-#include "llvocache.h"
-
-const S32 MIN_QUIET_FRAMES_COALESCE = 30;
-const F32 FORCE_SIMPLE_RENDER_AREA = 512.f;
-const F32 FORCE_CULL_AREA = 8.f;
-const F32 MAX_LOD_DISTANCE = 24.f;
-
-
-BOOL gAnimateTextures = TRUE;
-//extern BOOL gHideSelectedObjects;
-
-F32 LLVOVolume::sLODFactor = 1.f;
-F32	LLVOVolume::sLODSlopDistanceFactor = 0.5f; //Changing this to zero, effectively disables the LOD transition slop 
-F32 LLVOVolume::sDistanceFactor = 1.0f;
-S32 LLVOVolume::sNumLODChanges = 0;
-S32 LLVOVolume::mRenderComplexity_last = 0;
-S32 LLVOVolume::mRenderComplexity_current = 0;
-LLPointer<LLObjectMediaDataClient> LLVOVolume::sObjectMediaClient = NULL;
-LLPointer<LLObjectMediaNavigateClient> LLVOVolume::sObjectMediaNavigateClient = NULL;
-
-static LLFastTimer::DeclareTimer FTM_GEN_TRIANGLES("Generate Triangles");
-static LLFastTimer::DeclareTimer FTM_GEN_VOLUME("Generate Volumes");
-static LLFastTimer::DeclareTimer FTM_VOLUME_TEXTURES("Volume Textures");
-
-// Implementation class of LLMediaDataClientObject.  See llmediadataclient.h
-class LLMediaDataClientObjectImpl : public LLMediaDataClientObject
-{
-public:
-	LLMediaDataClientObjectImpl(LLVOVolume *obj, bool isNew) : mObject(obj), mNew(isNew) 
-	{
-		mObject->addMDCImpl();
-	}
-	~LLMediaDataClientObjectImpl()
-	{
-		mObject->removeMDCImpl();
-	}
-	
-	virtual U8 getMediaDataCount() const 
-		{ return mObject->getNumTEs(); }
-
-	virtual LLSD getMediaDataLLSD(U8 index) const 
-		{
-			LLSD result;
-			LLTextureEntry *te = mObject->getTE(index); 
-			if (NULL != te)
-			{
-				llassert((te->getMediaData() != NULL) == te->hasMedia());
-				if (te->getMediaData() != NULL)
-				{
-					result = te->getMediaData()->asLLSD();
-					// XXX HACK: workaround bug in asLLSD() where whitelist is not set properly
-					// See DEV-41949
-					if (!result.has(LLMediaEntry::WHITELIST_KEY))
-					{
-						result[LLMediaEntry::WHITELIST_KEY] = LLSD::emptyArray();
-					}
-				}
-			}
-			return result;
-		}
-	virtual bool isCurrentMediaUrl(U8 index, const std::string &url) const
-		{
-			LLTextureEntry *te = mObject->getTE(index); 
-			if (te)
-			{
-				if (te->getMediaData())
-				{
-					return (te->getMediaData()->getCurrentURL() == url);
-				}
-			}
-			return url.empty();
-		}
-
-	virtual LLUUID getID() const
-		{ return mObject->getID(); }
-
-	virtual void mediaNavigateBounceBack(U8 index)
-		{ mObject->mediaNavigateBounceBack(index); }
-	
-	virtual bool hasMedia() const
-		{ return mObject->hasMedia(); }
-	
-	virtual void updateObjectMediaData(LLSD const &data, const std::string &version_string) 
-		{ mObject->updateObjectMediaData(data, version_string); }
-	
-	virtual F64 getMediaInterest() const 
-		{ 
-			F64 interest = mObject->getTotalMediaInterest();
-			if (interest < (F64)0.0)
-			{
-				// media interest not valid yet, try pixel area
-				interest = mObject->getPixelArea();
-				// HACK: force recalculation of pixel area if interest is the "magic default" of 1024.
-				if (interest == 1024.f)
-				{
-					const_cast<LLVOVolume*>(static_cast<LLVOVolume*>(mObject))->setPixelAreaAndAngle(gAgent);
-					interest = mObject->getPixelArea();
-				}
-			}
-			return interest; 
-		}
-	
-	virtual bool isInterestingEnough() const
-		{
-			return LLViewerMedia::isInterestingEnough(mObject, getMediaInterest());
-		}
-
-	virtual std::string getCapabilityUrl(const std::string &name) const
-		{ return mObject->getRegion()->getCapability(name); }
-	
-	virtual bool isDead() const
-		{ return mObject->isDead(); }
-	
-	virtual U32 getMediaVersion() const
-		{ return LLTextureEntry::getVersionFromMediaVersionString(mObject->getMediaURL()); }
-	
-	virtual bool isNew() const
-		{ return mNew; }
-
-private:
-	LLPointer<LLVOVolume> mObject;
-	bool mNew;
-};
-
-
-LLVOVolume::LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
-	: LLViewerObject(id, pcode, regionp),
-	  mVolumeImpl(NULL)
-{
-	mTexAnimMode = 0;
-	mRelativeXform.setIdentity();
-	mRelativeXformInvTrans.setIdentity();
-
-	mFaceMappingChanged = FALSE;
-	mLOD = MIN_LOD;
-	mTextureAnimp = NULL;
-	mVolumeChanged = FALSE;
-	mVObjRadius = LLVector3(1,1,0.5f).length();
-	mNumFaces = 0;
-	mLODChanged = FALSE;
-	mSculptChanged = FALSE;
-	mSpotLightPriority = 0.f;
-
-	mMediaImplList.resize(getNumTEs());
-	mLastFetchedMediaVersion = -1;
-	mIndexInTex = 0;
-	mMDCImplCount = 0;
-}
-
-LLVOVolume::~LLVOVolume()
-{
-	delete mTextureAnimp;
-	mTextureAnimp = NULL;
-	delete mVolumeImpl;
-	mVolumeImpl = NULL;
-
-	if(!mMediaImplList.empty())
-	{
-		for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
-		{
-			if(mMediaImplList[i].notNull())
-			{
-				mMediaImplList[i]->removeObject(this) ;
-			}
-		}
-	}
-}
-
-void LLVOVolume::markDead()
-{
-	if (!mDead)
-	{
-		if(getMDCImplCount() > 0)
-		{
-			LLMediaDataClientObject::ptr_t obj = new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false);
-			if (sObjectMediaClient) sObjectMediaClient->removeFromQueue(obj);
-			if (sObjectMediaNavigateClient) sObjectMediaNavigateClient->removeFromQueue(obj);
-		}
-		
-		// Detach all media impls from this object
-		for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
-		{
-			removeMediaImpl(i);
-		}
-
-		if (mSculptTexture.notNull())
-		{
-			mSculptTexture->removeVolume(this);
-		}
-	}
-	
-	LLViewerObject::markDead();
-}
-
-
-// static
-void LLVOVolume::initClass()
-{
-	// gSavedSettings better be around
-	if (gSavedSettings.getBOOL("PrimMediaMasterEnabled"))
-	{
-		const F32 queue_timer_delay = gSavedSettings.getF32("PrimMediaRequestQueueDelay");
-		const F32 retry_timer_delay = gSavedSettings.getF32("PrimMediaRetryTimerDelay");
-		const U32 max_retries = gSavedSettings.getU32("PrimMediaMaxRetries");
-		const U32 max_sorted_queue_size = gSavedSettings.getU32("PrimMediaMaxSortedQueueSize");
-		const U32 max_round_robin_queue_size = gSavedSettings.getU32("PrimMediaMaxRoundRobinQueueSize");
-		sObjectMediaClient = new LLObjectMediaDataClient(queue_timer_delay, retry_timer_delay, max_retries, 
-														 max_sorted_queue_size, max_round_robin_queue_size);
-		sObjectMediaNavigateClient = new LLObjectMediaNavigateClient(queue_timer_delay, retry_timer_delay, 
-																	 max_retries, max_sorted_queue_size, max_round_robin_queue_size);
-	}
-}
-
-// static
-void LLVOVolume::cleanupClass()
-{
-    sObjectMediaClient = NULL;
-    sObjectMediaNavigateClient = NULL;
-}
-
-U32 LLVOVolume::processUpdateMessage(LLMessageSystem *mesgsys,
-										  void **user_data,
-										  U32 block_num, EObjectUpdateType update_type,
-										  LLDataPacker *dp)
-{
-	LLColor4U color;
-	const S32 teDirtyBits = (TEM_CHANGE_TEXTURE|TEM_CHANGE_COLOR|TEM_CHANGE_MEDIA);
-
-	// Do base class updates...
-	U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
-
-	LLUUID sculpt_id;
-	U8 sculpt_type = 0;
-	if (isSculpted())
-	{
-		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
-		sculpt_id = sculpt_params->getSculptTexture();
-		sculpt_type = sculpt_params->getSculptType();
-	}
-
-	if (!dp)
-	{
-		if (update_type == OUT_FULL)
-		{
-			////////////////////////////////
-			//
-			// Unpack texture animation data
-			//
-			//
-
-			if (mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureAnim))
-			{
-				if (!mTextureAnimp)
-				{
-					mTextureAnimp = new LLViewerTextureAnim();
-				}
-				else
-				{
-					if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
-					{
-						mTextureAnimp->reset();
-					}
-				}
-				mTexAnimMode = 0;
-				mTextureAnimp->unpackTAMessage(mesgsys, block_num);
-			}
-			else
-			{
-				if (mTextureAnimp)
-				{
-					delete mTextureAnimp;
-					mTextureAnimp = NULL;
-					gPipeline.markTextured(mDrawable);
-					mFaceMappingChanged = TRUE;
-					mTexAnimMode = 0;
-				}
-			}
-
-			// Unpack volume data
-			LLVolumeParams volume_params;
-			LLVolumeMessage::unpackVolumeParams(&volume_params, mesgsys, _PREHASH_ObjectData, block_num);
-			volume_params.setSculptID(sculpt_id, sculpt_type);
-
-			if (setVolume(volume_params, 0))
-			{
-				markForUpdate(TRUE);
-			}
-		}
-
-		// Sigh, this needs to be done AFTER the volume is set as well, otherwise bad stuff happens...
-		////////////////////////////
-		//
-		// Unpack texture entry data
-		//
-
-		S32 result = unpackTEMessage(mesgsys, _PREHASH_ObjectData, block_num);
-		if (result & teDirtyBits)
-		{
-			updateTEData();
-		}
-		if (result & TEM_CHANGE_MEDIA)
-		{
-			retval |= MEDIA_FLAGS_CHANGED;
-		}
-	}
-	else
-	{
-		// CORY TO DO: Figure out how to get the value here
-		if (update_type != OUT_TERSE_IMPROVED)
-		{
-			LLVolumeParams volume_params;
-			BOOL res = LLVolumeMessage::unpackVolumeParams(&volume_params, *dp);
-			if (!res)
-			{
-				llwarns << "Bogus volume parameters in object " << getID() << llendl;
-				llwarns << getRegion()->getOriginGlobal() << llendl;
-			}
-
-			volume_params.setSculptID(sculpt_id, sculpt_type);
-
-			if (setVolume(volume_params, 0))
-			{
-				markForUpdate(TRUE);
-			}
-			S32 res2 = unpackTEMessage(*dp);
-			if (TEM_INVALID == res2)
-			{
-				// There's something bogus in the data that we're unpacking.
-				dp->dumpBufferToLog();
-				llwarns << "Flushing cache files" << llendl;
-
-				if(LLVOCache::hasInstance() && getRegion())
-				{
-					LLVOCache::getInstance()->removeEntry(getRegion()->getHandle()) ;
-				}
-				
-				llwarns << "Bogus TE data in " << getID() << llendl;
-			}
-			else 
-			{
-				if (res2 & teDirtyBits) 
-				{
-					updateTEData();
-				}
-				if (res2 & TEM_CHANGE_MEDIA)
-				{
-					retval |= MEDIA_FLAGS_CHANGED;
-				}
-			}
-
-			U32 value = dp->getPassFlags();
-
-			if (value & 0x40)
-			{
-				if (!mTextureAnimp)
-				{
-					mTextureAnimp = new LLViewerTextureAnim();
-				}
-				else
-				{
-					if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
-					{
-						mTextureAnimp->reset();
-					}
-				}
-				mTexAnimMode = 0;
-				mTextureAnimp->unpackTAMessage(*dp);
-			}
-			else if (mTextureAnimp)
-			{
-				delete mTextureAnimp;
-				mTextureAnimp = NULL;
-				gPipeline.markTextured(mDrawable);
-				mFaceMappingChanged = TRUE;
-				mTexAnimMode = 0;
-			}
-		}
-		else
-		{
-			S32 texture_length = mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureEntry);
-			if (texture_length)
-			{
-				U8							tdpbuffer[1024];
-				LLDataPackerBinaryBuffer	tdp(tdpbuffer, 1024);
-				mesgsys->getBinaryDataFast(_PREHASH_ObjectData, _PREHASH_TextureEntry, tdpbuffer, 0, block_num);
-				S32 result = unpackTEMessage(tdp);
-				if (result & teDirtyBits)
-				{
-					updateTEData();
-				}
-				if (result & TEM_CHANGE_MEDIA)
-				{
-					retval |= MEDIA_FLAGS_CHANGED;
-				}
-			}
-		}
-	}
-	if (retval & (MEDIA_URL_REMOVED | MEDIA_URL_ADDED | MEDIA_URL_UPDATED | MEDIA_FLAGS_CHANGED)) 
-	{
-		// If only the media URL changed, and it isn't a media version URL,
-		// ignore it
-		if ( ! ( retval & (MEDIA_URL_ADDED | MEDIA_URL_UPDATED) &&
-				 mMedia && ! mMedia->mMediaURL.empty() &&
-				 ! LLTextureEntry::isMediaVersionString(mMedia->mMediaURL) ) )
-		{
-			// If the media changed at all, request new media data
-			LL_DEBUGS("MediaOnAPrim") << "Media update: " << getID() << ": retval=" << retval << " Media URL: " <<
-                ((mMedia) ?  mMedia->mMediaURL : std::string("")) << LL_ENDL;
-			requestMediaDataUpdate(retval & MEDIA_FLAGS_CHANGED);
-		}
-        else {
-            LL_INFOS("MediaOnAPrim") << "Ignoring media update for: " << getID() << " Media URL: " <<
-                ((mMedia) ?  mMedia->mMediaURL : std::string("")) << LL_ENDL;
-        }
-	}
-	// ...and clean up any media impls
-	cleanUpMediaImpls();
-
-	return retval;
-}
-
-
-void LLVOVolume::animateTextures()
-{
-	F32 off_s = 0.f, off_t = 0.f, scale_s = 1.f, scale_t = 1.f, rot = 0.f;
-	S32 result = mTextureAnimp->animateTextures(off_s, off_t, scale_s, scale_t, rot);
-	
-	if (result)
-	{
-		if (!mTexAnimMode)
-		{
-			mFaceMappingChanged = TRUE;
-			gPipeline.markTextured(mDrawable);
-		}
-		mTexAnimMode = result | mTextureAnimp->mMode;
-				
-		S32 start=0, end=mDrawable->getNumFaces()-1;
-		if (mTextureAnimp->mFace >= 0 && mTextureAnimp->mFace <= end)
-		{
-			start = end = mTextureAnimp->mFace;
-		}
-		
-		for (S32 i = start; i <= end; i++)
-		{
-			LLFace* facep = mDrawable->getFace(i);
-			if(facep->getVirtualSize() <= MIN_TEX_ANIM_SIZE && facep->mTextureMatrix) continue;
-
-			const LLTextureEntry* te = facep->getTextureEntry();
-			
-			if (!te)
-			{
-				continue;
-			}
-		
-			if (!(result & LLViewerTextureAnim::ROTATE))
-			{
-				te->getRotation(&rot);
-			}
-			if (!(result & LLViewerTextureAnim::TRANSLATE))
-			{
-				te->getOffset(&off_s,&off_t);
-			}			
-			if (!(result & LLViewerTextureAnim::SCALE))
-			{
-				te->getScale(&scale_s, &scale_t);
-			}
-
-			if (!facep->mTextureMatrix)
-			{
-				facep->mTextureMatrix = new LLMatrix4();
-			}
-
-			LLMatrix4& tex_mat = *facep->mTextureMatrix;
-			tex_mat.setIdentity();
-			LLVector3 trans ;
-
-			if(facep->isAtlasInUse())
-			{
-				//
-				//if use atlas for animated texture
-				//apply the following transform to the animation matrix.
-				//
-
-				F32 tcoord_xoffset = 0.f ;
-				F32 tcoord_yoffset = 0.f ;
-				F32 tcoord_xscale = 1.f ;
-				F32 tcoord_yscale = 1.f ;			
-				if(facep->isAtlasInUse())
-				{
-					const LLVector2* tmp = facep->getTexCoordOffset() ;
-					tcoord_xoffset = tmp->mV[0] ; 
-					tcoord_yoffset = tmp->mV[1] ;
-
-					tmp = facep->getTexCoordScale() ;
-					tcoord_xscale = tmp->mV[0] ; 
-					tcoord_yscale = tmp->mV[1] ;	
-				}
-				trans.set(LLVector3(tcoord_xoffset + tcoord_xscale * (off_s+0.5f), tcoord_yoffset + tcoord_yscale * (off_t+0.5f), 0.f));
-
-				tex_mat.translate(LLVector3(-(tcoord_xoffset + tcoord_xscale * 0.5f), -(tcoord_yoffset + tcoord_yscale * 0.5f), 0.f));
-			}
-			else	//non atlas
-			{
-				trans.set(LLVector3(off_s+0.5f, off_t+0.5f, 0.f));			
-				tex_mat.translate(LLVector3(-0.5f, -0.5f, 0.f));
-			}
-
-			LLVector3 scale(scale_s, scale_t, 1.f);			
-			LLQuaternion quat;
-			quat.setQuat(rot, 0, 0, -1.f);
-		
-			tex_mat.rotate(quat);				
-
-			LLMatrix4 mat;
-			mat.initAll(scale, LLQuaternion(), LLVector3());
-			tex_mat *= mat;
-		
-			tex_mat.translate(trans);
-		}
-	}
-	else
-	{
-		if (mTexAnimMode && mTextureAnimp->mRate == 0)
-		{
-			U8 start, count;
-
-			if (mTextureAnimp->mFace == -1)
-			{
-				start = 0;
-				count = getNumTEs();
-			}
-			else
-			{
-				start = (U8) mTextureAnimp->mFace;
-				count = 1;
-			}
-
-			for (S32 i = start; i < start + count; i++)
-			{
-				if (mTexAnimMode & LLViewerTextureAnim::TRANSLATE)
-				{
-					setTEOffset(i, mTextureAnimp->mOffS, mTextureAnimp->mOffT);				
-				}
-				if (mTexAnimMode & LLViewerTextureAnim::SCALE)
-				{
-					setTEScale(i, mTextureAnimp->mScaleS, mTextureAnimp->mScaleT);	
-				}
-				if (mTexAnimMode & LLViewerTextureAnim::ROTATE)
-				{
-					setTERotation(i, mTextureAnimp->mRot);
-				}
-			}
-
-			gPipeline.markTextured(mDrawable);
-			mFaceMappingChanged = TRUE;
-			mTexAnimMode = 0;
-		}
-	}
-}
-BOOL LLVOVolume::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
-{
-	LLViewerObject::idleUpdate(agent, world, time);
-
-	static LLFastTimer::DeclareTimer ftm("Volume");
-	LLFastTimer t(ftm);
-
-	if (mDead || mDrawable.isNull())
-	{
-		return TRUE;
-	}
-	
-	///////////////////////
-	//
-	// Do texture animation stuff
-	//
-
-	if (mTextureAnimp && gAnimateTextures)
-	{
-		animateTextures();
-	}
-
-	// Dispatch to implementation
-	if (mVolumeImpl)
-	{
-		mVolumeImpl->doIdleUpdate(agent, world, time);
-	}
-
-	const S32 MAX_ACTIVE_OBJECT_QUIET_FRAMES = 40;
-
-	if (mDrawable->isActive())
-	{
-		if (mDrawable->isRoot() && 
-			mDrawable->mQuietCount++ > MAX_ACTIVE_OBJECT_QUIET_FRAMES && 
-			(!mDrawable->getParent() || !mDrawable->getParent()->isActive()))
-		{
-			mDrawable->makeStatic();
-		}
-	}
-
-	return TRUE;
-}
-
-void LLVOVolume::updateTextures()
-{
-	const F32 TEXTURE_AREA_REFRESH_TIME = 5.f; // seconds
-	if (mTextureUpdateTimer.getElapsedTimeF32() > TEXTURE_AREA_REFRESH_TIME)
-	{
-		updateTextureVirtualSize();		
-	}
-}
-
-BOOL LLVOVolume::isVisible() const 
-{
-	if(mDrawable.notNull() && mDrawable->isVisible())
-	{
-		return TRUE ;
-	}
-
-	if(isAttachment())
-	{
-		LLViewerObject* objp = (LLViewerObject*)getParent() ;
-		while(objp && !objp->isAvatar())
-		{
-			objp = (LLViewerObject*)objp->getParent() ;
-		}
-
-		return objp && objp->mDrawable.notNull() && objp->mDrawable->isVisible() ;
-	}
-
-	return FALSE ;
-}
-
-void LLVOVolume::updateTextureVirtualSize()
-{
-	LLFastTimer ftm(FTM_VOLUME_TEXTURES);
-	// Update the pixel area of all faces
-
-	if(!isVisible())
-	{
-		return ;
-	}
-
-	if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SIMPLE))
-	{
-		return;
-	}
-
-	static LLCachedControl<bool> dont_load_textures(gSavedSettings,"TextureDisable");
-		
-	if (dont_load_textures || LLAppViewer::getTextureFetch()->mDebugPause) // || !mDrawable->isVisible())
-	{
-		return;
-	}
-
-	mTextureUpdateTimer.reset();
-	
-	F32 old_area = mPixelArea;
-	mPixelArea = 0.f;
-
-	const S32 num_faces = mDrawable->getNumFaces();
-	F32 min_vsize=999999999.f, max_vsize=0.f;
-	LLViewerCamera* camera = LLViewerCamera::getInstance();
-	for (S32 i = 0; i < num_faces; i++)
-	{
-		LLFace* face = mDrawable->getFace(i);
-		const LLTextureEntry *te = face->getTextureEntry();
-		LLViewerTexture *imagep = face->getTexture();
-		if (!imagep || !te ||			
-			face->mExtents[0].equals3(face->mExtents[1]))
-		{
-			continue;
-		}
-		
-		F32 vsize;
-		F32 old_size = face->getVirtualSize();
-
-		if (isHUDAttachment())
-		{
-			F32 area = (F32) camera->getScreenPixelArea();
-			vsize = area;
-			imagep->setBoostLevel(LLViewerTexture::BOOST_HUD);
- 			face->setPixelArea(area); // treat as full screen
-			face->setVirtualSize(vsize);
-		}
-		else
-		{
-			vsize = face->getTextureVirtualSize();
-		}
-
-		mPixelArea = llmax(mPixelArea, face->getPixelArea());		
-
-		if (face->mTextureMatrix != NULL)
-		{
-			if ((vsize < MIN_TEX_ANIM_SIZE && old_size > MIN_TEX_ANIM_SIZE) ||
-				(vsize > MIN_TEX_ANIM_SIZE && old_size < MIN_TEX_ANIM_SIZE))
-			{
-				gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD, FALSE);
-			}
-		}
-				
-		if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
-		{
-			if (vsize < min_vsize) min_vsize = vsize;
-			if (vsize > max_vsize) max_vsize = vsize;
-		}
-		else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
-		{
-			LLViewerFetchedTexture* img = LLViewerTextureManager::staticCastToFetchedTexture(imagep) ;
-			if(img)
-			{
-				F32 pri = img->getDecodePriority();
-				pri = llmax(pri, 0.0f);
-				if (pri < min_vsize) min_vsize = pri;
-				if (pri > max_vsize) max_vsize = pri;
-			}
-		}
-		else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
-		{
-			F32 pri = mPixelArea;
-			if (pri < min_vsize) min_vsize = pri;
-			if (pri > max_vsize) max_vsize = pri;
-		}	
-	}
-	
-	if (isSculpted())
-	{
-		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
-		LLUUID id =  sculpt_params->getSculptTexture();
-		
-		updateSculptTexture();
-		
-		
-
-		if (mSculptTexture.notNull())
-		{
-			mSculptTexture->setBoostLevel(llmax((S32)mSculptTexture->getBoostLevel(),
-												(S32)LLViewerTexture::BOOST_SCULPTED));
-			mSculptTexture->setForSculpt() ;
-			
-			if(!mSculptTexture->isCachedRawImageReady())
-			{
-				S32 lod = llmin(mLOD, 3);
-				F32 lodf = ((F32)(lod + 1.0f)/4.f);
-				F32 tex_size = lodf * LLViewerTexture::sMaxSculptRez ;
-				mSculptTexture->addTextureStats(2.f * tex_size * tex_size, FALSE);
-			
-				//if the sculpty very close to the view point, load first
-				{				
-					LLVector3 lookAt = getPositionAgent() - camera->getOrigin();
-					F32 dist = lookAt.normVec() ;
-					F32 cos_angle_to_view_dir = lookAt * camera->getXAxis() ;				
-					mSculptTexture->setAdditionalDecodePriority(0.8f * LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist)) ;
-				}
-			}
-	
-			S32 texture_discard = mSculptTexture->getDiscardLevel(); //try to match the texture
-			S32 current_discard = getVolume() ? getVolume()->getSculptLevel() : -2 ;
-
-			if (texture_discard >= 0 && //texture has some data available
-				(texture_discard < current_discard || //texture has more data than last rebuild
-				current_discard < 0)) //no previous rebuild
-			{
-				gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
-				mSculptChanged = TRUE;
-			}
-
-			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SCULPTED))
-			{
-				setDebugText(llformat("T%d C%d V%d\n%dx%d",
-										  texture_discard, current_discard, getVolume()->getSculptLevel(),
-										  mSculptTexture->getHeight(), mSculptTexture->getWidth()));
-			}
-		}
-
-	}
-
-	if (getLightTextureID().notNull())
-	{
-		LLLightImageParams* params = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
-		LLUUID id = params->getLightTexture();
-		mLightTexture = LLViewerTextureManager::getFetchedTexture(id);
-		if (mLightTexture.notNull())
-		{
-			F32 rad = getLightRadius();
-			mLightTexture->addTextureStats(gPipeline.calcPixelArea(getPositionAgent(), 
-																	LLVector3(rad,rad,rad),
-																	*camera));
-		}	
-	}
-	
-	if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
-	{
-		setDebugText(llformat("%.0f:%.0f", (F32) sqrt(min_vsize),(F32) sqrt(max_vsize)));
-	}
- 	else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
- 	{
- 		setDebugText(llformat("%.0f:%.0f", (F32) sqrt(min_vsize),(F32) sqrt(max_vsize)));
- 	}
-	else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
-	{
-		setDebugText(llformat("%.0f:%.0f", (F32) sqrt(min_vsize),(F32) sqrt(max_vsize)));
-	}
-
-	if (mPixelArea == 0)
-	{ //flexi phasing issues make this happen
-		mPixelArea = old_area;
-	}
-}
-
-BOOL LLVOVolume::isActive() const
-{
-	return !mStatic || mTextureAnimp || (mVolumeImpl && mVolumeImpl->isActive()) || 
-		(mDrawable.notNull() && mDrawable->isActive());
-}
-
-BOOL LLVOVolume::setMaterial(const U8 material)
-{
-	BOOL res = LLViewerObject::setMaterial(material);
-	
-	return res;
-}
-
-void LLVOVolume::setTexture(const S32 face)
-{
-	llassert(face < getNumTEs());
-	gGL.getTexUnit(0)->bind(getTEImage(face));
-}
-
-void LLVOVolume::setScale(const LLVector3 &scale, BOOL damped)
-{
-	if (scale != getScale())
-	{
-		// store local radius
-		LLViewerObject::setScale(scale);
-
-		if (mVolumeImpl)
-		{
-			mVolumeImpl->onSetScale(scale, damped);
-		}
-		
-		updateRadius();
-
-		//since drawable transforms do not include scale, changing volume scale
-		//requires an immediate rebuild of volume verts.
-		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_POSITION, TRUE);
-	}
-}
-
-LLFace* LLVOVolume::addFace(S32 f)
-{
-	const LLTextureEntry* te = getTE(f);
-	LLViewerTexture* imagep = getTEImage(f);
-	return mDrawable->addFace(te, imagep);
-}
-
-LLDrawable *LLVOVolume::createDrawable(LLPipeline *pipeline)
-{
-	pipeline->allocDrawable(this);
-		
-	mDrawable->setRenderType(LLPipeline::RENDER_TYPE_VOLUME);
-
-	S32 max_tes_to_set = getNumTEs();
-	for (S32 i = 0; i < max_tes_to_set; i++)
-	{
-		addFace(i);
-	}
-	mNumFaces = max_tes_to_set;
-
-	if (isAttachment())
-	{
-		mDrawable->makeActive();
-	}
-
-	if (getIsLight())
-	{
-		// Add it to the pipeline mLightSet
-		gPipeline.setLight(mDrawable, TRUE);
-	}
-	
-	updateRadius();
-	bool force_update = true; // avoid non-alpha mDistance update being optimized away
-	mDrawable->updateDistance(*LLViewerCamera::getInstance(), force_update);
-
-	return mDrawable;
-}
-
-BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bool unique_volume)
-{
-	LLVolumeParams volume_params = params_in;
-
-	S32 last_lod = mVolumep.notNull() ? LLVolumeLODGroup::getVolumeDetailFromScale(mVolumep->getDetail()) : -1;
-	S32 lod = mLOD;
-
-	BOOL is404 = FALSE;
-	
-	if (isSculpted())
-	{
-		// if it's a mesh
-		if ((volume_params.getSculptType() & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
-		{ //meshes might not have all LODs, get the force detail to best existing LOD
-			LLUUID mesh_id = volume_params.getSculptID();
-
-			lod = gMeshRepo.getActualMeshLOD(volume_params, lod);
-			if (lod == -1)
-			{
-				is404 = TRUE;
-				lod = 0;
-			}
-		}
-	}
-
-	// Check if we need to change implementations
-	bool is_flexible = (volume_params.getPathParams().getCurveType() == LL_PCODE_PATH_FLEXIBLE);
-	if (is_flexible)
-	{
-		setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, TRUE, false);
-		if (!mVolumeImpl)
-		{
-			LLFlexibleObjectData* data = (LLFlexibleObjectData*)getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
-			mVolumeImpl = new LLVolumeImplFlexible(this, data);
-		}
-	}
-	else
-	{
-		// Mark the parameter not in use
-		setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, FALSE, false);
-		if (mVolumeImpl)
-		{
-			delete mVolumeImpl;
-			mVolumeImpl = NULL;
-			if (mDrawable.notNull())
-			{
-				// Undo the damage we did to this matrix
-				mDrawable->updateXform(FALSE);
-			}
-		}
-	}
-	
-	if (is404)
-	{
-		setIcon(LLViewerTextureManager::getFetchedTextureFromFile("icons/Inv_Mesh.png", TRUE, LLViewerTexture::BOOST_UI));
-		//render prim proxy when mesh loading attempts give up
-		volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_NONE);
-
-	}
-
-	if ((LLPrimitive::setVolume(volume_params, lod, (mVolumeImpl && mVolumeImpl->isVolumeUnique()))) || mSculptChanged)
-	{
-		mFaceMappingChanged = TRUE;
-		
-		if (mVolumeImpl)
-		{
-			mVolumeImpl->onSetVolume(volume_params, mLOD);
-		}
-	
-		updateSculptTexture();
-
-		if (isSculpted())
-		{
-			updateSculptTexture();
-			// if it's a mesh
-			if ((volume_params.getSculptType() & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
-			{
-				if (!getVolume()->isMeshAssetLoaded())
-				{ 
-					//load request not yet issued, request pipeline load this mesh
-					LLUUID asset_id = volume_params.getSculptID();
-					S32 available_lod = gMeshRepo.loadMesh(this, volume_params, lod, last_lod);
-					if (available_lod != lod)
-					{
-						LLPrimitive::setVolume(volume_params, available_lod);
-					}
-				}
-				
-			}
-			else // otherwise is sculptie
-			{
-				if (mSculptTexture.notNull())
-				{
-					sculpt();
-				}
-			}
-		}
-
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-void LLVOVolume::updateSculptTexture()
-{
-	LLPointer<LLViewerFetchedTexture> old_sculpt = mSculptTexture;
-
-	if (isSculpted() && !isMesh())
-	{
-		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
-		LLUUID id =  sculpt_params->getSculptTexture();
-		if (id.notNull())
-		{
-			mSculptTexture = LLViewerTextureManager::getFetchedTexture(id, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
-		}
-	}
-	else
-	{
-		mSculptTexture = NULL;
-	}
-
-	if (mSculptTexture != old_sculpt)
-	{
-		if (old_sculpt.notNull())
-		{
-			old_sculpt->removeVolume(this);
-		}
-		if (mSculptTexture.notNull())
-		{
-			mSculptTexture->addVolume(this);
-		}
-	}
-	
-}
-
-void LLVOVolume::notifyMeshLoaded()
-{ 
-	mSculptChanged = TRUE;
-	gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_GEOMETRY, TRUE);
-}
-
-// sculpt replaces generate() for sculpted surfaces
-void LLVOVolume::sculpt()
-{	
-	if (mSculptTexture.notNull())
-	{				
-		U16 sculpt_height = 0;
-		U16 sculpt_width = 0;
-		S8 sculpt_components = 0;
-		const U8* sculpt_data = NULL;
-	
-		S32 discard_level = mSculptTexture->getDiscardLevel() ;
-		LLImageRaw* raw_image = mSculptTexture->getCachedRawImage() ;
-		
-		S32 max_discard = mSculptTexture->getMaxDiscardLevel();
-		if (discard_level > max_discard)
-			discard_level = max_discard;    // clamp to the best we can do
-
-		S32 current_discard = getVolume()->getSculptLevel() ;
-		if(current_discard < -2)
-		{
-			llwarns << "WARNING!!: Current discard of sculpty at " << current_discard 
-				<< " is less than -2." << llendl;
-			
-			// corrupted volume... don't update the sculpty
-			return;
-		}
-		else if (current_discard > MAX_DISCARD_LEVEL)
-		{
-			llwarns << "WARNING!!: Current discard of sculpty at " << current_discard 
-				<< " is more than than allowed max of " << MAX_DISCARD_LEVEL << llendl;
-			
-			// corrupted volume... don't update the sculpty			
-			return;
-		}
-
-		if (current_discard == discard_level)  // no work to do here
-			return;
-		
-		if(!raw_image)
-		{
-			llassert(discard_level < 0) ;
-
-			sculpt_width = 0;
-			sculpt_height = 0;
-			sculpt_data = NULL ;
-
-			if(LLViewerTextureManager::sTesterp)
-			{
-				LLViewerTextureManager::sTesterp->updateGrayTextureBinding();
-			}
-		}
-		else
-		{					
-			sculpt_height = raw_image->getHeight();
-			sculpt_width = raw_image->getWidth();
-			sculpt_components = raw_image->getComponents();		
-					   
-			sculpt_data = raw_image->getData();
-
-			if(LLViewerTextureManager::sTesterp)
-			{
-				mSculptTexture->updateBindStatsForTester() ;
-			}
-		}
-		getVolume()->sculpt(sculpt_width, sculpt_height, sculpt_components, sculpt_data, discard_level);
-
-		//notify rebuild any other VOVolumes that reference this sculpty volume
-		for (S32 i = 0; i < mSculptTexture->getNumVolumes(); ++i)
-		{
-			LLVOVolume* volume = (*(mSculptTexture->getVolumeList()))[i];
-			if (volume != this && volume->getVolume() == getVolume())
-			{
-				gPipeline.markRebuild(volume->mDrawable, LLDrawable::REBUILD_GEOMETRY, FALSE);
-			}
-		}
-	}
-}
-
-S32	LLVOVolume::computeLODDetail(F32 distance, F32 radius)
-{
-	S32	cur_detail;
-	if (LLPipeline::sDynamicLOD)
-	{
-		// We've got LOD in the profile, and in the twist.  Use radius.
-		F32 tan_angle = (LLVOVolume::sLODFactor*radius)/distance;
-		cur_detail = LLVolumeLODGroup::getDetailFromTan(llround(tan_angle, 0.01f));
-	}
-	else
-	{
-		cur_detail = llclamp((S32) (sqrtf(radius)*LLVOVolume::sLODFactor*4.f), 0, 3);		
-	}
-	return cur_detail;
-}
-
-BOOL LLVOVolume::calcLOD()
-{
-	if (mDrawable.isNull())
-	{
-		return FALSE;
-	}
-
-	S32 cur_detail = 0;
-	
-	F32 radius;
-	F32 distance;
-
-	if (mDrawable->isState(LLDrawable::RIGGED))
-	{
-		LLVOAvatar* avatar = getAvatar(); 
-		distance = avatar->mDrawable->mDistanceWRTCamera;
-		radius = avatar->getBinRadius();
-	}
-	else
-	{
-		distance = mDrawable->mDistanceWRTCamera;
-		radius = getVolume()->mLODScaleBias.scaledVec(getScale()).length();
-	}
-	
-	//hold onto unmodified distance for debugging
-	//F32 debug_distance = distance;
-	
-	distance *= sDistanceFactor;
-
-	F32 rampDist = LLVOVolume::sLODFactor * 2;
-	
-	if (distance < rampDist)
-	{
-		// Boost LOD when you're REALLY close
-		distance *= 1.0f/rampDist;
-		distance *= distance;
-		distance *= rampDist;
-	}
-	
-	// DON'T Compensate for field of view changing on FOV zoom.
-	distance *= F_PI/3.f;
-
-	cur_detail = computeLODDetail(llround(distance, 0.01f), 
-									llround(radius, 0.01f));
-
-
-	if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_LOD_INFO))
-	{
-		//setDebugText(llformat("%.2f:%.2f, %d", debug_distance, radius, cur_detail));
-
-		setDebugText(llformat("%d", mDrawable->getFace(0)->getTextureIndex()));
-	}
-
-	if (cur_detail != mLOD)
-	{
-		mAppAngle = llround((F32) atan2( mDrawable->getRadius(), mDrawable->mDistanceWRTCamera) * RAD_TO_DEG, 0.01f);
-		mLOD = cur_detail;		
-		return TRUE;
-	}
-	else
-	{
-		return FALSE;
-	}
-}
-
-BOOL LLVOVolume::updateLOD()
-{
-	if (mDrawable.isNull())
-	{
-		return FALSE;
-	}
-	
-	BOOL lod_changed = calcLOD();
-
-	if (lod_changed)
-	{
-		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
-		mLODChanged = TRUE;
-	}
-	else
-	{
-		F32 new_radius = getBinRadius();
-		F32 old_radius = mDrawable->getBinRadius();
-		if (new_radius < old_radius * 0.9f || new_radius > old_radius*1.1f)
-		{
-			gPipeline.markPartitionMove(mDrawable);
-		}
-	}
-
-	lod_changed = lod_changed || LLViewerObject::updateLOD();
-	
-	return lod_changed;
-}
-
-BOOL LLVOVolume::setDrawableParent(LLDrawable* parentp)
-{
-	if (!LLViewerObject::setDrawableParent(parentp))
-	{
-		// no change in drawable parent
-		return FALSE;
-	}
-
-	if (!mDrawable->isRoot())
-	{
-		// rebuild vertices in parent relative space
-		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
-
-		if (mDrawable->isActive() && !parentp->isActive())
-		{
-			parentp->makeActive();
-		}
-		else if (mDrawable->isStatic() && parentp->isActive())
-		{
-			mDrawable->makeActive();
-		}
-	}
-	
-	return TRUE;
-}
-
-void LLVOVolume::updateFaceFlags()
-{
-	for (S32 i = 0; i < getVolume()->getNumFaces(); i++)
-	{
-		LLFace *face = mDrawable->getFace(i);
-		if (!face)
-		{
-			return;
-		}
-
-		BOOL fullbright = getTE(i)->getFullbright();
-		face->clearState(LLFace::FULLBRIGHT | LLFace::HUD_RENDER | LLFace::LIGHT);
-
-		if (fullbright || (mMaterial == LL_MCODE_LIGHT))
-		{
-			face->setState(LLFace::FULLBRIGHT);
-		}
-		if (mDrawable->isLight())
-		{
-			face->setState(LLFace::LIGHT);
-		}
-		if (isHUDAttachment())
-		{
-			face->setState(LLFace::HUD_RENDER);
-		}
-	}
-}
-
-BOOL LLVOVolume::setParent(LLViewerObject* parent)
-{
-	BOOL ret = FALSE ;
-	if (parent != getParent())
-	{
-		ret = LLViewerObject::setParent(parent);
-		if (ret && mDrawable)
-		{
-			gPipeline.markMoved(mDrawable);
-			gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
-		}
-	}
-
-	return ret ;
-}
-
-// NOTE: regenFaces() MUST be followed by genTriangles()!
-void LLVOVolume::regenFaces()
-{
-	// remove existing faces
-	BOOL count_changed = mNumFaces != getNumTEs();
-	
-	if (count_changed)
-	{
-		deleteFaces();		
-		// add new faces
-		mNumFaces = getNumTEs();
-	}
-		
-	for (S32 i = 0; i < mNumFaces; i++)
-	{
-		LLFace* facep = count_changed ? addFace(i) : mDrawable->getFace(i);
-		facep->setTEOffset(i);
-		facep->setTexture(getTEImage(i));
-		facep->setViewerObject(this);
-		
-		// If the face had media on it, this will have broken the link between the LLViewerMediaTexture and the face.
-		// Re-establish the link.
-		if((int)mMediaImplList.size() > i)
-		{
-			if(mMediaImplList[i])
-			{
-				LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[i]->getMediaTextureID()) ;
-				if(media_tex)
-				{
-					media_tex->addMediaToFace(facep) ;
-				}
-			}
-		}
-	}
-	
-	if (!count_changed)
-	{
-		updateFaceFlags();
-	}
-}
-
-BOOL LLVOVolume::genBBoxes(BOOL force_global)
-{
-	BOOL res = TRUE;
-
-	LLVector4a min,max;
-
-	min.clear();
-	max.clear();
-
-	BOOL rebuild = mDrawable->isState(LLDrawable::REBUILD_VOLUME | LLDrawable::REBUILD_POSITION | LLDrawable::REBUILD_RIGGED);
-
-//	bool rigged = false;
-	LLVolume* volume = mRiggedVolume;
-	if (!volume)
-	{
-		volume = getVolume();
-	}
-
-	for (S32 i = 0; i < getVolume()->getNumVolumeFaces(); i++)
-	{
-		LLFace *face = mDrawable->getFace(i);
-		if (!face)
-		{
-			continue;
-		}
-		res &= face->genVolumeBBoxes(*volume, i,
-										mRelativeXform, mRelativeXformInvTrans,
-										(mVolumeImpl && mVolumeImpl->isVolumeGlobal()) || force_global);
-		
-		if (rebuild)
-		{
-			if (i == 0)
-			{
-				min = face->mExtents[0];
-				max = face->mExtents[1];
-			}
-			else
-			{
-				min.setMin(min, face->mExtents[0]);
-				max.setMax(max, face->mExtents[1]);
-			}
-		}
-	}
-	
-	if (rebuild)
-	{
-		mDrawable->setSpatialExtents(min,max);
-		min.add(max);
-		min.mul(0.5f);
-		mDrawable->setPositionGroup(min);	
-	}
-
-	updateRadius();
-	mDrawable->movePartition();
-			
-	return res;
-}
-
-void LLVOVolume::preRebuild()
-{
-	if (mVolumeImpl != NULL)
-	{
-		mVolumeImpl->preRebuild();
-	}
-}
-
-void LLVOVolume::updateRelativeXform()
-{
-	if (mVolumeImpl)
-	{
-		mVolumeImpl->updateRelativeXform();
-		return;
-	}
-	
-	LLDrawable* drawable = mDrawable;
-	
-	if (drawable->isState(LLDrawable::RIGGED) && mRiggedVolume.notNull())
-	{ //rigged volume (which is in agent space) is used for generating bounding boxes etc
-	  //inverse of render matrix should go to partition space
-		mRelativeXform = getRenderMatrix();
-
-		F32* dst = (F32*) mRelativeXformInvTrans.mMatrix;
-		F32* src = (F32*) mRelativeXform.mMatrix;
-		dst[0] = src[0]; dst[1] = src[1]; dst[2] = src[2];
-		dst[3] = src[4]; dst[4] = src[5]; dst[5] = src[6];
-		dst[6] = src[8]; dst[7] = src[9]; dst[8] = src[10];
-		
-		mRelativeXform.invert();
-		mRelativeXformInvTrans.transpose();
-	}
-	else if (drawable->isActive())
-	{				
-		// setup relative transforms
-		LLQuaternion delta_rot;
-		LLVector3 delta_pos, delta_scale;
-		
-		//matrix from local space to parent relative/global space
-		delta_rot = drawable->isSpatialRoot() ? LLQuaternion() : mDrawable->getRotation();
-		delta_pos = drawable->isSpatialRoot() ? LLVector3(0,0,0) : mDrawable->getPosition();
-		delta_scale = mDrawable->getScale();
-
-		// Vertex transform (4x4)
-		LLVector3 x_axis = LLVector3(delta_scale.mV[VX], 0.f, 0.f) * delta_rot;
-		LLVector3 y_axis = LLVector3(0.f, delta_scale.mV[VY], 0.f) * delta_rot;
-		LLVector3 z_axis = LLVector3(0.f, 0.f, delta_scale.mV[VZ]) * delta_rot;
-
-		mRelativeXform.initRows(LLVector4(x_axis, 0.f),
-								LLVector4(y_axis, 0.f),
-								LLVector4(z_axis, 0.f),
-								LLVector4(delta_pos, 1.f));
-
-		
-		// compute inverse transpose for normals
-		// mRelativeXformInvTrans.setRows(x_axis, y_axis, z_axis);
-		// mRelativeXformInvTrans.invert(); 
-		// mRelativeXformInvTrans.setRows(x_axis, y_axis, z_axis);
-		// grumble - invert is NOT a matrix invert, so we do it by hand:
-
-		LLMatrix3 rot_inverse = LLMatrix3(~delta_rot);
-
-		LLMatrix3 scale_inverse;
-		scale_inverse.setRows(LLVector3(1.0, 0.0, 0.0) / delta_scale.mV[VX],
-							  LLVector3(0.0, 1.0, 0.0) / delta_scale.mV[VY],
-							  LLVector3(0.0, 0.0, 1.0) / delta_scale.mV[VZ]);
-							   
-		
-		mRelativeXformInvTrans = rot_inverse * scale_inverse;
-
-		mRelativeXformInvTrans.transpose();
-	}
-	else
-	{
-		LLVector3 pos = getPosition();
-		LLVector3 scale = getScale();
-		LLQuaternion rot = getRotation();
-	
-		if (mParent)
-		{
-			pos *= mParent->getRotation();
-			pos += mParent->getPosition();
-			rot *= mParent->getRotation();
-		}
-		
-		//LLViewerRegion* region = getRegion();
-		//pos += region->getOriginAgent();
-		
-		LLVector3 x_axis = LLVector3(scale.mV[VX], 0.f, 0.f) * rot;
-		LLVector3 y_axis = LLVector3(0.f, scale.mV[VY], 0.f) * rot;
-		LLVector3 z_axis = LLVector3(0.f, 0.f, scale.mV[VZ]) * rot;
-
-		mRelativeXform.initRows(LLVector4(x_axis, 0.f),
-								LLVector4(y_axis, 0.f),
-								LLVector4(z_axis, 0.f),
-								LLVector4(pos, 1.f));
-
-		// compute inverse transpose for normals
-		LLMatrix3 rot_inverse = LLMatrix3(~rot);
-
-		LLMatrix3 scale_inverse;
-		scale_inverse.setRows(LLVector3(1.0, 0.0, 0.0) / scale.mV[VX],
-							  LLVector3(0.0, 1.0, 0.0) / scale.mV[VY],
-							  LLVector3(0.0, 0.0, 1.0) / scale.mV[VZ]);
-							   
-		
-		mRelativeXformInvTrans = rot_inverse * scale_inverse;
-
-		mRelativeXformInvTrans.transpose();
-	}
-}
-
-static LLFastTimer::DeclareTimer FTM_GEN_FLEX("Generate Flexies");
-static LLFastTimer::DeclareTimer FTM_UPDATE_PRIMITIVES("Update Primitives");
-static LLFastTimer::DeclareTimer FTM_UPDATE_RIGGED_VOLUME("Update Rigged");
-
-BOOL LLVOVolume::updateGeometry(LLDrawable *drawable)
-{
-	LLFastTimer t(FTM_UPDATE_PRIMITIVES);
-	
-	if (mDrawable->isState(LLDrawable::REBUILD_RIGGED))
-	{
-		{
-			LLFastTimer t(FTM_UPDATE_RIGGED_VOLUME);
-			updateRiggedVolume();
-		}
-		genBBoxes(FALSE);
-		mDrawable->clearState(LLDrawable::REBUILD_RIGGED);
-	}
-
-	if (mVolumeImpl != NULL)
-	{
-		BOOL res;
-		{
-			LLFastTimer t(FTM_GEN_FLEX);
-			res = mVolumeImpl->doUpdateGeometry(drawable);
-		}
-		updateFaceFlags();
-		return res;
-	}
-	
-	dirtySpatialGroup(drawable->isState(LLDrawable::IN_REBUILD_Q1));
-
-	BOOL compiled = FALSE;
-			
-	updateRelativeXform();
-	
-	if (mDrawable.isNull()) // Not sure why this is happening, but it is...
-	{
-		return TRUE; // No update to complete
-	}
-
-	if (mVolumeChanged || mFaceMappingChanged )
-	{
-		compiled = TRUE;
-
-		if (mVolumeChanged)
-		{
-			LLFastTimer ftm(FTM_GEN_VOLUME);
-			LLVolumeParams volume_params = getVolume()->getParams();
-			setVolume(volume_params, 0);
-			drawable->setState(LLDrawable::REBUILD_VOLUME);
-		}
-
-		{
-			LLFastTimer t(FTM_GEN_TRIANGLES);
-			regenFaces();
-			genBBoxes(FALSE);
-		}
-	}
-	else if ((mLODChanged) || (mSculptChanged))
-	{
-		LLVolume *old_volumep, *new_volumep;
-		F32 old_lod, new_lod;
-		S32 old_num_faces, new_num_faces ;
-
-		old_volumep = getVolume();
-		old_lod = old_volumep->getDetail();
-		old_num_faces = old_volumep->getNumFaces() ;
-		old_volumep = NULL ;
-
-		{
-			LLFastTimer ftm(FTM_GEN_VOLUME);
-			LLVolumeParams volume_params = getVolume()->getParams();
-			setVolume(volume_params, 0);
-		}
-
-		new_volumep = getVolume();
-		new_lod = new_volumep->getDetail();
-		new_num_faces = new_volumep->getNumFaces() ;
-		new_volumep = NULL ;
-
-		if ((new_lod != old_lod) || mSculptChanged)
-		{
-			compiled = TRUE;
-			sNumLODChanges += new_num_faces ;
-	
-			drawable->setState(LLDrawable::REBUILD_VOLUME); // for face->genVolumeTriangles()
-
-			{
-				LLFastTimer t(FTM_GEN_TRIANGLES);
-				if (new_num_faces != old_num_faces)
-				{
-					regenFaces();
-				}
-				genBBoxes(FALSE);
-
-				if (mSculptChanged)
-				{ //changes in sculpt maps can thrash an object bounding box without 
-				  //triggering a spatial group bounding box update -- force spatial group
-				  //to update bounding boxes
-					LLSpatialGroup* group = mDrawable->getSpatialGroup();
-					if (group)
-					{
-						group->unbound();
-					}
-				}
-			}
-		}
-	}
-	// it has its own drawable (it's moved) or it has changed UVs or it has changed xforms from global<->local
-	else
-	{
-		compiled = TRUE;
-		// All it did was move or we changed the texture coordinate offset
-		LLFastTimer t(FTM_GEN_TRIANGLES);
-		genBBoxes(FALSE);
-	}
-
-	// Update face flags
-	updateFaceFlags();
-	
-	if(compiled)
-	{
-		LLPipeline::sCompiles++;
-	}
-		
-	mVolumeChanged = FALSE;
-	mLODChanged = FALSE;
-	mSculptChanged = FALSE;
-	mFaceMappingChanged = FALSE;
-	
-	return LLViewerObject::updateGeometry(drawable);
-}
-
-void LLVOVolume::updateFaceSize(S32 idx)
-{
-	LLFace* facep = mDrawable->getFace(idx);
-	if (idx >= getVolume()->getNumVolumeFaces())
-	{
-		facep->setSize(0,0, true);
-	}
-	else
-	{
-		const LLVolumeFace& vol_face = getVolume()->getVolumeFace(idx);
-		facep->setSize(vol_face.mNumVertices, vol_face.mNumIndices, 
-						true); // <--- volume faces should be padded for 16-byte alignment
-		
-	}
-}
-
-BOOL LLVOVolume::isRootEdit() const
-{
-	if (mParent && !((LLViewerObject*)mParent)->isAvatar())
-	{
-		return FALSE;
-	}
-	return TRUE;
-}
-
-//virtual
-void LLVOVolume::setNumTEs(const U8 num_tes)
-{
-	const U8 old_num_tes = getNumTEs() ;
-	
-	if(old_num_tes && old_num_tes < num_tes) //new faces added
-	{
-		LLViewerObject::setNumTEs(num_tes) ;
-
-		if(mMediaImplList.size() >= old_num_tes && mMediaImplList[old_num_tes -1].notNull())//duplicate the last media textures if exists.
-		{
-			mMediaImplList.resize(num_tes) ;
-			const LLTextureEntry* te = getTE(old_num_tes - 1) ;
-			for(U8 i = old_num_tes; i < num_tes ; i++)
-			{
-				setTE(i, *te) ;
-				mMediaImplList[i] = mMediaImplList[old_num_tes -1] ;
-			}
-			mMediaImplList[old_num_tes -1]->setUpdated(TRUE) ;
-		}
-	}
-	else if(old_num_tes > num_tes && mMediaImplList.size() > num_tes) //old faces removed
-	{
-		U8 end = mMediaImplList.size() ;
-		for(U8 i = num_tes; i < end ; i++)
-		{
-			removeMediaImpl(i) ;				
-		}
-		mMediaImplList.resize(num_tes) ;
-
-		LLViewerObject::setNumTEs(num_tes) ;
-	}
-	else
-	{
-		LLViewerObject::setNumTEs(num_tes) ;
-	}
-
-	return ;
-}
-
-void LLVOVolume::setTEImage(const U8 te, LLViewerTexture *imagep)
-{
-	BOOL changed = (mTEImages[te] != imagep);
-	LLViewerObject::setTEImage(te, imagep);
-	if (changed)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-}
-
-S32 LLVOVolume::setTETexture(const U8 te, const LLUUID &uuid)
-{
-	S32 res = LLViewerObject::setTETexture(te, uuid);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return res;
-}
-
-S32 LLVOVolume::setTEColor(const U8 te, const LLColor3& color)
-{
-	return setTEColor(te, LLColor4(color));
-}
-
-S32 LLVOVolume::setTEColor(const U8 te, const LLColor4& color)
-{
-	S32 retval = 0;
-	const LLTextureEntry *tep = getTE(te);
-	if (!tep)
-	{
-		llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
-	}
-	else if (color != tep->getColor())
-	{
-		if (color.mV[3] != tep->getColor().mV[3])
-		{
-			gPipeline.markTextured(mDrawable);
-		}
-		retval = LLPrimitive::setTEColor(te, color);
-		if (mDrawable.notNull() && retval)
-		{
-			// These should only happen on updates which are not the initial update.
-			mDrawable->setState(LLDrawable::REBUILD_COLOR);
-			dirtyMesh();
-		}
-	}
-
-	return  retval;
-}
-
-S32 LLVOVolume::setTEBumpmap(const U8 te, const U8 bumpmap)
-{
-	S32 res = LLViewerObject::setTEBumpmap(te, bumpmap);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return  res;
-}
-
-S32 LLVOVolume::setTETexGen(const U8 te, const U8 texgen)
-{
-	S32 res = LLViewerObject::setTETexGen(te, texgen);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return  res;
-}
-
-S32 LLVOVolume::setTEMediaTexGen(const U8 te, const U8 media)
-{
-	S32 res = LLViewerObject::setTEMediaTexGen(te, media);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return  res;
-}
-
-S32 LLVOVolume::setTEShiny(const U8 te, const U8 shiny)
-{
-	S32 res = LLViewerObject::setTEShiny(te, shiny);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return  res;
-}
-
-S32 LLVOVolume::setTEFullbright(const U8 te, const U8 fullbright)
-{
-	S32 res = LLViewerObject::setTEFullbright(te, fullbright);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return  res;
-}
-
-S32 LLVOVolume::setTEBumpShinyFullbright(const U8 te, const U8 bump)
-{
-	S32 res = LLViewerObject::setTEBumpShinyFullbright(te, bump);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return res;
-}
-
-S32 LLVOVolume::setTEMediaFlags(const U8 te, const U8 media_flags)
-{
-	S32 res = LLViewerObject::setTEMediaFlags(te, media_flags);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return  res;
-}
-
-S32 LLVOVolume::setTEGlow(const U8 te, const F32 glow)
-{
-	S32 res = LLViewerObject::setTEGlow(te, glow);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return  res;
-}
-
-S32 LLVOVolume::setTEScale(const U8 te, const F32 s, const F32 t)
-{
-	S32 res = LLViewerObject::setTEScale(te, s, t);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return res;
-}
-
-S32 LLVOVolume::setTEScaleS(const U8 te, const F32 s)
-{
-	S32 res = LLViewerObject::setTEScaleS(te, s);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return res;
-}
-
-S32 LLVOVolume::setTEScaleT(const U8 te, const F32 t)
-{
-	S32 res = LLViewerObject::setTEScaleT(te, t);
-	if (res)
-	{
-		gPipeline.markTextured(mDrawable);
-		mFaceMappingChanged = TRUE;
-	}
-	return res;
-}
-
-void LLVOVolume::updateTEData()
-{
-	/*if (mDrawable.notNull())
-	{
-		mFaceMappingChanged = TRUE;
-		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_MATERIAL, TRUE);
-	}*/
-}
-
-bool LLVOVolume::hasMedia() const
-{
-	bool result = false;
-	const U8 numTEs = getNumTEs();
-	for (U8 i = 0; i < numTEs; i++)
-	{
-		const LLTextureEntry* te = getTE(i);
-		if(te->hasMedia())
-		{
-			result = true;
-			break;
-		}
-	}
-	return result;
-}
-
-LLVector3 LLVOVolume::getApproximateFaceNormal(U8 face_id)
-{
-	LLVolume* volume = getVolume();
-	LLVector4a result;
-	result.clear();
-
-	LLVector3 ret;
-
-	if (volume && face_id < volume->getNumVolumeFaces())
-	{
-		const LLVolumeFace& face = volume->getVolumeFace(face_id);
-		for (S32 i = 0; i < (S32)face.mNumVertices; ++i)
-		{
-			result.add(face.mNormals[i]);
-		}
-
-		LLVector3 ret(result.getF32ptr());
-		ret = volumeDirectionToAgent(ret);
-		ret.normVec();
-	}
-	
-	return ret;
-}
-
-void LLVOVolume::requestMediaDataUpdate(bool isNew)
-{
-    if (sObjectMediaClient)
-		sObjectMediaClient->fetchMedia(new LLMediaDataClientObjectImpl(this, isNew));
-}
-
-bool LLVOVolume::isMediaDataBeingFetched() const
-{
-	// I know what I'm doing by const_casting this away: this is just 
-	// a wrapper class that is only going to do a lookup.
-	return (sObjectMediaClient) ? sObjectMediaClient->isInQueue(new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false)) : false;
-}
-
-void LLVOVolume::cleanUpMediaImpls()
-{
-	// Iterate through our TEs and remove any Impls that are no longer used
-	const U8 numTEs = getNumTEs();
-	for (U8 i = 0; i < numTEs; i++)
-	{
-		const LLTextureEntry* te = getTE(i);
-		if( ! te->hasMedia())
-		{
-			// Delete the media IMPL!
-			removeMediaImpl(i) ;
-		}
-	}
-}
-
-void LLVOVolume::updateObjectMediaData(const LLSD &media_data_array, const std::string &media_version)
-{
-	// media_data_array is an array of media entry maps
-	// media_version is the version string in the response.
-	U32 fetched_version = LLTextureEntry::getVersionFromMediaVersionString(media_version);
-
-	// Only update it if it is newer!
-	if ( (S32)fetched_version > mLastFetchedMediaVersion)
-	{
-		mLastFetchedMediaVersion = fetched_version;
-		//llinfos << "updating:" << this->getID() << " " << ll_pretty_print_sd(media_data_array) << llendl;
-		
-		LLSD::array_const_iterator iter = media_data_array.beginArray();
-		LLSD::array_const_iterator end = media_data_array.endArray();
-		U8 texture_index = 0;
-		for (; iter != end; ++iter, ++texture_index)
-		{
-			syncMediaData(texture_index, *iter, false/*merge*/, false/*ignore_agent*/);
-		}
-	}
-}
-
-void LLVOVolume::syncMediaData(S32 texture_index, const LLSD &media_data, bool merge, bool ignore_agent)
-{
-	if(mDead)
-	{
-		// If the object has been marked dead, don't process media updates.
-		return;
-	}
-	
-	LLTextureEntry *te = getTE(texture_index);
-	if(!te)
-	{
-		return ;
-	}
-
-	LL_DEBUGS("MediaOnAPrim") << "BEFORE: texture_index = " << texture_index
-		<< " hasMedia = " << te->hasMedia() << " : " 
-		<< ((NULL == te->getMediaData()) ? "NULL MEDIA DATA" : ll_pretty_print_sd(te->getMediaData()->asLLSD())) << llendl;
-
-	std::string previous_url;
-	LLMediaEntry* mep = te->getMediaData();
-	if(mep)
-	{
-		// Save the "current url" from before the update so we can tell if
-		// it changes. 
-		previous_url = mep->getCurrentURL();
-	}
-
-	if (merge)
-	{
-		te->mergeIntoMediaData(media_data);
-	}
-	else {
-		// XXX Question: what if the media data is undefined LLSD, but the
-		// update we got above said that we have media flags??	Here we clobber
-		// that, assuming the data from the service is more up-to-date. 
-		te->updateMediaData(media_data);
-	}
-
-	mep = te->getMediaData();
-	if(mep)
-	{
-		bool update_from_self = false;
-		if (!ignore_agent) 
-		{
-			LLUUID updating_agent = LLTextureEntry::getAgentIDFromMediaVersionString(getMediaURL());
-			update_from_self = (updating_agent == gAgent.getID());
-		}
-		viewer_media_t media_impl = LLViewerMedia::updateMediaImpl(mep, previous_url, update_from_self);
-			
-		addMediaImpl(media_impl, texture_index) ;
-	}
-	else
-	{
-		removeMediaImpl(texture_index);
-	}
-
-	LL_DEBUGS("MediaOnAPrim") << "AFTER: texture_index = " << texture_index
-		<< " hasMedia = " << te->hasMedia() << " : " 
-		<< ((NULL == te->getMediaData()) ? "NULL MEDIA DATA" : ll_pretty_print_sd(te->getMediaData()->asLLSD())) << llendl;
-}
-
-void LLVOVolume::mediaNavigateBounceBack(U8 texture_index)
-{
-	// Find the media entry for this navigate
-	const LLMediaEntry* mep = NULL;
-	viewer_media_t impl = getMediaImpl(texture_index);
-	LLTextureEntry *te = getTE(texture_index);
-	if(te)
-	{
-		mep = te->getMediaData();
-	}
-	
-	if (mep && impl)
-	{
-        std::string url = mep->getCurrentURL();
-		// Look for a ":", if not there, assume "http://"
-		if (!url.empty() && std::string::npos == url.find(':')) 
-		{
-			url = "http://" + url;
-		}
-		// If the url we're trying to "bounce back" to is either empty or not
-		// allowed by the whitelist, try the home url.  If *that* doesn't work,
-		// set the media as failed and unload it
-        if (url.empty() || !mep->checkCandidateUrl(url))
-        {
-            url = mep->getHomeURL();
-			// Look for a ":", if not there, assume "http://"
-			if (!url.empty() && std::string::npos == url.find(':')) 
-			{
-				url = "http://" + url;
-			}
-        }
-        if (url.empty() || !mep->checkCandidateUrl(url))
-		{
-			// The url to navigate back to is not good, and we have nowhere else
-			// to go.
-			LL_WARNS("MediaOnAPrim") << "FAILED to bounce back URL \"" << url << "\" -- unloading impl" << LL_ENDL;
-			impl->setMediaFailed(true);
-		}
-		else {
-			// Okay, navigate now
-            LL_INFOS("MediaOnAPrim") << "bouncing back to URL: " << url << LL_ENDL;
-            impl->navigateTo(url, "", false, true);
-        }
-    }
-}
-
-bool LLVOVolume::hasMediaPermission(const LLMediaEntry* media_entry, MediaPermType perm_type)
-{
-    // NOTE: This logic ALMOST duplicates the logic in the server (in particular, in llmediaservice.cpp).
-    if (NULL == media_entry ) return false; // XXX should we assert here?
-    
-    // The agent has permissions if:
-    // - world permissions are on, or
-    // - group permissions are on, and agent_id is in the group, or
-    // - agent permissions are on, and agent_id is the owner
-    
-	// *NOTE: We *used* to check for modify permissions here (i.e. permissions were
-	// granted if permModify() was true).  However, this doesn't make sense in the
-	// viewer: we don't want to show controls or allow interaction if the author
-	// has deemed it so.  See DEV-42115.
-	
-    U8 media_perms = (perm_type == MEDIA_PERM_INTERACT) ? media_entry->getPermsInteract() : media_entry->getPermsControl();
-    
-    // World permissions
-    if (0 != (media_perms & LLMediaEntry::PERM_ANYONE)) 
-    {
-        return true;
-    }
-    
-    // Group permissions
-    else if (0 != (media_perms & LLMediaEntry::PERM_GROUP))
-    {
-		LLPermissions* obj_perm = LLSelectMgr::getInstance()->findObjectPermissions(this);
-		if (obj_perm && gAgent.isInGroup(obj_perm->getGroup()))
-		{
-			return true;
-		}
-    }
-    
-    // Owner permissions
-    else if (0 != (media_perms & LLMediaEntry::PERM_OWNER) && permYouOwner()) 
-    {
-        return true;
-    }
-    
-    return false;
-    
-}
-
-void LLVOVolume::mediaNavigated(LLViewerMediaImpl *impl, LLPluginClassMedia* plugin, std::string new_location)
-{
-	bool block_navigation = false;
-	// FIXME: if/when we allow the same media impl to be used by multiple faces, the logic here will need to be fixed
-	// to deal with multiple face indices.
-	int face_index = getFaceIndexWithMediaImpl(impl, -1);
-	
-	// Find the media entry for this navigate
-	LLMediaEntry* mep = NULL;
-	LLTextureEntry *te = getTE(face_index);
-	if(te)
-	{
-		mep = te->getMediaData();
-	}
-	
-	if(mep)
-	{
-		if(!mep->checkCandidateUrl(new_location))
-		{
-			block_navigation = true;
-		}
-		if (!block_navigation && !hasMediaPermission(mep, MEDIA_PERM_INTERACT))
-		{
-			block_navigation = true;
-		}
-	}
-	else
-	{
-		LL_WARNS("MediaOnAPrim") << "Couldn't find media entry!" << LL_ENDL;
-	}
-						
-	if(block_navigation)
-	{
-		LL_INFOS("MediaOnAPrim") << "blocking navigate to URI " << new_location << LL_ENDL;
-
-		// "bounce back" to the current URL from the media entry
-		mediaNavigateBounceBack(face_index);
-	}
-	else if (sObjectMediaNavigateClient)
-	{
-		
-		LL_DEBUGS("MediaOnAPrim") << "broadcasting navigate with URI " << new_location << LL_ENDL;
-
-		sObjectMediaNavigateClient->navigate(new LLMediaDataClientObjectImpl(this, false), face_index, new_location);
-	}
-}
-
-void LLVOVolume::mediaEvent(LLViewerMediaImpl *impl, LLPluginClassMedia* plugin, LLViewerMediaObserver::EMediaEvent event)
-{
-	switch(event)
-	{
-		
-		case LLViewerMediaObserver::MEDIA_EVENT_LOCATION_CHANGED:
-		{			
-			switch(impl->getNavState())
-			{
-				case LLViewerMediaImpl::MEDIANAVSTATE_FIRST_LOCATION_CHANGED:
-				{
-					// This is the first location changed event after the start of a non-server-directed nav.  It may need to be broadcast or bounced back.
-					mediaNavigated(impl, plugin, plugin->getLocation());
-				}
-				break;
-				
-				case LLViewerMediaImpl::MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS:
-					// This navigate didn't change the current URL.  
-					LL_DEBUGS("MediaOnAPrim") << "	NOT broadcasting navigate (spurious)" << LL_ENDL;
-				break;
-				
-				case LLViewerMediaImpl::MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED:
-					// This is the first location changed event after the start of a server-directed nav.  Don't broadcast it.
-					LL_INFOS("MediaOnAPrim") << "	NOT broadcasting navigate (server-directed)" << LL_ENDL;
-				break;
-				
-				default:
-					// This is a subsequent location-changed due to a redirect.	 Don't broadcast.
-					LL_INFOS("MediaOnAPrim") << "	NOT broadcasting navigate (redirect)" << LL_ENDL;
-				break;
-			}
-		}
-		break;
-		
-		case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_COMPLETE:
-		{
-			switch(impl->getNavState())
-			{
-				case LLViewerMediaImpl::MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED:
-				{
-					// This is the first location changed event after the start of a non-server-directed nav.  It may need to be broadcast or bounced back.
-					mediaNavigated(impl, plugin, plugin->getNavigateURI());
-				}
-				break;
-				
-				case LLViewerMediaImpl::MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS:
-					// This navigate didn't change the current URL.  
-					LL_DEBUGS("MediaOnAPrim") << "	NOT broadcasting navigate (spurious)" << LL_ENDL;
-				break;
-
-				case LLViewerMediaImpl::MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED:
-					// This is the the navigate complete event from a server-directed nav.  Don't broadcast it.
-					LL_INFOS("MediaOnAPrim") << "	NOT broadcasting navigate (server-directed)" << LL_ENDL;
-				break;
-				
-				default:
-					// For all other states, the navigate should have been handled by LOCATION_CHANGED events already.
-				break;
-			}
-		}
-		break;
-		
-		default:
-		break;
-	}
-
-}
-
-void LLVOVolume::sendMediaDataUpdate()
-{
-    if (sObjectMediaClient)
-		sObjectMediaClient->updateMedia(new LLMediaDataClientObjectImpl(this, false));
-}
-
-void LLVOVolume::removeMediaImpl(S32 texture_index)
-{
-	if(mMediaImplList.size() <= (U32)texture_index || mMediaImplList[texture_index].isNull())
-	{
-		return ;
-	}
-
-	//make the face referencing to mMediaImplList[texture_index] to point back to the old texture.
-	if(mDrawable && texture_index < mDrawable->getNumFaces())
-	{
-		LLFace* facep = mDrawable->getFace(texture_index) ;
-		if(facep)
-		{
-			LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[texture_index]->getMediaTextureID()) ;
-			if(media_tex)
-			{
-				media_tex->removeMediaFromFace(facep) ;
-			}
-		}
-	}		
-	
-	//check if some other face(s) of this object reference(s)to this media impl.
-	S32 i ;
-	S32 end = (S32)mMediaImplList.size() ;
-	for(i = 0; i < end ; i++)
-	{
-		if( i != texture_index && mMediaImplList[i] == mMediaImplList[texture_index])
-		{
-			break ;
-		}
-	}
-
-	if(i == end) //this object does not need this media impl.
-	{
-		mMediaImplList[texture_index]->removeObject(this) ;
-	}
-
-	mMediaImplList[texture_index] = NULL ;
-	return ;
-}
-
-void LLVOVolume::addMediaImpl(LLViewerMediaImpl* media_impl, S32 texture_index)
-{
-	if((S32)mMediaImplList.size() < texture_index + 1)
-	{
-		mMediaImplList.resize(texture_index + 1) ;
-	}
-	
-	if(mMediaImplList[texture_index].notNull())
-	{
-		if(mMediaImplList[texture_index] == media_impl)
-		{
-			return ;
-		}
-
-		removeMediaImpl(texture_index) ;
-	}
-
-	mMediaImplList[texture_index] = media_impl;
-	media_impl->addObject(this) ;	
-
-	//add the face to show the media if it is in playing
-	if(mDrawable)
-	{
-		LLFace* facep = mDrawable->getFace(texture_index) ;
-		if(facep)
-		{
-			LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[texture_index]->getMediaTextureID()) ;
-			if(media_tex)
-			{
-				media_tex->addMediaToFace(facep) ;
-			}
-		}
-		else //the face is not available now, start media on this face later.
-		{
-			media_impl->setUpdated(TRUE) ;
-		}
-	}
-	return ;
-}
-
-viewer_media_t LLVOVolume::getMediaImpl(U8 face_id) const
-{
-	if(mMediaImplList.size() > face_id)
-	{
-		return mMediaImplList[face_id];
-	}
-	return NULL;
-}
-
-F64 LLVOVolume::getTotalMediaInterest() const
-{
-	// If this object is currently focused, this object has "high" interest
-	if (LLViewerMediaFocus::getInstance()->getFocusedObjectID() == getID())
-		return F64_MAX;
-	
-	F64 interest = (F64)-1.0;  // means not interested;
-    
-	// If this object is selected, this object has "high" interest, but since 
-	// there can be more than one, we still add in calculated impl interest
-	// XXX Sadly, 'contains()' doesn't take a const :(
-	if (LLSelectMgr::getInstance()->getSelection()->contains(const_cast<LLVOVolume*>(this)))
-		interest = F64_MAX / 2.0;
-	
-	int i = 0;
-	const int end = getNumTEs();
-	for ( ; i < end; ++i)
-	{
-		const viewer_media_t &impl = getMediaImpl(i);
-		if (!impl.isNull())
-		{
-			if (interest == (F64)-1.0) interest = (F64)0.0;
-			interest += impl->getInterest();
-		}
-	}
-	return interest;
-}
-
-S32 LLVOVolume::getFaceIndexWithMediaImpl(const LLViewerMediaImpl* media_impl, S32 start_face_id)
-{
-	S32 end = (S32)mMediaImplList.size() ;
-	for(S32 face_id = start_face_id + 1; face_id < end; face_id++)
-	{
-		if(mMediaImplList[face_id] == media_impl)
-		{
-			return face_id ;
-		}
-	}
-	return -1 ;
-}
-
-//----------------------------------------------------------------------------
-
-void LLVOVolume::setLightTextureID(LLUUID id)
-{
-	if (id.notNull())
-	{
-		if (!hasLightTexture())
-		{
-			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, TRUE, true);
-		}
-		LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
-		if (param_block && param_block->getLightTexture() != id)
-		{
-			param_block->setLightTexture(id);
-			parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
-		}
-	}
-	else
-	{
-		if (hasLightTexture())
-		{
-			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, FALSE, true);
-			mLightTexture = NULL;
-		}
-	}		
-}
-
-void LLVOVolume::setSpotLightParams(LLVector3 params)
-{
-	LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
-	if (param_block && param_block->getParams() != params)
-	{
-		param_block->setParams(params);
-		parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
-	}
-}
-		
-void LLVOVolume::setIsLight(BOOL is_light)
-{
-	if (is_light != getIsLight())
-	{
-		if (is_light)
-		{
-			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT, TRUE, true);
-		}
-		else
-		{
-			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT, FALSE, true);
-		}
-
-		if (is_light)
-		{
-			// Add it to the pipeline mLightSet
-			gPipeline.setLight(mDrawable, TRUE);
-		}
-		else
-		{
-			// Not a light.  Remove it from the pipeline's light set.
-			gPipeline.setLight(mDrawable, FALSE);
-		}
-	}
-}
-
-void LLVOVolume::setLightColor(const LLColor3& color)
-{
-	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		if (param_block->getColor() != color)
-		{
-			param_block->setColor(LLColor4(color, param_block->getColor().mV[3]));
-			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
-			gPipeline.markTextured(mDrawable);
-			mFaceMappingChanged = TRUE;
-		}
-	}
-}
-
-void LLVOVolume::setLightIntensity(F32 intensity)
-{
-	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		if (param_block->getColor().mV[3] != intensity)
-		{
-			param_block->setColor(LLColor4(LLColor3(param_block->getColor()), intensity));
-			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
-		}
-	}
-}
-
-void LLVOVolume::setLightRadius(F32 radius)
-{
-	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		if (param_block->getRadius() != radius)
-		{
-			param_block->setRadius(radius);
-			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
-		}
-	}
-}
-
-void LLVOVolume::setLightFalloff(F32 falloff)
-{
-	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		if (param_block->getFalloff() != falloff)
-		{
-			param_block->setFalloff(falloff);
-			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
-		}
-	}
-}
-
-void LLVOVolume::setLightCutoff(F32 cutoff)
-{
-	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		if (param_block->getCutoff() != cutoff)
-		{
-			param_block->setCutoff(cutoff);
-			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
-		}
-	}
-}
-
-//----------------------------------------------------------------------------
-
-BOOL LLVOVolume::getIsLight() const
-{
-	return getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT);
-}
-
-LLColor3 LLVOVolume::getLightBaseColor() const
-{
-	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		return LLColor3(param_block->getColor());
-	}
-	else
-	{
-		return LLColor3(1,1,1);
-	}
-}
-
-LLColor3 LLVOVolume::getLightColor() const
-{
-	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		return LLColor3(param_block->getColor()) * param_block->getColor().mV[3];
-	}
-	else
-	{
-		return LLColor3(1,1,1);
-	}
-}
-
-LLUUID LLVOVolume::getLightTextureID() const
-{
-	if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
-	{
-		const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
-		if (param_block)
-		{
-			return param_block->getLightTexture();
-		}
-	}
-	
-	return LLUUID::null;
-}
-
-
-LLVector3 LLVOVolume::getSpotLightParams() const
-{
-	if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
-	{
-		const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
-		if (param_block)
-		{
-			return param_block->getParams();
-		}
-	}
-	
-	return LLVector3();
-}
-
-F32 LLVOVolume::getSpotLightPriority() const
-{
-	return mSpotLightPriority;
-}
-
-void LLVOVolume::updateSpotLightPriority()
-{
-	LLVector3 pos = mDrawable->getPositionAgent();
-	LLVector3 at(0,0,-1);
-	at *= getRenderRotation();
-
-	F32 r = getLightRadius()*0.5f;
-
-	pos += at * r;
-
-	at = LLViewerCamera::getInstance()->getAtAxis();
-
-	pos -= at * r;
-	
-	mSpotLightPriority = gPipeline.calcPixelArea(pos, LLVector3(r,r,r), *LLViewerCamera::getInstance());
-
-	if (mLightTexture.notNull())
-	{
-		mLightTexture->addTextureStats(mSpotLightPriority);
-		mLightTexture->setBoostLevel(LLViewerTexture::BOOST_CLOUDS);
-	}
-}
-
-
-bool LLVOVolume::isLightSpotlight() const
-{
-	LLLightImageParams* params = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
-	if (params)
-	{
-		return params->isLightSpotlight();
-	}
-	return false;
-}
-
-
-LLViewerTexture* LLVOVolume::getLightTexture()
-{
-	LLUUID id = getLightTextureID();
-
-	if (id.notNull())
-	{
-		if (mLightTexture.isNull() || id != mLightTexture->getID())
-		{
-			mLightTexture = LLViewerTextureManager::getFetchedTexture(id);
-		}
-	}
-	else
-	{
-		mLightTexture = NULL;
-	}
-
-	return mLightTexture;
-}
-
-F32 LLVOVolume::getLightIntensity() const
-{
-	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		return param_block->getColor().mV[3];
-	}
-	else
-	{
-		return 1.f;
-	}
-}
-
-F32 LLVOVolume::getLightRadius() const
-{
-	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		return param_block->getRadius();
-	}
-	else
-	{
-		return 0.f;
-	}
-}
-
-F32 LLVOVolume::getLightFalloff() const
-{
-	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		return param_block->getFalloff();
-	}
-	else
-	{
-		return 0.f;
-	}
-}
-
-F32 LLVOVolume::getLightCutoff() const
-{
-	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
-	if (param_block)
-	{
-		return param_block->getCutoff();
-	}
-	else
-	{
-		return 0.f;
-	}
-}
-
-U32 LLVOVolume::getVolumeInterfaceID() const
-{
-	if (mVolumeImpl)
-	{
-		return mVolumeImpl->getID();
-	}
-
-	return 0;
-}
-
-BOOL LLVOVolume::isFlexible() const
-{
-	if (getParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE))
-	{
-		LLVolume* volume = getVolume();
-		if (volume && volume->getParams().getPathParams().getCurveType() != LL_PCODE_PATH_FLEXIBLE)
-		{
-			LLVolumeParams volume_params = getVolume()->getParams();
-			U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
-			volume_params.setType(profile_and_hole, LL_PCODE_PATH_FLEXIBLE);
-		}
-		return TRUE;
-	}
-	else
-	{
-		return FALSE;
-	}
-}
-
-BOOL LLVOVolume::isSculpted() const
-{
-	if (getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
-	{
-		return TRUE;
-	}
-	
-	return FALSE;
-}
-
-BOOL LLVOVolume::isMesh() const
-{
-	if (isSculpted())
-	{
-		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
-		U8 sculpt_type = sculpt_params->getSculptType();
-
-		if ((sculpt_type & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
-			// mesh is a mesh
-		{
-			return TRUE;	
-		}
-	}
-
-	return FALSE;
-}
-
-BOOL LLVOVolume::hasLightTexture() const
-{
-	if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
-	{
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-BOOL LLVOVolume::isVolumeGlobal() const
-{
-	if (mVolumeImpl)
-	{
-		return mVolumeImpl->isVolumeGlobal() ? TRUE : FALSE;
-	}
-	else if (mRiggedVolume.notNull())
-	{
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-BOOL LLVOVolume::canBeFlexible() const
-{
-	U8 path = getVolume()->getParams().getPathParams().getCurveType();
-	return (path == LL_PCODE_PATH_FLEXIBLE || path == LL_PCODE_PATH_LINE);
-}
-
-BOOL LLVOVolume::setIsFlexible(BOOL is_flexible)
-{
-	BOOL res = FALSE;
-	BOOL was_flexible = isFlexible();
-	LLVolumeParams volume_params;
-	if (is_flexible)
-	{
-		if (!was_flexible)
-		{
-			volume_params = getVolume()->getParams();
-			U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
-			volume_params.setType(profile_and_hole, LL_PCODE_PATH_FLEXIBLE);
-			res = TRUE;
-			setFlags(FLAGS_USE_PHYSICS, FALSE);
-			setFlags(FLAGS_PHANTOM, TRUE);
-			setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, TRUE, true);
-			if (mDrawable)
-			{
-				mDrawable->makeActive();
-			}
-		}
-	}
-	else
-	{
-		if (was_flexible)
-		{
-			volume_params = getVolume()->getParams();
-			U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
-			volume_params.setType(profile_and_hole, LL_PCODE_PATH_LINE);
-			res = TRUE;
-			setFlags(FLAGS_PHANTOM, FALSE);
-			setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, FALSE, true);
-		}
-	}
-	if (res)
-	{
-		res = setVolume(volume_params, 1);
-		if (res)
-		{
-			markForUpdate(TRUE);
-		}
-	}
-	return res;
-}
-
-//----------------------------------------------------------------------------
-
-void LLVOVolume::generateSilhouette(LLSelectNode* nodep, const LLVector3& view_point)
-{
-	LLVolume *volume = getVolume();
-
-	if (volume)
-	{
-		LLVector3 view_vector;
-		view_vector = view_point; 
-
-		//transform view vector into volume space
-		view_vector -= getRenderPosition();
-		mDrawable->mDistanceWRTCamera = view_vector.length();
-		LLQuaternion worldRot = getRenderRotation();
-		view_vector = view_vector * ~worldRot;
-		if (!isVolumeGlobal())
-		{
-			LLVector3 objScale = getScale();
-			LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
-			view_vector.scaleVec(invObjScale);
-		}
-		
-		updateRelativeXform();
-		LLMatrix4 trans_mat = mRelativeXform;
-		if (mDrawable->isStatic())
-		{
-			trans_mat.translate(getRegion()->getOriginAgent());
-		}
-
-		volume->generateSilhouetteVertices(nodep->mSilhouetteVertices, nodep->mSilhouetteNormals, view_vector, trans_mat, mRelativeXformInvTrans, nodep->getTESelectMask());
-
-		nodep->mSilhouetteExists = TRUE;
-	}
-}
-
-void LLVOVolume::deleteFaces()
-{
-	S32 face_count = mNumFaces;
-	if (mDrawable.notNull())
-	{
-		mDrawable->deleteFaces(0, face_count);
-	}
-
-	mNumFaces = 0;
-}
-
-void LLVOVolume::updateRadius()
-{
-	if (mDrawable.isNull())
-	{
-		return;
-	}
-	
-	mVObjRadius = getScale().length();
-	mDrawable->setRadius(mVObjRadius);
-}
-
-
-BOOL LLVOVolume::isAttachment() const
-{
-	return mState != 0 ;
-}
-
-BOOL LLVOVolume::isHUDAttachment() const
-{
-	// *NOTE: we assume hud attachment points are in defined range
-	// since this range is constant for backwards compatibility
-	// reasons this is probably a reasonable assumption to make
-	S32 attachment_id = ATTACHMENT_ID_FROM_STATE(mState);
-	return ( attachment_id >= 31 && attachment_id <= 38 );
-}
-
-
-const LLMatrix4 LLVOVolume::getRenderMatrix() const
-{
-	if (mDrawable->isActive() && !mDrawable->isRoot())
-	{
-		return mDrawable->getParent()->getWorldMatrix();
-	}
-	return mDrawable->getWorldMatrix();
-}
-
-// Returns a base cost and adds textures to passed in set.
-// total cost is returned value + 5 * size of the resulting set.
-// Cannot include cost of textures, as they may be re-used in linked
-// children, and cost should only be increased for unique textures  -Nyx
-U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
-{
-	// Get access to params we'll need at various points.  
-	// Skip if this is object doesn't have a volume (e.g. is an avatar).
-	BOOL has_volume = (getVolume() != NULL);
-	LLVolumeParams volume_params;
-	LLPathParams path_params;
-	LLProfileParams profile_params;
-
-	U32 num_triangles = 0;
-
-	// per-prim costs
-	static const U32 ARC_PARTICLE_COST = 1; // determined experimentally
-	static const U32 ARC_PARTICLE_MAX = 2048; // default values
-	static const U32 ARC_TEXTURE_COST = 16; // multiplier for texture resolution - performance tested
-	static const U32 ARC_LIGHT_COST = 500; // static cost for light-producing prims 
-	static const U32 ARC_MEDIA_FACE_COST = 1500; // static cost per media-enabled face 
-
-
-	// per-prim multipliers
-	static const F32 ARC_GLOW_MULT = 1.5f; // tested based on performance
-	static const F32 ARC_BUMP_MULT = 1.25f; // tested based on performance
-	static const F32 ARC_FLEXI_MULT = 5; // tested based on performance
-	static const F32 ARC_SHINY_MULT = 1.6f; // tested based on performance
-	static const F32 ARC_INVISI_COST = 1.2f; // tested based on performance
-	static const F32 ARC_WEIGHTED_MESH = 1.2f; // tested based on performance
-
-	static const F32 ARC_PLANAR_COST = 1.0f; // tested based on performance to have negligible impact
-	static const F32 ARC_ANIM_TEX_COST = 4.f; // tested based on performance
-	static const F32 ARC_ALPHA_COST = 4.f; // 4x max - based on performance
-
-	F32 shame = 0;
-
-	U32 invisi = 0;
-	U32 shiny = 0;
-	U32 glow = 0;
-	U32 alpha = 0;
-	U32 flexi = 0;
-	U32 animtex = 0;
-	U32 particles = 0;
-	U32 bump = 0;
-	U32 planar = 0;
-	U32 weighted_mesh = 0;
-	U32 produces_light = 0;
-	U32 media_faces = 0;
-
-	// these multipliers are variable and can be floating point
-	F32 scale = 0.f;
-
-	const LLDrawable* drawablep = mDrawable;
-	U32 num_faces = drawablep->getNumFaces();
-
-	if (has_volume)
-	{
-		volume_params = getVolume()->getParams();
-		path_params = volume_params.getPathParams();
-		profile_params = volume_params.getProfileParams();
-
-		F32 weighted_triangles = -1.0;
-		getStreamingCost(NULL, NULL, &weighted_triangles);
-
-		if (weighted_triangles > 0.0)
-		{
-			num_triangles = (U32)(weighted_triangles * 2); // scale weighted triangles to match the recorded scale.
-															// a complex prim (tortured torus, sculptie) should be 1000-1200 points @ 5 m
-		}
-	}
-
-	if (num_triangles == 0)
-	{
-		num_triangles = 4;
-	}
-
-	if (isSculpted())
-	{
-		if (isMesh())
-		{
-			// base cost is dependent on mesh complexity
-			// note that 3 is the highest LOD as of the time of this coding.
-			S32 size = gMeshRepo.getMeshSize(volume_params.getSculptID(),3);
-			if ( size > 0)
-			{
-				if (gMeshRepo.getSkinInfo(volume_params.getSculptID(), this))
-				{
-					// weighted attachment - 1 point for every 3 bytes
-					weighted_mesh = 1;
-				}
-
-			}
-			else
-			{
-				// something went wrong - user should know their content isn't render-free
-				return 0;
-			}
-		}
-		else
-		{
-			const LLSculptParams *sculpt_params = (LLSculptParams *) getParameterEntry(LLNetworkData::PARAMS_SCULPT);
-			LLUUID sculpt_id = sculpt_params->getSculptTexture();
-			if (textures.find(sculpt_id) == textures.end())
-			{
-				LLViewerFetchedTexture *texture = LLViewerTextureManager::getFetchedTexture(sculpt_id);
-				if (texture)
-				{
-					S32 texture_cost = 256 + (S32)(ARC_TEXTURE_COST * (texture->getFullHeight() / 128.f + texture->getFullWidth() / 128.f));
-					textures.insert(texture_cost_t::value_type(sculpt_id, texture_cost));
-				}
-			}
-		}
-	}
-
-	if (isFlexible())
-	{
-		flexi = 1;
-	}
-	if (isParticleSource())
-	{
-		particles = 1;
-	}
-
-	if (getIsLight())
-	{
-		produces_light = 1;
-	}
-
-	const LLVector3& sc = getScale();
-	scale += (sc.mV[0] + sc.mV[1] + sc.mV[2]) / 4.f; // scale to 1/4 the sum of the size
-	// enforce scale multiplier to be in the range [1,7] (7 was determined to experimentally be a reasonable max)
-	scale = scale > 7.f ? 7.f : scale;
-	scale = scale < 1.f ? 1.f : scale;
-
-	for (S32 i = 0; i < num_faces; ++i)
-	{
-		const LLFace* face = drawablep->getFace(i);
-		const LLTextureEntry* te = face->getTextureEntry();
-		const LLViewerTexture* img = face->getTexture();
-
-		if (img)
-		{
-			if (textures.find(img->getID()) == textures.end())
-			{
-				S32 texture_cost = 256 + (S32)(ARC_TEXTURE_COST * (img->getFullHeight() / 128.f + img->getFullWidth() / 128.f));
-				textures.insert(texture_cost_t::value_type(img->getID(), texture_cost));
-			}
-		}
-
-		if (face->getPoolType() == LLDrawPool::POOL_ALPHA)
-		{
-			alpha = 1;
-		}
-		else if (img && img->getPrimaryFormat() == GL_ALPHA)
-		{
-			invisi = 1;
-		}
-		if (face->hasMedia())
-		{
-			media_faces++;
-		}
-
-		if (te)
-		{
-			if (te->getBumpmap())
-			{
-				// bump is a multiplier, don't add per-face
-				bump = 1;
-			}
-			if (te->getShiny())
-			{
-				// shiny is a multiplier, don't add per-face
-				shiny = 1;
-			}
-			if (te->getGlow() > 0.f)
-			{
-				// glow is a multiplier, don't add per-face
-				glow = 1;
-			}
-			if (face->mTextureMatrix != NULL)
-			{
-				animtex = 1;
-			}
-			if (te->getTexGen())
-			{
-				planar = 1;
-			}
-		}
-	}
-
-	// shame currently has the "base" cost of 1 point per 15 triangles, min 2.
-	shame = num_triangles / 15.f;
-	shame = shame < 2.f ? 2.f : shame;
-
-	// factor in scale
-	shame *= scale;
-
-	// multiply by per-face modifiers
-	if (planar)
-	{
-		shame *= planar * ARC_PLANAR_COST;
-	}
-
-	if (animtex)
-	{
-		shame *= animtex * ARC_ANIM_TEX_COST;
-	}
-
-	if (alpha)
-	{
-		shame *= alpha * ARC_ALPHA_COST;
-	}
-
-	if(invisi)
-	{
-		shame *= invisi * ARC_INVISI_COST;
-	}
-
-	if (glow)
-	{
-		shame *= glow * ARC_GLOW_MULT;
-	}
-
-	if (bump)
-	{
-		shame *= bump * ARC_BUMP_MULT;
-	}
-
-	if (shiny)
-	{
-		shame *= shiny * ARC_SHINY_MULT;
-	}
-
-
-	// multiply shame by multipliers
-	if (weighted_mesh)
-	{
-		shame *= weighted_mesh * ARC_WEIGHTED_MESH;
-	}
-
-	if (flexi)
-	{
-		shame *= flexi * ARC_FLEXI_MULT;
-	}
-
-
-	// add additional costs
-	if (particles)
-	{
-		const LLPartSysData *part_sys_data = &(mPartSourcep->mPartSysData);
-		const LLPartData *part_data = &(part_sys_data->mPartData);
-		U32 num_particles = (U32)(part_sys_data->mBurstPartCount * llceil( part_data->mMaxAge / part_sys_data->mBurstRate));
-		num_particles = num_particles > ARC_PARTICLE_MAX ? ARC_PARTICLE_MAX : num_particles;
-		F32 part_size = (llmax(part_data->mStartScale[0], part_data->mEndScale[0]) + llmax(part_data->mStartScale[1], part_data->mEndScale[1])) / 2.f;
-		shame += num_particles * part_size * ARC_PARTICLE_COST;
-	}
-
-	if (produces_light)
-	{
-		shame += ARC_LIGHT_COST;
-	}
-
-	if (media_faces)
-	{
-		shame += media_faces * ARC_MEDIA_FACE_COST;
-	}
-
-	if (shame > mRenderComplexity_current)
-	{
-		mRenderComplexity_current = (S32)shame;
-	}
-
-	return (U32)shame;
-}
-
-F32 LLVOVolume::getStreamingCost(S32* bytes, S32* visible_bytes, F32* unscaled_value) const
-{
-	F32 radius = getScale().length()*0.5f;
-
-	if (isMesh())
-	{	
-		LLSD& header = gMeshRepo.getMeshHeader(getVolume()->getParams().getSculptID());
-
-		return LLMeshRepository::getStreamingCost(header, radius, bytes, visible_bytes, mLOD, unscaled_value);
-	}
-	else
-	{
-		LLVolume* volume = getVolume();
-		S32 counts[4];
-		LLVolume::getLoDTriangleCounts(volume->getParams(), counts);
-
-		LLSD header;
-		header["lowest_lod"]["size"] = counts[0] * 10;
-		header["low_lod"]["size"] = counts[1] * 10;
-		header["medium_lod"]["size"] = counts[2] * 10;
-		header["high_lod"]["size"] = counts[3] * 10;
-
-		return LLMeshRepository::getStreamingCost(header, radius, NULL, NULL, -1, unscaled_value);
-	}	
-}
-
-//static 
-void LLVOVolume::updateRenderComplexity()
-{
-	mRenderComplexity_last = mRenderComplexity_current;
-	mRenderComplexity_current = 0;
-}
-
-U32 LLVOVolume::getTriangleCount() const
-{
-	U32 count = 0;
-	LLVolume* volume = getVolume();
-	if (volume)
-	{
-		count = volume->getNumTriangles();
-	}
-
-	return count;
-}
-
-U32 LLVOVolume::getHighLODTriangleCount()
-{
-	U32 ret = 0;
-
-	LLVolume* volume = getVolume();
-
-	if (!isSculpted())
-	{
-		LLVolume* ref = LLPrimitive::getVolumeManager()->refVolume(volume->getParams(), 3);
-		ret = ref->getNumTriangles();
-		LLPrimitive::getVolumeManager()->unrefVolume(ref);
-	}
-	else if (isMesh())
-	{
-		LLVolume* ref = LLPrimitive::getVolumeManager()->refVolume(volume->getParams(), 3);
-		if (!ref->isMeshAssetLoaded() || ref->getNumVolumeFaces() == 0)
-		{
-			gMeshRepo.loadMesh(this, volume->getParams(), LLModel::LOD_HIGH);
-		}
-		ret = ref->getNumTriangles();
-		LLPrimitive::getVolumeManager()->unrefVolume(ref);
-	}
-	else
-	{ //default sculpts have a constant number of triangles
-		ret = 31*2*31;  //31 rows of 31 columns of quads for a 32x32 vertex patch
-	}
-
-	return ret;
-}
-
-//static
-void LLVOVolume::preUpdateGeom()
-{
-	sNumLODChanges = 0;
-}
-
-void LLVOVolume::parameterChanged(U16 param_type, bool local_origin)
-{
-	LLViewerObject::parameterChanged(param_type, local_origin);
-}
-
-void LLVOVolume::parameterChanged(U16 param_type, LLNetworkData* data, BOOL in_use, bool local_origin)
-{
-	LLViewerObject::parameterChanged(param_type, data, in_use, local_origin);
-	if (mVolumeImpl)
-	{
-		mVolumeImpl->onParameterChanged(param_type, data, in_use, local_origin);
-	}
-	if (mDrawable.notNull())
-	{
-		BOOL is_light = getIsLight();
-		if (is_light != mDrawable->isState(LLDrawable::LIGHT))
-		{
-			gPipeline.setLight(mDrawable, is_light);
-		}
-	}
-}
-
-void LLVOVolume::setSelected(BOOL sel)
-{
-	LLViewerObject::setSelected(sel);
-	if (mDrawable.notNull())
-	{
-		markForUpdate(TRUE);
-	}
-}
-
-void LLVOVolume::updateSpatialExtents(LLVector4a& newMin, LLVector4a& newMax)
-{		
-}
-
-F32 LLVOVolume::getBinRadius()
-{
-	F32 radius;
-	
-	F32 scale = 1.f;
-
-	S32 size_factor = llmax(gSavedSettings.getS32("OctreeStaticObjectSizeFactor"), 1);
-	S32 attachment_size_factor = llmax(gSavedSettings.getS32("OctreeAttachmentSizeFactor"), 1);
-	LLVector3 distance_factor = gSavedSettings.getVector3("OctreeDistanceFactor");
-	LLVector3 alpha_distance_factor = gSavedSettings.getVector3("OctreeAlphaDistanceFactor");
-	const LLVector4a* ext = mDrawable->getSpatialExtents();
-	
-	BOOL shrink_wrap = mDrawable->isAnimating();
-	BOOL alpha_wrap = FALSE;
-
-	if (!isHUDAttachment())
-	{
-		for (S32 i = 0; i < mDrawable->getNumFaces(); i++)
-		{
-			LLFace* face = mDrawable->getFace(i);
-			if (face->getPoolType() == LLDrawPool::POOL_ALPHA &&
-			    !face->canRenderAsMask())
-			{
-				alpha_wrap = TRUE;
-				break;
-			}
-		}
-	}
-	else
-	{
-		shrink_wrap = FALSE;
-	}
-
-	if (alpha_wrap)
-	{
-		LLVector3 bounds = getScale();
-		radius = llmin(bounds.mV[1], bounds.mV[2]);
-		radius = llmin(radius, bounds.mV[0]);
-		radius *= 0.5f;
-		radius *= 1.f+mDrawable->mDistanceWRTCamera*alpha_distance_factor[1];
-		radius += mDrawable->mDistanceWRTCamera*alpha_distance_factor[0];
-	}
-	else if (shrink_wrap)
-	{
-		LLVector4a rad;
-		rad.setSub(ext[1], ext[0]);
-		
-		radius = rad.getLength3().getF32()*0.5f;
-	}
-	else if (mDrawable->isStatic())
-	{
-		radius = llmax((S32) mDrawable->getRadius(), 1)*size_factor;
-		radius *= 1.f + mDrawable->mDistanceWRTCamera * distance_factor[1];
-		radius += mDrawable->mDistanceWRTCamera * distance_factor[0];
-	}
-	else if (mDrawable->getVObj()->isAttachment())
-	{
-		radius = llmax((S32) mDrawable->getRadius(),1)*attachment_size_factor;
-	}
-	else
-	{
-		radius = mDrawable->getRadius();
-		radius *= 1.f + mDrawable->mDistanceWRTCamera * distance_factor[1];
-		radius += mDrawable->mDistanceWRTCamera * distance_factor[0];
-	}
-
-	return llclamp(radius*scale, 0.5f, 256.f);
-}
-
-const LLVector3 LLVOVolume::getPivotPositionAgent() const
-{
-	if (mVolumeImpl)
-	{
-		return mVolumeImpl->getPivotPosition();
-	}
-	return LLViewerObject::getPivotPositionAgent();
-}
-
-void LLVOVolume::onShift(const LLVector4a &shift_vector)
-{
-	if (mVolumeImpl)
-	{
-		mVolumeImpl->onShift(shift_vector);
-	}
-
-	updateRelativeXform();
-}
-
-const LLMatrix4& LLVOVolume::getWorldMatrix(LLXformMatrix* xform) const
-{
-	if (mVolumeImpl)
-	{
-		return mVolumeImpl->getWorldMatrix(xform);
-	}
-	return xform->getWorldMatrix();
-}
-
-LLVector3 LLVOVolume::agentPositionToVolume(const LLVector3& pos) const
-{
-	LLVector3 ret = pos - getRenderPosition();
-	ret = ret * ~getRenderRotation();
-	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
-	LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
-	ret.scaleVec(invObjScale);
-	
-	return ret;
-}
-
-LLVector3 LLVOVolume::agentDirectionToVolume(const LLVector3& dir) const
-{
-	LLVector3 ret = dir * ~getRenderRotation();
-	
-	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
-	ret.scaleVec(objScale);
-
-	return ret;
-}
-
-LLVector3 LLVOVolume::volumePositionToAgent(const LLVector3& dir) const
-{
-	LLVector3 ret = dir;
-	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
-	ret.scaleVec(objScale);
-	ret = ret * getRenderRotation();
-	ret += getRenderPosition();
-	
-	return ret;
-}
-
-LLVector3 LLVOVolume::volumeDirectionToAgent(const LLVector3& dir) const
-{
-	LLVector3 ret = dir;
-	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
-	LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
-	ret.scaleVec(invObjScale);
-	ret = ret * getRenderRotation();
-
-	return ret;
-}
-
-
-BOOL LLVOVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, S32 face, BOOL pick_transparent, S32 *face_hitp,
-									  LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
-	
-{
-	if (!mbCanSelect 
-		|| mDrawable->isDead() 
-		|| !gPipeline.hasRenderType(mDrawable->getRenderType()))
-	{
-		return FALSE;
-	}
-
-	BOOL ret = FALSE;
-
-	LLVolume* volume = getVolume();
-
-	bool transform = true;
-
-	if (mDrawable->isState(LLDrawable::RIGGED))
-	{
-		if (LLFloater::isVisible(gFloaterTools) && getAvatar()->isSelf())
-		{
-			updateRiggedVolume();
-			genBBoxes(FALSE);
-			volume = mRiggedVolume;
-			transform = false;
-		}
-		else
-		{ //cannot pick rigged attachments on other avatars or when not in build mode
-			return FALSE;
-		}
-	}
-	
-	if (volume)
-	{	
-		LLVector3 v_start, v_end, v_dir;
-	
-		if (transform)
-		{
-			v_start = agentPositionToVolume(start);
-			v_end = agentPositionToVolume(end);
-		}
-		else
-		{
-			v_start = start;
-			v_end = end;
-		}
-		
-		LLVector3 p;
-		LLVector3 n;
-		LLVector2 tc;
-		LLVector3 bn;
-
-		if (intersection != NULL)
-		{
-			p = *intersection;
-		}
-
-		if (tex_coord != NULL)
-		{
-			tc = *tex_coord;
-		}
-
-		if (normal != NULL)
-		{
-			n = *normal;
-		}
-
-		if (bi_normal != NULL)
-		{
-			bn = *bi_normal;
-		}
-
-		S32 face_hit = -1;
-
-		S32 start_face, end_face;
-		if (face == -1)
-		{
-			start_face = 0;
-			end_face = volume->getNumVolumeFaces();
-		}
-		else
-		{
-			start_face = face;
-			end_face = face+1;
-		}
-
-		bool special_cursor = specialHoverCursor();
-		for (S32 i = start_face; i < end_face; ++i)
-		{
-			if (!special_cursor && !pick_transparent && getTE(i)->getColor().mV[3] == 0.f)
-			{ //don't attempt to pick completely transparent faces unless
-				//pick_transparent is true
-				continue;
-			}
-
-			face_hit = volume->lineSegmentIntersect(v_start, v_end, i,
-													&p, &tc, &n, &bn);
-			
-			if (face_hit >= 0 && mDrawable->getNumFaces() > face_hit)
-			{
-				LLFace* face = mDrawable->getFace(face_hit);				
-
-				if (pick_transparent || !face->getTexture() || !face->getTexture()->hasGLTexture() || face->getTexture()->getMask(face->surfaceToTexture(tc, p, n)))
-				{
-					v_end = p;
-					if (face_hitp != NULL)
-					{
-						*face_hitp = face_hit;
-					}
-					
-					if (intersection != NULL)
-					{
-						if (transform)
-						{
-							*intersection = volumePositionToAgent(p);  // must map back to agent space
-						}
-						else
-						{
-							*intersection = p;
-						}
-					}
-
-					if (normal != NULL)
-					{
-						if (transform)
-						{
-							*normal = volumeDirectionToAgent(n);
-						}
-						else
-						{
-							*normal = n;
-						}
-
-						(*normal).normVec();
-					}
-
-					if (bi_normal != NULL)
-					{
-						if (transform)
-						{
-							*bi_normal = volumeDirectionToAgent(bn);
-						}
-						else
-						{
-							*bi_normal = bn;
-						}
-						(*bi_normal).normVec();
-					}
-
-					if (tex_coord != NULL)
-					{
-						*tex_coord = tc;
-					}
-					
-					ret = TRUE;
-				}
-			}
-		}
-	}
-		
-	return ret;
-}
-
-bool LLVOVolume::treatAsRigged()
-{
-	return LLFloater::isVisible(gFloaterTools) && 
-			isAttachment() && 
-			getAvatar() &&
-			getAvatar()->isSelf() &&
-			mDrawable.notNull() &&
-			mDrawable->isState(LLDrawable::RIGGED);
-}
-
-LLRiggedVolume* LLVOVolume::getRiggedVolume()
-{
-	return mRiggedVolume;
-}
-
-void LLVOVolume::clearRiggedVolume()
-{
-	if (mRiggedVolume.notNull())
-	{
-		mRiggedVolume = NULL;
-		updateRelativeXform();
-	}
-}
-
-void LLVOVolume::updateRiggedVolume()
-{
-	//Update mRiggedVolume to match current animation frame of avatar. 
-	//Also update position/size in octree.  
-
-	if (!treatAsRigged())
-	{
-		clearRiggedVolume();
-		
-		return;
-	}
-
-	LLVolume* volume = getVolume();
-
-	const LLMeshSkinInfo* skin = gMeshRepo.getSkinInfo(volume->getParams().getSculptID(), this);
-
-	if (!skin)
-	{
-		clearRiggedVolume();
-		return;
-	}
-
-	LLVOAvatar* avatar = getAvatar();
-
-	if (!avatar)
-	{
-		clearRiggedVolume();
-		return;
-	}
-
-	if (!mRiggedVolume)
-	{
-		LLVolumeParams p;
-		mRiggedVolume = new LLRiggedVolume(p);
-		updateRelativeXform();
-	}
-
-	mRiggedVolume->update(skin, avatar, volume);
-
-}
-
-static LLFastTimer::DeclareTimer FTM_SKIN_RIGGED("Skin");
-static LLFastTimer::DeclareTimer FTM_RIGGED_OCTREE("Octree");
-
-void LLRiggedVolume::update(const LLMeshSkinInfo* skin, LLVOAvatar* avatar, const LLVolume* volume)
-{
-	bool copy = false;
-	if (volume->getNumVolumeFaces() != getNumVolumeFaces())
-	{ 
-		copy = true;
-	}
-
-	for (S32 i = 0; i < volume->getNumVolumeFaces() && !copy; ++i)
-	{
-		const LLVolumeFace& src_face = volume->getVolumeFace(i);
-		const LLVolumeFace& dst_face = getVolumeFace(i);
-
-		if (src_face.mNumIndices != dst_face.mNumIndices ||
-			src_face.mNumVertices != dst_face.mNumVertices)
-		{
-			copy = true;
-		}
-	}
-
-	if (copy)
-	{
-		copyVolumeFaces(volume);	
-	}
-
-	//build matrix palette
-	LLMatrix4a mp[64];
-	LLMatrix4* mat = (LLMatrix4*) mp;
-	
-	for (U32 j = 0; j < skin->mJointNames.size(); ++j)
-	{
-		LLJoint* joint = avatar->getJoint(skin->mJointNames[j]);
-		if (joint)
-		{
-			mat[j] = skin->mInvBindMatrix[j];
-			mat[j] *= joint->getWorldMatrix();
-		}
-	}
-
-	for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
-	{
-		const LLVolumeFace& vol_face = volume->getVolumeFace(i);
-		
-		LLVolumeFace& dst_face = mVolumeFaces[i];
-		
-		LLVector4a* weight = vol_face.mWeights;
-
-		LLMatrix4a bind_shape_matrix;
-		bind_shape_matrix.loadu(skin->mBindShapeMatrix);
-
-		LLVector4a* pos = dst_face.mPositions;
-
-		{
-			LLFastTimer t(FTM_SKIN_RIGGED);
-
-			for (U32 j = 0; j < dst_face.mNumVertices; ++j)
-			{
-				LLMatrix4a final_mat;
-				final_mat.clear();
-
-				S32 idx[4];
-
-				LLVector4 wght;
-
-				F32 scale = 0.f;
-				for (U32 k = 0; k < 4; k++)
-				{
-					F32 w = weight[j][k];
-
-					idx[k] = (S32) floorf(w);
-					wght[k] = w - floorf(w);
-					scale += wght[k];
-				}
-
-				wght *= 1.f/scale;
-
-				for (U32 k = 0; k < 4; k++)
-				{
-					F32 w = wght[k];
-
-					LLMatrix4a src;
-					src.setMul(mp[idx[k]], w);
-
-					final_mat.add(src);
-				}
-
-				
-				LLVector4a& v = vol_face.mPositions[j];
-				LLVector4a t;
-				LLVector4a dst;
-				bind_shape_matrix.affineTransform(v, t);
-				final_mat.affineTransform(t, dst);
-				pos[j] = dst;
-			}
-
-			//update bounding box
-			LLVector4a& min = dst_face.mExtents[0];
-			LLVector4a& max = dst_face.mExtents[1];
-
-			min = pos[0];
-			max = pos[1];
-
-			for (U32 j = 1; j < dst_face.mNumVertices; ++j)
-			{
-				min.setMin(min, pos[j]);
-				max.setMax(max, pos[j]);
-			}
-
-			dst_face.mCenter->setAdd(dst_face.mExtents[0], dst_face.mExtents[1]);
-			dst_face.mCenter->mul(0.5f);
-
-		}
-
-		{
-			LLFastTimer t(FTM_RIGGED_OCTREE);
-			delete dst_face.mOctree;
-			dst_face.mOctree = NULL;
-
-			LLVector4a size;
-			size.setSub(dst_face.mExtents[1], dst_face.mExtents[0]);
-			size.splat(size.getLength3().getF32()*0.5f);
-			
-			dst_face.createOctree(1.f);
-		}
-	}
-}
-
-U32 LLVOVolume::getPartitionType() const
-{
-	if (isHUDAttachment())
-	{
-		return LLViewerRegion::PARTITION_HUD;
-	}
-
-	return LLViewerRegion::PARTITION_VOLUME;
-}
-
-LLVolumePartition::LLVolumePartition()
-: LLSpatialPartition(LLVOVolume::VERTEX_DATA_MASK, TRUE, GL_DYNAMIC_DRAW_ARB)
-{
-	mLODPeriod = 32;
-	mDepthMask = FALSE;
-	mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
-	mPartitionType = LLViewerRegion::PARTITION_VOLUME;
-	mSlopRatio = 0.25f;
-	mBufferUsage = GL_DYNAMIC_DRAW_ARB;
-}
-
-LLVolumeBridge::LLVolumeBridge(LLDrawable* drawablep)
-: LLSpatialBridge(drawablep, TRUE, LLVOVolume::VERTEX_DATA_MASK)
-{
-	mDepthMask = FALSE;
-	mLODPeriod = 32;
-	mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
-	mPartitionType = LLViewerRegion::PARTITION_BRIDGE;
-	
-	mBufferUsage = GL_DYNAMIC_DRAW_ARB;
-
-	mSlopRatio = 0.25f;
-}
-
-bool can_batch_texture(LLFace* facep)
-{
-	if (facep->getTextureEntry()->getBumpmap())
-	{ //bump maps aren't worked into texture batching yet
-		return false;
-	}
-
-	if (facep->getTexture() && facep->getTexture()->getPrimaryFormat() == GL_ALPHA)
-	{ //can't batch invisiprims
-		return false;
-	}
-
-	if (facep->isState(LLFace::TEXTURE_ANIM) && facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
-	{ //texture animation breaks batches
-		return false;
-	}
-	
-	return true;
-}
-
-void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, U32 type)
-{
-	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
-
-	if (facep->getViewerObject()->isSelected() && LLSelectMgr::getInstance()->mHideSelectedObjects)
-	{
-		return;
-	}
-
-	//add face to drawmap
-	LLSpatialGroup::drawmap_elem_t& draw_vec = group->mDrawMap[type];	
-
-	S32 idx = draw_vec.size()-1;
-
-	BOOL fullbright = (type == LLRenderPass::PASS_FULLBRIGHT) ||
-		(type == LLRenderPass::PASS_INVISIBLE) ||
-		(type == LLRenderPass::PASS_ALPHA && facep->isState(LLFace::FULLBRIGHT));
-	
-	if (!fullbright && type != LLRenderPass::PASS_GLOW && !facep->getVertexBuffer()->hasDataType(LLVertexBuffer::TYPE_NORMAL))
-	{
-		llwarns << "Non fullbright face has no normals!" << llendl;
-		return;
-	}
-
-	const LLMatrix4* tex_mat = NULL;
-	if (facep->isState(LLFace::TEXTURE_ANIM) && facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
-	{
-		tex_mat = facep->mTextureMatrix;	
-	}
-
-	const LLMatrix4* model_mat = NULL;
-
-	LLDrawable* drawable = facep->getDrawable();
-	if (drawable->isActive())
-	{
-		model_mat = &(drawable->getRenderMatrix());
-	}
-	else
-	{
-		model_mat = &(drawable->getRegion()->mRenderMatrix);
-		if (model_mat->isIdentity())
-		{
-			model_mat = NULL;
-		}
-	}
-
-	U8 bump = (type == LLRenderPass::PASS_BUMP || type == LLRenderPass::PASS_POST_BUMP) ? facep->getTextureEntry()->getBumpmap() : 0;
-	
-	LLViewerTexture* tex = facep->getTexture();
-
-	U8 index = facep->getTextureIndex();
-
-	bool batchable = false;
-
-	if (index < 255 && idx >= 0)
-	{
-		if (index < draw_vec[idx]->mTextureList.size())
-		{
-			if (draw_vec[idx]->mTextureList[index].isNull())
-			{
-				batchable = true;
-				draw_vec[idx]->mTextureList[index] = tex;
-			}
-			else if (draw_vec[idx]->mTextureList[index] == tex)
-			{ //this face's texture index can be used with this batch
-				batchable = true;
-			}
-		}
-		else
-		{ //texture list can be expanded to fit this texture index
-			batchable = true;
-		}
-	}
-	
-	U8 glow = (U8) (facep->getTextureEntry()->getGlow() * 255);
-
-	if (idx >= 0 && 
-		draw_vec[idx]->mVertexBuffer == facep->getVertexBuffer() &&
-		draw_vec[idx]->mEnd == facep->getGeomIndex()-1 &&
-		(LLPipeline::sTextureBindTest || draw_vec[idx]->mTexture == tex || batchable) &&
-#if LL_DARWIN
-		draw_vec[idx]->mEnd - draw_vec[idx]->mStart + facep->getGeomCount() <= (U32) gGLManager.mGLMaxVertexRange &&
-		draw_vec[idx]->mCount + facep->getIndicesCount() <= (U32) gGLManager.mGLMaxIndexRange &&
-#endif
-		draw_vec[idx]->mGlowColor.mV[3] == glow &&
-		draw_vec[idx]->mFullbright == fullbright &&
-		draw_vec[idx]->mBump == bump &&
-		draw_vec[idx]->mTextureMatrix == tex_mat &&
-		draw_vec[idx]->mModelMatrix == model_mat)
-	{
-		draw_vec[idx]->mCount += facep->getIndicesCount();
-		draw_vec[idx]->mEnd += facep->getGeomCount();
-		draw_vec[idx]->mVSize = llmax(draw_vec[idx]->mVSize, facep->getVirtualSize());
-
-		if (index >= draw_vec[idx]->mTextureList.size())
-		{
-			draw_vec[idx]->mTextureList.resize(index+1);
-			draw_vec[idx]->mTextureList[index] = tex;
-		}
-		draw_vec[idx]->validate();
-		update_min_max(draw_vec[idx]->mExtents[0], draw_vec[idx]->mExtents[1], facep->mExtents[0]);
-		update_min_max(draw_vec[idx]->mExtents[0], draw_vec[idx]->mExtents[1], facep->mExtents[1]);
-	}
-	else
-	{
-		U32 start = facep->getGeomIndex();
-		U32 end = start + facep->getGeomCount()-1;
-		U32 offset = facep->getIndicesStart();
-		U32 count = facep->getIndicesCount();
-		LLPointer<LLDrawInfo> draw_info = new LLDrawInfo(start,end,count,offset, tex, 
-			facep->getVertexBuffer(), fullbright, bump); 
-		draw_info->mGroup = group;
-		draw_info->mVSize = facep->getVirtualSize();
-		draw_vec.push_back(draw_info);
-		draw_info->mTextureMatrix = tex_mat;
-		draw_info->mModelMatrix = model_mat;
-		draw_info->mGlowColor.setVec(0,0,0,glow);
-		if (type == LLRenderPass::PASS_ALPHA)
-		{ //for alpha sorting
-			facep->setDrawInfo(draw_info);
-		}
-		draw_info->mExtents[0] = facep->mExtents[0];
-		draw_info->mExtents[1] = facep->mExtents[1];
-
-		if (LLPipeline::sUseTriStrips)
-		{
-			draw_info->mDrawMode = LLRender::TRIANGLE_STRIP;
-		}
-
-		if (index < 255)
-		{ //initialize texture list for texture batching
-			draw_info->mTextureList.resize(index+1);
-			draw_info->mTextureList[index] = tex;
-		}
-		draw_info->validate();
-	}
-}
-
-void LLVolumeGeometryManager::getGeometry(LLSpatialGroup* group)
-{
-
-}
-
-static LLFastTimer::DeclareTimer FTM_REBUILD_VOLUME_VB("Volume");
-static LLFastTimer::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
-
-static LLDrawPoolAvatar* get_avatar_drawpool(LLViewerObject* vobj)
-{
-	LLVOAvatar* avatar = vobj->getAvatar();
-					
-	if (avatar)
-	{
-		LLDrawable* drawable = avatar->mDrawable;
-		if (drawable && drawable->getNumFaces() > 0)
-		{
-			LLFace* face = drawable->getFace(0);
-			if (face)
-			{
-				LLDrawPool* drawpool = face->getPool();
-				if (drawpool)
-				{
-					if (drawpool->getType() == LLDrawPool::POOL_AVATAR)
-					{
-						return (LLDrawPoolAvatar*) drawpool;
-					}
-				}
-			}
-		}
-	}
-
-	return NULL;
-}
-
-void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
-{
-	if (group->changeLOD())
-	{
-		group->mLastUpdateDistance = group->mDistance;
-	}
-
-	group->mLastUpdateViewAngle = group->mViewAngle;
-
-	if (!group->isState(LLSpatialGroup::GEOM_DIRTY | LLSpatialGroup::ALPHA_DIRTY))
-	{
-		if (group->isState(LLSpatialGroup::MESH_DIRTY) && !LLPipeline::sDelayVBUpdate)
-		{
-			LLFastTimer ftm(FTM_REBUILD_VBO);	
-			LLFastTimer ftm2(FTM_REBUILD_VOLUME_VB);
-		
-			rebuildMesh(group);
-		}
-		return;
-	}
-
-	group->mBuilt = 1.f;
-	LLFastTimer ftm(FTM_REBUILD_VBO);	
-
-	LLFastTimer ftm2(FTM_REBUILD_VOLUME_VB);
-
-	group->clearDrawMap();
-
-	mFaceList.clear();
-
-	std::vector<LLFace*> fullbright_faces;
-	std::vector<LLFace*> bump_faces;
-	std::vector<LLFace*> simple_faces;
-
-	std::vector<LLFace*> alpha_faces;
-	U32 useage = group->mSpatialPartition->mBufferUsage;
-
-	U32 max_vertices = (gSavedSettings.getS32("RenderMaxVBOSize")*1024)/LLVertexBuffer::calcVertexSize(group->mSpatialPartition->mVertexDataMask);
-	U32 max_total = (gSavedSettings.getS32("RenderMaxNodeSize")*1024)/LLVertexBuffer::calcVertexSize(group->mSpatialPartition->mVertexDataMask);
-	max_vertices = llmin(max_vertices, (U32) 65535);
-
-	U32 cur_total = 0;
-
-	//get all the faces into a list
-	for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
-	{
-		LLDrawable* drawablep = *drawable_iter;
-		
-		if (drawablep->isDead() || drawablep->isState(LLDrawable::FORCE_INVISIBLE) )
-		{
-			continue;
-		}
-	
-		if (drawablep->isAnimating())
-		{ //fall back to stream draw for animating verts
-			useage = GL_STREAM_DRAW_ARB;
-		}
-
-		LLVOVolume* vobj = drawablep->getVOVolume();
-
-		if (vobj->isMesh() &&
-			(vobj->getVolume() && !vobj->getVolume()->isMeshAssetLoaded() || !gMeshRepo.meshRezEnabled()))
-		{
-			continue;
-		}
-
-		llassert_always(vobj);
-		vobj->updateTextureVirtualSize();
-		vobj->preRebuild();
-
-		drawablep->clearState(LLDrawable::HAS_ALPHA);
-
-		bool rigged = vobj->isAttachment() && 
-					vobj->isMesh() && 
-					gMeshRepo.getSkinInfo(vobj->getVolume()->getParams().getSculptID(), vobj);
-
-		bool bake_sunlight = LLPipeline::sBakeSunlight && drawablep->isStatic();
-
-		bool is_rigged = false;
-
-		//for each face
-		for (S32 i = 0; i < drawablep->getNumFaces(); i++)
-		{
-			LLFace* facep = drawablep->getFace(i);
-
-			//ALWAYS null out vertex buffer on rebuild -- if the face lands in a render
-			// batch, it will recover its vertex buffer reference from the spatial group
-			facep->setVertexBuffer(NULL);
-			
-			//sum up face verts and indices
-			drawablep->updateFaceSize(i);
-			
-			
-
-			if (rigged) 
-			{
-				if (!facep->isState(LLFace::RIGGED))
-				{ //completely reset vertex buffer
-					facep->clearVertexBuffer();
-				}
-		
-				facep->setState(LLFace::RIGGED);
-				is_rigged = true;
-				
-				//get drawpool of avatar with rigged face
-				LLDrawPoolAvatar* pool = get_avatar_drawpool(vobj);
-				
-				//Determine if we've received skininfo that contains an
-				//alternate bind matrix - if it does then apply the translational component
-				//to the joints of the avatar.
-				LLVOAvatar* pAvatarVO = vobj->getAvatar();
-				bool pelvisGotSet = false;
-
-				if ( pAvatarVO )
-				{
-					LLUUID currentId = vobj->getVolume()->getParams().getSculptID();
-					const LLMeshSkinInfo*  pSkinData = gMeshRepo.getSkinInfo( currentId, vobj );
-					
-					if ( pSkinData )
-					{
-						const int bindCnt = pSkinData->mAlternateBindMatrix.size();								
-						if ( bindCnt > 0 )
-						{					
-							const int jointCnt = pSkinData->mJointNames.size();
-							const F32 pelvisZOffset = pSkinData->mPelvisOffset;
-							bool fullRig = (jointCnt>=20) ? true : false;
-							if ( fullRig )
-							{
-								for ( int i=0; i<jointCnt; ++i )
-								{
-									std::string lookingForJoint = pSkinData->mJointNames[i].c_str();
-									//llinfos<<"joint name "<<lookingForJoint.c_str()<<llendl;
-									LLJoint* pJoint = pAvatarVO->getJoint( lookingForJoint );
-									if ( pJoint && pJoint->getId() != currentId )
-									{   									
-										pJoint->setId( currentId );
-										const LLVector3& jointPos = pSkinData->mAlternateBindMatrix[i].getTranslation();									
-										//Set the joint position
-										pJoint->storeCurrentXform( jointPos );																																
-										//If joint is a pelvis then handle old/new pelvis to foot values
-										if ( lookingForJoint == "mPelvis" )
-										{	
-											pJoint->storeCurrentXform( jointPos );																																
-											if ( !pAvatarVO->hasPelvisOffset() )
-											{										
-												pAvatarVO->setPelvisOffset( true, jointPos, pelvisZOffset );
-												//Trigger to rebuild viewer AV
-												pelvisGotSet = true;											
-											}										
-										}										
-									}
-								}
-							}							
-						}
-					}
-				}
-				//If we've set the pelvis to a new position we need to also rebuild some information that the
-				//viewer does at launch (e.g. body size etc.)
-				if ( pelvisGotSet )
-				{
-					pAvatarVO->postPelvisSetRecalc();
-				}
-
-				if (pool)
-				{
-					const LLTextureEntry* te = facep->getTextureEntry();
-
-					//remove face from old pool if it exists
-					LLDrawPool* old_pool = facep->getPool();
-					if (old_pool && old_pool->getType() == LLDrawPool::POOL_AVATAR)
-					{
-						((LLDrawPoolAvatar*) old_pool)->removeRiggedFace(facep);
-					}
-
-					//add face to new pool
-					LLViewerTexture* tex = facep->getTexture();
-					U32 type = gPipeline.getPoolTypeFromTE(te, tex);
-
-					if (type == LLDrawPool::POOL_ALPHA)
-					{
-						if (te->getFullbright())
-						{
-							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_FULLBRIGHT_ALPHA);
-						}
-						else
-						{
-							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_ALPHA);
-						}
-					}
-					else if (te->getShiny())
-					{
-						if (te->getFullbright())
-						{
-							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_FULLBRIGHT_SHINY);
-						}
-						else
-						{
-							if (LLPipeline::sRenderDeferred)
-							{
-								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_SIMPLE);
-							}
-							else
-							{
-								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_SHINY);
-							}
-						}
-					}
-					else
-					{
-						if (te->getFullbright())
-						{
-							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_FULLBRIGHT);
-						}
-						else
-						{
-							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_SIMPLE);
-						}
-					}
-
-					if (te->getGlow())
-					{
-						pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_GLOW);
-					}
-
-					if (LLPipeline::sRenderDeferred)
-					{
-						if (type != LLDrawPool::POOL_ALPHA && !te->getFullbright())
-						{
-							if (te->getBumpmap())
-							{
-								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_DEFERRED_BUMP);
-							}
-							else
-							{
-								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_DEFERRED_SIMPLE);
-							}
-						}
-					}
-				}
-
-				continue;
-			}
-			else
-			{
-				if (facep->isState(LLFace::RIGGED))
-				{ //face is not rigged but used to be, remove from rigged face pool
-					LLDrawPoolAvatar* pool = (LLDrawPoolAvatar*) facep->getPool();
-					if (pool)
-					{
-						pool->removeRiggedFace(facep);
-					}
-					facep->clearState(LLFace::RIGGED);
-				}
-			}
-
-			if (cur_total > max_total || facep->getIndicesCount() <= 0 || facep->getGeomCount() <= 0)
-			{
-				facep->clearVertexBuffer();
-				continue;
-			}
-
-			cur_total += facep->getGeomCount();
-
-			if (facep->hasGeometry() && facep->getPixelArea() > FORCE_CULL_AREA)
-			{
-				const LLTextureEntry* te = facep->getTextureEntry();
-				LLViewerTexture* tex = facep->getTexture();
-
-				if (facep->isState(LLFace::TEXTURE_ANIM))
-				{
-					if (!vobj->mTexAnimMode)
-					{
-						facep->clearState(LLFace::TEXTURE_ANIM);
-					}
-				}
-
-				BOOL force_simple = (facep->getPixelArea() < FORCE_SIMPLE_RENDER_AREA);
-				U32 type = gPipeline.getPoolTypeFromTE(te, tex);
-				if (type != LLDrawPool::POOL_ALPHA && force_simple)
-				{
-					type = LLDrawPool::POOL_SIMPLE;
-				}
-				facep->setPoolType(type);
-
-				if (vobj->isHUDAttachment())
-				{
-					facep->setState(LLFace::FULLBRIGHT);
-				}
-
-				if (vobj->mTextureAnimp && vobj->mTexAnimMode)
-				{
-					if (vobj->mTextureAnimp->mFace <= -1)
-					{
-						S32 face;
-						for (face = 0; face < vobj->getNumTEs(); face++)
-						{
-							drawablep->getFace(face)->setState(LLFace::TEXTURE_ANIM);
-						}
-					}
-					else if (vobj->mTextureAnimp->mFace < vobj->getNumTEs())
-					{
-						drawablep->getFace(vobj->mTextureAnimp->mFace)->setState(LLFace::TEXTURE_ANIM);
-					}
-				}
-
-				if (type == LLDrawPool::POOL_ALPHA)
-				{
-					if (facep->canRenderAsMask())
-					{ //can be treated as alpha mask
-						simple_faces.push_back(facep);
-					}
-					else
-					{
-						drawablep->setState(LLDrawable::HAS_ALPHA);
-						alpha_faces.push_back(facep);
-					}
-				}
-				else
-				{
-					if (drawablep->isState(LLDrawable::REBUILD_VOLUME))
-					{
-						facep->mLastUpdateTime = gFrameTimeSeconds;
-					}
-
-					if (gPipeline.canUseWindLightShadersOnObjects()
-						&& LLPipeline::sRenderBump)
-					{
-						if (te->getBumpmap())
-						{ //needs normal + binormal
-							bump_faces.push_back(facep);
-						}
-						else if (te->getShiny() || !te->getFullbright())
-						{ //needs normal
-							simple_faces.push_back(facep);
-						}
-						else 
-						{ //doesn't need normal
-							facep->setState(LLFace::FULLBRIGHT);
-							fullbright_faces.push_back(facep);
-						}
-					}
-					else
-					{
-						if (te->getBumpmap() && LLPipeline::sRenderBump)
-						{ //needs normal + binormal
-							bump_faces.push_back(facep);
-						}
-						else if ((te->getShiny() && LLPipeline::sRenderBump) ||
-							!(te->getFullbright() || bake_sunlight))
-						{ //needs normal
-							simple_faces.push_back(facep);
-						}
-						else 
-						{ //doesn't need normal
-							facep->setState(LLFace::FULLBRIGHT);
-							fullbright_faces.push_back(facep);
-						}
-					}
-				}
-			}
-			else
-			{	//face has no renderable geometry
-				facep->clearVertexBuffer();
-			}		
-		}
-
-		if (is_rigged)
-		{
-			drawablep->setState(LLDrawable::RIGGED);
-		}
-		else
-		{
-			drawablep->clearState(LLDrawable::RIGGED);
-		}
-	}
-
-	group->mBufferUsage = useage;
-
-	//PROCESS NON-ALPHA FACES
-	U32 simple_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
-	U32 alpha_mask = simple_mask | 0x80000000; //hack to give alpha verts their own VBO
-	U32 bump_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
-	U32 fullbright_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
-
-	bool batch_textures = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT) > 1;
-
-	if (batch_textures)
-	{
-		bump_mask |= LLVertexBuffer::MAP_BINORMAL;
-		genDrawInfo(group, simple_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, simple_faces, FALSE, TRUE);
-		genDrawInfo(group, fullbright_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, fullbright_faces, FALSE, TRUE);
-		genDrawInfo(group, bump_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, bump_faces, FALSE, TRUE);
-		genDrawInfo(group, alpha_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, alpha_faces, TRUE, TRUE);
-	}
-	else
-	{
-		genDrawInfo(group, simple_mask, simple_faces);
-		genDrawInfo(group, fullbright_mask, fullbright_faces);
-		genDrawInfo(group, bump_mask, bump_faces, FALSE, TRUE);
-		genDrawInfo(group, alpha_mask, alpha_faces, TRUE);
-	}
-	
-
-	if (!LLPipeline::sDelayVBUpdate)
-	{
-		//drawables have been rebuilt, clear rebuild status
-		for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
-		{
-			LLDrawable* drawablep = *drawable_iter;
-			drawablep->clearState(LLDrawable::REBUILD_ALL);
-		}
-	}
-
-	group->mLastUpdateTime = gFrameTimeSeconds;
-	group->mBuilt = 1.f;
-	group->clearState(LLSpatialGroup::GEOM_DIRTY | LLSpatialGroup::ALPHA_DIRTY);
-
-	if (LLPipeline::sDelayVBUpdate)
-	{
-		group->setState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO);
-	}
-
-	mFaceList.clear();
-}
-
-static LLFastTimer::DeclareTimer FTM_VOLUME_GEOM("Volume Geometry");
-static LLFastTimer::DeclareTimer FTM_VOLUME_GEOM_PARTIAL("Terse Rebuild");
-
-void LLVolumeGeometryManager::rebuildMesh(LLSpatialGroup* group)
-{
-	llassert(group);
-	if (group && group->isState(LLSpatialGroup::MESH_DIRTY) && !group->isState(LLSpatialGroup::GEOM_DIRTY))
-	{
-		LLFastTimer tm(FTM_VOLUME_GEOM);
-		S32 num_mapped_veretx_buffer = LLVertexBuffer::sMappedCount ;
-
-		group->mBuilt = 1.f;
-		
-		std::set<LLVertexBuffer*> mapped_buffers;
-
-		for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
-		{
-			LLFastTimer t(FTM_VOLUME_GEOM_PARTIAL);
-			LLDrawable* drawablep = *drawable_iter;
-
-			if (!drawablep->isDead() && drawablep->isState(LLDrawable::REBUILD_ALL) )
-			{
-				LLVOVolume* vobj = drawablep->getVOVolume();
-				vobj->preRebuild();
-
-				LLVolume* volume = vobj->getVolume();
-				for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
-				{
-					LLFace* face = drawablep->getFace(i);
-					if (face)
-					{
-						LLVertexBuffer* buff = face->getVertexBuffer();
-						if (buff)
-						{
-							face->getGeometryVolume(*volume, face->getTEOffset(), 
-								vobj->getRelativeXform(), vobj->getRelativeXformInvTrans(), face->getGeomIndex());
-
-							if (buff->isLocked())
-							{
-								mapped_buffers.insert(buff);
-							}
-						}
-					}
-				}
-				
-				drawablep->clearState(LLDrawable::REBUILD_ALL);
-			}
-		}
-		
-		for (std::set<LLVertexBuffer*>::iterator iter = mapped_buffers.begin(); iter != mapped_buffers.end(); ++iter)
-		{
-			(*iter)->setBuffer(0);
-		}
-
-		// don't forget alpha
-		if(group != NULL && 
-		   !group->mVertexBuffer.isNull() && 
-		   group->mVertexBuffer->isLocked())
-		{
-			group->mVertexBuffer->setBuffer(0);
-		}
-
-		//if not all buffers are unmapped
-		if(num_mapped_veretx_buffer != LLVertexBuffer::sMappedCount) 
-		{
-			llwarns << "Not all mapped vertex buffers are unmapped!" << llendl ; 
-			for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
-			{
-				LLDrawable* drawablep = *drawable_iter;
-				for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
-				{
-					LLFace* face = drawablep->getFace(i);
-					LLVertexBuffer* buff = face->getVertexBuffer();
-					if (face && buff && buff->isLocked())
-					{
-						buff->setBuffer(0) ;
-					}
-				}
-			} 
-		}
-
-		group->clearState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO);
-	}
-
-	llassert(!group || !group->isState(LLSpatialGroup::NEW_DRAWINFO));
-}
-
-struct CompareBatchBreakerModified
-{
-	bool operator()(const LLFace* const& lhs, const LLFace* const& rhs)
-	{
-		const LLTextureEntry* lte = lhs->getTextureEntry();
-		const LLTextureEntry* rte = rhs->getTextureEntry();
-
-		if (lte->getBumpmap() != rte->getBumpmap())
-		{
-			return lte->getBumpmap() < rte->getBumpmap();
-		}
-		else if (lte->getFullbright() != rte->getFullbright())
-		{
-			return lte->getFullbright() < rte->getFullbright();
-		}
-		else  if (lte->getGlow() != rte->getGlow())
-		{
-			return lte->getGlow() < rte->getGlow();
-		}
-		else
-		{
-			return lhs->getTexture() < rhs->getTexture();
-		}
-		
-	}
-};
-
-void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::vector<LLFace*>& faces, BOOL distance_sort, BOOL batch_textures)
-{
-	//calculate maximum number of vertices to store in a single buffer
-	U32 max_vertices = (gSavedSettings.getS32("RenderMaxVBOSize")*1024)/LLVertexBuffer::calcVertexSize(group->mSpatialPartition->mVertexDataMask);
-	max_vertices = llmin(max_vertices, (U32) 65535);
-
-	if (!distance_sort)
-	{
-		//sort faces by things that break batches
-		std::sort(faces.begin(), faces.end(), CompareBatchBreakerModified());
-	}
-	else
-	{
-		//sort faces by distance
-		std::sort(faces.begin(), faces.end(), LLFace::CompareDistanceGreater());
-	}
-				
-	std::vector<LLFace*>::iterator face_iter = faces.begin();
-	
-	LLSpatialGroup::buffer_map_t buffer_map;
-
-	LLViewerTexture* last_tex = NULL;
-	S32 buffer_index = 0;
-
-	if (distance_sort)
-	{
-		buffer_index = -1;
-	}
-
-	S32 texture_index_channels = gGLManager.mNumTextureImageUnits-1; //always reserve one for shiny for now just for simplicity
-	
-	if (gGLManager.mGLVersion < 3.1f)
-	{
-		texture_index_channels = 1;
-	}
-
-	if (LLPipeline::sRenderDeferred && distance_sort)
-	{
-		texture_index_channels = gDeferredAlphaProgram.mFeatures.mIndexedTextureChannels;
-	}
-
-	texture_index_channels = llmin(texture_index_channels, (S32) gSavedSettings.getU32("RenderMaxTextureIndex"));
-	
-
-	while (face_iter != faces.end())
-	{
-		//pull off next face
-		LLFace* facep = *face_iter;
-		LLViewerTexture* tex = facep->getTexture();
-
-		if (distance_sort)
-		{
-			tex = NULL;
-		}
-
-		if (last_tex == tex)
-		{
-			buffer_index++;
-		}
-		else
-		{
-			last_tex = tex;
-			buffer_index = 0;
-		}
-
-		bool bake_sunlight = LLPipeline::sBakeSunlight && facep->getDrawable()->isStatic(); 
-
-		U32 index_count = facep->getIndicesCount();
-		U32 geom_count = facep->getGeomCount();
-
-		//sum up vertices needed for this render batch
-		std::vector<LLFace*>::iterator i = face_iter;
-		++i;
-		
-		std::vector<LLViewerTexture*> texture_list;
-
-		if (batch_textures)
-		{
-			U8 cur_tex = 0;
-			facep->setTextureIndex(cur_tex);
-			texture_list.push_back(tex);
-
-			//if (can_batch_texture(facep))
-			{
-				while (i != faces.end())
-				{
-					facep = *i;
-					if (facep->getTexture() != tex)
-					{
-						if (distance_sort)
-						{ //textures might be out of order, see if texture exists in current batch
-							bool found = false;
-							for (U32 tex_idx = 0; tex_idx < texture_list.size(); ++tex_idx)
-							{
-								if (facep->getTexture() == texture_list[tex_idx])
-								{
-									cur_tex = tex_idx;
-									found = true;
-									break;
-								}
-							}
-
-							if (!found)
-							{
-								cur_tex = texture_list.size();
-							}
-						}
-						else
-						{
-							cur_tex++;
-						}
-
-						if (!can_batch_texture(facep))
-						{ //face is bump mapped or has an animated texture matrix -- can't 
-							//batch more than 1 texture at a time
-							break;
-						}
-
-						if (cur_tex >= texture_index_channels)
-						{ //cut batches when index channels are depleted
-							break;
-						}
-
-						tex = facep->getTexture();
-
-						texture_list.push_back(tex);
-					}
-
-					if (geom_count + facep->getGeomCount() > max_vertices)
-					{ //cut batches on geom count too big
-						break;
-					}
-
-					++i;
-					index_count += facep->getIndicesCount();
-					geom_count += facep->getGeomCount();
-
-					facep->setTextureIndex(cur_tex);
-				}
-			}
-
-			tex = texture_list[0];
-		}
-		else
-		{
-			while (i != faces.end() && 
-				(LLPipeline::sTextureBindTest || (distance_sort || (*i)->getTexture() == tex)))
-			{
-				facep = *i;
-			
-
-				//face has no texture index
-				facep->mDrawInfo = NULL;
-				facep->setTextureIndex(255);
-
-				if (geom_count + facep->getGeomCount() > max_vertices)
-				{ //cut batches on geom count too big
-					break;
-				}
-
-				++i;
-				index_count += facep->getIndicesCount();
-				geom_count += facep->getGeomCount();
-			}
-		}
-	
-		//create/delete/resize vertex buffer if needed
-		LLVertexBuffer* buffer = NULL;
-		LLSpatialGroup::buffer_texture_map_t::iterator found_iter = group->mBufferMap[mask].find(*face_iter);
-		
-		if (found_iter != group->mBufferMap[mask].end())
-		{
-			if ((U32) buffer_index < found_iter->second.size())
-			{
-				buffer = found_iter->second[buffer_index];
-			}
-		}
-						
-		if (!buffer)
-		{ //create new buffer if needed
-			buffer = createVertexBuffer(mask, 
-											group->mBufferUsage);
-			buffer->allocateBuffer(geom_count, index_count, TRUE);
-		}
-		else 
-		{ //resize pre-existing buffer
-			if (LLVertexBuffer::sEnableVBOs && buffer->getUsage() != group->mBufferUsage ||
-				buffer->getTypeMask() != mask)
-			{
-				buffer = createVertexBuffer(mask, 
-											group->mBufferUsage);
-				buffer->allocateBuffer(geom_count, index_count, TRUE);
-			}
-			else
-			{
-				buffer->resizeBuffer(geom_count, index_count);
-			}
-		}
-
-		buffer_map[mask][*face_iter].push_back(buffer);
-
-		//add face geometry
-
-		U32 indices_index = 0;
-		U16 index_offset = 0;
-
-		while (face_iter < i)
-		{ //update face indices for new buffer
-			facep = *face_iter;
-			facep->setIndicesIndex(indices_index);
-			facep->setGeomIndex(index_offset);
-			facep->setVertexBuffer(buffer);	
-			
-			if (batch_textures && facep->getTextureIndex() == 255)
-			{
-				llerrs << "Invalid texture index." << llendl;
-			}
-			
-			{
-				//for debugging, set last time face was updated vs moved
-				facep->updateRebuildFlags();
-
-				if (!LLPipeline::sDelayVBUpdate)
-				{ //copy face geometry into vertex buffer
-					LLDrawable* drawablep = facep->getDrawable();
-					LLVOVolume* vobj = drawablep->getVOVolume();
-					LLVolume* volume = vobj->getVolume();
-
-					U32 te_idx = facep->getTEOffset();
-
-					facep->getGeometryVolume(*volume, te_idx, 
-						vobj->getRelativeXform(), vobj->getRelativeXformInvTrans(), index_offset);
-				}
-			}
-
-			index_offset += facep->getGeomCount();
-			indices_index += facep->getIndicesCount();
-
-
-			//append face to appropriate render batch
-
-			BOOL force_simple = facep->getPixelArea() < FORCE_SIMPLE_RENDER_AREA;
-			BOOL fullbright = facep->isState(LLFace::FULLBRIGHT);
-			if ((mask & LLVertexBuffer::MAP_NORMAL) == 0)
-			{ //paranoia check to make sure GL doesn't try to read non-existant normals
-				fullbright = TRUE;
-			}
-
-			const LLTextureEntry* te = facep->getTextureEntry();
-			tex = facep->getTexture();
-
-			BOOL is_alpha = (facep->getPoolType() == LLDrawPool::POOL_ALPHA) ? TRUE : FALSE;
-		
-			if (is_alpha)
-			{
-				// can we safely treat this as an alpha mask?
-				if (facep->canRenderAsMask())
-				{
-					if (te->getFullbright() || LLPipeline::sNoAlpha)
-					{
-						registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK);
-					}
-					else
-					{
-						registerFace(group, facep, LLRenderPass::PASS_ALPHA_MASK);
-					}
-				}
-				else
-				{
-					registerFace(group, facep, LLRenderPass::PASS_ALPHA);
-				}
-
-				if (LLPipeline::sRenderDeferred)
-				{
-					registerFace(group, facep, LLRenderPass::PASS_ALPHA_SHADOW);
-				}
-			}
-			else if (gPipeline.canUseVertexShaders()
-				&& group->mSpatialPartition->mPartitionType != LLViewerRegion::PARTITION_HUD 
-				&& LLPipeline::sRenderBump 
-				&& te->getShiny())
-			{ //shiny
-				if (tex->getPrimaryFormat() == GL_ALPHA)
-				{ //invisiprim+shiny
-					registerFace(group, facep, LLRenderPass::PASS_INVISI_SHINY);
-					registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
-				}
-				else if (LLPipeline::sRenderDeferred)
-				{ //deferred rendering
-					if (te->getFullbright())
-					{ //register in post deferred fullbright shiny pass
-						registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
-						if (te->getBumpmap())
-						{ //register in post deferred bump pass
-							registerFace(group, facep, LLRenderPass::PASS_POST_BUMP);
-						}
-					}
-					else if (te->getBumpmap())
-					{ //register in deferred bump pass
-						registerFace(group, facep, LLRenderPass::PASS_BUMP);
-					}
-					else
-					{ //register in deferred simple pass (deferred simple includes shiny)
-						llassert(mask & LLVertexBuffer::MAP_NORMAL);
-						registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
-					}
-				}
-				else if (fullbright)
-				{	//not deferred, register in standard fullbright shiny pass					
-					registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
-				}
-				else
-				{ //not deferred or fullbright, register in standard shiny pass
-					registerFace(group, facep, LLRenderPass::PASS_SHINY);
-				}
-			}
-			else
-			{ //not alpha and not shiny
-				if (!is_alpha && tex->getPrimaryFormat() == GL_ALPHA)
-				{ //invisiprim
-					registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
-				}
-				else if (fullbright || bake_sunlight)
-				{ //fullbright
-					registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT);
-					if (LLPipeline::sRenderDeferred && LLPipeline::sRenderBump && te->getBumpmap())
-					{ //if this is the deferred render and a bump map is present, register in post deferred bump
-						registerFace(group, facep, LLRenderPass::PASS_POST_BUMP);
-					}
-				}
-				else
-				{
-					if (LLPipeline::sRenderDeferred && LLPipeline::sRenderBump && te->getBumpmap())
-					{ //non-shiny or fullbright deferred bump
-						registerFace(group, facep, LLRenderPass::PASS_BUMP);
-					}
-					else
-					{ //all around simple
-						llassert(mask & LLVertexBuffer::MAP_NORMAL);
-						registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
-					}
-				}
-				
-				//not sure why this is here -- shiny HUD attachments maybe?  -- davep 5/11/2010
-				if (!is_alpha && te->getShiny() && LLPipeline::sRenderBump)
-				{
-					registerFace(group, facep, LLRenderPass::PASS_SHINY);
-				}
-			}
-			
-			//not sure why this is here, and looks like it might cause bump mapped objects to get rendered redundantly -- davep 5/11/2010
-			if (!is_alpha && !LLPipeline::sRenderDeferred)
-			{
-				llassert((mask & LLVertexBuffer::MAP_NORMAL) || fullbright);
-				facep->setPoolType((fullbright) ? LLDrawPool::POOL_FULLBRIGHT : LLDrawPool::POOL_SIMPLE);
-				
-				if (!force_simple && te->getBumpmap() && LLPipeline::sRenderBump)
-				{
-					registerFace(group, facep, LLRenderPass::PASS_BUMP);
-				}
-			}
-
-			if (!is_alpha && LLPipeline::sRenderGlow && te->getGlow() > 0.f)
-			{
-				registerFace(group, facep, LLRenderPass::PASS_GLOW);
-			}
-						
-			++face_iter;
-		}
-
-		buffer->setBuffer(0);
-	}
-
-	group->mBufferMap[mask].clear();
-	for (LLSpatialGroup::buffer_texture_map_t::iterator i = buffer_map[mask].begin(); i != buffer_map[mask].end(); ++i)
-	{
-		group->mBufferMap[mask][i->first] = i->second;
-	}
-}
-
-void LLGeometryManager::addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32 &index_count)
-{	
-	//initialize to default usage for this partition
-	U32 usage = group->mSpatialPartition->mBufferUsage;
-	
-	//clear off any old faces
-	mFaceList.clear();
-
-	//for each drawable
-	for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
-	{
-		LLDrawable* drawablep = *drawable_iter;
-		
-		if (drawablep->isDead())
-		{
-			continue;
-		}
-	
-		if (drawablep->isAnimating())
-		{ //fall back to stream draw for animating verts
-			usage = GL_STREAM_DRAW_ARB;
-		}
-
-		//for each face
-		for (S32 i = 0; i < drawablep->getNumFaces(); i++)
-		{
-			//sum up face verts and indices
-			drawablep->updateFaceSize(i);
-			LLFace* facep = drawablep->getFace(i);
-			if (facep->hasGeometry() && facep->getPixelArea() > FORCE_CULL_AREA)
-			{
-				vertex_count += facep->getGeomCount();
-				index_count += facep->getIndicesCount();
-				llassert(facep->getIndicesCount() < 65536);
-				//remember face (for sorting)
-				mFaceList.push_back(facep);
-			}
-			else
-			{
-				facep->clearVertexBuffer();
-			}
-		}
-	}
-	
-	group->mBufferUsage = usage;
-}
-
-LLHUDPartition::LLHUDPartition()
-{
-	mPartitionType = LLViewerRegion::PARTITION_HUD;
-	mDrawableType = LLPipeline::RENDER_TYPE_HUD;
-	mSlopRatio = 0.f;
-	mLODPeriod = 1;
-}
-
-void LLHUDPartition::shift(const LLVector4a &offset)
-{
-	//HUD objects don't shift with region crossing.  That would be silly.
-}
-
-
+/** 
+ * @file llvovolume.cpp
+ * @brief LLVOVolume class implementation
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+// A "volume" is a box, cylinder, sphere, or other primitive shape.
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llvovolume.h"
+
+#include <sstream>
+
+#include "llviewercontrol.h"
+#include "lldir.h"
+#include "llflexibleobject.h"
+#include "llfloatertools.h"
+#include "llmaterialtable.h"
+#include "llprimitive.h"
+#include "llvolume.h"
+#include "llvolumeoctree.h"
+#include "llvolumemgr.h"
+#include "llvolumemessage.h"
+#include "material_codes.h"
+#include "message.h"
+#include "llpluginclassmedia.h" // for code in the mediaEvent handler
+#include "object_flags.h"
+#include "llagentconstants.h"
+#include "lldrawable.h"
+#include "lldrawpoolavatar.h"
+#include "lldrawpoolbump.h"
+#include "llface.h"
+#include "llspatialpartition.h"
+#include "llhudmanager.h"
+#include "llflexibleobject.h"
+#include "llsky.h"
+#include "lltexturefetch.h"
+#include "llvector4a.h"
+#include "llviewercamera.h"
+#include "llviewertexturelist.h"
+#include "llviewerobjectlist.h"
+#include "llviewerregion.h"
+#include "llviewertextureanim.h"
+#include "llworld.h"
+#include "llselectmgr.h"
+#include "pipeline.h"
+#include "llsdutil.h"
+#include "llmatrix4a.h"
+#include "llmediaentry.h"
+#include "llmediadataclient.h"
+#include "llmeshrepository.h"
+#include "llagent.h"
+#include "llviewermediafocus.h"
+#include "lldatapacker.h"
+#include "llviewershadermgr.h"
+#include "llvoavatar.h"
+#include "llvocache.h"
+
+const S32 MIN_QUIET_FRAMES_COALESCE = 30;
+const F32 FORCE_SIMPLE_RENDER_AREA = 512.f;
+const F32 FORCE_CULL_AREA = 8.f;
+const F32 MAX_LOD_DISTANCE = 24.f;
+
+
+BOOL gAnimateTextures = TRUE;
+//extern BOOL gHideSelectedObjects;
+
+F32 LLVOVolume::sLODFactor = 1.f;
+F32	LLVOVolume::sLODSlopDistanceFactor = 0.5f; //Changing this to zero, effectively disables the LOD transition slop 
+F32 LLVOVolume::sDistanceFactor = 1.0f;
+S32 LLVOVolume::sNumLODChanges = 0;
+S32 LLVOVolume::mRenderComplexity_last = 0;
+S32 LLVOVolume::mRenderComplexity_current = 0;
+LLPointer<LLObjectMediaDataClient> LLVOVolume::sObjectMediaClient = NULL;
+LLPointer<LLObjectMediaNavigateClient> LLVOVolume::sObjectMediaNavigateClient = NULL;
+
+static LLFastTimer::DeclareTimer FTM_GEN_TRIANGLES("Generate Triangles");
+static LLFastTimer::DeclareTimer FTM_GEN_VOLUME("Generate Volumes");
+static LLFastTimer::DeclareTimer FTM_VOLUME_TEXTURES("Volume Textures");
+
+// Implementation class of LLMediaDataClientObject.  See llmediadataclient.h
+class LLMediaDataClientObjectImpl : public LLMediaDataClientObject
+{
+public:
+	LLMediaDataClientObjectImpl(LLVOVolume *obj, bool isNew) : mObject(obj), mNew(isNew) 
+	{
+		mObject->addMDCImpl();
+	}
+	~LLMediaDataClientObjectImpl()
+	{
+		mObject->removeMDCImpl();
+	}
+	
+	virtual U8 getMediaDataCount() const 
+		{ return mObject->getNumTEs(); }
+
+	virtual LLSD getMediaDataLLSD(U8 index) const 
+		{
+			LLSD result;
+			LLTextureEntry *te = mObject->getTE(index); 
+			if (NULL != te)
+			{
+				llassert((te->getMediaData() != NULL) == te->hasMedia());
+				if (te->getMediaData() != NULL)
+				{
+					result = te->getMediaData()->asLLSD();
+					// XXX HACK: workaround bug in asLLSD() where whitelist is not set properly
+					// See DEV-41949
+					if (!result.has(LLMediaEntry::WHITELIST_KEY))
+					{
+						result[LLMediaEntry::WHITELIST_KEY] = LLSD::emptyArray();
+					}
+				}
+			}
+			return result;
+		}
+	virtual bool isCurrentMediaUrl(U8 index, const std::string &url) const
+		{
+			LLTextureEntry *te = mObject->getTE(index); 
+			if (te)
+			{
+				if (te->getMediaData())
+				{
+					return (te->getMediaData()->getCurrentURL() == url);
+				}
+			}
+			return url.empty();
+		}
+
+	virtual LLUUID getID() const
+		{ return mObject->getID(); }
+
+	virtual void mediaNavigateBounceBack(U8 index)
+		{ mObject->mediaNavigateBounceBack(index); }
+	
+	virtual bool hasMedia() const
+		{ return mObject->hasMedia(); }
+	
+	virtual void updateObjectMediaData(LLSD const &data, const std::string &version_string) 
+		{ mObject->updateObjectMediaData(data, version_string); }
+	
+	virtual F64 getMediaInterest() const 
+		{ 
+			F64 interest = mObject->getTotalMediaInterest();
+			if (interest < (F64)0.0)
+			{
+				// media interest not valid yet, try pixel area
+				interest = mObject->getPixelArea();
+				// HACK: force recalculation of pixel area if interest is the "magic default" of 1024.
+				if (interest == 1024.f)
+				{
+					const_cast<LLVOVolume*>(static_cast<LLVOVolume*>(mObject))->setPixelAreaAndAngle(gAgent);
+					interest = mObject->getPixelArea();
+				}
+			}
+			return interest; 
+		}
+	
+	virtual bool isInterestingEnough() const
+		{
+			return LLViewerMedia::isInterestingEnough(mObject, getMediaInterest());
+		}
+
+	virtual std::string getCapabilityUrl(const std::string &name) const
+		{ return mObject->getRegion()->getCapability(name); }
+	
+	virtual bool isDead() const
+		{ return mObject->isDead(); }
+	
+	virtual U32 getMediaVersion() const
+		{ return LLTextureEntry::getVersionFromMediaVersionString(mObject->getMediaURL()); }
+	
+	virtual bool isNew() const
+		{ return mNew; }
+
+private:
+	LLPointer<LLVOVolume> mObject;
+	bool mNew;
+};
+
+
+LLVOVolume::LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
+	: LLViewerObject(id, pcode, regionp),
+	  mVolumeImpl(NULL)
+{
+	mTexAnimMode = 0;
+	mRelativeXform.setIdentity();
+	mRelativeXformInvTrans.setIdentity();
+
+	mFaceMappingChanged = FALSE;
+	mLOD = MIN_LOD;
+	mTextureAnimp = NULL;
+	mVolumeChanged = FALSE;
+	mVObjRadius = LLVector3(1,1,0.5f).length();
+	mNumFaces = 0;
+	mLODChanged = FALSE;
+	mSculptChanged = FALSE;
+	mSpotLightPriority = 0.f;
+
+	mMediaImplList.resize(getNumTEs());
+	mLastFetchedMediaVersion = -1;
+	mIndexInTex = 0;
+	mMDCImplCount = 0;
+}
+
+LLVOVolume::~LLVOVolume()
+{
+	delete mTextureAnimp;
+	mTextureAnimp = NULL;
+	delete mVolumeImpl;
+	mVolumeImpl = NULL;
+
+	if(!mMediaImplList.empty())
+	{
+		for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
+		{
+			if(mMediaImplList[i].notNull())
+			{
+				mMediaImplList[i]->removeObject(this) ;
+			}
+		}
+	}
+}
+
+void LLVOVolume::markDead()
+{
+	if (!mDead)
+	{
+		if(getMDCImplCount() > 0)
+		{
+			LLMediaDataClientObject::ptr_t obj = new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false);
+			if (sObjectMediaClient) sObjectMediaClient->removeFromQueue(obj);
+			if (sObjectMediaNavigateClient) sObjectMediaNavigateClient->removeFromQueue(obj);
+		}
+		
+		// Detach all media impls from this object
+		for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
+		{
+			removeMediaImpl(i);
+		}
+
+		if (mSculptTexture.notNull())
+		{
+			mSculptTexture->removeVolume(this);
+		}
+	}
+	
+	LLViewerObject::markDead();
+}
+
+
+// static
+void LLVOVolume::initClass()
+{
+	// gSavedSettings better be around
+	if (gSavedSettings.getBOOL("PrimMediaMasterEnabled"))
+	{
+		const F32 queue_timer_delay = gSavedSettings.getF32("PrimMediaRequestQueueDelay");
+		const F32 retry_timer_delay = gSavedSettings.getF32("PrimMediaRetryTimerDelay");
+		const U32 max_retries = gSavedSettings.getU32("PrimMediaMaxRetries");
+		const U32 max_sorted_queue_size = gSavedSettings.getU32("PrimMediaMaxSortedQueueSize");
+		const U32 max_round_robin_queue_size = gSavedSettings.getU32("PrimMediaMaxRoundRobinQueueSize");
+		sObjectMediaClient = new LLObjectMediaDataClient(queue_timer_delay, retry_timer_delay, max_retries, 
+														 max_sorted_queue_size, max_round_robin_queue_size);
+		sObjectMediaNavigateClient = new LLObjectMediaNavigateClient(queue_timer_delay, retry_timer_delay, 
+																	 max_retries, max_sorted_queue_size, max_round_robin_queue_size);
+	}
+}
+
+// static
+void LLVOVolume::cleanupClass()
+{
+    sObjectMediaClient = NULL;
+    sObjectMediaNavigateClient = NULL;
+}
+
+U32 LLVOVolume::processUpdateMessage(LLMessageSystem *mesgsys,
+										  void **user_data,
+										  U32 block_num, EObjectUpdateType update_type,
+										  LLDataPacker *dp)
+{
+	LLColor4U color;
+	const S32 teDirtyBits = (TEM_CHANGE_TEXTURE|TEM_CHANGE_COLOR|TEM_CHANGE_MEDIA);
+
+	// Do base class updates...
+	U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
+
+	LLUUID sculpt_id;
+	U8 sculpt_type = 0;
+	if (isSculpted())
+	{
+		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
+		sculpt_id = sculpt_params->getSculptTexture();
+		sculpt_type = sculpt_params->getSculptType();
+	}
+
+	if (!dp)
+	{
+		if (update_type == OUT_FULL)
+		{
+			////////////////////////////////
+			//
+			// Unpack texture animation data
+			//
+			//
+
+			if (mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureAnim))
+			{
+				if (!mTextureAnimp)
+				{
+					mTextureAnimp = new LLViewerTextureAnim();
+				}
+				else
+				{
+					if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
+					{
+						mTextureAnimp->reset();
+					}
+				}
+				mTexAnimMode = 0;
+				mTextureAnimp->unpackTAMessage(mesgsys, block_num);
+			}
+			else
+			{
+				if (mTextureAnimp)
+				{
+					delete mTextureAnimp;
+					mTextureAnimp = NULL;
+					gPipeline.markTextured(mDrawable);
+					mFaceMappingChanged = TRUE;
+					mTexAnimMode = 0;
+				}
+			}
+
+			// Unpack volume data
+			LLVolumeParams volume_params;
+			LLVolumeMessage::unpackVolumeParams(&volume_params, mesgsys, _PREHASH_ObjectData, block_num);
+			volume_params.setSculptID(sculpt_id, sculpt_type);
+
+			if (setVolume(volume_params, 0))
+			{
+				markForUpdate(TRUE);
+			}
+		}
+
+		// Sigh, this needs to be done AFTER the volume is set as well, otherwise bad stuff happens...
+		////////////////////////////
+		//
+		// Unpack texture entry data
+		//
+
+		S32 result = unpackTEMessage(mesgsys, _PREHASH_ObjectData, block_num);
+		if (result & teDirtyBits)
+		{
+			updateTEData();
+		}
+		if (result & TEM_CHANGE_MEDIA)
+		{
+			retval |= MEDIA_FLAGS_CHANGED;
+		}
+	}
+	else
+	{
+		// CORY TO DO: Figure out how to get the value here
+		if (update_type != OUT_TERSE_IMPROVED)
+		{
+			LLVolumeParams volume_params;
+			BOOL res = LLVolumeMessage::unpackVolumeParams(&volume_params, *dp);
+			if (!res)
+			{
+				llwarns << "Bogus volume parameters in object " << getID() << llendl;
+				llwarns << getRegion()->getOriginGlobal() << llendl;
+			}
+
+			volume_params.setSculptID(sculpt_id, sculpt_type);
+
+			if (setVolume(volume_params, 0))
+			{
+				markForUpdate(TRUE);
+			}
+			S32 res2 = unpackTEMessage(*dp);
+			if (TEM_INVALID == res2)
+			{
+				// There's something bogus in the data that we're unpacking.
+				dp->dumpBufferToLog();
+				llwarns << "Flushing cache files" << llendl;
+
+				if(LLVOCache::hasInstance() && getRegion())
+				{
+					LLVOCache::getInstance()->removeEntry(getRegion()->getHandle()) ;
+				}
+				
+				llwarns << "Bogus TE data in " << getID() << llendl;
+			}
+			else 
+			{
+				if (res2 & teDirtyBits) 
+				{
+					updateTEData();
+				}
+				if (res2 & TEM_CHANGE_MEDIA)
+				{
+					retval |= MEDIA_FLAGS_CHANGED;
+				}
+			}
+
+			U32 value = dp->getPassFlags();
+
+			if (value & 0x40)
+			{
+				if (!mTextureAnimp)
+				{
+					mTextureAnimp = new LLViewerTextureAnim();
+				}
+				else
+				{
+					if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
+					{
+						mTextureAnimp->reset();
+					}
+				}
+				mTexAnimMode = 0;
+				mTextureAnimp->unpackTAMessage(*dp);
+			}
+			else if (mTextureAnimp)
+			{
+				delete mTextureAnimp;
+				mTextureAnimp = NULL;
+				gPipeline.markTextured(mDrawable);
+				mFaceMappingChanged = TRUE;
+				mTexAnimMode = 0;
+			}
+		}
+		else
+		{
+			S32 texture_length = mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureEntry);
+			if (texture_length)
+			{
+				U8							tdpbuffer[1024];
+				LLDataPackerBinaryBuffer	tdp(tdpbuffer, 1024);
+				mesgsys->getBinaryDataFast(_PREHASH_ObjectData, _PREHASH_TextureEntry, tdpbuffer, 0, block_num);
+				S32 result = unpackTEMessage(tdp);
+				if (result & teDirtyBits)
+				{
+					updateTEData();
+				}
+				if (result & TEM_CHANGE_MEDIA)
+				{
+					retval |= MEDIA_FLAGS_CHANGED;
+				}
+			}
+		}
+	}
+	if (retval & (MEDIA_URL_REMOVED | MEDIA_URL_ADDED | MEDIA_URL_UPDATED | MEDIA_FLAGS_CHANGED)) 
+	{
+		// If only the media URL changed, and it isn't a media version URL,
+		// ignore it
+		if ( ! ( retval & (MEDIA_URL_ADDED | MEDIA_URL_UPDATED) &&
+				 mMedia && ! mMedia->mMediaURL.empty() &&
+				 ! LLTextureEntry::isMediaVersionString(mMedia->mMediaURL) ) )
+		{
+			// If the media changed at all, request new media data
+			LL_DEBUGS("MediaOnAPrim") << "Media update: " << getID() << ": retval=" << retval << " Media URL: " <<
+                ((mMedia) ?  mMedia->mMediaURL : std::string("")) << LL_ENDL;
+			requestMediaDataUpdate(retval & MEDIA_FLAGS_CHANGED);
+		}
+        else {
+            LL_INFOS("MediaOnAPrim") << "Ignoring media update for: " << getID() << " Media URL: " <<
+                ((mMedia) ?  mMedia->mMediaURL : std::string("")) << LL_ENDL;
+        }
+	}
+	// ...and clean up any media impls
+	cleanUpMediaImpls();
+
+	return retval;
+}
+
+
+void LLVOVolume::animateTextures()
+{
+	F32 off_s = 0.f, off_t = 0.f, scale_s = 1.f, scale_t = 1.f, rot = 0.f;
+	S32 result = mTextureAnimp->animateTextures(off_s, off_t, scale_s, scale_t, rot);
+	
+	if (result)
+	{
+		if (!mTexAnimMode)
+		{
+			mFaceMappingChanged = TRUE;
+			gPipeline.markTextured(mDrawable);
+		}
+		mTexAnimMode = result | mTextureAnimp->mMode;
+				
+		S32 start=0, end=mDrawable->getNumFaces()-1;
+		if (mTextureAnimp->mFace >= 0 && mTextureAnimp->mFace <= end)
+		{
+			start = end = mTextureAnimp->mFace;
+		}
+		
+		for (S32 i = start; i <= end; i++)
+		{
+			LLFace* facep = mDrawable->getFace(i);
+			if(facep->getVirtualSize() <= MIN_TEX_ANIM_SIZE && facep->mTextureMatrix) continue;
+
+			const LLTextureEntry* te = facep->getTextureEntry();
+			
+			if (!te)
+			{
+				continue;
+			}
+		
+			if (!(result & LLViewerTextureAnim::ROTATE))
+			{
+				te->getRotation(&rot);
+			}
+			if (!(result & LLViewerTextureAnim::TRANSLATE))
+			{
+				te->getOffset(&off_s,&off_t);
+			}			
+			if (!(result & LLViewerTextureAnim::SCALE))
+			{
+				te->getScale(&scale_s, &scale_t);
+			}
+
+			if (!facep->mTextureMatrix)
+			{
+				facep->mTextureMatrix = new LLMatrix4();
+			}
+
+			LLMatrix4& tex_mat = *facep->mTextureMatrix;
+			tex_mat.setIdentity();
+			LLVector3 trans ;
+
+			if(facep->isAtlasInUse())
+			{
+				//
+				//if use atlas for animated texture
+				//apply the following transform to the animation matrix.
+				//
+
+				F32 tcoord_xoffset = 0.f ;
+				F32 tcoord_yoffset = 0.f ;
+				F32 tcoord_xscale = 1.f ;
+				F32 tcoord_yscale = 1.f ;			
+				if(facep->isAtlasInUse())
+				{
+					const LLVector2* tmp = facep->getTexCoordOffset() ;
+					tcoord_xoffset = tmp->mV[0] ; 
+					tcoord_yoffset = tmp->mV[1] ;
+
+					tmp = facep->getTexCoordScale() ;
+					tcoord_xscale = tmp->mV[0] ; 
+					tcoord_yscale = tmp->mV[1] ;	
+				}
+				trans.set(LLVector3(tcoord_xoffset + tcoord_xscale * (off_s+0.5f), tcoord_yoffset + tcoord_yscale * (off_t+0.5f), 0.f));
+
+				tex_mat.translate(LLVector3(-(tcoord_xoffset + tcoord_xscale * 0.5f), -(tcoord_yoffset + tcoord_yscale * 0.5f), 0.f));
+			}
+			else	//non atlas
+			{
+				trans.set(LLVector3(off_s+0.5f, off_t+0.5f, 0.f));			
+				tex_mat.translate(LLVector3(-0.5f, -0.5f, 0.f));
+			}
+
+			LLVector3 scale(scale_s, scale_t, 1.f);			
+			LLQuaternion quat;
+			quat.setQuat(rot, 0, 0, -1.f);
+		
+			tex_mat.rotate(quat);				
+
+			LLMatrix4 mat;
+			mat.initAll(scale, LLQuaternion(), LLVector3());
+			tex_mat *= mat;
+		
+			tex_mat.translate(trans);
+		}
+	}
+	else
+	{
+		if (mTexAnimMode && mTextureAnimp->mRate == 0)
+		{
+			U8 start, count;
+
+			if (mTextureAnimp->mFace == -1)
+			{
+				start = 0;
+				count = getNumTEs();
+			}
+			else
+			{
+				start = (U8) mTextureAnimp->mFace;
+				count = 1;
+			}
+
+			for (S32 i = start; i < start + count; i++)
+			{
+				if (mTexAnimMode & LLViewerTextureAnim::TRANSLATE)
+				{
+					setTEOffset(i, mTextureAnimp->mOffS, mTextureAnimp->mOffT);				
+				}
+				if (mTexAnimMode & LLViewerTextureAnim::SCALE)
+				{
+					setTEScale(i, mTextureAnimp->mScaleS, mTextureAnimp->mScaleT);	
+				}
+				if (mTexAnimMode & LLViewerTextureAnim::ROTATE)
+				{
+					setTERotation(i, mTextureAnimp->mRot);
+				}
+			}
+
+			gPipeline.markTextured(mDrawable);
+			mFaceMappingChanged = TRUE;
+			mTexAnimMode = 0;
+		}
+	}
+}
+BOOL LLVOVolume::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
+{
+	LLViewerObject::idleUpdate(agent, world, time);
+
+	static LLFastTimer::DeclareTimer ftm("Volume");
+	LLFastTimer t(ftm);
+
+	if (mDead || mDrawable.isNull())
+	{
+		return TRUE;
+	}
+	
+	///////////////////////
+	//
+	// Do texture animation stuff
+	//
+
+	if (mTextureAnimp && gAnimateTextures)
+	{
+		animateTextures();
+	}
+
+	// Dispatch to implementation
+	if (mVolumeImpl)
+	{
+		mVolumeImpl->doIdleUpdate(agent, world, time);
+	}
+
+	const S32 MAX_ACTIVE_OBJECT_QUIET_FRAMES = 40;
+
+	if (mDrawable->isActive())
+	{
+		if (mDrawable->isRoot() && 
+			mDrawable->mQuietCount++ > MAX_ACTIVE_OBJECT_QUIET_FRAMES && 
+			(!mDrawable->getParent() || !mDrawable->getParent()->isActive()))
+		{
+			mDrawable->makeStatic();
+		}
+	}
+
+	return TRUE;
+}
+
+void LLVOVolume::updateTextures()
+{
+	const F32 TEXTURE_AREA_REFRESH_TIME = 5.f; // seconds
+	if (mTextureUpdateTimer.getElapsedTimeF32() > TEXTURE_AREA_REFRESH_TIME)
+	{
+		updateTextureVirtualSize();		
+	}
+}
+
+BOOL LLVOVolume::isVisible() const 
+{
+	if(mDrawable.notNull() && mDrawable->isVisible())
+	{
+		return TRUE ;
+	}
+
+	if(isAttachment())
+	{
+		LLViewerObject* objp = (LLViewerObject*)getParent() ;
+		while(objp && !objp->isAvatar())
+		{
+			objp = (LLViewerObject*)objp->getParent() ;
+		}
+
+		return objp && objp->mDrawable.notNull() && objp->mDrawable->isVisible() ;
+	}
+
+	return FALSE ;
+}
+
+void LLVOVolume::updateTextureVirtualSize()
+{
+	LLFastTimer ftm(FTM_VOLUME_TEXTURES);
+	// Update the pixel area of all faces
+
+	if(!isVisible())
+	{
+		return ;
+	}
+
+	if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SIMPLE))
+	{
+		return;
+	}
+
+	static LLCachedControl<bool> dont_load_textures(gSavedSettings,"TextureDisable");
+		
+	if (dont_load_textures || LLAppViewer::getTextureFetch()->mDebugPause) // || !mDrawable->isVisible())
+	{
+		return;
+	}
+
+	mTextureUpdateTimer.reset();
+	
+	F32 old_area = mPixelArea;
+	mPixelArea = 0.f;
+
+	const S32 num_faces = mDrawable->getNumFaces();
+	F32 min_vsize=999999999.f, max_vsize=0.f;
+	LLViewerCamera* camera = LLViewerCamera::getInstance();
+	for (S32 i = 0; i < num_faces; i++)
+	{
+		LLFace* face = mDrawable->getFace(i);
+		const LLTextureEntry *te = face->getTextureEntry();
+		LLViewerTexture *imagep = face->getTexture();
+		if (!imagep || !te ||			
+			face->mExtents[0].equals3(face->mExtents[1]))
+		{
+			continue;
+		}
+		
+		F32 vsize;
+		F32 old_size = face->getVirtualSize();
+
+		if (isHUDAttachment())
+		{
+			F32 area = (F32) camera->getScreenPixelArea();
+			vsize = area;
+			imagep->setBoostLevel(LLViewerTexture::BOOST_HUD);
+ 			face->setPixelArea(area); // treat as full screen
+			face->setVirtualSize(vsize);
+		}
+		else
+		{
+			vsize = face->getTextureVirtualSize();
+		}
+
+		mPixelArea = llmax(mPixelArea, face->getPixelArea());		
+
+		if (face->mTextureMatrix != NULL)
+		{
+			if ((vsize < MIN_TEX_ANIM_SIZE && old_size > MIN_TEX_ANIM_SIZE) ||
+				(vsize > MIN_TEX_ANIM_SIZE && old_size < MIN_TEX_ANIM_SIZE))
+			{
+				gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD, FALSE);
+			}
+		}
+				
+		if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
+		{
+			if (vsize < min_vsize) min_vsize = vsize;
+			if (vsize > max_vsize) max_vsize = vsize;
+		}
+		else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
+		{
+			LLViewerFetchedTexture* img = LLViewerTextureManager::staticCastToFetchedTexture(imagep) ;
+			if(img)
+			{
+				F32 pri = img->getDecodePriority();
+				pri = llmax(pri, 0.0f);
+				if (pri < min_vsize) min_vsize = pri;
+				if (pri > max_vsize) max_vsize = pri;
+			}
+		}
+		else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
+		{
+			F32 pri = mPixelArea;
+			if (pri < min_vsize) min_vsize = pri;
+			if (pri > max_vsize) max_vsize = pri;
+		}	
+	}
+	
+	if (isSculpted())
+	{
+		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
+		LLUUID id =  sculpt_params->getSculptTexture();
+		
+		updateSculptTexture();
+		
+		
+
+		if (mSculptTexture.notNull())
+		{
+			mSculptTexture->setBoostLevel(llmax((S32)mSculptTexture->getBoostLevel(),
+												(S32)LLViewerTexture::BOOST_SCULPTED));
+			mSculptTexture->setForSculpt() ;
+			
+			if(!mSculptTexture->isCachedRawImageReady())
+			{
+				S32 lod = llmin(mLOD, 3);
+				F32 lodf = ((F32)(lod + 1.0f)/4.f);
+				F32 tex_size = lodf * LLViewerTexture::sMaxSculptRez ;
+				mSculptTexture->addTextureStats(2.f * tex_size * tex_size, FALSE);
+			
+				//if the sculpty very close to the view point, load first
+				{				
+					LLVector3 lookAt = getPositionAgent() - camera->getOrigin();
+					F32 dist = lookAt.normVec() ;
+					F32 cos_angle_to_view_dir = lookAt * camera->getXAxis() ;				
+					mSculptTexture->setAdditionalDecodePriority(0.8f * LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist)) ;
+				}
+			}
+	
+			S32 texture_discard = mSculptTexture->getDiscardLevel(); //try to match the texture
+			S32 current_discard = getVolume() ? getVolume()->getSculptLevel() : -2 ;
+
+			if (texture_discard >= 0 && //texture has some data available
+				(texture_discard < current_discard || //texture has more data than last rebuild
+				current_discard < 0)) //no previous rebuild
+			{
+				gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
+				mSculptChanged = TRUE;
+			}
+
+			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SCULPTED))
+			{
+				setDebugText(llformat("T%d C%d V%d\n%dx%d",
+										  texture_discard, current_discard, getVolume()->getSculptLevel(),
+										  mSculptTexture->getHeight(), mSculptTexture->getWidth()));
+			}
+		}
+
+	}
+
+	if (getLightTextureID().notNull())
+	{
+		LLLightImageParams* params = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+		LLUUID id = params->getLightTexture();
+		mLightTexture = LLViewerTextureManager::getFetchedTexture(id);
+		if (mLightTexture.notNull())
+		{
+			F32 rad = getLightRadius();
+			mLightTexture->addTextureStats(gPipeline.calcPixelArea(getPositionAgent(), 
+																	LLVector3(rad,rad,rad),
+																	*camera));
+		}	
+	}
+	
+	if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
+	{
+		setDebugText(llformat("%.0f:%.0f", (F32) sqrt(min_vsize),(F32) sqrt(max_vsize)));
+	}
+ 	else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
+ 	{
+ 		setDebugText(llformat("%.0f:%.0f", (F32) sqrt(min_vsize),(F32) sqrt(max_vsize)));
+ 	}
+	else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
+	{
+		setDebugText(llformat("%.0f:%.0f", (F32) sqrt(min_vsize),(F32) sqrt(max_vsize)));
+	}
+
+	if (mPixelArea == 0)
+	{ //flexi phasing issues make this happen
+		mPixelArea = old_area;
+	}
+}
+
+BOOL LLVOVolume::isActive() const
+{
+	return !mStatic || mTextureAnimp || (mVolumeImpl && mVolumeImpl->isActive()) || 
+		(mDrawable.notNull() && mDrawable->isActive());
+}
+
+BOOL LLVOVolume::setMaterial(const U8 material)
+{
+	BOOL res = LLViewerObject::setMaterial(material);
+	
+	return res;
+}
+
+void LLVOVolume::setTexture(const S32 face)
+{
+	llassert(face < getNumTEs());
+	gGL.getTexUnit(0)->bind(getTEImage(face));
+}
+
+void LLVOVolume::setScale(const LLVector3 &scale, BOOL damped)
+{
+	if (scale != getScale())
+	{
+		// store local radius
+		LLViewerObject::setScale(scale);
+
+		if (mVolumeImpl)
+		{
+			mVolumeImpl->onSetScale(scale, damped);
+		}
+		
+		updateRadius();
+
+		//since drawable transforms do not include scale, changing volume scale
+		//requires an immediate rebuild of volume verts.
+		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_POSITION, TRUE);
+	}
+}
+
+LLFace* LLVOVolume::addFace(S32 f)
+{
+	const LLTextureEntry* te = getTE(f);
+	LLViewerTexture* imagep = getTEImage(f);
+	return mDrawable->addFace(te, imagep);
+}
+
+LLDrawable *LLVOVolume::createDrawable(LLPipeline *pipeline)
+{
+	pipeline->allocDrawable(this);
+		
+	mDrawable->setRenderType(LLPipeline::RENDER_TYPE_VOLUME);
+
+	S32 max_tes_to_set = getNumTEs();
+	for (S32 i = 0; i < max_tes_to_set; i++)
+	{
+		addFace(i);
+	}
+	mNumFaces = max_tes_to_set;
+
+	if (isAttachment())
+	{
+		mDrawable->makeActive();
+	}
+
+	if (getIsLight())
+	{
+		// Add it to the pipeline mLightSet
+		gPipeline.setLight(mDrawable, TRUE);
+	}
+	
+	updateRadius();
+	bool force_update = true; // avoid non-alpha mDistance update being optimized away
+	mDrawable->updateDistance(*LLViewerCamera::getInstance(), force_update);
+
+	return mDrawable;
+}
+
+BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bool unique_volume)
+{
+	LLVolumeParams volume_params = params_in;
+
+	S32 last_lod = mVolumep.notNull() ? LLVolumeLODGroup::getVolumeDetailFromScale(mVolumep->getDetail()) : -1;
+	S32 lod = mLOD;
+
+	BOOL is404 = FALSE;
+	
+	if (isSculpted())
+	{
+		// if it's a mesh
+		if ((volume_params.getSculptType() & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
+		{ //meshes might not have all LODs, get the force detail to best existing LOD
+			LLUUID mesh_id = volume_params.getSculptID();
+
+			lod = gMeshRepo.getActualMeshLOD(volume_params, lod);
+			if (lod == -1)
+			{
+				is404 = TRUE;
+				lod = 0;
+			}
+		}
+	}
+
+	// Check if we need to change implementations
+	bool is_flexible = (volume_params.getPathParams().getCurveType() == LL_PCODE_PATH_FLEXIBLE);
+	if (is_flexible)
+	{
+		setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, TRUE, false);
+		if (!mVolumeImpl)
+		{
+			LLFlexibleObjectData* data = (LLFlexibleObjectData*)getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
+			mVolumeImpl = new LLVolumeImplFlexible(this, data);
+		}
+	}
+	else
+	{
+		// Mark the parameter not in use
+		setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, FALSE, false);
+		if (mVolumeImpl)
+		{
+			delete mVolumeImpl;
+			mVolumeImpl = NULL;
+			if (mDrawable.notNull())
+			{
+				// Undo the damage we did to this matrix
+				mDrawable->updateXform(FALSE);
+			}
+		}
+	}
+	
+	if (is404)
+	{
+		setIcon(LLViewerTextureManager::getFetchedTextureFromFile("icons/Inv_Mesh.png", TRUE, LLViewerTexture::BOOST_UI));
+		//render prim proxy when mesh loading attempts give up
+		volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_NONE);
+
+	}
+
+	if ((LLPrimitive::setVolume(volume_params, lod, (mVolumeImpl && mVolumeImpl->isVolumeUnique()))) || mSculptChanged)
+	{
+		mFaceMappingChanged = TRUE;
+		
+		if (mVolumeImpl)
+		{
+			mVolumeImpl->onSetVolume(volume_params, mLOD);
+		}
+	
+		updateSculptTexture();
+
+		if (isSculpted())
+		{
+			updateSculptTexture();
+			// if it's a mesh
+			if ((volume_params.getSculptType() & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
+			{
+				if (!getVolume()->isMeshAssetLoaded())
+				{ 
+					//load request not yet issued, request pipeline load this mesh
+					LLUUID asset_id = volume_params.getSculptID();
+					S32 available_lod = gMeshRepo.loadMesh(this, volume_params, lod, last_lod);
+					if (available_lod != lod)
+					{
+						LLPrimitive::setVolume(volume_params, available_lod);
+					}
+				}
+				
+			}
+			else // otherwise is sculptie
+			{
+				if (mSculptTexture.notNull())
+				{
+					sculpt();
+				}
+			}
+		}
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+void LLVOVolume::updateSculptTexture()
+{
+	LLPointer<LLViewerFetchedTexture> old_sculpt = mSculptTexture;
+
+	if (isSculpted() && !isMesh())
+	{
+		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
+		LLUUID id =  sculpt_params->getSculptTexture();
+		if (id.notNull())
+		{
+			mSculptTexture = LLViewerTextureManager::getFetchedTexture(id, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
+		}
+	}
+	else
+	{
+		mSculptTexture = NULL;
+	}
+
+	if (mSculptTexture != old_sculpt)
+	{
+		if (old_sculpt.notNull())
+		{
+			old_sculpt->removeVolume(this);
+		}
+		if (mSculptTexture.notNull())
+		{
+			mSculptTexture->addVolume(this);
+		}
+	}
+	
+}
+
+void LLVOVolume::notifyMeshLoaded()
+{ 
+	mSculptChanged = TRUE;
+	gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_GEOMETRY, TRUE);
+}
+
+// sculpt replaces generate() for sculpted surfaces
+void LLVOVolume::sculpt()
+{	
+	if (mSculptTexture.notNull())
+	{				
+		U16 sculpt_height = 0;
+		U16 sculpt_width = 0;
+		S8 sculpt_components = 0;
+		const U8* sculpt_data = NULL;
+	
+		S32 discard_level = mSculptTexture->getDiscardLevel() ;
+		LLImageRaw* raw_image = mSculptTexture->getCachedRawImage() ;
+		
+		S32 max_discard = mSculptTexture->getMaxDiscardLevel();
+		if (discard_level > max_discard)
+			discard_level = max_discard;    // clamp to the best we can do
+
+		S32 current_discard = getVolume()->getSculptLevel() ;
+		if(current_discard < -2)
+		{
+			llwarns << "WARNING!!: Current discard of sculpty at " << current_discard 
+				<< " is less than -2." << llendl;
+			
+			// corrupted volume... don't update the sculpty
+			return;
+		}
+		else if (current_discard > MAX_DISCARD_LEVEL)
+		{
+			llwarns << "WARNING!!: Current discard of sculpty at " << current_discard 
+				<< " is more than than allowed max of " << MAX_DISCARD_LEVEL << llendl;
+			
+			// corrupted volume... don't update the sculpty			
+			return;
+		}
+
+		if (current_discard == discard_level)  // no work to do here
+			return;
+		
+		if(!raw_image)
+		{
+			llassert(discard_level < 0) ;
+
+			sculpt_width = 0;
+			sculpt_height = 0;
+			sculpt_data = NULL ;
+
+			if(LLViewerTextureManager::sTesterp)
+			{
+				LLViewerTextureManager::sTesterp->updateGrayTextureBinding();
+			}
+		}
+		else
+		{					
+			sculpt_height = raw_image->getHeight();
+			sculpt_width = raw_image->getWidth();
+			sculpt_components = raw_image->getComponents();		
+					   
+			sculpt_data = raw_image->getData();
+
+			if(LLViewerTextureManager::sTesterp)
+			{
+				mSculptTexture->updateBindStatsForTester() ;
+			}
+		}
+		getVolume()->sculpt(sculpt_width, sculpt_height, sculpt_components, sculpt_data, discard_level);
+
+		//notify rebuild any other VOVolumes that reference this sculpty volume
+		for (S32 i = 0; i < mSculptTexture->getNumVolumes(); ++i)
+		{
+			LLVOVolume* volume = (*(mSculptTexture->getVolumeList()))[i];
+			if (volume != this && volume->getVolume() == getVolume())
+			{
+				gPipeline.markRebuild(volume->mDrawable, LLDrawable::REBUILD_GEOMETRY, FALSE);
+			}
+		}
+	}
+}
+
+S32	LLVOVolume::computeLODDetail(F32 distance, F32 radius)
+{
+	S32	cur_detail;
+	if (LLPipeline::sDynamicLOD)
+	{
+		// We've got LOD in the profile, and in the twist.  Use radius.
+		F32 tan_angle = (LLVOVolume::sLODFactor*radius)/distance;
+		cur_detail = LLVolumeLODGroup::getDetailFromTan(llround(tan_angle, 0.01f));
+	}
+	else
+	{
+		cur_detail = llclamp((S32) (sqrtf(radius)*LLVOVolume::sLODFactor*4.f), 0, 3);		
+	}
+	return cur_detail;
+}
+
+BOOL LLVOVolume::calcLOD()
+{
+	if (mDrawable.isNull())
+	{
+		return FALSE;
+	}
+
+	S32 cur_detail = 0;
+	
+	F32 radius;
+	F32 distance;
+
+	if (mDrawable->isState(LLDrawable::RIGGED))
+	{
+		LLVOAvatar* avatar = getAvatar(); 
+		distance = avatar->mDrawable->mDistanceWRTCamera;
+		radius = avatar->getBinRadius();
+	}
+	else
+	{
+		distance = mDrawable->mDistanceWRTCamera;
+		radius = getVolume()->mLODScaleBias.scaledVec(getScale()).length();
+	}
+	
+	//hold onto unmodified distance for debugging
+	//F32 debug_distance = distance;
+	
+	distance *= sDistanceFactor;
+
+	F32 rampDist = LLVOVolume::sLODFactor * 2;
+	
+	if (distance < rampDist)
+	{
+		// Boost LOD when you're REALLY close
+		distance *= 1.0f/rampDist;
+		distance *= distance;
+		distance *= rampDist;
+	}
+	
+	// DON'T Compensate for field of view changing on FOV zoom.
+	distance *= F_PI/3.f;
+
+	cur_detail = computeLODDetail(llround(distance, 0.01f), 
+									llround(radius, 0.01f));
+
+
+	if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_LOD_INFO))
+	{
+		//setDebugText(llformat("%.2f:%.2f, %d", debug_distance, radius, cur_detail));
+
+		setDebugText(llformat("%d", mDrawable->getFace(0)->getTextureIndex()));
+	}
+
+	if (cur_detail != mLOD)
+	{
+		mAppAngle = llround((F32) atan2( mDrawable->getRadius(), mDrawable->mDistanceWRTCamera) * RAD_TO_DEG, 0.01f);
+		mLOD = cur_detail;		
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+BOOL LLVOVolume::updateLOD()
+{
+	if (mDrawable.isNull())
+	{
+		return FALSE;
+	}
+	
+	BOOL lod_changed = calcLOD();
+
+	if (lod_changed)
+	{
+		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
+		mLODChanged = TRUE;
+	}
+	else
+	{
+		F32 new_radius = getBinRadius();
+		F32 old_radius = mDrawable->getBinRadius();
+		if (new_radius < old_radius * 0.9f || new_radius > old_radius*1.1f)
+		{
+			gPipeline.markPartitionMove(mDrawable);
+		}
+	}
+
+	lod_changed = lod_changed || LLViewerObject::updateLOD();
+	
+	return lod_changed;
+}
+
+BOOL LLVOVolume::setDrawableParent(LLDrawable* parentp)
+{
+	if (!LLViewerObject::setDrawableParent(parentp))
+	{
+		// no change in drawable parent
+		return FALSE;
+	}
+
+	if (!mDrawable->isRoot())
+	{
+		// rebuild vertices in parent relative space
+		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
+
+		if (mDrawable->isActive() && !parentp->isActive())
+		{
+			parentp->makeActive();
+		}
+		else if (mDrawable->isStatic() && parentp->isActive())
+		{
+			mDrawable->makeActive();
+		}
+	}
+	
+	return TRUE;
+}
+
+void LLVOVolume::updateFaceFlags()
+{
+	for (S32 i = 0; i < getVolume()->getNumFaces(); i++)
+	{
+		LLFace *face = mDrawable->getFace(i);
+		if (!face)
+		{
+			return;
+		}
+
+		BOOL fullbright = getTE(i)->getFullbright();
+		face->clearState(LLFace::FULLBRIGHT | LLFace::HUD_RENDER | LLFace::LIGHT);
+
+		if (fullbright || (mMaterial == LL_MCODE_LIGHT))
+		{
+			face->setState(LLFace::FULLBRIGHT);
+		}
+		if (mDrawable->isLight())
+		{
+			face->setState(LLFace::LIGHT);
+		}
+		if (isHUDAttachment())
+		{
+			face->setState(LLFace::HUD_RENDER);
+		}
+	}
+}
+
+BOOL LLVOVolume::setParent(LLViewerObject* parent)
+{
+	BOOL ret = FALSE ;
+	if (parent != getParent())
+	{
+		ret = LLViewerObject::setParent(parent);
+		if (ret && mDrawable)
+		{
+			gPipeline.markMoved(mDrawable);
+			gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
+		}
+	}
+
+	return ret ;
+}
+
+// NOTE: regenFaces() MUST be followed by genTriangles()!
+void LLVOVolume::regenFaces()
+{
+	// remove existing faces
+	BOOL count_changed = mNumFaces != getNumTEs();
+	
+	if (count_changed)
+	{
+		deleteFaces();		
+		// add new faces
+		mNumFaces = getNumTEs();
+	}
+		
+	for (S32 i = 0; i < mNumFaces; i++)
+	{
+		LLFace* facep = count_changed ? addFace(i) : mDrawable->getFace(i);
+		facep->setTEOffset(i);
+		facep->setTexture(getTEImage(i));
+		facep->setViewerObject(this);
+		
+		// If the face had media on it, this will have broken the link between the LLViewerMediaTexture and the face.
+		// Re-establish the link.
+		if((int)mMediaImplList.size() > i)
+		{
+			if(mMediaImplList[i])
+			{
+				LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[i]->getMediaTextureID()) ;
+				if(media_tex)
+				{
+					media_tex->addMediaToFace(facep) ;
+				}
+			}
+		}
+	}
+	
+	if (!count_changed)
+	{
+		updateFaceFlags();
+	}
+}
+
+BOOL LLVOVolume::genBBoxes(BOOL force_global)
+{
+	BOOL res = TRUE;
+
+	LLVector4a min,max;
+
+	min.clear();
+	max.clear();
+
+	BOOL rebuild = mDrawable->isState(LLDrawable::REBUILD_VOLUME | LLDrawable::REBUILD_POSITION | LLDrawable::REBUILD_RIGGED);
+
+//	bool rigged = false;
+	LLVolume* volume = mRiggedVolume;
+	if (!volume)
+	{
+		volume = getVolume();
+	}
+
+	for (S32 i = 0; i < getVolume()->getNumVolumeFaces(); i++)
+	{
+		LLFace *face = mDrawable->getFace(i);
+		if (!face)
+		{
+			continue;
+		}
+		res &= face->genVolumeBBoxes(*volume, i,
+										mRelativeXform, mRelativeXformInvTrans,
+										(mVolumeImpl && mVolumeImpl->isVolumeGlobal()) || force_global);
+		
+		if (rebuild)
+		{
+			if (i == 0)
+			{
+				min = face->mExtents[0];
+				max = face->mExtents[1];
+			}
+			else
+			{
+				min.setMin(min, face->mExtents[0]);
+				max.setMax(max, face->mExtents[1]);
+			}
+		}
+	}
+	
+	if (rebuild)
+	{
+		mDrawable->setSpatialExtents(min,max);
+		min.add(max);
+		min.mul(0.5f);
+		mDrawable->setPositionGroup(min);	
+	}
+
+	updateRadius();
+	mDrawable->movePartition();
+			
+	return res;
+}
+
+void LLVOVolume::preRebuild()
+{
+	if (mVolumeImpl != NULL)
+	{
+		mVolumeImpl->preRebuild();
+	}
+}
+
+void LLVOVolume::updateRelativeXform()
+{
+	if (mVolumeImpl)
+	{
+		mVolumeImpl->updateRelativeXform();
+		return;
+	}
+	
+	LLDrawable* drawable = mDrawable;
+	
+	if (drawable->isState(LLDrawable::RIGGED) && mRiggedVolume.notNull())
+	{ //rigged volume (which is in agent space) is used for generating bounding boxes etc
+	  //inverse of render matrix should go to partition space
+		mRelativeXform = getRenderMatrix();
+
+		F32* dst = (F32*) mRelativeXformInvTrans.mMatrix;
+		F32* src = (F32*) mRelativeXform.mMatrix;
+		dst[0] = src[0]; dst[1] = src[1]; dst[2] = src[2];
+		dst[3] = src[4]; dst[4] = src[5]; dst[5] = src[6];
+		dst[6] = src[8]; dst[7] = src[9]; dst[8] = src[10];
+		
+		mRelativeXform.invert();
+		mRelativeXformInvTrans.transpose();
+	}
+	else if (drawable->isActive())
+	{				
+		// setup relative transforms
+		LLQuaternion delta_rot;
+		LLVector3 delta_pos, delta_scale;
+		
+		//matrix from local space to parent relative/global space
+		delta_rot = drawable->isSpatialRoot() ? LLQuaternion() : mDrawable->getRotation();
+		delta_pos = drawable->isSpatialRoot() ? LLVector3(0,0,0) : mDrawable->getPosition();
+		delta_scale = mDrawable->getScale();
+
+		// Vertex transform (4x4)
+		LLVector3 x_axis = LLVector3(delta_scale.mV[VX], 0.f, 0.f) * delta_rot;
+		LLVector3 y_axis = LLVector3(0.f, delta_scale.mV[VY], 0.f) * delta_rot;
+		LLVector3 z_axis = LLVector3(0.f, 0.f, delta_scale.mV[VZ]) * delta_rot;
+
+		mRelativeXform.initRows(LLVector4(x_axis, 0.f),
+								LLVector4(y_axis, 0.f),
+								LLVector4(z_axis, 0.f),
+								LLVector4(delta_pos, 1.f));
+
+		
+		// compute inverse transpose for normals
+		// mRelativeXformInvTrans.setRows(x_axis, y_axis, z_axis);
+		// mRelativeXformInvTrans.invert(); 
+		// mRelativeXformInvTrans.setRows(x_axis, y_axis, z_axis);
+		// grumble - invert is NOT a matrix invert, so we do it by hand:
+
+		LLMatrix3 rot_inverse = LLMatrix3(~delta_rot);
+
+		LLMatrix3 scale_inverse;
+		scale_inverse.setRows(LLVector3(1.0, 0.0, 0.0) / delta_scale.mV[VX],
+							  LLVector3(0.0, 1.0, 0.0) / delta_scale.mV[VY],
+							  LLVector3(0.0, 0.0, 1.0) / delta_scale.mV[VZ]);
+							   
+		
+		mRelativeXformInvTrans = rot_inverse * scale_inverse;
+
+		mRelativeXformInvTrans.transpose();
+	}
+	else
+	{
+		LLVector3 pos = getPosition();
+		LLVector3 scale = getScale();
+		LLQuaternion rot = getRotation();
+	
+		if (mParent)
+		{
+			pos *= mParent->getRotation();
+			pos += mParent->getPosition();
+			rot *= mParent->getRotation();
+		}
+		
+		//LLViewerRegion* region = getRegion();
+		//pos += region->getOriginAgent();
+		
+		LLVector3 x_axis = LLVector3(scale.mV[VX], 0.f, 0.f) * rot;
+		LLVector3 y_axis = LLVector3(0.f, scale.mV[VY], 0.f) * rot;
+		LLVector3 z_axis = LLVector3(0.f, 0.f, scale.mV[VZ]) * rot;
+
+		mRelativeXform.initRows(LLVector4(x_axis, 0.f),
+								LLVector4(y_axis, 0.f),
+								LLVector4(z_axis, 0.f),
+								LLVector4(pos, 1.f));
+
+		// compute inverse transpose for normals
+		LLMatrix3 rot_inverse = LLMatrix3(~rot);
+
+		LLMatrix3 scale_inverse;
+		scale_inverse.setRows(LLVector3(1.0, 0.0, 0.0) / scale.mV[VX],
+							  LLVector3(0.0, 1.0, 0.0) / scale.mV[VY],
+							  LLVector3(0.0, 0.0, 1.0) / scale.mV[VZ]);
+							   
+		
+		mRelativeXformInvTrans = rot_inverse * scale_inverse;
+
+		mRelativeXformInvTrans.transpose();
+	}
+}
+
+static LLFastTimer::DeclareTimer FTM_GEN_FLEX("Generate Flexies");
+static LLFastTimer::DeclareTimer FTM_UPDATE_PRIMITIVES("Update Primitives");
+static LLFastTimer::DeclareTimer FTM_UPDATE_RIGGED_VOLUME("Update Rigged");
+
+BOOL LLVOVolume::updateGeometry(LLDrawable *drawable)
+{
+	LLFastTimer t(FTM_UPDATE_PRIMITIVES);
+	
+	if (mDrawable->isState(LLDrawable::REBUILD_RIGGED))
+	{
+		{
+			LLFastTimer t(FTM_UPDATE_RIGGED_VOLUME);
+			updateRiggedVolume();
+		}
+		genBBoxes(FALSE);
+		mDrawable->clearState(LLDrawable::REBUILD_RIGGED);
+	}
+
+	if (mVolumeImpl != NULL)
+	{
+		BOOL res;
+		{
+			LLFastTimer t(FTM_GEN_FLEX);
+			res = mVolumeImpl->doUpdateGeometry(drawable);
+		}
+		updateFaceFlags();
+		return res;
+	}
+	
+	dirtySpatialGroup(drawable->isState(LLDrawable::IN_REBUILD_Q1));
+
+	BOOL compiled = FALSE;
+			
+	updateRelativeXform();
+	
+	if (mDrawable.isNull()) // Not sure why this is happening, but it is...
+	{
+		return TRUE; // No update to complete
+	}
+
+	if (mVolumeChanged || mFaceMappingChanged )
+	{
+		compiled = TRUE;
+
+		if (mVolumeChanged)
+		{
+			LLFastTimer ftm(FTM_GEN_VOLUME);
+			LLVolumeParams volume_params = getVolume()->getParams();
+			setVolume(volume_params, 0);
+			drawable->setState(LLDrawable::REBUILD_VOLUME);
+		}
+
+		{
+			LLFastTimer t(FTM_GEN_TRIANGLES);
+			regenFaces();
+			genBBoxes(FALSE);
+		}
+	}
+	else if ((mLODChanged) || (mSculptChanged))
+	{
+		LLVolume *old_volumep, *new_volumep;
+		F32 old_lod, new_lod;
+		S32 old_num_faces, new_num_faces ;
+
+		old_volumep = getVolume();
+		old_lod = old_volumep->getDetail();
+		old_num_faces = old_volumep->getNumFaces() ;
+		old_volumep = NULL ;
+
+		{
+			LLFastTimer ftm(FTM_GEN_VOLUME);
+			LLVolumeParams volume_params = getVolume()->getParams();
+			setVolume(volume_params, 0);
+		}
+
+		new_volumep = getVolume();
+		new_lod = new_volumep->getDetail();
+		new_num_faces = new_volumep->getNumFaces() ;
+		new_volumep = NULL ;
+
+		if ((new_lod != old_lod) || mSculptChanged)
+		{
+			compiled = TRUE;
+			sNumLODChanges += new_num_faces ;
+	
+			drawable->setState(LLDrawable::REBUILD_VOLUME); // for face->genVolumeTriangles()
+
+			{
+				LLFastTimer t(FTM_GEN_TRIANGLES);
+				if (new_num_faces != old_num_faces)
+				{
+					regenFaces();
+				}
+				genBBoxes(FALSE);
+
+				if (mSculptChanged)
+				{ //changes in sculpt maps can thrash an object bounding box without 
+				  //triggering a spatial group bounding box update -- force spatial group
+				  //to update bounding boxes
+					LLSpatialGroup* group = mDrawable->getSpatialGroup();
+					if (group)
+					{
+						group->unbound();
+					}
+				}
+			}
+		}
+	}
+	// it has its own drawable (it's moved) or it has changed UVs or it has changed xforms from global<->local
+	else
+	{
+		compiled = TRUE;
+		// All it did was move or we changed the texture coordinate offset
+		LLFastTimer t(FTM_GEN_TRIANGLES);
+		genBBoxes(FALSE);
+	}
+
+	// Update face flags
+	updateFaceFlags();
+	
+	if(compiled)
+	{
+		LLPipeline::sCompiles++;
+	}
+		
+	mVolumeChanged = FALSE;
+	mLODChanged = FALSE;
+	mSculptChanged = FALSE;
+	mFaceMappingChanged = FALSE;
+	
+	return LLViewerObject::updateGeometry(drawable);
+}
+
+void LLVOVolume::updateFaceSize(S32 idx)
+{
+	LLFace* facep = mDrawable->getFace(idx);
+	if (idx >= getVolume()->getNumVolumeFaces())
+	{
+		facep->setSize(0,0, true);
+	}
+	else
+	{
+		const LLVolumeFace& vol_face = getVolume()->getVolumeFace(idx);
+		facep->setSize(vol_face.mNumVertices, vol_face.mNumIndices, 
+						true); // <--- volume faces should be padded for 16-byte alignment
+		
+	}
+}
+
+BOOL LLVOVolume::isRootEdit() const
+{
+	if (mParent && !((LLViewerObject*)mParent)->isAvatar())
+	{
+		return FALSE;
+	}
+	return TRUE;
+}
+
+//virtual
+void LLVOVolume::setNumTEs(const U8 num_tes)
+{
+	const U8 old_num_tes = getNumTEs() ;
+	
+	if(old_num_tes && old_num_tes < num_tes) //new faces added
+	{
+		LLViewerObject::setNumTEs(num_tes) ;
+
+		if(mMediaImplList.size() >= old_num_tes && mMediaImplList[old_num_tes -1].notNull())//duplicate the last media textures if exists.
+		{
+			mMediaImplList.resize(num_tes) ;
+			const LLTextureEntry* te = getTE(old_num_tes - 1) ;
+			for(U8 i = old_num_tes; i < num_tes ; i++)
+			{
+				setTE(i, *te) ;
+				mMediaImplList[i] = mMediaImplList[old_num_tes -1] ;
+			}
+			mMediaImplList[old_num_tes -1]->setUpdated(TRUE) ;
+		}
+	}
+	else if(old_num_tes > num_tes && mMediaImplList.size() > num_tes) //old faces removed
+	{
+		U8 end = mMediaImplList.size() ;
+		for(U8 i = num_tes; i < end ; i++)
+		{
+			removeMediaImpl(i) ;				
+		}
+		mMediaImplList.resize(num_tes) ;
+
+		LLViewerObject::setNumTEs(num_tes) ;
+	}
+	else
+	{
+		LLViewerObject::setNumTEs(num_tes) ;
+	}
+
+	return ;
+}
+
+void LLVOVolume::setTEImage(const U8 te, LLViewerTexture *imagep)
+{
+	BOOL changed = (mTEImages[te] != imagep);
+	LLViewerObject::setTEImage(te, imagep);
+	if (changed)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+}
+
+S32 LLVOVolume::setTETexture(const U8 te, const LLUUID &uuid)
+{
+	S32 res = LLViewerObject::setTETexture(te, uuid);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return res;
+}
+
+S32 LLVOVolume::setTEColor(const U8 te, const LLColor3& color)
+{
+	return setTEColor(te, LLColor4(color));
+}
+
+S32 LLVOVolume::setTEColor(const U8 te, const LLColor4& color)
+{
+	S32 retval = 0;
+	const LLTextureEntry *tep = getTE(te);
+	if (!tep)
+	{
+		llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
+	}
+	else if (color != tep->getColor())
+	{
+		if (color.mV[3] != tep->getColor().mV[3])
+		{
+			gPipeline.markTextured(mDrawable);
+		}
+		retval = LLPrimitive::setTEColor(te, color);
+		if (mDrawable.notNull() && retval)
+		{
+			// These should only happen on updates which are not the initial update.
+			mDrawable->setState(LLDrawable::REBUILD_COLOR);
+			dirtyMesh();
+		}
+	}
+
+	return  retval;
+}
+
+S32 LLVOVolume::setTEBumpmap(const U8 te, const U8 bumpmap)
+{
+	S32 res = LLViewerObject::setTEBumpmap(te, bumpmap);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return  res;
+}
+
+S32 LLVOVolume::setTETexGen(const U8 te, const U8 texgen)
+{
+	S32 res = LLViewerObject::setTETexGen(te, texgen);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return  res;
+}
+
+S32 LLVOVolume::setTEMediaTexGen(const U8 te, const U8 media)
+{
+	S32 res = LLViewerObject::setTEMediaTexGen(te, media);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return  res;
+}
+
+S32 LLVOVolume::setTEShiny(const U8 te, const U8 shiny)
+{
+	S32 res = LLViewerObject::setTEShiny(te, shiny);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return  res;
+}
+
+S32 LLVOVolume::setTEFullbright(const U8 te, const U8 fullbright)
+{
+	S32 res = LLViewerObject::setTEFullbright(te, fullbright);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return  res;
+}
+
+S32 LLVOVolume::setTEBumpShinyFullbright(const U8 te, const U8 bump)
+{
+	S32 res = LLViewerObject::setTEBumpShinyFullbright(te, bump);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return res;
+}
+
+S32 LLVOVolume::setTEMediaFlags(const U8 te, const U8 media_flags)
+{
+	S32 res = LLViewerObject::setTEMediaFlags(te, media_flags);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return  res;
+}
+
+S32 LLVOVolume::setTEGlow(const U8 te, const F32 glow)
+{
+	S32 res = LLViewerObject::setTEGlow(te, glow);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return  res;
+}
+
+S32 LLVOVolume::setTEScale(const U8 te, const F32 s, const F32 t)
+{
+	S32 res = LLViewerObject::setTEScale(te, s, t);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return res;
+}
+
+S32 LLVOVolume::setTEScaleS(const U8 te, const F32 s)
+{
+	S32 res = LLViewerObject::setTEScaleS(te, s);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return res;
+}
+
+S32 LLVOVolume::setTEScaleT(const U8 te, const F32 t)
+{
+	S32 res = LLViewerObject::setTEScaleT(te, t);
+	if (res)
+	{
+		gPipeline.markTextured(mDrawable);
+		mFaceMappingChanged = TRUE;
+	}
+	return res;
+}
+
+void LLVOVolume::updateTEData()
+{
+	/*if (mDrawable.notNull())
+	{
+		mFaceMappingChanged = TRUE;
+		gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_MATERIAL, TRUE);
+	}*/
+}
+
+bool LLVOVolume::hasMedia() const
+{
+	bool result = false;
+	const U8 numTEs = getNumTEs();
+	for (U8 i = 0; i < numTEs; i++)
+	{
+		const LLTextureEntry* te = getTE(i);
+		if(te->hasMedia())
+		{
+			result = true;
+			break;
+		}
+	}
+	return result;
+}
+
+LLVector3 LLVOVolume::getApproximateFaceNormal(U8 face_id)
+{
+	LLVolume* volume = getVolume();
+	LLVector4a result;
+	result.clear();
+
+	LLVector3 ret;
+
+	if (volume && face_id < volume->getNumVolumeFaces())
+	{
+		const LLVolumeFace& face = volume->getVolumeFace(face_id);
+		for (S32 i = 0; i < (S32)face.mNumVertices; ++i)
+		{
+			result.add(face.mNormals[i]);
+		}
+
+		LLVector3 ret(result.getF32ptr());
+		ret = volumeDirectionToAgent(ret);
+		ret.normVec();
+	}
+	
+	return ret;
+}
+
+void LLVOVolume::requestMediaDataUpdate(bool isNew)
+{
+    if (sObjectMediaClient)
+		sObjectMediaClient->fetchMedia(new LLMediaDataClientObjectImpl(this, isNew));
+}
+
+bool LLVOVolume::isMediaDataBeingFetched() const
+{
+	// I know what I'm doing by const_casting this away: this is just 
+	// a wrapper class that is only going to do a lookup.
+	return (sObjectMediaClient) ? sObjectMediaClient->isInQueue(new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false)) : false;
+}
+
+void LLVOVolume::cleanUpMediaImpls()
+{
+	// Iterate through our TEs and remove any Impls that are no longer used
+	const U8 numTEs = getNumTEs();
+	for (U8 i = 0; i < numTEs; i++)
+	{
+		const LLTextureEntry* te = getTE(i);
+		if( ! te->hasMedia())
+		{
+			// Delete the media IMPL!
+			removeMediaImpl(i) ;
+		}
+	}
+}
+
+void LLVOVolume::updateObjectMediaData(const LLSD &media_data_array, const std::string &media_version)
+{
+	// media_data_array is an array of media entry maps
+	// media_version is the version string in the response.
+	U32 fetched_version = LLTextureEntry::getVersionFromMediaVersionString(media_version);
+
+	// Only update it if it is newer!
+	if ( (S32)fetched_version > mLastFetchedMediaVersion)
+	{
+		mLastFetchedMediaVersion = fetched_version;
+		//llinfos << "updating:" << this->getID() << " " << ll_pretty_print_sd(media_data_array) << llendl;
+		
+		LLSD::array_const_iterator iter = media_data_array.beginArray();
+		LLSD::array_const_iterator end = media_data_array.endArray();
+		U8 texture_index = 0;
+		for (; iter != end; ++iter, ++texture_index)
+		{
+			syncMediaData(texture_index, *iter, false/*merge*/, false/*ignore_agent*/);
+		}
+	}
+}
+
+void LLVOVolume::syncMediaData(S32 texture_index, const LLSD &media_data, bool merge, bool ignore_agent)
+{
+	if(mDead)
+	{
+		// If the object has been marked dead, don't process media updates.
+		return;
+	}
+	
+	LLTextureEntry *te = getTE(texture_index);
+	if(!te)
+	{
+		return ;
+	}
+
+	LL_DEBUGS("MediaOnAPrim") << "BEFORE: texture_index = " << texture_index
+		<< " hasMedia = " << te->hasMedia() << " : " 
+		<< ((NULL == te->getMediaData()) ? "NULL MEDIA DATA" : ll_pretty_print_sd(te->getMediaData()->asLLSD())) << llendl;
+
+	std::string previous_url;
+	LLMediaEntry* mep = te->getMediaData();
+	if(mep)
+	{
+		// Save the "current url" from before the update so we can tell if
+		// it changes. 
+		previous_url = mep->getCurrentURL();
+	}
+
+	if (merge)
+	{
+		te->mergeIntoMediaData(media_data);
+	}
+	else {
+		// XXX Question: what if the media data is undefined LLSD, but the
+		// update we got above said that we have media flags??	Here we clobber
+		// that, assuming the data from the service is more up-to-date. 
+		te->updateMediaData(media_data);
+	}
+
+	mep = te->getMediaData();
+	if(mep)
+	{
+		bool update_from_self = false;
+		if (!ignore_agent) 
+		{
+			LLUUID updating_agent = LLTextureEntry::getAgentIDFromMediaVersionString(getMediaURL());
+			update_from_self = (updating_agent == gAgent.getID());
+		}
+		viewer_media_t media_impl = LLViewerMedia::updateMediaImpl(mep, previous_url, update_from_self);
+			
+		addMediaImpl(media_impl, texture_index) ;
+	}
+	else
+	{
+		removeMediaImpl(texture_index);
+	}
+
+	LL_DEBUGS("MediaOnAPrim") << "AFTER: texture_index = " << texture_index
+		<< " hasMedia = " << te->hasMedia() << " : " 
+		<< ((NULL == te->getMediaData()) ? "NULL MEDIA DATA" : ll_pretty_print_sd(te->getMediaData()->asLLSD())) << llendl;
+}
+
+void LLVOVolume::mediaNavigateBounceBack(U8 texture_index)
+{
+	// Find the media entry for this navigate
+	const LLMediaEntry* mep = NULL;
+	viewer_media_t impl = getMediaImpl(texture_index);
+	LLTextureEntry *te = getTE(texture_index);
+	if(te)
+	{
+		mep = te->getMediaData();
+	}
+	
+	if (mep && impl)
+	{
+        std::string url = mep->getCurrentURL();
+		// Look for a ":", if not there, assume "http://"
+		if (!url.empty() && std::string::npos == url.find(':')) 
+		{
+			url = "http://" + url;
+		}
+		// If the url we're trying to "bounce back" to is either empty or not
+		// allowed by the whitelist, try the home url.  If *that* doesn't work,
+		// set the media as failed and unload it
+        if (url.empty() || !mep->checkCandidateUrl(url))
+        {
+            url = mep->getHomeURL();
+			// Look for a ":", if not there, assume "http://"
+			if (!url.empty() && std::string::npos == url.find(':')) 
+			{
+				url = "http://" + url;
+			}
+        }
+        if (url.empty() || !mep->checkCandidateUrl(url))
+		{
+			// The url to navigate back to is not good, and we have nowhere else
+			// to go.
+			LL_WARNS("MediaOnAPrim") << "FAILED to bounce back URL \"" << url << "\" -- unloading impl" << LL_ENDL;
+			impl->setMediaFailed(true);
+		}
+		else {
+			// Okay, navigate now
+            LL_INFOS("MediaOnAPrim") << "bouncing back to URL: " << url << LL_ENDL;
+            impl->navigateTo(url, "", false, true);
+        }
+    }
+}
+
+bool LLVOVolume::hasMediaPermission(const LLMediaEntry* media_entry, MediaPermType perm_type)
+{
+    // NOTE: This logic ALMOST duplicates the logic in the server (in particular, in llmediaservice.cpp).
+    if (NULL == media_entry ) return false; // XXX should we assert here?
+    
+    // The agent has permissions if:
+    // - world permissions are on, or
+    // - group permissions are on, and agent_id is in the group, or
+    // - agent permissions are on, and agent_id is the owner
+    
+	// *NOTE: We *used* to check for modify permissions here (i.e. permissions were
+	// granted if permModify() was true).  However, this doesn't make sense in the
+	// viewer: we don't want to show controls or allow interaction if the author
+	// has deemed it so.  See DEV-42115.
+	
+    U8 media_perms = (perm_type == MEDIA_PERM_INTERACT) ? media_entry->getPermsInteract() : media_entry->getPermsControl();
+    
+    // World permissions
+    if (0 != (media_perms & LLMediaEntry::PERM_ANYONE)) 
+    {
+        return true;
+    }
+    
+    // Group permissions
+    else if (0 != (media_perms & LLMediaEntry::PERM_GROUP))
+    {
+		LLPermissions* obj_perm = LLSelectMgr::getInstance()->findObjectPermissions(this);
+		if (obj_perm && gAgent.isInGroup(obj_perm->getGroup()))
+		{
+			return true;
+		}
+    }
+    
+    // Owner permissions
+    else if (0 != (media_perms & LLMediaEntry::PERM_OWNER) && permYouOwner()) 
+    {
+        return true;
+    }
+    
+    return false;
+    
+}
+
+void LLVOVolume::mediaNavigated(LLViewerMediaImpl *impl, LLPluginClassMedia* plugin, std::string new_location)
+{
+	bool block_navigation = false;
+	// FIXME: if/when we allow the same media impl to be used by multiple faces, the logic here will need to be fixed
+	// to deal with multiple face indices.
+	int face_index = getFaceIndexWithMediaImpl(impl, -1);
+	
+	// Find the media entry for this navigate
+	LLMediaEntry* mep = NULL;
+	LLTextureEntry *te = getTE(face_index);
+	if(te)
+	{
+		mep = te->getMediaData();
+	}
+	
+	if(mep)
+	{
+		if(!mep->checkCandidateUrl(new_location))
+		{
+			block_navigation = true;
+		}
+		if (!block_navigation && !hasMediaPermission(mep, MEDIA_PERM_INTERACT))
+		{
+			block_navigation = true;
+		}
+	}
+	else
+	{
+		LL_WARNS("MediaOnAPrim") << "Couldn't find media entry!" << LL_ENDL;
+	}
+						
+	if(block_navigation)
+	{
+		LL_INFOS("MediaOnAPrim") << "blocking navigate to URI " << new_location << LL_ENDL;
+
+		// "bounce back" to the current URL from the media entry
+		mediaNavigateBounceBack(face_index);
+	}
+	else if (sObjectMediaNavigateClient)
+	{
+		
+		LL_DEBUGS("MediaOnAPrim") << "broadcasting navigate with URI " << new_location << LL_ENDL;
+
+		sObjectMediaNavigateClient->navigate(new LLMediaDataClientObjectImpl(this, false), face_index, new_location);
+	}
+}
+
+void LLVOVolume::mediaEvent(LLViewerMediaImpl *impl, LLPluginClassMedia* plugin, LLViewerMediaObserver::EMediaEvent event)
+{
+	switch(event)
+	{
+		
+		case LLViewerMediaObserver::MEDIA_EVENT_LOCATION_CHANGED:
+		{			
+			switch(impl->getNavState())
+			{
+				case LLViewerMediaImpl::MEDIANAVSTATE_FIRST_LOCATION_CHANGED:
+				{
+					// This is the first location changed event after the start of a non-server-directed nav.  It may need to be broadcast or bounced back.
+					mediaNavigated(impl, plugin, plugin->getLocation());
+				}
+				break;
+				
+				case LLViewerMediaImpl::MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS:
+					// This navigate didn't change the current URL.  
+					LL_DEBUGS("MediaOnAPrim") << "	NOT broadcasting navigate (spurious)" << LL_ENDL;
+				break;
+				
+				case LLViewerMediaImpl::MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED:
+					// This is the first location changed event after the start of a server-directed nav.  Don't broadcast it.
+					LL_INFOS("MediaOnAPrim") << "	NOT broadcasting navigate (server-directed)" << LL_ENDL;
+				break;
+				
+				default:
+					// This is a subsequent location-changed due to a redirect.	 Don't broadcast.
+					LL_INFOS("MediaOnAPrim") << "	NOT broadcasting navigate (redirect)" << LL_ENDL;
+				break;
+			}
+		}
+		break;
+		
+		case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_COMPLETE:
+		{
+			switch(impl->getNavState())
+			{
+				case LLViewerMediaImpl::MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED:
+				{
+					// This is the first location changed event after the start of a non-server-directed nav.  It may need to be broadcast or bounced back.
+					mediaNavigated(impl, plugin, plugin->getNavigateURI());
+				}
+				break;
+				
+				case LLViewerMediaImpl::MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS:
+					// This navigate didn't change the current URL.  
+					LL_DEBUGS("MediaOnAPrim") << "	NOT broadcasting navigate (spurious)" << LL_ENDL;
+				break;
+
+				case LLViewerMediaImpl::MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED:
+					// This is the the navigate complete event from a server-directed nav.  Don't broadcast it.
+					LL_INFOS("MediaOnAPrim") << "	NOT broadcasting navigate (server-directed)" << LL_ENDL;
+				break;
+				
+				default:
+					// For all other states, the navigate should have been handled by LOCATION_CHANGED events already.
+				break;
+			}
+		}
+		break;
+		
+		default:
+		break;
+	}
+
+}
+
+void LLVOVolume::sendMediaDataUpdate()
+{
+    if (sObjectMediaClient)
+		sObjectMediaClient->updateMedia(new LLMediaDataClientObjectImpl(this, false));
+}
+
+void LLVOVolume::removeMediaImpl(S32 texture_index)
+{
+	if(mMediaImplList.size() <= (U32)texture_index || mMediaImplList[texture_index].isNull())
+	{
+		return ;
+	}
+
+	//make the face referencing to mMediaImplList[texture_index] to point back to the old texture.
+	if(mDrawable && texture_index < mDrawable->getNumFaces())
+	{
+		LLFace* facep = mDrawable->getFace(texture_index) ;
+		if(facep)
+		{
+			LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[texture_index]->getMediaTextureID()) ;
+			if(media_tex)
+			{
+				media_tex->removeMediaFromFace(facep) ;
+			}
+		}
+	}		
+	
+	//check if some other face(s) of this object reference(s)to this media impl.
+	S32 i ;
+	S32 end = (S32)mMediaImplList.size() ;
+	for(i = 0; i < end ; i++)
+	{
+		if( i != texture_index && mMediaImplList[i] == mMediaImplList[texture_index])
+		{
+			break ;
+		}
+	}
+
+	if(i == end) //this object does not need this media impl.
+	{
+		mMediaImplList[texture_index]->removeObject(this) ;
+	}
+
+	mMediaImplList[texture_index] = NULL ;
+	return ;
+}
+
+void LLVOVolume::addMediaImpl(LLViewerMediaImpl* media_impl, S32 texture_index)
+{
+	if((S32)mMediaImplList.size() < texture_index + 1)
+	{
+		mMediaImplList.resize(texture_index + 1) ;
+	}
+	
+	if(mMediaImplList[texture_index].notNull())
+	{
+		if(mMediaImplList[texture_index] == media_impl)
+		{
+			return ;
+		}
+
+		removeMediaImpl(texture_index) ;
+	}
+
+	mMediaImplList[texture_index] = media_impl;
+	media_impl->addObject(this) ;	
+
+	//add the face to show the media if it is in playing
+	if(mDrawable)
+	{
+		LLFace* facep = mDrawable->getFace(texture_index) ;
+		if(facep)
+		{
+			LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[texture_index]->getMediaTextureID()) ;
+			if(media_tex)
+			{
+				media_tex->addMediaToFace(facep) ;
+			}
+		}
+		else //the face is not available now, start media on this face later.
+		{
+			media_impl->setUpdated(TRUE) ;
+		}
+	}
+	return ;
+}
+
+viewer_media_t LLVOVolume::getMediaImpl(U8 face_id) const
+{
+	if(mMediaImplList.size() > face_id)
+	{
+		return mMediaImplList[face_id];
+	}
+	return NULL;
+}
+
+F64 LLVOVolume::getTotalMediaInterest() const
+{
+	// If this object is currently focused, this object has "high" interest
+	if (LLViewerMediaFocus::getInstance()->getFocusedObjectID() == getID())
+		return F64_MAX;
+	
+	F64 interest = (F64)-1.0;  // means not interested;
+    
+	// If this object is selected, this object has "high" interest, but since 
+	// there can be more than one, we still add in calculated impl interest
+	// XXX Sadly, 'contains()' doesn't take a const :(
+	if (LLSelectMgr::getInstance()->getSelection()->contains(const_cast<LLVOVolume*>(this)))
+		interest = F64_MAX / 2.0;
+	
+	int i = 0;
+	const int end = getNumTEs();
+	for ( ; i < end; ++i)
+	{
+		const viewer_media_t &impl = getMediaImpl(i);
+		if (!impl.isNull())
+		{
+			if (interest == (F64)-1.0) interest = (F64)0.0;
+			interest += impl->getInterest();
+		}
+	}
+	return interest;
+}
+
+S32 LLVOVolume::getFaceIndexWithMediaImpl(const LLViewerMediaImpl* media_impl, S32 start_face_id)
+{
+	S32 end = (S32)mMediaImplList.size() ;
+	for(S32 face_id = start_face_id + 1; face_id < end; face_id++)
+	{
+		if(mMediaImplList[face_id] == media_impl)
+		{
+			return face_id ;
+		}
+	}
+	return -1 ;
+}
+
+//----------------------------------------------------------------------------
+
+void LLVOVolume::setLightTextureID(LLUUID id)
+{
+	if (id.notNull())
+	{
+		if (!hasLightTexture())
+		{
+			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, TRUE, true);
+		}
+		LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+		if (param_block && param_block->getLightTexture() != id)
+		{
+			param_block->setLightTexture(id);
+			parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
+		}
+	}
+	else
+	{
+		if (hasLightTexture())
+		{
+			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, FALSE, true);
+			mLightTexture = NULL;
+		}
+	}		
+}
+
+void LLVOVolume::setSpotLightParams(LLVector3 params)
+{
+	LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+	if (param_block && param_block->getParams() != params)
+	{
+		param_block->setParams(params);
+		parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
+	}
+}
+		
+void LLVOVolume::setIsLight(BOOL is_light)
+{
+	if (is_light != getIsLight())
+	{
+		if (is_light)
+		{
+			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT, TRUE, true);
+		}
+		else
+		{
+			setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT, FALSE, true);
+		}
+
+		if (is_light)
+		{
+			// Add it to the pipeline mLightSet
+			gPipeline.setLight(mDrawable, TRUE);
+		}
+		else
+		{
+			// Not a light.  Remove it from the pipeline's light set.
+			gPipeline.setLight(mDrawable, FALSE);
+		}
+	}
+}
+
+void LLVOVolume::setLightColor(const LLColor3& color)
+{
+	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		if (param_block->getColor() != color)
+		{
+			param_block->setColor(LLColor4(color, param_block->getColor().mV[3]));
+			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
+			gPipeline.markTextured(mDrawable);
+			mFaceMappingChanged = TRUE;
+		}
+	}
+}
+
+void LLVOVolume::setLightIntensity(F32 intensity)
+{
+	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		if (param_block->getColor().mV[3] != intensity)
+		{
+			param_block->setColor(LLColor4(LLColor3(param_block->getColor()), intensity));
+			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
+		}
+	}
+}
+
+void LLVOVolume::setLightRadius(F32 radius)
+{
+	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		if (param_block->getRadius() != radius)
+		{
+			param_block->setRadius(radius);
+			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
+		}
+	}
+}
+
+void LLVOVolume::setLightFalloff(F32 falloff)
+{
+	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		if (param_block->getFalloff() != falloff)
+		{
+			param_block->setFalloff(falloff);
+			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
+		}
+	}
+}
+
+void LLVOVolume::setLightCutoff(F32 cutoff)
+{
+	LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		if (param_block->getCutoff() != cutoff)
+		{
+			param_block->setCutoff(cutoff);
+			parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
+		}
+	}
+}
+
+//----------------------------------------------------------------------------
+
+BOOL LLVOVolume::getIsLight() const
+{
+	return getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT);
+}
+
+LLColor3 LLVOVolume::getLightBaseColor() const
+{
+	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		return LLColor3(param_block->getColor());
+	}
+	else
+	{
+		return LLColor3(1,1,1);
+	}
+}
+
+LLColor3 LLVOVolume::getLightColor() const
+{
+	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		return LLColor3(param_block->getColor()) * param_block->getColor().mV[3];
+	}
+	else
+	{
+		return LLColor3(1,1,1);
+	}
+}
+
+LLUUID LLVOVolume::getLightTextureID() const
+{
+	if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
+	{
+		const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+		if (param_block)
+		{
+			return param_block->getLightTexture();
+		}
+	}
+	
+	return LLUUID::null;
+}
+
+
+LLVector3 LLVOVolume::getSpotLightParams() const
+{
+	if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
+	{
+		const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+		if (param_block)
+		{
+			return param_block->getParams();
+		}
+	}
+	
+	return LLVector3();
+}
+
+F32 LLVOVolume::getSpotLightPriority() const
+{
+	return mSpotLightPriority;
+}
+
+void LLVOVolume::updateSpotLightPriority()
+{
+	LLVector3 pos = mDrawable->getPositionAgent();
+	LLVector3 at(0,0,-1);
+	at *= getRenderRotation();
+
+	F32 r = getLightRadius()*0.5f;
+
+	pos += at * r;
+
+	at = LLViewerCamera::getInstance()->getAtAxis();
+
+	pos -= at * r;
+	
+	mSpotLightPriority = gPipeline.calcPixelArea(pos, LLVector3(r,r,r), *LLViewerCamera::getInstance());
+
+	if (mLightTexture.notNull())
+	{
+		mLightTexture->addTextureStats(mSpotLightPriority);
+		mLightTexture->setBoostLevel(LLViewerTexture::BOOST_CLOUDS);
+	}
+}
+
+
+bool LLVOVolume::isLightSpotlight() const
+{
+	LLLightImageParams* params = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+	if (params)
+	{
+		return params->isLightSpotlight();
+	}
+	return false;
+}
+
+
+LLViewerTexture* LLVOVolume::getLightTexture()
+{
+	LLUUID id = getLightTextureID();
+
+	if (id.notNull())
+	{
+		if (mLightTexture.isNull() || id != mLightTexture->getID())
+		{
+			mLightTexture = LLViewerTextureManager::getFetchedTexture(id);
+		}
+	}
+	else
+	{
+		mLightTexture = NULL;
+	}
+
+	return mLightTexture;
+}
+
+F32 LLVOVolume::getLightIntensity() const
+{
+	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		return param_block->getColor().mV[3];
+	}
+	else
+	{
+		return 1.f;
+	}
+}
+
+F32 LLVOVolume::getLightRadius() const
+{
+	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		return param_block->getRadius();
+	}
+	else
+	{
+		return 0.f;
+	}
+}
+
+F32 LLVOVolume::getLightFalloff() const
+{
+	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		return param_block->getFalloff();
+	}
+	else
+	{
+		return 0.f;
+	}
+}
+
+F32 LLVOVolume::getLightCutoff() const
+{
+	const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
+	if (param_block)
+	{
+		return param_block->getCutoff();
+	}
+	else
+	{
+		return 0.f;
+	}
+}
+
+U32 LLVOVolume::getVolumeInterfaceID() const
+{
+	if (mVolumeImpl)
+	{
+		return mVolumeImpl->getID();
+	}
+
+	return 0;
+}
+
+BOOL LLVOVolume::isFlexible() const
+{
+	if (getParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE))
+	{
+		LLVolume* volume = getVolume();
+		if (volume && volume->getParams().getPathParams().getCurveType() != LL_PCODE_PATH_FLEXIBLE)
+		{
+			LLVolumeParams volume_params = getVolume()->getParams();
+			U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
+			volume_params.setType(profile_and_hole, LL_PCODE_PATH_FLEXIBLE);
+		}
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+BOOL LLVOVolume::isSculpted() const
+{
+	if (getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
+	{
+		return TRUE;
+	}
+	
+	return FALSE;
+}
+
+BOOL LLVOVolume::isMesh() const
+{
+	if (isSculpted())
+	{
+		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
+		U8 sculpt_type = sculpt_params->getSculptType();
+
+		if ((sculpt_type & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)
+			// mesh is a mesh
+		{
+			return TRUE;	
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL LLVOVolume::hasLightTexture() const
+{
+	if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
+	{
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL LLVOVolume::isVolumeGlobal() const
+{
+	if (mVolumeImpl)
+	{
+		return mVolumeImpl->isVolumeGlobal() ? TRUE : FALSE;
+	}
+	else if (mRiggedVolume.notNull())
+	{
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL LLVOVolume::canBeFlexible() const
+{
+	U8 path = getVolume()->getParams().getPathParams().getCurveType();
+	return (path == LL_PCODE_PATH_FLEXIBLE || path == LL_PCODE_PATH_LINE);
+}
+
+BOOL LLVOVolume::setIsFlexible(BOOL is_flexible)
+{
+	BOOL res = FALSE;
+	BOOL was_flexible = isFlexible();
+	LLVolumeParams volume_params;
+	if (is_flexible)
+	{
+		if (!was_flexible)
+		{
+			volume_params = getVolume()->getParams();
+			U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
+			volume_params.setType(profile_and_hole, LL_PCODE_PATH_FLEXIBLE);
+			res = TRUE;
+			setFlags(FLAGS_USE_PHYSICS, FALSE);
+			setFlags(FLAGS_PHANTOM, TRUE);
+			setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, TRUE, true);
+			if (mDrawable)
+			{
+				mDrawable->makeActive();
+			}
+		}
+	}
+	else
+	{
+		if (was_flexible)
+		{
+			volume_params = getVolume()->getParams();
+			U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
+			volume_params.setType(profile_and_hole, LL_PCODE_PATH_LINE);
+			res = TRUE;
+			setFlags(FLAGS_PHANTOM, FALSE);
+			setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, FALSE, true);
+		}
+	}
+	if (res)
+	{
+		res = setVolume(volume_params, 1);
+		if (res)
+		{
+			markForUpdate(TRUE);
+		}
+	}
+	return res;
+}
+
+//----------------------------------------------------------------------------
+
+void LLVOVolume::generateSilhouette(LLSelectNode* nodep, const LLVector3& view_point)
+{
+	LLVolume *volume = getVolume();
+
+	if (volume)
+	{
+		LLVector3 view_vector;
+		view_vector = view_point; 
+
+		//transform view vector into volume space
+		view_vector -= getRenderPosition();
+		mDrawable->mDistanceWRTCamera = view_vector.length();
+		LLQuaternion worldRot = getRenderRotation();
+		view_vector = view_vector * ~worldRot;
+		if (!isVolumeGlobal())
+		{
+			LLVector3 objScale = getScale();
+			LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
+			view_vector.scaleVec(invObjScale);
+		}
+		
+		updateRelativeXform();
+		LLMatrix4 trans_mat = mRelativeXform;
+		if (mDrawable->isStatic())
+		{
+			trans_mat.translate(getRegion()->getOriginAgent());
+		}
+
+		volume->generateSilhouetteVertices(nodep->mSilhouetteVertices, nodep->mSilhouetteNormals, view_vector, trans_mat, mRelativeXformInvTrans, nodep->getTESelectMask());
+
+		nodep->mSilhouetteExists = TRUE;
+	}
+}
+
+void LLVOVolume::deleteFaces()
+{
+	S32 face_count = mNumFaces;
+	if (mDrawable.notNull())
+	{
+		mDrawable->deleteFaces(0, face_count);
+	}
+
+	mNumFaces = 0;
+}
+
+void LLVOVolume::updateRadius()
+{
+	if (mDrawable.isNull())
+	{
+		return;
+	}
+	
+	mVObjRadius = getScale().length();
+	mDrawable->setRadius(mVObjRadius);
+}
+
+
+BOOL LLVOVolume::isAttachment() const
+{
+	return mState != 0 ;
+}
+
+BOOL LLVOVolume::isHUDAttachment() const
+{
+	// *NOTE: we assume hud attachment points are in defined range
+	// since this range is constant for backwards compatibility
+	// reasons this is probably a reasonable assumption to make
+	S32 attachment_id = ATTACHMENT_ID_FROM_STATE(mState);
+	return ( attachment_id >= 31 && attachment_id <= 38 );
+}
+
+
+const LLMatrix4 LLVOVolume::getRenderMatrix() const
+{
+	if (mDrawable->isActive() && !mDrawable->isRoot())
+	{
+		return mDrawable->getParent()->getWorldMatrix();
+	}
+	return mDrawable->getWorldMatrix();
+}
+
+// Returns a base cost and adds textures to passed in set.
+// total cost is returned value + 5 * size of the resulting set.
+// Cannot include cost of textures, as they may be re-used in linked
+// children, and cost should only be increased for unique textures  -Nyx
+U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
+{
+	// Get access to params we'll need at various points.  
+	// Skip if this is object doesn't have a volume (e.g. is an avatar).
+	BOOL has_volume = (getVolume() != NULL);
+	LLVolumeParams volume_params;
+	LLPathParams path_params;
+	LLProfileParams profile_params;
+
+	U32 num_triangles = 0;
+
+	// per-prim costs
+	static const U32 ARC_PARTICLE_COST = 1; // determined experimentally
+	static const U32 ARC_PARTICLE_MAX = 2048; // default values
+	static const U32 ARC_TEXTURE_COST = 16; // multiplier for texture resolution - performance tested
+	static const U32 ARC_LIGHT_COST = 500; // static cost for light-producing prims 
+	static const U32 ARC_MEDIA_FACE_COST = 1500; // static cost per media-enabled face 
+
+
+	// per-prim multipliers
+	static const F32 ARC_GLOW_MULT = 1.5f; // tested based on performance
+	static const F32 ARC_BUMP_MULT = 1.25f; // tested based on performance
+	static const F32 ARC_FLEXI_MULT = 5; // tested based on performance
+	static const F32 ARC_SHINY_MULT = 1.6f; // tested based on performance
+	static const F32 ARC_INVISI_COST = 1.2f; // tested based on performance
+	static const F32 ARC_WEIGHTED_MESH = 1.2f; // tested based on performance
+
+	static const F32 ARC_PLANAR_COST = 1.0f; // tested based on performance to have negligible impact
+	static const F32 ARC_ANIM_TEX_COST = 4.f; // tested based on performance
+	static const F32 ARC_ALPHA_COST = 4.f; // 4x max - based on performance
+
+	F32 shame = 0;
+
+	U32 invisi = 0;
+	U32 shiny = 0;
+	U32 glow = 0;
+	U32 alpha = 0;
+	U32 flexi = 0;
+	U32 animtex = 0;
+	U32 particles = 0;
+	U32 bump = 0;
+	U32 planar = 0;
+	U32 weighted_mesh = 0;
+	U32 produces_light = 0;
+	U32 media_faces = 0;
+
+	// these multipliers are variable and can be floating point
+	F32 scale = 0.f;
+
+	const LLDrawable* drawablep = mDrawable;
+	U32 num_faces = drawablep->getNumFaces();
+
+	if (has_volume)
+	{
+		volume_params = getVolume()->getParams();
+		path_params = volume_params.getPathParams();
+		profile_params = volume_params.getProfileParams();
+
+		F32 weighted_triangles = -1.0;
+		getStreamingCost(NULL, NULL, &weighted_triangles);
+
+		if (weighted_triangles > 0.0)
+		{
+			num_triangles = (U32)(weighted_triangles * 2); // scale weighted triangles to match the recorded scale.
+															// a complex prim (tortured torus, sculptie) should be 1000-1200 points @ 5 m
+		}
+	}
+
+	if (num_triangles == 0)
+	{
+		num_triangles = 4;
+	}
+
+	if (isSculpted())
+	{
+		if (isMesh())
+		{
+			// base cost is dependent on mesh complexity
+			// note that 3 is the highest LOD as of the time of this coding.
+			S32 size = gMeshRepo.getMeshSize(volume_params.getSculptID(),3);
+			if ( size > 0)
+			{
+				if (gMeshRepo.getSkinInfo(volume_params.getSculptID(), this))
+				{
+					// weighted attachment - 1 point for every 3 bytes
+					weighted_mesh = 1;
+				}
+
+			}
+			else
+			{
+				// something went wrong - user should know their content isn't render-free
+				return 0;
+			}
+		}
+		else
+		{
+			const LLSculptParams *sculpt_params = (LLSculptParams *) getParameterEntry(LLNetworkData::PARAMS_SCULPT);
+			LLUUID sculpt_id = sculpt_params->getSculptTexture();
+			if (textures.find(sculpt_id) == textures.end())
+			{
+				LLViewerFetchedTexture *texture = LLViewerTextureManager::getFetchedTexture(sculpt_id);
+				if (texture)
+				{
+					S32 texture_cost = 256 + (S32)(ARC_TEXTURE_COST * (texture->getFullHeight() / 128.f + texture->getFullWidth() / 128.f));
+					textures.insert(texture_cost_t::value_type(sculpt_id, texture_cost));
+				}
+			}
+		}
+	}
+
+	if (isFlexible())
+	{
+		flexi = 1;
+	}
+	if (isParticleSource())
+	{
+		particles = 1;
+	}
+
+	if (getIsLight())
+	{
+		produces_light = 1;
+	}
+
+	const LLVector3& sc = getScale();
+	scale += (sc.mV[0] + sc.mV[1] + sc.mV[2]) / 4.f; // scale to 1/4 the sum of the size
+	// enforce scale multiplier to be in the range [1,7] (7 was determined to experimentally be a reasonable max)
+	scale = scale > 7.f ? 7.f : scale;
+	scale = scale < 1.f ? 1.f : scale;
+
+	for (S32 i = 0; i < num_faces; ++i)
+	{
+		const LLFace* face = drawablep->getFace(i);
+		const LLTextureEntry* te = face->getTextureEntry();
+		const LLViewerTexture* img = face->getTexture();
+
+		if (img)
+		{
+			if (textures.find(img->getID()) == textures.end())
+			{
+				S32 texture_cost = 256 + (S32)(ARC_TEXTURE_COST * (img->getFullHeight() / 128.f + img->getFullWidth() / 128.f));
+				textures.insert(texture_cost_t::value_type(img->getID(), texture_cost));
+			}
+		}
+
+		if (face->getPoolType() == LLDrawPool::POOL_ALPHA)
+		{
+			alpha = 1;
+		}
+		else if (img && img->getPrimaryFormat() == GL_ALPHA)
+		{
+			invisi = 1;
+		}
+		if (face->hasMedia())
+		{
+			media_faces++;
+		}
+
+		if (te)
+		{
+			if (te->getBumpmap())
+			{
+				// bump is a multiplier, don't add per-face
+				bump = 1;
+			}
+			if (te->getShiny())
+			{
+				// shiny is a multiplier, don't add per-face
+				shiny = 1;
+			}
+			if (te->getGlow() > 0.f)
+			{
+				// glow is a multiplier, don't add per-face
+				glow = 1;
+			}
+			if (face->mTextureMatrix != NULL)
+			{
+				animtex = 1;
+			}
+			if (te->getTexGen())
+			{
+				planar = 1;
+			}
+		}
+	}
+
+	// shame currently has the "base" cost of 1 point per 15 triangles, min 2.
+	shame = num_triangles / 15.f;
+	shame = shame < 2.f ? 2.f : shame;
+
+	// factor in scale
+	shame *= scale;
+
+	// multiply by per-face modifiers
+	if (planar)
+	{
+		shame *= planar * ARC_PLANAR_COST;
+	}
+
+	if (animtex)
+	{
+		shame *= animtex * ARC_ANIM_TEX_COST;
+	}
+
+	if (alpha)
+	{
+		shame *= alpha * ARC_ALPHA_COST;
+	}
+
+	if(invisi)
+	{
+		shame *= invisi * ARC_INVISI_COST;
+	}
+
+	if (glow)
+	{
+		shame *= glow * ARC_GLOW_MULT;
+	}
+
+	if (bump)
+	{
+		shame *= bump * ARC_BUMP_MULT;
+	}
+
+	if (shiny)
+	{
+		shame *= shiny * ARC_SHINY_MULT;
+	}
+
+
+	// multiply shame by multipliers
+	if (weighted_mesh)
+	{
+		shame *= weighted_mesh * ARC_WEIGHTED_MESH;
+	}
+
+	if (flexi)
+	{
+		shame *= flexi * ARC_FLEXI_MULT;
+	}
+
+
+	// add additional costs
+	if (particles)
+	{
+		const LLPartSysData *part_sys_data = &(mPartSourcep->mPartSysData);
+		const LLPartData *part_data = &(part_sys_data->mPartData);
+		U32 num_particles = (U32)(part_sys_data->mBurstPartCount * llceil( part_data->mMaxAge / part_sys_data->mBurstRate));
+		num_particles = num_particles > ARC_PARTICLE_MAX ? ARC_PARTICLE_MAX : num_particles;
+		F32 part_size = (llmax(part_data->mStartScale[0], part_data->mEndScale[0]) + llmax(part_data->mStartScale[1], part_data->mEndScale[1])) / 2.f;
+		shame += num_particles * part_size * ARC_PARTICLE_COST;
+	}
+
+	if (produces_light)
+	{
+		shame += ARC_LIGHT_COST;
+	}
+
+	if (media_faces)
+	{
+		shame += media_faces * ARC_MEDIA_FACE_COST;
+	}
+
+	if (shame > mRenderComplexity_current)
+	{
+		mRenderComplexity_current = (S32)shame;
+	}
+
+	return (U32)shame;
+}
+
+F32 LLVOVolume::getStreamingCost(S32* bytes, S32* visible_bytes, F32* unscaled_value) const
+{
+	F32 radius = getScale().length()*0.5f;
+
+	if (isMesh())
+	{	
+		LLSD& header = gMeshRepo.getMeshHeader(getVolume()->getParams().getSculptID());
+
+		return LLMeshRepository::getStreamingCost(header, radius, bytes, visible_bytes, mLOD, unscaled_value);
+	}
+	else
+	{
+		LLVolume* volume = getVolume();
+		S32 counts[4];
+		LLVolume::getLoDTriangleCounts(volume->getParams(), counts);
+
+		LLSD header;
+		header["lowest_lod"]["size"] = counts[0] * 10;
+		header["low_lod"]["size"] = counts[1] * 10;
+		header["medium_lod"]["size"] = counts[2] * 10;
+		header["high_lod"]["size"] = counts[3] * 10;
+
+		return LLMeshRepository::getStreamingCost(header, radius, NULL, NULL, -1, unscaled_value);
+	}	
+}
+
+//static 
+void LLVOVolume::updateRenderComplexity()
+{
+	mRenderComplexity_last = mRenderComplexity_current;
+	mRenderComplexity_current = 0;
+}
+
+U32 LLVOVolume::getTriangleCount() const
+{
+	U32 count = 0;
+	LLVolume* volume = getVolume();
+	if (volume)
+	{
+		count = volume->getNumTriangles();
+	}
+
+	return count;
+}
+
+U32 LLVOVolume::getHighLODTriangleCount()
+{
+	U32 ret = 0;
+
+	LLVolume* volume = getVolume();
+
+	if (!isSculpted())
+	{
+		LLVolume* ref = LLPrimitive::getVolumeManager()->refVolume(volume->getParams(), 3);
+		ret = ref->getNumTriangles();
+		LLPrimitive::getVolumeManager()->unrefVolume(ref);
+	}
+	else if (isMesh())
+	{
+		LLVolume* ref = LLPrimitive::getVolumeManager()->refVolume(volume->getParams(), 3);
+		if (!ref->isMeshAssetLoaded() || ref->getNumVolumeFaces() == 0)
+		{
+			gMeshRepo.loadMesh(this, volume->getParams(), LLModel::LOD_HIGH);
+		}
+		ret = ref->getNumTriangles();
+		LLPrimitive::getVolumeManager()->unrefVolume(ref);
+	}
+	else
+	{ //default sculpts have a constant number of triangles
+		ret = 31*2*31;  //31 rows of 31 columns of quads for a 32x32 vertex patch
+	}
+
+	return ret;
+}
+
+//static
+void LLVOVolume::preUpdateGeom()
+{
+	sNumLODChanges = 0;
+}
+
+void LLVOVolume::parameterChanged(U16 param_type, bool local_origin)
+{
+	LLViewerObject::parameterChanged(param_type, local_origin);
+}
+
+void LLVOVolume::parameterChanged(U16 param_type, LLNetworkData* data, BOOL in_use, bool local_origin)
+{
+	LLViewerObject::parameterChanged(param_type, data, in_use, local_origin);
+	if (mVolumeImpl)
+	{
+		mVolumeImpl->onParameterChanged(param_type, data, in_use, local_origin);
+	}
+	if (mDrawable.notNull())
+	{
+		BOOL is_light = getIsLight();
+		if (is_light != mDrawable->isState(LLDrawable::LIGHT))
+		{
+			gPipeline.setLight(mDrawable, is_light);
+		}
+	}
+}
+
+void LLVOVolume::setSelected(BOOL sel)
+{
+	LLViewerObject::setSelected(sel);
+	if (mDrawable.notNull())
+	{
+		markForUpdate(TRUE);
+	}
+}
+
+void LLVOVolume::updateSpatialExtents(LLVector4a& newMin, LLVector4a& newMax)
+{		
+}
+
+F32 LLVOVolume::getBinRadius()
+{
+	F32 radius;
+	
+	F32 scale = 1.f;
+
+	S32 size_factor = llmax(gSavedSettings.getS32("OctreeStaticObjectSizeFactor"), 1);
+	S32 attachment_size_factor = llmax(gSavedSettings.getS32("OctreeAttachmentSizeFactor"), 1);
+	LLVector3 distance_factor = gSavedSettings.getVector3("OctreeDistanceFactor");
+	LLVector3 alpha_distance_factor = gSavedSettings.getVector3("OctreeAlphaDistanceFactor");
+	const LLVector4a* ext = mDrawable->getSpatialExtents();
+	
+	BOOL shrink_wrap = mDrawable->isAnimating();
+	BOOL alpha_wrap = FALSE;
+
+	if (!isHUDAttachment())
+	{
+		for (S32 i = 0; i < mDrawable->getNumFaces(); i++)
+		{
+			LLFace* face = mDrawable->getFace(i);
+			if (face->getPoolType() == LLDrawPool::POOL_ALPHA &&
+			    !face->canRenderAsMask())
+			{
+				alpha_wrap = TRUE;
+				break;
+			}
+		}
+	}
+	else
+	{
+		shrink_wrap = FALSE;
+	}
+
+	if (alpha_wrap)
+	{
+		LLVector3 bounds = getScale();
+		radius = llmin(bounds.mV[1], bounds.mV[2]);
+		radius = llmin(radius, bounds.mV[0]);
+		radius *= 0.5f;
+		radius *= 1.f+mDrawable->mDistanceWRTCamera*alpha_distance_factor[1];
+		radius += mDrawable->mDistanceWRTCamera*alpha_distance_factor[0];
+	}
+	else if (shrink_wrap)
+	{
+		LLVector4a rad;
+		rad.setSub(ext[1], ext[0]);
+		
+		radius = rad.getLength3().getF32()*0.5f;
+	}
+	else if (mDrawable->isStatic())
+	{
+		radius = llmax((S32) mDrawable->getRadius(), 1)*size_factor;
+		radius *= 1.f + mDrawable->mDistanceWRTCamera * distance_factor[1];
+		radius += mDrawable->mDistanceWRTCamera * distance_factor[0];
+	}
+	else if (mDrawable->getVObj()->isAttachment())
+	{
+		radius = llmax((S32) mDrawable->getRadius(),1)*attachment_size_factor;
+	}
+	else
+	{
+		radius = mDrawable->getRadius();
+		radius *= 1.f + mDrawable->mDistanceWRTCamera * distance_factor[1];
+		radius += mDrawable->mDistanceWRTCamera * distance_factor[0];
+	}
+
+	return llclamp(radius*scale, 0.5f, 256.f);
+}
+
+const LLVector3 LLVOVolume::getPivotPositionAgent() const
+{
+	if (mVolumeImpl)
+	{
+		return mVolumeImpl->getPivotPosition();
+	}
+	return LLViewerObject::getPivotPositionAgent();
+}
+
+void LLVOVolume::onShift(const LLVector4a &shift_vector)
+{
+	if (mVolumeImpl)
+	{
+		mVolumeImpl->onShift(shift_vector);
+	}
+
+	updateRelativeXform();
+}
+
+const LLMatrix4& LLVOVolume::getWorldMatrix(LLXformMatrix* xform) const
+{
+	if (mVolumeImpl)
+	{
+		return mVolumeImpl->getWorldMatrix(xform);
+	}
+	return xform->getWorldMatrix();
+}
+
+LLVector3 LLVOVolume::agentPositionToVolume(const LLVector3& pos) const
+{
+	LLVector3 ret = pos - getRenderPosition();
+	ret = ret * ~getRenderRotation();
+	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
+	LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
+	ret.scaleVec(invObjScale);
+	
+	return ret;
+}
+
+LLVector3 LLVOVolume::agentDirectionToVolume(const LLVector3& dir) const
+{
+	LLVector3 ret = dir * ~getRenderRotation();
+	
+	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
+	ret.scaleVec(objScale);
+
+	return ret;
+}
+
+LLVector3 LLVOVolume::volumePositionToAgent(const LLVector3& dir) const
+{
+	LLVector3 ret = dir;
+	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
+	ret.scaleVec(objScale);
+	ret = ret * getRenderRotation();
+	ret += getRenderPosition();
+	
+	return ret;
+}
+
+LLVector3 LLVOVolume::volumeDirectionToAgent(const LLVector3& dir) const
+{
+	LLVector3 ret = dir;
+	LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
+	LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
+	ret.scaleVec(invObjScale);
+	ret = ret * getRenderRotation();
+
+	return ret;
+}
+
+
+BOOL LLVOVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, S32 face, BOOL pick_transparent, S32 *face_hitp,
+									  LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
+	
+{
+	if (!mbCanSelect 
+		|| mDrawable->isDead() 
+		|| !gPipeline.hasRenderType(mDrawable->getRenderType()))
+	{
+		return FALSE;
+	}
+
+	BOOL ret = FALSE;
+
+	LLVolume* volume = getVolume();
+
+	bool transform = true;
+
+	if (mDrawable->isState(LLDrawable::RIGGED))
+	{
+		if (LLFloater::isVisible(gFloaterTools) && getAvatar()->isSelf())
+		{
+			updateRiggedVolume();
+			genBBoxes(FALSE);
+			volume = mRiggedVolume;
+			transform = false;
+		}
+		else
+		{ //cannot pick rigged attachments on other avatars or when not in build mode
+			return FALSE;
+		}
+	}
+	
+	if (volume)
+	{	
+		LLVector3 v_start, v_end, v_dir;
+	
+		if (transform)
+		{
+			v_start = agentPositionToVolume(start);
+			v_end = agentPositionToVolume(end);
+		}
+		else
+		{
+			v_start = start;
+			v_end = end;
+		}
+		
+		LLVector3 p;
+		LLVector3 n;
+		LLVector2 tc;
+		LLVector3 bn;
+
+		if (intersection != NULL)
+		{
+			p = *intersection;
+		}
+
+		if (tex_coord != NULL)
+		{
+			tc = *tex_coord;
+		}
+
+		if (normal != NULL)
+		{
+			n = *normal;
+		}
+
+		if (bi_normal != NULL)
+		{
+			bn = *bi_normal;
+		}
+
+		S32 face_hit = -1;
+
+		S32 start_face, end_face;
+		if (face == -1)
+		{
+			start_face = 0;
+			end_face = volume->getNumVolumeFaces();
+		}
+		else
+		{
+			start_face = face;
+			end_face = face+1;
+		}
+
+		bool special_cursor = specialHoverCursor();
+		for (S32 i = start_face; i < end_face; ++i)
+		{
+			if (!special_cursor && !pick_transparent && getTE(i)->getColor().mV[3] == 0.f)
+			{ //don't attempt to pick completely transparent faces unless
+				//pick_transparent is true
+				continue;
+			}
+
+			face_hit = volume->lineSegmentIntersect(v_start, v_end, i,
+													&p, &tc, &n, &bn);
+			
+			if (face_hit >= 0 && mDrawable->getNumFaces() > face_hit)
+			{
+				LLFace* face = mDrawable->getFace(face_hit);				
+
+				if (pick_transparent || !face->getTexture() || !face->getTexture()->hasGLTexture() || face->getTexture()->getMask(face->surfaceToTexture(tc, p, n)))
+				{
+					v_end = p;
+					if (face_hitp != NULL)
+					{
+						*face_hitp = face_hit;
+					}
+					
+					if (intersection != NULL)
+					{
+						if (transform)
+						{
+							*intersection = volumePositionToAgent(p);  // must map back to agent space
+						}
+						else
+						{
+							*intersection = p;
+						}
+					}
+
+					if (normal != NULL)
+					{
+						if (transform)
+						{
+							*normal = volumeDirectionToAgent(n);
+						}
+						else
+						{
+							*normal = n;
+						}
+
+						(*normal).normVec();
+					}
+
+					if (bi_normal != NULL)
+					{
+						if (transform)
+						{
+							*bi_normal = volumeDirectionToAgent(bn);
+						}
+						else
+						{
+							*bi_normal = bn;
+						}
+						(*bi_normal).normVec();
+					}
+
+					if (tex_coord != NULL)
+					{
+						*tex_coord = tc;
+					}
+					
+					ret = TRUE;
+				}
+			}
+		}
+	}
+		
+	return ret;
+}
+
+bool LLVOVolume::treatAsRigged()
+{
+	return LLFloater::isVisible(gFloaterTools) && 
+			isAttachment() && 
+			getAvatar() &&
+			getAvatar()->isSelf() &&
+			mDrawable.notNull() &&
+			mDrawable->isState(LLDrawable::RIGGED);
+}
+
+LLRiggedVolume* LLVOVolume::getRiggedVolume()
+{
+	return mRiggedVolume;
+}
+
+void LLVOVolume::clearRiggedVolume()
+{
+	if (mRiggedVolume.notNull())
+	{
+		mRiggedVolume = NULL;
+		updateRelativeXform();
+	}
+}
+
+void LLVOVolume::updateRiggedVolume()
+{
+	//Update mRiggedVolume to match current animation frame of avatar. 
+	//Also update position/size in octree.  
+
+	if (!treatAsRigged())
+	{
+		clearRiggedVolume();
+		
+		return;
+	}
+
+	LLVolume* volume = getVolume();
+
+	const LLMeshSkinInfo* skin = gMeshRepo.getSkinInfo(volume->getParams().getSculptID(), this);
+
+	if (!skin)
+	{
+		clearRiggedVolume();
+		return;
+	}
+
+	LLVOAvatar* avatar = getAvatar();
+
+	if (!avatar)
+	{
+		clearRiggedVolume();
+		return;
+	}
+
+	if (!mRiggedVolume)
+	{
+		LLVolumeParams p;
+		mRiggedVolume = new LLRiggedVolume(p);
+		updateRelativeXform();
+	}
+
+	mRiggedVolume->update(skin, avatar, volume);
+
+}
+
+static LLFastTimer::DeclareTimer FTM_SKIN_RIGGED("Skin");
+static LLFastTimer::DeclareTimer FTM_RIGGED_OCTREE("Octree");
+
+void LLRiggedVolume::update(const LLMeshSkinInfo* skin, LLVOAvatar* avatar, const LLVolume* volume)
+{
+	bool copy = false;
+	if (volume->getNumVolumeFaces() != getNumVolumeFaces())
+	{ 
+		copy = true;
+	}
+
+	for (S32 i = 0; i < volume->getNumVolumeFaces() && !copy; ++i)
+	{
+		const LLVolumeFace& src_face = volume->getVolumeFace(i);
+		const LLVolumeFace& dst_face = getVolumeFace(i);
+
+		if (src_face.mNumIndices != dst_face.mNumIndices ||
+			src_face.mNumVertices != dst_face.mNumVertices)
+		{
+			copy = true;
+		}
+	}
+
+	if (copy)
+	{
+		copyVolumeFaces(volume);	
+	}
+
+	//build matrix palette
+	LLMatrix4a mp[64];
+	LLMatrix4* mat = (LLMatrix4*) mp;
+	
+	for (U32 j = 0; j < skin->mJointNames.size(); ++j)
+	{
+		LLJoint* joint = avatar->getJoint(skin->mJointNames[j]);
+		if (joint)
+		{
+			mat[j] = skin->mInvBindMatrix[j];
+			mat[j] *= joint->getWorldMatrix();
+		}
+	}
+
+	for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
+	{
+		const LLVolumeFace& vol_face = volume->getVolumeFace(i);
+		
+		LLVolumeFace& dst_face = mVolumeFaces[i];
+		
+		LLVector4a* weight = vol_face.mWeights;
+
+		LLMatrix4a bind_shape_matrix;
+		bind_shape_matrix.loadu(skin->mBindShapeMatrix);
+
+		LLVector4a* pos = dst_face.mPositions;
+
+		{
+			LLFastTimer t(FTM_SKIN_RIGGED);
+
+			for (U32 j = 0; j < dst_face.mNumVertices; ++j)
+			{
+				LLMatrix4a final_mat;
+				final_mat.clear();
+
+				S32 idx[4];
+
+				LLVector4 wght;
+
+				F32 scale = 0.f;
+				for (U32 k = 0; k < 4; k++)
+				{
+					F32 w = weight[j][k];
+
+					idx[k] = (S32) floorf(w);
+					wght[k] = w - floorf(w);
+					scale += wght[k];
+				}
+
+				wght *= 1.f/scale;
+
+				for (U32 k = 0; k < 4; k++)
+				{
+					F32 w = wght[k];
+
+					LLMatrix4a src;
+					src.setMul(mp[idx[k]], w);
+
+					final_mat.add(src);
+				}
+
+				
+				LLVector4a& v = vol_face.mPositions[j];
+				LLVector4a t;
+				LLVector4a dst;
+				bind_shape_matrix.affineTransform(v, t);
+				final_mat.affineTransform(t, dst);
+				pos[j] = dst;
+			}
+
+			//update bounding box
+			LLVector4a& min = dst_face.mExtents[0];
+			LLVector4a& max = dst_face.mExtents[1];
+
+			min = pos[0];
+			max = pos[1];
+
+			for (U32 j = 1; j < dst_face.mNumVertices; ++j)
+			{
+				min.setMin(min, pos[j]);
+				max.setMax(max, pos[j]);
+			}
+
+			dst_face.mCenter->setAdd(dst_face.mExtents[0], dst_face.mExtents[1]);
+			dst_face.mCenter->mul(0.5f);
+
+		}
+
+		{
+			LLFastTimer t(FTM_RIGGED_OCTREE);
+			delete dst_face.mOctree;
+			dst_face.mOctree = NULL;
+
+			LLVector4a size;
+			size.setSub(dst_face.mExtents[1], dst_face.mExtents[0]);
+			size.splat(size.getLength3().getF32()*0.5f);
+			
+			dst_face.createOctree(1.f);
+		}
+	}
+}
+
+U32 LLVOVolume::getPartitionType() const
+{
+	if (isHUDAttachment())
+	{
+		return LLViewerRegion::PARTITION_HUD;
+	}
+
+	return LLViewerRegion::PARTITION_VOLUME;
+}
+
+LLVolumePartition::LLVolumePartition()
+: LLSpatialPartition(LLVOVolume::VERTEX_DATA_MASK, TRUE, GL_DYNAMIC_DRAW_ARB)
+{
+	mLODPeriod = 32;
+	mDepthMask = FALSE;
+	mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
+	mPartitionType = LLViewerRegion::PARTITION_VOLUME;
+	mSlopRatio = 0.25f;
+	mBufferUsage = GL_DYNAMIC_DRAW_ARB;
+}
+
+LLVolumeBridge::LLVolumeBridge(LLDrawable* drawablep)
+: LLSpatialBridge(drawablep, TRUE, LLVOVolume::VERTEX_DATA_MASK)
+{
+	mDepthMask = FALSE;
+	mLODPeriod = 32;
+	mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
+	mPartitionType = LLViewerRegion::PARTITION_BRIDGE;
+	
+	mBufferUsage = GL_DYNAMIC_DRAW_ARB;
+
+	mSlopRatio = 0.25f;
+}
+
+bool can_batch_texture(LLFace* facep)
+{
+	if (facep->getTextureEntry()->getBumpmap())
+	{ //bump maps aren't worked into texture batching yet
+		return false;
+	}
+
+	if (facep->getTexture() && facep->getTexture()->getPrimaryFormat() == GL_ALPHA)
+	{ //can't batch invisiprims
+		return false;
+	}
+
+	if (facep->isState(LLFace::TEXTURE_ANIM) && facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
+	{ //texture animation breaks batches
+		return false;
+	}
+	
+	return true;
+}
+
+void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, U32 type)
+{
+	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
+
+	if (facep->getViewerObject()->isSelected() && LLSelectMgr::getInstance()->mHideSelectedObjects)
+	{
+		return;
+	}
+
+	//add face to drawmap
+	LLSpatialGroup::drawmap_elem_t& draw_vec = group->mDrawMap[type];	
+
+	S32 idx = draw_vec.size()-1;
+
+	BOOL fullbright = (type == LLRenderPass::PASS_FULLBRIGHT) ||
+		(type == LLRenderPass::PASS_INVISIBLE) ||
+		(type == LLRenderPass::PASS_ALPHA && facep->isState(LLFace::FULLBRIGHT));
+	
+	if (!fullbright && type != LLRenderPass::PASS_GLOW && !facep->getVertexBuffer()->hasDataType(LLVertexBuffer::TYPE_NORMAL))
+	{
+		llwarns << "Non fullbright face has no normals!" << llendl;
+		return;
+	}
+
+	const LLMatrix4* tex_mat = NULL;
+	if (facep->isState(LLFace::TEXTURE_ANIM) && facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
+	{
+		tex_mat = facep->mTextureMatrix;	
+	}
+
+	const LLMatrix4* model_mat = NULL;
+
+	LLDrawable* drawable = facep->getDrawable();
+	if (drawable->isActive())
+	{
+		model_mat = &(drawable->getRenderMatrix());
+	}
+	else
+	{
+		model_mat = &(drawable->getRegion()->mRenderMatrix);
+		if (model_mat->isIdentity())
+		{
+			model_mat = NULL;
+		}
+	}
+
+	U8 bump = (type == LLRenderPass::PASS_BUMP || type == LLRenderPass::PASS_POST_BUMP) ? facep->getTextureEntry()->getBumpmap() : 0;
+	
+	LLViewerTexture* tex = facep->getTexture();
+
+	U8 index = facep->getTextureIndex();
+
+	bool batchable = false;
+
+	if (index < 255 && idx >= 0)
+	{
+		if (index < draw_vec[idx]->mTextureList.size())
+		{
+			if (draw_vec[idx]->mTextureList[index].isNull())
+			{
+				batchable = true;
+				draw_vec[idx]->mTextureList[index] = tex;
+			}
+			else if (draw_vec[idx]->mTextureList[index] == tex)
+			{ //this face's texture index can be used with this batch
+				batchable = true;
+			}
+		}
+		else
+		{ //texture list can be expanded to fit this texture index
+			batchable = true;
+		}
+	}
+	
+	U8 glow = (U8) (facep->getTextureEntry()->getGlow() * 255);
+
+	if (idx >= 0 && 
+		draw_vec[idx]->mVertexBuffer == facep->getVertexBuffer() &&
+		draw_vec[idx]->mEnd == facep->getGeomIndex()-1 &&
+		(LLPipeline::sTextureBindTest || draw_vec[idx]->mTexture == tex || batchable) &&
+#if LL_DARWIN
+		draw_vec[idx]->mEnd - draw_vec[idx]->mStart + facep->getGeomCount() <= (U32) gGLManager.mGLMaxVertexRange &&
+		draw_vec[idx]->mCount + facep->getIndicesCount() <= (U32) gGLManager.mGLMaxIndexRange &&
+#endif
+		draw_vec[idx]->mGlowColor.mV[3] == glow &&
+		draw_vec[idx]->mFullbright == fullbright &&
+		draw_vec[idx]->mBump == bump &&
+		draw_vec[idx]->mTextureMatrix == tex_mat &&
+		draw_vec[idx]->mModelMatrix == model_mat)
+	{
+		draw_vec[idx]->mCount += facep->getIndicesCount();
+		draw_vec[idx]->mEnd += facep->getGeomCount();
+		draw_vec[idx]->mVSize = llmax(draw_vec[idx]->mVSize, facep->getVirtualSize());
+
+		if (index >= draw_vec[idx]->mTextureList.size())
+		{
+			draw_vec[idx]->mTextureList.resize(index+1);
+			draw_vec[idx]->mTextureList[index] = tex;
+		}
+		draw_vec[idx]->validate();
+		update_min_max(draw_vec[idx]->mExtents[0], draw_vec[idx]->mExtents[1], facep->mExtents[0]);
+		update_min_max(draw_vec[idx]->mExtents[0], draw_vec[idx]->mExtents[1], facep->mExtents[1]);
+	}
+	else
+	{
+		U32 start = facep->getGeomIndex();
+		U32 end = start + facep->getGeomCount()-1;
+		U32 offset = facep->getIndicesStart();
+		U32 count = facep->getIndicesCount();
+		LLPointer<LLDrawInfo> draw_info = new LLDrawInfo(start,end,count,offset, tex, 
+			facep->getVertexBuffer(), fullbright, bump); 
+		draw_info->mGroup = group;
+		draw_info->mVSize = facep->getVirtualSize();
+		draw_vec.push_back(draw_info);
+		draw_info->mTextureMatrix = tex_mat;
+		draw_info->mModelMatrix = model_mat;
+		draw_info->mGlowColor.setVec(0,0,0,glow);
+		if (type == LLRenderPass::PASS_ALPHA)
+		{ //for alpha sorting
+			facep->setDrawInfo(draw_info);
+		}
+		draw_info->mExtents[0] = facep->mExtents[0];
+		draw_info->mExtents[1] = facep->mExtents[1];
+
+		if (LLPipeline::sUseTriStrips)
+		{
+			draw_info->mDrawMode = LLRender::TRIANGLE_STRIP;
+		}
+
+		if (index < 255)
+		{ //initialize texture list for texture batching
+			draw_info->mTextureList.resize(index+1);
+			draw_info->mTextureList[index] = tex;
+		}
+		draw_info->validate();
+	}
+}
+
+void LLVolumeGeometryManager::getGeometry(LLSpatialGroup* group)
+{
+
+}
+
+static LLFastTimer::DeclareTimer FTM_REBUILD_VOLUME_VB("Volume");
+static LLFastTimer::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
+
+static LLDrawPoolAvatar* get_avatar_drawpool(LLViewerObject* vobj)
+{
+	LLVOAvatar* avatar = vobj->getAvatar();
+					
+	if (avatar)
+	{
+		LLDrawable* drawable = avatar->mDrawable;
+		if (drawable && drawable->getNumFaces() > 0)
+		{
+			LLFace* face = drawable->getFace(0);
+			if (face)
+			{
+				LLDrawPool* drawpool = face->getPool();
+				if (drawpool)
+				{
+					if (drawpool->getType() == LLDrawPool::POOL_AVATAR)
+					{
+						return (LLDrawPoolAvatar*) drawpool;
+					}
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
+{
+	if (group->changeLOD())
+	{
+		group->mLastUpdateDistance = group->mDistance;
+	}
+
+	group->mLastUpdateViewAngle = group->mViewAngle;
+
+	if (!group->isState(LLSpatialGroup::GEOM_DIRTY | LLSpatialGroup::ALPHA_DIRTY))
+	{
+		if (group->isState(LLSpatialGroup::MESH_DIRTY) && !LLPipeline::sDelayVBUpdate)
+		{
+			LLFastTimer ftm(FTM_REBUILD_VBO);	
+			LLFastTimer ftm2(FTM_REBUILD_VOLUME_VB);
+		
+			rebuildMesh(group);
+		}
+		return;
+	}
+
+	group->mBuilt = 1.f;
+	LLFastTimer ftm(FTM_REBUILD_VBO);	
+
+	LLFastTimer ftm2(FTM_REBUILD_VOLUME_VB);
+
+	group->clearDrawMap();
+
+	mFaceList.clear();
+
+	std::vector<LLFace*> fullbright_faces;
+	std::vector<LLFace*> bump_faces;
+	std::vector<LLFace*> simple_faces;
+
+	std::vector<LLFace*> alpha_faces;
+	U32 useage = group->mSpatialPartition->mBufferUsage;
+
+	U32 max_vertices = (gSavedSettings.getS32("RenderMaxVBOSize")*1024)/LLVertexBuffer::calcVertexSize(group->mSpatialPartition->mVertexDataMask);
+	U32 max_total = (gSavedSettings.getS32("RenderMaxNodeSize")*1024)/LLVertexBuffer::calcVertexSize(group->mSpatialPartition->mVertexDataMask);
+	max_vertices = llmin(max_vertices, (U32) 65535);
+
+	U32 cur_total = 0;
+
+	//get all the faces into a list
+	for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
+	{
+		LLDrawable* drawablep = *drawable_iter;
+		
+		if (drawablep->isDead() || drawablep->isState(LLDrawable::FORCE_INVISIBLE) )
+		{
+			continue;
+		}
+	
+		if (drawablep->isAnimating())
+		{ //fall back to stream draw for animating verts
+			useage = GL_STREAM_DRAW_ARB;
+		}
+
+		LLVOVolume* vobj = drawablep->getVOVolume();
+
+		if (vobj->isMesh() &&
+			(vobj->getVolume() && !vobj->getVolume()->isMeshAssetLoaded() || !gMeshRepo.meshRezEnabled()))
+		{
+			continue;
+		}
+
+		llassert_always(vobj);
+		vobj->updateTextureVirtualSize();
+		vobj->preRebuild();
+
+		drawablep->clearState(LLDrawable::HAS_ALPHA);
+
+		bool rigged = vobj->isAttachment() && 
+					vobj->isMesh() && 
+					gMeshRepo.getSkinInfo(vobj->getVolume()->getParams().getSculptID(), vobj);
+
+		bool bake_sunlight = LLPipeline::sBakeSunlight && drawablep->isStatic();
+
+		bool is_rigged = false;
+
+		//for each face
+		for (S32 i = 0; i < drawablep->getNumFaces(); i++)
+		{
+			LLFace* facep = drawablep->getFace(i);
+
+			//ALWAYS null out vertex buffer on rebuild -- if the face lands in a render
+			// batch, it will recover its vertex buffer reference from the spatial group
+			facep->setVertexBuffer(NULL);
+			
+			//sum up face verts and indices
+			drawablep->updateFaceSize(i);
+			
+			
+
+			if (rigged) 
+			{
+				if (!facep->isState(LLFace::RIGGED))
+				{ //completely reset vertex buffer
+					facep->clearVertexBuffer();
+				}
+		
+				facep->setState(LLFace::RIGGED);
+				is_rigged = true;
+				
+				//get drawpool of avatar with rigged face
+				LLDrawPoolAvatar* pool = get_avatar_drawpool(vobj);
+				
+				//Determine if we've received skininfo that contains an
+				//alternate bind matrix - if it does then apply the translational component
+				//to the joints of the avatar.
+				LLVOAvatar* pAvatarVO = vobj->getAvatar();
+				bool pelvisGotSet = false;
+
+				if ( pAvatarVO )
+				{
+					LLUUID currentId = vobj->getVolume()->getParams().getSculptID();
+					const LLMeshSkinInfo*  pSkinData = gMeshRepo.getSkinInfo( currentId, vobj );
+					
+					if ( pSkinData )
+					{
+						const int bindCnt = pSkinData->mAlternateBindMatrix.size();								
+						if ( bindCnt > 0 )
+						{					
+							const int jointCnt = pSkinData->mJointNames.size();
+							const F32 pelvisZOffset = pSkinData->mPelvisOffset;
+							bool fullRig = (jointCnt>=20) ? true : false;
+							if ( fullRig )
+							{
+								for ( int i=0; i<jointCnt; ++i )
+								{
+									std::string lookingForJoint = pSkinData->mJointNames[i].c_str();
+									//llinfos<<"joint name "<<lookingForJoint.c_str()<<llendl;
+									LLJoint* pJoint = pAvatarVO->getJoint( lookingForJoint );
+									if ( pJoint && pJoint->getId() != currentId )
+									{   									
+										pJoint->setId( currentId );
+										const LLVector3& jointPos = pSkinData->mAlternateBindMatrix[i].getTranslation();									
+										//Set the joint position
+										pJoint->storeCurrentXform( jointPos );																																
+										//If joint is a pelvis then handle old/new pelvis to foot values
+										if ( lookingForJoint == "mPelvis" )
+										{	
+											pJoint->storeCurrentXform( jointPos );																																
+											if ( !pAvatarVO->hasPelvisOffset() )
+											{										
+												pAvatarVO->setPelvisOffset( true, jointPos, pelvisZOffset );
+												//Trigger to rebuild viewer AV
+												pelvisGotSet = true;											
+											}										
+										}										
+									}
+								}
+							}							
+						}
+					}
+				}
+				//If we've set the pelvis to a new position we need to also rebuild some information that the
+				//viewer does at launch (e.g. body size etc.)
+				if ( pelvisGotSet )
+				{
+					pAvatarVO->postPelvisSetRecalc();
+				}
+
+				if (pool)
+				{
+					const LLTextureEntry* te = facep->getTextureEntry();
+
+					//remove face from old pool if it exists
+					LLDrawPool* old_pool = facep->getPool();
+					if (old_pool && old_pool->getType() == LLDrawPool::POOL_AVATAR)
+					{
+						((LLDrawPoolAvatar*) old_pool)->removeRiggedFace(facep);
+					}
+
+					//add face to new pool
+					LLViewerTexture* tex = facep->getTexture();
+					U32 type = gPipeline.getPoolTypeFromTE(te, tex);
+
+					if (type == LLDrawPool::POOL_ALPHA)
+					{
+						if (te->getFullbright())
+						{
+							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_FULLBRIGHT_ALPHA);
+						}
+						else
+						{
+							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_ALPHA);
+						}
+					}
+					else if (te->getShiny())
+					{
+						if (te->getFullbright())
+						{
+							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_FULLBRIGHT_SHINY);
+						}
+						else
+						{
+							if (LLPipeline::sRenderDeferred)
+							{
+								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_SIMPLE);
+							}
+							else
+							{
+								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_SHINY);
+							}
+						}
+					}
+					else
+					{
+						if (te->getFullbright())
+						{
+							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_FULLBRIGHT);
+						}
+						else
+						{
+							pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_SIMPLE);
+						}
+					}
+
+					if (te->getGlow())
+					{
+						pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_GLOW);
+					}
+
+					if (LLPipeline::sRenderDeferred)
+					{
+						if (type != LLDrawPool::POOL_ALPHA && !te->getFullbright())
+						{
+							if (te->getBumpmap())
+							{
+								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_DEFERRED_BUMP);
+							}
+							else
+							{
+								pool->addRiggedFace(facep, LLDrawPoolAvatar::RIGGED_DEFERRED_SIMPLE);
+							}
+						}
+					}
+				}
+
+				continue;
+			}
+			else
+			{
+				if (facep->isState(LLFace::RIGGED))
+				{ //face is not rigged but used to be, remove from rigged face pool
+					LLDrawPoolAvatar* pool = (LLDrawPoolAvatar*) facep->getPool();
+					if (pool)
+					{
+						pool->removeRiggedFace(facep);
+					}
+					facep->clearState(LLFace::RIGGED);
+				}
+			}
+
+			if (cur_total > max_total || facep->getIndicesCount() <= 0 || facep->getGeomCount() <= 0)
+			{
+				facep->clearVertexBuffer();
+				continue;
+			}
+
+			cur_total += facep->getGeomCount();
+
+			if (facep->hasGeometry() && facep->getPixelArea() > FORCE_CULL_AREA)
+			{
+				const LLTextureEntry* te = facep->getTextureEntry();
+				LLViewerTexture* tex = facep->getTexture();
+
+				if (facep->isState(LLFace::TEXTURE_ANIM))
+				{
+					if (!vobj->mTexAnimMode)
+					{
+						facep->clearState(LLFace::TEXTURE_ANIM);
+					}
+				}
+
+				BOOL force_simple = (facep->getPixelArea() < FORCE_SIMPLE_RENDER_AREA);
+				U32 type = gPipeline.getPoolTypeFromTE(te, tex);
+				if (type != LLDrawPool::POOL_ALPHA && force_simple)
+				{
+					type = LLDrawPool::POOL_SIMPLE;
+				}
+				facep->setPoolType(type);
+
+				if (vobj->isHUDAttachment())
+				{
+					facep->setState(LLFace::FULLBRIGHT);
+				}
+
+				if (vobj->mTextureAnimp && vobj->mTexAnimMode)
+				{
+					if (vobj->mTextureAnimp->mFace <= -1)
+					{
+						S32 face;
+						for (face = 0; face < vobj->getNumTEs(); face++)
+						{
+							drawablep->getFace(face)->setState(LLFace::TEXTURE_ANIM);
+						}
+					}
+					else if (vobj->mTextureAnimp->mFace < vobj->getNumTEs())
+					{
+						drawablep->getFace(vobj->mTextureAnimp->mFace)->setState(LLFace::TEXTURE_ANIM);
+					}
+				}
+
+				if (type == LLDrawPool::POOL_ALPHA)
+				{
+					if (facep->canRenderAsMask())
+					{ //can be treated as alpha mask
+						simple_faces.push_back(facep);
+					}
+					else
+					{
+						drawablep->setState(LLDrawable::HAS_ALPHA);
+						alpha_faces.push_back(facep);
+					}
+				}
+				else
+				{
+					if (drawablep->isState(LLDrawable::REBUILD_VOLUME))
+					{
+						facep->mLastUpdateTime = gFrameTimeSeconds;
+					}
+
+					if (gPipeline.canUseWindLightShadersOnObjects()
+						&& LLPipeline::sRenderBump)
+					{
+						if (te->getBumpmap())
+						{ //needs normal + binormal
+							bump_faces.push_back(facep);
+						}
+						else if (te->getShiny() || !te->getFullbright())
+						{ //needs normal
+							simple_faces.push_back(facep);
+						}
+						else 
+						{ //doesn't need normal
+							facep->setState(LLFace::FULLBRIGHT);
+							fullbright_faces.push_back(facep);
+						}
+					}
+					else
+					{
+						if (te->getBumpmap() && LLPipeline::sRenderBump)
+						{ //needs normal + binormal
+							bump_faces.push_back(facep);
+						}
+						else if ((te->getShiny() && LLPipeline::sRenderBump) ||
+							!(te->getFullbright() || bake_sunlight))
+						{ //needs normal
+							simple_faces.push_back(facep);
+						}
+						else 
+						{ //doesn't need normal
+							facep->setState(LLFace::FULLBRIGHT);
+							fullbright_faces.push_back(facep);
+						}
+					}
+				}
+			}
+			else
+			{	//face has no renderable geometry
+				facep->clearVertexBuffer();
+			}		
+		}
+
+		if (is_rigged)
+		{
+			drawablep->setState(LLDrawable::RIGGED);
+		}
+		else
+		{
+			drawablep->clearState(LLDrawable::RIGGED);
+		}
+	}
+
+	group->mBufferUsage = useage;
+
+	//PROCESS NON-ALPHA FACES
+	U32 simple_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
+	U32 alpha_mask = simple_mask | 0x80000000; //hack to give alpha verts their own VBO
+	U32 bump_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
+	U32 fullbright_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
+
+	bool batch_textures = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT) > 1;
+
+	if (batch_textures)
+	{
+		bump_mask |= LLVertexBuffer::MAP_BINORMAL;
+		genDrawInfo(group, simple_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, simple_faces, FALSE, TRUE);
+		genDrawInfo(group, fullbright_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, fullbright_faces, FALSE, TRUE);
+		genDrawInfo(group, bump_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, bump_faces, FALSE, TRUE);
+		genDrawInfo(group, alpha_mask | LLVertexBuffer::MAP_TEXTURE_INDEX, alpha_faces, TRUE, TRUE);
+	}
+	else
+	{
+		genDrawInfo(group, simple_mask, simple_faces);
+		genDrawInfo(group, fullbright_mask, fullbright_faces);
+		genDrawInfo(group, bump_mask, bump_faces, FALSE, TRUE);
+		genDrawInfo(group, alpha_mask, alpha_faces, TRUE);
+	}
+	
+
+	if (!LLPipeline::sDelayVBUpdate)
+	{
+		//drawables have been rebuilt, clear rebuild status
+		for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
+		{
+			LLDrawable* drawablep = *drawable_iter;
+			drawablep->clearState(LLDrawable::REBUILD_ALL);
+		}
+	}
+
+	group->mLastUpdateTime = gFrameTimeSeconds;
+	group->mBuilt = 1.f;
+	group->clearState(LLSpatialGroup::GEOM_DIRTY | LLSpatialGroup::ALPHA_DIRTY);
+
+	if (LLPipeline::sDelayVBUpdate)
+	{
+		group->setState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO);
+	}
+
+	mFaceList.clear();
+}
+
+static LLFastTimer::DeclareTimer FTM_VOLUME_GEOM("Volume Geometry");
+static LLFastTimer::DeclareTimer FTM_VOLUME_GEOM_PARTIAL("Terse Rebuild");
+
+void LLVolumeGeometryManager::rebuildMesh(LLSpatialGroup* group)
+{
+	llassert(group);
+	if (group && group->isState(LLSpatialGroup::MESH_DIRTY) && !group->isState(LLSpatialGroup::GEOM_DIRTY))
+	{
+		LLFastTimer tm(FTM_VOLUME_GEOM);
+		S32 num_mapped_veretx_buffer = LLVertexBuffer::sMappedCount ;
+
+		group->mBuilt = 1.f;
+		
+		std::set<LLVertexBuffer*> mapped_buffers;
+
+		for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
+		{
+			LLFastTimer t(FTM_VOLUME_GEOM_PARTIAL);
+			LLDrawable* drawablep = *drawable_iter;
+
+			if (!drawablep->isDead() && drawablep->isState(LLDrawable::REBUILD_ALL) )
+			{
+				LLVOVolume* vobj = drawablep->getVOVolume();
+				vobj->preRebuild();
+
+				LLVolume* volume = vobj->getVolume();
+				for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
+				{
+					LLFace* face = drawablep->getFace(i);
+					if (face)
+					{
+						LLVertexBuffer* buff = face->getVertexBuffer();
+						if (buff)
+						{
+							face->getGeometryVolume(*volume, face->getTEOffset(), 
+								vobj->getRelativeXform(), vobj->getRelativeXformInvTrans(), face->getGeomIndex());
+
+							if (buff->isLocked())
+							{
+								mapped_buffers.insert(buff);
+							}
+						}
+					}
+				}
+				
+				drawablep->clearState(LLDrawable::REBUILD_ALL);
+			}
+		}
+		
+		for (std::set<LLVertexBuffer*>::iterator iter = mapped_buffers.begin(); iter != mapped_buffers.end(); ++iter)
+		{
+			(*iter)->setBuffer(0);
+		}
+
+		// don't forget alpha
+		if(group != NULL && 
+		   !group->mVertexBuffer.isNull() && 
+		   group->mVertexBuffer->isLocked())
+		{
+			group->mVertexBuffer->setBuffer(0);
+		}
+
+		//if not all buffers are unmapped
+		if(num_mapped_veretx_buffer != LLVertexBuffer::sMappedCount) 
+		{
+			llwarns << "Not all mapped vertex buffers are unmapped!" << llendl ; 
+			for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
+			{
+				LLDrawable* drawablep = *drawable_iter;
+				for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
+				{
+					LLFace* face = drawablep->getFace(i);
+					LLVertexBuffer* buff = face->getVertexBuffer();
+					if (face && buff && buff->isLocked())
+					{
+						buff->setBuffer(0) ;
+					}
+				}
+			} 
+		}
+
+		group->clearState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO);
+	}
+
+	llassert(!group || !group->isState(LLSpatialGroup::NEW_DRAWINFO));
+}
+
+struct CompareBatchBreakerModified
+{
+	bool operator()(const LLFace* const& lhs, const LLFace* const& rhs)
+	{
+		const LLTextureEntry* lte = lhs->getTextureEntry();
+		const LLTextureEntry* rte = rhs->getTextureEntry();
+
+		if (lte->getBumpmap() != rte->getBumpmap())
+		{
+			return lte->getBumpmap() < rte->getBumpmap();
+		}
+		else if (lte->getFullbright() != rte->getFullbright())
+		{
+			return lte->getFullbright() < rte->getFullbright();
+		}
+		else  if (lte->getGlow() != rte->getGlow())
+		{
+			return lte->getGlow() < rte->getGlow();
+		}
+		else
+		{
+			return lhs->getTexture() < rhs->getTexture();
+		}
+		
+	}
+};
+
+void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::vector<LLFace*>& faces, BOOL distance_sort, BOOL batch_textures)
+{
+	//calculate maximum number of vertices to store in a single buffer
+	U32 max_vertices = (gSavedSettings.getS32("RenderMaxVBOSize")*1024)/LLVertexBuffer::calcVertexSize(group->mSpatialPartition->mVertexDataMask);
+	max_vertices = llmin(max_vertices, (U32) 65535);
+
+	if (!distance_sort)
+	{
+		//sort faces by things that break batches
+		std::sort(faces.begin(), faces.end(), CompareBatchBreakerModified());
+	}
+	else
+	{
+		//sort faces by distance
+		std::sort(faces.begin(), faces.end(), LLFace::CompareDistanceGreater());
+	}
+				
+	std::vector<LLFace*>::iterator face_iter = faces.begin();
+	
+	LLSpatialGroup::buffer_map_t buffer_map;
+
+	LLViewerTexture* last_tex = NULL;
+	S32 buffer_index = 0;
+
+	if (distance_sort)
+	{
+		buffer_index = -1;
+	}
+
+	S32 texture_index_channels = gGLManager.mNumTextureImageUnits-1; //always reserve one for shiny for now just for simplicity
+	
+	if (gGLManager.mGLVersion < 3.1f)
+	{
+		texture_index_channels = 1;
+	}
+
+	if (LLPipeline::sRenderDeferred && distance_sort)
+	{
+		texture_index_channels = gDeferredAlphaProgram.mFeatures.mIndexedTextureChannels;
+	}
+
+	texture_index_channels = llmin(texture_index_channels, (S32) gSavedSettings.getU32("RenderMaxTextureIndex"));
+	
+
+	while (face_iter != faces.end())
+	{
+		//pull off next face
+		LLFace* facep = *face_iter;
+		LLViewerTexture* tex = facep->getTexture();
+
+		if (distance_sort)
+		{
+			tex = NULL;
+		}
+
+		if (last_tex == tex)
+		{
+			buffer_index++;
+		}
+		else
+		{
+			last_tex = tex;
+			buffer_index = 0;
+		}
+
+		bool bake_sunlight = LLPipeline::sBakeSunlight && facep->getDrawable()->isStatic(); 
+
+		U32 index_count = facep->getIndicesCount();
+		U32 geom_count = facep->getGeomCount();
+
+		//sum up vertices needed for this render batch
+		std::vector<LLFace*>::iterator i = face_iter;
+		++i;
+		
+		std::vector<LLViewerTexture*> texture_list;
+
+		if (batch_textures)
+		{
+			U8 cur_tex = 0;
+			facep->setTextureIndex(cur_tex);
+			texture_list.push_back(tex);
+
+			//if (can_batch_texture(facep))
+			{
+				while (i != faces.end())
+				{
+					facep = *i;
+					if (facep->getTexture() != tex)
+					{
+						if (distance_sort)
+						{ //textures might be out of order, see if texture exists in current batch
+							bool found = false;
+							for (U32 tex_idx = 0; tex_idx < texture_list.size(); ++tex_idx)
+							{
+								if (facep->getTexture() == texture_list[tex_idx])
+								{
+									cur_tex = tex_idx;
+									found = true;
+									break;
+								}
+							}
+
+							if (!found)
+							{
+								cur_tex = texture_list.size();
+							}
+						}
+						else
+						{
+							cur_tex++;
+						}
+
+						if (!can_batch_texture(facep))
+						{ //face is bump mapped or has an animated texture matrix -- can't 
+							//batch more than 1 texture at a time
+							break;
+						}
+
+						if (cur_tex >= texture_index_channels)
+						{ //cut batches when index channels are depleted
+							break;
+						}
+
+						tex = facep->getTexture();
+
+						texture_list.push_back(tex);
+					}
+
+					if (geom_count + facep->getGeomCount() > max_vertices)
+					{ //cut batches on geom count too big
+						break;
+					}
+
+					++i;
+					index_count += facep->getIndicesCount();
+					geom_count += facep->getGeomCount();
+
+					facep->setTextureIndex(cur_tex);
+				}
+			}
+
+			tex = texture_list[0];
+		}
+		else
+		{
+			while (i != faces.end() && 
+				(LLPipeline::sTextureBindTest || (distance_sort || (*i)->getTexture() == tex)))
+			{
+				facep = *i;
+			
+
+				//face has no texture index
+				facep->mDrawInfo = NULL;
+				facep->setTextureIndex(255);
+
+				if (geom_count + facep->getGeomCount() > max_vertices)
+				{ //cut batches on geom count too big
+					break;
+				}
+
+				++i;
+				index_count += facep->getIndicesCount();
+				geom_count += facep->getGeomCount();
+			}
+		}
+	
+		//create/delete/resize vertex buffer if needed
+		LLVertexBuffer* buffer = NULL;
+		LLSpatialGroup::buffer_texture_map_t::iterator found_iter = group->mBufferMap[mask].find(*face_iter);
+		
+		if (found_iter != group->mBufferMap[mask].end())
+		{
+			if ((U32) buffer_index < found_iter->second.size())
+			{
+				buffer = found_iter->second[buffer_index];
+			}
+		}
+						
+		if (!buffer)
+		{ //create new buffer if needed
+			buffer = createVertexBuffer(mask, 
+											group->mBufferUsage);
+			buffer->allocateBuffer(geom_count, index_count, TRUE);
+		}
+		else 
+		{ //resize pre-existing buffer
+			if (LLVertexBuffer::sEnableVBOs && buffer->getUsage() != group->mBufferUsage ||
+				buffer->getTypeMask() != mask)
+			{
+				buffer = createVertexBuffer(mask, 
+											group->mBufferUsage);
+				buffer->allocateBuffer(geom_count, index_count, TRUE);
+			}
+			else
+			{
+				buffer->resizeBuffer(geom_count, index_count);
+			}
+		}
+
+		buffer_map[mask][*face_iter].push_back(buffer);
+
+		//add face geometry
+
+		U32 indices_index = 0;
+		U16 index_offset = 0;
+
+		while (face_iter < i)
+		{ //update face indices for new buffer
+			facep = *face_iter;
+			facep->setIndicesIndex(indices_index);
+			facep->setGeomIndex(index_offset);
+			facep->setVertexBuffer(buffer);	
+			
+			if (batch_textures && facep->getTextureIndex() == 255)
+			{
+				llerrs << "Invalid texture index." << llendl;
+			}
+			
+			{
+				//for debugging, set last time face was updated vs moved
+				facep->updateRebuildFlags();
+
+				if (!LLPipeline::sDelayVBUpdate)
+				{ //copy face geometry into vertex buffer
+					LLDrawable* drawablep = facep->getDrawable();
+					LLVOVolume* vobj = drawablep->getVOVolume();
+					LLVolume* volume = vobj->getVolume();
+
+					U32 te_idx = facep->getTEOffset();
+
+					facep->getGeometryVolume(*volume, te_idx, 
+						vobj->getRelativeXform(), vobj->getRelativeXformInvTrans(), index_offset);
+				}
+			}
+
+			index_offset += facep->getGeomCount();
+			indices_index += facep->getIndicesCount();
+
+
+			//append face to appropriate render batch
+
+			BOOL force_simple = facep->getPixelArea() < FORCE_SIMPLE_RENDER_AREA;
+			BOOL fullbright = facep->isState(LLFace::FULLBRIGHT);
+			if ((mask & LLVertexBuffer::MAP_NORMAL) == 0)
+			{ //paranoia check to make sure GL doesn't try to read non-existant normals
+				fullbright = TRUE;
+			}
+
+			const LLTextureEntry* te = facep->getTextureEntry();
+			tex = facep->getTexture();
+
+			BOOL is_alpha = (facep->getPoolType() == LLDrawPool::POOL_ALPHA) ? TRUE : FALSE;
+		
+			if (is_alpha)
+			{
+				// can we safely treat this as an alpha mask?
+				if (facep->canRenderAsMask())
+				{
+					if (te->getFullbright() || LLPipeline::sNoAlpha)
+					{
+						registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK);
+					}
+					else
+					{
+						registerFace(group, facep, LLRenderPass::PASS_ALPHA_MASK);
+					}
+				}
+				else
+				{
+					registerFace(group, facep, LLRenderPass::PASS_ALPHA);
+				}
+
+				if (LLPipeline::sRenderDeferred)
+				{
+					registerFace(group, facep, LLRenderPass::PASS_ALPHA_SHADOW);
+				}
+			}
+			else if (gPipeline.canUseVertexShaders()
+				&& group->mSpatialPartition->mPartitionType != LLViewerRegion::PARTITION_HUD 
+				&& LLPipeline::sRenderBump 
+				&& te->getShiny())
+			{ //shiny
+				if (tex->getPrimaryFormat() == GL_ALPHA)
+				{ //invisiprim+shiny
+					registerFace(group, facep, LLRenderPass::PASS_INVISI_SHINY);
+					registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
+				}
+				else if (LLPipeline::sRenderDeferred)
+				{ //deferred rendering
+					if (te->getFullbright())
+					{ //register in post deferred fullbright shiny pass
+						registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
+						if (te->getBumpmap())
+						{ //register in post deferred bump pass
+							registerFace(group, facep, LLRenderPass::PASS_POST_BUMP);
+						}
+					}
+					else if (te->getBumpmap())
+					{ //register in deferred bump pass
+						registerFace(group, facep, LLRenderPass::PASS_BUMP);
+					}
+					else
+					{ //register in deferred simple pass (deferred simple includes shiny)
+						llassert(mask & LLVertexBuffer::MAP_NORMAL);
+						registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
+					}
+				}
+				else if (fullbright)
+				{	//not deferred, register in standard fullbright shiny pass					
+					registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
+				}
+				else
+				{ //not deferred or fullbright, register in standard shiny pass
+					registerFace(group, facep, LLRenderPass::PASS_SHINY);
+				}
+			}
+			else
+			{ //not alpha and not shiny
+				if (!is_alpha && tex->getPrimaryFormat() == GL_ALPHA)
+				{ //invisiprim
+					registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
+				}
+				else if (fullbright || bake_sunlight)
+				{ //fullbright
+					registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT);
+					if (LLPipeline::sRenderDeferred && LLPipeline::sRenderBump && te->getBumpmap())
+					{ //if this is the deferred render and a bump map is present, register in post deferred bump
+						registerFace(group, facep, LLRenderPass::PASS_POST_BUMP);
+					}
+				}
+				else
+				{
+					if (LLPipeline::sRenderDeferred && LLPipeline::sRenderBump && te->getBumpmap())
+					{ //non-shiny or fullbright deferred bump
+						registerFace(group, facep, LLRenderPass::PASS_BUMP);
+					}
+					else
+					{ //all around simple
+						llassert(mask & LLVertexBuffer::MAP_NORMAL);
+						registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
+					}
+				}
+				
+				//not sure why this is here -- shiny HUD attachments maybe?  -- davep 5/11/2010
+				if (!is_alpha && te->getShiny() && LLPipeline::sRenderBump)
+				{
+					registerFace(group, facep, LLRenderPass::PASS_SHINY);
+				}
+			}
+			
+			//not sure why this is here, and looks like it might cause bump mapped objects to get rendered redundantly -- davep 5/11/2010
+			if (!is_alpha && !LLPipeline::sRenderDeferred)
+			{
+				llassert((mask & LLVertexBuffer::MAP_NORMAL) || fullbright);
+				facep->setPoolType((fullbright) ? LLDrawPool::POOL_FULLBRIGHT : LLDrawPool::POOL_SIMPLE);
+				
+				if (!force_simple && te->getBumpmap() && LLPipeline::sRenderBump)
+				{
+					registerFace(group, facep, LLRenderPass::PASS_BUMP);
+				}
+			}
+
+			if (!is_alpha && LLPipeline::sRenderGlow && te->getGlow() > 0.f)
+			{
+				registerFace(group, facep, LLRenderPass::PASS_GLOW);
+			}
+						
+			++face_iter;
+		}
+
+		buffer->setBuffer(0);
+	}
+
+	group->mBufferMap[mask].clear();
+	for (LLSpatialGroup::buffer_texture_map_t::iterator i = buffer_map[mask].begin(); i != buffer_map[mask].end(); ++i)
+	{
+		group->mBufferMap[mask][i->first] = i->second;
+	}
+}
+
+void LLGeometryManager::addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32 &index_count)
+{	
+	//initialize to default usage for this partition
+	U32 usage = group->mSpatialPartition->mBufferUsage;
+	
+	//clear off any old faces
+	mFaceList.clear();
+
+	//for each drawable
+	for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
+	{
+		LLDrawable* drawablep = *drawable_iter;
+		
+		if (drawablep->isDead())
+		{
+			continue;
+		}
+	
+		if (drawablep->isAnimating())
+		{ //fall back to stream draw for animating verts
+			usage = GL_STREAM_DRAW_ARB;
+		}
+
+		//for each face
+		for (S32 i = 0; i < drawablep->getNumFaces(); i++)
+		{
+			//sum up face verts and indices
+			drawablep->updateFaceSize(i);
+			LLFace* facep = drawablep->getFace(i);
+			if (facep->hasGeometry() && facep->getPixelArea() > FORCE_CULL_AREA)
+			{
+				vertex_count += facep->getGeomCount();
+				index_count += facep->getIndicesCount();
+				llassert(facep->getIndicesCount() < 65536);
+				//remember face (for sorting)
+				mFaceList.push_back(facep);
+			}
+			else
+			{
+				facep->clearVertexBuffer();
+			}
+		}
+	}
+	
+	group->mBufferUsage = usage;
+}
+
+LLHUDPartition::LLHUDPartition()
+{
+	mPartitionType = LLViewerRegion::PARTITION_HUD;
+	mDrawableType = LLPipeline::RENDER_TYPE_HUD;
+	mSlopRatio = 0.f;
+	mLODPeriod = 1;
+}
+
+void LLHUDPartition::shift(const LLVector4a &offset)
+{
+	//HUD objects don't shift with region crossing.  That would be silly.
+}
+
+
-- 
cgit v1.3


From f8d68b088782567c2b0023cf693896368d97babb Mon Sep 17 00:00:00 2001
From: "Nyx (Neal Orman)" <nyx@lindenlab.com>
Date: Fri, 26 Aug 2011 18:04:44 -0400
Subject: SH-862 FIX re-scaling render weight algorithm

We were double-counting the factor of scale both through
the streaming cost algorithm, as well as another multiplier
in the render cost algorithm. This caused objects at small scales
to have little cost difference regardless of amount of geometry,
due to minimum costs.

Eliminated extra scale factor, and instead scaled number of triangles
up by a constant factor to keep the balance between geometry and texture
costs sane.
---
 indra/newview/llvovolume.cpp | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index eac2f3d1b0..ddf7d9dd1d 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -3012,9 +3012,6 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	U32 produces_light = 0;
 	U32 media_faces = 0;
 
-	// these multipliers are variable and can be floating point
-	F32 scale = 0.f;
-
 	const LLDrawable* drawablep = mDrawable;
 	U32 num_faces = drawablep->getNumFaces();
 
@@ -3029,8 +3026,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 
 		if (weighted_triangles > 0.0)
 		{
-			num_triangles = (U32)(weighted_triangles * 2); // scale weighted triangles to match the recorded scale.
-															// a complex prim (tortured torus, sculptie) should be 1000-1200 points @ 5 m
+			num_triangles = (U32)(weighted_triangles); 
 		}
 	}
 
@@ -3091,12 +3087,6 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 		produces_light = 1;
 	}
 
-	const LLVector3& sc = getScale();
-	scale += (sc.mV[0] + sc.mV[1] + sc.mV[2]) / 4.f; // scale to 1/4 the sum of the size
-	// enforce scale multiplier to be in the range [1,7] (7 was determined to experimentally be a reasonable max)
-	scale = scale > 7.f ? 7.f : scale;
-	scale = scale < 1.f ? 1.f : scale;
-
 	for (S32 i = 0; i < num_faces; ++i)
 	{
 		const LLFace* face = drawablep->getFace(i);
@@ -3154,12 +3144,9 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
 	}
 
 	// shame currently has the "base" cost of 1 point per 15 triangles, min 2.
-	shame = num_triangles / 15.f;
+	shame = num_triangles  * 5.f;
 	shame = shame < 2.f ? 2.f : shame;
 
-	// factor in scale
-	shame *= scale;
-
 	// multiply by per-face modifiers
 	if (planar)
 	{
-- 
cgit v1.3


From 8cef480b96dc779c5879f74224fb0a185ee550f2 Mon Sep 17 00:00:00 2001
From: Xiaohong Bao <bao@lindenlab.com>
Date: Mon, 29 Aug 2011 18:15:38 -0600
Subject: fix for SH-2311: crash at LLVOVolume::lineSegmentIntersect line 3435
 and SH-2358: Crash in LLError::crashAndLoop: Invalid face index

---
 indra/llmath/llvolume.cpp    | 2 +-
 indra/newview/llvovolume.cpp | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp
index b2fe9ba6c2..1a95f9cd46 100755
--- a/indra/llmath/llvolume.cpp
+++ b/indra/llmath/llvolume.cpp
@@ -2734,7 +2734,7 @@ void LLVolume::cacheOptimize()
 
 S32	LLVolume::getNumFaces() const
 {
-	return (S32)mProfilep->mFaces.size();
+	return mIsMeshAssetLoaded ? getNumVolumeFaces() : (S32)mProfilep->mFaces.size();
 }
 
 
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index d3ef1771c3..6b0a5d8642 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -1660,11 +1660,16 @@ BOOL LLVOVolume::updateGeometry(LLDrawable *drawable)
 			compiled = TRUE;
 			sNumLODChanges += new_num_faces ;
 	
+			if((S32)getNumTEs() != getVolume()->getNumFaces())
+			{
+				setNumTEs(getVolume()->getNumFaces()); //mesh loading may change number of faces.
+			}
+
 			drawable->setState(LLDrawable::REBUILD_VOLUME); // for face->genVolumeTriangles()
 
 			{
 				LLFastTimer t(FTM_GEN_TRIANGLES);
-				if (new_num_faces != old_num_faces)
+				if (new_num_faces != old_num_faces || mNumFaces != (S32)getNumTEs())
 				{
 					regenFaces();
 				}
-- 
cgit v1.3


From 2091ce3ae745b15c979e78f853eb0d1777efff18 Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Wed, 21 Sep 2011 16:25:34 -0400
Subject: SH-2472 FIX - avoid accessing nonexistent texture entries in
 lineSegmentItersect

---
 indra/newview/llvovolume.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 mode change 100644 => 100755 indra/newview/llvovolume.cpp

(limited to 'indra/newview/llvovolume.cpp')

diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
old mode 100644
new mode 100755
index 6b0a5d8642..380d63c77b
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -3579,7 +3579,7 @@ BOOL LLVOVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& e
 		bool special_cursor = specialHoverCursor();
 		for (S32 i = start_face; i < end_face; ++i)
 		{
-			if (!special_cursor && !pick_transparent && getTE(i)->getColor().mV[3] == 0.f)
+			if (!special_cursor && !pick_transparent && getTE(i) && getTE(i)->getColor().mV[3] == 0.f)
 			{ //don't attempt to pick completely transparent faces unless
 				//pick_transparent is true
 				continue;
-- 
cgit v1.3