From 3e80fa3dbc943de9b784fedc202ba38cf238f46d Mon Sep 17 00:00:00 2001
From: David Parks <davep@lindenlab.com>
Date: Mon, 2 Nov 2009 19:55:37 +0000
Subject: Sync up with render-pipeline-7 ignore-dead-branch

---
 indra/newview/llspatialpartition.cpp | 1 -
 1 file changed, 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 9f317803ce..9704fe71b7 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2294,7 +2294,6 @@ void pushVerts(LLFace* face, U32 mask)
 		U16 offset = face->getIndicesStart();
 		buffer->drawRange(LLRender::TRIANGLES, start, end, count, offset);
 	}
-
 }
 
 void pushBufferVerts(LLVertexBuffer* buffer, U32 mask)
-- 
cgit v1.2.3


From 095a5e84408b47ef3c5610e111aefe51d77633ca Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sat, 6 Feb 2010 17:33:12 -0600
Subject: Draw prims using triangle strips instead of triangle lists.

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

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 2a57d48f16..d6e9256fee 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3380,7 +3380,8 @@ LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset,
 	mVSize(0.f),
 	mGroup(NULL),
 	mFace(NULL),
-	mDistance(0.f)
+	mDistance(0.f),
+	mDrawMode(LLRender::TRIANGLES)
 {
 	mDebugColor = (rand() << 16) + rand();
 	if (mStart >= mVertexBuffer->getRequestedVerts() ||
-- 
cgit v1.2.3


From 4ffac619945cafc9c7da357bf56c9bc92e318b1b Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 4 Mar 2010 15:30:15 -0600
Subject: Optimiziation pass. Added RenderUseStreamVBO to enable/disable usage
 of VBO's for streaming buffers. Faster traversal of LLCullResult members.
 Removal of llpushcallstacks from inner loops. Sprinkling in fast timers.

---
 indra/newview/llspatialpartition.cpp | 73 ++++++++++++++++++++++++------------
 1 file changed, 49 insertions(+), 24 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 317b597a11..cf1e3bf186 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2,25 +2,31 @@
  * @file llspatialpartition.cpp
  * @brief LLSpatialGroup class implementation and supporting functions
  *
- * $LicenseInfo:firstyear=2003&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * $LicenseInfo:firstyear=2003&license=viewergpl$
+ * 
+ * Copyright (c) 2003-2009, 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.
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * 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.
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * 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
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
  * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 
@@ -294,7 +300,6 @@ LLSpatialGroup::~LLSpatialGroup()
 	}
 
 	delete [] mOcclusionVerts;
-	mOcclusionVerts = NULL;
 
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 	clearDrawMap();
@@ -1508,6 +1513,7 @@ void LLSpatialGroup::checkOcclusion()
 {
 	if (LLPipeline::sUseOcclusion > 1)
 	{
+		LLFastTimer t(FTM_OCCLUSION_READBACK);
 		LLSpatialGroup* parent = getParent();
 		if (parent && parent->isOcclusionState(LLSpatialGroup::OCCLUDED))
 		{	//if the parent has been marked as occluded, the child is implicitly occluded
@@ -1515,7 +1521,6 @@ void LLSpatialGroup::checkOcclusion()
 		}
 		else if (isOcclusionState(QUERY_PENDING))
 		{	//otherwise, if a query is pending, read it back
-			LLFastTimer t(FTM_OCCLUSION_READBACK);
 			GLuint res = 1;
 			if (!isOcclusionState(DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
 			{
@@ -3418,11 +3423,23 @@ LLCullResult::LLCullResult()
 void LLCullResult::clear()
 {
 	mVisibleGroupsSize = 0;
+	mVisibleGroupsEnd = mVisibleGroups.begin();
+
 	mAlphaGroupsSize = 0;
+	mAlphaGroupsEnd = mAlphaGroups.begin();
+
 	mOcclusionGroupsSize = 0;
+	mOcclusionGroupsEnd = mOcclusionGroups.begin();
+
 	mDrawableGroupsSize = 0;
+	mDrawableGroupsEnd = mDrawableGroups.begin();
+
 	mVisibleListSize = 0;
+	mVisibleListEnd = mVisibleList.begin();
+
 	mVisibleBridgeSize = 0;
+	mVisibleBridgeEnd = mVisibleBridge.begin();
+
 
 	for (U32 i = 0; i < LLRenderPass::NUM_RENDER_TYPES; i++)
 	{
@@ -3431,6 +3448,7 @@ void LLCullResult::clear()
 			mRenderMap[i][j] = 0;
 		}
 		mRenderMapSize[i] = 0;
+		mRenderMapEnd[i] = mRenderMap[i].begin();
 	}
 }
 
@@ -3441,7 +3459,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginVisibleGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endVisibleGroups()
 {
-	return mVisibleGroups.begin() + mVisibleGroupsSize;
+	return mVisibleGroupsEnd;
 }
 
 LLCullResult::sg_list_t::iterator LLCullResult::beginAlphaGroups()
@@ -3451,7 +3469,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginAlphaGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endAlphaGroups()
 {
-	return mAlphaGroups.begin() + mAlphaGroupsSize;
+	return mAlphaGroupsEnd;
 }
 
 LLCullResult::sg_list_t::iterator LLCullResult::beginOcclusionGroups()
@@ -3461,7 +3479,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginOcclusionGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endOcclusionGroups()
 {
-	return mOcclusionGroups.begin() + mOcclusionGroupsSize;
+	return mOcclusionGroupsEnd;
 }
 
 LLCullResult::sg_list_t::iterator LLCullResult::beginDrawableGroups()
@@ -3471,7 +3489,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginDrawableGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endDrawableGroups()
 {
-	return mDrawableGroups.begin() + mDrawableGroupsSize;
+	return mDrawableGroupsEnd;
 }
 
 LLCullResult::drawable_list_t::iterator LLCullResult::beginVisibleList()
@@ -3481,7 +3499,7 @@ LLCullResult::drawable_list_t::iterator LLCullResult::beginVisibleList()
 
 LLCullResult::drawable_list_t::iterator LLCullResult::endVisibleList()
 {
-	return mVisibleList.begin() + mVisibleListSize;
+	return mVisibleListEnd;
 }
 
 LLCullResult::bridge_list_t::iterator LLCullResult::beginVisibleBridge()
@@ -3491,7 +3509,7 @@ LLCullResult::bridge_list_t::iterator LLCullResult::beginVisibleBridge()
 
 LLCullResult::bridge_list_t::iterator LLCullResult::endVisibleBridge()
 {
-	return mVisibleBridge.begin() + mVisibleBridgeSize;
+	return mVisibleBridgeEnd;
 }
 
 LLCullResult::drawinfo_list_t::iterator LLCullResult::beginRenderMap(U32 type)
@@ -3501,7 +3519,7 @@ LLCullResult::drawinfo_list_t::iterator LLCullResult::beginRenderMap(U32 type)
 
 LLCullResult::drawinfo_list_t::iterator LLCullResult::endRenderMap(U32 type)
 {
-	return mRenderMap[type].begin() + mRenderMapSize[type];
+	return mRenderMapEnd[type];
 }
 
 void LLCullResult::pushVisibleGroup(LLSpatialGroup* group)
@@ -3515,6 +3533,7 @@ void LLCullResult::pushVisibleGroup(LLSpatialGroup* group)
 		mVisibleGroups.push_back(group);
 	}
 	++mVisibleGroupsSize;
+	mVisibleGroupsEnd = mVisibleGroups.begin()+mVisibleGroupsSize;
 }
 
 void LLCullResult::pushAlphaGroup(LLSpatialGroup* group)
@@ -3528,6 +3547,7 @@ void LLCullResult::pushAlphaGroup(LLSpatialGroup* group)
 		mAlphaGroups.push_back(group);
 	}
 	++mAlphaGroupsSize;
+	mAlphaGroupsEnd = mAlphaGroups.begin()+mAlphaGroupsSize;
 }
 
 void LLCullResult::pushOcclusionGroup(LLSpatialGroup* group)
@@ -3541,6 +3561,7 @@ void LLCullResult::pushOcclusionGroup(LLSpatialGroup* group)
 		mOcclusionGroups.push_back(group);
 	}
 	++mOcclusionGroupsSize;
+	mOcclusionGroupsEnd = mOcclusionGroups.begin()+mOcclusionGroupsSize;
 }
 
 void LLCullResult::pushDrawableGroup(LLSpatialGroup* group)
@@ -3554,6 +3575,7 @@ void LLCullResult::pushDrawableGroup(LLSpatialGroup* group)
 		mDrawableGroups.push_back(group);
 	}
 	++mDrawableGroupsSize;
+	mDrawableGroupsEnd = mDrawableGroups.begin()+mDrawableGroupsSize;
 }
 
 void LLCullResult::pushDrawable(LLDrawable* drawable)
@@ -3567,6 +3589,7 @@ void LLCullResult::pushDrawable(LLDrawable* drawable)
 		mVisibleList.push_back(drawable);
 	}
 	++mVisibleListSize;
+	mVisibleListEnd = mVisibleList.begin()+mVisibleListSize;
 }
 
 void LLCullResult::pushBridge(LLSpatialBridge* bridge)
@@ -3580,6 +3603,7 @@ void LLCullResult::pushBridge(LLSpatialBridge* bridge)
 		mVisibleBridge.push_back(bridge);
 	}
 	++mVisibleBridgeSize;
+	mVisibleBridgeEnd = mVisibleBridge.begin()+mVisibleBridgeSize;
 }
 
 void LLCullResult::pushDrawInfo(U32 type, LLDrawInfo* draw_info)
@@ -3593,6 +3617,7 @@ void LLCullResult::pushDrawInfo(U32 type, LLDrawInfo* draw_info)
 		mRenderMap[type].push_back(draw_info);
 	}
 	++mRenderMapSize[type];
+	mRenderMapEnd[type] = mRenderMap[type].begin() + mRenderMapSize[type];
 }
 
 
-- 
cgit v1.2.3


From ea6397fe4990b73e190391d61781c609fbd1f8c1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 4 Mar 2010 15:30:15 -0600
Subject: Optimiziation pass. Added RenderUseStreamVBO to enable/disable usage
 of VBO's for streaming buffers. Faster traversal of LLCullResult members.
 Removal of llpushcallstacks from inner loops. Sprinkling in fast timers.

---
 indra/newview/llspatialpartition.cpp | 36 ++++++++++++++++++++++++++++--------
 1 file changed, 28 insertions(+), 8 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 19bf40b56a..3742f70df5 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1513,6 +1513,7 @@ void LLSpatialGroup::checkOcclusion()
 {
 	if (LLPipeline::sUseOcclusion > 1)
 	{
+		LLFastTimer t(FTM_OCCLUSION_READBACK);
 		LLSpatialGroup* parent = getParent();
 		if (parent && parent->isOcclusionState(LLSpatialGroup::OCCLUDED))
 		{	//if the parent has been marked as occluded, the child is implicitly occluded
@@ -1520,7 +1521,6 @@ void LLSpatialGroup::checkOcclusion()
 		}
 		else if (isOcclusionState(QUERY_PENDING))
 		{	//otherwise, if a query is pending, read it back
-			LLFastTimer t(FTM_OCCLUSION_READBACK);
 			GLuint res = 1;
 			if (!isOcclusionState(DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
 			{
@@ -3422,11 +3422,23 @@ LLCullResult::LLCullResult()
 void LLCullResult::clear()
 {
 	mVisibleGroupsSize = 0;
+	mVisibleGroupsEnd = mVisibleGroups.begin();
+
 	mAlphaGroupsSize = 0;
+	mAlphaGroupsEnd = mAlphaGroups.begin();
+
 	mOcclusionGroupsSize = 0;
+	mOcclusionGroupsEnd = mOcclusionGroups.begin();
+
 	mDrawableGroupsSize = 0;
+	mDrawableGroupsEnd = mDrawableGroups.begin();
+
 	mVisibleListSize = 0;
+	mVisibleListEnd = mVisibleList.begin();
+
 	mVisibleBridgeSize = 0;
+	mVisibleBridgeEnd = mVisibleBridge.begin();
+
 
 	for (U32 i = 0; i < LLRenderPass::NUM_RENDER_TYPES; i++)
 	{
@@ -3435,6 +3447,7 @@ void LLCullResult::clear()
 			mRenderMap[i][j] = 0;
 		}
 		mRenderMapSize[i] = 0;
+		mRenderMapEnd[i] = mRenderMap[i].begin();
 	}
 }
 
@@ -3445,7 +3458,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginVisibleGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endVisibleGroups()
 {
-	return mVisibleGroups.begin() + mVisibleGroupsSize;
+	return mVisibleGroupsEnd;
 }
 
 LLCullResult::sg_list_t::iterator LLCullResult::beginAlphaGroups()
@@ -3455,7 +3468,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginAlphaGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endAlphaGroups()
 {
-	return mAlphaGroups.begin() + mAlphaGroupsSize;
+	return mAlphaGroupsEnd;
 }
 
 LLCullResult::sg_list_t::iterator LLCullResult::beginOcclusionGroups()
@@ -3465,7 +3478,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginOcclusionGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endOcclusionGroups()
 {
-	return mOcclusionGroups.begin() + mOcclusionGroupsSize;
+	return mOcclusionGroupsEnd;
 }
 
 LLCullResult::sg_list_t::iterator LLCullResult::beginDrawableGroups()
@@ -3475,7 +3488,7 @@ LLCullResult::sg_list_t::iterator LLCullResult::beginDrawableGroups()
 
 LLCullResult::sg_list_t::iterator LLCullResult::endDrawableGroups()
 {
-	return mDrawableGroups.begin() + mDrawableGroupsSize;
+	return mDrawableGroupsEnd;
 }
 
 LLCullResult::drawable_list_t::iterator LLCullResult::beginVisibleList()
@@ -3485,7 +3498,7 @@ LLCullResult::drawable_list_t::iterator LLCullResult::beginVisibleList()
 
 LLCullResult::drawable_list_t::iterator LLCullResult::endVisibleList()
 {
-	return mVisibleList.begin() + mVisibleListSize;
+	return mVisibleListEnd;
 }
 
 LLCullResult::bridge_list_t::iterator LLCullResult::beginVisibleBridge()
@@ -3495,7 +3508,7 @@ LLCullResult::bridge_list_t::iterator LLCullResult::beginVisibleBridge()
 
 LLCullResult::bridge_list_t::iterator LLCullResult::endVisibleBridge()
 {
-	return mVisibleBridge.begin() + mVisibleBridgeSize;
+	return mVisibleBridgeEnd;
 }
 
 LLCullResult::drawinfo_list_t::iterator LLCullResult::beginRenderMap(U32 type)
@@ -3505,7 +3518,7 @@ LLCullResult::drawinfo_list_t::iterator LLCullResult::beginRenderMap(U32 type)
 
 LLCullResult::drawinfo_list_t::iterator LLCullResult::endRenderMap(U32 type)
 {
-	return mRenderMap[type].begin() + mRenderMapSize[type];
+	return mRenderMapEnd[type];
 }
 
 void LLCullResult::pushVisibleGroup(LLSpatialGroup* group)
@@ -3519,6 +3532,7 @@ void LLCullResult::pushVisibleGroup(LLSpatialGroup* group)
 		mVisibleGroups.push_back(group);
 	}
 	++mVisibleGroupsSize;
+	mVisibleGroupsEnd = mVisibleGroups.begin()+mVisibleGroupsSize;
 }
 
 void LLCullResult::pushAlphaGroup(LLSpatialGroup* group)
@@ -3532,6 +3546,7 @@ void LLCullResult::pushAlphaGroup(LLSpatialGroup* group)
 		mAlphaGroups.push_back(group);
 	}
 	++mAlphaGroupsSize;
+	mAlphaGroupsEnd = mAlphaGroups.begin()+mAlphaGroupsSize;
 }
 
 void LLCullResult::pushOcclusionGroup(LLSpatialGroup* group)
@@ -3545,6 +3560,7 @@ void LLCullResult::pushOcclusionGroup(LLSpatialGroup* group)
 		mOcclusionGroups.push_back(group);
 	}
 	++mOcclusionGroupsSize;
+	mOcclusionGroupsEnd = mOcclusionGroups.begin()+mOcclusionGroupsSize;
 }
 
 void LLCullResult::pushDrawableGroup(LLSpatialGroup* group)
@@ -3558,6 +3574,7 @@ void LLCullResult::pushDrawableGroup(LLSpatialGroup* group)
 		mDrawableGroups.push_back(group);
 	}
 	++mDrawableGroupsSize;
+	mDrawableGroupsEnd = mDrawableGroups.begin()+mDrawableGroupsSize;
 }
 
 void LLCullResult::pushDrawable(LLDrawable* drawable)
@@ -3571,6 +3588,7 @@ void LLCullResult::pushDrawable(LLDrawable* drawable)
 		mVisibleList.push_back(drawable);
 	}
 	++mVisibleListSize;
+	mVisibleListEnd = mVisibleList.begin()+mVisibleListSize;
 }
 
 void LLCullResult::pushBridge(LLSpatialBridge* bridge)
@@ -3584,6 +3602,7 @@ void LLCullResult::pushBridge(LLSpatialBridge* bridge)
 		mVisibleBridge.push_back(bridge);
 	}
 	++mVisibleBridgeSize;
+	mVisibleBridgeEnd = mVisibleBridge.begin()+mVisibleBridgeSize;
 }
 
 void LLCullResult::pushDrawInfo(U32 type, LLDrawInfo* draw_info)
@@ -3597,6 +3616,7 @@ void LLCullResult::pushDrawInfo(U32 type, LLDrawInfo* draw_info)
 		mRenderMap[type].push_back(draw_info);
 	}
 	++mRenderMapSize[type];
+	mRenderMapEnd[type] = mRenderMap[type].begin() + mRenderMapSize[type];
 }
 
 
-- 
cgit v1.2.3


From 1df3e85d2d73820a3129ebeb1a3e4c88338e5a93 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 8 Apr 2010 20:42:55 -0500
Subject: Total fix for shadows going wonky at altitude.

---
 indra/newview/llspatialpartition.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 3742f70df5..77c38798d1 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1924,11 +1924,8 @@ public:
 			return;
 		}
 		
-		if (mRes == 2)
-		{
-			//fully in, don't traverse further (won't effect extents
-		}
-		else if (mRes && group->isState(LLSpatialGroup::SKIP_FRUSTUM_CHECK))
+		if ((mRes && group->isState(LLSpatialGroup::SKIP_FRUSTUM_CHECK)) ||
+			mRes == 2)
 		{	//don't need to do frustum check
 			LLSpatialGroup::OctreeTraveler::traverse(n);
 		}
-- 
cgit v1.2.3


From 53e791b299d51df3891a177b52dc5e1dc5dc5825 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 8 Apr 2010 20:42:55 -0500
Subject: Total fix for shadows going wonky at altitude.

---
 indra/newview/llspatialpartition.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index cf1e3bf186..c229657ded 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1924,11 +1924,8 @@ public:
 			return;
 		}
 		
-		if (mRes == 2)
-		{
-			//fully in, don't traverse further (won't effect extents
-		}
-		else if (mRes && group->isState(LLSpatialGroup::SKIP_FRUSTUM_CHECK))
+		if ((mRes && group->isState(LLSpatialGroup::SKIP_FRUSTUM_CHECK)) ||
+			mRes == 2)
 		{	//don't need to do frustum check
 			LLSpatialGroup::OctreeTraveler::traverse(n);
 		}
-- 
cgit v1.2.3


From 44e9e6d2310c598011d7af59ced43f32abbf68b0 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sat, 8 May 2010 16:10:05 -0500
Subject: Physics shape fetching.

---
 indra/newview/llspatialpartition.cpp | 49 +++++++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 77c38798d1..6787018f5a 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -44,6 +44,7 @@
 #include "llviewerregion.h"
 #include "llcamera.h"
 #include "pipeline.h"
+#include "llmeshrepository.h"
 #include "llrender.h"
 #include "lloctree.h"
 #include "llvoavatar.h"
@@ -2658,6 +2659,46 @@ void renderBoundingBox(LLDrawable* drawable, BOOL set_color = TRUE)
 	
 }
 
+void renderPhysicsShape(LLDrawable* drawable)
+{
+	LLVOVolume* volume = drawable->getVOVolume();
+	if (volume)
+	{
+		if (volume->isMesh())
+		{
+			LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
+			const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
+			if (decomp)
+			{
+				gGL.pushMatrix();
+				glLoadMatrixd(gGLModelView);
+				gGL.flush();
+				glPointSize(4.f);
+				gGL.begin(LLRender::POINTS);
+				static std::vector<LLColor4U> color;
+
+				for (U32 i = 0; i < decomp->mHull.size(); ++i)
+				{
+					if (color.size() <= i)
+					{
+						color.push_back(LLColor4U(rand()%128+127, rand()%128+127, rand()%128+127));
+					}
+					gGL.color4ubv(color[i].mV);
+					for (U32 j = 0; j < decomp->mHull[i].size(); ++j)
+					{
+						LLVector3 v = volume->volumePositionToAgent(decomp->mHull[i][j]);
+						gGL.vertex3fv(v.mV);
+					}
+				}
+				gGL.end();
+				gGL.flush();
+				gGL.popMatrix();
+				glPointSize(1.f);
+			}
+		}
+	}
+}
+
 void renderTexturePriority(LLDrawable* drawable)
 {
 	for (int face=0; face<drawable->getNumFaces(); ++face)
@@ -2974,6 +3015,11 @@ public:
 				renderBoundingBox(drawable);			
 			}
 			
+			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_PHYSICS_SHAPES))
+			{
+				renderPhysicsShape(drawable);
+			}
+
 			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_BUILD_QUEUE))
 			{
 				if (drawable->isState(LLDrawable::IN_REBUILD_Q2))
@@ -3173,7 +3219,8 @@ void LLSpatialPartition::renderDebug()
 									  LLPipeline::RENDER_DEBUG_AVATAR_VOLUME |
 									  LLPipeline::RENDER_DEBUG_AGENT_TARGET |
 									  LLPipeline::RENDER_DEBUG_BUILD_QUEUE |
-									  LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA)) 
+									  LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA |
+									  LLPipeline::RENDER_DEBUG_PHYSICS_SHAPES)) 
 	{
 		return;
 	}
-- 
cgit v1.2.3


From b2906b594470ced996f102f4797eef7671ad009c Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 12 May 2010 17:17:39 -0500
Subject: Moved LLPhysicsDecomp to llmeshrepository. Better convex hull
 visualization.

---
 indra/newview/llspatialpartition.cpp | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 6787018f5a..ed99f8648f 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2671,10 +2671,8 @@ void renderPhysicsShape(LLDrawable* drawable)
 			if (decomp)
 			{
 				gGL.pushMatrix();
-				glLoadMatrixd(gGLModelView);
-				gGL.flush();
-				glPointSize(4.f);
-				gGL.begin(LLRender::POINTS);
+				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+				glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
 				static std::vector<LLColor4U> color;
 
 				for (U32 i = 0; i < decomp->mHull.size(); ++i)
@@ -2683,17 +2681,15 @@ void renderPhysicsShape(LLDrawable* drawable)
 					{
 						color.push_back(LLColor4U(rand()%128+127, rand()%128+127, rand()%128+127));
 					}
-					gGL.color4ubv(color[i].mV);
-					for (U32 j = 0; j < decomp->mHull[i].size(); ++j)
-					{
-						LLVector3 v = volume->volumePositionToAgent(decomp->mHull[i][j]);
-						gGL.vertex3fv(v.mV);
-					}
+					glColor4ubv(color[i].mV);
+
+					LLVertexBuffer* buff = decomp->mMesh;
+
+					buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
+					buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 				}
-				gGL.end();
-				gGL.flush();
+				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 				gGL.popMatrix();
-				glPointSize(1.f);
 			}
 		}
 	}
-- 
cgit v1.2.3


From 65acaab16ffaa4cc6bed0934973ead659df20741 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 13 May 2010 01:31:45 -0500
Subject: working inworld vis

---
 indra/newview/llspatialpartition.cpp | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index ed99f8648f..025c5084c3 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2671,24 +2671,36 @@ void renderPhysicsShape(LLDrawable* drawable)
 			if (decomp)
 			{
 				gGL.pushMatrix();
-				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 				glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
 				static std::vector<LLColor4U> color;
 
+				gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
 				for (U32 i = 0; i < decomp->mHull.size(); ++i)
 				{
 					if (color.size() <= i)
 					{
-						color.push_back(LLColor4U(rand()%128+127, rand()%128+127, rand()%128+127));
+						color.push_back(LLColor4U(rand()%128+127, rand()%128+127, rand()%128+127, 255));
 					}
-					glColor4ubv(color[i].mV);
-
-					LLVertexBuffer* buff = decomp->mMesh;
+					
+					LLVertexBuffer* buff = decomp->mMesh[i];
 
 					buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
+
+					glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+					glColor4ubv(color[i].mV);
 					buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+					glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+					{
+						LLGLEnable blend(GL_BLEND);
+						gGL.setSceneBlendType(LLRender::BT_ALPHA);
+						LLGLDepthTest depth(GL_TRUE, GL_FALSE);
+						glColor4ub(color[i].mV[0], color[i].mV[1], color[i].mV[2], 64);
+						buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+					}
 				}
-				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
 				gGL.popMatrix();
 			}
 		}
-- 
cgit v1.2.3


From d334a9e645ab14c2822f35ee67d2c1e0f2a646a6 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 13 May 2010 14:54:56 -0500
Subject: Vis that works and first pass at fetching prim cost.

---
 indra/newview/llspatialpartition.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 025c5084c3..f11195303e 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2670,6 +2670,11 @@ void renderPhysicsShape(LLDrawable* drawable)
 			const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
 			if (decomp)
 			{
+				if (volume->getObjectCost() == -1)
+				{
+					gObjectList.updateObjectCost(volume);
+				}
+
 				gGL.pushMatrix();
 				glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
 				static std::vector<LLColor4U> color;
@@ -2688,7 +2693,7 @@ void renderPhysicsShape(LLDrawable* drawable)
 					buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
 
 					glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-					glColor4ubv(color[i].mV);
+					glColor3ub(color[i].mV[0], color[i].mV[1], color[i].mV[2]);
 					buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 					glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
-- 
cgit v1.2.3


From 246dd9c168550bfe4b1b71bba75f5af9456e86dd Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sat, 15 May 2010 02:45:58 -0500
Subject: Highlight for object cost and proper retrieval/display of prim object
 cost and linkset cost.

---
 indra/newview/llspatialpartition.cpp | 51 ++++++++++++++++++++++++------------
 1 file changed, 34 insertions(+), 17 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index f11195303e..1290e6b9a6 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2294,6 +2294,14 @@ void pushVerts(LLFace* face, U32 mask)
 	}
 }
 
