re-applying render cost changes for experimentations

6 files changed, 198 insertions, 97 deletions

diff --git a/indra/newview/llfloatertools.cpp b/indra/newview/llfloatertools.cpp
index bef830a93e..ceaf3c1449 100644
--- a/indra/newview/llfloatertools.cpp
+++ b/indra/newview/llfloatertools.cpp
@@ -476,7 +476,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);
 		}
 
@@ -1037,35 +1038,6 @@ void LLFloaterTools::onClickGridOptions()
 	//floaterp->addDependentFloater(LLFloaterBuildOptions::getInstance(), FALSE);
 }
 
-S32 LLFloaterTools::calcRenderCost()
-{
-       S32 cost = 0;
-       std::set<LLUUID> textures;
-
-       for (LLObjectSelection::iterator selection_iter = LLSelectMgr::getInstance()->getSelection()->begin();
-                 selection_iter != LLSelectMgr::getInstance()->getSelection()->end();
-                 ++selection_iter)
-       {
-               LLSelectNode *select_node = *selection_iter;
-               if (select_node)
-               {
-                       LLViewerObject *vobj = select_node->getObject();
-                       if (vobj->getVolume())
-                       {
-                               LLVOVolume* volume = (LLVOVolume*) vobj;
-
-                               cost += volume->getRenderCost(textures);
-							   cost += textures.size() * LLVOVolume::ARC_TEXTURE_COST;
-							   textures.clear();
-                       }
-               }
-       }
-
-
-       return cost;
-}
-
-
 // static
 void LLFloaterTools::setEditTool(void* tool_pointer)
 {
diff --git a/indra/newview/llfloatertools.h b/indra/newview/llfloatertools.h
index 87c3d2ab47..d5595445e0 100644
--- a/indra/newview/llfloatertools.h
+++ b/indra/newview/llfloatertools.h
@@ -114,7 +114,6 @@ private:
 	static bool multipleFacesSelectedConfirm(const LLSD& notification, const LLSD& response);
 	static void setObjectType( LLPCode pcode );
 	void onClickGridOptions();
-	S32 calcRenderCost();
 
 public:
 	LLButton		*mBtnFocus;
diff --git a/indra/newview/llselectmgr.cpp b/indra/newview/llselectmgr.cpp
index 93c9131424..90c2cf1eb4 100644
--- a/indra/newview/llselectmgr.cpp
+++ b/indra/newview/llselectmgr.cpp
@@ -6391,7 +6391,7 @@ U32 LLObjectSelection::getSelectedObjectTriangleCount()
 	return count;
 }
 
-/*S32 LLObjectSelection::getSelectedObjectRenderCost()
+S32 LLObjectSelection::getSelectedObjectRenderCost()
 {
        S32 cost = 0;
        LLVOVolume::texture_cost_t textures;
@@ -6415,7 +6415,7 @@ U32 LLObjectSelection::getSelectedObjectTriangleCount()
 
 
        return cost;
-}*/
+}
 
 
 //-----------------------------------------------------------------------------
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index a257703b24..950d050f26 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -8241,7 +8241,7 @@ void LLVOAvatar::getImpostorValues(LLVector4a* extents, LLVector3& angle, F32& d
 
 void LLVOAvatar::idleUpdateRenderCost()
 {
-	static const U32 ARC_BODY_PART_COST = 20;
+	static const U32 ARC_BODY_PART_COST = 200;
 	static const U32 ARC_LIMIT = 2048;
 
 	static std::set<LLUUID> all_textures;
@@ -8252,7 +8252,7 @@ void LLVOAvatar::idleUpdateRenderCost()
 	}
 
 	U32 cost = 0;
-	std::set<LLUUID> textures;
+	LLVOVolume::texture_cost_t textures;
 
 	for (U8 baked_index = 0; baked_index < BAKED_NUM_INDICES; baked_index++)
 	{
@@ -8293,15 +8293,21 @@ void LLVOAvatar::idleUpdateRenderCost()
 
 	}
 
+	for (LLVOVolume::texture_cost_t::iterator iter = textures.begin(); iter != textures.end(); ++iter)
+	{
+		// add the cost of each individual texture in the linkset
+		cost += iter->second;
+	}
+
 	// Diagnostic output to identify all avatar-related textures.
 	// Does not affect rendering cost calculation.
 	// Could be wrapped in a debug option if output becomes problematic.
 	if (isSelf())
 	{
 		// print any attachment textures we didn't already know about.
-		for (std::set<LLUUID>::iterator it = textures.begin(); it != textures.end(); ++it)
+		for (LLVOVolume::texture_cost_t::iterator it = textures.begin(); it != textures.end(); ++it)
 		{
-			LLUUID image_id = *it;
+			LLUUID image_id = it->first;
 			if( image_id.isNull() || image_id == IMG_DEFAULT || image_id == IMG_DEFAULT_AVATAR)
 				continue;
 			if (all_textures.find(image_id) == all_textures.end())
@@ -8333,8 +8339,6 @@ void LLVOAvatar::idleUpdateRenderCost()
 		}
 	}
 
-	cost += textures.size() * LLVOVolume::ARC_TEXTURE_COST;
-
 	setDebugText(llformat("%d", 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);
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()

diff --git a/indra/newview/llvovolume.h b/indra/newview/llvovolume.h
index 0c12f14832..e02a5d5675 100644
--- a/indra/newview/llvovolume.h
+++ b/indra/newview/llvovolume.h
@@ -129,7 +129,8 @@ public:
 	const LLMatrix4&	getRelativeXform() const				{ return mRelativeXform; }
 	const LLMatrix3&	getRelativeXformInvTrans() const		{ return mRelativeXformInvTrans; }
 	/*virtual*/	const LLMatrix4	getRenderMatrix() const;
-				U32 	getRenderCost(std::set<LLUUID> &textures) const;
+				typedef std::map<LLUUID, S32> texture_cost_t;
+				U32 	getRenderCost(texture_cost_t &textures) const;
 	/*virtual*/	F32		getStreamingCost();
 	/*virtual*/ U32		getTriangleCount() const;
 	/*virtual*/ BOOL lineSegmentIntersect(const LLVector3& start, const LLVector3& end, 
@@ -358,8 +359,6 @@ public:
 	static LLPointer<LLObjectMediaDataClient> sObjectMediaClient;
 	static LLPointer<LLObjectMediaNavigateClient> sObjectMediaNavigateClient;
 
-	static const U32 ARC_TEXTURE_COST = 5;
-
 protected:
 	static S32 sNumLODChanges;