← Back to branch summary

~ubuntu-branches/ubuntu/maverick/blender/maverick

« back to all changes in this revision

Viewing changes to extern/bullet2/src/BulletCollision/Gimpact/btTriangleShapeEx.h

  • Committer: Bazaar Package Importer
  • Author(s): Khashayar Naderehvandi, Khashayar Naderehvandi, Alessio Treglia
  • Date: 2009-01-22 16:53:59 UTC
  • mfrom: (14.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20090122165359-v0996tn7fbit64ni
Tags: 2.48a+dfsg-1ubuntu1
https://launchpad.net/bugs/320045
[ Khashayar Naderehvandi ]
* Merge from debian experimental (LP: #320045), Ubuntu remaining changes:
  - Add patch correcting header file locations.
  - Add libvorbis-dev and libgsm1-dev to Build-Depends.
  - Use avcodec_decode_audio2() in source/blender/src/hddaudio.c

[ Alessio Treglia ]
* Add missing previous changelog entries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/bullet2/src/BulletCollision/Gimpact/btTriangleShapeEx.h
 
1
/*! \file btGImpactShape.h
 
2
\author Francisco Len N�jera
 
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
 
 
25
#ifndef TRIANGLE_SHAPE_EX_H
 
26
#define TRIANGLE_SHAPE_EX_H
 
27
 
 
28
#include "BulletCollision/CollisionShapes/btCollisionShape.h"
 
29
#include "BulletCollision/CollisionShapes/btTriangleShape.h"
 
30
#include "btBoxCollision.h"
 
31
#include "btClipPolygon.h"
 
32
#include "btGeometryOperations.h"
 
33
 
 
34
 
 
35
#define MAX_TRI_CLIPPING 16
 
36
 
 
37
//! Structure for collision
 
38
struct BT_TRIANGLE_CONTACT
 
39
{
 
40
    btScalar m_penetration_depth;
 
41
    int m_point_count;
 
42
    btVector4 m_separating_normal;
 
43
    btVector3 m_points[MAX_TRI_CLIPPING];
 
44
 
 
45
        SIMD_FORCE_INLINE void copy_from(const BT_TRIANGLE_CONTACT& other)
 
46
        {
 
47
                m_penetration_depth = other.m_penetration_depth;
 
48
                m_separating_normal = other.m_separating_normal;
 
49
                m_point_count = other.m_point_count;
 
50
                int i = m_point_count;
 
51
                while(i--)
 
52
                {
 
53
                        m_points[i] = other.m_points[i];
 
54
                }
 
55
        }
 
56
 
 
57
        BT_TRIANGLE_CONTACT()
 
58
        {
 
59
        }
 
60
 
 
61
        BT_TRIANGLE_CONTACT(const BT_TRIANGLE_CONTACT& other)
 
62
        {
 
63
                copy_from(other);
 
64
        }
 
65
 
 
66
    //! classify points that are closer
 
67
    void merge_points(const btVector4 & plane,
 
68
                                btScalar margin, const btVector3 * points, int point_count);
 
69
 
 
70
};
 
71
 
 
72
 
 
73
 
 
74
class btPrimitiveTriangle
 
75
{
 
76
public:
 
77
        btVector3 m_vertices[3];
 
78
        btVector4 m_plane;
 
79
        btScalar m_margin;
 
80
        btScalar m_dummy;
 
81
        btPrimitiveTriangle():m_margin(0.01f)
 
82
        {
 
83
 
 
84
        }
 
85
 
 
86
 
 
87
        SIMD_FORCE_INLINE void buildTriPlane()
 
88
        {
 
89
                btVector3 normal = (m_vertices[1]-m_vertices[0]).cross(m_vertices[2]-m_vertices[0]);
 
90
                normal.normalize();
 
91
                m_plane.setValue(normal[0],normal[1],normal[2],m_vertices[0].dot(normal));
 
92
        }
 
93
 
 
94
        //! Test if triangles could collide
 
95
        bool overlap_test_conservative(const btPrimitiveTriangle& other);
 
96
 
 
97
        //! Calcs the plane which is paralele to the edge and perpendicular to the triangle plane
 
98
        /*!
 
99
        \pre this triangle must have its plane calculated.
 
100
        */
 
101
        SIMD_FORCE_INLINE void get_edge_plane(int edge_index, btVector4 &plane)  const
 
102
    {
 
103
                const btVector3 & e0 = m_vertices[edge_index];
 
104
                const btVector3 & e1 = m_vertices[(edge_index+1)%3];
 
105
                bt_edge_plane(e0,e1,m_plane,plane);
 
106
    }
 
107
 
 
108
    void applyTransform(const btTransform& t)
 
109
        {
 
110
                m_vertices[0] = t(m_vertices[0]);
 
111
                m_vertices[1] = t(m_vertices[1]);
 
112
                m_vertices[2] = t(m_vertices[2]);
 
113
        }
 
114
 
 
115
        //! Clips the triangle against this
 
116
        /*!
 
117
        \pre clipped_points must have MAX_TRI_CLIPPING size, and this triangle must have its plane calculated.
 
118
        \return the number of clipped points
 
119
        */
 
120
    int clip_triangle(btPrimitiveTriangle & other, btVector3 * clipped_points );
 
121
 
 
122
        //! Find collision using the clipping method
 
123
        /*!
 
124
        \pre this triangle and other must have their triangles calculated
 
125
        */
 
126
    bool find_triangle_collision_clip_method(btPrimitiveTriangle & other, BT_TRIANGLE_CONTACT & contacts);
 
127
};
 
128
 
 
129
 
 
130
 
 
131
//! Helper class for colliding Bullet Triangle Shapes
 
132
/*!
 
133
This class implements a better getAabb method than the previous btTriangleShape class
 
134
*/
 
135
class btTriangleShapeEx: public btTriangleShape
 
136
{
 
137
public:
 
138
 
 
139
        btTriangleShapeEx():btTriangleShape(btVector3(0,0,0),btVector3(0,0,0),btVector3(0,0,0))
 
140
        {
 
141
        }
 
142
 
 
143
        btTriangleShapeEx(const btVector3& p0,const btVector3& p1,const btVector3& p2): btTriangleShape(p0,p1,p2)
 
144
        {
 
145
        }
 
146
 
 
147
        btTriangleShapeEx(const btTriangleShapeEx & other):     btTriangleShape(other.m_vertices1[0],other.m_vertices1[1],other.m_vertices1[2])
 
148
        {
 
149
        }
 
150
 
 
151
        virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax)const
 
152
        {
 
153
                btVector3 tv0 = t(m_vertices1[0]);
 
154
                btVector3 tv1 = t(m_vertices1[1]);
 
155
                btVector3 tv2 = t(m_vertices1[2]);
 
156
 
 
157
                btAABB trianglebox(tv0,tv1,tv2,m_collisionMargin);
 
158
                aabbMin = trianglebox.m_min;
 
159
                aabbMax = trianglebox.m_max;
 
160
        }
 
161
 
 
162
        void applyTransform(const btTransform& t)
 
163
        {
 
164
                m_vertices1[0] = t(m_vertices1[0]);
 
165
                m_vertices1[1] = t(m_vertices1[1]);
 
166
                m_vertices1[2] = t(m_vertices1[2]);
 
167
        }
 
168
 
 
169
        SIMD_FORCE_INLINE void buildTriPlane(btVector4 & plane) const
 
170
        {
 
171
                btVector3 normal = (m_vertices1[1]-m_vertices1[0]).cross(m_vertices1[2]-m_vertices1[0]);
 
172
                normal.normalize();
 
173
                plane.setValue(normal[0],normal[1],normal[2],m_vertices1[0].dot(normal));
 
174
        }
 
175
 
 
176
        bool overlap_test_conservative(const btTriangleShapeEx& other);
 
177
};
 
178
 
 
179
 
 
180
#endif //TRIANGLE_MESH_SHAPE_H