+void pushVerts(LLDrawable* drawable, U32 mask)
+{
+	for (S32 i = 0; i < drawable->getNumFaces(); ++i)
+	{
+		pushVerts(drawable->getFace(i), mask);
+	}
+}
+
 void pushBufferVerts(LLVertexBuffer* buffer, U32 mask)
 {
 	if (buffer)
@@ -2664,36 +2672,35 @@ void renderPhysicsShape(LLDrawable* drawable)
 	LLVOVolume* volume = drawable->getVOVolume();
 	if (volume)
 	{
+		F32 threshold = gSavedSettings.getF32("ObjectCostHighThreshold");
+		F32 cost = volume->getObjectCost();
+
+		LLColor4 low = gSavedSettings.getColor4("ObjectCostLowColor");
+		LLColor4 high = gSavedSettings.getColor4("ObjectCostHighColor");
+
+		LLColor4 color = lerp(low, high, cost/threshold);
+
+		U32 data_mask = LLVertexBuffer::MAP_VERTEX;
+
 		if (volume->isMesh())
-		{
+		{			
 			LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
 			const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
 			if (decomp)
 			{
-				if (volume->getObjectCost() == -1)
-				{
-					gObjectList.updateObjectCost(volume);
-				}
-
 				gGL.pushMatrix();
 				glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
-				static std::vector<LLColor4U> color;
-
+				
 				gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
 				for (U32 i = 0; i < decomp->mHull.size(); ++i)
-				{
-					if (color.size() <= i)
-					{
-						color.push_back(LLColor4U(rand()%128+127, rand()%128+127, rand()%128+127, 255));
-					}
-					
+				{		
 					LLVertexBuffer* buff = decomp->mMesh[i];
 
-					buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
+					buff->setBuffer(data_mask);
 
 					glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-					glColor3ub(color[i].mV[0], color[i].mV[1], color[i].mV[2]);
+					glColor3fv(color.mV);
 					buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 					glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
@@ -2701,14 +2708,24 @@ void renderPhysicsShape(LLDrawable* drawable)
 						LLGLEnable blend(GL_BLEND);
 						gGL.setSceneBlendType(LLRender::BT_ALPHA);
 						LLGLDepthTest depth(GL_TRUE, GL_FALSE);
-						glColor4ub(color[i].mV[0], color[i].mV[1], color[i].mV[2], 64);
+						glColor4fv(color.mV);
 						buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 					}
 				}
 
 				gGL.popMatrix();
+
+				return;
 			}
 		}
+
+		//push faces
+		glColor3fv(color.mV);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+		pushVerts(drawable, data_mask);
+		glColor4fv(color.mV);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+		pushVerts(drawable, data_mask);
 	}
 }
 
-- 
cgit v1.2.3


From 1d92a950df91d7e6d3a34e925f445bc389a3fa93 Mon Sep 17 00:00:00 2001
From: "Matthew Breindel (Falcon)" <falcon@lindenlab.com>
Date: Tue, 18 May 2010 11:26:53 -0700
Subject: Modified color scheme for visualization of physics reps.

---
 indra/newview/llspatialpartition.cpp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 1290e6b9a6..9bfc12c7ab 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2676,9 +2676,20 @@ void renderPhysicsShape(LLDrawable* drawable)
 		F32 cost = volume->getObjectCost();
 
 		LLColor4 low = gSavedSettings.getColor4("ObjectCostLowColor");
+		LLColor4 mid = gSavedSettings.getColor4("ObjectCostMidColor");
 		LLColor4 high = gSavedSettings.getColor4("ObjectCostHighColor");
 
-		LLColor4 color = lerp(low, high, cost/threshold);
+		F32 normalizedCost = 1.f - exp( -(cost / threshold) );
+
+		LLColor4 color;
+		if ( normalizedCost <= 0.5f )
+		{
+			color = lerp( low, mid, 2.f * normalizedCost );
+		}
+		else
+		{
+			color = lerp( mid, high, 2.f * ( normalizedCost - 0.5f ) );
+		}
 
 		U32 data_mask = LLVertexBuffer::MAP_VERTEX;
 
-- 
cgit v1.2.3


From 7eba473723a260a1025b5a865715573b2369298e Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 24 May 2010 14:01:18 -0500
Subject: Fix for bad indexes on cube faces. Extra validation on vertex
 buffers.

---
 indra/newview/llspatialpartition.cpp | 66 +++++-------------------------------
 1 file changed, 9 insertions(+), 57 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 77c38798d1..470c332b42 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -512,50 +512,6 @@ void LLSpatialGroup::checkStates()
 #endif
 }
 
-void validate_draw_info(LLDrawInfo& params)
-{
-#if LL_OCTREE_PARANOIA_CHECK
-	if (params.mVertexBuffer.isNull())
-	{
-		llerrs << "Draw batch has no vertex buffer." << llendl;
-	}
-	
-	//bad range
-	if (params.mStart >= params.mEnd)
-	{
-		llerrs << "Draw batch has invalid range." << llendl;
-	}
-	
-	if (params.mEnd >= (U32) params.mVertexBuffer->getNumVerts())
-	{
-		llerrs << "Draw batch has buffer overrun error." << llendl;
-	}
-	
-	if (params.mOffset + params.mCount > (U32) params.mVertexBuffer->getNumIndices())
-	{
-		llerrs << "Draw batch has index buffer ovverrun error." << llendl;
-	}
-	
-	//bad indices
-	U16* indicesp = (U16*) params.mVertexBuffer->getIndicesPointer();
-	if (indicesp)
-	{
-		for (U32 i = params.mOffset; i < params.mOffset+params.mCount; i++)
-		{
-			if (indicesp[i] < (U16)params.mStart)
-			{
-				llerrs << "Draw batch has vertex buffer index out of range error (index too low)." << llendl;
-			}
-			
-			if (indicesp[i] > (U16)params.mEnd)
-			{
-				llerrs << "Draw batch has vertex buffer index out of range error (index too high)." << llendl;
-			}
-		}
-	}
-#endif
-}
-
 void LLSpatialGroup::validateDrawMap()
 {
 #if LL_OCTREE_PARANOIA_CHECK
@@ -565,8 +521,8 @@ void LLSpatialGroup::validateDrawMap()
 		for (drawmap_elem_t::iterator j = draw_vec.begin(); j != draw_vec.end(); ++j)
 		{
 			LLDrawInfo& params = **j;
-			
-			validate_draw_info(params);
+		
+			params.validate();
 		}
 	}
 #endif
@@ -3379,18 +3335,9 @@ LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset,
 	mDistance(0.f),
 	mDrawMode(LLRender::TRIANGLES)
 {
-	mDebugColor = (rand() << 16) + rand();
-	if (mStart >= mVertexBuffer->getRequestedVerts() ||
-		mEnd >= mVertexBuffer->getRequestedVerts())
-	{
-		llerrs << "Invalid draw info vertex range." << llendl;
-	}
+	mVertexBuffer->validateRange(mStart, mEnd, mCount, mOffset);
 
-	if (mOffset >= (U32) mVertexBuffer->getRequestedIndices() ||
-		mOffset + mCount > (U32) mVertexBuffer->getRequestedIndices())
-	{
-		llerrs << "Invalid draw info index range." << llendl;
-	}
+	mDebugColor = (rand() << 16) + rand();
 }
 
 LLDrawInfo::~LLDrawInfo()	
@@ -3406,6 +3353,11 @@ LLDrawInfo::~LLDrawInfo()
 	}
 }
 
+void LLDrawInfo::validate()
+{
+	mVertexBuffer->validateRange(mStart, mEnd, mCount, mOffset);
+}
+
 LLVertexBuffer* LLGeometryManager::createVertexBuffer(U32 type_mask, U32 usage)
 {
 	return new LLVertexBuffer(type_mask, usage);
-- 
cgit v1.2.3


From 0e7f4dc5cef8a97cb1dd08aa2f79538ced267888 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sat, 29 May 2010 05:37:38 -0500
Subject: Octree per LLVolumeFace WIP

---
 indra/newview/llspatialpartition.cpp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 470c332b42..60e704d360 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2769,6 +2769,19 @@ void renderLights(LLDrawable* drawablep)
 	}
 }
 
+class LLRenderOctree : public LLOctreeTraveler<LLVolumeFace::Triangle>
+{
+public:
+	void visit(const LLOctreeNode<LLVolumeFace::Triangle>* branch)
+	{
+		const LLVector3d& c = branch->getCenter();
+		const LLVector3d& s = branch->getSize();
+
+		LLVector3 pos((F32) c.mdV[0], (F32) c.mdV[1], (F32) c.mdV[2]);
+		LLVector3 size((F32) s.mdV[0], (F32) s.mdV[1], (F32) s.mdV[2]);
+		drawBoxOutline(pos, size);
+	}
+};
 
 void renderRaycast(LLDrawable* drawablep)
 {
@@ -2787,6 +2800,23 @@ void renderRaycast(LLDrawable* drawablep)
 			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 			pushVerts(drawablep->getFace(gDebugRaycastFaceHit), LLVertexBuffer::MAP_VERTEX);
 			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+			LLVOVolume* vobj = drawablep->getVOVolume();
+			LLVolume* volume = vobj->getVolume();
+			if (volume && volume->getNumVolumeFaces() > gDebugRaycastFaceHit)
+			{
+				const LLVolumeFace& face = volume->getVolumeFace(gDebugRaycastFaceHit);
+				if (!face.mOctree)
+				{
+					((LLVolumeFace*) &face)->createOctree(); 
+				}
+
+				gGL.pushMatrix();
+				glMultMatrixf((F32*) vobj->getRelativeXform().mMatrix);
+				LLRenderOctree render;
+				render.traverse(face.mOctree);
+				gGL.popMatrix();		
+			}
 		}
 		else if (drawablep->isAvatar())
 		{
-- 
cgit v1.2.3


From 9a869d630162292864e01fdd1707efc609fbd6b4 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sat, 29 May 2010 19:55:13 -0500
Subject: Octree triven raycast works, time to profile.

---
 indra/newview/llspatialpartition.cpp | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 60e704d360..355173772b 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -38,6 +38,7 @@
 #include "llviewerobjectlist.h"
 #include "llvovolume.h"
 #include "llvolume.h"
+#include "llvolumeoctree.h"
 #include "llviewercamera.h"
 #include "llface.h"
 #include "llviewercontrol.h"
@@ -2769,17 +2770,26 @@ void renderLights(LLDrawable* drawablep)
 	}
 }
 
-class LLRenderOctree : public LLOctreeTraveler<LLVolumeFace::Triangle>
+class LLRenderOctreeRaycast : public LLOctreeTriangleRayIntersect
 {
 public:
+	
+	LLRenderOctreeRaycast(const LLVector3& start, const LLVector3& end)
+	{
+		mStart.load3(start.mV);
+		mEnd.load3(end.mV);
+		mDir.setSub(mEnd, mStart);
+	}
+
 	void visit(const LLOctreeNode<LLVolumeFace::Triangle>* branch)
 	{
-		const LLVector3d& c = branch->getCenter();
-		const LLVector3d& s = branch->getSize();
+		LLVolumeOctreeListener* vl = (LLVolumeOctreeListener*) branch->getListener(0);
 
-		LLVector3 pos((F32) c.mdV[0], (F32) c.mdV[1], (F32) c.mdV[2]);
-		LLVector3 size((F32) s.mdV[0], (F32) s.mdV[1], (F32) s.mdV[2]);
-		drawBoxOutline(pos, size);
+		LLVector3 center, size;
+		center.set(vl->mBounds[0].getF32());
+		size.set(vl->mBounds[1].getF32());
+
+		drawBoxOutline(center, size);
 	}
 };
 
@@ -2813,7 +2823,11 @@ void renderRaycast(LLDrawable* drawablep)
 
 				gGL.pushMatrix();
 				glMultMatrixf((F32*) vobj->getRelativeXform().mMatrix);
-				LLRenderOctree render;
+				LLVector3 start, end;
+				start = vobj->agentPositionToVolume(gDebugRaycastStart);
+				end = vobj->agentPositionToVolume(gDebugRaycastEnd);
+
+				LLRenderOctreeRaycast render(start, end);
 				render.traverse(face.mOctree);
 				gGL.popMatrix();		
 			}
-- 
cgit v1.2.3


From 26ba00b5554d20ee958693ced87b36fa7f6e3d99 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 3 Jun 2010 12:52:28 -0500
Subject: Vectorized octree and much of llspatialpartition and lldrawable.
 Octree driven raycast.

---
 indra/newview/llspatialpartition.cpp | 520 ++++++++++++++++++++++-------------
 1 file changed, 324 insertions(+), 196 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 355173772b..3cf0138303 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -102,23 +102,6 @@ void sg_assert(BOOL expr)
 #endif
 }
 
-#if LL_DEBUG
-void validate_drawable(LLDrawable* drawablep)
-{
-	F64 rad = drawablep->getBinRadius();
-	const LLVector3* ext = drawablep->getSpatialExtents();
-
-	if (rad < 0 || rad > 4096 ||
-		(ext[1]-ext[0]).magVec() > 4096)
-	{
-		llwarns << "Invalid drawable found in octree." << llendl;
-	}
-}
-#else
-#define validate_drawable(x)
-#endif
-
-
 S32 AABBSphereIntersect(const LLVector3& min, const LLVector3& max, const LLVector3 &origin, const F32 &rad)
 {
 	return AABBSphereIntersectR2(min, max, origin, rad*rad);
@@ -158,6 +141,55 @@ S32 AABBSphereIntersectR2(const LLVector3& min, const LLVector3& max, const LLVe
 }
 
 
+S32 AABBSphereIntersect(const LLVector4a& min, const LLVector4a& max, const LLVector3 &origin, const F32 &rad)
+{
+	return AABBSphereIntersectR2(min, max, origin, rad*rad);
+}
+
+S32 AABBSphereIntersectR2(const LLVector4a& min, const LLVector4a& max, const LLVector3 &origin, const F32 &r)
+{
+	F32 d = 0.f;
+	F32 t;
+	
+	LLVector4a origina;
+	origina.load3(origin.mV);
+
+	LLVector4a v;
+	v.setSub(min, origina);
+	
+	if (v.dot3(v) < r)
+	{
+		v.setSub(max, origina);
+		if (v.dot3(v) < r)
+		{
+			return 2;
+		}
+	}
+
+
+	for (U32 i = 0; i < 3; i++)
+	{
+		if (origin.mV[i] < min[i])
+		{
+			t = min[i] - origin.mV[i];
+			d += t*t;
+		}
+		else if (origin.mV[i] > max[i])
+		{
+			t = origin.mV[i] - max[i];
+			d += t*t;
+		}
+
+		if (d > r)
+		{
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+
 typedef enum
 {
 	b000 = 0x00,
@@ -193,24 +225,13 @@ static U8 sOcclusionIndices[] =
 		b000, b110, b100, b101, b001, b011, b010, b110,
 };
 
-U8* get_box_fan_indices(LLCamera* camera, const LLVector3& center)
+U8* get_box_fan_indices(LLCamera* camera, const LLVector4a& center)
 {
-	LLVector3 d = center - camera->getOrigin();
-
-	U8 cypher = 0;
-	if (d.mV[0] > 0)
-	{
-		cypher |= b100;
-	}
-	if (d.mV[1] > 0)
-	{
-		cypher |= b010;
-	}
-	if (d.mV[2] > 0)
-	{
-		cypher |= b001;
-	}
+	LLVector4a origin;
+	origin.load3(camera->getOrigin().mV);
 
+	S32 cypher = center.greaterThan4(origin).getComparisonMask() & 0x7;
+	
 	return sOcclusionIndices+cypher*8;
 }
 						
@@ -218,33 +239,49 @@ void LLSpatialGroup::buildOcclusion()
 {
 	if (!mOcclusionVerts)
 	{
-		mOcclusionVerts = new F32[8*3];
+		mOcclusionVerts = (LLVector4a*) _mm_malloc(sizeof(LLVector4a)*8, 16);
 	}
 
-	LLVector3 r = mBounds[1] + LLVector3(SG_OCCLUSION_FUDGE, SG_OCCLUSION_FUDGE, SG_OCCLUSION_FUDGE);
+	LLVector4a fudge;
+	fudge.splat(SG_OCCLUSION_FUDGE);
 
-	for (U32 k = 0; k < 3; k++)
-	{
-		r.mV[k] = llmin(mBounds[1].mV[k]+0.25f, r.mV[k]);
-	}
+	LLVector4a r;
+	r.setAdd(mBounds[1], fudge);
 
-	F32* v = mOcclusionVerts;
-	F32* c = mBounds[0].mV;
-	F32* s = r.mV;
+	LLVector4a r2;
+	r2.splat(0.25f);
+	r2.add(mBounds[1]);
+
+	r.setMin(r2);
+
+	LLVector4a* v = mOcclusionVerts;
+	const LLVector4a& c = mBounds[0];
+	const LLVector4a& s = r;
 	
+	static const LLVector4a octant[] =
+	{
+		LLVector4a(-1.f, -1.f, -1.f),
+		LLVector4a(-1.f, -1.f, 1.f),
+		LLVector4a(-1.f, 1.f, -1.f),
+		LLVector4a(-1.f, 1.f, 1.f),
+
+		LLVector4a(1.f, -1.f, -1.f),
+		LLVector4a(1.f, -1.f, 1.f),
+		LLVector4a(1.f, 1.f, -1.f),
+		LLVector4a(1.f, 1.f, 1.f),
+	};
+
 	//vertex positions are encoded so the 3 bits of their vertex index 
 	//correspond to their axis facing, with bit position 3,2,1 matching
 	//axis facing x,y,z, bit set meaning positive facing, bit clear 
 	//meaning negative facing
-	v[0] = c[0]-s[0]; v[1]  = c[1]-s[1]; v[2]  = c[2]-s[2];  // 0 - 0000 
-	v[3] = c[0]-s[0]; v[4]  = c[1]-s[1]; v[5]  = c[2]+s[2];  // 1 - 0001
-	v[6] = c[0]-s[0]; v[7]  = c[1]+s[1]; v[8]  = c[2]-s[2];  // 2 - 0010
-	v[9] = c[0]-s[0]; v[10] = c[1]+s[1]; v[11] = c[2]+s[2];  // 3 - 0011
-																					   
-	v[12] = c[0]+s[0]; v[13] = c[1]-s[1]; v[14] = c[2]-s[2]; // 4 - 0100
-	v[15] = c[0]+s[0]; v[16] = c[1]-s[1]; v[17] = c[2]+s[2]; // 5 - 0101
-	v[18] = c[0]+s[0]; v[19] = c[1]+s[1]; v[20] = c[2]-s[2]; // 6 - 0110
-	v[21] = c[0]+s[0]; v[22] = c[1]+s[1]; v[23] = c[2]+s[2]; // 7 - 0111
+	
+	for (S32 i = 0; i < 8; ++i)
+	{
+		v[i] = s;
+		v[i].mul(octant[i]);
+		v[i].add(c);
+	}
 
 	clearState(LLSpatialGroup::OCCLUSION_DIRTY);
 }
@@ -288,6 +325,11 @@ LLSpatialGroup::~LLSpatialGroup()
 		llerrs << "Illegal deletion of LLSpatialGroup!" << llendl;
 	}*/
 
+	if (gDebugGL)
+	{
+		gPipeline.checkReferences(this);
+	}
+
 	if (isState(DEAD))
 	{
 		sZombieGroups--;
@@ -300,11 +342,13 @@ LLSpatialGroup::~LLSpatialGroup()
 		sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
 	}
 
-	delete [] mOcclusionVerts;
+	_mm_free(mOcclusionVerts);
 
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 	clearDrawMap();
 	clearAtlasList() ;
+
+	_mm_free(mBounds);
 }
 
 BOOL LLSpatialGroup::hasAtlas(LLTextureAtlas* atlasp)
@@ -456,8 +500,10 @@ void LLSpatialGroup::validate()
 	sg_assert(!isState(DIRTY));
 	sg_assert(!isDead());
 
-	LLVector3 myMin = mBounds[0] - mBounds[1];
-	LLVector3 myMax = mBounds[0] + mBounds[1];
+	LLVector4a myMin;
+	myMin.setSub(mBounds[0], mBounds[1]);
+	LLVector4a myMax;
+	myMax.setAdd(mBounds[0], mBounds[1]);
 
 	validateDrawMap();
 
@@ -489,16 +535,18 @@ void LLSpatialGroup::validate()
 		group->validate();
 		
 		//ensure all children are enclosed in this node
-		LLVector3 center = group->mBounds[0];
-		LLVector3 size = group->mBounds[1];
+		LLVector4a center = group->mBounds[0];
+		LLVector4a size = group->mBounds[1];
 		
-		LLVector3 min = center - size;
-		LLVector3 max = center + size;
+		LLVector4a min;
+		min.setSub(center, size);
+		LLVector4a max;
+		max.setAdd(center, size);
 		
 		for (U32 j = 0; j < 3; j++)
 		{
-			sg_assert(min.mV[j] >= myMin.mV[j]-0.02f);
-			sg_assert(max.mV[j] <= myMax.mV[j]+0.02f);
+			sg_assert(min[j] >= myMin[j]-0.02f);
+			sg_assert(max[j] <= myMax[j]+0.02f);
 		}
 	}
 
@@ -508,8 +556,8 @@ void LLSpatialGroup::validate()
 void LLSpatialGroup::checkStates()
 {
 #if LL_OCTREE_PARANOIA_CHECK
-	LLOctreeStateCheck checker;
-	checker.traverse(mOctreeNode);
+	//LLOctreeStateCheck checker;
+	//checker.traverse(mOctreeNode);
 #endif
 }
 
@@ -534,19 +582,17 @@ BOOL LLSpatialGroup::updateInGroup(LLDrawable *drawablep, BOOL immediate)
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 		
 	drawablep->updateSpatialExtents();
-	validate_drawable(drawablep);
 
 	OctreeNode* parent = mOctreeNode->getOctParent();
 	
 	if (mOctreeNode->isInside(drawablep->getPositionGroup()) && 
 		(mOctreeNode->contains(drawablep) ||
-		 (drawablep->getBinRadius() > mOctreeNode->getSize().mdV[0] &&
+		 (drawablep->getBinRadius() > mOctreeNode->getSize()[0] &&
 				parent && parent->getElementCount() >= LL_OCTREE_MAX_CAPACITY)))
 	{
 		unbound();
 		setState(OBJECT_DIRTY);
 		//setState(GEOM_DIRTY);
-		validate_drawable(drawablep);
 		return TRUE;
 	}
 		
@@ -564,7 +610,6 @@ BOOL LLSpatialGroup::addObject(LLDrawable *drawablep, BOOL add_all, BOOL from_oc
 	else
 	{
 		drawablep->setSpatialGroup(this);
-		validate_drawable(drawablep);
 		setState(OBJECT_DIRTY | GEOM_DIRTY);
 		setOcclusionState(LLSpatialGroup::DISCARD_QUERY, LLSpatialGroup::STATE_MODE_ALL_CAMERAS);
 		gPipeline.markRebuild(this, TRUE);
@@ -665,7 +710,7 @@ void LLSpatialPartition::rebuildMesh(LLSpatialGroup* group)
 
 }
 
-BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector3& minOut, LLVector3& maxOut)
+BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector4a& minOut, LLVector4a& maxOut)
 {	
 	const OctreeNode* node = mOctreeNode;
 
@@ -678,8 +723,8 @@ BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector3& minOut, LLVector3& maxO
 		return FALSE;
 	}
 
-	LLVector3& newMin = mObjectExtents[0];
-	LLVector3& newMax = mObjectExtents[1];
+	LLVector4a& newMin = mObjectExtents[0];
+	LLVector4a& newMax = mObjectExtents[1];
 	
 	if (isState(OBJECT_DIRTY))
 	{ //calculate new bounding box
@@ -688,10 +733,10 @@ BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector3& minOut, LLVector3& maxO
 		//initialize bounding box to first element
 		OctreeNode::const_element_iter i = node->getData().begin();
 		LLDrawable* drawablep = *i;
-		const LLVector3* minMax = drawablep->getSpatialExtents();
+		const LLVector4a* minMax = drawablep->getSpatialExtents();
 
-		newMin.setVec(minMax[0]);
-		newMax.setVec(minMax[1]);
+		newMin = minMax[0];
+		newMax = minMax[1];
 
 		for (++i; i != node->getData().end(); ++i)
 		{
@@ -715,8 +760,10 @@ BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector3& minOut, LLVector3& maxO
 			}*/
 		}
 		
-		mObjectBounds[0] = (newMin + newMax) * 0.5f;
-		mObjectBounds[1] = (newMax - newMin) * 0.5f;
+		mObjectBounds[0].setAdd(newMin, newMax);
+		mObjectBounds[0].mul(0.5f);
+		mObjectBounds[1].setSub(newMax, newMin);
+		mObjectBounds[1].mul(0.5f);
 	}
 	
 	if (empty)
@@ -726,17 +773,8 @@ BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector3& minOut, LLVector3& maxO
 	}
 	else
 	{
-		for (U32 i = 0; i < 3; i++)
-		{
-			if (newMin.mV[i] < minOut.mV[i])
-			{
-				minOut.mV[i] = newMin.mV[i];
-			}
-			if (newMax.mV[i] > maxOut.mV[i])
-			{
-				maxOut.mV[i] = newMax.mV[i];
-			}
-		}
+		minOut.setMin(newMin);
+		maxOut.setMax(newMax);
 	}
 		
 	return TRUE;
@@ -827,18 +865,19 @@ BOOL LLSpatialGroup::removeObject(LLDrawable *drawablep, BOOL from_octree)
 	return TRUE;
 }
 
