Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Feb 27, 2011, 7:43:24 AM (14 years ago)
Author:
rgrieder
Message:

Updated Bullet Physics Engine from v2.74 to v2.77

File:
1 edited

Legend:

Unmodified
Added
Removed
  • code/branches/kicklib/src/external/bullet/LinearMath/btConvexHull.cpp

    r5781 r7983  
    1717
    1818#include "btConvexHull.h"
    19 #include "LinearMath/btAlignedObjectArray.h"
    20 #include "LinearMath/btMinMax.h"
    21 #include "LinearMath/btVector3.h"
     19#include "btAlignedObjectArray.h"
     20#include "btMinMax.h"
     21#include "btVector3.h"
    2222
    2323
     
    9797                                static btVector3 dif;
    9898                dif = p1-p0;
    99                                 btScalar dn= dot(plane.normal,dif);
    100                                 btScalar t = -(plane.dist+dot(plane.normal,p0) )/dn;
     99                                btScalar dn= btDot(plane.normal,dif);
     100                                btScalar t = -(plane.dist+btDot(plane.normal,p0) )/dn;
    101101                                return p0 + (dif*t);
    102102}
     
    104104btVector3 PlaneProject(const btPlane &plane, const btVector3 &point)
    105105{
    106         return point - plane.normal * (dot(point,plane.normal)+plane.dist);
     106        return point - plane.normal * (btDot(point,plane.normal)+plane.dist);
    107107}
    108108
     
    111111        // return the normal of the triangle
    112112        // inscribed by v0, v1, and v2
    113         btVector3 cp=cross(v1-v0,v2-v1);
     113        btVector3 cp=btCross(v1-v0,v2-v1);
    114114        btScalar m=cp.length();
    115115        if(m==0) return btVector3(1,0,0);
     
    121121{
    122122        static btVector3 cp;
    123         cp = cross(udir,vdir).normalized();
    124 
    125         btScalar distu = -dot(cp,ustart);
    126         btScalar distv = -dot(cp,vstart);
     123        cp = btCross(udir,vdir).normalized();
     124
     125        btScalar distu = -btDot(cp,ustart);
     126        btScalar distv = -btDot(cp,vstart);
    127127        btScalar dist = (btScalar)fabs(distu-distv);
    128128        if(upoint)
    129129                {
    130130                btPlane plane;
    131                 plane.normal = cross(vdir,cp).normalized();
    132                 plane.dist = -dot(plane.normal,vstart);
     131                plane.normal = btCross(vdir,cp).normalized();
     132                plane.dist = -btDot(plane.normal,vstart);
    133133                *upoint = PlaneLineIntersection(plane,ustart,ustart+udir);
    134134        }
     
    136136                {
    137137                btPlane plane;
    138                 plane.normal = cross(udir,cp).normalized();
    139                 plane.dist = -dot(plane.normal,ustart);
     138                plane.normal = btCross(udir,cp).normalized();
     139                plane.dist = -btDot(plane.normal,ustart);
    140140                *vpoint = PlaneLineIntersection(plane,vstart,vstart+vdir);
    141141        }
     
    171171int PlaneTest(const btPlane &p, const btVector3 &v);
    172172int PlaneTest(const btPlane &p, const btVector3 &v) {
    173         btScalar a  = dot(v,p.normal)+p.dist;
     173        btScalar a  = btDot(v,p.normal)+p.dist;
    174174        int   flag = (a>planetestepsilon)?OVER:((a<-planetestepsilon)?UNDER:COPLANAR);
    175175        return flag;
     
    229229                if(allow[i])
    230230                {
    231                         if(m==-1 || dot(p[i],dir)>dot(p[m],dir))
     231                        if(m==-1 || btDot(p[i],dir)>btDot(p[m],dir))
    232232                                m=i;
    233233                }
     
    239239btVector3 orth(const btVector3 &v)
    240240{
    241         btVector3 a=cross(v,btVector3(0,0,1));
    242         btVector3 b=cross(v,btVector3(0,1,0));
     241        btVector3 a=btCross(v,btVector3(0,0,1));
     242        btVector3 b=btCross(v,btVector3(0,1,0));
    243243        if (a.length() > b.length())
    244244        {
     
    259259                if(allow[m]==3) return m;
    260260                T u = orth(dir);
    261                 T v = cross(u,dir);
     261                T v = btCross(u,dir);
    262262                int ma=-1;
    263263                for(btScalar x = btScalar(0.0) ; x<= btScalar(360.0) ; x+= btScalar(45.0))
     
    314314{
    315315        btVector3 n=TriNormal(vertices[t[0]],vertices[t[1]],vertices[t[2]]);
    316         return (dot(n,p-vertices[t[0]]) > epsilon); // EPSILON???
     316        return (btDot(n,p-vertices[t[0]]) > epsilon); // EPSILON???
    317317}
    318318int hasedge(const int3 &t, int a,int b);
     
    496496        if(p0==p1 || basis[0]==btVector3(0,0,0))
    497497                return int4(-1,-1,-1,-1);
    498         basis[1] = cross(btVector3(     btScalar(1),btScalar(0.02), btScalar(0)),basis[0]);
    499         basis[2] = cross(btVector3(btScalar(-0.02),     btScalar(1), btScalar(0)),basis[0]);
     498        basis[1] = btCross(btVector3(     btScalar(1),btScalar(0.02), btScalar(0)),basis[0]);
     499        basis[2] = btCross(btVector3(btScalar(-0.02),     btScalar(1), btScalar(0)),basis[0]);
    500500        if (basis[1].length() > basis[2].length())
    501501        {
     
    513513                return int4(-1,-1,-1,-1);
    514514        basis[1] = verts[p2] - verts[p0];
    515         basis[2] = cross(basis[1],basis[0]).normalized();
     515        basis[2] = btCross(basis[1],basis[0]).normalized();
    516516        int p3 = maxdirsterid(verts,verts_count,basis[2],allow);
    517517        if(p3==p0||p3==p1||p3==p2) p3 = maxdirsterid(verts,verts_count,-basis[2],allow);
     
    519519                return int4(-1,-1,-1,-1);
    520520        btAssert(!(p0==p1||p0==p2||p0==p3||p1==p2||p1==p3||p2==p3));
    521         if(dot(verts[p3]-verts[p0],cross(verts[p1]-verts[p0],verts[p2]-verts[p0])) <0) {Swap(p2,p3);}
     521        if(btDot(verts[p3]-verts[p0],btCross(verts[p1]-verts[p0],verts[p2]-verts[p0])) <0) {Swap(p2,p3);}
    522522        return int4(p0,p1,p2,p3);
    523523}
     
    565565                btVector3 n=TriNormal(verts[(*t)[0]],verts[(*t)[1]],verts[(*t)[2]]);
    566566                t->vmax = maxdirsterid(verts,verts_count,n,allow);
    567                 t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
     567                t->rise = btDot(n,verts[t->vmax]-verts[(*t)[0]]);
    568568        }
    569569        btHullTriangle *te;
     
    593593                        if(!hasvert(*m_tris[j],v)) break;
    594594                        int3 nt=*m_tris[j];
    595                         if(above(verts,nt,center,btScalar(0.01)*epsilon)  || cross(verts[nt[1]]-verts[nt[0]],verts[nt[2]]-verts[nt[1]]).length()< epsilon*epsilon*btScalar(0.1) )
     595                        if(above(verts,nt,center,btScalar(0.01)*epsilon)  || btCross(verts[nt[1]]-verts[nt[0]],verts[nt[2]]-verts[nt[1]]).length()< epsilon*epsilon*btScalar(0.1) )
    596596                        {
    597597                                btHullTriangle *nb = m_tris[m_tris[j]->n[0]];
     
    615615                        else
    616616                        {
    617                                 t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
     617                                t->rise = btDot(n,verts[t->vmax]-verts[(*t)[0]]);
    618618                        }
    619619                }
     
    877877        vcount = 0;
    878878
    879         btScalar recip[3];
     879        btScalar recip[3]={0.f,0.f,0.f};
    880880
    881881        if ( scale )
     
    10121012                                btScalar z = v[2];
    10131013
    1014                                 btScalar dx = fabsf(x - px );
    1015                                 btScalar dy = fabsf(y - py );
    1016                                 btScalar dz = fabsf(z - pz );
     1014                                btScalar dx = btFabs(x - px );
     1015                                btScalar dy = btFabs(y - py );
     1016                                btScalar dz = btFabs(z - pz );
    10171017
    10181018                                if ( dx < normalepsilon && dy < normalepsilon && dz < normalepsilon )
     
    11361136        ocount = 0;
    11371137
    1138         for (i=0; i<indexcount; i++)
     1138        for (i=0; i<int (indexcount); i++)
    11391139        {
    11401140                unsigned int v = indices[i]; // original array index
     
    11571157                        for (int k=0;k<m_vertexIndexMapping.size();k++)
    11581158                        {
    1159                                 if (tmpIndices[k]==v)
     1159                                if (tmpIndices[k]==int(v))
    11601160                                        m_vertexIndexMapping[k]=ocount;
    11611161                        }
Note: See TracChangeset for help on using the changeset viewer.