Box2D: b2Collision.h Source File

| Box2D 2.3.0 A 2D Physics Engine for Games

- Main Page
- Classes
- Files

- File List
- File Members

b2Collision.h
Go to the documentation of this file.
1 /*
2 * Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
3 *
4 * This software is provided 'as-is', without any express or implied
5 * warranty. In no event will the authors be held liable for any damages
6 * 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
9 * freely, subject to the following restrictions:
10 * 1. The origin of this software must not be misrepresented; you must not
11 * claim that you wrote the original software. If you use this software
12 * in a product, an acknowledgment in the product documentation would be
13 * appreciated but is not required.
14 * 2. Altered source versions must be plainly marked as such, and must not be
15 * misrepresented as being the original software.
16 * 3. This notice may not be removed or altered from any source distribution.
17 */
18
19 #ifndef B2_COLLISION_H
20 #define B2_COLLISION_H
21
22 #include <Box2D/Common/b2Math.h>
23 #include <limits.h>
24
28
29 class b2Shape;
30 class b2CircleShape;
31 class b2EdgeShape;
32 class b2PolygonShape;
33
34 const uint8 b2_nullFeature = UCHAR_MAX;
35
38 struct b2ContactFeature
39 {
40 enum Type
41 {
42 e_vertex = 0,
43 e_face = 1
44 };
45
46 uint8 indexA;
47 uint8 indexB;
48 uint8 typeA;
49 uint8 typeB;
50 };
51
53 union b2ContactID
54 {
55 b2ContactFeature cf;
56 uint32 key;
57 };
58
69 struct b2ManifoldPoint
70 {
71 b2Vec2 localPoint;
72 float32 normalImpulse;
73 float32 tangentImpulse;
74 b2ContactID id;
75 };
76
93 struct b2Manifold
94 {
95 enum Type
96 {
97 e_circles,
98 e_faceA,
99 e_faceB
100 };
101
102 b2ManifoldPoint points[b2_maxManifoldPoints];
103 b2Vec2 localNormal;
104 b2Vec2 localPoint;
105 Type type;
106 int32 pointCount;
107 };
108
110 struct b2WorldManifold
111 {
116 void Initialize(const b2Manifold* manifold,
117 const b2Transform& xfA, float32 radiusA,
118 const b2Transform& xfB, float32 radiusB);
119
120 b2Vec2 normal;
121 b2Vec2 points[b2_maxManifoldPoints];
122 float32 separations[b2_maxManifoldPoints];
123 };
124
126 enum b2PointState
127 {
128 b2_nullState,
129 b2_addState,
130 b2_persistState,
131 b2_removeState
132 };
133
136 void b2GetPointStates(b2PointState state1[b2_maxManifoldPoints], b2PointState state2[b2_maxManifoldPoints],
137 const b2Manifold* manifold1, const b2Manifold* manifold2);
138
140 struct b2ClipVertex
141 {
142 b2Vec2 v;
143 b2ContactID id;
144 };
145
147 struct b2RayCastInput
148 {
149 b2Vec2 p1, p2;
150 float32 maxFraction;
151 };
152
155 struct b2RayCastOutput
156 {
157 b2Vec2 normal;
158 float32 fraction;
159 };
160
162 struct b2AABB
163 {
165 bool IsValid() const;
166
168 b2Vec2 GetCenter() const
169 {
170 return 0.5f * (lowerBound + upperBound);
171 }
172
174 b2Vec2 GetExtents() const
175 {
176 return 0.5f * (upperBound - lowerBound);
177 }
178
180 float32 GetPerimeter() const
181 {
182 float32 wx = upperBound.x - lowerBound.x;
183 float32 wy = upperBound.y - lowerBound.y;
184 return 2.0f * (wx + wy);
185 }
186
188 void Combine(const b2AABB& aabb)
189 {
190 lowerBound = b2Min(lowerBound, aabb.lowerBound);
191 upperBound = b2Max(upperBound, aabb.upperBound);
192 }
193
195 void Combine(const b2AABB& aabb1, const b2AABB& aabb2)
196 {
197 lowerBound = b2Min(aabb1.lowerBound, aabb2.lowerBound);
198 upperBound = b2Max(aabb1.upperBound, aabb2.upperBound);
199 }
200
202 bool Contains(const b2AABB& aabb) const
203 {
204 bool result = true;
205 result = result && lowerBound.x <= aabb.lowerBound.x;
206 result = result && lowerBound.y <= aabb.lowerBound.y;
207 result = result && aabb.upperBound.x <= upperBound.x;
208 result = result && aabb.upperBound.y <= upperBound.y;
209 return result;
210 }
211
212 bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input) const;
213
214 b2Vec2 lowerBound;
215 b2Vec2 upperBound;
216 };
217
219 void b2CollideCircles(b2Manifold* manifold,
220 const b2CircleShape* circleA, const b2Transform& xfA,
221 const b2CircleShape* circleB, const b2Transform& xfB);
222
224 void b2CollidePolygonAndCircle(b2Manifold* manifold,
225 const b2PolygonShape* polygonA, const b2Transform& xfA,
226 const b2CircleShape* circleB, const b2Transform& xfB);
227
229 void b2CollidePolygons(b2Manifold* manifold,
230 const b2PolygonShape* polygonA, const b2Transform& xfA,
231 const b2PolygonShape* polygonB, const b2Transform& xfB);
232
234 void b2CollideEdgeAndCircle(b2Manifold* manifold,
235 const b2EdgeShape* polygonA, const b2Transform& xfA,
236 const b2CircleShape* circleB, const b2Transform& xfB);
237
239 void b2CollideEdgeAndPolygon(b2Manifold* manifold,
240 const b2EdgeShape* edgeA, const b2Transform& xfA,
241 const b2PolygonShape* circleB, const b2Transform& xfB);
242
244 int32 b2ClipSegmentToLine(b2ClipVertex vOut[2], const b2ClipVertex vIn[2],
245 const b2Vec2& normal, float32 offset, int32 vertexIndexA);
246
248 bool b2TestOverlap( const b2Shape* shapeA, int32 indexA,
249 const b2Shape* shapeB, int32 indexB,
250 const b2Transform& xfA, const b2Transform& xfB);
251
252 // ---------------- Inline Functions ------------------------------------------
253
254 inline bool b2AABB::IsValid() const
255 {
256 b2Vec2 d = upperBound - lowerBound;
257 bool valid = d.x >= 0.0f && d.y >= 0.0f;
258 valid = valid && lowerBound.IsValid() && upperBound.IsValid();
259 return valid;
260 }
261
262 inline bool b2TestOverlap(const b2AABB& a, const b2AABB& b)
263 {
264 b2Vec2 d1, d2;
265 d1 = b.lowerBound - a.upperBound;
266 d2 = a.lowerBound - b.upperBound;
267
268 if (d1.x > 0.0f || d1.y > 0.0f)
269 return false;
270
271 if (d2.x > 0.0f || d2.y > 0.0f)
272 return false;
273
274 return true;
275 }
276
277 #endif
b2Transform
Definition: b2Math.h:350
b2AABB::GetExtents
b2Vec2 GetExtents() const
Get the extents of the AABB (half-widths).
Definition: b2Collision.h:174
b2CircleShape
A circle shape.
Definition: b2CircleShape.h:25
b2_addState
point was added in the update
Definition: b2Collision.h:129
b2AABB::GetCenter
b2Vec2 GetCenter() const
Get the center of the AABB.
Definition: b2Collision.h:168
b2AABB::lowerBound
b2Vec2 lowerBound
the lower vertex
Definition: b2Collision.h:214
b2WorldManifold
This is used to compute the current state of a contact manifold.
Definition: b2Collision.h:110
b2AABB::Contains
bool Contains(const b2AABB &aabb) const
Does this aabb contain the provided AABB.
Definition: b2Collision.h:202
b2ContactFeature::typeA
uint8 typeA
The feature type on shapeA.
Definition: b2Collision.h:48
b2CollideEdgeAndPolygon
void b2CollideEdgeAndPolygon(b2Manifold *manifold, const b2EdgeShape *edgeA, const b2Transform &xfA, const b2PolygonShape *circleB, const b2Transform &xfB)
Compute the collision manifold between an edge and a circle.
Definition: b2CollideEdge.cpp:692
b2Shape
Definition: b2Shape.h:42
b2ClipVertex
Used for computing contact manifolds.
Definition: b2Collision.h:140
b2_nullState
point does not exist
Definition: b2Collision.h:128
b2ClipSegmentToLine
int32 b2ClipSegmentToLine(b2ClipVertex vOut[2], const b2ClipVertex vIn[2], const b2Vec2 &normal, float32 offset, int32 vertexIndexA)
Clipping for contact manifolds.
Definition: b2Collision.cpp:201
b2PolygonShape
Definition: b2PolygonShape.h:28
b2RayCastOutput
Definition: b2Collision.h:155
b2ManifoldPoint::normalImpulse
float32 normalImpulse
the non-penetration impulse
Definition: b2Collision.h:72
b2ContactID
Contact ids to facilitate warm starting.
Definition: b2Collision.h:53
b2ContactFeature
Definition: b2Collision.h:38
b2_removeState
point was removed in the update
Definition: b2Collision.h:131
b2CollideCircles
void b2CollideCircles(b2Manifold *manifold, const b2CircleShape *circleA, const b2Transform &xfA, const b2CircleShape *circleB, const b2Transform &xfB)
Compute the collision manifold between two circles.
Definition: b2CollideCircle.cpp:23
b2ManifoldPoint::localPoint
b2Vec2 localPoint
usage depends on manifold type
Definition: b2Collision.h:71
b2AABB::upperBound
b2Vec2 upperBound
the upper vertex
Definition: b2Collision.h:215
b2Manifold::localPoint
b2Vec2 localPoint
usage depends on manifold type
Definition: b2Collision.h:104
b2AABB::IsValid
bool IsValid() const
Verify that the bounds are sorted.
Definition: b2Collision.h:254
b2ManifoldPoint::tangentImpulse
float32 tangentImpulse
the friction impulse
Definition: b2Collision.h:73
b2AABB
An axis aligned bounding box.
Definition: b2Collision.h:162
b2TestOverlap
bool b2TestOverlap(const b2Shape *shapeA, int32 indexA, const b2Shape *shapeB, int32 indexB, const b2Transform &xfA, const b2Transform &xfB)
Determine if two generic shapes overlap.
Definition: b2Collision.cpp:233
b2_persistState
point persisted across the update
Definition: b2Collision.h:130
b2ContactFeature::typeB
uint8 typeB
The feature type on shapeB.
Definition: b2Collision.h:49
b2CollidePolygonAndCircle
void b2CollidePolygonAndCircle(b2Manifold *manifold, const b2PolygonShape *polygonA, const b2Transform &xfA, const b2CircleShape *circleB, const b2Transform &xfB)
Compute the collision manifold between a polygon and a circle.
Definition: b2CollideCircle.cpp:51
b2RayCastInput
Ray-cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1).
Definition: b2Collision.h:147
b2EdgeShape
Definition: b2EdgeShape.h:27
b2CollidePolygons
void b2CollidePolygons(b2Manifold *manifold, const b2PolygonShape *polygonA, const b2Transform &xfA, const b2PolygonShape *polygonB, const b2Transform &xfB)
Compute the collision manifold between two polygons.
Definition: b2CollidePolygon.cpp:116
b2ContactFeature::indexA
uint8 indexA
Feature index on shapeA.
Definition: b2Collision.h:46
b2ContactID::key
uint32 key
Used to quickly compare contact ids.
Definition: b2Collision.h:56
b2AABB::GetPerimeter
float32 GetPerimeter() const
Get the perimeter length.
Definition: b2Collision.h:180
b2Manifold
Definition: b2Collision.h:93
b2PointState
b2PointState
This is used for determining the state of contact points.
Definition: b2Collision.h:126
b2CollideEdgeAndCircle
void b2CollideEdgeAndCircle(b2Manifold *manifold, const b2EdgeShape *polygonA, const b2Transform &xfA, const b2CircleShape *circleB, const b2Transform &xfB)
Compute the collision manifold between an edge and a circle.
Definition: b2CollideEdge.cpp:27
b2Manifold::pointCount
int32 pointCount
the number of manifold points
Definition: b2Collision.h:106
b2AABB::Combine
void Combine(const b2AABB &aabb)
Combine an AABB into this one.
Definition: b2Collision.h:188
b2Vec2
A 2D column vector.
Definition: b2Math.h:53
b2ContactFeature::indexB
uint8 indexB
Feature index on shapeB.
Definition: b2Collision.h:47
b2_maxManifoldPoints
#define b2_maxManifoldPoints
Definition: b2Settings.h:50
b2ManifoldPoint
Definition: b2Collision.h:69
b2WorldManifold::normal
b2Vec2 normal
world vector pointing from A to B
Definition: b2Collision.h:120
b2GetPointStates
void b2GetPointStates(b2PointState state1[b2_maxManifoldPoints], b2PointState state2[b2_maxManifoldPoints], const b2Manifold *manifold1, const b2Manifold *manifold2)
Definition: b2Collision.cpp:88
b2AABB::Combine
void Combine(const b2AABB &aabb1, const b2AABB &aabb2)
Combine two AABBs into this one.
Definition: b2Collision.h:195
b2Manifold::localNormal
b2Vec2 localNormal
not use for Type::e_points
Definition: b2Collision.h:103
b2ManifoldPoint::id
b2ContactID id
uniquely identifies a contact point between two shapes
Definition: b2Collision.h:74