-void LLSpatialGroup::shift(const LLVector3 &offset)
+void LLSpatialGroup::shift(const LLVector4a &offset)
 {
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
-	LLVector3d offsetd(offset);
-	mOctreeNode->setCenter(mOctreeNode->getCenter()+offsetd);
+	LLVector4a t = mOctreeNode->getCenter();
+	t.add(offset);	
+	mOctreeNode->setCenter(t);
 	mOctreeNode->updateMinMax();
-	mBounds[0] += offset;
-	mExtents[0] += offset;
-	mExtents[1] += offset;
-	mObjectBounds[0] += offset;
-	mObjectExtents[0] += offset;
-	mObjectExtents[1] += offset;
+	mBounds[0].add(offset);
+	mExtents[0].add(offset);
+	mExtents[1].add(offset);
+	mObjectBounds[0].add(offset);
+	mObjectExtents[0].add(offset);
+	mObjectExtents[1].add(offset);
 
 	//if (!mSpatialPartition->mRenderByGroup)
 	{
@@ -850,10 +889,7 @@ void LLSpatialGroup::shift(const LLVector3 &offset)
 	{
 		for (U32 i = 0; i < 8; i++)
 		{
-			F32* v = mOcclusionVerts+i*3;
-			v[0] += offset.mV[0];
-			v[1] += offset.mV[1];
-			v[2] += offset.mV[2];
+			mOcclusionVerts[i].add(offset);
 		}
 	}
 }
@@ -1119,8 +1155,6 @@ LLSpatialGroup::LLSpatialGroup(OctreeNode* node, LLSpatialPartition* part) :
 	mDepth(0.f),
 	mLastUpdateDistance(-1.f), 
 	mLastUpdateTime(gFrameTimeSeconds),
-	mViewAngle(0.f),
-	mLastUpdateViewAngle(-1.f),
 	mAtlasList(4),
 	mCurUpdatingTime(0),
 	mCurUpdatingSlotp(NULL),
@@ -1129,13 +1163,25 @@ LLSpatialGroup::LLSpatialGroup(OctreeNode* node, LLSpatialPartition* part) :
 	sNodeCount++;
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 
+	mBounds = (LLVector4a*) _mm_malloc(sizeof(LLVector4a) * V4_COUNT, 16);
+	mExtents = mBounds + EXTENTS;
+	mObjectBounds = mBounds + OBJECT_BOUNDS;
+	mObjectExtents = mBounds + OBJECT_EXTENTS;
+	mViewAngle = mBounds+VIEW_ANGLE;
+	mLastUpdateViewAngle = mBounds+LAST_VIEW_ANGLE;
+
+	mViewAngle->splat(0.f);
+	mLastUpdateViewAngle->splat(-1.f);
+	mExtents[0] = mExtents[1] = mObjectBounds[0] = mObjectBounds[0] = mObjectBounds[1] = 
+		mObjectExtents[0] = mObjectExtents[1] = *mViewAngle;
+
 	sg_assert(mOctreeNode->getListenerCount() == 0);
 	mOctreeNode->addListener(this);
 	setState(SG_INITIAL_STATE_MASK);
 	gPipeline.markRebuild(this, TRUE);
 
-	mBounds[0] = LLVector3(node->getCenter());
-	mBounds[1] = LLVector3(node->getSize());
+	mBounds[0] = node->getCenter();
+	mBounds[1] = node->getSize();
 
 	part->mLODSeed = (part->mLODSeed+1)%part->mLODPeriod;
 	mLODHash = part->mLODSeed;
@@ -1172,8 +1218,8 @@ void LLSpatialGroup::updateDistance(LLCamera &camera)
 #endif
 	if (!getData().empty())
 	{
-		mRadius = mSpatialPartition->mRenderByGroup ? mObjectBounds[1].magVec() :
-						(F32) mOctreeNode->getSize().magVec();
+		mRadius = mSpatialPartition->mRenderByGroup ? mObjectBounds[1].length3() :
+						(F32) mOctreeNode->getSize().length3();
 		mDistance = mSpatialPartition->calcDistance(this, camera);
 		mPixelArea = mSpatialPartition->calcPixelArea(this, camera);
 	}
@@ -1181,27 +1227,34 @@ void LLSpatialGroup::updateDistance(LLCamera &camera)
 
 F32 LLSpatialPartition::calcDistance(LLSpatialGroup* group, LLCamera& camera)
 {
-	LLVector3 eye = group->mObjectBounds[0] - camera.getOrigin();
+	LLVector4a eye;
+	LLVector4a origin;
+	origin.load3(camera.getOrigin().mV);
+
+	eye.setSub(group->mObjectBounds[0], origin);
 
 	F32 dist = 0.f;
 
 	if (group->mDrawMap.find(LLRenderPass::PASS_ALPHA) != group->mDrawMap.end())
 	{
-		LLVector3 v = eye;
-		dist = eye.normVec();
+		LLVector4a v = eye;
+
+		dist = eye.length3();
+		eye.normalize3fast();
 
 		if (!group->isState(LLSpatialGroup::ALPHA_DIRTY))
 		{
 			if (!group->mSpatialPartition->isBridge())
 			{
-				LLVector3 view_angle = LLVector3(eye * LLVector3(1,0,0),
-												 eye * LLVector3(0,1,0),
-												 eye * LLVector3(0,0,1));
+				LLVector4a view_angle = eye;
 
-				if ((view_angle-group->mLastUpdateViewAngle).magVec() > 0.64f)
+				LLVector4a diff;
+				diff.setSub(view_angle, *group->mLastUpdateViewAngle);
+
+				if (diff.length3() > 0.64f)
 				{
-					group->mViewAngle = view_angle;
-					group->mLastUpdateViewAngle = view_angle;
+					*group->mViewAngle = view_angle;
+					*group->mLastUpdateViewAngle = view_angle;
 					//for occasional alpha sorting within the group
 					//NOTE: If there is a trivial way to detect that alpha sorting here would not change the render order,
 					//not setting this node to dirty would be a very good thing
@@ -1215,17 +1268,20 @@ F32 LLSpatialPartition::calcDistance(LLSpatialGroup* group, LLCamera& camera)
 
 		LLVector3 at = camera.getAtAxis();
 
-		//front of bounding box
-		for (U32 i = 0; i < 3; i++)
-		{
-			v.mV[i] -= group->mObjectBounds[1].mV[i]*0.25f * at.mV[i];
-		}
+		LLVector4a ata;
+		ata.load3(at.mV);
 
-		group->mDepth = v * at;
+		LLVector4a t = ata;
+		//front of bounding box
+		t.mul(0.25f);
+		t.mul(group->mObjectBounds[1]);
+		v.sub(t);
+		
+		group->mDepth = v.dot3(ata);
 	}
 	else
 	{
-		dist = eye.magVec();
+		dist = eye.length3();
 	}
 
 	if (dist < 16.f)
@@ -1378,7 +1434,7 @@ void LLSpatialGroup::destroyGL()
 		}
 	}
 
-	delete [] mOcclusionVerts;
+	_mm_free(mOcclusionVerts);
 	mOcclusionVerts = NULL;
 
 	for (LLSpatialGroup::element_iter i = getData().begin(); i != getData().end(); ++i)
@@ -1421,8 +1477,8 @@ BOOL LLSpatialGroup::rebound()
 	}
 	else
 	{
-		LLVector3& newMin = mExtents[0];
-		LLVector3& newMax = mExtents[1];
+		LLVector4a& newMin = mExtents[0];
+		LLVector4a& newMax = mExtents[1];
 		LLSpatialGroup* group = (LLSpatialGroup*) mOctreeNode->getChild(0)->getListener(0);
 		group->clearState(SKIP_FRUSTUM_CHECK);
 		group->rebound();
@@ -1436,26 +1492,19 @@ BOOL LLSpatialGroup::rebound()
 			group = (LLSpatialGroup*) mOctreeNode->getChild(i)->getListener(0);
 			group->clearState(SKIP_FRUSTUM_CHECK);
 			group->rebound();
-			const LLVector3& max = group->mExtents[1];
-			const LLVector3& min = group->mExtents[0];
+			const LLVector4a& max = group->mExtents[1];
+			const LLVector4a& min = group->mExtents[0];
 
-			for (U32 j = 0; j < 3; j++)
-			{
-				if (max.mV[j] > newMax.mV[j])
-				{
-					newMax.mV[j] = max.mV[j];
-				}
-				if (min.mV[j] < newMin.mV[j])
-				{
-					newMin.mV[j] = min.mV[j];
-				}
-			}
+			newMax.setMax(max);
+			newMin.setMin(min);
 		}
 
 		boundObjects(FALSE, newMin, newMax);
 		
-		mBounds[0] = (newMin + newMax)*0.5f;
-		mBounds[1] = (newMax - newMin)*0.5f;
+		mBounds[0].setAdd(newMin, newMax);
+		mBounds[0].mul(0.5f);
+		mBounds[1].setSub(newMax, newMin);
+		mBounds[1].mul(0.5f);
 	}
 	
 	setState(OCCLUSION_DIRTY);
@@ -1540,7 +1589,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 				}
 
 				glBeginQueryARB(GL_SAMPLES_PASSED_ARB, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
-				glVertexPointer(3, GL_FLOAT, 0, mOcclusionVerts);
+				glVertexPointer(3, GL_FLOAT, 16, mOcclusionVerts);
 				if (camera->getOrigin().isExactlyZero())
 				{ //origin is invalid, draw entire box
 					glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
@@ -1581,8 +1630,11 @@ LLSpatialPartition::LLSpatialPartition(U32 data_mask, BOOL render_by_group, U32
 
 	LLGLNamePool::registerPool(&sQueryPool);
 
-	mOctree = new LLSpatialGroup::OctreeRoot(LLVector3d(0,0,0), 
-											LLVector3d(1,1,1), 
+	LLVector4a center, size;
+	center.splat(0.f);
+	size.splat(1.f);
+
+	mOctree = new LLSpatialGroup::OctreeRoot(center,size,
 											NULL);
 	new LLSpatialGroup(mOctree, this);
 }
@@ -1602,7 +1654,6 @@ LLSpatialGroup *LLSpatialPartition::put(LLDrawable *drawablep, BOOL was_visible)
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 		
 	drawablep->updateSpatialExtents();
-	validate_drawable(drawablep);
 
 	//keep drawable from being garbage collected
 	LLPointer<LLDrawable> ptr = drawablep;
@@ -1686,16 +1737,16 @@ void LLSpatialPartition::move(LLDrawable *drawablep, LLSpatialGroup *curp, BOOL
 class LLSpatialShift : public LLSpatialGroup::OctreeTraveler
 {
 public:
-	LLSpatialShift(LLVector3 offset) : mOffset(offset) { }
+	const LLVector4a& mOffset;
+
+	LLSpatialShift(const LLVector4a& offset) : mOffset(offset) { }
 	virtual void visit(const LLSpatialGroup::OctreeNode* branch) 
 	{ 
 		((LLSpatialGroup*) branch->getListener(0))->shift(mOffset); 
 	}
-		
-	LLVector3 mOffset;
 };
 
-void LLSpatialPartition::shift(const LLVector3 &offset)
+void LLSpatialPartition::shift(const LLVector4a &offset)
 { //shift octree node bounding boxes by offset
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 	LLSpatialShift shifter(offset);
@@ -1857,7 +1908,7 @@ public:
 class LLOctreeCullVisExtents: public LLOctreeCullShadow
 {
 public:
-	LLOctreeCullVisExtents(LLCamera* camera, LLVector3& min, LLVector3& max)
+	LLOctreeCullVisExtents(LLCamera* camera, LLVector4a& min, LLVector4a& max)
 		: LLOctreeCullShadow(camera), mMin(min), mMax(max), mEmpty(TRUE) { }
 
 	virtual bool earlyFail(LLSpatialGroup* group)
@@ -1924,8 +1975,8 @@ public:
 	}
 
 	BOOL mEmpty;
-	LLVector3& mMin;
-	LLVector3& mMax;
+	LLVector4a& mMin;
+	LLVector4a& mMax;
 };
 
 class LLOctreeCullDetectVisible: public LLOctreeCullShadow
@@ -2029,6 +2080,11 @@ void drawBox(const LLVector3& c, const LLVector3& r)
 	gGL.end();	
 }
 
+void drawBox(const LLVector4a& c, const LLVector4a& r)
+{
+	drawBox(reinterpret_cast<const LLVector3&>(c), reinterpret_cast<const LLVector3&>(r));
+}
+
 void drawBoxOutline(const LLVector3& pos, const LLVector3& size)
 {
 	LLVector3 v1 = size.scaledVec(LLVector3( 1, 1,1));
@@ -2075,6 +2131,11 @@ void drawBoxOutline(const LLVector3& pos, const LLVector3& size)
 	gGL.end();
 }
 
+void drawBoxOutline(const LLVector4a& pos, const LLVector4a& size)
+{
+	drawBoxOutline(reinterpret_cast<const LLVector3&>(pos), reinterpret_cast<const LLVector3&>(size));
+}
+
 class LLOctreeDirty : public LLOctreeTraveler<LLDrawable>
 {
 public:
@@ -2118,14 +2179,21 @@ BOOL LLSpatialPartition::isOcclusionEnabled()
 
 BOOL LLSpatialPartition::getVisibleExtents(LLCamera& camera, LLVector3& visMin, LLVector3& visMax)
 {
+	LLVector4a visMina, visMaxa;
+	visMina.load3(visMin.mV);
+	visMaxa.load3(visMax.mV);
+
 	{
 		LLFastTimer ftm(FTM_CULL_REBOUND);		
 		LLSpatialGroup* group = (LLSpatialGroup*) mOctree->getListener(0);
 		group->rebound();
 	}
 
-	LLOctreeCullVisExtents vis(&camera, visMin, visMax);
+	LLOctreeCullVisExtents vis(&camera, visMina, visMaxa);
 	vis.traverse(mOctree);
+
+	visMin.set(visMina.getF32());
+	visMax.set(visMina.getF32());
 	return vis.mEmpty;
 }
 
@@ -2188,25 +2256,36 @@ BOOL earlyFail(LLCamera* camera, LLSpatialGroup* group)
 	}
 
 	const F32 vel = SG_OCCLUSION_FUDGE*2.f;
-	LLVector3 c = group->mBounds[0];
-	LLVector3 r = group->mBounds[1] + LLVector3(vel,vel,vel);
-    
+	LLVector4a fudge;
+	fudge.splat(vel);
+
+	const LLVector4a& c = group->mBounds[0];
+	LLVector4a r;
+	r.setAdd(group->mBounds[1], fudge);
+
 	/*if (r.magVecSquared() > 1024.0*1024.0)
 	{
 		return TRUE;
 	}*/
 
-	LLVector3 e = camera->getOrigin();
+	LLVector4a e;
+	e.load3(camera->getOrigin().mV);
 	
-	LLVector3 min = c - r;
-	LLVector3 max = c + r;
+	LLVector4a min;
+	min.setSub(c,r);
+	LLVector4a max;
+	max.setAdd(c,r);
 	
-	for (U32 j = 0; j < 3; j++)
+	S32 lt = e.lessThan4(min).getComparisonMask() & 0x7;
+	if (lt)
 	{
-		if (e.mV[j] < min.mV[j] || e.mV[j] > max.mV[j])
-		{
-			return FALSE;
-		}
+		return FALSE;
+	}
+
+	S32 gt = e.greaterThan4(max).getComparisonMask() & 0x7;
+	if (gt)
+	{
+		return FALSE;
 	}
 
 	return TRUE;
@@ -2411,7 +2490,13 @@ void renderOctree(LLSpatialGroup* group)
 	}
 
 	gGL.color4fv(col.mV);
-	drawBox(group->mObjectBounds[0], group->mObjectBounds[1]*1.01f+LLVector3(0.001f, 0.001f, 0.001f));
+	LLVector4a fudge;
+	fudge.splat(0.001f);
+	LLVector4a size = group->mObjectBounds[1];
+	size.mul(1.01f);
+	size.add(fudge);
+
+	drawBox(group->mObjectBounds[0], fudge);
 	
 	gGL.setSceneBlendType(LLRender::BT_ALPHA);
 
@@ -2442,8 +2527,12 @@ void renderOctree(LLSpatialGroup* group)
 				for (LLSpatialGroup::drawmap_elem_t::iterator j = i->second.begin(); j != i->second.end(); ++j)
 				{
 					LLDrawInfo* draw_info = *j;
-					LLVector3 center = (draw_info->mExtents[1] + draw_info->mExtents[0])*0.5f;
-					LLVector3 size = (draw_info->mExtents[1] - draw_info->mExtents[0])*0.5f;
+					LLVector4a center;
+					center.setAdd(draw_info->mExtents[1], draw_info->mExtents[0]);
+					center.mul(0.5f);
+					LLVector4a size;
+					size.setSub(draw_info->mExtents[1], draw_info->mExtents[0]);
+					size.mul(0.5f);
 					drawBoxOutline(center, size);
 				}
 			}
@@ -2493,7 +2582,7 @@ void renderVisibility(LLSpatialGroup* group, LLCamera* camera)
 		else if (camera && group->mOcclusionVerts)
 		{
 			LLVertexBuffer::unbind();
-			glVertexPointer(3, GL_FLOAT, 0, group->mOcclusionVerts);
+			glVertexPointer(3, GL_FLOAT, 16, group->mOcclusionVerts);
 
 			glColor4f(1.0f, 0.f, 0.f, 0.5f);
 			glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8, GL_UNSIGNED_BYTE, get_box_fan_indices(camera, group->mBounds[0]));
@@ -2572,8 +2661,8 @@ void renderBoundingBox(LLDrawable* drawable, BOOL set_color = TRUE)
 		}
 	}
 
-	const LLVector3* ext;
-	LLVector3 pos, size;
+	const LLVector4a* ext;
+	LLVector4a pos, size;
 
 	//render face bounding boxes
 	for (S32 i = 0; i < drawable->getNumFaces(); i++)
@@ -2582,20 +2671,21 @@ void renderBoundingBox(LLDrawable* drawable, BOOL set_color = TRUE)
 
 		ext = facep->mExtents;
 
-		if (ext[0].isExactlyZero() && ext[1].isExactlyZero())
-		{
-			continue;
-		}
-		pos = (ext[0] + ext[1]) * 0.5f;
-		size = (ext[1] - ext[0]) * 0.5f;
+		pos.setAdd(ext[0], ext[1]);
+		pos.mul(0.5f);
+		size.setSub(ext[1], ext[0]);
+		size.mul(0.5f);
+		
 		drawBoxOutline(pos,size);
 	}
 
 	//render drawable bounding box
 	ext = drawable->getSpatialExtents();
 
-	pos = (ext[0] + ext[1]) * 0.5f;
-	size = (ext[1] - ext[0]) * 0.5f;
+	pos.setAdd(ext[0], ext[1]);
+	pos.mul(0.5f);
+	size.setSub(ext[1], ext[0]);
+	size.mul(0.5f);
 	
 	LLViewerObject* vobj = drawable->getVObj();
 	if (vobj && vobj->onActiveList())
@@ -2651,8 +2741,13 @@ void renderTexturePriority(LLDrawable* drawable)
 		//	gGL.color4f(1,0,1,1);
 		//}
 		
