← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/box2d/Box2D/Collision/Shapes/b2Shape.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/box2d/Box2D/Collision/Shapes/b2Shape.h
 
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_SHAPE_H
 
20
#define B2_SHAPE_H
 
21
 
 
22
#include <Box2D/Common/b2BlockAllocator.h>
 
23
#include <Box2D/Common/b2Math.h>
 
24
#include <Box2D/Collision/b2Collision.h>
 
25
 
 
26
/// This holds the mass data computed for a shape.
 
27
struct b2MassData
 
28
{
 
29
        /// The mass of the shape, usually in kilograms.
 
30
        float32 mass;
 
31
 
 
32
        /// The position of the shape's centroid relative to the shape's origin.
 
33
        b2Vec2 center;
 
34
 
 
35
        /// The rotational inertia of the shape about the local origin.
 
36
        float32 I;
 
37
};
 
38
 
 
39
/// A shape is used for collision detection. You can create a shape however you like.
 
40
/// Shapes used for simulation in b2World are created automatically when a b2Fixture
 
41
/// is created. Shapes may encapsulate a one or more child shapes.
 
42
class b2Shape
 
43
{
 
44
public:
 
45
        
 
46
        enum Type
 
47
        {
 
48
                e_circle = 0,
 
49
                e_edge = 1,
 
50
                e_polygon = 2,
 
51
                e_chain = 3,
 
52
                e_typeCount = 4
 
53
        };
 
54
 
 
55
        virtual ~b2Shape() {}
 
56
 
 
57
        /// Clone the concrete shape using the provided allocator.
 
58
        virtual b2Shape* Clone(b2BlockAllocator* allocator) const = 0;
 
59
 
 
60
        /// Get the type of this shape. You can use this to down cast to the concrete shape.
 
61
        /// @return the shape type.
 
62
        Type GetType() const;
 
63
 
 
64
        /// Get the number of child primitives.
 
65
        virtual int32 GetChildCount() const = 0;
 
66
 
 
67
        /// Test a point for containment in this shape. This only works for convex shapes.
 
68
        /// @param xf the shape world transform.
 
69
        /// @param p a point in world coordinates.
 
70
        virtual bool TestPoint(const b2Transform& xf, const b2Vec2& p) const = 0;
 
71
 
 
72
        /// Cast a ray against a child shape.
 
73
        /// @param output the ray-cast results.
 
74
        /// @param input the ray-cast input parameters.
 
75
        /// @param transform the transform to be applied to the shape.
 
76
        /// @param childIndex the child shape index
 
77
        virtual bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
 
78
                                                const b2Transform& transform, int32 childIndex) const = 0;
 
79
 
 
80
        /// Given a transform, compute the associated axis aligned bounding box for a child shape.
 
81
        /// @param aabb returns the axis aligned box.
 
82
        /// @param xf the world transform of the shape.
 
83
        /// @param childIndex the child shape
 
84
        virtual void ComputeAABB(b2AABB* aabb, const b2Transform& xf, int32 childIndex) const = 0;
 
85
 
 
86
        /// Compute the mass properties of this shape using its dimensions and density.
 
87
        /// The inertia tensor is computed about the local origin.
 
88
        /// @param massData returns the mass data for this shape.
 
89
        /// @param density the density in kilograms per meter squared.
 
90
        virtual void ComputeMass(b2MassData* massData, float32 density) const = 0;
 
91
 
 
92
        Type m_type;
 
93
        float32 m_radius;
 
94
};
 
95
 
 
96
inline b2Shape::Type b2Shape::GetType() const
 
97
{
 
98
        return m_type;
 
99
}
 
100
 
 
101
#endif