Changeset 8351 for code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConvexShape.cpp

Timestamp:

Apr 28, 2011, 7:15:14 AM (13 years ago)

Author:

rgrieder

Message:

Merged kicklib2 branch back to trunk (includes former branches ois_update, mac_osx and kicklib).

Notes for updating

Linux:
You don't need an extra package for CEGUILua and Tolua, it's already shipped with CEGUI.
However you do need to make sure that the OgreRenderer is installed too with CEGUI 0.7 (may be a separate package).
Also, Orxonox now recognises if you install the CgProgramManager (a separate package available on newer Ubuntu on Debian systems).

Windows:
Download the new dependency packages versioned 6.0 and use these. If you have problems with that or if you don't like the in game console problem mentioned below, you can download the new 4.3 version of the packages (only available for Visual Studio 2005/2008).

Key new features:

• *Support for Mac OS X*
• Visual Studio 2010 support
• Bullet library update to 2.77
• OIS library update to 1.3
• Support for CEGUI 0.7 —> Support for Arch Linux and even SuSE
• Improved install target
• Compiles now with GCC 4.6
• Ogre Cg Shader plugin activated for Linux if available
• And of course lots of bug fixes

There are also some regressions:

• No support for CEGUI 0.5, Ogre 1.4 and boost 1.35 - 1.39 any more
• In game console is not working in main menu for CEGUI 0.7
• Tolua (just the C lib, not the application) and CEGUILua libraries are no longer in our repository. —> You will need to get these as well when compiling Orxonox
• And of course lots of new bugs we don't yet know about

File:

• code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConvexShape.cpp (modified) (7 diffs)

code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConvexShape.cpp