-		LLVector3 center = (facep->mExtents[1]+facep->mExtents[0])*0.5f;
-		LLVector3 size = (facep->mExtents[1]-facep->mExtents[0])*0.5f + LLVector3(0.01f, 0.01f, 0.01f);
+		LLVector4a center;
+		center.setAdd(facep->mExtents[1],facep->mExtents[0]);
+		center.mul(0.5f);
+		LLVector4a size;
+		size.setSub(facep->mExtents[1],facep->mExtents[0]);
+		size.mul(0.5f);
+		size.add(LLVector4a(0.01f));
 		drawBox(center, size);
 		
 		/*S32 boost = imagep->getBoostLevel();
@@ -2676,7 +2771,6 @@ void renderPoints(LLDrawable* drawablep)
 	{
 		gGL.begin(LLRender::POINTS);
 		gGL.color3f(1,1,1);
-		LLVector3 center(drawablep->getPositionGroup());
 		for (S32 i = 0; i < drawablep->getNumFaces(); i++)
 		{
 			gGL.vertex3fv(drawablep->getFace(i)->mCenterLocal.mV);
@@ -2708,8 +2802,12 @@ void renderShadowFrusta(LLDrawInfo* params)
 	LLGLEnable blend(GL_BLEND);
 	gGL.setSceneBlendType(LLRender::BT_ADD);
 
-	LLVector3 center = (params->mExtents[1]+params->mExtents[0])*0.5f;
-	LLVector3 size = (params->mExtents[1]-params->mExtents[0])*0.5f;
+	LLVector4a center;
+	center.setAdd(params->mExtents[1], params->mExtents[0]);
+	center.mul(0.5f);
+	LLVector4a size;
+	size.setSub(params->mExtents[1],params->mExtents[0]);
+	size.mul(0.5f);
 
 	if (gPipeline.mShadowCamera[4].AABBInFrustum(center, size))
 	{
@@ -2753,10 +2851,14 @@ void renderLights(LLDrawable* drawablep)
 			pushVerts(drawablep->getFace(i), LLVertexBuffer::MAP_VERTEX);
 		}
 
-		const LLVector3* ext = drawablep->getSpatialExtents();
+		const LLVector4a* ext = drawablep->getSpatialExtents();
 
-		LLVector3 pos = (ext[0] + ext[1]) * 0.5f;
-		LLVector3 size = (ext[1] - ext[0]) * 0.5f;
+		LLVector4a pos;
+		pos.setAdd(ext[0], ext[1]);
+		pos.mul(0.5f);
+		LLVector4a size;
+		size.setSub(ext[1], ext[0]);
+		size.mul(0.5f);
 
 		{
 			LLGLDepthTest depth(GL_FALSE, GL_TRUE);
@@ -2766,7 +2868,7 @@ void renderLights(LLDrawable* drawablep)
 
 		gGL.color4f(1,1,0,1);
 		F32 rad = drawablep->getVOVolume()->getLightRadius();
-		drawBoxOutline(pos, LLVector3(rad,rad,rad));
+		drawBoxOutline(pos, LLVector4a(rad));
 	}
 }
 
@@ -2781,7 +2883,7 @@ public:
 		mDir.setSub(mEnd, mStart);
 	}
 
-	void visit(const LLOctreeNode<LLVolumeFace::Triangle>* branch)
+	void visit(const LLOctreeNode<LLVolumeTriangle>* branch)
 	{
 		LLVolumeOctreeListener* vl = (LLVolumeOctreeListener*) branch->getListener(0);
 
@@ -2859,10 +2961,14 @@ void renderRaycast(LLDrawable* drawablep)
 		glPopMatrix();
 
 		// draw bounding box of prim
-		const LLVector3* ext = drawablep->getSpatialExtents();
+		const LLVector4a* ext = drawablep->getSpatialExtents();
 
-		LLVector3 pos = (ext[0] + ext[1]) * 0.5f;
-		LLVector3 size = (ext[1] - ext[0]) * 0.5f;
+		LLVector4a pos;
+		pos.setAdd(ext[0], ext[1]);
+		pos.mul(0.5f);
+		LLVector4a size;
+		size.setSub(ext[1], ext[0]);
+		size.mul(0.5f);
 
 		LLGLDepthTest depth(GL_FALSE, GL_TRUE);
 		gGL.color4f(0,0.5f,0.5f,1);
@@ -2949,8 +3055,8 @@ public:
 			return;
 		}
 
-		LLVector3 nodeCenter = group->mBounds[0];
-		LLVector3 octCenter = LLVector3(group->mOctreeNode->getCenter());
+		LLVector4a nodeCenter = group->mBounds[0];
+		LLVector4a octCenter = group->mOctreeNode->getCenter();
 
 		group->rebuildGeom();
 		group->rebuildMesh();
@@ -2979,8 +3085,14 @@ public:
 				if (drawable->isState(LLDrawable::IN_REBUILD_Q2))
 				{
 					gGL.color4f(0.6f, 0.6f, 0.1f, 1.f);
-					const LLVector3* ext = drawable->getSpatialExtents();
-					drawBoxOutline((ext[0]+ext[1])*0.5f, (ext[1]-ext[0])*0.5f);
+					const LLVector4a* ext = drawable->getSpatialExtents();
+					LLVector4a center;
+					center.setAdd(ext[0], ext[1]);
+					center.mul(0.5f);
+					LLVector4a size;
+					size.setSub(ext[1], ext[0]);
+					size.mul(0.5f);
+					drawBoxOutline(center, size);
 				}
 			}	
 
@@ -3211,7 +3323,11 @@ void LLSpatialPartition::renderDebug()
 void LLSpatialGroup::drawObjectBox(LLColor4 col)
 {
 	gGL.color4fv(col.mV);
-	drawBox(mObjectBounds[0], mObjectBounds[1]*1.01f+LLVector3(0.001f, 0.001f, 0.001f));
+	LLVector4a size;
+	size = mObjectBounds[0];
+	size.mul(1.01f);
+	size.add(LLVector4a(0.001f));
+	drawBox(mObjectBounds[0], size);
 }
 
 
@@ -3271,8 +3387,8 @@ public:
 
 			LLSpatialGroup* group = (LLSpatialGroup*) child->getListener(0);
 			
-			LLVector3 size;
-			LLVector3 center;
+			LLVector4a size;
+			LLVector4a center;
 			
 			size = group->mBounds[1];
 			center = group->mBounds[0];
@@ -3289,7 +3405,11 @@ public:
 				local_end   = mEnd   * local_matrix;
 			}
 
-			if (LLLineSegmentBoxIntersect(local_start, local_end, center, size))
+			LLVector4a start, end;
+			start.load3(local_start.mV);
+			end.load3(local_end.mV);
+
+			if (LLLineSegmentBoxIntersect(start, end, center, size))
 			{
 				check(child);
 			}
@@ -3380,6 +3500,7 @@ LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset,
 	mDrawMode(LLRender::TRIANGLES)
 {
 	mVertexBuffer->validateRange(mStart, mEnd, mCount, mOffset);
+	mExtents = (LLVector4a*) _mm_malloc(sizeof(LLVector4a)*2, 16);
 
 	mDebugColor = (rand() << 16) + rand();
 }
@@ -3395,6 +3516,13 @@ LLDrawInfo::~LLDrawInfo()
 	{
 		mFace->setDrawInfo(NULL);
 	}
+
+	if (gDebugGL)
+	{
+		gPipeline.checkReferences(this);
+	}
+
+	_mm_free(mExtents);
 }
 
 void LLDrawInfo::validate()
-- 
cgit v1.2.3


From ca1caeb1deedd1b8e59a90223153ca6f05914b95 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 4 Jun 2010 00:11:57 -0500
Subject: Fix for occlusion culling cypher bits being flipped.

---
 indra/newview/llspatialpartition.cpp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 3cf0138303..05e7bbb6cd 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -207,20 +207,20 @@ typedef enum
 //gives you a triangle fan index array
 static U8 sOcclusionIndices[] =
 {
-	 // 000
+	 //000
 		b111, b110, b010, b011, b001, b101, b100, b110,
-	//001 
-		b110, b000, b010, b011, b111, b101, b100, b000,
+	 //001 
+		b011, b010, b000, b001, b101, b111, b110, b010,
 	 //010
 		b101, b100, b110, b111, b011, b001, b000, b100,
 	 //011 
-		b100, b010, b110, b111, b101, b001, b000, b010,
-	//100 
-		b011, b010, b000, b001, b101, b111, b110, b010,
+		b001, b000, b100, b101, b111, b011, b010, b000,
+	 //100 
+		b110, b000, b010, b011, b111, b101, b100, b000,
 	 //101 
 		b010, b100, b000, b001, b011, b111, b110, b100,
 	 //110
-		b001, b000, b100, b101, b111, b011, b010, b000,
+		b100, b010, b110, b111, b101, b001, b000, b010,
 	 //111
 		b000, b110, b100, b101, b001, b011, b010, b110,
 };
@@ -2045,6 +2045,8 @@ public:
 
 void drawBox(const LLVector3& c, const LLVector3& r)
 {
+	LLVertexBuffer::unbind();
+
 	gGL.begin(LLRender::TRIANGLE_STRIP);
 	//left front
 	gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,1,-1))).mV);
-- 
cgit v1.2.3


From f40d07512ab54ba3da38c8a8b92cf0c6d1469bc6 Mon Sep 17 00:00:00 2001
From: Tofu Linden <tofu.linden@lindenlab.com>
Date: Fri, 4 Jun 2010 09:04:36 +0100
Subject: finish conversion to ll_aligned_*() wrappers

---
 indra/newview/llspatialpartition.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 05e7bbb6cd..e5d0e064c6 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -239,7 +239,7 @@ void LLSpatialGroup::buildOcclusion()
 {
 	if (!mOcclusionVerts)
 	{
-		mOcclusionVerts = (LLVector4a*) _mm_malloc(sizeof(LLVector4a)*8, 16);
+		mOcclusionVerts = (LLVector4a*) ll_aligned_malloc_16(sizeof(LLVector4a)*8);
 	}
 
 	LLVector4a fudge;
@@ -342,13 +342,13 @@ LLSpatialGroup::~LLSpatialGroup()
 		sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
 	}
 
-	_mm_free(mOcclusionVerts);
+	ll_aligned_free_16(mOcclusionVerts);
 
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 	clearDrawMap();
 	clearAtlasList() ;
 
-	_mm_free(mBounds);
+	ll_aligned_free_16(mBounds);
 }
 
 BOOL LLSpatialGroup::hasAtlas(LLTextureAtlas* atlasp)
@@ -1163,7 +1163,7 @@ LLSpatialGroup::LLSpatialGroup(OctreeNode* node, LLSpatialPartition* part) :
 	sNodeCount++;
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 
-	mBounds = (LLVector4a*) _mm_malloc(sizeof(LLVector4a) * V4_COUNT, 16);
+	mBounds = (LLVector4a*) ll_aligned_malloc_16(sizeof(LLVector4a) * V4_COUNT);
 	mExtents = mBounds + EXTENTS;
 	mObjectBounds = mBounds + OBJECT_BOUNDS;
 	mObjectExtents = mBounds + OBJECT_EXTENTS;
@@ -1434,7 +1434,7 @@ void LLSpatialGroup::destroyGL()
 		}
 	}
 
-	_mm_free(mOcclusionVerts);
+	ll_aligned_free_16(mOcclusionVerts);
 	mOcclusionVerts = NULL;
 
 	for (LLSpatialGroup::element_iter i = getData().begin(); i != getData().end(); ++i)
@@ -3502,7 +3502,7 @@ LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset,
 	mDrawMode(LLRender::TRIANGLES)
 {
 	mVertexBuffer->validateRange(mStart, mEnd, mCount, mOffset);
-	mExtents = (LLVector4a*) _mm_malloc(sizeof(LLVector4a)*2, 16);
+	mExtents = (LLVector4a*) ll_aligned_malloc_16(sizeof(LLVector4a)*2);
 
 	mDebugColor = (rand() << 16) + rand();
 }
@@ -3524,7 +3524,7 @@ LLDrawInfo::~LLDrawInfo()
 		gPipeline.checkReferences(this);
 	}
 
-	_mm_free(mExtents);
+	ll_aligned_free_16(mExtents);
 }
 
 void LLDrawInfo::validate()
-- 
cgit v1.2.3


From a8f0e47fd5deee1e45b4126ee43955a7bc68bb5d Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 4 Jun 2010 12:07:55 -0500
Subject: Normal debug display and fix for bad bump mapping and planar texture
 coordinates.

---
 indra/newview/llspatialpartition.cpp | 57 +++++++++++++++++++++++++++++++++++-
 1 file changed, 56 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 05e7bbb6cd..77d36b1c2e 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2704,7 +2704,56 @@ void renderBoundingBox(LLDrawable* drawable, BOOL set_color = TRUE)
 	{
 		drawBoxOutline(pos,size);
 	}
-	
+}
+
+void renderNormals(LLDrawable* drawablep)
+{
+	LLVertexBuffer::unbind();
+
+	LLVOVolume* vol = drawablep->getVOVolume();
+	if (vol)
+	{
+		LLVolume* volume = vol->getVolume();
+		gGL.pushMatrix();
+		glMultMatrixf((F32*) vol->getRelativeXform().mMatrix);
+		
+		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
+		LLVector4a scale(gSavedSettings.getF32("RenderDebugNormalScale"));
+
+		for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
+		{
+			const LLVolumeFace& face = volume->getVolumeFace(i);
+
+			gGL.begin(LLRender::LINES);
+			
+			for (S32 j = 0; j < face.mNumVertices; ++j)
+			{
+				LLVector4a n,p;
+				
+				n.setMul(face.mNormals[j], scale);
+				p.setAdd(face.mPositions[j], n);
+				
+				gGL.color4f(1,1,1,1);
+				gGL.vertex3fv(face.mPositions[j].getF32());
+				gGL.vertex3fv(p.getF32());
+				
+				if (face.mBinormals)
+				{
+					n.setMul(face.mBinormals[j], scale);
+					p.setAdd(face.mPositions[j], n);
+				
+					gGL.color4f(0,1,1,1);
+					gGL.vertex3fv(face.mPositions[j].getF32());
+					gGL.vertex3fv(p.getF32());
+				}	
+			}
+
+			gGL.end();
+		}
+
+		gGL.popMatrix();
+	}
 }
 
 void renderTexturePriority(LLDrawable* drawable)
@@ -3081,6 +3130,11 @@ public:
 			{
 				renderBoundingBox(drawable);			
 			}
+
+			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_NORMALS))
+			{
+				renderNormals(drawable);
+			}
 			
 			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_BUILD_QUEUE))
 			{
@@ -3280,6 +3334,7 @@ void LLSpatialPartition::renderDebug()
 									  LLPipeline::RENDER_DEBUG_LIGHTS |
 									  LLPipeline::RENDER_DEBUG_BATCH_SIZE |
 									  LLPipeline::RENDER_DEBUG_BBOXES |
+									  LLPipeline::RENDER_DEBUG_NORMALS |
 									  LLPipeline::RENDER_DEBUG_POINTS |
 									  LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY |
 									  LLPipeline::RENDER_DEBUG_TEXTURE_ANIM |
-- 
cgit v1.2.3


From 84e619a6dc9e5a5967c4ce035ac530a4588f72a5 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 7 Jun 2010 13:43:30 -0500
Subject: Fix for bad shadow frustum calculation.

---
 indra/newview/llspatialpartition.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index d0e3a1428f..bda59f49d1 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2195,7 +2195,7 @@ BOOL LLSpatialPartition::getVisibleExtents(LLCamera& camera, LLVector3& visMin,
 	vis.traverse(mOctree);
 
 	visMin.set(visMina.getF32());
-	visMax.set(visMina.getF32());
+	visMax.set(visMaxa.getF32());
 	return vis.mEmpty;
 }
 
-- 
cgit v1.2.3


From 6f2bd694d9a21174648b4e4f76d6d078aa88265f Mon Sep 17 00:00:00 2001
From: Matthew Breindel <falcon@lindenlab.com>
Date: Sat, 26 Jun 2010 12:35:05 -0700
Subject: Fixed mac build (given LL_MESH_ENABLED set to 0).

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

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index dc193dc600..9951cf0193 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2791,6 +2791,7 @@ void renderPhysicsShape(LLDrawable* drawable)
 
 		U32 data_mask = LLVertexBuffer::MAP_VERTEX;
 
+#if LL_MESH_ENABLED
 		if (volume->isMesh())
 		{			
 			LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
@@ -2827,7 +2828,8 @@ void renderPhysicsShape(LLDrawable* drawable)
 				return;
 			}
 		}
-
+#endif //LL_MESH_ENABLED
+		
 		//push faces
 		glColor3fv(color.mV);
 		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-- 
cgit v1.2.3


From 2fea1d5d33ec1b41a3cfa4307a1bfa58d8014f88 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 19 Aug 2010 12:25:15 -0500
Subject: Integrate SIMD API from oreh/server-trunk-oreh

---
 indra/newview/llspatialpartition.cpp | 44 ++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 2335c7bb8e..e55ec03356 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -231,7 +231,7 @@ U8* get_box_fan_indices(LLCamera* camera, const LLVector4a& center)
 	LLVector4a origin;
 	origin.load3(camera->getOrigin().mV);
 
-	S32 cypher = center.greaterThan4(origin).getComparisonMask() & 0x7;
+	S32 cypher = center.greaterThan(origin).getGatheredBits() & 0x7;
 	
 	return sOcclusionIndices+cypher*8;
 }
@@ -253,7 +253,7 @@ void LLSpatialGroup::buildOcclusion()
 	r2.splat(0.25f);
 	r2.add(mBounds[1]);
 
-	r.setMin(r2);
+	r.setMin(r, r2);
 
 	LLVector4a* v = mOcclusionVerts;
 	const LLVector4a& c = mBounds[0];
@@ -775,8 +775,8 @@ BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector4a& minOut, LLVector4a& ma
 	}
 	else
 	{
-		minOut.setMin(newMin);
-		maxOut.setMax(newMax);
+		minOut.setMin(minOut, newMin);
+		maxOut.setMax(maxOut, newMax);
 	}
 		
 	return TRUE;
@@ -1220,8 +1220,8 @@ void LLSpatialGroup::updateDistance(LLCamera &camera)
 #endif
 	if (!getData().empty())
 	{
-		mRadius = mSpatialPartition->mRenderByGroup ? mObjectBounds[1].length3() :
-						(F32) mOctreeNode->getSize().length3();
+		mRadius = mSpatialPartition->mRenderByGroup ? mObjectBounds[1].getLength3().getF32() :
+						(F32) mOctreeNode->getSize().getLength3().getF32();
 		mDistance = mSpatialPartition->calcDistance(this, camera);
 		mPixelArea = mSpatialPartition->calcPixelArea(this, camera);
 	}
@@ -1241,7 +1241,7 @@ F32 LLSpatialPartition::calcDistance(LLSpatialGroup* group, LLCamera& camera)
 	{
 		LLVector4a v = eye;
 
-		dist = eye.length3();
+		dist = eye.getLength3().getF32();
 		eye.normalize3fast();
 
 		if (!group->isState(LLSpatialGroup::ALPHA_DIRTY))
@@ -1253,7 +1253,7 @@ F32 LLSpatialPartition::calcDistance(LLSpatialGroup* group, LLCamera& camera)
 				LLVector4a diff;
 				diff.setSub(view_angle, *group->mLastUpdateViewAngle);
 
-				if (diff.length3() > 0.64f)
+				if (diff.getLength3().getF32() > 0.64f)
 				{
 					*group->mViewAngle = view_angle;
 					*group->mLastUpdateViewAngle = view_angle;
@@ -1279,11 +1279,11 @@ F32 LLSpatialPartition::calcDistance(LLSpatialGroup* group, LLCamera& camera)
 		t.mul(group->mObjectBounds[1]);
 		v.sub(t);
 		
-		group->mDepth = v.dot3(ata);
+		group->mDepth = v.dot3(ata).getF32();
 	}
 	else
 	{
-		dist = eye.length3();
+		dist = eye.getLength3().getF32();
 	}
 
 	if (dist < 16.f)
@@ -1497,8 +1497,8 @@ BOOL LLSpatialGroup::rebound()
 			const LLVector4a& max = group->mExtents[1];
 			const LLVector4a& min = group->mExtents[0];
 
-			newMax.setMax(max);
-			newMin.setMin(min);
+			newMax.setMax(newMax, max);
+			newMin.setMin(newMin, min);
 		}
 
 		boundObjects(FALSE, newMin, newMax);
@@ -2196,8 +2196,8 @@ BOOL LLSpatialPartition::getVisibleExtents(LLCamera& camera, LLVector3& visMin,
 	LLOctreeCullVisExtents vis(&camera, visMina, visMaxa);
 	vis.traverse(mOctree);
 
-	visMin.set(visMina.getF32());
-	visMax.set(visMaxa.getF32());
+	visMin.set(visMina.getF32ptr());
+	visMax.set(visMaxa.getF32ptr());
 	return vis.mEmpty;
 }
 
@@ -2280,13 +2280,13 @@ BOOL earlyFail(LLCamera* camera, LLSpatialGroup* group)
 	LLVector4a max;
 	max.setAdd(c,r);
 	
-	S32 lt = e.lessThan4(min).getComparisonMask() & 0x7;
+	S32 lt = e.lessThan(min).getGatheredBits() & 0x7;
 	if (lt)
 	{
 		return FALSE;
 	}
 
-	S32 gt = e.greaterThan4(max).getComparisonMask() & 0x7;
+	S32 gt = e.greaterThan(max).getGatheredBits() & 0x7;
 	if (gt)
 	{
 		return FALSE;
@@ -2745,8 +2745,8 @@ void renderNormals(LLDrawable* drawablep)
 				p.setAdd(face.mPositions[j], n);
 				
 				gGL.color4f(1,1,1,1);
-				gGL.vertex3fv(face.mPositions[j].getF32());
-				gGL.vertex3fv(p.getF32());
+				gGL.vertex3fv(face.mPositions[j].getF32ptr());
+				gGL.vertex3fv(p.getF32ptr());
 				
 				if (face.mBinormals)
 				{
@@ -2754,8 +2754,8 @@ void renderNormals(LLDrawable* drawablep)
 					p.setAdd(face.mPositions[j], n);
 				
 					gGL.color4f(0,1,1,1);
-					gGL.vertex3fv(face.mPositions[j].getF32());
-					gGL.vertex3fv(p.getF32());
+					gGL.vertex3fv(face.mPositions[j].getF32ptr());
+					gGL.vertex3fv(p.getF32ptr());
 				}	
 			}
 
@@ -3024,8 +3024,8 @@ public:
 		LLVolumeOctreeListener* vl = (LLVolumeOctreeListener*) branch->getListener(0);
 
 		LLVector3 center, size;
-		center.set(vl->mBounds[0].getF32());
-		size.set(vl->mBounds[1].getF32());
+		center.set(vl->mBounds[0].getF32ptr());
+		size.set(vl->mBounds[1].getF32ptr());
 
 		drawBoxOutline(center, size);
 	}
-- 
cgit v1.2.3


From 8a67b31d6a775ef87d29e2c3e22e30368adf59b0 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 26 Aug 2010 17:06:59 -0500
Subject: Fix for various physics shape rendering glitches.

---
 indra/newview/llspatialpartition.cpp | 148 ++++++++++++++++++++---------------
 1 file changed, 87 insertions(+), 61 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index e55ec03356..291cc76c29 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2766,78 +2766,101 @@ void renderNormals(LLDrawable* drawablep)
 	}
 }
 
-void renderPhysicsShape(LLDrawable* drawable)
+void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 {
-	LLVOVolume* volume = drawable->getVOVolume();
-	if (volume)
-	{
-		F32 threshold = gSavedSettings.getF32("ObjectCostHighThreshold");
-		F32 cost = volume->getObjectCost();
+	F32 threshold = gSavedSettings.getF32("ObjectCostHighThreshold");
+	F32 cost = volume->getObjectCost();
 
-		LLColor4 low = gSavedSettings.getColor4("ObjectCostLowColor");
-		LLColor4 mid = gSavedSettings.getColor4("ObjectCostMidColor");
-		LLColor4 high = gSavedSettings.getColor4("ObjectCostHighColor");
+	LLColor4 low = gSavedSettings.getColor4("ObjectCostLowColor");
+	LLColor4 mid = gSavedSettings.getColor4("ObjectCostMidColor");
+	LLColor4 high = gSavedSettings.getColor4("ObjectCostHighColor");
 
-		F32 normalizedCost = 1.f - exp( -(cost / threshold) );
+	F32 normalizedCost = 1.f - exp( -(cost / threshold) );
 
-		LLColor4 color;
-		if ( normalizedCost <= 0.5f )
-		{
-			color = lerp( low, mid, 2.f * normalizedCost );
-		}
-		else
-		{
-			color = lerp( mid, high, 2.f * ( normalizedCost - 0.5f ) );
-		}
+	LLColor4 color;
+	if ( normalizedCost <= 0.5f )
+	{
+		color = lerp( low, mid, 2.f * normalizedCost );
+	}
+	else
+	{
+		color = lerp( mid, high, 2.f * ( normalizedCost - 0.5f ) );
+	}
 
-		U32 data_mask = LLVertexBuffer::MAP_VERTEX;
+	U32 data_mask = LLVertexBuffer::MAP_VERTEX;
 
 #if LL_MESH_ENABLED
-		if (volume->isMesh())
-		{			
-			LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
-			const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
-			if (decomp)
-			{
-				gGL.pushMatrix();
-				glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
-				
-				gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+	if (volume->isMesh())
+	{			
+		LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
+		const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
+		if (decomp)
+		{
+			gGL.pushMatrix();
+			glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
+			
+			gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
-				for (U32 i = 0; i < decomp->mHull.size(); ++i)
-				{		
-					LLVertexBuffer* buff = decomp->mMesh[i];
+			for (U32 i = 0; i < decomp->mHull.size(); ++i)
+			{		
+				LLVertexBuffer* buff = decomp->mMesh[i];
 
-					buff->setBuffer(data_mask);
+				buff->setBuffer(data_mask);
 
-					glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-					glColor3fv(color.mV);
-					buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
-					glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+				glColor3fv(color.mV);
+				buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
-					{
-						LLGLEnable blend(GL_BLEND);
-						gGL.setSceneBlendType(LLRender::BT_ALPHA);
-						LLGLDepthTest depth(GL_TRUE, GL_FALSE);
-						glColor4fv(color.mV);
-						buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
-					}
+				{
+					LLGLEnable blend(GL_BLEND);
+					gGL.setSceneBlendType(LLRender::BT_ALPHA);
+					LLGLDepthTest depth(GL_TRUE, GL_FALSE);
+					glColor4fv(color.mV);
+					buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 				}
+			}
 
-				gGL.popMatrix();
+			gGL.popMatrix();
 
-				return;
-			}
+			return;
 		}
+	}
 #endif //LL_MESH_ENABLED
-		
-		//push faces
-		glColor3fv(color.mV);
-		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-		pushVerts(drawable, data_mask);
-		glColor4fv(color.mV);
-		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-		pushVerts(drawable, data_mask);
+	
+	//push faces
+	glColor3fv(color.mV);
+	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	pushVerts(drawable, data_mask);
+	glColor4fv(color.mV);
+	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+	pushVerts(drawable, data_mask);
+}
+
+void renderPhysicsShapes(LLSpatialGroup* group)
+{
+	LLGLEnable blend(GL_BLEND);
+	LLGLDepthTest test(GL_TRUE, GL_FALSE);
+
+	for (LLSpatialGroup::OctreeNode::const_element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
+	{
+		LLDrawable* drawable = *i;
+		LLVOVolume* volume = drawable->getVOVolume();
+		if (volume && !volume->isAttachment() && volume->getPhysicsShapeType() != LLViewerObject::PHYSICS_SHAPE_NONE )
+		{
+			if (!group->mSpatialPartition->isBridge())
+			{
+				gGL.pushMatrix();
+				LLVector3 trans = drawable->getRegion()->getOriginAgent();
+				glTranslatef(trans.mV[0], trans.mV[1], trans.mV[2]);
+				renderPhysicsShape(drawable, volume);
+				gGL.popMatrix();
+			}
+			else
+			{
+				renderPhysicsShape(drawable, volume);
+			}
+		}
 	}
 }
 
@@ -3163,6 +3186,14 @@ public:
 				stop_glerror();
 			}
 
+			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_PHYSICS_SHAPES))
+			{
+				group->rebuildGeom();
+				group->rebuildMesh();
+
+				renderPhysicsShapes(group);
+			}
+
 			//render visibility wireframe
 			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCCLUSION))
 			{
@@ -3221,11 +3252,6 @@ public:
 				renderNormals(drawable);
 			}
 			
-			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_PHYSICS_SHAPES))
-			{
-				renderPhysicsShape(drawable);
-			}
-
 			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_BUILD_QUEUE))
 			{
 				if (drawable->isState(LLDrawable::IN_REBUILD_Q2))
-- 
cgit v1.2.3


From ae17e84d14242e0b44d9a8c9021f46885740ae3b Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 9 Sep 2010 16:57:50 -0500
Subject: Better debug visualization for raycasting (trying to track down
 raycasting bugs).

---
 indra/newview/llspatialpartition.cpp | 126 ++++++++++++++++++++++-------------
 1 file changed, 78 insertions(+), 48 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 291cc76c29..425fa42339 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3050,33 +3050,55 @@ public:
 		center.set(vl->mBounds[0].getF32ptr());
 		size.set(vl->mBounds[1].getF32ptr());
 
-		drawBoxOutline(center, size);
+		for (U32 i = 0; i < 2; i++)
+		{
+			LLGLDepthTest depth(GL_TRUE, GL_FALSE, i == 1 ? GL_LEQUAL : GL_GREATER);
+
+			if (i == 1)
+			{
+				gGL.color4f(0,1,1,0.5f);
+			}
+			else
+			{
+				gGL.color4f(0,0.5f,0.5f, 0.25f);
+			}
+
+			drawBoxOutline(center, size);
+
+			gGL.begin(LLRender::TRIANGLES);
+			for (LLOctreeNode<LLVolumeTriangle>::const_element_iter iter = branch->getData().begin();
+					iter != branch->getData().end();
+					++iter)
+			{
+				const LLVolumeTriangle* tri = *iter;
+				
+				gGL.vertex3fv(tri->mV[0]->getF32ptr());
+				gGL.vertex3fv(tri->mV[1]->getF32ptr());
+				gGL.vertex3fv(tri->mV[2]->getF32ptr());
+			}	
+			gGL.end();
+		}
 	}
 };
 
 void renderRaycast(LLDrawable* drawablep)
 {
-	if (drawablep->getVObj() != gDebugRaycastObject)
-	{
-		return;
-	}
-	
 	if (drawablep->getNumFaces())
 	{
 		LLGLEnable blend(GL_BLEND);
 		gGL.color4f(0,1,1,0.5f);
 
-		if (drawablep->getVOVolume() && gDebugRaycastFaceHit != -1)
+		if (drawablep->getVOVolume())
 		{
-			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-			pushVerts(drawablep->getFace(gDebugRaycastFaceHit), LLVertexBuffer::MAP_VERTEX);
-			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+			//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+			//pushVerts(drawablep->getFace(gDebugRaycastFaceHit), LLVertexBuffer::MAP_VERTEX);
+			//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
 			LLVOVolume* vobj = drawablep->getVOVolume();
 			LLVolume* volume = vobj->getVolume();
-			if (volume && volume->getNumVolumeFaces() > gDebugRaycastFaceHit)
+			for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
 			{
-				const LLVolumeFace& face = volume->getVolumeFace(gDebugRaycastFaceHit);
+				const LLVolumeFace& face = volume->getVolumeFace(i);
 				if (!face.mOctree)
 				{
 					((LLVolumeFace*) &face)->createOctree(); 
@@ -3089,50 +3111,58 @@ void renderRaycast(LLDrawable* drawablep)
 				end = vobj->agentPositionToVolume(gDebugRaycastEnd);
 
 				LLRenderOctreeRaycast render(start, end);
+				gGL.flush();
+				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 				render.traverse(face.mOctree);
 				gGL.popMatrix();		
+				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 			}
 		}
 		else if (drawablep->isAvatar())
 		{
-			LLGLDepthTest depth(GL_FALSE);
-			LLVOAvatar* av = (LLVOAvatar*) drawablep->getVObj().get();
-			av->renderCollisionVolumes();
-		}
-
-		// draw intersection point
-		glPushMatrix();
-		glLoadMatrixd(gGLModelView);
-		LLVector3 translate = gDebugRaycastIntersection;
-		glTranslatef(translate.mV[0], translate.mV[1], translate.mV[2]);
-		LLCoordFrame orient;
-		orient.lookDir(gDebugRaycastNormal, gDebugRaycastBinormal);
-		LLMatrix4 rotation;
-		orient.getRotMatrixToParent(rotation);
-		glMultMatrixf((float*)rotation.mMatrix);
-		
-		gGL.color4f(1,0,0,0.5f);
-		drawBox(LLVector3(0, 0, 0), LLVector3(0.1f, 0.022f, 0.022f));
-		gGL.color4f(0,1,0,0.5f);
-		drawBox(LLVector3(0, 0, 0), LLVector3(0.021f, 0.1f, 0.021f));
-		gGL.color4f(0,0,1,0.5f);
-		drawBox(LLVector3(0, 0, 0), LLVector3(0.02f, 0.02f, 0.1f));
-		glPopMatrix();
-
-		// draw bounding box of prim
-		const LLVector4a* ext = drawablep->getSpatialExtents();
-
-		LLVector4a pos;
-		pos.setAdd(ext[0], ext[1]);
-		pos.mul(0.5f);
-		LLVector4a size;
-		size.setSub(ext[1], ext[0]);
-		size.mul(0.5f);
+			if (drawablep->getVObj() == gDebugRaycastObject)
+			{
+				LLGLDepthTest depth(GL_FALSE);
+				LLVOAvatar* av = (LLVOAvatar*) drawablep->getVObj().get();
+				av->renderCollisionVolumes();
+			}
+		}
 
-		LLGLDepthTest depth(GL_FALSE, GL_TRUE);
-		gGL.color4f(0,0.5f,0.5f,1);
-		drawBoxOutline(pos, size);
+		if (drawablep->getVObj() == gDebugRaycastObject)
+		{
+			// draw intersection point
+			glPushMatrix();
+			glLoadMatrixd(gGLModelView);
+			LLVector3 translate = gDebugRaycastIntersection;
+			glTranslatef(translate.mV[0], translate.mV[1], translate.mV[2]);
+			LLCoordFrame orient;
+			orient.lookDir(gDebugRaycastNormal, gDebugRaycastBinormal);
+			LLMatrix4 rotation;
+			orient.getRotMatrixToParent(rotation);
+			glMultMatrixf((float*)rotation.mMatrix);
+			
+			gGL.color4f(1,0,0,0.5f);
+			drawBox(LLVector3(0, 0, 0), LLVector3(0.1f, 0.022f, 0.022f));
+			gGL.color4f(0,1,0,0.5f);
+			drawBox(LLVector3(0, 0, 0), LLVector3(0.021f, 0.1f, 0.021f));
+			gGL.color4f(0,0,1,0.5f);
+			drawBox(LLVector3(0, 0, 0), LLVector3(0.02f, 0.02f, 0.1f));
+			glPopMatrix();
+
+			// draw bounding box of prim
+			const LLVector4a* ext = drawablep->getSpatialExtents();
+
+			LLVector4a pos;
+			pos.setAdd(ext[0], ext[1]);
+			pos.mul(0.5f);
+			LLVector4a size;
+			size.setSub(ext[1], ext[0]);
+			size.mul(0.5f);
 
+			LLGLDepthTest depth(GL_FALSE, GL_TRUE);
+			gGL.color4f(0,0.5f,0.5f,1);
+			drawBoxOutline(pos, size);
+		}
 	}
 }
 
-- 
cgit v1.2.3


From 3cda7606380109beb3f331b8b53d38914f8ba8f5 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 10 Sep 2010 14:08:12 -0500
Subject: Added test code for volume raycast octree and fixed a crash in render
 cost calculation when selecting trees/grass.  Reviewed by jwolk.

---
 indra/newview/llspatialpartition.cpp | 47 ++++++++++++++++++++++++++++++------
 1 file changed, 40 insertions(+), 7 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 425fa42339..2f0641489d 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3035,11 +3035,11 @@ class LLRenderOctreeRaycast : public LLOctreeTriangleRayIntersect
 {
 public:
 	
-	LLRenderOctreeRaycast(const LLVector3& start, const LLVector3& end)
+	
+	LLRenderOctreeRaycast(const LLVector4a& start, const LLVector4a& dir, F32* closest_t)
+		: LLOctreeTriangleRayIntersect(start, dir, NULL, closest_t, NULL, NULL, NULL, NULL)
 	{
-		mStart.load3(start.mV);
-		mEnd.load3(end.mV);
-		mDir.setSub(mEnd, mStart);
+
 	}
 
 	void visit(const LLOctreeNode<LLVolumeTriangle>* branch)
@@ -3050,6 +3050,17 @@ public:
 		center.set(vl->mBounds[0].getF32ptr());
 		size.set(vl->mBounds[1].getF32ptr());
 
+		if (branch->getData().empty())
+		{
+			gGL.color3f(1.f,0.2f,0.f);
+		}
+		else
+		{
+			gGL.color3f(0.75f, 1.f, 0.f);
+		}
+		
+		drawBoxOutline(center, size);
+		
 		for (U32 i = 0; i < 2; i++)
 		{
 			LLGLDepthTest depth(GL_TRUE, GL_FALSE, i == 1 ? GL_LEQUAL : GL_GREATER);
@@ -3061,9 +3072,17 @@ public:
 			else
 			{
 				gGL.color4f(0,0.5f,0.5f, 0.25f);
+				if (!branch->getData().empty())
+				{
+					drawBoxOutline(center, size);
+				}
+			}
+			
+			if (i == 1)
+			{
+				gGL.flush();
+				glLineWidth(3.f);
 			}
-
-			drawBoxOutline(center, size);
 
 			gGL.begin(LLRender::TRIANGLES);
 			for (LLOctreeNode<LLVolumeTriangle>::const_element_iter iter = branch->getData().begin();
@@ -3077,6 +3096,12 @@ public:
 				gGL.vertex3fv(tri->mV[2]->getF32ptr());
 			}	
 			gGL.end();
+
+			if (i == 1)
+			{
+				gGL.flush();
+				glLineWidth(1.f);
+			}
 		}
 	}
 };
@@ -3110,7 +3135,15 @@ void renderRaycast(LLDrawable* drawablep)
 				start = vobj->agentPositionToVolume(gDebugRaycastStart);
 				end = vobj->agentPositionToVolume(gDebugRaycastEnd);
 
-				LLRenderOctreeRaycast render(start, end);
+				LLVector4a starta, enda;
+				starta.load3(start.mV);
+				enda.load3(end.mV);
+				LLVector4a dir;
+				dir.setSub(enda, starta);
+
+				F32 t = 1.f;
+
+				LLRenderOctreeRaycast render(starta, dir, &t);
 				gGL.flush();
 				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 				render.traverse(face.mOctree);
-- 
cgit v1.2.3


From 90da6d6fdc33343be72252101aed1be641e822b5 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sun, 19 Sep 2010 23:07:15 -0500
Subject: Raycasting for rigged attachments now works for your own attachments
 while in edit mode.

---
 indra/newview/llspatialpartition.cpp | 80 ++++++++++++++++++++++--------------
 1 file changed, 49 insertions(+), 31 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 2f0641489d..191cdac981 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3047,19 +3047,21 @@ public:
 		LLVolumeOctreeListener* vl = (LLVolumeOctreeListener*) branch->getListener(0);
 
 		LLVector3 center, size;
-		center.set(vl->mBounds[0].getF32ptr());
-		size.set(vl->mBounds[1].getF32ptr());
-
+		
 		if (branch->getData().empty())
 		{
 			gGL.color3f(1.f,0.2f,0.f);
+			center.set(branch->getCenter().getF32ptr());
+			size.set(branch->getSize().getF32ptr());
 		}
 		else
 		{
 			gGL.color3f(0.75f, 1.f, 0.f);
+			center.set(vl->mBounds[0].getF32ptr());
+			size.set(vl->mBounds[1].getF32ptr());
 		}
-		
-		drawBoxOutline(center, size);
+
+		drawBoxOutline(center, size);	
 		
 		for (U32 i = 0; i < 2; i++)
 		{
@@ -3072,10 +3074,7 @@ public:
 			else
 			{
 				gGL.color4f(0,0.5f,0.5f, 0.25f);
-				if (!branch->getData().empty())
-				{
-					drawBoxOutline(center, size);
-				}
+				drawBoxOutline(center, size);
 			}
 			
 			if (i == 1)
@@ -3121,34 +3120,53 @@ void renderRaycast(LLDrawable* drawablep)
 
 			LLVOVolume* vobj = drawablep->getVOVolume();
 			LLVolume* volume = vobj->getVolume();
-			for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
+
+			if (drawablep->isState(LLDrawable::RIGGED))
+			{
+				volume = NULL;
+			}
+
+			if (volume)
 			{
-				const LLVolumeFace& face = volume->getVolumeFace(i);
-				if (!face.mOctree)
+				for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
 				{
-					((LLVolumeFace*) &face)->createOctree(); 
-				}
+					const LLVolumeFace& face = volume->getVolumeFace(i);
+					if (!face.mOctree)
+					{
+						((LLVolumeFace*) &face)->createOctree(); 
+					}
 
-				gGL.pushMatrix();
-				glMultMatrixf((F32*) vobj->getRelativeXform().mMatrix);
-				LLVector3 start, end;
-				start = vobj->agentPositionToVolume(gDebugRaycastStart);
-				end = vobj->agentPositionToVolume(gDebugRaycastEnd);
+					gGL.pushMatrix();
+					glMultMatrixf((F32*) vobj->getRelativeXform().mMatrix);
 
-				LLVector4a starta, enda;
-				starta.load3(start.mV);
-				enda.load3(end.mV);
-				LLVector4a dir;
-				dir.setSub(enda, starta);
+					LLVector3 start, end;
+					start = vobj->agentPositionToVolume(gDebugRaycastStart);
+					end = vobj->agentPositionToVolume(gDebugRaycastEnd);
 
-				F32 t = 1.f;
+					LLVector4a starta, enda;
+					starta.load3(start.mV);
+					enda.load3(end.mV);
+					LLVector4a dir;
+					dir.setSub(enda, starta);
 
-				LLRenderOctreeRaycast render(starta, dir, &t);
-				gGL.flush();
-				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-				render.traverse(face.mOctree);
-				gGL.popMatrix();		
-				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+					F32 t = 1.f;
+
+					LLRenderOctreeRaycast render(starta, dir, &t);
+					gGL.flush();
+					glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+
+					{
+						//render face positions
+						LLVertexBuffer::unbind();
+						glColor4f(0,1,1,0.5f);
+						glVertexPointer(3, GL_FLOAT, sizeof(LLVector4a), face.mPositions);
+						glDrawElements(GL_TRIANGLES, face.mNumIndices, GL_UNSIGNED_SHORT, face.mIndices);
+					}
+						
+					render.traverse(face.mOctree);
+					gGL.popMatrix();		
+					glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+				}
 			}
 		}
 		else if (drawablep->isAvatar())
-- 
cgit v1.2.3


From c42ed54b0a532cb4e0ad30a1b0b5038cef9938f2 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 20 Sep 2010 18:45:56 -0500
Subject: Stop using ll_aligned_malloc/free in llvolume. Fix for garbage data
 in vertex weight array crashing software skinning. Proper integration of
 picking for rigged attachhments. Optimization in LLDrawable::updateDistance
 (don't call updateRelativeXform, just use spatial group position).

---
 indra/newview/llspatialpartition.cpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 191cdac981..0f9f35dc57 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3121,9 +3121,11 @@ void renderRaycast(LLDrawable* drawablep)
 			LLVOVolume* vobj = drawablep->getVOVolume();
 			LLVolume* volume = vobj->getVolume();
 
+			bool transform = true;
 			if (drawablep->isState(LLDrawable::RIGGED))
 			{
-				volume = NULL;
+				volume = vobj->getRiggedVolume();
+				transform = false;
 			}
 
 			if (volume)
@@ -3140,8 +3142,16 @@ void renderRaycast(LLDrawable* drawablep)
 					glMultMatrixf((F32*) vobj->getRelativeXform().mMatrix);
 
 					LLVector3 start, end;
-					start = vobj->agentPositionToVolume(gDebugRaycastStart);
-					end = vobj->agentPositionToVolume(gDebugRaycastEnd);
+					if (transform)
+					{
+						start = vobj->agentPositionToVolume(gDebugRaycastStart);
+						end = vobj->agentPositionToVolume(gDebugRaycastEnd);
+					}
+					else
+					{
+						start = gDebugRaycastStart;
+						end = gDebugRaycastEnd;
+					}
 
 					LLVector4a starta, enda;
 					starta.load3(start.mV);
-- 
cgit v1.2.3


From 90e3d83a5cb35e98a02a3017dd79ebc272bbfe85 Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Tue, 21 Sep 2010 13:26:52 -0400
Subject: Fix for build failures - disabling tcmalloc for now

---
 indra/newview/llspatialpartition.cpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 indra/newview/llspatialpartition.cpp

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
old mode 100644
new mode 100755
-- 
cgit v1.2.3


From cf09d6c58a741263cddcf338c2f79836873475b1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 22 Sep 2010 03:04:21 -0500
Subject: Remove LL_MESH_ENABLED macros (fixes drag and drop).  Add mesh
 stitching type back into tools floater.

---
 indra/newview/llspatialpartition.cpp | 2 --
 1 file changed, 2 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 0f9f35dc57..56be8af599 100755
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2789,7 +2789,6 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 	U32 data_mask = LLVertexBuffer::MAP_VERTEX;
 
-#if LL_MESH_ENABLED
 	if (volume->isMesh())
 	{			
 		LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
@@ -2826,7 +2825,6 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 			return;
 		}
 	}
-#endif //LL_MESH_ENABLED
 	
 	//push faces
 	glColor3fv(color.mV);
-- 
cgit v1.2.3


From e3a515f91c796208e7eca0784ce65ce7626565a1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 1 Oct 2010 17:25:36 -0500
Subject: Rough draft of physics display better matching what's on the sim.

---
 indra/newview/llspatialpartition.cpp | 127 ++++++++++++++++++++++++++++++++---
 1 file changed, 117 insertions(+), 10 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 56be8af599..b46fc9ce63 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -48,7 +48,9 @@
 #include "llmeshrepository.h"
 #include "llrender.h"
 #include "lloctree.h"
+#include "llphysicsshapebuilderutil.h"
 #include "llvoavatar.h"
+#include "llvolumemgr.h"
 #include "lltextureatlas.h"
 
 static LLFastTimer::DeclareTimer FTM_FRUSTUM_CULL("Frustum Culling");
@@ -2341,6 +2343,17 @@ void pushVerts(LLDrawable* drawable, U32 mask)
 	}
 }
 
+void pushVerts(LLVolume* volume)
+{
+	LLVertexBuffer::unbind();
+	for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
+	{
+		const LLVolumeFace& face = volume->getVolumeFace(i);
+		glVertexPointer(3, GL_FLOAT, 16, face.mPositions);
+		glDrawElements(GL_TRIANGLES, face.mNumIndices, GL_UNSIGNED_SHORT, face.mIndices);
+	}
+}
+
 void pushBufferVerts(LLVertexBuffer* buffer, U32 mask)
 {
 	if (buffer)
@@ -2789,10 +2802,19 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 	U32 data_mask = LLVertexBuffer::MAP_VERTEX;
 
-	if (volume->isMesh())
-	{			
+	LLVolumeParams volume_params = volume->getVolume()->getParams();
+
+	LLPhysicsVolumeParams physics_params(volume->getVolume()->getParams(), false); //pass as true if type is convex hull
+	LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification physics_spec;
+	LLPhysicsShapeBuilderUtil::determinePhysicsShape(physics_params, volume->getScale(), physics_spec);
+
+	U32 type = physics_spec.getType();
+
+	if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::USER_MESH)
+	{
 		LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
 		const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
+
 		if (decomp)
 		{
 			gGL.pushMatrix();
@@ -2821,18 +2843,99 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 			}
 
 			gGL.popMatrix();
+		}
+	}
+	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::BOX)
+	{
+		gGL.pushMatrix();
+		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
+		LLVector3 center = physics_spec.getCenter();
+		LLVector3 scale = physics_spec.getScale();
+		LLVector3 vscale = volume->getScale()*2.f;
+		scale.set(scale[0]/vscale[0], scale[1]/vscale[1], scale[2]/vscale[2]);
+		
+		gGL.color4fv(color.mV);
+		drawBox(center, scale);
+		gGL.popMatrix();
+	}
+	else if	(type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::SPHERE)
+	{
+		LLVolumeParams volume_params;
+		volume_params.setType( LL_PCODE_PROFILE_CIRCLE_HALF, LL_PCODE_PATH_CIRCLE );
+		volume_params.setBeginAndEndS( 0.f, 1.f );
+		volume_params.setBeginAndEndT( 0.f, 1.f );
+		volume_params.setRatio	( 1, 1 );
+		volume_params.setShear	( 0, 0 );
+		LLVolume* sphere = LLPrimitive::sVolumeManager->refVolume(volume_params, 3);
+		
+		gGL.pushMatrix();
+		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
+		glColor4fv(color.mV);
+		pushVerts(sphere);
+		gGL.popMatrix();
+		LLPrimitive::sVolumeManager->unrefVolume(sphere);
+	}
+	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::CYLINDER)
+	{
+		LLVolumeParams volume_params;
+		volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
+		volume_params.setBeginAndEndS( 0.f, 1.f );
+		volume_params.setBeginAndEndT( 0.f, 1.f );
+		volume_params.setRatio	( 1, 1 );
+		volume_params.setShear	( 0, 0 );
+		LLVolume* cylinder = LLPrimitive::sVolumeManager->refVolume(volume_params, 3);
+		
+		gGL.pushMatrix();
+		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
+		glColor4fv(color.mV);
+		pushVerts(cylinder);
+		gGL.popMatrix();
+		LLPrimitive::sVolumeManager->unrefVolume(cylinder);
+	}
+	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::PRIM_MESH)
+	{
+		LLVolumeParams volume_params = volume->getVolume()->getParams();
 
-			return;
+		const S32 DEFAULT_DETAIL = 1;
+		const F32 LARGE_THRESHOLD = 5.f;
+		const F32 MEGA_THRESHOLD = 25.f;
+
+		S32 detail = DEFAULT_DETAIL;
+		LLVector3 scale = volume->getScale();
+		F32 avg_scale = (scale[0]+scale[1]+scale[2])/3.f;
+
+		if (avg_scale > LARGE_THRESHOLD)
+		{
+			detail += 1;
+			if (avg_scale > MEGA_THRESHOLD)
+			{
+				detail += 1;
+			}
 		}
+
+		LLVolume* phys_volume = LLPrimitive::sVolumeManager->refVolume(volume_params, detail);
+		gGL.pushMatrix();
+		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+		
+		glColor3fv(color.mV);
+		pushVerts(phys_volume);
+		
+		glColor4fv(color.mV);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+		pushVerts(phys_volume);
+		gGL.popMatrix();
+		LLPrimitive::sVolumeManager->unrefVolume(phys_volume);
 	}
 	
-	//push faces
-	glColor3fv(color.mV);
-	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-	pushVerts(drawable, data_mask);
-	glColor4fv(color.mV);
-	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-	pushVerts(drawable, data_mask);
+	/*{ //analytical shape, just push visual rep.
+		glColor3fv(color.mV);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+		pushVerts(drawable, data_mask);
+		glColor4fv(color.mV);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+		pushVerts(drawable, data_mask);
+	}*/
 }
 
 void renderPhysicsShapes(LLSpatialGroup* group)
