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/BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp

    r5781 r7983  
    6969                btMatrix3x3                             m_toshape1;
    7070                btTransform                             m_toshape0;
     71#ifdef __SPU__
     72                bool                                    m_enableMargin;
     73#else
    7174                btVector3                               (btConvexShape::*Ls)(const btVector3&) const;
     75#endif//__SPU__
     76               
     77
     78                MinkowskiDiff()
     79                {
     80
     81                }
     82#ifdef __SPU__
     83                        void                                    EnableMargin(bool enable)
     84                {
     85                        m_enableMargin = enable;
     86                }       
     87                inline btVector3                Support0(const btVector3& d) const
     88                {
     89                        if (m_enableMargin)
     90                        {
     91                                return m_shapes[0]->localGetSupportVertexNonVirtual(d);
     92                        } else
     93                        {
     94                                return m_shapes[0]->localGetSupportVertexWithoutMarginNonVirtual(d);
     95                        }
     96                }
     97                inline btVector3                Support1(const btVector3& d) const
     98                {
     99                        if (m_enableMargin)
     100                        {
     101                                return m_toshape0*(m_shapes[1]->localGetSupportVertexNonVirtual(m_toshape1*d));
     102                        } else
     103                        {
     104                                return m_toshape0*(m_shapes[1]->localGetSupportVertexWithoutMarginNonVirtual(m_toshape1*d));
     105                        }
     106                }
     107#else
    72108                void                                    EnableMargin(bool enable)
    73109                {
     
    85121                        return(m_toshape0*((m_shapes[1])->*(Ls))(m_toshape1*d));
    86122                }
     123#endif //__SPU__
     124
    87125                inline btVector3                Support(const btVector3& d) const
    88126                {
     
    203241                                        }
    204242                                        /* Check for termination                                */
    205                                         const btScalar  omega=dot(m_ray,w)/rl;
     243                                        const btScalar  omega=btDot(m_ray,w)/rl;
    206244                                        alpha=btMax(omega,alpha);
    207245                                        if(((rl-alpha)-(GJK_ACCURARY*rl))<=0)
     
    260298                                case    eStatus::Valid:         m_distance=m_ray.length();break;
    261299                                case    eStatus::Inside:        m_distance=0;break;
     300                                default:
     301                                        {
     302                                        }
    262303                                }       
    263304                                return(m_status);
     
    289330                                                        btVector3               axis=btVector3(0,0,0);
    290331                                                        axis[i]=1;
    291                                                         const btVector3 p=cross(d,axis);
     332                                                        const btVector3 p=btCross(d,axis);
    292333                                                        if(p.length2()>0)
    293334                                                        {
     
    304345                                case    3:
    305346                                        {
    306                                                 const btVector3 n=cross(m_simplex->c[1]->w-m_simplex->c[0]->w,
     347                                                const btVector3 n=btCross(m_simplex->c[1]->w-m_simplex->c[0]->w,
    307348                                                        m_simplex->c[2]->w-m_simplex->c[0]->w);
    308349                                                if(n.length2()>0)
     
    358399                                if(l>GJK_SIMPLEX2_EPS)
    359400                                {
    360                                         const btScalar  t(l>0?-dot(a,d)/l:0);
     401                                        const btScalar  t(l>0?-btDot(a,d)/l:0);
    361402                                        if(t>=1)                { w[0]=0;w[1]=1;m=2;return(b.length2()); }
    362403                                        else if(t<=0)   { w[0]=1;w[1]=0;m=1;return(a.length2()); }
     
    373414                                const btVector3*        vt[]={&a,&b,&c};
    374415                                const btVector3         dl[]={a-b,b-c,c-a};
    375                                 const btVector3         n=cross(dl[0],dl[1]);
     416                                const btVector3         n=btCross(dl[0],dl[1]);
    376417                                const btScalar          l=n.length2();
    377418                                if(l>GJK_SIMPLEX3_EPS)
    378419                                {
    379420                                        btScalar        mindist=-1;
    380                                         btScalar        subw[2];
    381                                         U                       subm;
     421                                        btScalar        subw[2]={0.f,0.f};
     422                                        U                       subm(0);
    382423                                        for(U i=0;i<3;++i)
    383424                                        {
    384                                                 if(dot(*vt[i],cross(dl[i],n))>0)
     425                                                if(btDot(*vt[i],btCross(dl[i],n))>0)
    385426                                                {
    386427                                                        const U                 j=imd3[i];
     
    398439                                        if(mindist<0)
    399440                                        {
    400                                                 const btScalar  d=dot(a,n);     
     441                                                const btScalar  d=btDot(a,n);   
    401442                                                const btScalar  s=btSqrt(l);
    402443                                                const btVector3 p=n*(d/l);
    403444                                                mindist =       p.length2();
    404445                                                m               =       7;
    405                                                 w[0]    =       (cross(dl[1],b-p)).length()/s;
    406                                                 w[1]    =       (cross(dl[2],c-p)).length()/s;
     446                                                w[0]    =       (btCross(dl[1],b-p)).length()/s;
     447                                                w[1]    =       (btCross(dl[2],c-p)).length()/s;
    407448                                                w[2]    =       1-(w[0]+w[1]);
    408449                                        }
     
    421462                                const btVector3         dl[]={a-d,b-d,c-d};
    422463                                const btScalar          vl=det(dl[0],dl[1],dl[2]);
    423                                 const bool                      ng=(vl*dot(a,cross(b-c,a-b)))<=0;
     464                                const bool                      ng=(vl*btDot(a,btCross(b-c,a-b)))<=0;
    424465                                if(ng&&(btFabs(vl)>GJK_SIMPLEX4_EPS))
    425466                                {
    426467                                        btScalar        mindist=-1;
    427                                         btScalar        subw[3];
    428                                         U                       subm;
     468                                        btScalar        subw[3]={0.f,0.f,0.f};
     469                                        U                       subm(0);
    429470                                        for(U i=0;i<3;++i)
    430471                                        {
    431472                                                const U                 j=imd3[i];
    432                                                 const btScalar  s=vl*dot(d,cross(dl[i],dl[j]));
     473                                                const btScalar  s=vl*btDot(d,btCross(dl[i],dl[j]));
    433474                                                if(s>0)
    434475                                                {
     
    602643                                                                best->pass      =       (U1)(++pass);
    603644                                                                gjk.getsupport(best->n,*w);
    604                                                                 const btScalar  wdist=dot(best->n,w->w)-best->d;
     645                                                                const btScalar  wdist=btDot(best->n,w->w)-best->d;
    605646                                                                if(wdist>EPA_ACCURACY)
    606647                                                                {
     
    629670                                                m_result.c[1]   =       outer.c[1];
    630671                                                m_result.c[2]   =       outer.c[2];
    631                                                 m_result.p[0]   =       cross(  outer.c[1]->w-projection,
     672                                                m_result.p[0]   =       btCross(        outer.c[1]->w-projection,
    632673                                                        outer.c[2]->w-projection).length();
    633                                                 m_result.p[1]   =       cross(  outer.c[2]->w-projection,
     674                                                m_result.p[1]   =       btCross(        outer.c[2]->w-projection,
    634675                                                        outer.c[0]->w-projection).length();
    635                                                 m_result.p[2]   =       cross(  outer.c[0]->w-projection,
     676                                                m_result.p[2]   =       btCross(        outer.c[0]->w-projection,
    636677                                                        outer.c[1]->w-projection).length();
    637678                                                const btScalar  sum=m_result.p[0]+m_result.p[1]+m_result.p[2];
     
    667708                                        face->c[1]      =       b;
    668709                                        face->c[2]      =       c;
    669                                         face->n         =       cross(b->w-a->w,c->w-a->w);
     710                                        face->n         =       btCross(b->w-a->w,c->w-a->w);
    670711                                        const btScalar  l=face->n.length();
    671712                                        const bool              v=l>EPA_ACCURACY;
    672713                                        face->p         =       btMin(btMin(
    673                                                 dot(a->w,cross(face->n,a->w-b->w)),
    674                                                 dot(b->w,cross(face->n,b->w-c->w))),
    675                                                 dot(c->w,cross(face->n,c->w-a->w)))     /
     714                                                btDot(a->w,btCross(face->n,a->w-b->w)),
     715                                                btDot(b->w,btCross(face->n,b->w-c->w))),
     716                                                btDot(c->w,btCross(face->n,c->w-a->w))) /
    676717                                                (v?l:1);
    677718                                        face->p         =       face->p>=-EPA_INSIDE_EPS?0:face->p;
    678719                                        if(v)
    679720                                        {
    680                                                 face->d         =       dot(a->w,face->n)/l;
     721                                                face->d         =       btDot(a->w,face->n)/l;
    681722                                                face->n         /=      l;
    682723                                                if(forced||(face->d>=-EPA_PLANE_EPS))
     
    716757                                {
    717758                                        const U e1=i1m3[e];
    718                                         if((dot(f->n,w->w)-f->d)<-EPA_PLANE_EPS)
     759                                        if((btDot(f->n,w->w)-f->d)<-EPA_PLANE_EPS)
    719760                                        {
    720761                                                sFace*  nf=newface(f->c[e1],f->c[e],w,false);
     
    855896                results.status=sResults::GJK_Failed;
    856897                break;
     898                default:
     899                                        {
     900                                        }
    857901        }
    858902        return(false);
    859903}
    860904
     905#ifndef __SPU__
    861906//
    862907btScalar        btGjkEpaSolver2::SignedDistance(const btVector3& position,
     
    924969                return(true);
    925970}
     971#endif //__SPU__
    926972
    927973/* Symbols cleanup              */
Note: See TracChangeset for help on using the changeset viewer.