@@ -1 +1 @@
 /*
 Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
 
 This software is provided 'as-is', without any express or implied warranty.
@@ -22 +22 @@
 #include "btConvexPointCloudShape.h"
 
+///not supported on IBM SDK, until we fix the alignment of btVector3
+#if defined (__CELLOS_LV2__) && defined (__SPU__)
+#include <spu_intrinsics.h>
+static inline vec_float4 vec_dot3( vec_float4 vec0, vec_float4 vec1 )
+{
+    vec_float4 result;
+    result = spu_mul( vec0, vec1 );
+    result = spu_madd( spu_rlqwbyte( vec0, 4 ), spu_rlqwbyte( vec1, 4 ), result );
+    return spu_madd( spu_rlqwbyte( vec0, 8 ), spu_rlqwbyte( vec1, 8 ), result );
+}
+#endif //__SPU__
+
 btConvexShape::btConvexShape ()
 {
@@ -33 +45 @@
 
 
-static btVector3 convexHullSupport (const btVector3& localDir, const btVector3* points, int numPoints, const btVector3& localScaling)
-{
-        btVector3 supVec(btScalar(0.),btScalar(0.),btScalar(0.));
-        btScalar newDot,maxDot = btScalar(-1e30);
-
-        btVector3 vec0(localDir.getX(),localDir.getY(),localDir.getZ());
-        btVector3 vec = vec0;
-        btScalar lenSqr = vec.length2();
-        if (lenSqr < btScalar(0.0001))
-        {
-                vec.setValue(1,0,0);
-        } else {
-                btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
-                vec *= rlen;
-        }
-
+static btVector3 convexHullSupport (const btVector3& localDirOrg, const btVector3* points, int numPoints, const btVector3& localScaling)
+{       
+
+        btVector3 vec = localDirOrg * localScaling;
+
+#if defined (__CELLOS_LV2__) && defined (__SPU__)
+
+        btVector3 localDir = vec;
+
+        vec_float4 v_distMax = {-FLT_MAX,0,0,0};
+        vec_int4 v_idxMax = {-999,0,0,0};
+        int v=0;
+        int numverts = numPoints;
+
+        for(;v<(int)numverts-4;v+=4) {
+                vec_float4 p0 = vec_dot3(points[v  ].get128(),localDir.get128());
+                vec_float4 p1 = vec_dot3(points[v+1].get128(),localDir.get128());
+                vec_float4 p2 = vec_dot3(points[v+2].get128(),localDir.get128());
+                vec_float4 p3 = vec_dot3(points[v+3].get128(),localDir.get128());
+                const vec_int4 i0 = {v  ,0,0,0};
+                const vec_int4 i1 = {v+1,0,0,0};
+                const vec_int4 i2 = {v+2,0,0,0};
+                const vec_int4 i3 = {v+3,0,0,0};
+                vec_uint4  retGt01 = spu_cmpgt(p0,p1);
+                vec_float4 pmax01 = spu_sel(p1,p0,retGt01);
+                vec_int4   imax01 = spu_sel(i1,i0,retGt01);
+                vec_uint4  retGt23 = spu_cmpgt(p2,p3);
+                vec_float4 pmax23 = spu_sel(p3,p2,retGt23);
+                vec_int4   imax23 = spu_sel(i3,i2,retGt23);
+                vec_uint4  retGt0123 = spu_cmpgt(pmax01,pmax23);
+                vec_float4 pmax0123 = spu_sel(pmax23,pmax01,retGt0123);
+                vec_int4   imax0123 = spu_sel(imax23,imax01,retGt0123);
+                vec_uint4  retGtMax = spu_cmpgt(v_distMax,pmax0123);
+                v_distMax = spu_sel(pmax0123,v_distMax,retGtMax);
+                v_idxMax = spu_sel(imax0123,v_idxMax,retGtMax);
+        }
+        for(;v<(int)numverts;v++) {
+                vec_float4 p = vec_dot3(points[v].get128(),localDir.get128());
+                const vec_int4 i = {v,0,0,0};
+                vec_uint4  retGtMax = spu_cmpgt(v_distMax,p);
+                v_distMax = spu_sel(p,v_distMax,retGtMax);
+                v_idxMax = spu_sel(i,v_idxMax,retGtMax);
+        }
+        int ptIndex = spu_extract(v_idxMax,0);
+        const btVector3& supVec= points[ptIndex] * localScaling;
+        return supVec;
+#else
+
+        btScalar newDot,maxDot = btScalar(-BT_LARGE_FLOAT);
+        int ptIndex = -1;
 
         for (int i=0;i<numPoints;i++)
         {
-                btVector3 vtx = points[i] * localScaling;
-
-                newDot = vec.dot(vtx);
+
+                newDot = vec.dot(points[i]);
                 if (newDot > maxDot)
                 {
                         maxDot = newDot;
-                        supVec = vtx;
-                }
-        }
-        return btVector3(supVec.getX(),supVec.getY(),supVec.getZ());
+                        ptIndex = i;
+                }
+        }
+        btAssert(ptIndex >= 0);
+        btVector3 supVec = points[ptIndex] * localScaling;
+        return supVec;
+#endif //__SPU__
 }
 
@@ -161 +209 @@
                 btVector3 supVec(0,0,0);
 
-                btScalar maxDot(btScalar(-1e30));
+                btScalar maxDot(btScalar(-BT_LARGE_FLOAT));
 
                 btVector3 vec = vec0;
@@ -293 +341 @@
         return btScalar(0.0f);
 }
-
+#ifndef __SPU__
 void btConvexShape::getAabbNonVirtual (const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
 {
@@ -361 +409 @@
         case CONVEX_HULL_SHAPE_PROXYTYPE:
         {
-                btPolyhedralConvexShape* convexHullShape = (btPolyhedralConvexShape*)this;
+                btPolyhedralConvexAabbCachingShape* convexHullShape = (btPolyhedralConvexAabbCachingShape*)this;
                 btScalar margin = convexHullShape->getMarginNonVirtual();
                 convexHullShape->getNonvirtualAabb (t, aabbMin, aabbMax, margin);
@@ -378 +426 @@
         btAssert (0);
 }
+
+#endif //__SPU__