Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/external/bullet/BulletCollision/Gimpact/btBoxCollision.h @ 6458

Last change on this file since 6458 was 5781, checked in by rgrieder, 15 years ago

Reverted trunk again. We might want to find a way to delete these revisions again (x3n's changes are still available as diff in the commit mails).
  • Property svn:eol-style set to native
File size: 17.5 KB
Line 
1#ifndef BT_BOX_COLLISION_H_INCLUDED
2#define BT_BOX_COLLISION_H_INCLUDED
3
4/*! \file gim_box_collision.h
5\author Francisco Len Nßjera
6*/
7/*
8This source file is part of GIMPACT Library.
9
10For the latest info, see http://gimpact.sourceforge.net/
11
12Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
13email: projectileman@yahoo.com
14
15
16This software is provided 'as-is', without any express or implied warranty.
17In no event will the authors be held liable for any damages arising from the use of this software.
18Permission is granted to anyone to use this software for any purpose,
19including commercial applications, and to alter it and redistribute it freely,
20subject to the following restrictions:
21
221. 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.
232. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
243. This notice may not be removed or altered from any source distribution.
25*/
26
27#include "LinearMath/btTransform.h"
28
29
30///Swap numbers
31#define BT_SWAP_NUMBERS(a,b){ \
32    a = a+b; \
33    b = a-b; \
34    a = a-b; \
35}\
36
37
38#define BT_MAX(a,b) (a<b?b:a)
39#define BT_MIN(a,b) (a>b?b:a)
40
41#define BT_GREATER(x, y)        btFabs(x) > (y)
42
43#define BT_MAX3(a,b,c) BT_MAX(a,BT_MAX(b,c))
44#define BT_MIN3(a,b,c) BT_MIN(a,BT_MIN(b,c))
45
46
47
48
49
50
51enum eBT_PLANE_INTERSECTION_TYPE
52{
53        BT_CONST_BACK_PLANE = 0,
54        BT_CONST_COLLIDE_PLANE,
55        BT_CONST_FRONT_PLANE
56};
57
58//SIMD_FORCE_INLINE bool test_cross_edge_box(
59//      const btVector3 & edge,
60//      const btVector3 & absolute_edge,
61//      const btVector3 & pointa,
62//      const btVector3 & pointb, const btVector3 & extend,
63//      int dir_index0,
64//      int dir_index1
65//      int component_index0,
66//      int component_index1)
67//{
68//      // dir coords are -z and y
69//
70//      const btScalar dir0 = -edge[dir_index0];
71//      const btScalar dir1 = edge[dir_index1];
72//      btScalar pmin = pointa[component_index0]*dir0 + pointa[component_index1]*dir1;
73//      btScalar pmax = pointb[component_index0]*dir0 + pointb[component_index1]*dir1;
74//      //find minmax
75//      if(pmin>pmax)
76//      {
77//              BT_SWAP_NUMBERS(pmin,pmax);
78//      }
79//      //find extends
80//      const btScalar rad = extend[component_index0] * absolute_edge[dir_index0] +
81//                                      extend[component_index1] * absolute_edge[dir_index1];
82//
83//      if(pmin>rad || -rad>pmax) return false;
84//      return true;
85//}
86//
87//SIMD_FORCE_INLINE bool test_cross_edge_box_X_axis(
88//      const btVector3 & edge,
89//      const btVector3 & absolute_edge,
90//      const btVector3 & pointa,
91//      const btVector3 & pointb, btVector3 & extend)
92//{
93//
94//      return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,2,1,1,2);
95//}
96//
97//
98//SIMD_FORCE_INLINE bool test_cross_edge_box_Y_axis(
99//      const btVector3 & edge,
100//      const btVector3 & absolute_edge,
101//      const btVector3 & pointa,
102//      const btVector3 & pointb, btVector3 & extend)
103//{
104//
105//      return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,0,2,2,0);
106//}
107//
108//SIMD_FORCE_INLINE bool test_cross_edge_box_Z_axis(
109//      const btVector3 & edge,
110//      const btVector3 & absolute_edge,
111//      const btVector3 & pointa,
112//      const btVector3 & pointb, btVector3 & extend)
113//{
114//
115//      return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,1,0,0,1);
116//}
117
118
119#define TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,i_dir_0,i_dir_1,i_comp_0,i_comp_1)\
120{\
121        const btScalar dir0 = -edge[i_dir_0];\
122        const btScalar dir1 = edge[i_dir_1];\
123        btScalar pmin = pointa[i_comp_0]*dir0 + pointa[i_comp_1]*dir1;\
124        btScalar pmax = pointb[i_comp_0]*dir0 + pointb[i_comp_1]*dir1;\
125        if(pmin>pmax)\
126        {\
127                BT_SWAP_NUMBERS(pmin,pmax); \
128        }\
129        const btScalar abs_dir0 = absolute_edge[i_dir_0];\
130        const btScalar abs_dir1 = absolute_edge[i_dir_1];\
131        const btScalar rad = _extend[i_comp_0] * abs_dir0 + _extend[i_comp_1] * abs_dir1;\
132        if(pmin>rad || -rad>pmax) return false;\
133}\
134
135
136#define TEST_CROSS_EDGE_BOX_X_AXIS_MCR(edge,absolute_edge,pointa,pointb,_extend)\
137{\
138        TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,2,1,1,2);\
139}\
140
141#define TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(edge,absolute_edge,pointa,pointb,_extend)\
142{\
143        TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,0,2,2,0);\
144}\
145
146#define TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(edge,absolute_edge,pointa,pointb,_extend)\
147{\
148        TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,1,0,0,1);\
149}\
150
151
152//! Returns the dot product between a vec3f and the col of a matrix
153SIMD_FORCE_INLINE btScalar bt_mat3_dot_col(
154const btMatrix3x3 & mat, const btVector3 & vec3, int colindex)
155{
156        return vec3[0]*mat[0][colindex] + vec3[1]*mat[1][colindex] + vec3[2]*mat[2][colindex];
157}
158
159
160//!  Class for transforming a model1 to the space of model0
161ATTRIBUTE_ALIGNED16     (class) BT_BOX_BOX_TRANSFORM_CACHE
162{
163public:
164    btVector3  m_T1to0;//!< Transforms translation of model1 to model 0
165        btMatrix3x3 m_R1to0;//!< Transforms Rotation of model1 to model 0, equal  to R0' * R1
166        btMatrix3x3 m_AR;//!< Absolute value of m_R1to0
167
168        SIMD_FORCE_INLINE void calc_absolute_matrix()
169        {
170//              static const btVector3 vepsi(1e-6f,1e-6f,1e-6f);
171//              m_AR[0] = vepsi + m_R1to0[0].absolute();
172//              m_AR[1] = vepsi + m_R1to0[1].absolute();
173//              m_AR[2] = vepsi + m_R1to0[2].absolute();
174
175                int i,j;
176
177        for(i=0;i<3;i++)
178        {
179            for(j=0;j<3;j++ )
180            {
181                m_AR[i][j] = 1e-6f + btFabs(m_R1to0[i][j]);
182            }
183        }
184
185        }
186
187        BT_BOX_BOX_TRANSFORM_CACHE()
188        {
189        }
190
191
192
193        //! Calc the transformation relative  1 to 0. Inverts matrics by transposing
194        SIMD_FORCE_INLINE void calc_from_homogenic(const btTransform & trans0,const btTransform & trans1)
195        {
196
197                btTransform temp_trans = trans0.inverse();
198                temp_trans = temp_trans * trans1;
199
200                m_T1to0 = temp_trans.getOrigin();
201                m_R1to0 = temp_trans.getBasis();
202
203
204                calc_absolute_matrix();
205        }
206
207        //! Calcs the full invertion of the matrices. Useful for scaling matrices
208        SIMD_FORCE_INLINE void calc_from_full_invert(const btTransform & trans0,const btTransform & trans1)
209        {
210                m_R1to0 = trans0.getBasis().inverse();
211                m_T1to0 = m_R1to0 * (-trans0.getOrigin());
212
213                m_T1to0 += m_R1to0*trans1.getOrigin();
214                m_R1to0 *= trans1.getBasis();
215
216                calc_absolute_matrix();
217        }
218
219        SIMD_FORCE_INLINE btVector3 transform(const btVector3 & point) const
220        {
221                return btVector3(m_R1to0[0].dot(point) + m_T1to0.x(),
222                        m_R1to0[1].dot(point) + m_T1to0.y(),
223                        m_R1to0[2].dot(point) + m_T1to0.z());
224        }
225};
226
227
228#define BOX_PLANE_EPSILON 0.000001f
229
230//! Axis aligned box
231ATTRIBUTE_ALIGNED16     (class) btAABB
232{
233public:
234        btVector3 m_min;
235        btVector3 m_max;
236
237        btAABB()
238        {}
239
240
241        btAABB(const btVector3 & V1,
242                         const btVector3 & V2,
243                         const btVector3 & V3)
244        {
245                m_min[0] = BT_MIN3(V1[0],V2[0],V3[0]);
246                m_min[1] = BT_MIN3(V1[1],V2[1],V3[1]);
247                m_min[2] = BT_MIN3(V1[2],V2[2],V3[2]);
248
249                m_max[0] = BT_MAX3(V1[0],V2[0],V3[0]);
250                m_max[1] = BT_MAX3(V1[1],V2[1],V3[1]);
251                m_max[2] = BT_MAX3(V1[2],V2[2],V3[2]);
252        }
253
254        btAABB(const btVector3 & V1,
255                         const btVector3 & V2,
256                         const btVector3 & V3,
257                         btScalar margin)
258        {
259                m_min[0] = BT_MIN3(V1[0],V2[0],V3[0]);
260                m_min[1] = BT_MIN3(V1[1],V2[1],V3[1]);
261                m_min[2] = BT_MIN3(V1[2],V2[2],V3[2]);
262
263                m_max[0] = BT_MAX3(V1[0],V2[0],V3[0]);
264                m_max[1] = BT_MAX3(V1[1],V2[1],V3[1]);
265                m_max[2] = BT_MAX3(V1[2],V2[2],V3[2]);
266
267                m_min[0] -= margin;
268                m_min[1] -= margin;
269                m_min[2] -= margin;
270                m_max[0] += margin;
271                m_max[1] += margin;
272                m_max[2] += margin;
273        }
274
275        btAABB(const btAABB &other):
276                m_min(other.m_min),m_max(other.m_max)
277        {
278        }
279
280        btAABB(const btAABB &other,btScalar margin ):
281                m_min(other.m_min),m_max(other.m_max)
282        {
283                m_min[0] -= margin;
284                m_min[1] -= margin;
285                m_min[2] -= margin;
286                m_max[0] += margin;
287                m_max[1] += margin;
288                m_max[2] += margin;
289        }
290
291        SIMD_FORCE_INLINE void invalidate()
292        {
293                m_min[0] = SIMD_INFINITY;
294                m_min[1] = SIMD_INFINITY;
295                m_min[2] = SIMD_INFINITY;
296                m_max[0] = -SIMD_INFINITY;
297                m_max[1] = -SIMD_INFINITY;
298                m_max[2] = -SIMD_INFINITY;
299        }
300
301        SIMD_FORCE_INLINE void increment_margin(btScalar margin)
302        {
303                m_min[0] -= margin;
304                m_min[1] -= margin;
305                m_min[2] -= margin;
306                m_max[0] += margin;
307                m_max[1] += margin;
308                m_max[2] += margin;
309        }
310
311        SIMD_FORCE_INLINE void copy_with_margin(const btAABB &other, btScalar margin)
312        {
313                m_min[0] = other.m_min[0] - margin;
314                m_min[1] = other.m_min[1] - margin;
315                m_min[2] = other.m_min[2] - margin;
316
317                m_max[0] = other.m_max[0] + margin;
318                m_max[1] = other.m_max[1] + margin;
319                m_max[2] = other.m_max[2] + margin;
320        }
321
322        template<typename CLASS_POINT>
323        SIMD_FORCE_INLINE void calc_from_triangle(
324                                                        const CLASS_POINT & V1,
325                                                        const CLASS_POINT & V2,
326                                                        const CLASS_POINT & V3)
327        {
328                m_min[0] = BT_MIN3(V1[0],V2[0],V3[0]);
329                m_min[1] = BT_MIN3(V1[1],V2[1],V3[1]);
330                m_min[2] = BT_MIN3(V1[2],V2[2],V3[2]);
331
332                m_max[0] = BT_MAX3(V1[0],V2[0],V3[0]);
333                m_max[1] = BT_MAX3(V1[1],V2[1],V3[1]);
334                m_max[2] = BT_MAX3(V1[2],V2[2],V3[2]);
335        }
336
337        template<typename CLASS_POINT>
338        SIMD_FORCE_INLINE void calc_from_triangle_margin(
339                                                        const CLASS_POINT & V1,
340                                                        const CLASS_POINT & V2,
341                                                        const CLASS_POINT & V3, btScalar margin)
342        {
343                m_min[0] = BT_MIN3(V1[0],V2[0],V3[0]);
344                m_min[1] = BT_MIN3(V1[1],V2[1],V3[1]);
345                m_min[2] = BT_MIN3(V1[2],V2[2],V3[2]);
346
347                m_max[0] = BT_MAX3(V1[0],V2[0],V3[0]);
348                m_max[1] = BT_MAX3(V1[1],V2[1],V3[1]);
349                m_max[2] = BT_MAX3(V1[2],V2[2],V3[2]);
350
351                m_min[0] -= margin;
352                m_min[1] -= margin;
353                m_min[2] -= margin;
354                m_max[0] += margin;
355                m_max[1] += margin;
356                m_max[2] += margin;
357        }
358
359        //! Apply a transform to an AABB
360        SIMD_FORCE_INLINE void appy_transform(const btTransform & trans)
361        {
362                btVector3 center = (m_max+m_min)*0.5f;
363                btVector3 extends = m_max - center;
364                // Compute new center
365                center = trans(center);
366
367                btVector3 textends(extends.dot(trans.getBasis().getRow(0).absolute()),
368                                 extends.dot(trans.getBasis().getRow(1).absolute()),
369                                 extends.dot(trans.getBasis().getRow(2).absolute()));
370
371                m_min = center - textends;
372                m_max = center + textends;
373        }
374
375
376        //! Apply a transform to an AABB
377        SIMD_FORCE_INLINE void appy_transform_trans_cache(const BT_BOX_BOX_TRANSFORM_CACHE & trans)
378        {
379                btVector3 center = (m_max+m_min)*0.5f;
380                btVector3 extends = m_max - center;
381                // Compute new center
382                center = trans.transform(center);
383
384                btVector3 textends(extends.dot(trans.m_R1to0.getRow(0).absolute()),
385                                 extends.dot(trans.m_R1to0.getRow(1).absolute()),
386                                 extends.dot(trans.m_R1to0.getRow(2).absolute()));
387
388                m_min = center - textends;
389                m_max = center + textends;
390        }
391
392        //! Merges a Box
393        SIMD_FORCE_INLINE void merge(const btAABB & box)
394        {
395                m_min[0] = BT_MIN(m_min[0],box.m_min[0]);
396                m_min[1] = BT_MIN(m_min[1],box.m_min[1]);
397                m_min[2] = BT_MIN(m_min[2],box.m_min[2]);
398
399                m_max[0] = BT_MAX(m_max[0],box.m_max[0]);
400                m_max[1] = BT_MAX(m_max[1],box.m_max[1]);
401                m_max[2] = BT_MAX(m_max[2],box.m_max[2]);
402        }
403
404        //! Merges a point
405        template<typename CLASS_POINT>
406        SIMD_FORCE_INLINE void merge_point(const CLASS_POINT & point)
407        {
408                m_min[0] = BT_MIN(m_min[0],point[0]);
409                m_min[1] = BT_MIN(m_min[1],point[1]);
410                m_min[2] = BT_MIN(m_min[2],point[2]);
411
412                m_max[0] = BT_MAX(m_max[0],point[0]);
413                m_max[1] = BT_MAX(m_max[1],point[1]);
414                m_max[2] = BT_MAX(m_max[2],point[2]);
415        }
416
417        //! Gets the extend and center
418        SIMD_FORCE_INLINE void get_center_extend(btVector3 & center,btVector3 & extend)  const
419        {
420                center = (m_max+m_min)*0.5f;
421                extend = m_max - center;
422        }
423
424        //! Finds the intersecting box between this box and the other.
425        SIMD_FORCE_INLINE void find_intersection(const btAABB & other, btAABB & intersection)  const
426        {
427                intersection.m_min[0] = BT_MAX(other.m_min[0],m_min[0]);
428                intersection.m_min[1] = BT_MAX(other.m_min[1],m_min[1]);
429                intersection.m_min[2] = BT_MAX(other.m_min[2],m_min[2]);
430
431                intersection.m_max[0] = BT_MIN(other.m_max[0],m_max[0]);
432                intersection.m_max[1] = BT_MIN(other.m_max[1],m_max[1]);
433                intersection.m_max[2] = BT_MIN(other.m_max[2],m_max[2]);
434        }
435
436
437        SIMD_FORCE_INLINE bool has_collision(const btAABB & other) const
438        {
439                if(m_min[0] > other.m_max[0] ||
440                   m_max[0] < other.m_min[0] ||
441                   m_min[1] > other.m_max[1] ||
442                   m_max[1] < other.m_min[1] ||
443                   m_min[2] > other.m_max[2] ||
444                   m_max[2] < other.m_min[2])
445                {
446                        return false;
447                }
448                return true;
449        }
450
451        /*! \brief Finds the Ray intersection parameter.
452        \param aabb Aligned box
453        \param vorigin A vec3f with the origin of the ray
454        \param vdir A vec3f with the direction of the ray
455        */
456        SIMD_FORCE_INLINE bool collide_ray(const btVector3 & vorigin,const btVector3 & vdir)  const
457        {
458                btVector3 extents,center;
459                this->get_center_extend(center,extents);;
460
461                btScalar Dx = vorigin[0] - center[0];
462                if(BT_GREATER(Dx, extents[0]) && Dx*vdir[0]>=0.0f)      return false;
463                btScalar Dy = vorigin[1] - center[1];
464                if(BT_GREATER(Dy, extents[1]) && Dy*vdir[1]>=0.0f)      return false;
465                btScalar Dz = vorigin[2] - center[2];
466                if(BT_GREATER(Dz, extents[2]) && Dz*vdir[2]>=0.0f)      return false;
467
468
469                btScalar f = vdir[1] * Dz - vdir[2] * Dy;
470                if(btFabs(f) > extents[1]*btFabs(vdir[2]) + extents[2]*btFabs(vdir[1])) return false;
471                f = vdir[2] * Dx - vdir[0] * Dz;
472                if(btFabs(f) > extents[0]*btFabs(vdir[2]) + extents[2]*btFabs(vdir[0]))return false;
473                f = vdir[0] * Dy - vdir[1] * Dx;
474                if(btFabs(f) > extents[0]*btFabs(vdir[1]) + extents[1]*btFabs(vdir[0]))return false;
475                return true;
476        }
477
478
479        SIMD_FORCE_INLINE void projection_interval(const btVector3 & direction, btScalar &vmin, btScalar &vmax) const
480        {
481                btVector3 center = (m_max+m_min)*0.5f;
482                btVector3 extend = m_max-center;
483
484                btScalar _fOrigin =  direction.dot(center);
485                btScalar _fMaximumExtent = extend.dot(direction.absolute());
486                vmin = _fOrigin - _fMaximumExtent;
487                vmax = _fOrigin + _fMaximumExtent;
488        }
489
490        SIMD_FORCE_INLINE eBT_PLANE_INTERSECTION_TYPE plane_classify(const btVector4 &plane) const
491        {
492                btScalar _fmin,_fmax;
493                this->projection_interval(plane,_fmin,_fmax);
494
495                if(plane[3] > _fmax + BOX_PLANE_EPSILON)
496                {
497                        return BT_CONST_BACK_PLANE; // 0
498                }
499
500                if(plane[3]+BOX_PLANE_EPSILON >=_fmin)
501                {
502                        return BT_CONST_COLLIDE_PLANE; //1
503                }
504                return BT_CONST_FRONT_PLANE;//2
505        }
506
507        SIMD_FORCE_INLINE bool overlapping_trans_conservative(const btAABB & box, btTransform & trans1_to_0) const
508        {
509                btAABB tbox = box;
510                tbox.appy_transform(trans1_to_0);
511                return has_collision(tbox);
512        }
513
514        SIMD_FORCE_INLINE bool overlapping_trans_conservative2(const btAABB & box,
515                const BT_BOX_BOX_TRANSFORM_CACHE & trans1_to_0) const
516        {
517                btAABB tbox = box;
518                tbox.appy_transform_trans_cache(trans1_to_0);
519                return has_collision(tbox);
520        }
521
522        //! transcache is the transformation cache from box to this AABB
523        SIMD_FORCE_INLINE bool overlapping_trans_cache(
524                const btAABB & box,const BT_BOX_BOX_TRANSFORM_CACHE & transcache, bool fulltest) const
525        {
526
527                //Taken from OPCODE
528                btVector3 ea,eb;//extends
529                btVector3 ca,cb;//extends
530                get_center_extend(ca,ea);
531                box.get_center_extend(cb,eb);
532
533
534                btVector3 T;
535                btScalar t,t2;
536                int i;
537
538                // Class I : A's basis vectors
539                for(i=0;i<3;i++)
540                {
541                        T[i] =  transcache.m_R1to0[i].dot(cb) + transcache.m_T1to0[i] - ca[i];
542                        t = transcache.m_AR[i].dot(eb) + ea[i];
543                        if(BT_GREATER(T[i], t)) return false;
544                }
545                // Class II : B's basis vectors
546                for(i=0;i<3;i++)
547                {
548                        t = bt_mat3_dot_col(transcache.m_R1to0,T,i);
549                        t2 = bt_mat3_dot_col(transcache.m_AR,ea,i) + eb[i];
550                        if(BT_GREATER(t,t2))    return false;
551                }
552                // Class III : 9 cross products
553                if(fulltest)
554                {
555                        int j,m,n,o,p,q,r;
556                        for(i=0;i<3;i++)
557                        {
558                                m = (i+1)%3;
559                                n = (i+2)%3;
560                                o = i==0?1:0;
561                                p = i==2?1:2;
562                                for(j=0;j<3;j++)
563                                {
564                                        q = j==2?1:2;
565                                        r = j==0?1:0;
566                                        t = T[n]*transcache.m_R1to0[m][j] - T[m]*transcache.m_R1to0[n][j];
567                                        t2 = ea[o]*transcache.m_AR[p][j] + ea[p]*transcache.m_AR[o][j] +
568                                                eb[r]*transcache.m_AR[i][q] + eb[q]*transcache.m_AR[i][r];
569                                        if(BT_GREATER(t,t2))    return false;
570                                }
571                        }
572                }
573                return true;
574        }
575
576        //! Simple test for planes.
577        SIMD_FORCE_INLINE bool collide_plane(
578                const btVector4 & plane) const
579        {
580                eBT_PLANE_INTERSECTION_TYPE classify = plane_classify(plane);
581                return (classify == BT_CONST_COLLIDE_PLANE);
582        }
583
584        //! test for a triangle, with edges
585        SIMD_FORCE_INLINE bool collide_triangle_exact(
586                const btVector3 & p1,
587                const btVector3 & p2,
588                const btVector3 & p3,
589                const btVector4 & triangle_plane) const
590        {
591                if(!collide_plane(triangle_plane)) return false;
592
593                btVector3 center,extends;
594                this->get_center_extend(center,extends);
595
596                const btVector3 v1(p1 - center);
597                const btVector3 v2(p2 - center);
598                const btVector3 v3(p3 - center);
599
600                //First axis
601                btVector3 diff(v2 - v1);
602                btVector3 abs_diff = diff.absolute();
603                //Test With X axis
604                TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff,abs_diff,v1,v3,extends);
605                //Test With Y axis
606                TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff,abs_diff,v1,v3,extends);
607                //Test With Z axis
608                TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff,abs_diff,v1,v3,extends);
609
610
611                diff = v3 - v2;
612                abs_diff = diff.absolute();
613                //Test With X axis
614                TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff,abs_diff,v2,v1,extends);
615                //Test With Y axis
616                TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff,abs_diff,v2,v1,extends);
617                //Test With Z axis
618                TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff,abs_diff,v2,v1,extends);
619
620                diff = v1 - v3;
621                abs_diff = diff.absolute();
622                //Test With X axis
623                TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff,abs_diff,v3,v2,extends);
624                //Test With Y axis
625                TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff,abs_diff,v3,v2,extends);
626                //Test With Z axis
627                TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff,abs_diff,v3,v2,extends);
628
629                return true;
630        }
631};
632
633
634//! Compairison of transformation objects
635SIMD_FORCE_INLINE bool btCompareTransformsEqual(const btTransform & t1,const btTransform & t2)
636{
637        if(!(t1.getOrigin() == t2.getOrigin()) ) return false;
638
639        if(!(t1.getBasis().getRow(0) == t2.getBasis().getRow(0)) ) return false;
640        if(!(t1.getBasis().getRow(1) == t2.getBasis().getRow(1)) ) return false;
641        if(!(t1.getBasis().getRow(2) == t2.getBasis().getRow(2)) ) return false;
642        return true;
643}
644
645
646
647#endif // GIM_BOX_COLLISION_H_INCLUDED
Note: See TracBrowser for help on using the repository browser.