dali-physics/third-party/bullet3/src/BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp

   1 /*
   2 Bullet Continuous Collision Detection and Physics Library
   3 Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
   4
   5 This software is provided 'as-is', without any express or implied warranty.
   6 In no event will the authors be held liable for any damages arising from the use of this software.
   7 Permission is granted to anyone to use this software for any purpose,
   8 including commercial applications, and to alter it and redistribute it freely,
   9 subject to the following restrictions:
  10
  11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  13 3. This notice may not be removed or altered from any source distribution.
  14 */
  15
  16 #include "btConvexPointCloudShape.h"
  17 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"
  18
  19 #include "LinearMath/btQuaternion.h"
  20
  21 void btConvexPointCloudShape::setLocalScaling(const btVector3& scaling)
  22 {
  23         m_localScaling = scaling;
  24         recalcLocalAabb();
  25 }
  26
  27 #ifndef __SPU__
  28 btVector3 btConvexPointCloudShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0) const
  29 {
  30         btVector3 supVec(btScalar(0.), btScalar(0.), btScalar(0.));
  31         btScalar maxDot = btScalar(-BT_LARGE_FLOAT);
  32
  33         btVector3 vec = vec0;
  34         btScalar lenSqr = vec.length2();
  35         if (lenSqr < btScalar(0.0001))
  36         {
  37                 vec.setValue(1, 0, 0);
  38         }
  39         else
  40         {
  41                 btScalar rlen = btScalar(1.) / btSqrt(lenSqr);
  42                 vec *= rlen;
  43         }
  44
  45         if (m_numPoints > 0)
  46         {
  47                 // Here we take advantage of dot(a*b, c) = dot( a, b*c) to do less work. Note this transformation is true mathematically, not numerically.
  48                 //    btVector3 scaled = vec * m_localScaling;
  49                 int index = (int)vec.maxDot(&m_unscaledPoints[0], m_numPoints, maxDot);  //FIXME: may violate encapsulation of m_unscaledPoints
  50                 return getScaledPoint(index);
  51         }
  52
  53         return supVec;
  54 }
  55
  56 void btConvexPointCloudShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const
  57 {
  58         for (int j = 0; j < numVectors; j++)
  59         {
  60                 const btVector3& vec = vectors[j] * m_localScaling;  // dot( a*c, b) = dot(a, b*c)
  61                 btScalar maxDot;
  62                 int index = (int)vec.maxDot(&m_unscaledPoints[0], m_numPoints, maxDot);
  63                 supportVerticesOut[j][3] = btScalar(-BT_LARGE_FLOAT);
  64                 if (0 <= index)
  65                 {
  66                         //WARNING: don't swap next lines, the w component would get overwritten!
  67                         supportVerticesOut[j] = getScaledPoint(index);
  68                         supportVerticesOut[j][3] = maxDot;
  69                 }
  70         }
  71 }
  72
  73 btVector3 btConvexPointCloudShape::localGetSupportingVertex(const btVector3& vec) const
  74 {
  75         btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec);
  76
  77         if (getMargin() != btScalar(0.))
  78         {
  79                 btVector3 vecnorm = vec;
  80                 if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON))
  81                 {
  82                         vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.));
  83                 }
  84                 vecnorm.normalize();
  85                 supVertex += getMargin() * vecnorm;
  86         }
  87         return supVertex;
  88 }
  89
  90 #endif
  91
  92 //currently just for debugging (drawing), perhaps future support for algebraic continuous collision detection
  93 //Please note that you can debug-draw btConvexHullShape with the Raytracer Demo
  94 int btConvexPointCloudShape::getNumVertices() const
  95 {
  96         return m_numPoints;
  97 }
  98
  99 int btConvexPointCloudShape::getNumEdges() const
 100 {
 101         return 0;
 102 }
 103
 104 void btConvexPointCloudShape::getEdge(int i, btVector3& pa, btVector3& pb) const
 105 {
 106         btAssert(0);
 107 }
 108
 109 void btConvexPointCloudShape::getVertex(int i, btVector3& vtx) const
 110 {
 111         vtx = m_unscaledPoints[i] * m_localScaling;
 112 }
 113
 114 int btConvexPointCloudShape::getNumPlanes() const
 115 {
 116         return 0;
 117 }
 118
 119 void btConvexPointCloudShape::getPlane(btVector3&, btVector3&, int) const
 120 {
 121         btAssert(0);
 122 }
 123
 124 //not yet
 125 bool btConvexPointCloudShape::isInside(const btVector3&, btScalar) const
 126 {
 127         btAssert(0);
 128         return false;
 129 }