@@ -2840,6 +2943,10 @@ void renderPhysicsShapes(LLSpatialGroup* group)
 	LLGLEnable blend(GL_BLEND);
 	LLGLDepthTest test(GL_TRUE, GL_FALSE);
 
+	LLGLEnable offset_fill(GL_POLYGON_OFFSET_FILL);
+	LLGLEnable offset_line(GL_POLYGON_OFFSET_LINE);
+	glPolygonOffset(-1.f, -1.f);
+
 	for (LLSpatialGroup::OctreeNode::const_element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
 	{
 		LLDrawable* drawable = *i;
-- 
cgit v1.2.3


From 1327e124384a1d29fe573182cd98146d39981895 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sun, 3 Oct 2010 00:55:59 -0500
Subject: Correct rendering of prims as user meshes/analytical shapes when not
 set to convex hull or no physics.

---
 indra/newview/llspatialpartition.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index b46fc9ce63..327e29c6e4 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2781,6 +2781,13 @@ void renderNormals(LLDrawable* drawablep)
 
 void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 {
+	U8 physics_type = volume->getPhysicsShapeType();
+
+	if (physics_type == LLViewerObject::PHYSICS_SHAPE_NONE)
+	{
+		return;
+	}
+
 	F32 threshold = gSavedSettings.getF32("ObjectCostHighThreshold");
 	F32 cost = volume->getObjectCost();
 
@@ -2804,7 +2811,9 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 	LLVolumeParams volume_params = volume->getVolume()->getParams();
 
-	LLPhysicsVolumeParams physics_params(volume->getVolume()->getParams(), false); //pass as true if type is convex hull
+	LLPhysicsVolumeParams physics_params(volume->getVolume()->getParams(), 
+		physics_type == LLViewerObject::PHYSICS_SHAPE_CONVEX_HULL); 
+
 	LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification physics_spec;
 	LLPhysicsShapeBuilderUtil::determinePhysicsShape(physics_params, volume->getScale(), physics_spec);
 
-- 
cgit v1.2.3


From 478e0927c87338e02e75d3791f51ad2b4e7b8c74 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 4 Oct 2010 09:48:05 -0500
Subject: Interface/state for rendering convex hull physics shapes.  Still need
 to implement gMeshRepo.buildHull

---
 indra/newview/llspatialpartition.cpp | 70 ++++++++++++++++++++++++++----------
 1 file changed, 52 insertions(+), 18 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 327e29c6e4..148c222014 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2779,6 +2779,27 @@ void renderNormals(LLDrawable* drawablep)
 	}
 }
 
+S32 get_physics_detail(const LLVolumeParams& volume_params, const LLVector3& scale)
+{
+	const S32 DEFAULT_DETAIL = 1;
+	const F32 LARGE_THRESHOLD = 5.f;
+	const F32 MEGA_THRESHOLD = 25.f;
+
+	S32 detail = DEFAULT_DETAIL;
+	F32 avg_scale = (scale[0]+scale[1]+scale[2])/3.f;
+
+	if (avg_scale > LARGE_THRESHOLD)
+	{
+		detail += 1;
+		if (avg_scale > MEGA_THRESHOLD)
+		{
+			detail += 1;
+		}
+	}
+
+	return detail;
+}
+
 void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 {
 	U8 physics_type = volume->getPhysicsShapeType();
@@ -2904,23 +2925,7 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::PRIM_MESH)
 	{
 		LLVolumeParams volume_params = volume->getVolume()->getParams();
-
-		const S32 DEFAULT_DETAIL = 1;
-		const F32 LARGE_THRESHOLD = 5.f;
-		const F32 MEGA_THRESHOLD = 25.f;
-
-		S32 detail = DEFAULT_DETAIL;
-		LLVector3 scale = volume->getScale();
-		F32 avg_scale = (scale[0]+scale[1]+scale[2])/3.f;
-
-		if (avg_scale > LARGE_THRESHOLD)
-		{
-			detail += 1;
-			if (avg_scale > MEGA_THRESHOLD)
-			{
-				detail += 1;
-			}
-		}
+		S32 detail = get_physics_detail(volume_params, volume->getScale());
 
 		LLVolume* phys_volume = LLPrimitive::sVolumeManager->refVolume(volume_params, detail);
 		gGL.pushMatrix();
@@ -2936,7 +2941,36 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		gGL.popMatrix();
 		LLPrimitive::sVolumeManager->unrefVolume(phys_volume);
 	}
-	
+	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::PRIM_CONVEX)
+	{
+		LLVolumeParams volume_params = volume->getVolume()->getParams();
+		S32 detail = get_physics_detail(volume_params, volume->getScale());
+
+		LLVolume* phys_volume = LLPrimitive::sVolumeManager->refVolume(volume_params, detail);
+
+		if (phys_volume->mHullPoints && phys_volume->mHullIndices)
+		{
+			gGL.pushMatrix();
+			glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
+			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+			
+			LLVertexBuffer::unbind();
+			glVertexPointer(3, GL_FLOAT, 16, phys_volume->mHullPoints);
+			glColor3fv(color.mV);
+			glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
+			
+			glColor4fv(color.mV);
+			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+			glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);			
+			gGL.popMatrix();
+		}
+		else
+		{
+			gMeshRepo.buildHull(volume_params, detail);
+		}
+		LLPrimitive::sVolumeManager->unrefVolume(phys_volume);
+	}
+
 	/*{ //analytical shape, just push visual rep.
 		glColor3fv(color.mV);
 		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-- 
cgit v1.2.3


From 24e0d62a5eb3299a877d7a6b37e1881ec3d1ca0c Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 6 Oct 2010 01:17:12 -0500
Subject: Added mandatory single hull simplification to mesh upload.

---
 indra/newview/llspatialpartition.cpp | 39 ++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 148c222014..b99829c3e4 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2800,6 +2800,38 @@ S32 get_physics_detail(const LLVolumeParams& volume_params, const LLVector3& sca
 	return detail;
 }
 
+void renderMeshBaseHull(LLVOVolume* volume, U32 data_mask, LLColor4& color)
+{
+	LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
+	const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
+
+	if (decomp)
+	{
+		gGL.pushMatrix();
+		glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
+		
+		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
+		LLVertexBuffer* buff = decomp->mBaseHullMesh;
+
+		buff->setBuffer(data_mask);
+
+		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+		glColor3fv(color.mV);
+		buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+		{
+			LLGLEnable blend(GL_BLEND);
+			gGL.setSceneBlendType(LLRender::BT_ALPHA);
+			LLGLDepthTest depth(GL_TRUE, GL_FALSE);
+			glColor4fv(color.mV);
+			buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+		}
+		gGL.popMatrix();
+	}
+}
+
 void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 {
 	U8 physics_type = volume->getPhysicsShapeType();
@@ -2875,6 +2907,13 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 			gGL.popMatrix();
 		}
 	}
+	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::USER_CONVEX)
+	{
+		if (volume->isMesh())
+		{
+			renderMeshBaseHull(volume, data_mask, color);
+		}
+	}
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::BOX)
 	{
 		gGL.pushMatrix();
-- 
cgit v1.2.3


From ca1f7828b236b9a692f04e390975e8fcda13d597 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 7 Oct 2010 15:37:07 -0500
Subject: Update convex decomp and physics shape display to include convex
 hulls for prims where appropriate.

---
 indra/newview/llspatialpartition.cpp | 99 +++++++++++++++++++++++++++++++++++-
 1 file changed, 98 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index b99829c3e4..68f3fdb1a0 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2907,12 +2907,109 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 			gGL.popMatrix();
 		}
 	}
-	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::USER_CONVEX)
+	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::USER_CONVEX ||
+		type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::PRIM_CONVEX)
 	{
 		if (volume->isMesh())
 		{
 			renderMeshBaseHull(volume, data_mask, color);
 		}
+#if 0 && LL_WINDOWS 
+		else
+		{
+			LLVolumeParams volume_params = volume->getVolume()->getParams();
+			S32 detail = get_physics_detail(volume_params, volume->getScale());
+			LLVolume* phys_volume = LLPrimitive::sVolumeManager->refVolume(volume_params, detail);
+
+			if (!phys_volume->mHullPoints)
+			{ //build convex hull
+				std::vector<LLVector3> pos;
+				std::vector<U16> index;
+
+				S32 index_offset = 0;
+
+				for (S32 i = 0; i < phys_volume->getNumVolumeFaces(); ++i)
+				{
+					const LLVolumeFace& face = phys_volume->getVolumeFace(i);
+					if (index_offset + face.mNumVertices > 65535)
+					{
+						continue;
+					}
+
+					for (S32 j = 0; j < face.mNumVertices; ++j)
+					{
+						pos.push_back(LLVector3(face.mPositions[j].getF32ptr()));
+					}
+
+					for (S32 j = 0; j < face.mNumIndices; ++j)
+					{
+						index.push_back(face.mIndices[j]+index_offset);
+					}
+
+					index_offset += face.mNumVertices;
+				}
+
+				LLCDMeshData mesh;
+				mesh.mIndexBase = &index[0];
+				mesh.mVertexBase = pos[0].mV;
+				mesh.mNumVertices = pos.size();
+				mesh.mVertexStrideBytes = 12;
+				mesh.mIndexStrideBytes = 6;
+				mesh.mIndexType = LLCDMeshData::INT_16;
+
+				mesh.mNumTriangles = index.size()/3;
+				
+				LLCDMeshData res;
+
+				LLConvexDecomposition::getInstance()->generateSingleHullMeshFromMesh( &mesh, &res );
+
+				//copy res into phys_volume
+				phys_volume->mHullPoints = (LLVector4a*) malloc(sizeof(LLVector4a)*res.mNumVertices);
+				phys_volume->mNumHullPoints = res.mNumVertices;
+
+				S32 idx_size = (res.mNumTriangles*3*2+0xF) & ~0xF;
+				phys_volume->mHullIndices = (U16*) malloc(idx_size);
+				phys_volume->mNumHullIndices = res.mNumTriangles*3;
+
+				const F32* v = mesh.mVertexBase;
+
+				for (S32 i = 0; i < res.mNumVertices; ++i)
+				{
+					F32* p = (F32*) ((U8*)v+i*mesh.mVertexStrideBytes);
+					phys_volume->mHullPoints[i].load3(p);
+				}
+
+				for (S32 i = 0; i < res.mNumTriangles; ++i)
+				{
+					U16* idx = (U16*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
+
+					phys_volume->mHullIndices[i*3+0] = idx[0];
+					phys_volume->mHullIndices[i*3+1] = idx[1];
+					phys_volume->mHullIndices[i*3+2] = idx[2];
+				}
+			}
+
+			if (phys_volume->mHullPoints)
+			{
+				//render hull
+				gGL.pushMatrix();
+				glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
+				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+				
+				glColor3fv(color.mV);
+				LLVertexBuffer::unbind();
+				glVertexPointer(3, GL_FLOAT, 16, phys_volume->mHullPoints);
+				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
+				
+				glColor4fv(color.mV);
+				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
+				gGL.popMatrix();
+			}
+
+			LLPrimitive::sVolumeManager->unrefVolume(phys_volume);
+		}
+#endif //LL_WINDOWS			
 	}
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::BOX)
 	{
-- 
cgit v1.2.3


From 578389ce23960180610fce932eac1b7816ed8f68 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 7 Oct 2010 16:48:13 -0500
Subject: Fix for crash when attempting to render single hull rep when no such
 rep is available.

---
 indra/newview/llspatialpartition.cpp | 37 +++++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 17 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 68f3fdb1a0..929405232a 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2806,29 +2806,32 @@ void renderMeshBaseHull(LLVOVolume* volume, U32 data_mask, LLColor4& color)
 	const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
 
 	if (decomp)
-	{
-		gGL.pushMatrix();
-		glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
-		
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
+	{		
 		LLVertexBuffer* buff = decomp->mBaseHullMesh;
 
-		buff->setBuffer(data_mask);
+		if (buff)
+		{
+			gGL.pushMatrix();
+			glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
+			
+			gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
-		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-		glColor3fv(color.mV);
-		buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
-		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+			buff->setBuffer(data_mask);
 
-		{
-			LLGLEnable blend(GL_BLEND);
-			gGL.setSceneBlendType(LLRender::BT_ALPHA);
-			LLGLDepthTest depth(GL_TRUE, GL_FALSE);
-			glColor4fv(color.mV);
+			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+			glColor3fv(color.mV);
 			buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+			{
+				LLGLEnable blend(GL_BLEND);
+				gGL.setSceneBlendType(LLRender::BT_ALPHA);
+				LLGLDepthTest depth(GL_TRUE, GL_FALSE);
+				glColor4fv(color.mV);
+				buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+			}
+			gGL.popMatrix();
 		}
-		gGL.popMatrix();
 	}
 }
 
-- 
cgit v1.2.3


From a5619d16f74863168f45b04b37cc6383e1a92263 Mon Sep 17 00:00:00 2001
From: Oz Linden <oz@lindenlab.com>
Date: Wed, 13 Oct 2010 07:24:37 -0400
Subject: correct licenses (fix problem with license change merge)

---
 indra/newview/llspatialpartition.cpp | 36 +++++++++++++++---------------------
 1 file changed, 15 insertions(+), 21 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 929405232a..5cfa8cb9cb 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2,31 +2,25 @@
  * @file llspatialpartition.cpp
  * @brief LLSpatialGroup class implementation and supporting functions
  *
- * $LicenseInfo:firstyear=2003&license=viewergpl$
- * 
- * Copyright (c) 2003-2009, Linden Research, Inc.
- * 
+ * $LicenseInfo:firstyear=2003&license=viewerlgpl$
  * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 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.
  * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 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.
  * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
+ * 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
  * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
-- 
cgit v1.2.3


From dcb43490a512ff0aa6a56fdc008d2118ea3dad9a Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 15 Oct 2010 14:04:26 -0500
Subject: Proper loading of hull indices, bad use of initThread

---
 indra/newview/llspatialpartition.cpp | 47 ++++++++++++++++++++++++++++--------
 1 file changed, 37 insertions(+), 10 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 5cfa8cb9cb..c40a411978 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2833,7 +2833,7 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 {
 	U8 physics_type = volume->getPhysicsShapeType();
 
-	if (physics_type == LLViewerObject::PHYSICS_SHAPE_NONE)
+	if (physics_type == LLViewerObject::PHYSICS_SHAPE_NONE || volume->isFlexible())
 	{
 		return;
 	}
@@ -2958,6 +2958,8 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 				
 				LLCDMeshData res;
 
+				LLConvexDecomposition::getInstance()->initThread();
+
 				LLConvexDecomposition::getInstance()->generateSingleHullMeshFromMesh( &mesh, &res );
 
 				//copy res into phys_volume
@@ -2976,14 +2978,30 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 					phys_volume->mHullPoints[i].load3(p);
 				}
 
-				for (S32 i = 0; i < res.mNumTriangles; ++i)
+				if (res.mIndexType == LLCDMeshData::INT_16)
+				{
+					for (S32 i = 0; i < res.mNumTriangles; ++i)
+					{
+						U16* idx = (U16*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
+
+						phys_volume->mHullIndices[i*3+0] = idx[0];
+						phys_volume->mHullIndices[i*3+1] = idx[1];
+						phys_volume->mHullIndices[i*3+2] = idx[2];
+					}
+				}
+				else
 				{
-					U16* idx = (U16*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
+					for (S32 i = 0; i < res.mNumTriangles; ++i)
+					{
+						U32* idx = (U32*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
 
-					phys_volume->mHullIndices[i*3+0] = idx[0];
-					phys_volume->mHullIndices[i*3+1] = idx[1];
-					phys_volume->mHullIndices[i*3+2] = idx[2];
+						phys_volume->mHullIndices[i*3+0] = (U16) idx[0];
+						phys_volume->mHullIndices[i*3+1] = (U16) idx[1];
+						phys_volume->mHullIndices[i*3+2] = (U16) idx[2];
+					}
 				}
+
+				LLConvexDecomposition::getInstance()->quitThread();
 			}
 
 			if (phys_volume->mHullPoints)
@@ -2995,12 +3013,21 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 				
 				glColor3fv(color.mV);
 				LLVertexBuffer::unbind();
-				glVertexPointer(3, GL_FLOAT, 16, phys_volume->mHullPoints);
-				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
+
+				glPointSize(2.f);
+				gGL.begin(LLRender::POINTS);
+				gGL.color3fv(color.mV);
+				for (U32 i = 0; i < phys_volume->mNumHullPoints; i++)
+				{
+					gGL.vertex3fv(phys_volume->mHullPoints[i].getF32ptr());
+				}
+				gGL.end();
+				gGL.flush();				
+				//glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
 				
-				glColor4fv(color.mV);
+				/*glColor4fv(color.mV);
 				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
+				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);*/
 				gGL.popMatrix();
 			}
 
