--- /dev/null
+/*
+* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
+*
+* This software is provided 'as-is', without any express or implied
+* warranty. In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 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.
+* 2. Altered source versions must be plainly marked as such, and must not be
+* misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B2_SHAPE_H
+#define B2_SHAPE_H
+
+#include "../../Common/b2Math.h"
+#include "../b2Collision.h"
+
+class b2BlockAllocator;
+class b2Body;
+class b2BroadPhase;
+
+/// This holds the mass data computed for a shape.
+struct b2MassData
+{
+ /// The mass of the shape, usually in kilograms.
+ float32 mass;
+
+ /// The position of the shape's centroid relative to the shape's origin.
+ b2Vec2 center;
+
+ /// The rotational inertia of the shape.
+ float32 I;
+};
+
+/// This holds contact filtering data.
+struct b2FilterData
+{
+ /// The collision category bits. Normally you would just set one bit.
+ uint16 categoryBits;
+
+ /// The collision mask bits. This states the categories that this
+ /// shape would accept for collision.
+ uint16 maskBits;
+
+ /// Collision groups allow a certain group of objects to never collide (negative)
+ /// or always collide (positive). Zero means no collision group. Non-zero group
+ /// filtering always wins against the mask bits.
+ int16 groupIndex;
+};
+
+/// The various collision shape types supported by Box2D.
+enum b2ShapeType
+{
+ e_unknownShape = -1,
+ e_circleShape,
+ e_polygonShape,
+ e_shapeTypeCount,
+};
+
+/// A shape definition is used to construct a shape. This class defines an
+/// abstract shape definition. You can reuse shape definitions safely.
+struct b2ShapeDef
+{
+ /// The constructor sets the default shape definition values.
+ b2ShapeDef()
+ {
+ type = e_unknownShape;
+ userData = NULL;
+ friction = 0.2f;
+ restitution = 0.0f;
+ density = 0.0f;
+ filter.categoryBits = 0x0001;
+ filter.maskBits = 0xFFFF;
+ filter.groupIndex = 0;
+ isSensor = false;
+ }
+
+ virtual ~b2ShapeDef() {}
+
+ /// Holds the shape type for down-casting.
+ b2ShapeType type;
+
+ /// Use this to store application specify shape data.
+ void* userData;
+
+ /// The shape's friction coefficient, usually in the range [0,1].
+ float32 friction;
+
+ /// The shape's restitution (elasticity) usually in the range [0,1].
+ float32 restitution;
+
+ /// The shape's density, usually in kg/m^2.
+ float32 density;
+
+ /// A sensor shape collects contact information but never generates a collision
+ /// response.
+ bool isSensor;
+
+ /// Contact filtering data.
+ b2FilterData filter;
+};
+
+/// A shape is used for collision detection. Shapes are created in b2World.
+/// You can use shape for collision detection before they are attached to the world.
+/// @warning you cannot reuse shapes.
+class b2Shape
+{
+public:
+ /// Get the type of this shape. You can use this to down cast to the concrete shape.
+ /// @return the shape type.
+ b2ShapeType GetType() const;
+
+ /// Is this shape a sensor (non-solid)?
+ /// @return the true if the shape is a sensor.
+ bool IsSensor() const;
+
+ /// Set the contact filtering data. You must call b2World::Refilter to correct
+ /// existing contacts/non-contacts.
+ void SetFilterData(const b2FilterData& filter);
+
+ /// Get the contact filtering data.
+ const b2FilterData& GetFilterData() const;
+
+ /// Get the parent body of this shape. This is NULL if the shape is not attached.
+ /// @return the parent body.
+ b2Body* GetBody();
+
+ /// Get the next shape in the parent body's shape list.
+ /// @return the next shape.
+ b2Shape* GetNext();
+
+ /// Get the user data that was assigned in the shape definition. Use this to
+ /// store your application specific data.
+ void* GetUserData();
+
+ /// Set the user data. Use this to store your application specific data.
+ void SetUserData(void* data);
+
+ /// Test a point for containment in this shape. This only works for convex shapes.
+ /// @param xf the shape world transform.
+ /// @param p a point in world coordinates.
+ virtual bool TestPoint(const b2XForm& xf, const b2Vec2& p) const = 0;
+
+ /// Perform a ray cast against this shape.
+ /// @param xf the shape world transform.
+ /// @param lambda returns the hit fraction. You can use this to compute the contact point
+ /// p = (1 - lambda) * segment.p1 + lambda * segment.p2.
+ /// @param normal returns the normal at the contact point. If there is no intersection, the normal
+ /// is not set.
+ /// @param segment defines the begin and end point of the ray cast.
+ /// @param maxLambda a number typically in the range [0,1].
+ /// @return true if there was an intersection.
+ virtual bool TestSegment( const b2XForm& xf,
+ float32* lambda,
+ b2Vec2* normal,
+ const b2Segment& segment,
+ float32 maxLambda) const = 0;
+
+ /// Given a transform, compute the associated axis aligned bounding box for this shape.
+ /// @param aabb returns the axis aligned box.
+ /// @param xf the world transform of the shape.
+ virtual void ComputeAABB(b2AABB* aabb, const b2XForm& xf) const = 0;
+
+ /// Given two transforms, compute the associated swept axis aligned bounding box for this shape.
+ /// @param aabb returns the axis aligned box.
+ /// @param xf1 the starting shape world transform.
+ /// @param xf2 the ending shape world transform.
+ virtual void ComputeSweptAABB( b2AABB* aabb,
+ const b2XForm& xf1,
+ const b2XForm& xf2) const = 0;
+
+ /// Compute the mass properties of this shape using its dimensions and density.
+ /// The inertia tensor is computed about the local origin, not the centroid.
+ /// @param massData returns the mass data for this shape.
+ virtual void ComputeMass(b2MassData* massData) const = 0;
+
+ /// Get the maximum radius about the parent body's center of mass.
+ float32 GetSweepRadius() const;
+
+ /// Get the coefficient of friction.
+ float32 GetFriction() const;
+
+ /// Get the coefficient of restitution.
+ float32 GetRestitution() const;
+
+protected:
+
+ friend class b2Body;
+ friend class b2World;
+
+ static b2Shape* Create(const b2ShapeDef* def, b2BlockAllocator* allocator);
+ static void Destroy(b2Shape* shape, b2BlockAllocator* allocator);
+
+ b2Shape(const b2ShapeDef* def);
+ virtual ~b2Shape();
+
+ void CreateProxy(b2BroadPhase* broadPhase, const b2XForm& xf);
+ void DestroyProxy(b2BroadPhase* broadPhase);
+ bool Synchronize(b2BroadPhase* broadPhase, const b2XForm& xf1, const b2XForm& xf2);
+ void RefilterProxy(b2BroadPhase* broadPhase, const b2XForm& xf);
+
+ virtual void UpdateSweepRadius(const b2Vec2& center) = 0;
+
+ b2ShapeType m_type;
+ b2Shape* m_next;
+ b2Body* m_body;
+
+ // Sweep radius relative to the parent body's center of mass.
+ float32 m_sweepRadius;
+
+ float32 m_density;
+ float32 m_friction;
+ float32 m_restitution;
+
+ uint16 m_proxyId;
+ b2FilterData m_filter;
+
+ bool m_isSensor;
+
+ void* m_userData;
+};
+
+inline b2ShapeType b2Shape::GetType() const
+{
+ return m_type;
+}
+
+inline bool b2Shape::IsSensor() const
+{
+ return m_isSensor;
+}
+
+inline void b2Shape::SetFilterData(const b2FilterData& filter)
+{
+ m_filter = filter;
+}
+
+inline const b2FilterData& b2Shape::GetFilterData() const
+{
+ return m_filter;
+}
+
+inline void* b2Shape::GetUserData()
+{
+ return m_userData;
+}
+
+inline void b2Shape::SetUserData(void* data)
+{
+ m_userData = data;
+}
+
+inline b2Body* b2Shape::GetBody()
+{
+ return m_body;
+}
+
+inline b2Shape* b2Shape::GetNext()
+{
+ return m_next;
+}
+
+inline float32 b2Shape::GetSweepRadius() const
+{
+ return m_sweepRadius;
+}
+
+inline float32 b2Shape::GetFriction() const
+{
+ return m_friction;
+}
+
+inline float32 b2Shape::GetRestitution() const
+{
+ return m_restitution;
+}
+
+#endif
projects / blok / blobdiff