← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/bullet/src/BulletCollision/CollisionShapes/btCollisionShape.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/bullet/src/BulletCollision/CollisionShapes/btCollisionShape.h
 
1
/*
 
2
Bullet Continuous Collision Detection and Physics Library
 
3
Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
 
4
 
 
5
This software is provided 'as-is', without any express or implied warranty.
 
6
In no event will the authors be held liable for any damages arising from the use of this software.
 
7
Permission is granted to anyone to use this software for any purpose, 
 
8
including commercial applications, and to alter it and redistribute it freely, 
 
9
subject to the following restrictions:
 
10
 
 
11
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.
 
12
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
 
13
3. This notice may not be removed or altered from any source distribution.
 
14
*/
 
15
 
 
16
#ifndef BT_COLLISION_SHAPE_H
 
17
#define BT_COLLISION_SHAPE_H
 
18
 
 
19
#include "LinearMath/btTransform.h"
 
20
#include "LinearMath/btVector3.h"
 
21
#include "LinearMath/btMatrix3x3.h"
 
22
#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types
 
23
class btSerializer;
 
24
 
 
25
 
 
26
///The btCollisionShape class provides an interface for collision shapes that can be shared among btCollisionObjects.
 
27
class btCollisionShape
 
28
{
 
29
protected:
 
30
        int m_shapeType;
 
31
        void* m_userPointer;
 
32
 
 
33
public:
 
34
 
 
35
        btCollisionShape() : m_shapeType (INVALID_SHAPE_PROXYTYPE), m_userPointer(0)
 
36
        {
 
37
        }
 
38
 
 
39
        virtual ~btCollisionShape()
 
40
        {
 
41
        }
 
42
 
 
43
        ///getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t.
 
44
        virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const =0;
 
45
 
 
46
        virtual void    getBoundingSphere(btVector3& center,btScalar& radius) const;
 
47
 
 
48
        ///getAngularMotionDisc returns the maximus radius needed for Conservative Advancement to handle time-of-impact with rotations.
 
49
        virtual btScalar        getAngularMotionDisc() const;
 
50
 
 
51
        virtual btScalar        getContactBreakingThreshold(btScalar defaultContactThresholdFactor) const;
 
52
 
 
53
 
 
54
        ///calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep)
 
55
        ///result is conservative
 
56
        void calculateTemporalAabb(const btTransform& curTrans,const btVector3& linvel,const btVector3& angvel,btScalar timeStep, btVector3& temporalAabbMin,btVector3& temporalAabbMax) const;
 
57
 
 
58
 
 
59
 
 
60
        SIMD_FORCE_INLINE bool  isPolyhedral() const
 
61
        {
 
62
                return btBroadphaseProxy::isPolyhedral(getShapeType());
 
63
        }
 
64
 
 
65
        SIMD_FORCE_INLINE bool  isConvex2d() const
 
66
        {
 
67
                return btBroadphaseProxy::isConvex2d(getShapeType());
 
68
        }
 
69
 
 
70
        SIMD_FORCE_INLINE bool  isConvex() const
 
71
        {
 
72
                return btBroadphaseProxy::isConvex(getShapeType());
 
73
        }
 
74
        SIMD_FORCE_INLINE bool  isNonMoving() const
 
75
        {
 
76
                return btBroadphaseProxy::isNonMoving(getShapeType());
 
77
        }
 
78
        SIMD_FORCE_INLINE bool  isConcave() const
 
79
        {
 
80
                return btBroadphaseProxy::isConcave(getShapeType());
 
81
        }
 
82
        SIMD_FORCE_INLINE bool  isCompound() const
 
83
        {
 
84
                return btBroadphaseProxy::isCompound(getShapeType());
 
85
        }
 
86
 
 
87
        SIMD_FORCE_INLINE bool  isSoftBody() const
 
88
        {
 
89
                return btBroadphaseProxy::isSoftBody(getShapeType());
 
90
        }
 
91
 
 
92
        ///isInfinite is used to catch simulation error (aabb check)
 
93
        SIMD_FORCE_INLINE bool isInfinite() const
 
94
        {
 
95
                return btBroadphaseProxy::isInfinite(getShapeType());
 
96
        }
 
97
 
 
98
#ifndef __SPU__
 
99
        virtual void    setLocalScaling(const btVector3& scaling) =0;
 
100
        virtual const btVector3& getLocalScaling() const =0;
 
101
        virtual void    calculateLocalInertia(btScalar mass,btVector3& inertia) const = 0;
 
102
 
 
103
 
 
104
//debugging support
 
105
        virtual const char*     getName()const =0 ;
 
106
#endif //__SPU__
 
107
 
 
108
        
 
109
        int             getShapeType() const { return m_shapeType; }
 
110
        virtual void    setMargin(btScalar margin) = 0;
 
111
        virtual btScalar        getMargin() const = 0;
 
112
 
 
113
        
 
114
        ///optional user data pointer
 
115
        void    setUserPointer(void*  userPtr)
 
116
        {
 
117
                m_userPointer = userPtr;
 
118
        }
 
119
 
 
120
        void*   getUserPointer() const
 
121
        {
 
122
                return m_userPointer;
 
123
        }
 
124
 
 
125
        virtual int     calculateSerializeBufferSize() const;
 
126
 
 
127
        ///fills the dataBuffer and returns the struct name (and 0 on failure)
 
128
        virtual const char*     serialize(void* dataBuffer, btSerializer* serializer) const;
 
129
 
 
130
        virtual void    serializeSingleShape(btSerializer* serializer) const;
 
131
 
 
132
};      
 
133
 
 
134
///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
 
135
struct  btCollisionShapeData
 
136
{
 
137
        char    *m_name;
 
138
        int             m_shapeType;
 
139
        char    m_padding[4];
 
140
};
 
141
 
 
142
SIMD_FORCE_INLINE       int     btCollisionShape::calculateSerializeBufferSize() const
 
143
{
 
144
        return sizeof(btCollisionShapeData);
 
145
}
 
146
 
 
147
 
 
148
 
 
149
#endif //BT_COLLISION_SHAPE_H
 
150