-- 
cgit v1.2.3


From 997d66d348b3c6a19ecd2f5b092f68f645712eb1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 15 Oct 2010 16:33:22 -0500
Subject: Fix for various crashes on exit and leaks when using convex
 decomposition. Make rendering of convex hullified prims work in physics shape
 display.

Reviewed by Falcon.
---
 indra/newview/llspatialpartition.cpp | 26 +++++++-------------------
 1 file changed, 7 insertions(+), 19 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index c40a411978..6ce6a3ecdb 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2911,7 +2911,7 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		{
 			renderMeshBaseHull(volume, data_mask, color);
 		}
-#if 0 && LL_WINDOWS 
+#if LL_WINDOWS 
 		else
 		{
 			LLVolumeParams volume_params = volume->getVolume()->getParams();
@@ -2958,8 +2958,6 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 				
 				LLCDMeshData res;
 
-				LLConvexDecomposition::getInstance()->initThread();
-
 				LLConvexDecomposition::getInstance()->generateSingleHullMeshFromMesh( &mesh, &res );
 
 				//copy res into phys_volume
@@ -2970,11 +2968,11 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 				phys_volume->mHullIndices = (U16*) malloc(idx_size);
 				phys_volume->mNumHullIndices = res.mNumTriangles*3;
 
-				const F32* v = mesh.mVertexBase;
+				const F32* v = res.mVertexBase;
 
 				for (S32 i = 0; i < res.mNumVertices; ++i)
 				{
-					F32* p = (F32*) ((U8*)v+i*mesh.mVertexStrideBytes);
+					F32* p = (F32*) ((U8*)v+i*res.mVertexStrideBytes);
 					phys_volume->mHullPoints[i].load3(p);
 				}
 
@@ -3000,8 +2998,6 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 						phys_volume->mHullIndices[i*3+2] = (U16) idx[2];
 					}
 				}
-
-				LLConvexDecomposition::getInstance()->quitThread();
 			}
 
 			if (phys_volume->mHullPoints)
@@ -3014,20 +3010,12 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 				glColor3fv(color.mV);
 				LLVertexBuffer::unbind();
 
-				glPointSize(2.f);
-				gGL.begin(LLRender::POINTS);
-				gGL.color3fv(color.mV);
-				for (U32 i = 0; i < phys_volume->mNumHullPoints; i++)
-				{
-					gGL.vertex3fv(phys_volume->mHullPoints[i].getF32ptr());
-				}
-				gGL.end();
-				gGL.flush();				
-				//glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
+				glVertexPointer(3, GL_FLOAT, 16, phys_volume->mHullPoints);
+				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
 				
-				/*glColor4fv(color.mV);
+				glColor4fv(color.mV);
 				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);*/
+				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
 				gGL.popMatrix();
 			}
 
-- 
cgit v1.2.3


From 028bb02a6b325f8a1079030414872ab20db944ca Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sat, 16 Oct 2010 04:02:52 -0500
Subject: Better physics shape display.

---
 indra/newview/llspatialpartition.cpp | 224 ++++++++++++++++++++++++-----------
 1 file changed, 153 insertions(+), 71 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 6ce6a3ecdb..e763f92fab 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2794,43 +2794,68 @@ S32 get_physics_detail(const LLVolumeParams& volume_params, const LLVector3& sca
 	return detail;
 }
 
-void renderMeshBaseHull(LLVOVolume* volume, U32 data_mask, LLColor4& color)
+void renderMeshBaseHull(LLVOVolume* volume, U32 data_mask, LLColor4& color, LLColor4& line_color)
 {
 	LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
 	const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
 
+	const LLVector3 center(0,0,0);
+	const LLVector3 size(0.25f,0.25f,0.25f);
+
 	if (decomp)
 	{		
 		LLVertexBuffer* buff = decomp->mBaseHullMesh;
 
-		if (buff)
+		if (buff && buff->getNumVerts() > 0)
 		{
-			gGL.pushMatrix();
-			glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
-			
-			gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
 			buff->setBuffer(data_mask);
 
 			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-			glColor3fv(color.mV);
+			glColor4fv(line_color.mV);
 			buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
 			{
-				LLGLEnable blend(GL_BLEND);
-				gGL.setSceneBlendType(LLRender::BT_ALPHA);
-				LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 				glColor4fv(color.mV);
 				buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 			}
-			gGL.popMatrix();
 		}
+		else
+		{
+			gGL.color3f(0,1,1);
+			drawBoxOutline(center, size);
+		}
+
+	}
+	else
+	{
+		gGL.color3f(1,0,1);
+		drawBoxOutline(center, size);
 	}
 }
 
+void render_hull(LLVertexBuffer* buff, U32 data_mask, const LLColor4& color, const LLColor4& line_color)
+{
+	buff->setBuffer(data_mask);
+
+	glColor4fv(color.mV);
+	buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+
+	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	glColor4fv(line_color.mV);
+	buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+}
+
 void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 {
+	if (volume->isSelected())
+	{
+		LLVector3 construct_me(5,5,5);
+		construct_me.normalize();
+	}
+
+	
 	U8 physics_type = volume->getPhysicsShapeType();
 
 	if (physics_type == LLViewerObject::PHYSICS_SHAPE_NONE || volume->isFlexible())
@@ -2838,6 +2863,8 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		return;
 	}
 
+	//not allowed to return at this point without rendering *something*
+
 	F32 threshold = gSavedSettings.getF32("ObjectCostHighThreshold");
 	F32 cost = volume->getObjectCost();
 
@@ -2857,6 +2884,8 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		color = lerp( mid, high, 2.f * ( normalizedCost - 0.5f ) );
 	}
 
+	LLColor4 line_color = color*0.5f;
+
 	U32 data_mask = LLVertexBuffer::MAP_VERTEX;
 
 	LLVolumeParams volume_params = volume->getVolume()->getParams();
@@ -2869,39 +2898,55 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 	U32 type = physics_spec.getType();
 
+	LLVector3 center(0,0,0);
+	LLVector3 size(0.25f,0.25f,0.25f);
+
+	gGL.pushMatrix();
+	glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
+		
 	if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::USER_MESH)
 	{
 		LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
 		const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
-
+			
 		if (decomp)
-		{
-			gGL.pushMatrix();
-			glMultMatrixf((F32*) volume->getRelativeXform().mMatrix);
+		{ //render a physics based mesh
 			
 			gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
-			for (U32 i = 0; i < decomp->mHull.size(); ++i)
-			{		
-				LLVertexBuffer* buff = decomp->mMesh[i];
-
-				buff->setBuffer(data_mask);
-
+			if (!decomp->mHull.empty())
+			{ //decomposition exists, use that
+				for (U32 i = 0; i < decomp->mHull.size(); ++i)
+				{		
+					render_hull(decomp->mMesh[i], data_mask, color, line_color);
+				}
+			}
+			else if (decomp->mPhysicsShapeMesh.notNull() && decomp->mPhysicsShapeMesh->getNumVerts() > 0)
+			{ 
+				//decomp has physics mesh, render that mesh
+				glColor4fv(color.mV);
+				pushBufferVerts(decomp->mPhysicsShapeMesh, data_mask);
+				
 				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-				glColor3fv(color.mV);
-				buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+				glColor4fv(line_color.mV);
+				pushBufferVerts(decomp->mPhysicsShapeMesh, data_mask);
 				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+			}
+			else
+			{ //no mesh or decomposition, render base hull
+				renderMeshBaseHull(volume, data_mask, color, line_color);
 
+				if (decomp->mPhysicsShapeMesh.isNull())
 				{
-					LLGLEnable blend(GL_BLEND);
-					gGL.setSceneBlendType(LLRender::BT_ALPHA);
-					LLGLDepthTest depth(GL_TRUE, GL_FALSE);
-					glColor4fv(color.mV);
-					buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+					//attempt to fetch physics shape mesh if available
+					gMeshRepo.fetchPhysicsShape(mesh_id);
 				}
 			}
-
-			gGL.popMatrix();
+		}
+		else
+		{	
+			gGL.color3f(1,1,0);
+			drawBoxOutline(center, size);
 		}
 	}
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::USER_CONVEX ||
@@ -2909,7 +2954,7 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 	{
 		if (volume->isMesh())
 		{
-			renderMeshBaseHull(volume, data_mask, color);
+			renderMeshBaseHull(volume, data_mask, color, line_color);
 		}
 #if LL_WINDOWS 
 		else
@@ -3003,11 +3048,10 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 			if (phys_volume->mHullPoints)
 			{
 				//render hull
-				gGL.pushMatrix();
-				glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
+			
 				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 				
-				glColor3fv(color.mV);
+				glColor4fv(line_color.mV);
 				LLVertexBuffer::unbind();
 
 				glVertexPointer(3, GL_FLOAT, 16, phys_volume->mHullPoints);
@@ -3016,7 +3060,11 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 				glColor4fv(color.mV);
 				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 				glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
-				gGL.popMatrix();
+			}
+			else
+			{
+				gGL.color3f(1,0,1);
+				drawBoxOutline(center, size);
 			}
 
 			LLPrimitive::sVolumeManager->unrefVolume(phys_volume);
@@ -3025,8 +3073,6 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 	}
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::BOX)
 	{
-		gGL.pushMatrix();
-		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
 		LLVector3 center = physics_spec.getCenter();
 		LLVector3 scale = physics_spec.getScale();
 		LLVector3 vscale = volume->getScale()*2.f;
@@ -3034,7 +3080,6 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		
 		gGL.color4fv(color.mV);
 		drawBox(center, scale);
-		gGL.popMatrix();
 	}
 	else if	(type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::SPHERE)
 	{
@@ -3046,11 +3091,8 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		volume_params.setShear	( 0, 0 );
 		LLVolume* sphere = LLPrimitive::sVolumeManager->refVolume(volume_params, 3);
 		
-		gGL.pushMatrix();
-		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
 		glColor4fv(color.mV);
 		pushVerts(sphere);
-		gGL.popMatrix();
 		LLPrimitive::sVolumeManager->unrefVolume(sphere);
 	}
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::CYLINDER)
@@ -3063,11 +3105,8 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		volume_params.setShear	( 0, 0 );
 		LLVolume* cylinder = LLPrimitive::sVolumeManager->refVolume(volume_params, 3);
 		
-		gGL.pushMatrix();
-		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
 		glColor4fv(color.mV);
 		pushVerts(cylinder);
-		gGL.popMatrix();
 		LLPrimitive::sVolumeManager->unrefVolume(cylinder);
 	}
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::PRIM_MESH)
@@ -3076,17 +3115,14 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 		S32 detail = get_physics_detail(volume_params, volume->getScale());
 
 		LLVolume* phys_volume = LLPrimitive::sVolumeManager->refVolume(volume_params, detail);
-		gGL.pushMatrix();
-		glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
 		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 		
-		glColor3fv(color.mV);
+		glColor4fv(line_color.mV);
 		pushVerts(phys_volume);
 		
 		glColor4fv(color.mV);
 		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 		pushVerts(phys_volume);
-		gGL.popMatrix();
 		LLPrimitive::sVolumeManager->unrefVolume(phys_volume);
 	}
 	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::PRIM_CONVEX)
@@ -3098,26 +3134,35 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 		if (phys_volume->mHullPoints && phys_volume->mHullIndices)
 		{
-			gGL.pushMatrix();
-			glMultMatrixf((GLfloat*) volume->getRelativeXform().mMatrix);
 			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 			
 			LLVertexBuffer::unbind();
 			glVertexPointer(3, GL_FLOAT, 16, phys_volume->mHullPoints);
-			glColor3fv(color.mV);
+			glColor4fv(line_color.mV);
 			glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);
 			
 			glColor4fv(color.mV);
 			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 			glDrawElements(GL_TRIANGLES, phys_volume->mNumHullIndices, GL_UNSIGNED_SHORT, phys_volume->mHullIndices);			
-			gGL.popMatrix();
 		}
 		else
 		{
+			gGL.color3f(1,0,1);
+			drawBoxOutline(center, size);
 			gMeshRepo.buildHull(volume_params, detail);
 		}
 		LLPrimitive::sVolumeManager->unrefVolume(phys_volume);
 	}
