dali-physics/third-party/bullet3/src/BulletCollision/Gimpact/btTriangleShapeEx.h

   1 /*! \file btGImpactShape.h
   2 \author Francisco Leon Najera
   3 */
   4 /*
   5 This source file is part of GIMPACT Library.
   6
   7 For the latest info, see http://gimpact.sourceforge.net/
   8
   9 Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
  10 email: projectileman@yahoo.com
  11
  12
  13 This software is provided 'as-is', without any express or implied warranty.
  14 In no event will the authors be held liable for any damages arising from the use of this software.
  15 Permission is granted to anyone to use this software for any purpose,
  16 including commercial applications, and to alter it and redistribute it freely,
  17 subject to the following restrictions:
  18
  19 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  20 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  21 3. This notice may not be removed or altered from any source distribution.
  22 */
  23
  24 #ifndef GIMPACT_TRIANGLE_SHAPE_EX_H
  25 #define GIMPACT_TRIANGLE_SHAPE_EX_H
  26
  27 #include "BulletCollision/CollisionShapes/btCollisionShape.h"
  28 #include "BulletCollision/CollisionShapes/btTriangleShape.h"
  29 #include "btBoxCollision.h"
  30 #include "btClipPolygon.h"
  31 #include "btGeometryOperations.h"
  32
  33 #define MAX_TRI_CLIPPING 16
  34
  35 //! Structure for collision
  36 struct GIM_TRIANGLE_CONTACT
  37 {
  38         btScalar m_penetration_depth;
  39         int m_point_count;
  40         btVector4 m_separating_normal;
  41         btVector3 m_points[MAX_TRI_CLIPPING];
  42
  43         SIMD_FORCE_INLINE void copy_from(const GIM_TRIANGLE_CONTACT& other)
  44         {
  45                 m_penetration_depth = other.m_penetration_depth;
  46                 m_separating_normal = other.m_separating_normal;
  47                 m_point_count = other.m_point_count;
  48                 int i = m_point_count;
  49                 while (i--)
  50                 {
  51                         m_points[i] = other.m_points[i];
  52                 }
  53         }
  54
  55         GIM_TRIANGLE_CONTACT()
  56         {
  57         }
  58
  59         GIM_TRIANGLE_CONTACT(const GIM_TRIANGLE_CONTACT& other)
  60         {
  61                 copy_from(other);
  62         }
  63
  64         //! classify points that are closer
  65         void merge_points(const btVector4& plane,
  66                                           btScalar margin, const btVector3* points, int point_count);
  67 };
  68
  69 class btPrimitiveTriangle
  70 {
  71 public:
  72         btVector3 m_vertices[3];
  73         btVector4 m_plane;
  74         btScalar m_margin;
  75         btScalar m_dummy;
  76         btPrimitiveTriangle() : m_margin(0.01f)
  77         {
  78         }
  79
  80         SIMD_FORCE_INLINE void buildTriPlane()
  81         {
  82                 btVector3 normal = (m_vertices[1] - m_vertices[0]).cross(m_vertices[2] - m_vertices[0]);
  83                 normal.normalize();
  84                 m_plane.setValue(normal[0], normal[1], normal[2], m_vertices[0].dot(normal));
  85         }
  86
  87         //! Test if triangles could collide
  88         bool overlap_test_conservative(const btPrimitiveTriangle& other);
  89
  90         //! Calcs the plane which is paralele to the edge and perpendicular to the triangle plane
  91         /*!
  92         \pre this triangle must have its plane calculated.
  93         */
  94         SIMD_FORCE_INLINE void get_edge_plane(int edge_index, btVector4& plane) const
  95         {
  96                 const btVector3& e0 = m_vertices[edge_index];
  97                 const btVector3& e1 = m_vertices[(edge_index + 1) % 3];
  98                 bt_edge_plane(e0, e1, m_plane, plane);
  99         }
 100
 101         void applyTransform(const btTransform& t)
 102         {
 103                 m_vertices[0] = t(m_vertices[0]);
 104                 m_vertices[1] = t(m_vertices[1]);
 105                 m_vertices[2] = t(m_vertices[2]);
 106         }
 107
 108         //! Clips the triangle against this
 109         /*!
 110         \pre clipped_points must have MAX_TRI_CLIPPING size, and this triangle must have its plane calculated.
 111         \return the number of clipped points
 112         */
 113         int clip_triangle(btPrimitiveTriangle& other, btVector3* clipped_points);
 114
 115         //! Find collision using the clipping method
 116         /*!
 117         \pre this triangle and other must have their triangles calculated
 118         */
 119         bool find_triangle_collision_clip_method(btPrimitiveTriangle& other, GIM_TRIANGLE_CONTACT& contacts);
 120 };
 121
 122 //! Helper class for colliding Bullet Triangle Shapes
 123 /*!
 124 This class implements a better getAabb method than the previous btTriangleShape class
 125 */
 126 class btTriangleShapeEx : public btTriangleShape
 127 {
 128 public:
 129         btTriangleShapeEx() : btTriangleShape(btVector3(0, 0, 0), btVector3(0, 0, 0), btVector3(0, 0, 0))
 130         {
 131         }
 132
 133         btTriangleShapeEx(const btVector3& p0, const btVector3& p1, const btVector3& p2) : btTriangleShape(p0, p1, p2)
 134         {
 135         }
 136
 137         btTriangleShapeEx(const btTriangleShapeEx& other) : btTriangleShape(other.m_vertices1[0], other.m_vertices1[1], other.m_vertices1[2])
 138         {
 139         }
 140
 141         virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
 142         {
 143                 btVector3 tv0 = t(m_vertices1[0]);
 144                 btVector3 tv1 = t(m_vertices1[1]);
 145                 btVector3 tv2 = t(m_vertices1[2]);
 146
 147                 btAABB trianglebox(tv0, tv1, tv2, m_collisionMargin);
 148                 aabbMin = trianglebox.m_min;
 149                 aabbMax = trianglebox.m_max;
 150         }
 151
 152         void applyTransform(const btTransform& t)
 153         {
 154                 m_vertices1[0] = t(m_vertices1[0]);
 155                 m_vertices1[1] = t(m_vertices1[1]);
 156                 m_vertices1[2] = t(m_vertices1[2]);
 157         }
 158
 159         SIMD_FORCE_INLINE void buildTriPlane(btVector4& plane) const
 160         {
 161                 btVector3 normal = (m_vertices1[1] - m_vertices1[0]).cross(m_vertices1[2] - m_vertices1[0]);
 162                 normal.normalize();
 163                 plane.setValue(normal[0], normal[1], normal[2], m_vertices1[0].dot(normal));
 164         }
 165
 166         bool overlap_test_conservative(const btTriangleShapeEx& other);
 167 };
 168
 169 #endif  //GIMPACT_TRIANGLE_MESH_SHAPE_H