Bullet/BulletFull/btInternalEdgeUtility_8cpp_source.html

 #include "btInternalEdgeUtility.h"

 #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
 #include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h"
 #include "BulletCollision/CollisionShapes/btTriangleShape.h"
 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
 #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h"
 #include "LinearMath/btIDebugDraw.h"
 #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"

 //#define DEBUG_INTERNAL_EDGE

 #ifdef DEBUG_INTERNAL_EDGE
 #include <stdio.h>
 #endif //DEBUG_INTERNAL_EDGE


 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
 static btIDebugDraw* gDebugDrawer = 0;

 void    btSetDebugDrawer(btIDebugDraw* debugDrawer)
 {
         gDebugDrawer = debugDrawer;
 }

 static void    btDebugDrawLine(const btVector3& from,const btVector3& to, const btVector3& color)
 {
         if (gDebugDrawer)
                 gDebugDrawer->drawLine(from,to,color);
 }
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW


 static int      btGetHash(int partId, int triangleIndex)
 {
         int hash = (partId<<(31-MAX_NUM_PARTS_IN_BITS)) | triangleIndex;
         return hash;
 }


 static btScalar btGetAngle(const btVector3& edgeA, const btVector3& normalA,const btVector3& normalB)
 {
         const btVector3 refAxis0  = edgeA;
         const btVector3 refAxis1  = normalA;
         const btVector3 swingAxis = normalB;
         btScalar angle = btAtan2(swingAxis.dot(refAxis0), swingAxis.dot(refAxis1));
         return  angle;
 }


 struct btConnectivityProcessor : public btTriangleCallback
 {
         int                             m_partIdA;
         int                             m_triangleIndexA;
         btVector3*              m_triangleVerticesA;
         btTriangleInfoMap*      m_triangleInfoMap;


         virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex)
         {
                 //skip self-collisions
                 if ((m_partIdA == partId) && (m_triangleIndexA == triangleIndex))
                         return;

                 //skip duplicates (disabled for now)
                 //if ((m_partIdA <= partId) && (m_triangleIndexA <= triangleIndex))
                 //      return;

                 //search for shared vertices and edges
                 int numshared = 0;
                 int sharedVertsA[3]={-1,-1,-1};
                 int sharedVertsB[3]={-1,-1,-1};

                 btScalar crossBSqr = ((triangle[1]-triangle[0]).cross(triangle[2]-triangle[0])).length2();
                 if (crossBSqr < m_triangleInfoMap->m_equalVertexThreshold)
                         return;


                 btScalar crossASqr = ((m_triangleVerticesA[1]-m_triangleVerticesA[0]).cross(m_triangleVerticesA[2]-m_triangleVerticesA[0])).length2();
                 if (crossASqr< m_triangleInfoMap->m_equalVertexThreshold)
                         return;

 #if 0
                 printf("triangle A[0]   =       (%f,%f,%f)\ntriangle A[1]       =       (%f,%f,%f)\ntriangle A[2]       =       (%f,%f,%f)\n",
                         m_triangleVerticesA[0].getX(),m_triangleVerticesA[0].getY(),m_triangleVerticesA[0].getZ(),
                         m_triangleVerticesA[1].getX(),m_triangleVerticesA[1].getY(),m_triangleVerticesA[1].getZ(),
                         m_triangleVerticesA[2].getX(),m_triangleVerticesA[2].getY(),m_triangleVerticesA[2].getZ());

                 printf("partId=%d, triangleIndex=%d\n",partId,triangleIndex);
                 printf("triangle B[0]   =       (%f,%f,%f)\ntriangle B[1]       =       (%f,%f,%f)\ntriangle B[2]       =       (%f,%f,%f)\n",
                         triangle[0].getX(),triangle[0].getY(),triangle[0].getZ(),
                         triangle[1].getX(),triangle[1].getY(),triangle[1].getZ(),
                         triangle[2].getX(),triangle[2].getY(),triangle[2].getZ());
 #endif

                 for (int i=0;i<3;i++)
                 {
                         for (int j=0;j<3;j++)
                         {
                                 if ( (m_triangleVerticesA[i]-triangle[j]).length2() < m_triangleInfoMap->m_equalVertexThreshold)
                                 {
                                         sharedVertsA[numshared] = i;
                                         sharedVertsB[numshared] = j;
                                         numshared++;
                                         if(numshared >= 3)
                                                 return;
                                 }
                         }
                         if(numshared >= 3)
                                 return;
                 }
                 switch (numshared)
                 {
                 case 0:
                         {
                                 break;
                         }
                 case 1:
                         {
                                 //shared vertex
                                 break;
                         }
                 case 2:
                         {
                                 //shared edge
                                 //we need to make sure the edge is in the order V2V0 and not V0V2 so that the signs are correct
                                 if (sharedVertsA[0] == 0 && sharedVertsA[1] == 2)
                                 {
                                         sharedVertsA[0] = 2;
                                         sharedVertsA[1] = 0;
                                         int tmp = sharedVertsB[1];
                                         sharedVertsB[1] = sharedVertsB[0];
                                         sharedVertsB[0] = tmp;
                                 }

                                 int hash = btGetHash(m_partIdA,m_triangleIndexA);

                                 btTriangleInfo* info = m_triangleInfoMap->find(hash);
                                 if (!info)
                                 {
                                         btTriangleInfo tmp;
                                         m_triangleInfoMap->insert(hash,tmp);
                                         info = m_triangleInfoMap->find(hash);
                                 }

                                 int sumvertsA = sharedVertsA[0]+sharedVertsA[1];
                                 int otherIndexA = 3-sumvertsA;


                                 btVector3 edge(m_triangleVerticesA[sharedVertsA[1]]-m_triangleVerticesA[sharedVertsA[0]]);

                                 btTriangleShape tA(m_triangleVerticesA[0],m_triangleVerticesA[1],m_triangleVerticesA[2]);
                                 int otherIndexB = 3-(sharedVertsB[0]+sharedVertsB[1]);

                                 btTriangleShape tB(triangle[sharedVertsB[1]],triangle[sharedVertsB[0]],triangle[otherIndexB]);
                                 //btTriangleShape tB(triangle[0],triangle[1],triangle[2]);

                                 btVector3 normalA;
                                 btVector3 normalB;
                                 tA.calcNormal(normalA);
                                 tB.calcNormal(normalB);
                                 edge.normalize();
                                 btVector3 edgeCrossA = edge.cross(normalA).normalize();

                                 {
                                         btVector3 tmp = m_triangleVerticesA[otherIndexA]-m_triangleVerticesA[sharedVertsA[0]];
                                         if (edgeCrossA.dot(tmp) < 0)
                                         {
                                                 edgeCrossA*=-1;
                                         }
                                 }

                                 btVector3 edgeCrossB = edge.cross(normalB).normalize();

                                 {
                                         btVector3 tmp = triangle[otherIndexB]-triangle[sharedVertsB[0]];
                                         if (edgeCrossB.dot(tmp) < 0)
                                         {
                                                 edgeCrossB*=-1;
                                         }
                                 }

                                 btScalar        angle2 = 0;
                                 btScalar        ang4 = 0.f;


                                 btVector3 calculatedEdge = edgeCrossA.cross(edgeCrossB);
                                 btScalar len2 = calculatedEdge.length2();

                                 btScalar correctedAngle(0);
                                 //btVector3 calculatedNormalB = normalA;
                                 bool isConvex = false;

                                 if (len2<m_triangleInfoMap->m_planarEpsilon)
                                 {
                                         angle2 = 0.f;
                                         ang4 = 0.f;
                                 } else
                                 {

                                         calculatedEdge.normalize();
                                         btVector3 calculatedNormalA = calculatedEdge.cross(edgeCrossA);
                                         calculatedNormalA.normalize();
                                         angle2 = btGetAngle(calculatedNormalA,edgeCrossA,edgeCrossB);
                                         ang4 = SIMD_PI-angle2;
                                         btScalar dotA = normalA.dot(edgeCrossB);
                                         isConvex = (dotA<0.);

                                         correctedAngle = isConvex ? ang4 : -ang4;
                                 }


                                 //alternatively use
                                 //btVector3 calculatedNormalB2 = quatRotate(orn,normalA);


                                 switch (sumvertsA)
                                 {
                                 case 1:
                                         {
                                                 btVector3 edge = m_triangleVerticesA[0]-m_triangleVerticesA[1];
                                                 btQuaternion orn(edge,-correctedAngle);
                                                 btVector3 computedNormalB = quatRotate(orn,normalA);
                                                 btScalar bla = computedNormalB.dot(normalB);
                                                 if (bla<0)
                                                 {
                                                         computedNormalB*=-1;
                                                         info->m_flags |= TRI_INFO_V0V1_SWAP_NORMALB;
                                                 }
 #ifdef DEBUG_INTERNAL_EDGE
                                                 if ((computedNormalB-normalB).length()>0.0001)
                                                 {
                                                         printf("warning: normals not identical\n");
                                                 }
 #endif//DEBUG_INTERNAL_EDGE

                                                 info->m_edgeV0V1Angle = -correctedAngle;

                                                 if (isConvex)
                                                         info->m_flags |= TRI_INFO_V0V1_CONVEX;
                                                 break;
                                         }
                                 case 2:
                                         {
                                                 btVector3 edge = m_triangleVerticesA[2]-m_triangleVerticesA[0];
                                                 btQuaternion orn(edge,-correctedAngle);
                                                 btVector3 computedNormalB = quatRotate(orn,normalA);
                                                 if (computedNormalB.dot(normalB)<0)
                                                 {
                                                         computedNormalB*=-1;
                                                         info->m_flags |= TRI_INFO_V2V0_SWAP_NORMALB;
                                                 }

 #ifdef DEBUG_INTERNAL_EDGE
                                                 if ((computedNormalB-normalB).length()>0.0001)
                                                 {
                                                         printf("warning: normals not identical\n");
                                                 }
 #endif //DEBUG_INTERNAL_EDGE
                                                 info->m_edgeV2V0Angle = -correctedAngle;
                                                 if (isConvex)
                                                         info->m_flags |= TRI_INFO_V2V0_CONVEX;
                                                 break;
                                         }
                                 case 3:
                                         {
                                                 btVector3 edge = m_triangleVerticesA[1]-m_triangleVerticesA[2];
                                                 btQuaternion orn(edge,-correctedAngle);
                                                 btVector3 computedNormalB = quatRotate(orn,normalA);
                                                 if (computedNormalB.dot(normalB)<0)
                                                 {
                                                         info->m_flags |= TRI_INFO_V1V2_SWAP_NORMALB;
                                                         computedNormalB*=-1;
                                                 }
 #ifdef DEBUG_INTERNAL_EDGE
                                                 if ((computedNormalB-normalB).length()>0.0001)
                                                 {
                                                         printf("warning: normals not identical\n");
                                                 }
 #endif //DEBUG_INTERNAL_EDGE
                                                 info->m_edgeV1V2Angle = -correctedAngle;

                                                 if (isConvex)
                                                         info->m_flags |= TRI_INFO_V1V2_CONVEX;
                                                 break;
                                         }
                                 }

                                 break;
                         }
                 default:
                         {
                                 //                              printf("warning: duplicate triangle\n");
                         }

                 }
         }
 };

 void btGenerateInternalEdgeInfo (btBvhTriangleMeshShape*trimeshShape, btTriangleInfoMap* triangleInfoMap)
 {
         //the user pointer shouldn't already be used for other purposes, we intend to store connectivity info there!
         if (trimeshShape->getTriangleInfoMap())
                 return;

         trimeshShape->setTriangleInfoMap(triangleInfoMap);

         btStridingMeshInterface* meshInterface = trimeshShape->getMeshInterface();
         const btVector3& meshScaling = meshInterface->getScaling();

         for (int partId = 0; partId< meshInterface->getNumSubParts();partId++)
         {
                 const unsigned char *vertexbase = 0;
                 int numverts = 0;
                 PHY_ScalarType type = PHY_INTEGER;
                 int stride = 0;
                 const unsigned char *indexbase = 0;
                 int indexstride = 0;
                 int numfaces = 0;
                 PHY_ScalarType indicestype = PHY_INTEGER;
                 //PHY_ScalarType indexType=0;

                 btVector3 triangleVerts[3];
                 meshInterface->getLockedReadOnlyVertexIndexBase(&vertexbase,numverts,   type,stride,&indexbase,indexstride,numfaces,indicestype,partId);
                 btVector3 aabbMin,aabbMax;

                 for (int triangleIndex = 0 ; triangleIndex < numfaces;triangleIndex++)
                 {
                         unsigned int* gfxbase = (unsigned int*)(indexbase+triangleIndex*indexstride);

                         for (int j=2;j>=0;j--)
                         {

                                 int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:gfxbase[j];
                                 if (type == PHY_FLOAT)
                                 {
                                         float* graphicsbase = (float*)(vertexbase+graphicsindex*stride);
                                         triangleVerts[j] = btVector3(
                                                 graphicsbase[0]*meshScaling.getX(),
                                                 graphicsbase[1]*meshScaling.getY(),
                                                 graphicsbase[2]*meshScaling.getZ());
                                 }
                                 else
                                 {
                                         double* graphicsbase = (double*)(vertexbase+graphicsindex*stride);
                                         triangleVerts[j] = btVector3( btScalar(graphicsbase[0]*meshScaling.getX()), btScalar(graphicsbase[1]*meshScaling.getY()), btScalar(graphicsbase[2]*meshScaling.getZ()));
                                 }
                         }
                         aabbMin.setValue(btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT));
                         aabbMax.setValue(btScalar(-BT_LARGE_FLOAT),btScalar(-BT_LARGE_FLOAT),btScalar(-BT_LARGE_FLOAT));
                         aabbMin.setMin(triangleVerts[0]);
                         aabbMax.setMax(triangleVerts[0]);
                         aabbMin.setMin(triangleVerts[1]);
                         aabbMax.setMax(triangleVerts[1]);
                         aabbMin.setMin(triangleVerts[2]);
                         aabbMax.setMax(triangleVerts[2]);

                         btConnectivityProcessor connectivityProcessor;
                         connectivityProcessor.m_partIdA = partId;
                         connectivityProcessor.m_triangleIndexA = triangleIndex;
                         connectivityProcessor.m_triangleVerticesA = &triangleVerts[0];
                         connectivityProcessor.m_triangleInfoMap  = triangleInfoMap;

                         trimeshShape->processAllTriangles(&connectivityProcessor,aabbMin,aabbMax);
                 }

         }

 }


 // Given a point and a line segment (defined by two points), compute the closest point
 // in the line.  Cap the point at the endpoints of the line segment.
 void btNearestPointInLineSegment(const btVector3 &point, const btVector3& line0, const btVector3& line1, btVector3& nearestPoint)
 {
         btVector3 lineDelta     = line1 - line0;

         // Handle degenerate lines
         if ( lineDelta.fuzzyZero())
         {
                 nearestPoint = line0;
         }
         else
         {
                 btScalar delta = (point-line0).dot(lineDelta) / (lineDelta).dot(lineDelta);

                 // Clamp the point to conform to the segment's endpoints
                 if ( delta < 0 )
                         delta = 0;
                 else if ( delta > 1 )
                         delta = 1;

                 nearestPoint = line0 + lineDelta*delta;
         }
 }


 bool    btClampNormal(const btVector3& edge,const btVector3& tri_normal_org,const btVector3& localContactNormalOnB, btScalar correctedEdgeAngle, btVector3 & clampedLocalNormal)
 {
         btVector3 tri_normal = tri_normal_org;
         //we only have a local triangle normal, not a local contact normal -> only normal in world space...
         //either compute the current angle all in local space, or all in world space

         btVector3 edgeCross = edge.cross(tri_normal).normalize();
         btScalar curAngle = btGetAngle(edgeCross,tri_normal,localContactNormalOnB);

         if (correctedEdgeAngle<0)
         {
                 if (curAngle < correctedEdgeAngle)
                 {
                         btScalar diffAngle = correctedEdgeAngle-curAngle;
                         btQuaternion rotation(edge,diffAngle );
                         clampedLocalNormal = btMatrix3x3(rotation)*localContactNormalOnB;
                         return true;
                 }
         }

         if (correctedEdgeAngle>=0)
         {
                 if (curAngle > correctedEdgeAngle)
                 {
                         btScalar diffAngle = correctedEdgeAngle-curAngle;
                         btQuaternion rotation(edge,diffAngle );
                         clampedLocalNormal = btMatrix3x3(rotation)*localContactNormalOnB;
                         return true;
                 }
         }
         return false;
 }


 void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap,const btCollisionObjectWrapper* colObj1Wrap, int partId0, int index0, int normalAdjustFlags)
 {
         //btAssert(colObj0->getCollisionShape()->getShapeType() == TRIANGLE_SHAPE_PROXYTYPE);
         if (colObj0Wrap->getCollisionShape()->getShapeType() != TRIANGLE_SHAPE_PROXYTYPE)
                 return;

         btBvhTriangleMeshShape* trimesh = 0;

         if( colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType() == SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE )
         {
                 trimesh = ((btScaledBvhTriangleMeshShape*)colObj0Wrap->getCollisionObject()->getCollisionShape())->getChildShape();
         }
         else
         {
                 if (colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
                 {
                         trimesh = (btBvhTriangleMeshShape*)colObj0Wrap->getCollisionObject()->getCollisionShape();
                 }
         }
         if (trimesh==0)
                 return;

         btTriangleInfoMap* triangleInfoMapPtr = (btTriangleInfoMap*) trimesh->getTriangleInfoMap();
         if (!triangleInfoMapPtr)
                 return;

         int hash = btGetHash(partId0,index0);


         btTriangleInfo* info = triangleInfoMapPtr->find(hash);
         if (!info)
                 return;

         btScalar frontFacing = (normalAdjustFlags & BT_TRIANGLE_CONVEX_BACKFACE_MODE)==0? 1.f : -1.f;

         const btTriangleShape* tri_shape = static_cast<const btTriangleShape*>(colObj0Wrap->getCollisionShape());
         btVector3 v0,v1,v2;
         tri_shape->getVertex(0,v0);
         tri_shape->getVertex(1,v1);
         tri_shape->getVertex(2,v2);

         //btVector3 center = (v0+v1+v2)*btScalar(1./3.);

         btVector3 red(1,0,0), green(0,1,0),blue(0,0,1),white(1,1,1),black(0,0,0);
         btVector3 tri_normal;
         tri_shape->calcNormal(tri_normal);

         //btScalar dot = tri_normal.dot(cp.m_normalWorldOnB);
         btVector3 nearest;
         btNearestPointInLineSegment(cp.m_localPointB,v0,v1,nearest);

         btVector3 contact = cp.m_localPointB;
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
         const btTransform& tr = colObj0->getWorldTransform();
         btDebugDrawLine(tr*nearest,tr*cp.m_localPointB,red);
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW


         bool isNearEdge = false;

         int numConcaveEdgeHits = 0;
         int numConvexEdgeHits = 0;

         btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().getBasis().transpose() * cp.m_normalWorldOnB;
         localContactNormalOnB.normalize();//is this necessary?

         // Get closest edge
         int      bestedge=-1;
         btScalar    disttobestedge=BT_LARGE_FLOAT;
         //
         // Edge 0 -> 1
         if (btFabs(info->m_edgeV0V1Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
         {
            btVector3 nearest;
            btNearestPointInLineSegment( cp.m_localPointB, v0, v1, nearest );
            btScalar     len=(contact-nearest).length();
            //
            if( len < disttobestedge )
            {
               bestedge=0;
               disttobestedge=len;
       }
    }
         // Edge 1 -> 2
         if (btFabs(info->m_edgeV1V2Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
         {
            btVector3 nearest;
            btNearestPointInLineSegment( cp.m_localPointB, v1, v2, nearest );
            btScalar     len=(contact-nearest).length();
            //
            if( len < disttobestedge )
            {
               bestedge=1;
               disttobestedge=len;
       }
    }
         // Edge 2 -> 0
         if (btFabs(info->m_edgeV2V0Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
         {
            btVector3 nearest;
            btNearestPointInLineSegment( cp.m_localPointB, v2, v0, nearest );
            btScalar     len=(contact-nearest).length();
            //
            if( len < disttobestedge )
            {
               bestedge=2;
               disttobestedge=len;
       }
    }

 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
    btVector3 upfix=tri_normal * btVector3(0.1f,0.1f,0.1f);
    btDebugDrawLine(tr * v0 + upfix, tr * v1 + upfix, red );
 #endif
         if (btFabs(info->m_edgeV0V1Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
         {
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                 btDebugDrawLine(tr*contact,tr*(contact+cp.m_normalWorldOnB*10),black);
 #endif
                 btScalar len = (contact-nearest).length();
                 if(len<triangleInfoMapPtr->m_edgeDistanceThreshold)
                 if( bestedge==0 )
                 {
                         btVector3 edge(v0-v1);
                         isNearEdge = true;

                         if (info->m_edgeV0V1Angle==btScalar(0))
                         {
                                 numConcaveEdgeHits++;
                         } else
                         {

                                 bool isEdgeConvex = (info->m_flags & TRI_INFO_V0V1_CONVEX);
                                 btScalar swapFactor = isEdgeConvex ? btScalar(1) : btScalar(-1);
         #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                                 btDebugDrawLine(tr*nearest,tr*(nearest+swapFactor*tri_normal*10),white);
         #endif //BT_INTERNAL_EDGE_DEBUG_DRAW

                                 btVector3 nA = swapFactor * tri_normal;

                                 btQuaternion orn(edge,info->m_edgeV0V1Angle);
                                 btVector3 computedNormalB = quatRotate(orn,tri_normal);
                                 if (info->m_flags & TRI_INFO_V0V1_SWAP_NORMALB)
                                         computedNormalB*=-1;
                                 btVector3 nB = swapFactor*computedNormalB;

                                 btScalar        NdotA = localContactNormalOnB.dot(nA);
                                 btScalar        NdotB = localContactNormalOnB.dot(nB);
                                 bool backFacingNormal = (NdotA< triangleInfoMapPtr->m_convexEpsilon) && (NdotB<triangleInfoMapPtr->m_convexEpsilon);

 #ifdef DEBUG_INTERNAL_EDGE
                                 {

                                         btDebugDrawLine(cp.getPositionWorldOnB(),cp.getPositionWorldOnB()+tr.getBasis()*(nB*20),red);
                                 }
 #endif //DEBUG_INTERNAL_EDGE


                                 if (backFacingNormal)
                                 {
                                         numConcaveEdgeHits++;
                                 }
                                 else
                                 {
                                         numConvexEdgeHits++;
                                         btVector3 clampedLocalNormal;
                                         bool isClamped = btClampNormal(edge,swapFactor*tri_normal,localContactNormalOnB, info->m_edgeV0V1Angle,clampedLocalNormal);
                                         if (isClamped)
                                         {
                                                 if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED)!=0) || (clampedLocalNormal.dot(frontFacing*tri_normal)>0))
                                                 {
                                                         btVector3 newNormal = colObj0Wrap->getWorldTransform().getBasis() * clampedLocalNormal;
                                                         //                                      cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB);
                                                         cp.m_normalWorldOnB = newNormal;
                                                         // Reproject collision point along normal. (what about cp.m_distance1?)
                                                         cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
                                                         cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);

                                                 }
                                         }
                                 }
                         }
                 }
         }

         btNearestPointInLineSegment(contact,v1,v2,nearest);
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
         btDebugDrawLine(tr*nearest,tr*cp.m_localPointB,green);
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW

 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
    btDebugDrawLine(tr * v1 + upfix, tr * v2 + upfix , green );
 #endif

         if (btFabs(info->m_edgeV1V2Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
         {
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                 btDebugDrawLine(tr*contact,tr*(contact+cp.m_normalWorldOnB*10),black);
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW


                 btScalar len = (contact-nearest).length();
                 if(len<triangleInfoMapPtr->m_edgeDistanceThreshold)
                 if( bestedge==1 )
                 {
                         isNearEdge = true;
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                         btDebugDrawLine(tr*nearest,tr*(nearest+tri_normal*10),white);
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW

                         btVector3 edge(v1-v2);

                         isNearEdge = true;

                         if (info->m_edgeV1V2Angle == btScalar(0))
                         {
                                 numConcaveEdgeHits++;
                         } else
                         {
                                 bool isEdgeConvex = (info->m_flags & TRI_INFO_V1V2_CONVEX)!=0;
                                 btScalar swapFactor = isEdgeConvex ? btScalar(1) : btScalar(-1);
         #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                                 btDebugDrawLine(tr*nearest,tr*(nearest+swapFactor*tri_normal*10),white);
         #endif //BT_INTERNAL_EDGE_DEBUG_DRAW

                                 btVector3 nA = swapFactor * tri_normal;

                                 btQuaternion orn(edge,info->m_edgeV1V2Angle);
                                 btVector3 computedNormalB = quatRotate(orn,tri_normal);
                                 if (info->m_flags & TRI_INFO_V1V2_SWAP_NORMALB)
                                         computedNormalB*=-1;
                                 btVector3 nB = swapFactor*computedNormalB;

 #ifdef DEBUG_INTERNAL_EDGE
                                 {
                                         btDebugDrawLine(cp.getPositionWorldOnB(),cp.getPositionWorldOnB()+tr.getBasis()*(nB*20),red);
                                 }
 #endif //DEBUG_INTERNAL_EDGE


                                 btScalar        NdotA = localContactNormalOnB.dot(nA);
                                 btScalar        NdotB = localContactNormalOnB.dot(nB);
                                 bool backFacingNormal = (NdotA< triangleInfoMapPtr->m_convexEpsilon) && (NdotB<triangleInfoMapPtr->m_convexEpsilon);

                                 if (backFacingNormal)
                                 {
                                         numConcaveEdgeHits++;
                                 }
                                 else
                                 {
                                         numConvexEdgeHits++;
                                         btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().getBasis().transpose() * cp.m_normalWorldOnB;
                                         btVector3 clampedLocalNormal;
                                         bool isClamped = btClampNormal(edge,swapFactor*tri_normal,localContactNormalOnB, info->m_edgeV1V2Angle,clampedLocalNormal);
                                         if (isClamped)
                                         {
                                                 if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED)!=0) || (clampedLocalNormal.dot(frontFacing*tri_normal)>0))
                                                 {
                                                         btVector3 newNormal = colObj0Wrap->getWorldTransform().getBasis() * clampedLocalNormal;
                                                         //                                      cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB);
                                                         cp.m_normalWorldOnB = newNormal;
                                                         // Reproject collision point along normal.
                                                         cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
                                                         cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
                                                 }
                                         }
                                 }
                         }
                 }
         }

         btNearestPointInLineSegment(contact,v2,v0,nearest);
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
         btDebugDrawLine(tr*nearest,tr*cp.m_localPointB,blue);
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
    btDebugDrawLine(tr * v2 + upfix, tr * v0 + upfix , blue );
 #endif

         if (btFabs(info->m_edgeV2V0Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
         {

 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                 btDebugDrawLine(tr*contact,tr*(contact+cp.m_normalWorldOnB*10),black);
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW

                 btScalar len = (contact-nearest).length();
                 if(len<triangleInfoMapPtr->m_edgeDistanceThreshold)
                 if( bestedge==2 )
                 {
                         isNearEdge = true;
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                         btDebugDrawLine(tr*nearest,tr*(nearest+tri_normal*10),white);
 #endif //BT_INTERNAL_EDGE_DEBUG_DRAW

                         btVector3 edge(v2-v0);

                         if (info->m_edgeV2V0Angle==btScalar(0))
                         {
                                 numConcaveEdgeHits++;
                         } else
                         {

                                 bool isEdgeConvex = (info->m_flags & TRI_INFO_V2V0_CONVEX)!=0;
                                 btScalar swapFactor = isEdgeConvex ? btScalar(1) : btScalar(-1);
         #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
                                 btDebugDrawLine(tr*nearest,tr*(nearest+swapFactor*tri_normal*10),white);
         #endif //BT_INTERNAL_EDGE_DEBUG_DRAW

                                 btVector3 nA = swapFactor * tri_normal;
                                 btQuaternion orn(edge,info->m_edgeV2V0Angle);
                                 btVector3 computedNormalB = quatRotate(orn,tri_normal);
                                 if (info->m_flags & TRI_INFO_V2V0_SWAP_NORMALB)
                                         computedNormalB*=-1;
                                 btVector3 nB = swapFactor*computedNormalB;

 #ifdef DEBUG_INTERNAL_EDGE
                                 {
                                         btDebugDrawLine(cp.getPositionWorldOnB(),cp.getPositionWorldOnB()+tr.getBasis()*(nB*20),red);
                                 }
 #endif //DEBUG_INTERNAL_EDGE

                                 btScalar        NdotA = localContactNormalOnB.dot(nA);
                                 btScalar        NdotB = localContactNormalOnB.dot(nB);
                                 bool backFacingNormal = (NdotA< triangleInfoMapPtr->m_convexEpsilon) && (NdotB<triangleInfoMapPtr->m_convexEpsilon);

                                 if (backFacingNormal)
                                 {
                                         numConcaveEdgeHits++;
                                 }
                                 else
                                 {
                                         numConvexEdgeHits++;
                                         //                              printf("hitting convex edge\n");


                                         btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().getBasis().transpose() * cp.m_normalWorldOnB;
                                         btVector3 clampedLocalNormal;
                                         bool isClamped = btClampNormal(edge,swapFactor*tri_normal,localContactNormalOnB,info->m_edgeV2V0Angle,clampedLocalNormal);
                                         if (isClamped)
                                         {
                                                 if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED)!=0) || (clampedLocalNormal.dot(frontFacing*tri_normal)>0))
                                                 {
                                                         btVector3 newNormal = colObj0Wrap->getWorldTransform().getBasis() * clampedLocalNormal;
                                                         //                                      cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB);
                                                         cp.m_normalWorldOnB = newNormal;
                                                         // Reproject collision point along normal.
                                                         cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
                                                         cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
                                                 }
                                         }
                                 }
                         }


                 }
         }

 #ifdef DEBUG_INTERNAL_EDGE
         {
                 btVector3 color(0,1,1);
                 btDebugDrawLine(cp.getPositionWorldOnB(),cp.getPositionWorldOnB()+cp.m_normalWorldOnB*10,color);
         }
 #endif //DEBUG_INTERNAL_EDGE

         if (isNearEdge)
         {

                 if (numConcaveEdgeHits>0)
                 {
                         if ((normalAdjustFlags & BT_TRIANGLE_CONCAVE_DOUBLE_SIDED)!=0)
                         {
                                 //fix tri_normal so it pointing the same direction as the current local contact normal
                                 if (tri_normal.dot(localContactNormalOnB) < 0)
                                 {
                                         tri_normal *= -1;
                                 }
                                 cp.m_normalWorldOnB = colObj0Wrap->getWorldTransform().getBasis()*tri_normal;
                         } else
                         {
                                 btVector3 newNormal = tri_normal *frontFacing;
                                 //if the tri_normal is pointing opposite direction as the current local contact normal, skip it
                                 btScalar d = newNormal.dot(localContactNormalOnB) ;
                                 if (d< 0)
                                 {
                                         return;
                                 }
                                 //modify the normal to be the triangle normal (or backfacing normal)
                                 cp.m_normalWorldOnB = colObj0Wrap->getWorldTransform().getBasis() *newNormal;
                         }

                         // Reproject collision point along normal.
                         cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
                         cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
                 }
         }
 }
SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:56

btNearestPointInLineSegment
void btNearestPointInLineSegment(const btVector3 &point, const btVector3 &line0, const btVector3 &line1, btVector3 &nearestPoint)
Definition: btInternalEdgeUtility.cpp:387

length
btScalar length(const btQuaternion &q)
Return the length of a quaternion.
Definition: btQuaternion.h:906

btCollisionShape::getShapeType
int getShapeType() const
Definition: btCollisionShape.h:112

BT_LARGE_FLOAT
#define BT_LARGE_FLOAT
Definition: btScalar.h:294

btBvhTriangleMeshShape::getTriangleInfoMap
const btTriangleInfoMap * getTriangleInfoMap() const
Definition: btBvhTriangleMeshShape.h:102

TRI_INFO_V0V1_SWAP_NORMALB
#define TRI_INFO_V0V1_SWAP_NORMALB
Definition: btTriangleInfoMap.h:29

btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:652

btInternalEdgeUtility.h

btConnectivityProcessor
Definition: btInternalEdgeUtility.cpp:52

btTriangleInfo::m_edgeV1V2Angle
btScalar m_edgeV1V2Angle
Definition: btTriangleInfoMap.h:49

TRI_INFO_V1V2_CONVEX
#define TRI_INFO_V1V2_CONVEX
Definition: btTriangleInfoMap.h:26

btConnectivityProcessor::m_partIdA
int m_partIdA
Definition: btInternalEdgeUtility.cpp:54

btIDebugDraw::drawLine
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0

btBvhTriangleMeshShape::processAllTriangles
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Definition: btBvhTriangleMeshShape.cpp:232

btTriangleInfoMap::m_maxEdgeAngleThreshold
btScalar m_maxEdgeAngleThreshold
used to determine edge contacts: if the closest distance between a contact point and an edge is small...
Definition: btTriangleInfoMap.h:64

TRIANGLE_MESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:55

btStridingMeshInterface::getScaling
const btVector3 & getScaling() const
Definition: btStridingMeshInterface.h:88

btBvhTriangleMeshShape.h

btGetHash
static int btGetHash(int partId, int triangleIndex)
Definition: btInternalEdgeUtility.cpp:34

btTriangleShape.h

btManifoldPoint
ManifoldContactPoint collects and maintains persistent contactpoints.
Definition: btManifoldPoint.h:49

btTriangleShape
Definition: btTriangleShape.h:22

btTriangleInfo::m_edgeV0V1Angle
btScalar m_edgeV0V1Angle
Definition: btTriangleInfoMap.h:48

btTriangleInfoMap::m_equalVertexThreshold
btScalar m_equalVertexThreshold
used to determine if a triangle edge is planar with zero angle
Definition: btTriangleInfoMap.h:62

TRI_INFO_V1V2_SWAP_NORMALB
#define TRI_INFO_V1V2_SWAP_NORMALB
Definition: btTriangleInfoMap.h:30

btVector3::dot
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition: btVector3.h:235

btScaledBvhTriangleMeshShape.h

btVector3::normalize
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
Definition: btVector3.h:309

btTriangleShape::calcNormal
void calcNormal(btVector3 &normal) const
Definition: btTriangleShape.h:111

quatRotate
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition: btQuaternion.h:937

btVector3::getZ
const btScalar & getZ() const
Return the z value.
Definition: btVector3.h:577

btTriangleShape::getVertex
virtual void getVertex(int index, btVector3 &vert) const
Definition: btTriangleShape.h:46

btBvhTriangleMeshShape
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
Definition: btBvhTriangleMeshShape.h:34

MAX_NUM_PARTS_IN_BITS
#define MAX_NUM_PARTS_IN_BITS
Definition: btQuantizedBvh.h:54

btAdjustInternalEdgeContacts
void btAdjustInternalEdgeContacts(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, const btCollisionObjectWrapper *colObj1Wrap, int partId0, int index0, int normalAdjustFlags)
Changes a btManifoldPoint collision normal to the normal from the mesh.
Definition: btInternalEdgeUtility.cpp:449

SIMD_PI
#define SIMD_PI
Definition: btScalar.h:504

btManifoldPoint::m_normalWorldOnB
btVector3 m_normalWorldOnB
Definition: btManifoldPoint.h:100

btManifoldPoint::m_positionWorldOnB
btVector3 m_positionWorldOnB
Definition: btManifoldPoint.h:97

btTriangleInfo::m_flags
int m_flags
Definition: btTriangleInfoMap.h:46

TRIANGLE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:32

btConnectivityProcessor::m_triangleInfoMap
btTriangleInfoMap * m_triangleInfoMap
Definition: btInternalEdgeUtility.cpp:57

btTriangleCallback
The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTrian...
Definition: btTriangleCallback.h:24

PHY_SHORT
Definition: btConcaveShape.h:29

btAtan2
btScalar btAtan2(btScalar x, btScalar y)
Definition: btScalar.h:496

btVector3::cross
btVector3 cross(const btVector3 &v) const
Return the cross product between this and another vector.
Definition: btVector3.h:389

btGenerateInternalEdgeInfo
void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape *trimeshShape, btTriangleInfoMap *triangleInfoMap)
Call btGenerateInternalEdgeInfo to create triangle info, store in the shape &#39;userInfo&#39;.
Definition: btInternalEdgeUtility.cpp:311

btVector3::getY
const btScalar & getY() const
Return the y value.
Definition: btVector3.h:575

btCollisionObjectWrapper::getWorldTransform
const btTransform & getWorldTransform() const
Definition: btCollisionObjectWrapper.h:38

btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112

btTriangleInfo
The btTriangleInfo structure stores information to adjust collision normals to avoid collisions again...
Definition: btTriangleInfoMap.h:36

btVector3::getX
const btScalar & getX() const
Return the x value.
Definition: btVector3.h:573

btHashMap::insert
void insert(const Key &key, const Value &value)
Definition: btHashMap.h:262

btIDebugDraw
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
Definition: btIDebugDraw.h:29

btManifoldPoint::m_positionWorldOnA
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity ...
Definition: btManifoldPoint.h:99

btVector3::fuzzyZero
bool fuzzyZero() const
Definition: btVector3.h:701

btCollisionObjectWrapper.h

btCollisionObjectWrapper::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObjectWrapper.h:40

BT_TRIANGLE_CONVEX_BACKFACE_MODE
Definition: btInternalEdgeUtility.h:23

btManifoldPoint::getPositionWorldOnB
const btVector3 & getPositionWorldOnB() const
Definition: btManifoldPoint.h:160

btTransform::invXform
btVector3 invXform(const btVector3 &inVec) const
Definition: btTransform.h:223

btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83

btStridingMeshInterface::getNumSubParts
virtual int getNumSubParts() const =0
getNumSubParts returns the number of seperate subparts each subpart has a continuous array of vertice...

btHashMap::find
const Value * find(const Key &key) const
Definition: btHashMap.h:422

TRI_INFO_V0V1_CONVEX
#define TRI_INFO_V0V1_CONVEX
for btTriangleInfo m_flags
Definition: btTriangleInfoMap.h:25

btVector3::length2
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:257

btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34

TRI_INFO_V2V0_SWAP_NORMALB
#define TRI_INFO_V2V0_SWAP_NORMALB
Definition: btTriangleInfoMap.h:31

btManifoldPoint::m_distance1
btScalar m_distance1
Definition: btManifoldPoint.h:102

btStridingMeshInterface
The btStridingMeshInterface is the interface class for high performance generic access to triangle me...
Definition: btStridingMeshInterface.h:30

btIDebugDraw.h

btManifoldPoint::m_localPointB
btVector3 m_localPointB
Definition: btManifoldPoint.h:96

BT_TRIANGLE_CONCAVE_DOUBLE_SIDED
Definition: btInternalEdgeUtility.h:24

PHY_INTEGER
Definition: btConcaveShape.h:28

btTriangleInfo::m_edgeV2V0Angle
btScalar m_edgeV2V0Angle
Definition: btTriangleInfoMap.h:50

btTriangleInfoMap::m_convexEpsilon
btScalar m_convexEpsilon
Definition: btTriangleInfoMap.h:60

btConnectivityProcessor::m_triangleIndexA
int m_triangleIndexA
Definition: btInternalEdgeUtility.cpp:55

btMatrix3x3::transpose
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1030

btCollisionObject.h

btGetAngle
static btScalar btGetAngle(const btVector3 &edgeA, const btVector3 &normalA, const btVector3 &normalB)
Definition: btInternalEdgeUtility.cpp:42

BT_TRIANGLE_CONVEX_DOUBLE_SIDED
Definition: btInternalEdgeUtility.h:25

TRI_INFO_V2V0_CONVEX
#define TRI_INFO_V2V0_CONVEX
Definition: btTriangleInfoMap.h:27

btStridingMeshInterface::getLockedReadOnlyVertexIndexBase
virtual void getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, int &numverts, PHY_ScalarType &type, int &stride, const unsigned char **indexbase, int &indexstride, int &numfaces, PHY_ScalarType &indicestype, int subpart=0) const =0

btClampNormal
bool btClampNormal(const btVector3 &edge, const btVector3 &tri_normal_org, const btVector3 &localContactNormalOnB, btScalar correctedEdgeAngle, btVector3 &clampedLocalNormal)
Definition: btInternalEdgeUtility.cpp:413

btScaledBvhTriangleMeshShape
The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMesh...
Definition: btScaledBvhTriangleMeshShape.h:24

btBvhTriangleMeshShape::setTriangleInfoMap
void setTriangleInfoMap(btTriangleInfoMap *triangleInfoMap)
Definition: btBvhTriangleMeshShape.h:97

btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48

dot
btScalar dot(const btQuaternion &q1, const btQuaternion &q2)
Calculate the dot product between two quaternions.
Definition: btQuaternion.h:898

btTriangleInfoMap
The btTriangleInfoMap stores edge angle information for some triangles. You can compute this informat...
Definition: btTriangleInfoMap.h:58

btQuaternion
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:55

btTriangleMeshShape::getMeshInterface
btStridingMeshInterface * getMeshInterface()
Definition: btTriangleMeshShape.h:59

btVector3::setMax
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3.
Definition: btVector3.h:621

btConnectivityProcessor::m_triangleVerticesA
btVector3 * m_triangleVerticesA
Definition: btInternalEdgeUtility.cpp:56

btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:228

btManifoldPoint.h

btCollisionObjectWrapper
Definition: btCollisionObjectWrapper.h:17

btConnectivityProcessor::processTriangle
virtual void processTriangle(btVector3 *triangle, int partId, int triangleIndex)
Definition: btInternalEdgeUtility.cpp:60

btVector3::setMin
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3.
Definition: btVector3.h:638

btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292

PHY_ScalarType
PHY_ScalarType
PHY_ScalarType enumerates possible scalar types.
Definition: btConcaveShape.h:25

btCollisionObjectWrapper::getCollisionObject
const btCollisionObject * getCollisionObject() const
Definition: btCollisionObjectWrapper.h:39

PHY_FLOAT
Definition: btConcaveShape.h:26

btFabs
btScalar btFabs(btScalar x)
Definition: btScalar.h:475