+	else if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::SCULPT)
+	{
+		//TODO: implement sculpted prim physics display
+	}
+	else 
+	{
+		llerrs << "Unhandled type" << llendl;
+	}
+
+	gGL.popMatrix();
 
 	/*{ //analytical shape, just push visual rep.
 		glColor3fv(color.mV);
@@ -3131,13 +3176,6 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 void renderPhysicsShapes(LLSpatialGroup* group)
 {
-	LLGLEnable blend(GL_BLEND);
-	LLGLDepthTest test(GL_TRUE, GL_FALSE);
-
-	LLGLEnable offset_fill(GL_POLYGON_OFFSET_FILL);
-	LLGLEnable offset_line(GL_POLYGON_OFFSET_LINE);
-	glPolygonOffset(-1.f, -1.f);
-
 	for (LLSpatialGroup::OctreeNode::const_element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
 	{
 		LLDrawable* drawable = *i;
@@ -3541,7 +3579,6 @@ void renderAgentTarget(LLVOAvatar* avatar)
 	}
 }
 
-
 class LLOctreeRenderNonOccluded : public LLOctreeTraveler<LLDrawable>
 {
 public:
@@ -3573,14 +3610,6 @@ public:
 				stop_glerror();
 			}
 
-			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_PHYSICS_SHAPES))
-			{
-				group->rebuildGeom();
-				group->rebuildMesh();
-
-				renderPhysicsShapes(group);
-			}
-
 			//render visibility wireframe
 			if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCCLUSION))
 			{
@@ -3712,6 +3741,41 @@ public:
 	}
 };
 
+
+class LLOctreeRenderPhysicsShapes : public LLOctreeTraveler<LLDrawable>
+{
+public:
+	LLCamera* mCamera;
+	LLOctreeRenderPhysicsShapes(LLCamera* camera): mCamera(camera) {}
+	
+	virtual void traverse(const LLSpatialGroup::OctreeNode* node)
+	{
+		LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
+		
+		if (!mCamera || mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1]))
+		{
+			node->accept(this);
+			stop_glerror();
+
+			for (U32 i = 0; i < node->getChildCount(); i++)
+			{
+				traverse(node->getChild(i));
+				stop_glerror();
+			}
+			
+			group->rebuildGeom();
+			group->rebuildMesh();
+
+			renderPhysicsShapes(group);
+		}
+	}
+
+	virtual void visit(const LLSpatialGroup::OctreeNode* branch)
+	{
+		
+	}
+};
+
 class LLOctreePushBBoxVerts : public LLOctreeTraveler<LLDrawable>
 {
 public:
@@ -3830,6 +3894,25 @@ public:
 };
 
 
+void LLSpatialPartition::renderPhysicsShapes()
+{
+	LLSpatialBridge* bridge = asBridge();
+	LLCamera* camera = LLViewerCamera::getInstance();
+	
+	if (bridge)
+	{
+		camera = NULL;
+	}
+
+	gGL.flush();
+	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+	glLineWidth(3.f);
+	LLOctreeRenderPhysicsShapes render_physics(camera);
+	render_physics.traverse(mOctree);
+	gGL.flush();
+	glLineWidth(1.f);
+}
+
 void LLSpatialPartition::renderDebug()
 {
 	if (!gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCTREE |
@@ -3845,8 +3928,7 @@ void LLSpatialPartition::renderDebug()
 									  LLPipeline::RENDER_DEBUG_AVATAR_VOLUME |
 									  LLPipeline::RENDER_DEBUG_AGENT_TARGET |
 									  LLPipeline::RENDER_DEBUG_BUILD_QUEUE |
-									  LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA |
-									  LLPipeline::RENDER_DEBUG_PHYSICS_SHAPES)) 
+									  LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA)) 
 	{
 		return;
 	}
-- 
cgit v1.2.3


From 187716a4ee9019b0133de865d9ede3c3abc3cc5b Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 20 Oct 2010 14:37:37 -0500
Subject: Add terrain to physics shape display.

---
 indra/newview/llspatialpartition.cpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index e763f92fab..c23756611d 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3195,6 +3195,31 @@ void renderPhysicsShapes(LLSpatialGroup* group)
 				renderPhysicsShape(drawable, volume);
 			}
 		}
+		else
+		{
+			LLViewerObject* object = drawable->getVObj();
+			if (object && object->getPCode() == LLViewerObject::LL_VO_SURFACE_PATCH)
+			{
+				//push face vertices for terrain
+				for (S32 i = 0; i < drawable->getNumFaces(); ++i)
+				{
+					LLFace* face = drawable->getFace(i);
+					LLVertexBuffer* buff = face->mVertexBuffer;
+					if (buff)
+					{
+						glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+
+						buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
+						glColor3f(0.2f, 0.5f, 0.3f);
+						buff->draw(LLRender::TRIANGLES, buff->getRequestedIndices(), 0);
+									
+						glColor3f(0.2f, 1.f, 0.3f);
+						glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+						buff->draw(LLRender::TRIANGLES, buff->getRequestedIndices(), 0);
+					}
+				}
+			}
+		}
 	}
 }
 
-- 
cgit v1.2.3


From 4b5ddf1c41622e48bff79eba3f9bc50e73a1efb6 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Sun, 21 Nov 2010 04:40:59 -0600
Subject: Remove ll_aligned_malloc from llspatialpartition

---
 indra/newview/llspatialpartition.cpp | 32 ++++++++++----------------------
 1 file changed, 10 insertions(+), 22 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index e69fe9f99e..bd6be14341 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -236,7 +236,7 @@ void LLSpatialGroup::buildOcclusion()
 {
 	if (!mOcclusionVerts)
 	{
-		mOcclusionVerts = (LLVector4a*) ll_aligned_malloc_16(sizeof(LLVector4a)*8);
+		mOcclusionVerts = new LLVector4a[8];
 	}
 
 	LLVector4a fudge;
@@ -339,14 +339,12 @@ LLSpatialGroup::~LLSpatialGroup()
 		sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
 	}
 
-	ll_aligned_free_16(mOcclusionVerts);
+	delete [] mOcclusionVerts;
 	mOcclusionVerts = NULL;
 
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 	clearDrawMap();
 	clearAtlasList() ;
-
-	ll_aligned_free_16(mBounds);
 }
 
 BOOL LLSpatialGroup::hasAtlas(LLTextureAtlas* atlasp)
@@ -1161,17 +1159,10 @@ LLSpatialGroup::LLSpatialGroup(OctreeNode* node, LLSpatialPartition* part) :
 	sNodeCount++;
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
 
-	mBounds = (LLVector4a*) ll_aligned_malloc_16(sizeof(LLVector4a) * V4_COUNT);
-	mExtents = mBounds + EXTENTS;
-	mObjectBounds = mBounds + OBJECT_BOUNDS;
-	mObjectExtents = mBounds + OBJECT_EXTENTS;
-	mViewAngle = mBounds+VIEW_ANGLE;
-	mLastUpdateViewAngle = mBounds+LAST_VIEW_ANGLE;
-
-	mViewAngle->splat(0.f);
-	mLastUpdateViewAngle->splat(-1.f);
+	mViewAngle.splat(0.f);
+	mLastUpdateViewAngle.splat(-1.f);
 	mExtents[0] = mExtents[1] = mObjectBounds[0] = mObjectBounds[0] = mObjectBounds[1] = 
-		mObjectExtents[0] = mObjectExtents[1] = *mViewAngle;
+		mObjectExtents[0] = mObjectExtents[1] = mViewAngle;
 
 	sg_assert(mOctreeNode->getListenerCount() == 0);
 	mOctreeNode->addListener(this);
@@ -1247,12 +1238,12 @@ F32 LLSpatialPartition::calcDistance(LLSpatialGroup* group, LLCamera& camera)
 				LLVector4a view_angle = eye;
 
 				LLVector4a diff;
-				diff.setSub(view_angle, *group->mLastUpdateViewAngle);
+				diff.setSub(view_angle, group->mLastUpdateViewAngle);
 
 				if (diff.getLength3().getF32() > 0.64f)
 				{
-					*group->mViewAngle = view_angle;
-					*group->mLastUpdateViewAngle = view_angle;
+					group->mViewAngle = view_angle;
+					group->mLastUpdateViewAngle = view_angle;
 					//for occasional alpha sorting within the group
 					//NOTE: If there is a trivial way to detect that alpha sorting here would not change the render order,
 					//not setting this node to dirty would be a very good thing
@@ -1432,7 +1423,7 @@ void LLSpatialGroup::destroyGL()
 		}
 	}
 
-	ll_aligned_free_16(mOcclusionVerts);
+	delete [] mOcclusionVerts;
 	mOcclusionVerts = NULL;
 
 	for (LLSpatialGroup::element_iter i = getData().begin(); i != getData().end(); ++i)
@@ -4187,8 +4178,7 @@ LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset,
 	mDrawMode(LLRender::TRIANGLES)
 {
 	mVertexBuffer->validateRange(mStart, mEnd, mCount, mOffset);
-	mExtents = (LLVector4a*) ll_aligned_malloc_16(sizeof(LLVector4a)*2);
-
+	
 	mDebugColor = (rand() << 16) + rand();
 }
 
@@ -4208,8 +4198,6 @@ LLDrawInfo::~LLDrawInfo()
 	{
 		gPipeline.checkReferences(this);
 	}
-
-	ll_aligned_free_16(mExtents);
 }
 
 void LLDrawInfo::validate()
-- 
cgit v1.2.3


From 1be5133116c7e63bc621a4017bedaebf557c83db Mon Sep 17 00:00:00 2001
From: Roxie Linden <roxie@lindenlab.com>
Date: Wed, 8 Dec 2010 21:24:02 -0800
Subject: SH-541 - Physics mesh display shows inconsistent data. The object UI
 was allowing the user to set 'prim' physics for meshes for which no user
 physics had been uploaded, or decomposed.  It defaulted to convex hull in
 that case.

The fix is to fix the UI to disallow 'prim' for meshes without physics meshes, limiting
those to only convex hull and none.

We will also redo the task validation to detect invalid states related to this as part
of the 'redo the validation' work
---
 indra/newview/llspatialpartition.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index bd6be14341..6b77209867 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2900,7 +2900,7 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 	LLVolumeParams volume_params = volume->getVolume()->getParams();
 
-	LLPhysicsVolumeParams physics_params(volume->getVolume()->getParams(), 
+	LLPhysicsVolumeParams physics_params(volume_params, 
 		physics_type == LLViewerObject::PHYSICS_SHAPE_CONVEX_HULL); 
 
 	LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification physics_spec;
-- 
cgit v1.2.3


From ac7fad4cd0beeee670be40fae1956e5f22a0f17d Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 17 Dec 2010 14:58:39 -0600
Subject: SH-558 Fix for crash in physics shape display.

---
 indra/newview/llspatialpartition.cpp | 81 +++++++++++++++++++-----------------
 1 file changed, 42 insertions(+), 39 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 6b77209867..cc54f21a7e 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3001,56 +3001,59 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 					index_offset += face.mNumVertices;
 				}
 
-				LLCDMeshData mesh;
-				mesh.mIndexBase = &index[0];
-				mesh.mVertexBase = pos[0].mV;
-				mesh.mNumVertices = pos.size();
-				mesh.mVertexStrideBytes = 12;
-				mesh.mIndexStrideBytes = 6;
-				mesh.mIndexType = LLCDMeshData::INT_16;
-
-				mesh.mNumTriangles = index.size()/3;
-				
-				LLCDMeshData res;
+				if (!pos.empty() && !index.empty())
+				{
+					LLCDMeshData mesh;
+					mesh.mIndexBase = &index[0];
+					mesh.mVertexBase = pos[0].mV;
+					mesh.mNumVertices = pos.size();
+					mesh.mVertexStrideBytes = 12;
+					mesh.mIndexStrideBytes = 6;
+					mesh.mIndexType = LLCDMeshData::INT_16;
+
+					mesh.mNumTriangles = index.size()/3;
+					
+					LLCDMeshData res;
 
-				LLConvexDecomposition::getInstance()->generateSingleHullMeshFromMesh( &mesh, &res );
+					LLConvexDecomposition::getInstance()->generateSingleHullMeshFromMesh( &mesh, &res );
 
-				//copy res into phys_volume
-				phys_volume->mHullPoints = (LLVector4a*) malloc(sizeof(LLVector4a)*res.mNumVertices);
-				phys_volume->mNumHullPoints = res.mNumVertices;
+					//copy res into phys_volume
+					phys_volume->mHullPoints = (LLVector4a*) malloc(sizeof(LLVector4a)*res.mNumVertices);
+					phys_volume->mNumHullPoints = res.mNumVertices;
 
-				S32 idx_size = (res.mNumTriangles*3*2+0xF) & ~0xF;
-				phys_volume->mHullIndices = (U16*) malloc(idx_size);
-				phys_volume->mNumHullIndices = res.mNumTriangles*3;
+					S32 idx_size = (res.mNumTriangles*3*2+0xF) & ~0xF;
+					phys_volume->mHullIndices = (U16*) malloc(idx_size);
+					phys_volume->mNumHullIndices = res.mNumTriangles*3;
 
-				const F32* v = res.mVertexBase;
+					const F32* v = res.mVertexBase;
 
-				for (S32 i = 0; i < res.mNumVertices; ++i)
-				{
-					F32* p = (F32*) ((U8*)v+i*res.mVertexStrideBytes);
-					phys_volume->mHullPoints[i].load3(p);
-				}
+					for (S32 i = 0; i < res.mNumVertices; ++i)
+					{
+						F32* p = (F32*) ((U8*)v+i*res.mVertexStrideBytes);
+						phys_volume->mHullPoints[i].load3(p);
+					}
 
-				if (res.mIndexType == LLCDMeshData::INT_16)
-				{
-					for (S32 i = 0; i < res.mNumTriangles; ++i)
+					if (res.mIndexType == LLCDMeshData::INT_16)
 					{
-						U16* idx = (U16*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
+						for (S32 i = 0; i < res.mNumTriangles; ++i)
+						{
+							U16* idx = (U16*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
 
-						phys_volume->mHullIndices[i*3+0] = idx[0];
-						phys_volume->mHullIndices[i*3+1] = idx[1];
-						phys_volume->mHullIndices[i*3+2] = idx[2];
+							phys_volume->mHullIndices[i*3+0] = idx[0];
+							phys_volume->mHullIndices[i*3+1] = idx[1];
+							phys_volume->mHullIndices[i*3+2] = idx[2];
+						}
 					}
-				}
-				else
-				{
-					for (S32 i = 0; i < res.mNumTriangles; ++i)
+					else
 					{
-						U32* idx = (U32*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
+						for (S32 i = 0; i < res.mNumTriangles; ++i)
+						{
+							U32* idx = (U32*) (((U8*)res.mIndexBase)+i*res.mIndexStrideBytes);
 
-						phys_volume->mHullIndices[i*3+0] = (U16) idx[0];
-						phys_volume->mHullIndices[i*3+1] = (U16) idx[1];
-						phys_volume->mHullIndices[i*3+2] = (U16) idx[2];
+							phys_volume->mHullIndices[i*3+0] = (U16) idx[0];
+							phys_volume->mHullIndices[i*3+1] = (U16) idx[1];
+							phys_volume->mHullIndices[i*3+2] = (U16) idx[2];
+						}
 					}
 				}
 			}
-- 
cgit v1.2.3


From 1e647e2cd2d0385bcf46fa054056de3615e95377 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 31 Dec 2010 18:41:54 -0600
Subject: Faster occlusion queries (take advantage of GL_ARB_occlusion_query2
 where available and don't read back result if it will block).

---
 indra/newview/llspatialpartition.cpp | 60 +++++++++++++++++++++---------------
 1 file changed, 35 insertions(+), 25 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index cc54f21a7e..7adffb6925 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1516,31 +1516,37 @@ void LLSpatialGroup::checkOcclusion()
 		}
 		else if (isOcclusionState(QUERY_PENDING))
 		{	//otherwise, if a query is pending, read it back
-			GLuint res = 1;
-			if (!isOcclusionState(DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
-			{
-				glGetQueryObjectuivARB(mOcclusionQuery[LLViewerCamera::sCurCameraID], GL_QUERY_RESULT_ARB, &res);	
-			}
 
-			if (isOcclusionState(DISCARD_QUERY))
-			{
-				res = 2;
-			}
+			GLuint available = 0;
+			glGetQueryObjectuivARB(mOcclusionQuery[LLViewerCamera::sCurCameraID], GL_QUERY_RESULT_AVAILABLE_ARB, &available);
+			if (available)
+			{ //result is available, read it back, otherwise wait until next frame
+				GLuint res = 1;
+				if (!isOcclusionState(DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
+				{
+					glGetQueryObjectuivARB(mOcclusionQuery[LLViewerCamera::sCurCameraID], GL_QUERY_RESULT_ARB, &res);	
+				}
 
-			if (res > 0)
-			{
-				assert_states_valid(this);
-				clearOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
-				assert_states_valid(this);
-			}
-			else
-			{
-				assert_states_valid(this);
-				setOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
-				assert_states_valid(this);
-			}
+				if (isOcclusionState(DISCARD_QUERY))
+				{
+					res = 2;
+				}
 
-			clearOcclusionState(QUERY_PENDING | DISCARD_QUERY);
+				if (res > 0)
+				{
+					assert_states_valid(this);
+					clearOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
+					assert_states_valid(this);
+				}
+				else
+				{
+					assert_states_valid(this);
+					setOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
+					assert_states_valid(this);
+				}
+
+				clearOcclusionState(QUERY_PENDING | DISCARD_QUERY);
+			}
 		}
 		else if (mSpatialPartition->isOcclusionEnabled() && isOcclusionState(LLSpatialGroup::OCCLUDED))
 		{	//check occlusion has been issued for occluded node that has not had a query issued
@@ -1566,7 +1572,8 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 		}
 		else
 		{
-			{
+			if (!isOcclusionState(QUERY_PENDING) || isOcclusionState(DISCARD_QUERY))
+			{ //no query pending, or previous query to be discarded
 				LLFastTimer t(FTM_RENDER_OCCLUSION);
 
 				if (!mOcclusionQuery[LLViewerCamera::sCurCameraID])
@@ -1590,7 +1597,10 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					glEnable(GL_DEPTH_CLAMP);
 				}
 				
-				glBeginQueryARB(GL_SAMPLES_PASSED_ARB, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
+				U32 mode = gGLManager.mHasOcclusionQuery2 ? GL_ANY_SAMPLES_PASSED : GL_SAMPLES_PASSED_ARB;
+
+				glBeginQueryARB(mode, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
+				
 				glVertexPointer(3, GL_FLOAT, 16, mOcclusionVerts);
 				if (camera->getOrigin().isExactlyZero())
 				{ //origin is invalid, draw entire box
@@ -1604,7 +1614,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
 								GL_UNSIGNED_BYTE, get_box_fan_indices(camera, mBounds[0]));
 				}
-				glEndQueryARB(GL_SAMPLES_PASSED_ARB);
+				glEndQueryARB(mode);
 				
 				if (use_depth_clamp)
 				{
-- 
cgit v1.2.3


From 808cd0fcbfe017c1212fb0c1d423fa06bb06c148 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 4 Jan 2011 18:34:27 -0600
Subject: VWR-21927 Fix for water reflections causing LoD updates. SH-735
 Potential fix for ATI X1950 wasting time in occlusion culling.

---
 indra/newview/llspatialpartition.cpp | 155 ++++++++++++++++++++---------------
 1 file changed, 89 insertions(+), 66 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 7adffb6925..cb72f35eee 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -222,7 +222,17 @@ static U8 sOcclusionIndices[] =
 		b000, b110, b100, b101, b001, b011, b010, b110,
 };
 
-U8* get_box_fan_indices(LLCamera* camera, const LLVector4a& center)
+U32 get_box_fan_indices(LLCamera* camera, const LLVector4a& center)
+{
+	LLVector4a origin;
+	origin.load3(camera->getOrigin().mV);
+
+	S32 cypher = center.greaterThan(origin).getGatheredBits() & 0x7;
+	
+	return cypher*8;
+}
+
+U8* get_box_fan_indices_ptr(LLCamera* camera, const LLVector4a& center)
 {
 	LLVector4a origin;
 	origin.load3(camera->getOrigin().mV);
@@ -231,12 +241,21 @@ U8* get_box_fan_indices(LLCamera* camera, const LLVector4a& center)
 	
 	return sOcclusionIndices+cypher*8;
 }
-						
+
+
 void LLSpatialGroup::buildOcclusion()
 {
-	if (!mOcclusionVerts)
+	if (mOcclusionVerts.isNull())
 	{
-		mOcclusionVerts = new LLVector4a[8];
+		mOcclusionVerts = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX, GL_DYNAMIC_DRAW_ARB);
+		mOcclusionVerts->allocateBuffer(8, 64, true);
+	
+		LLStrider<U16> idx;
+		mOcclusionVerts->getIndexStrider(idx);
+		for (U32 i = 0; i < 64; i++)
+		{
+			*idx++ = sOcclusionIndices[i];
+		}
 	}
 
 	LLVector4a fudge;
@@ -251,7 +270,12 @@ void LLSpatialGroup::buildOcclusion()
 
 	r.setMin(r, r2);
 
-	LLVector4a* v = mOcclusionVerts;
+	LLStrider<LLVector3> pos;
+	
+	mOcclusionVerts->getVertexStrider(pos);
+
+	LLVector4a* v = (LLVector4a*) pos.get();
+
 	const LLVector4a& c = mBounds[0];
 	const LLVector4a& s = r;
 	
@@ -275,10 +299,13 @@ void LLSpatialGroup::buildOcclusion()
 	
 	for (S32 i = 0; i < 8; ++i)
 	{
-		v[i] = s;
-		v[i].mul(octant[i]);
-		v[i].add(c);
+		LLVector4a p;
+		p.setMul(s, octant[i]);
+		p.add(c);
+		v[i] = p;
 	}
+	
+	mOcclusionVerts->setBuffer(0);
 
 	clearState(LLSpatialGroup::OCCLUSION_DIRTY);
 }
@@ -339,7 +366,6 @@ LLSpatialGroup::~LLSpatialGroup()
 		sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
 	}
 
-	delete [] mOcclusionVerts;
 	mOcclusionVerts = NULL;
 
 	LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
@@ -881,12 +907,9 @@ void LLSpatialGroup::shift(const LLVector4a &offset)
 		gPipeline.markRebuild(this, TRUE);
 	}
 
-	if (mOcclusionVerts)
+	if (mOcclusionVerts.notNull())
 	{
-		for (U32 i = 0; i < 8; i++)
-		{
-			mOcclusionVerts[i].add(offset);
-		}
+		setState(OCCLUSION_DIRTY);
 	}
 }
 
@@ -1423,7 +1446,6 @@ void LLSpatialGroup::destroyGL()
 		}
 	}
 
-	delete [] mOcclusionVerts;
 	mOcclusionVerts = NULL;
 
 	for (LLSpatialGroup::element_iter i = getData().begin(); i != getData().end(); ++i)
@@ -1573,57 +1595,58 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 		else
 		{
 			if (!isOcclusionState(QUERY_PENDING) || isOcclusionState(DISCARD_QUERY))
-			{ //no query pending, or previous query to be discarded
-				LLFastTimer t(FTM_RENDER_OCCLUSION);
+			{
+				{ //no query pending, or previous query to be discarded
+					LLFastTimer t(FTM_RENDER_OCCLUSION);
 
-				if (!mOcclusionQuery[LLViewerCamera::sCurCameraID])
-				{
-					mOcclusionQuery[LLViewerCamera::sCurCameraID] = sQueryPool.allocate();
-				}
+					if (!mOcclusionQuery[LLViewerCamera::sCurCameraID])
+					{
+						mOcclusionQuery[LLViewerCamera::sCurCameraID] = sQueryPool.allocate();
+					}
 
-				if (!mOcclusionVerts || isState(LLSpatialGroup::OCCLUSION_DIRTY))
-				{
-					buildOcclusion();
-				}
-				
-				// Depth clamp all water to avoid it being culled as a result of being
-				// behind the far clip plane, and in the case of edge water to avoid
-				// it being culled while still visible.
-				bool const use_depth_clamp = gGLManager.mHasDepthClamp &&
-											(mSpatialPartition->mDrawableType == LLDrawPool::POOL_WATER ||
-											mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER);
-				if (use_depth_clamp)
-				{
-					glEnable(GL_DEPTH_CLAMP);
-				}
-				
-				U32 mode = gGLManager.mHasOcclusionQuery2 ? GL_ANY_SAMPLES_PASSED : GL_SAMPLES_PASSED_ARB;
+					if (mOcclusionVerts.isNull() || isState(LLSpatialGroup::OCCLUSION_DIRTY))
+					{
+						buildOcclusion();
+					}
+					
+					// Depth clamp all water to avoid it being culled as a result of being
+					// behind the far clip plane, and in the case of edge water to avoid
+					// it being culled while still visible.
+					bool const use_depth_clamp = gGLManager.mHasDepthClamp &&
+												(mSpatialPartition->mDrawableType == LLDrawPool::POOL_WATER ||
+												mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER);
+					if (use_depth_clamp)
+					{
+						glEnable(GL_DEPTH_CLAMP);
+					}
+					
+					U32 mode = gGLManager.mHasOcclusionQuery2 ? GL_ANY_SAMPLES_PASSED : GL_SAMPLES_PASSED_ARB;
 
-				glBeginQueryARB(mode, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
-				
-				glVertexPointer(3, GL_FLOAT, 16, mOcclusionVerts);
-				if (camera->getOrigin().isExactlyZero())
-				{ //origin is invalid, draw entire box
-					glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
-												GL_UNSIGNED_BYTE, sOcclusionIndices);
-					glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
-							GL_UNSIGNED_BYTE, sOcclusionIndices+b111*8);
-				}
-				else
-				{
-					glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
-								GL_UNSIGNED_BYTE, get_box_fan_indices(camera, mBounds[0]));
-				}
-				glEndQueryARB(mode);
-				
-				if (use_depth_clamp)
-				{
-					glDisable(GL_DEPTH_CLAMP);
+					glBeginQueryARB(mode, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
+					
+					mOcclusionVerts->setBuffer(LLVertexBuffer::MAP_VERTEX);
+
+					if (camera->getOrigin().isExactlyZero())
+					{ //origin is invalid, draw entire box
+						mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
+						mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
+					}
+					else
+					{
+						mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
+					}
+
+					glEndQueryARB(mode);
+					
+					if (use_depth_clamp)
+					{
+						glDisable(GL_DEPTH_CLAMP);
+					}
 				}
-			}
 
-			setOcclusionState(LLSpatialGroup::QUERY_PENDING);
-			clearOcclusionState(LLSpatialGroup::DISCARD_QUERY);
+				setOcclusionState(LLSpatialGroup::QUERY_PENDING);
+				clearOcclusionState(LLSpatialGroup::DISCARD_QUERY);
+			}
 		}
 	}
 }
@@ -2617,17 +2640,17 @@ void renderVisibility(LLSpatialGroup* group, LLCamera* camera)
 			gGL.color4f(0.f, 0.75f, 0.f, 0.5f);
 			pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX);
 		}
-		else if (camera && group->mOcclusionVerts)
+		else if (camera && group->mOcclusionVerts.notNull())
 		{
 			LLVertexBuffer::unbind();
-			glVertexPointer(3, GL_FLOAT, 16, group->mOcclusionVerts);
-
+			group->mOcclusionVerts->setBuffer(LLVertexBuffer::MAP_VERTEX);
+			
 			glColor4f(1.0f, 0.f, 0.f, 0.5f);
-			glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8, GL_UNSIGNED_BYTE, get_box_fan_indices(camera, group->mBounds[0]));
+			group->mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, group->mBounds[0]));
 			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 			
 			glColor4f(1.0f, 1.f, 1.f, 1.0f);
-			glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8, GL_UNSIGNED_BYTE, get_box_fan_indices(camera, group->mBounds[0]));
+			group->mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, group->mBounds[0]));
 			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 		}
 	}
-- 
cgit v1.2.3


From c20f9342b9632c4e5480faa5d4e6be26c75e1157 Mon Sep 17 00:00:00 2001
From: prep <prep@lindenlab.com>
Date: Wed, 5 Jan 2011 14:09:19 -0500
Subject: patch for gl_any_samples_passed missing define on mac

---
 indra/newview/llspatialpartition.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index cb72f35eee..1b5800b8a5 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1619,7 +1619,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					{
 						glEnable(GL_DEPTH_CLAMP);
 					}
-					
+#if !LL_DARWIN					
 					U32 mode = gGLManager.mHasOcclusionQuery2 ? GL_ANY_SAMPLES_PASSED : GL_SAMPLES_PASSED_ARB;
 
 					glBeginQueryARB(mode, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
@@ -1637,7 +1637,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					}
 
 					glEndQueryARB(mode);
-					
+#endif					
 					if (use_depth_clamp)
 					{
 						glDisable(GL_DEPTH_CLAMP);
-- 
cgit v1.2.3


From aeec987f565f916c9919f8cc861a82b4caab9a46 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 18 Jan 2011 14:49:14 -0600
Subject: SH-571 work in progress.

---
 indra/newview/llspatialpartition.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 1b5800b8a5..ec9bc86ea0 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2465,7 +2465,6 @@ void renderOctree(LLSpatialGroup* group)
 {
 	//render solid object bounding box, color
 	//coded by buffer usage and activity
-	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 	gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
 	LLVector4 col;
 	if (group->mBuilt > 0.f)
@@ -2557,7 +2556,10 @@ void renderOctree(LLSpatialGroup* group)
 	size.mul(1.01f);
 	size.add(fudge);
 
-	drawBox(group->mObjectBounds[0], fudge);
+	{
+		LLGLDepthTest depth(GL_TRUE, GL_FALSE);
+		drawBox(group->mObjectBounds[0], fudge);
+	}
 	
 	gGL.setSceneBlendType(LLRender::BT_ALPHA);
 
-- 
cgit v1.2.3


From d7db673dc7c8cc638aab66be07f08892e548f783 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 21 Jan 2011 18:25:57 -0600
Subject: Fix for leaking occlusion queries -- try not to hold onto so many
 stale occlusion query references.

---
 indra/newview/llspatialpartition.cpp | 59 +++++++++++++++++++++++++++++++++---
 1 file changed, 54 insertions(+), 5 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index b9063b3c81..c53b7b3eb6 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -64,6 +64,12 @@ const F32 SG_OCCLUSION_FUDGE = 0.25f;
 
 static U32 sZombieGroups = 0;
 U32 LLSpatialGroup::sNodeCount = 0;
+
+#define LL_TRACK_PENDING_OCCLUSION_QUERIES 0
+
+std::set<GLuint> LLSpatialGroup::sPendingQueries;
+
+
 BOOL LLSpatialGroup::sNoDelete = FALSE;
 
 static F32 sLastMaxTexPriority = 1.f;
@@ -81,6 +87,9 @@ protected:
 
 	virtual void releaseName(GLuint name)
 	{
+#if LL_TRACK_PENDING_OCCLUSION_QUERIES
+		LLSpatialGroup::sPendingQueries.erase(name);
+#endif
 		glDeleteQueriesARB(1, &name);
 	}
 };
@@ -361,9 +370,15 @@ LLSpatialGroup::~LLSpatialGroup()
 	
 	sNodeCount--;
 
-	if (gGLManager.mHasOcclusionQuery && mOcclusionQuery[LLViewerCamera::sCurCameraID])
+	if (gGLManager.mHasOcclusionQuery)
 	{
-		sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
+		for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; ++i)
+		{
+			if (mOcclusionQuery[i])
+			{
+				sQueryPool.release(mOcclusionQuery[i]);
+			}
+		}
 	}
 
 	mOcclusionVerts = NULL;
@@ -1096,12 +1111,23 @@ void LLSpatialGroup::setOcclusionState(U32 state, S32 mode)
 			for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
 			{
 				mOcclusionState[i] |= state;
+
+				if ((state & DISCARD_QUERY) && mOcclusionQuery[i])
+				{
+					sQueryPool.release(mOcclusionQuery[i]);
+					mOcclusionQuery[i] = 0;
+				}
 			}
 		}
 	}
 	else
 	{
 		mOcclusionState[LLViewerCamera::sCurCameraID] |= state;
+		if ((state & DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
+		{
+			sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
+			mOcclusionQuery[LLViewerCamera::sCurCameraID] = 0;
+		}
 	}
 }
 
@@ -1540,15 +1566,31 @@ void LLSpatialGroup::checkOcclusion()
 		{	//otherwise, if a query is pending, read it back
 
 			GLuint available = 0;
-			glGetQueryObjectuivARB(mOcclusionQuery[LLViewerCamera::sCurCameraID], GL_QUERY_RESULT_AVAILABLE_ARB, &available);
+			if (mOcclusionQuery[LLViewerCamera::sCurCameraID])
+			{
+				glGetQueryObjectuivARB(mOcclusionQuery[LLViewerCamera::sCurCameraID], GL_QUERY_RESULT_AVAILABLE_ARB, &available);
+			}
+			else
+			{
+				available = 1;
+			}
+
 			if (available)
 			{ //result is available, read it back, otherwise wait until next frame
 				GLuint res = 1;
 				if (!isOcclusionState(DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
 				{
 					glGetQueryObjectuivARB(mOcclusionQuery[LLViewerCamera::sCurCameraID], GL_QUERY_RESULT_ARB, &res);	
+#if LL_TRACK_PENDING_OCCLUSION_QUERIES
+					sPendingQueries.erase(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
+#endif
 				}
-
+				else if (mOcclusionQuery[LLViewerCamera::sCurCameraID])
+				{ //delete the query to avoid holding onto hundreds of pending queries
+					sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
+					mOcclusionQuery[LLViewerCamera::sCurCameraID] = 0;
+				}
+				
 				if (isOcclusionState(DISCARD_QUERY))
 				{
 					res = 2;
@@ -1621,6 +1663,13 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					}
 #if !LL_DARWIN					
 					U32 mode = gGLManager.mHasOcclusionQuery2 ? GL_ANY_SAMPLES_PASSED : GL_SAMPLES_PASSED_ARB;
+#else
+					U32 mode = GL_SAMPLES_PASSED_ARB;
+#endif
+					
+#if LL_TRACK_PENDING_OCCLUSION_QUERIES
+					sPendingQueries.insert(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
+#endif
 
 					glBeginQueryARB(mode, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
 					
@@ -1637,7 +1686,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					}
 
 					glEndQueryARB(mode);
-#endif					
+
 					if (use_depth_clamp)
 					{
 						glDisable(GL_DEPTH_CLAMP);
-- 
cgit v1.2.3


From 92018853e2c9d6151e342c0b483a02fd0599a41f Mon Sep 17 00:00:00 2001
From: Roxie Linden <roxie@lindenlab.com>
Date: Mon, 24 Jan 2011 16:58:10 -0800
Subject: SH-753 GHOST Mesh from a Mesh Sandbox 11 and 12 from 6

Raycast debug view was not translating by the agent origin
---
 indra/newview/llspatialpartition.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index b9063b3c81..5f23908eda 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3580,6 +3580,8 @@ void renderRaycast(LLDrawable* drawablep)
 
 			if (volume)
 			{
+				LLVector3 trans = drawablep->getRegion()->getOriginAgent();
+				
 				for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
 				{
 					const LLVolumeFace& face = volume->getVolumeFace(i);
@@ -3589,6 +3591,7 @@ void renderRaycast(LLDrawable* drawablep)
 					}
 
 					gGL.pushMatrix();
+					glTranslatef(trans.mV[0], trans.mV[1], trans.mV[2]);					
 					glMultMatrixf((F32*) vobj->getRelativeXform().mMatrix);
 
 					LLVector3 start, end;
@@ -3613,7 +3616,7 @@ void renderRaycast(LLDrawable* drawablep)
 
 					LLRenderOctreeRaycast render(starta, dir, &t);
 					gGL.flush();
-					glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+					glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);				
 
 					{
 						//render face positions
@@ -3672,7 +3675,7 @@ void renderRaycast(LLDrawable* drawablep)
 
 			LLGLDepthTest depth(GL_FALSE, GL_TRUE);
 			gGL.color4f(0,0.5f,0.5f,1);
-			drawBoxOutline(pos, size);
+			drawBoxOutline(pos, size);		
 		}
 	}
 }
-- 
cgit v1.2.3


From f0be01bda92553a3e9e671c26c2905b47cacb0b5 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 26 Jan 2011 15:26:56 -0600
Subject: SH-641 Fix for some objects not properly switching LoD under some
 situations. Fix for redundant calls to stateSort(LLDrawable*...) Put back
 "Build Queue" info display.

---
 indra/newview/llspatialpartition.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index be8f81fc62..af6064ad20 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -522,7 +522,7 @@ BOOL LLSpatialGroup::isRecentlyVisible() const
 
 BOOL LLSpatialGroup::isVisible() const
 {
-	return mVisible[LLViewerCamera::sCurCameraID] == LLDrawable::getCurrentFrame() ? TRUE : FALSE;
+	return mVisible[LLViewerCamera::sCurCameraID] >= LLDrawable::getCurrentFrame() ? TRUE : FALSE;
 }
 
 void LLSpatialGroup::setVisible()
@@ -1345,7 +1345,8 @@ F32 LLSpatialGroup::getUpdateUrgency() const
 	}
 	else
 	{
-		return (gFrameTimeSeconds - mLastUpdateTime+4.f)/mDistance;
+		F32 time = gFrameTimeSeconds-mLastUpdateTime+4.f;
+		return time + (mObjectBounds[1].dot3(mObjectBounds[1]).getF32()+1.f)/mDistance;
 	}
 }
 
@@ -1356,8 +1357,8 @@ BOOL LLSpatialGroup::needsUpdate()
 
 BOOL LLSpatialGroup::changeLOD()
 {
-	if (isState(ALPHA_DIRTY))
-	{ ///an alpha sort is going to happen, update distance and LOD
+	if (isState(ALPHA_DIRTY | OBJECT_DIRTY))
+	{ ///a rebuild is going to happen, update distance and LoD
 		return TRUE;
 	}
 
@@ -1370,7 +1371,7 @@ BOOL LLSpatialGroup::changeLOD()
 			return TRUE;
 		}
 
-		if (mDistance > mRadius)
+		if (mDistance > mRadius*2.f)
 		{
 			return FALSE;
 		}
@@ -4100,7 +4101,7 @@ void LLSpatialPartition::renderDebug()
 									  LLPipeline::RENDER_DEBUG_RAYCAST |
 									  LLPipeline::RENDER_DEBUG_AVATAR_VOLUME |
 									  LLPipeline::RENDER_DEBUG_AGENT_TARGET |
-									  LLPipeline::RENDER_DEBUG_BUILD_QUEUE |
+									  //LLPipeline::RENDER_DEBUG_BUILD_QUEUE |
 									  LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA)) 
 	{
 		return;
@@ -4140,7 +4141,7 @@ void LLSpatialGroup::drawObjectBox(LLColor4 col)
 {
 	gGL.color4fv(col.mV);
 	LLVector4a size;
-	size = mObjectBounds[0];
+	size = mObjectBounds[1];
 	size.mul(1.01f);
 	size.add(LLVector4a(0.001f));
 	drawBox(mObjectBounds[0], size);
-- 
cgit v1.2.3


From 9e966bfe9fd15f9ffbc969fc41ef2306e9f9409c Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 2 Feb 2011 19:00:52 -0600
Subject: Tweak to physics shape display render to show convex decompositions.

---
 indra/newview/llspatialpartition.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index af6064ad20..a4c9b66e38 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2948,10 +2948,10 @@ void renderMeshBaseHull(LLVOVolume* volume, U32 data_mask, LLColor4& color, LLCo
 		{
 			buff->setBuffer(data_mask);
 
-			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+		/*	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 			glColor4fv(line_color.mV);
 			buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
-			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);*/
 
 			{
 				glColor4fv(color.mV);
@@ -2979,9 +2979,13 @@ void render_hull(LLVertexBuffer* buff, U32 data_mask, const LLColor4& color, con
 	glColor4fv(color.mV);
 	buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
 
+	LLGLEnable offset(GL_POLYGON_OFFSET_LINE);
 	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	glPolygonOffset(3.f, 3.f);
+	glLineWidth(3.f);
 	glColor4fv(line_color.mV);
 	buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+	glLineWidth(1.f);
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 }
 
-- 
cgit v1.2.3


From 068822b18d4e62381a25c833cfa2639eddd4c24d Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 9 Feb 2011 15:28:46 -0600
Subject: SH-874 Fix for bad performance on cards without GL_ARB_depth_clamp in
 cases where water and terrain should be occluded.

---
 indra/newview/llspatialpartition.cpp | 49 +++++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 23 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index a4c9b66e38..40f1596139 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -273,12 +273,6 @@ void LLSpatialGroup::buildOcclusion()
 	LLVector4a r;
 	r.setAdd(mBounds[1], fudge);
 
-	LLVector4a r2;
-	r2.splat(0.25f);
-	r2.add(mBounds[1]);
-
-	r.setMin(r, r2);
-
 	LLStrider<LLVector3> pos;
 	
 	mOcclusionVerts->getVertexStrider(pos);
@@ -1627,8 +1621,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 	if (mSpatialPartition->isOcclusionEnabled() && LLPipeline::sUseOcclusion > 1)
 	{
 		// Don't cull hole/edge water, unless we have the GL_ARB_depth_clamp extension
-		if ((mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER && !gGLManager.mHasDepthClamp) ||
-			earlyFail(camera, this))
+		if (earlyFail(camera, this))
 		{
 			setOcclusionState(LLSpatialGroup::DISCARD_QUERY);
 			assert_states_valid(this);
@@ -1656,12 +1649,11 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					// behind the far clip plane, and in the case of edge water to avoid
 					// it being culled while still visible.
 					bool const use_depth_clamp = gGLManager.mHasDepthClamp &&
-												(mSpatialPartition->mDrawableType == LLDrawPool::POOL_WATER ||
+												(mSpatialPartition->mDrawableType == LLDrawPool::POOL_WATER ||						
 												mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER);
-					if (use_depth_clamp)
-					{
-						glEnable(GL_DEPTH_CLAMP);
-					}
+
+					LLGLEnable clamp(use_depth_clamp ? GL_DEPTH_CLAMP : 0);				
+						
 #if !LL_DARWIN					
 					U32 mode = gGLManager.mHasOcclusionQuery2 ? GL_ANY_SAMPLES_PASSED : GL_SAMPLES_PASSED_ARB;
 #else
@@ -1676,22 +1668,33 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					
 					mOcclusionVerts->setBuffer(LLVertexBuffer::MAP_VERTEX);
 
-					if (camera->getOrigin().isExactlyZero())
-					{ //origin is invalid, draw entire box
-						mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
-						mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
+					if (!use_depth_clamp && mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER)
+					{
+						LLGLSquashToFarClip squash(glh_get_current_projection());
+						if (camera->getOrigin().isExactlyZero())
+						{ //origin is invalid, draw entire box
+							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
+							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
+						}
+						else
+						{
+							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
+						}
 					}
 					else
 					{
-						mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
+						if (camera->getOrigin().isExactlyZero())
+						{ //origin is invalid, draw entire box
+							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
+							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
+						}
+						else
+						{
+							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
+						}
 					}
 
 					glEndQueryARB(mode);
-
-					if (use_depth_clamp)
-					{
-						glDisable(GL_DEPTH_CLAMP);
-					}
 				}
 
 				setOcclusionState(LLSpatialGroup::QUERY_PENDING);
-- 
cgit v1.2.3


From 10518eaaaef51f6d5a23a4c8fa15267bf9aa0821 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 9 Feb 2011 16:53:47 -0600
Subject: SH-874 Revert much of the bad water bounding box and distortion
 texture usage changes from SNOW-643 and properly occlusion cull void water
 patches for machines without depth clamp.

---
 indra/newview/llspatialpartition.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 40f1596139..5dd1b5ba7e 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1670,7 +1670,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 
 					if (!use_depth_clamp && mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER)
 					{
-						LLGLSquashToFarClip squash(glh_get_current_projection());
+						LLGLSquashToFarClip squash(glh_get_current_projection(), 1);
 						if (camera->getOrigin().isExactlyZero())
 						{ //origin is invalid, draw entire box
 							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
-- 
cgit v1.2.3


From e55e91a5a546832b79643fdcd2208b5e4f62b6df Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 22 Feb 2011 18:36:50 -0600
Subject: SH-874 Better VBO usage hints, most notably don't use VBOs for
 occlusion queries if GL is set to not use VBOs for stream draw.

---
 indra/newview/llspatialpartition.cpp | 132 ++++++++++++++++++++---------------
 1 file changed, 77 insertions(+), 55 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 5dd1b5ba7e..14775f0f21 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -252,11 +252,15 @@ U8* get_box_fan_indices_ptr(LLCamera* camera, const LLVector4a& center)
 }
 
 
+static LLFastTimer::DeclareTimer FTM_BUILD_OCCLUSION("Build Occlusion");
+
 void LLSpatialGroup::buildOcclusion()
 {
 	if (mOcclusionVerts.isNull())
 	{
-		mOcclusionVerts = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX, GL_DYNAMIC_DRAW_ARB);
+
+		mOcclusionVerts = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX, 
+			LLVertexBuffer::sUseStreamDraw ? mBufferUsage : 0); //if GL has a hard time with VBOs, don't use them for occlusion culling.
 		mOcclusionVerts->allocateBuffer(8, 64, true);
 	
 		LLStrider<U16> idx;
@@ -275,40 +279,47 @@ void LLSpatialGroup::buildOcclusion()
 
 	LLStrider<LLVector3> pos;
 	
-	mOcclusionVerts->getVertexStrider(pos);
-
-	LLVector4a* v = (LLVector4a*) pos.get();
-
-	const LLVector4a& c = mBounds[0];
-	const LLVector4a& s = r;
-	
-	static const LLVector4a octant[] =
 	{
-		LLVector4a(-1.f, -1.f, -1.f),
-		LLVector4a(-1.f, -1.f, 1.f),
-		LLVector4a(-1.f, 1.f, -1.f),
-		LLVector4a(-1.f, 1.f, 1.f),
+		LLFastTimer t(FTM_BUILD_OCCLUSION);
+		mOcclusionVerts->getVertexStrider(pos);
+	}
 
-		LLVector4a(1.f, -1.f, -1.f),
-		LLVector4a(1.f, -1.f, 1.f),
-		LLVector4a(1.f, 1.f, -1.f),
-		LLVector4a(1.f, 1.f, 1.f),
-	};
+	{
+		LLVector4a* v = (LLVector4a*) pos.get();
 
-	//vertex positions are encoded so the 3 bits of their vertex index 
-	//correspond to their axis facing, with bit position 3,2,1 matching
-	//axis facing x,y,z, bit set meaning positive facing, bit clear 
-	//meaning negative facing
+		const LLVector4a& c = mBounds[0];
+		const LLVector4a& s = r;
+		
+		static const LLVector4a octant[] =
+		{
+			LLVector4a(-1.f, -1.f, -1.f),
+			LLVector4a(-1.f, -1.f, 1.f),
+			LLVector4a(-1.f, 1.f, -1.f),
+			LLVector4a(-1.f, 1.f, 1.f),
+
+			LLVector4a(1.f, -1.f, -1.f),
+			LLVector4a(1.f, -1.f, 1.f),
+			LLVector4a(1.f, 1.f, -1.f),
+			LLVector4a(1.f, 1.f, 1.f),
+		};
+
+		//vertex positions are encoded so the 3 bits of their vertex index 
+		//correspond to their axis facing, with bit position 3,2,1 matching
+		//axis facing x,y,z, bit set meaning positive facing, bit clear 
+		//meaning negative facing
+		
+		for (S32 i = 0; i < 8; ++i)
+		{
+			LLVector4a p;
+			p.setMul(s, octant[i]);
+			p.add(c);
+			v[i] = p;
+		}
+	}
 	
-	for (S32 i = 0; i < 8; ++i)
 	{
-		LLVector4a p;
-		p.setMul(s, octant[i]);
-		p.add(c);
-		v[i] = p;
+		mOcclusionVerts->setBuffer(0);
 	}
-	
-	mOcclusionVerts->setBuffer(0);
 
 	clearState(LLSpatialGroup::OCCLUSION_DIRTY);
 }
@@ -1189,7 +1200,7 @@ LLSpatialGroup::LLSpatialGroup(OctreeNode* node, LLSpatialPartition* part) :
 	mOctreeNode(node),
 	mSpatialPartition(part),
 	mVertexBuffer(NULL), 
-	mBufferUsage(GL_STATIC_DRAW_ARB),
+	mBufferUsage(part->mBufferUsage),
 	mDistance(0.f),
 	mDepth(0.f),
 	mLastUpdateDistance(-1.f), 
@@ -1616,6 +1627,10 @@ void LLSpatialGroup::checkOcclusion()
 	}
 }
 
+static LLFastTimer::DeclareTimer FTM_PUSH_OCCLUSION_VERTS("Push Occlusion");
+static LLFastTimer::DeclareTimer FTM_SET_OCCLUSION_STATE("Occlusion State");
+static LLFastTimer::DeclareTimer FTM_OCCLUSION_EARLY_FAIL("Occlusion Early Fail");
+
 void LLSpatialGroup::doOcclusion(LLCamera* camera)
 {
 	if (mSpatialPartition->isOcclusionEnabled() && LLPipeline::sUseOcclusion > 1)
@@ -1623,6 +1638,7 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 		// Don't cull hole/edge water, unless we have the GL_ARB_depth_clamp extension
 		if (earlyFail(camera, this))
 		{
+			LLFastTimer t(FTM_OCCLUSION_EARLY_FAIL);
 			setOcclusionState(LLSpatialGroup::DISCARD_QUERY);
 			assert_states_valid(this);
 			clearOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
@@ -1664,41 +1680,47 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 					sPendingQueries.insert(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
 #endif
 
-					glBeginQueryARB(mode, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
+					{
+						LLFastTimer t(FTM_PUSH_OCCLUSION_VERTS);
+						glBeginQueryARB(mode, mOcclusionQuery[LLViewerCamera::sCurCameraID]);					
 					
-					mOcclusionVerts->setBuffer(LLVertexBuffer::MAP_VERTEX);
+						mOcclusionVerts->setBuffer(LLVertexBuffer::MAP_VERTEX);
 
-					if (!use_depth_clamp && mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER)
-					{
-						LLGLSquashToFarClip squash(glh_get_current_projection(), 1);
-						if (camera->getOrigin().isExactlyZero())
-						{ //origin is invalid, draw entire box
-							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
-							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
-						}
-						else
+						if (!use_depth_clamp && mSpatialPartition->mDrawableType == LLDrawPool::POOL_VOIDWATER)
 						{
-							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
-						}
-					}
-					else
-					{
-						if (camera->getOrigin().isExactlyZero())
-						{ //origin is invalid, draw entire box
-							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
-							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
+							LLGLSquashToFarClip squash(glh_get_current_projection(), 1);
+							if (camera->getOrigin().isExactlyZero())
+							{ //origin is invalid, draw entire box
+								mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
+								mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
+							}
+							else
+							{
+								mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
+							}
 						}
 						else
 						{
-							mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
+							if (camera->getOrigin().isExactlyZero())
+							{ //origin is invalid, draw entire box
+								mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, 0);
+								mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, b111*8);				
+							}
+							else
+							{
+								mOcclusionVerts->drawRange(LLRender::TRIANGLE_FAN, 0, 7, 8, get_box_fan_indices(camera, mBounds[0]));
+							}
 						}
-					}
 
-					glEndQueryARB(mode);
+						glEndQueryARB(mode);
+					}
 				}
 
-				setOcclusionState(LLSpatialGroup::QUERY_PENDING);
-				clearOcclusionState(LLSpatialGroup::DISCARD_QUERY);
+				{
+					LLFastTimer t(FTM_SET_OCCLUSION_STATE);
+					setOcclusionState(LLSpatialGroup::QUERY_PENDING);
+					clearOcclusionState(LLSpatialGroup::DISCARD_QUERY);
+				}
 			}
 		}
 	}
-- 
cgit v1.2.3


From 162d467b4a8ca1dae6b16ece1728873d43a287ac Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 3 Mar 2011 16:14:52 -0600
Subject: SH-1085 Fix for crash when unchecking "mirror."  Basically got LLFace
 to be paranoid about who gets to touch its LLVertexBuffer members.

Reviewed by Nyx.
---
 indra/newview/llspatialpartition.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 14775f0f21..5e7af6bbb3 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1486,8 +1486,7 @@ void LLSpatialGroup::destroyGL()
 		for (S32 j = 0; j < drawable->getNumFaces(); j++)
 		{
 			LLFace* facep = drawable->getFace(j);
-			facep->mVertexBuffer = NULL;
-			facep->mLastVertexBuffer = NULL;
+			facep->clearVertexBuffer();
 		}
 	}
 }
@@ -2433,7 +2432,9 @@ void pushVerts(LLSpatialGroup* group, U32 mask)
 
 void pushVerts(LLFace* face, U32 mask)
 {
-	LLVertexBuffer* buffer = face->mVertexBuffer;
+	llassert(face->verify());
+
+	LLVertexBuffer* buffer = face->getVertexBuffer();
 
 	if (buffer)
 	{
@@ -2580,7 +2581,7 @@ void renderOctree(LLSpatialGroup* group)
 				for (S32 j = 0; j < drawable->getNumFaces(); j++)
 				{
 					LLFace* face = drawable->getFace(j);
-					if (face->mVertexBuffer.notNull())
+					if (face->getVertexBuffer())
 					{
 						if (gFrameTimeSeconds - face->mLastUpdateTime < 0.5f)
 						{
@@ -2595,10 +2596,10 @@ void renderOctree(LLSpatialGroup* group)
 							continue;
 						}
 
-						face->mVertexBuffer->setBuffer(LLVertexBuffer::MAP_VERTEX);
+						face->getVertexBuffer()->setBuffer(LLVertexBuffer::MAP_VERTEX);
 						//drawBox((face->mExtents[0] + face->mExtents[1])*0.5f,
 						//		(face->mExtents[1]-face->mExtents[0])*0.5f);
-						face->mVertexBuffer->draw(LLRender::TRIANGLES, face->getIndicesCount(), face->getIndicesStart());
+						face->getVertexBuffer()->draw(LLRender::TRIANGLES, face->getIndicesCount(), face->getIndicesStart());
 					}
 				}
 
@@ -3374,7 +3375,7 @@ void renderPhysicsShapes(LLSpatialGroup* group)
 				for (S32 i = 0; i < drawable->getNumFaces(); ++i)
 				{
 					LLFace* face = drawable->getFace(i);
-					LLVertexBuffer* buff = face->mVertexBuffer;
+					LLVertexBuffer* buff = face->getVertexBuffer();
 					if (buff)
 					{
 						glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-- 
cgit v1.2.3


From 719610e68ba8275f08f51d127ab760799cb1d1c3 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 29 Mar 2011 11:50:02 -0500
Subject: SH-1225 Import convex hull data from .slm

---
 indra/newview/llspatialpartition.cpp | 51 ++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 29 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 5e7af6bbb3..65f7d299bc 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2961,31 +2961,21 @@ S32 get_physics_detail(const LLVolumeParams& volume_params, const LLVector3& sca
 void renderMeshBaseHull(LLVOVolume* volume, U32 data_mask, LLColor4& color, LLColor4& line_color)
 {
 	LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
-	const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
+	LLModel::Decomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
 
 	const LLVector3 center(0,0,0);
 	const LLVector3 size(0.25f,0.25f,0.25f);
 
 	if (decomp)
 	{		
-		LLVertexBuffer* buff = decomp->mBaseHullMesh;
-
-		if (buff && buff->getNumVerts() > 0)
+		if (!decomp->mBaseHullMesh.empty())
 		{
-			buff->setBuffer(data_mask);
-
-		/*	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-			glColor4fv(line_color.mV);
-			buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
-			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);*/
-
-			{
-				glColor4fv(color.mV);
-				buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
-			}
+			glColor4fv(color.mV);
+			LLVertexBuffer::drawArrays(LLRender::TRIANGLES, decomp->mBaseHullMesh.mPositions, decomp->mBaseHullMesh.mNormals);
 		}
 		else
 		{
+			gMeshRepo.buildPhysicsMesh(*decomp);
 			gGL.color3f(0,1,1);
 			drawBoxOutline(center, size);
 		}
@@ -2998,19 +2988,16 @@ void renderMeshBaseHull(LLVOVolume* volume, U32 data_mask, LLColor4& color, LLCo
 	}
 }
 
-void render_hull(LLVertexBuffer* buff, U32 data_mask, const LLColor4& color, const LLColor4& line_color)
+void render_hull(LLModel::PhysicsMesh& mesh, const LLColor4& color, const LLColor4& line_color)
 {
-	buff->setBuffer(data_mask);
-
 	glColor4fv(color.mV);
-	buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
-
+	LLVertexBuffer::drawArrays(LLRender::TRIANGLES, mesh.mPositions, mesh.mNormals);
 	LLGLEnable offset(GL_POLYGON_OFFSET_LINE);
 	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 	glPolygonOffset(3.f, 3.f);
 	glLineWidth(3.f);
 	glColor4fv(line_color.mV);
-	buff->drawArrays(LLRender::TRIANGLES, 0, buff->getNumVerts());
+	LLVertexBuffer::drawArrays(LLRender::TRIANGLES, mesh.mPositions, mesh.mNormals);
 	glLineWidth(1.f);
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 }
@@ -3075,7 +3062,7 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 	if (type == LLPhysicsShapeBuilderUtil::PhysicsShapeSpecification::USER_MESH)
 	{
 		LLUUID mesh_id = volume->getVolume()->getParams().getSculptID();
-		const LLMeshDecomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
+		LLModel::Decomposition* decomp = gMeshRepo.getDecomposition(mesh_id);
 			
 		if (decomp)
 		{ //render a physics based mesh
@@ -3084,27 +3071,33 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 			if (!decomp->mHull.empty())
 			{ //decomposition exists, use that
-				for (U32 i = 0; i < decomp->mHull.size(); ++i)
+
+				if (decomp->mMesh.empty())
+				{
+					gMeshRepo.buildPhysicsMesh(*decomp);
+				}
+
+				for (U32 i = 0; i < decomp->mMesh.size(); ++i)
 				{		
-					render_hull(decomp->mMesh[i], data_mask, color, line_color);
+					render_hull(decomp->mMesh[i], color, line_color);
 				}
 			}
-			else if (decomp->mPhysicsShapeMesh.notNull() && decomp->mPhysicsShapeMesh->getNumVerts() > 0)
+			else if (!decomp->mPhysicsShapeMesh.empty())
 			{ 
 				//decomp has physics mesh, render that mesh
 				glColor4fv(color.mV);
-				pushBufferVerts(decomp->mPhysicsShapeMesh, data_mask);
-				
+				LLVertexBuffer::drawArrays(LLRender::TRIANGLES, decomp->mPhysicsShapeMesh.mPositions, decomp->mPhysicsShapeMesh.mNormals);
+								
 				glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 				glColor4fv(line_color.mV);
-				pushBufferVerts(decomp->mPhysicsShapeMesh, data_mask);
+				LLVertexBuffer::drawArrays(LLRender::TRIANGLES, decomp->mPhysicsShapeMesh.mPositions, decomp->mPhysicsShapeMesh.mNormals);
 				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 			}
 			else
 			{ //no mesh or decomposition, render base hull
 				renderMeshBaseHull(volume, data_mask, color, line_color);
 
-				if (decomp->mPhysicsShapeMesh.isNull())
+				if (decomp->mPhysicsShapeMesh.empty())
 				{
 					//attempt to fetch physics shape mesh if available
 					gMeshRepo.fetchPhysicsShape(mesh_id);
-- 
cgit v1.2.3


From 2a843e9a6bb5cb70f69794419ab4a7d16ee3c6cb Mon Sep 17 00:00:00 2001
From: brad kittenbrink <brad@lindenlab.com>
Date: Thu, 12 May 2011 16:09:42 -0700
Subject: Fix up alignment problems for debug build. reviewed by davep.

---
 indra/newview/llspatialpartition.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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

diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 65f7d299bc..34a42ff28b 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -3169,11 +3169,11 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 					LLConvexDecomposition::getInstance()->generateSingleHullMeshFromMesh( &mesh, &res );
 
 					//copy res into phys_volume
-					phys_volume->mHullPoints = (LLVector4a*) malloc(sizeof(LLVector4a)*res.mNumVertices);
+					phys_volume->mHullPoints = (LLVector4a*) ll_aligned_malloc_16(sizeof(LLVector4a)*res.mNumVertices);
 					phys_volume->mNumHullPoints = res.mNumVertices;
 
 					S32 idx_size = (res.mNumTriangles*3*2+0xF) & ~0xF;
-					phys_volume->mHullIndices = (U16*) malloc(idx_size);
+					phys_volume->mHullIndices = (U16*) ll_aligned_malloc_16(idx_size);
 					phys_volume->mNumHullIndices = res.mNumTriangles*3;
 
 					const F32* v = res.mVertexBase;
-- 
cgit v1.2.3