rpms
/
Box2D
21
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f105ef2e34'
${ noResults }
Box2D/631.patch

1648 lines
49 KiB
Raw Blame History

From 1e7275aa705cb9dfc18d0d55986423aec7cd038b Mon Sep 17 00:00:00 2001
From: Julien Bernard <julien.bernard@univ-fcomte.fr>
Date: Fri, 7 Aug 2020 21:08:04 +0200
Subject: [PATCH 1/3] modify CMakeLists.txt to support shared libraries
---
CMakeLists.txt | 4 ++++
src/CMakeLists.txt | 23 ++++++++++++++++++++++-
2 files changed, 26 insertions(+), 1 deletion(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 92b2c00f9..924bbf5e0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,6 +7,10 @@ project(box2d VERSION 2.4.0)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+
+option(BUILD_SHARED_LIBS "Build Box2D as a shared library" OFF)
+
add_subdirectory(src)
option(BOX2D_BUILD_UNIT_TESTS "Build the Box2D unit tests" ON)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6ef515f8c..429887359 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,3 +1,5 @@
+include(GenerateExportHeader)
+
set(BOX2D_SOURCE_FILES
collision/b2_broad_phase.cpp
collision/b2_chain_shape.cpp
From f5b2c8e0aa92b0cd9641ce44725f11d1119dce80 Mon Sep 17 00:00:00 2001
From: Julien Bernard <julien.bernard@univ-fcomte.fr>
Date: Fri, 7 Aug 2020 22:13:55 +0200
Subject: [PATCH 2/3] fully support Box2D as shared library
- add B2_API where relevant
- add missing variable declarations (mainly for testbed)
- C++ify some included headers
---
include/box2d/b2_block_allocator.h | 5 ++--
include/box2d/b2_body.h | 7 +++---
include/box2d/b2_broad_phase.h | 5 ++--
include/box2d/b2_chain_shape.h | 3 ++-
include/box2d/b2_circle_shape.h | 3 ++-
include/box2d/b2_collision.h | 38 ++++++++++++++--------------
include/box2d/b2_contact.h | 10 +++++---
include/box2d/b2_contact_manager.h | 5 ++--
include/box2d/b2_distance.h | 24 ++++++++++--------
include/box2d/b2_distance_joint.h | 5 ++--
include/box2d/b2_draw.h | 11 ++++----
include/box2d/b2_dynamic_tree.h | 5 ++--
include/box2d/b2_edge_shape.h | 7 +++---
include/box2d/b2_fixture.h | 9 ++++---
include/box2d/b2_friction_joint.h | 5 ++--
include/box2d/b2_gear_joint.h | 4 +--
include/box2d/b2_growable_stack.h | 5 ++--
include/box2d/b2_joint.h | 13 +++++-----
include/box2d/b2_math.h | 40 ++++++++++++++++--------------
include/box2d/b2_motor_joint.h | 7 +++---
include/box2d/b2_mouse_joint.h | 7 +++---
include/box2d/b2_polygon_shape.h | 3 ++-
include/box2d/b2_prismatic_joint.h | 5 ++--
include/box2d/b2_pulley_joint.h | 7 +++---
include/box2d/b2_revolute_joint.h | 7 +++---
include/box2d/b2_rope.h | 11 ++++----
include/box2d/b2_rope_joint.h | 5 ++--
include/box2d/b2_settings.h | 24 ++++++++++--------
include/box2d/b2_shape.h | 7 +++---
include/box2d/b2_stack_allocator.h | 5 ++--
include/box2d/b2_time_of_impact.h | 14 ++++++++---
include/box2d/b2_time_step.h | 11 ++++----
include/box2d/b2_timer.h | 3 ++-
include/box2d/b2_weld_joint.h | 7 +++---
include/box2d/b2_wheel_joint.h | 5 ++--
include/box2d/b2_world.h | 7 +++---
include/box2d/b2_world_callbacks.h | 13 +++++-----
src/CMakeLists.txt | 18 ++++++++++++--
38 files changed, 218 insertions(+), 152 deletions(-)
diff --git a/include/box2d/b2_block_allocator.h b/include/box2d/b2_block_allocator.h
index 48957343e..95c12de89 100644
--- a/include/box2d/b2_block_allocator.h
+++ b/include/box2d/b2_block_allocator.h
@@ -23,7 +23,8 @@
#ifndef B2_BLOCK_ALLOCATOR_H
#define B2_BLOCK_ALLOCATOR_H
-#include "box2d/b2_settings.h"
+#include "b2_api.h"
+#include "b2_settings.h"
const int32 b2_blockSizeCount = 14;
@@ -33,7 +34,7 @@ struct b2Chunk;
/// This is a small object allocator used for allocating small
/// objects that persist for more than one time step.
/// See: http://www.codeproject.com/useritems/Small_Block_Allocator.asp
-class b2BlockAllocator
+class B2_API b2BlockAllocator
{
public:
b2BlockAllocator();
diff --git a/include/box2d/b2_body.h b/include/box2d/b2_body.h
index 6ba8574de..81a791391 100644
--- a/include/box2d/b2_body.h
+++ b/include/box2d/b2_body.h
@@ -23,6 +23,7 @@
#ifndef B2_BODY_H
#define B2_BODY_H
+#include "b2_api.h"
#include "b2_math.h"
#include "b2_shape.h"
@@ -51,7 +52,7 @@ enum b2BodyType
/// A body definition holds all the data needed to construct a rigid body.
/// You can safely re-use body definitions. Shapes are added to a body after construction.
-struct b2BodyDef
+struct B2_API b2BodyDef
{
/// This constructor sets the body definition default values.
b2BodyDef()
@@ -128,7 +129,7 @@ struct b2BodyDef
};
/// A rigid body. These are created via b2World::CreateBody.
-class b2Body
+class B2_API b2Body
{
public:
/// Creates a fixture and attach it to this body. Use this function if you need
@@ -398,7 +399,7 @@ class b2Body
friend class b2ContactManager;
friend class b2ContactSolver;
friend class b2Contact;
-
+
friend class b2DistanceJoint;
friend class b2FrictionJoint;
friend class b2GearJoint;
diff --git a/include/box2d/b2_broad_phase.h b/include/box2d/b2_broad_phase.h
index cf1cf6773..cc882ab47 100644
--- a/include/box2d/b2_broad_phase.h
+++ b/include/box2d/b2_broad_phase.h
@@ -23,11 +23,12 @@
#ifndef B2_BROAD_PHASE_H
#define B2_BROAD_PHASE_H
+#include "b2_api.h"
#include "b2_settings.h"
#include "b2_collision.h"
#include "b2_dynamic_tree.h"
-struct b2Pair
+struct B2_API b2Pair
{
int32 proxyIdA;
int32 proxyIdB;
@@ -36,7 +37,7 @@ struct b2Pair
/// The broad-phase is used for computing pairs and performing volume queries and ray casts.
/// This broad-phase does not persist pairs. Instead, this reports potentially new pairs.
/// It is up to the client to consume the new pairs and to track subsequent overlap.
-class b2BroadPhase
+class B2_API b2BroadPhase
{
public:
diff --git a/include/box2d/b2_chain_shape.h b/include/box2d/b2_chain_shape.h
index 9ba0b8b1c..da2605d62 100644
--- a/include/box2d/b2_chain_shape.h
+++ b/include/box2d/b2_chain_shape.h
@@ -23,6 +23,7 @@
#ifndef B2_CHAIN_SHAPE_H
#define B2_CHAIN_SHAPE_H
+#include "b2_api.h"
#include "b2_shape.h"
class b2EdgeShape;
@@ -32,7 +33,7 @@ class b2EdgeShape;
/// This provides a counter-clockwise winding like the polygon shape.
/// Connectivity information is used to create smooth collisions.
/// @warning the chain will not collide properly if there are self-intersections.
-class b2ChainShape : public b2Shape
+class B2_API b2ChainShape : public b2Shape
{
public:
b2ChainShape();
diff --git a/include/box2d/b2_circle_shape.h b/include/box2d/b2_circle_shape.h
index 009d77db5..5e330f5a7 100644
--- a/include/box2d/b2_circle_shape.h
+++ b/include/box2d/b2_circle_shape.h
@@ -23,10 +23,11 @@
#ifndef B2_CIRCLE_SHAPE_H
#define B2_CIRCLE_SHAPE_H
+#include "b2_api.h"
#include "b2_shape.h"
/// A solid circle shape
-class b2CircleShape : public b2Shape
+class B2_API b2CircleShape : public b2Shape
{
public:
b2CircleShape();
diff --git a/include/box2d/b2_collision.h b/include/box2d/b2_collision.h
index aaa207b35..a6a5472cb 100644
--- a/include/box2d/b2_collision.h
+++ b/include/box2d/b2_collision.h
@@ -23,8 +23,10 @@
#ifndef B2_COLLISION_H
#define B2_COLLISION_H
+#include <climits>
+
+#include "b2_api.h"
#include "b2_math.h"
-#include <limits.h>
/// @file
/// Structures and functions used for computing contact points, distance
@@ -39,7 +41,7 @@ const uint8 b2_nullFeature = UCHAR_MAX;
/// The features that intersect to form the contact point
/// This must be 4 bytes or less.
-struct b2ContactFeature
+struct B2_API b2ContactFeature
{
enum Type
{
@@ -54,7 +56,7 @@ struct b2ContactFeature
};
/// Contact ids to facilitate warm starting.
-union b2ContactID
+union B2_API b2ContactID
{
b2ContactFeature cf;
uint32 key; ///< Used to quickly compare contact ids.
@@ -70,7 +72,7 @@ union b2ContactID
/// This structure is stored across time steps, so we keep it small.
/// Note: the impulses are used for internal caching and may not
/// provide reliable contact forces, especially for high speed collisions.
-struct b2ManifoldPoint
+struct B2_API b2ManifoldPoint
{
b2Vec2 localPoint; ///< usage depends on manifold type
float normalImpulse; ///< the non-penetration impulse
@@ -94,7 +96,7 @@ struct b2ManifoldPoint
/// account for movement, which is critical for continuous physics.
/// All contact scenarios must be expressed in one of these types.
/// This structure is stored across time steps, so we keep it small.
-struct b2Manifold
+struct B2_API b2Manifold
{
enum Type
{
@@ -111,7 +113,7 @@ struct b2Manifold
};
/// This is used to compute the current state of a contact manifold.
-struct b2WorldManifold
+struct B2_API b2WorldManifold
{
/// Evaluate the manifold with supplied transforms. This assumes
/// modest motion from the original state. This does not change the
@@ -137,18 +139,18 @@ enum b2PointState
/// Compute the point states given two manifolds. The states pertain to the transition from manifold1
/// to manifold2. So state1 is either persist or remove while state2 is either add or persist.
-void b2GetPointStates(b2PointState state1[b2_maxManifoldPoints], b2PointState state2[b2_maxManifoldPoints],
+B2_API void b2GetPointStates(b2PointState state1[b2_maxManifoldPoints], b2PointState state2[b2_maxManifoldPoints],
const b2Manifold* manifold1, const b2Manifold* manifold2);
/// Used for computing contact manifolds.
-struct b2ClipVertex
+struct B2_API b2ClipVertex
{
b2Vec2 v;
b2ContactID id;
};
/// Ray-cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1).
-struct b2RayCastInput
+struct B2_API b2RayCastInput
{
b2Vec2 p1, p2;
float maxFraction;
@@ -156,14 +158,14 @@ struct b2RayCastInput
/// Ray-cast output data. The ray hits at p1 + fraction * (p2 - p1), where p1 and p2
/// come from b2RayCastInput.
-struct b2RayCastOutput
+struct B2_API b2RayCastOutput
{
b2Vec2 normal;
float fraction;
};
/// An axis aligned bounding box.
-struct b2AABB
+struct B2_API b2AABB
{
/// Verify that the bounds are sorted.
bool IsValid() const;
@@ -220,36 +222,36 @@ struct b2AABB
};
/// Compute the collision manifold between two circles.
-void b2CollideCircles(b2Manifold* manifold,
+B2_API void b2CollideCircles(b2Manifold* manifold,
const b2CircleShape* circleA, const b2Transform& xfA,
const b2CircleShape* circleB, const b2Transform& xfB);
/// Compute the collision manifold between a polygon and a circle.
-void b2CollidePolygonAndCircle(b2Manifold* manifold,
+B2_API void b2CollidePolygonAndCircle(b2Manifold* manifold,
const b2PolygonShape* polygonA, const b2Transform& xfA,
const b2CircleShape* circleB, const b2Transform& xfB);
/// Compute the collision manifold between two polygons.
-void b2CollidePolygons(b2Manifold* manifold,
+B2_API void b2CollidePolygons(b2Manifold* manifold,
const b2PolygonShape* polygonA, const b2Transform& xfA,
const b2PolygonShape* polygonB, const b2Transform& xfB);
/// Compute the collision manifold between an edge and a circle.
-void b2CollideEdgeAndCircle(b2Manifold* manifold,
+B2_API 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 polygon.
-void b2CollideEdgeAndPolygon(b2Manifold* manifold,
+B2_API void b2CollideEdgeAndPolygon(b2Manifold* manifold,
const b2EdgeShape* edgeA, const b2Transform& xfA,
const b2PolygonShape* circleB, const b2Transform& xfB);
/// Clipping for contact manifolds.
-int32 b2ClipSegmentToLine(b2ClipVertex vOut[2], const b2ClipVertex vIn[2],
+B2_API int32 b2ClipSegmentToLine(b2ClipVertex vOut[2], const b2ClipVertex vIn[2],
const b2Vec2& normal, float offset, int32 vertexIndexA);
/// Determine if two generic shapes overlap.
-bool b2TestOverlap( const b2Shape* shapeA, int32 indexA,
+B2_API bool b2TestOverlap( const b2Shape* shapeA, int32 indexA,
const b2Shape* shapeB, int32 indexB,
const b2Transform& xfA, const b2Transform& xfB);
diff --git a/include/box2d/b2_contact.h b/include/box2d/b2_contact.h
index d4c59c620..eef7b3b6a 100644
--- a/include/box2d/b2_contact.h
+++ b/include/box2d/b2_contact.h
@@ -23,6 +23,7 @@
#ifndef B2_CONTACT_H
#define B2_CONTACT_H
+#include "b2_api.h"
#include "b2_collision.h"
#include "b2_fixture.h"
#include "b2_math.h"
@@ -55,7 +56,7 @@ typedef b2Contact* b2ContactCreateFcn( b2Fixture* fixtureA, int32 indexA,
b2BlockAllocator* allocator);
typedef void b2ContactDestroyFcn(b2Contact* contact, b2BlockAllocator* allocator);
-struct b2ContactRegister
+struct B2_API b2ContactRegister
{
b2ContactCreateFcn* createFcn;
b2ContactDestroyFcn* destroyFcn;
@@ -67,7 +68,7 @@ struct b2ContactRegister
/// is an edge. A contact edge belongs to a doubly linked list
/// maintained in each attached body. Each contact has two contact
/// nodes, one for each attached body.
-struct b2ContactEdge
+struct B2_API b2ContactEdge
{
b2Body* other; ///< provides quick access to the other body attached.
b2Contact* contact; ///< the contact
@@ -78,7 +79,7 @@ struct b2ContactEdge
/// The class manages contact between two shapes. A contact exists for each overlapping
/// AABB in the broad-phase (except if filtered). Therefore a contact object may exist
/// that has no contact points.
-class b2Contact
+class B2_API b2Contact
{
public:
@@ -350,4 +351,7 @@ inline float b2Contact::GetTangentSpeed() const
return m_tangentSpeed;
}
+/// internal for testbed, do not use
+extern B2_API bool g_blockSolve;
+
#endif
diff --git a/include/box2d/b2_contact_manager.h b/include/box2d/b2_contact_manager.h
index efa156847..fbd3b4d40 100644
--- a/include/box2d/b2_contact_manager.h
+++ b/include/box2d/b2_contact_manager.h
@@ -23,6 +23,7 @@
#ifndef B2_CONTACT_MANAGER_H
#define B2_CONTACT_MANAGER_H
+#include "b2_api.h"
#include "b2_broad_phase.h"
class b2Contact;
@@ -31,7 +32,7 @@ class b2ContactListener;
class b2BlockAllocator;
// Delegate of b2World.
-class b2ContactManager
+class B2_API b2ContactManager
{
public:
b2ContactManager();
@@ -44,7 +45,7 @@ class b2ContactManager
void Destroy(b2Contact* c);
void Collide();
-
+
b2BroadPhase m_broadPhase;
b2Contact* m_contactList;
int32 m_contactCount;
diff --git a/include/box2d/b2_distance.h b/include/box2d/b2_distance.h
index 3fcefc413..12e993fe6 100644
--- a/include/box2d/b2_distance.h
+++ b/include/box2d/b2_distance.h
@@ -23,13 +23,14 @@
#ifndef B2_DISTANCE_H
#define B2_DISTANCE_H
+#include "b2_api.h"
#include "b2_math.h"
class b2Shape;
/// A distance proxy is used by the GJK algorithm.
/// It encapsulates any shape.
-struct b2DistanceProxy
+struct B2_API b2DistanceProxy
{
b2DistanceProxy() : m_vertices(nullptr), m_count(0), m_radius(0.0f) {}
@@ -61,7 +62,7 @@ struct b2DistanceProxy
/// Used to warm start b2Distance.
/// Set count to zero on first call.
-struct b2SimplexCache
+struct B2_API b2SimplexCache
{
float metric; ///< length or area
uint16 count;
@@ -71,8 +72,8 @@ struct b2SimplexCache
/// Input for b2Distance.
/// You have to option to use the shape radii
-/// in the computation. Even
-struct b2DistanceInput
+/// in the computation. Even
+struct B2_API b2DistanceInput
{
b2DistanceProxy proxyA;
b2DistanceProxy proxyB;
@@ -82,7 +83,7 @@ struct b2DistanceInput
};
/// Output for b2Distance.
-struct b2DistanceOutput
+struct B2_API b2DistanceOutput
{
b2Vec2 pointA; ///< closest point on shapeA
b2Vec2 pointB; ///< closest point on shapeB
@@ -93,12 +94,12 @@ struct b2DistanceOutput
/// Compute the closest points between two shapes. Supports any combination of:
/// b2CircleShape, b2PolygonShape, b2EdgeShape. The simplex cache is input/output.
/// On the first call set b2SimplexCache.count to zero.
-void b2Distance(b2DistanceOutput* output,
- b2SimplexCache* cache,
+B2_API void b2Distance(b2DistanceOutput* output,
+ b2SimplexCache* cache,
const b2DistanceInput* input);
/// Input parameters for b2ShapeCast
-struct b2ShapeCastInput
+struct B2_API b2ShapeCastInput
{
b2DistanceProxy proxyA;
b2DistanceProxy proxyB;
@@ -108,7 +109,7 @@ struct b2ShapeCastInput
};
/// Output results for b2ShapeCast
-struct b2ShapeCastOutput
+struct B2_API b2ShapeCastOutput
{
b2Vec2 point;
b2Vec2 normal;
@@ -167,4 +168,7 @@ inline const b2Vec2& b2DistanceProxy::GetSupportVertex(const b2Vec2& d) const
return m_vertices[bestIndex];
}
+/// internal for testbed, do not use
+extern B2_API int32 b2_gjkCalls, b2_gjkIters, b2_gjkMaxIters;
+
#endif
diff --git a/include/box2d/b2_distance_joint.h b/include/box2d/b2_distance_joint.h
index b339e9239..51793fbac 100644
--- a/include/box2d/b2_distance_joint.h
+++ b/include/box2d/b2_distance_joint.h
@@ -23,6 +23,7 @@
#ifndef B2_DISTANCE_JOINT_H
#define B2_DISTANCE_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Distance joint definition. This requires defining an anchor point on both
@@ -30,7 +31,7 @@
/// so that the initial configuration can violate the constraint
/// slightly. This helps when saving and loading a game.
/// @warning Do not use a zero or short length.
-struct b2DistanceJointDef : public b2JointDef
+struct B2_API b2DistanceJointDef : public b2JointDef
{
b2DistanceJointDef()
{
@@ -65,7 +66,7 @@ struct b2DistanceJointDef : public b2JointDef
/// A distance joint constrains two points on two bodies to remain at a fixed
/// distance from each other. You can view this as a massless, rigid rod.
-class b2DistanceJoint : public b2Joint
+class B2_API b2DistanceJoint : public b2Joint
{
public:
diff --git a/include/box2d/b2_draw.h b/include/box2d/b2_draw.h
index 10cbf866f..a4d171187 100644
--- a/include/box2d/b2_draw.h
+++ b/include/box2d/b2_draw.h
@@ -23,10 +23,11 @@
#ifndef B2_DRAW_H
#define B2_DRAW_H
+#include "b2_api.h"
#include "b2_math.h"
/// Color for debug drawing. Each value has the range [0,1].
-struct b2Color
+struct B2_API b2Color
{
b2Color() {}
b2Color(float rIn, float gIn, float bIn, float aIn = 1.0f)
@@ -44,7 +45,7 @@ struct b2Color
/// Implement and register this class with a b2World to provide debug drawing of physics
/// entities in your game.
-class b2Draw
+class B2_API b2Draw
{
public:
b2Draw();
@@ -65,7 +66,7 @@ class b2Draw
/// Get the drawing flags.
uint32 GetFlags() const;
-
+
/// Append flags to the current flags.
void AppendFlags(uint32 flags);
@@ -80,10 +81,10 @@ class b2Draw
/// Draw a circle.
virtual void DrawCircle(const b2Vec2& center, float radius, const b2Color& color) = 0;
-
+
/// Draw a solid circle.
virtual void DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color) = 0;
-
+
/// Draw a line segment.
virtual void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) = 0;
diff --git a/include/box2d/b2_dynamic_tree.h b/include/box2d/b2_dynamic_tree.h
index b3ddb97ca..a3df1175d 100644
--- a/include/box2d/b2_dynamic_tree.h
+++ b/include/box2d/b2_dynamic_tree.h
@@ -23,13 +23,14 @@
#ifndef B2_DYNAMIC_TREE_H
#define B2_DYNAMIC_TREE_H
+#include "b2_api.h"
#include "b2_collision.h"
#include "b2_growable_stack.h"
#define b2_nullNode (-1)
/// A node in the dynamic tree. The client does not interact with this directly.
-struct b2TreeNode
+struct B2_API b2TreeNode
{
bool IsLeaf() const
{
@@ -64,7 +65,7 @@ struct b2TreeNode
/// object to move by small amounts without triggering a tree update.
///
/// Nodes are pooled and relocatable, so we use node indices rather than pointers.
-class b2DynamicTree
+class B2_API b2DynamicTree
{
public:
/// Constructing the tree initializes the node pool.
diff --git a/include/box2d/b2_edge_shape.h b/include/box2d/b2_edge_shape.h
index ed79b43e2..b930ee872 100644
--- a/include/box2d/b2_edge_shape.h
+++ b/include/box2d/b2_edge_shape.h
@@ -23,12 +23,13 @@
#ifndef B2_EDGE_SHAPE_H
#define B2_EDGE_SHAPE_H
+#include "b2_api.h"
#include "b2_shape.h"
/// A line segment (edge) shape. These can be connected in chains or loops
/// to other edge shapes. Edges created independently are two-sided and do
-/// no provide smooth movement across junctions.
-class b2EdgeShape : public b2Shape
+/// no provide smooth movement across junctions.
+class B2_API b2EdgeShape : public b2Shape
{
public:
b2EdgeShape();
@@ -60,7 +61,7 @@ class b2EdgeShape : public b2Shape
/// @see b2Shape::ComputeMass
void ComputeMass(b2MassData* massData, float density) const override;
-
+
/// These are the edge vertices
b2Vec2 m_vertex1, m_vertex2;
diff --git a/include/box2d/b2_fixture.h b/include/box2d/b2_fixture.h
index 4cdde74d8..3c8aa27a1 100644
--- a/include/box2d/b2_fixture.h
+++ b/include/box2d/b2_fixture.h
@@ -23,6 +23,7 @@
#ifndef B2_FIXTURE_H
#define B2_FIXTURE_H
+#include "b2_api.h"
#include "b2_body.h"
#include "b2_collision.h"
#include "b2_shape.h"
@@ -33,7 +34,7 @@ class b2BroadPhase;
class b2Fixture;
/// This holds contact filtering data.
-struct b2Filter
+struct B2_API b2Filter
{
b2Filter()
{
@@ -57,7 +58,7 @@ struct b2Filter
/// A fixture definition is used to create a fixture. This class defines an
/// abstract fixture definition. You can reuse fixture definitions safely.
-struct b2FixtureDef
+struct B2_API b2FixtureDef
{
/// The constructor sets the default fixture definition values.
b2FixtureDef()
@@ -95,7 +96,7 @@ struct b2FixtureDef
};
/// This proxy is used internally to connect fixtures to the broad-phase.
-struct b2FixtureProxy
+struct B2_API b2FixtureProxy
{
b2AABB aabb;
b2Fixture* fixture;
@@ -108,7 +109,7 @@ struct b2FixtureProxy
/// such as friction, collision filters, etc.
/// Fixtures are created via b2Body::CreateFixture.
/// @warning you cannot reuse fixtures.
-class b2Fixture
+class B2_API b2Fixture
{
public:
/// Get the type of the child shape. You can use this to down cast to the concrete shape.
diff --git a/include/box2d/b2_friction_joint.h b/include/box2d/b2_friction_joint.h
index d7b88245e..99922c3a3 100644
--- a/include/box2d/b2_friction_joint.h
+++ b/include/box2d/b2_friction_joint.h
@@ -23,10 +23,11 @@
#ifndef B2_FRICTION_JOINT_H
#define B2_FRICTION_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Friction joint definition.
-struct b2FrictionJointDef : public b2JointDef
+struct B2_API b2FrictionJointDef : public b2JointDef
{
b2FrictionJointDef()
{
@@ -56,7 +57,7 @@ struct b2FrictionJointDef : public b2JointDef
/// Friction joint. This is used for top-down friction.
/// It provides 2D translational friction and angular friction.
-class b2FrictionJoint : public b2Joint
+class B2_API b2FrictionJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
diff --git a/include/box2d/b2_gear_joint.h b/include/box2d/b2_gear_joint.h
index 69e67a199..18237a142 100644
--- a/include/box2d/b2_gear_joint.h
+++ b/include/box2d/b2_gear_joint.h
@@ -27,7 +27,7 @@
/// Gear joint definition. This definition requires two existing
/// revolute or prismatic joints (any combination will work).
-struct b2GearJointDef : public b2JointDef
+struct B2_API b2GearJointDef : public b2JointDef
{
b2GearJointDef()
{
@@ -57,7 +57,7 @@ struct b2GearJointDef : public b2JointDef
/// of length or units of 1/length.
/// @warning You have to manually destroy the gear joint if joint1 or joint2
/// is destroyed.
-class b2GearJoint : public b2Joint
+class B2_API b2GearJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
diff --git a/include/box2d/b2_growable_stack.h b/include/box2d/b2_growable_stack.h
index a24984f0c..ae39db9d5 100644
--- a/include/box2d/b2_growable_stack.h
+++ b/include/box2d/b2_growable_stack.h
@@ -23,8 +23,9 @@
#ifndef B2_GROWABLE_STACK_H
#define B2_GROWABLE_STACK_H
+#include <cstring>
+
#include "b2_settings.h"
-#include <string.h>
/// This is a growable LIFO stack with an initial capacity of N.
/// If the stack size exceeds the initial capacity, the heap is used
@@ -56,7 +57,7 @@ class b2GrowableStack
T* old = m_stack;
m_capacity *= 2;
m_stack = (T*)b2Alloc(m_capacity * sizeof(T));
- memcpy(m_stack, old, m_count * sizeof(T));
+ std::memcpy(m_stack, old, m_count * sizeof(T));
if (old != m_array)
{
b2Free(old);
diff --git a/include/box2d/b2_joint.h b/include/box2d/b2_joint.h
index c33ec90af..73ead3f90 100644
--- a/include/box2d/b2_joint.h
+++ b/include/box2d/b2_joint.h
@@ -23,6 +23,7 @@
#ifndef B2_JOINT_H
#define B2_JOINT_H
+#include "b2_api.h"
#include "b2_math.h"
class b2Body;
@@ -47,7 +48,7 @@ enum b2JointType
e_motorJoint
};
-struct b2Jacobian
+struct B2_API b2Jacobian
{
b2Vec2 linear;
float angularA;
@@ -59,7 +60,7 @@ struct b2Jacobian
/// is an edge. A joint edge belongs to a doubly linked list
/// maintained in each attached body. Each joint has two joint
/// nodes, one for each attached body.
-struct b2JointEdge
+struct B2_API b2JointEdge
{
b2Body* other; ///< provides quick access to the other body attached.
b2Joint* joint; ///< the joint
@@ -68,7 +69,7 @@ struct b2JointEdge
};
/// Joint definitions are used to construct joints.
-struct b2JointDef
+struct B2_API b2JointDef
{
b2JointDef()
{
@@ -96,18 +97,18 @@ struct b2JointDef
};
/// Utility to compute linear stiffness values from frequency and damping ratio
-void b2LinearStiffness(float& stiffness, float& damping,
+B2_API void b2LinearStiffness(float& stiffness, float& damping,
float frequencyHertz, float dampingRatio,
const b2Body* bodyA, const b2Body* bodyB);
/// Utility to compute rotational stiffness values frequency and damping ratio
-void b2AngularStiffness(float& stiffness, float& damping,
+B2_API void b2AngularStiffness(float& stiffness, float& damping,
float frequencyHertz, float dampingRatio,
const b2Body* bodyA, const b2Body* bodyB);
/// The base joint class. Joints are used to constraint two bodies together in
/// various fashions. Some joints also feature limits and motors.
-class b2Joint
+class B2_API b2Joint
{
public:
diff --git a/include/box2d/b2_math.h b/include/box2d/b2_math.h
index afe421ba8..08d130841 100644
--- a/include/box2d/b2_math.h
+++ b/include/box2d/b2_math.h
@@ -23,20 +23,22 @@
#ifndef B2_MATH_H
#define B2_MATH_H
+#include <cmath>
+
+#include "b2_api.h"
#include "b2_settings.h"
-#include <math.h>
/// This function is used to ensure that a floating point number is not a NaN or infinity.
inline bool b2IsValid(float x)
{
- return isfinite(x);
+ return std::isfinite(x);
}
-#define b2Sqrt(x) sqrtf(x)
-#define b2Atan2(y, x) atan2f(y, x)
+#define b2Sqrt(x) std::sqrt(x)
+#define b2Atan2(y, x) std::atan2(y, x)
/// A 2D column vector.
-struct b2Vec2
+struct B2_API b2Vec2
{
/// Default constructor does nothing (for performance).
b2Vec2() {}
@@ -52,7 +54,7 @@ struct b2Vec2
/// Negate this vector.
b2Vec2 operator -() const { b2Vec2 v; v.Set(-x, -y); return v; }
-
+
/// Read from and indexed element.
float operator () (int32 i) const
{
@@ -70,7 +72,7 @@ struct b2Vec2
{
x += v.x; y += v.y;
}
-
+
/// Subtract a vector from this vector.
void operator -= (const b2Vec2& v)
{
@@ -127,7 +129,7 @@ struct b2Vec2
};
/// A 2D column vector with 3 elements.
-struct b2Vec3
+struct B2_API b2Vec3
{
/// Default constructor does nothing (for performance).
b2Vec3() {}
@@ -166,7 +168,7 @@ struct b2Vec3
};
/// A 2-by-2 matrix. Stored in column-major order.
-struct b2Mat22
+struct B2_API b2Mat22
{
/// The default constructor does nothing (for performance).
b2Mat22() {}
@@ -240,7 +242,7 @@ struct b2Mat22
};
/// A 3-by-3 matrix. Stored in column-major order.
-struct b2Mat33
+struct B2_API b2Mat33
{
/// The default constructor does nothing (for performance).
b2Mat33() {}
@@ -282,7 +284,7 @@ struct b2Mat33
};
/// Rotation
-struct b2Rot
+struct B2_API b2Rot
{
b2Rot() {}
@@ -290,16 +292,16 @@ struct b2Rot
explicit b2Rot(float angle)
{
/// TODO_ERIN optimize
- s = sinf(angle);
- c = cosf(angle);
+ s = std::sin(angle);
+ c = std::cos(angle);
}
/// Set using an angle in radians.
void Set(float angle)
{
/// TODO_ERIN optimize
- s = sinf(angle);
- c = cosf(angle);
+ s = std::sin(angle);
+ c = std::cos(angle);
}
/// Set to the identity rotation
@@ -333,7 +335,7 @@ struct b2Rot
/// A transform contains translation and rotation. It is used to represent
/// the position and orientation of rigid frames.
-struct b2Transform
+struct B2_API b2Transform
{
/// The default constructor does nothing.
b2Transform() {}
@@ -363,7 +365,7 @@ struct b2Transform
/// Shapes are defined with respect to the body origin, which may
/// no coincide with the center of mass. However, to support dynamics
/// we must interpolate the center of mass position.
-struct b2Sweep
+struct B2_API b2Sweep
{
/// Get the interpolated transform at a specific time.
/// @param transform the output transform
@@ -387,7 +389,7 @@ struct b2Sweep
};
/// Useful constant
-extern const b2Vec2 b2Vec2_zero;
+extern B2_API const b2Vec2 b2Vec2_zero;
/// Perform the dot product on two vectors.
inline float b2Dot(const b2Vec2& a, const b2Vec2& b)
@@ -704,7 +706,7 @@ inline void b2Sweep::Advance(float alpha)
inline void b2Sweep::Normalize()
{
float twoPi = 2.0f * b2_pi;
- float d = twoPi * floorf(a0 / twoPi);
+ float d = twoPi * std::floor(a0 / twoPi);
a0 -= d;
a -= d;
}
diff --git a/include/box2d/b2_motor_joint.h b/include/box2d/b2_motor_joint.h
index c3f1adcbb..c88115f20 100644
--- a/include/box2d/b2_motor_joint.h
+++ b/include/box2d/b2_motor_joint.h
@@ -23,10 +23,11 @@
#ifndef B2_MOTOR_JOINT_H
#define B2_MOTOR_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Motor joint definition.
-struct b2MotorJointDef : public b2JointDef
+struct B2_API b2MotorJointDef : public b2JointDef
{
b2MotorJointDef()
{
@@ -46,7 +47,7 @@ struct b2MotorJointDef : public b2JointDef
/// The bodyB angle minus bodyA angle in radians.
float angularOffset;
-
+
/// The maximum motor force in N.
float maxForce;
@@ -60,7 +61,7 @@ struct b2MotorJointDef : public b2JointDef
/// A motor joint is used to control the relative motion
/// between two bodies. A typical usage is to control the movement
/// of a dynamic body with respect to the ground.
-class b2MotorJoint : public b2Joint
+class B2_API b2MotorJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
diff --git a/include/box2d/b2_mouse_joint.h b/include/box2d/b2_mouse_joint.h
index ebaa02592..fcbc56a70 100644
--- a/include/box2d/b2_mouse_joint.h
+++ b/include/box2d/b2_mouse_joint.h
@@ -23,11 +23,12 @@
#ifndef B2_MOUSE_JOINT_H
#define B2_MOUSE_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Mouse joint definition. This requires a world target point,
/// tuning parameters, and the time step.
-struct b2MouseJointDef : public b2JointDef
+struct B2_API b2MouseJointDef : public b2JointDef
{
b2MouseJointDef()
{
@@ -61,7 +62,7 @@ struct b2MouseJointDef : public b2JointDef
/// NOTE: this joint is not documented in the manual because it was
/// developed to be used in the testbed. If you want to learn how to
/// use the mouse joint, look at the testbed.
-class b2MouseJoint : public b2Joint
+class B2_API b2MouseJoint : public b2Joint
{
public:
diff --git a/include/box2d/b2_polygon_shape.h b/include/box2d/b2_polygon_shape.h
index 52f4cc0ec..5a4e563f8 100644
--- a/include/box2d/b2_polygon_shape.h
+++ b/include/box2d/b2_polygon_shape.h
@@ -22,13 +22,14 @@
#ifndef B2_POLYGON_SHAPE_H
#define B2_POLYGON_SHAPE_H
+#include "b2_api.h"
#include "b2_shape.h"
/// A solid convex polygon. It is assumed that the interior of the polygon is to
/// the left of each edge.
/// Polygons have a maximum number of vertices equal to b2_maxPolygonVertices.
/// In most cases you should not need many vertices for a convex polygon.
-class b2PolygonShape : public b2Shape
+class B2_API b2PolygonShape : public b2Shape
{
public:
b2PolygonShape();
diff --git a/include/box2d/b2_prismatic_joint.h b/include/box2d/b2_prismatic_joint.h
index 09cbad540..9d12d2126 100644
--- a/include/box2d/b2_prismatic_joint.h
+++ b/include/box2d/b2_prismatic_joint.h
@@ -23,6 +23,7 @@
#ifndef B2_PRISMATIC_JOINT_H
#define B2_PRISMATIC_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Prismatic joint definition. This requires defining a line of
@@ -31,7 +32,7 @@
/// can violate the constraint slightly. The joint translation is zero
/// when the local anchor points coincide in world space. Using local
/// anchors and a local axis helps when saving and loading a game.
-struct b2PrismaticJointDef : public b2JointDef
+struct B2_API b2PrismaticJointDef : public b2JointDef
{
b2PrismaticJointDef()
{
@@ -87,7 +88,7 @@ struct b2PrismaticJointDef : public b2JointDef
/// along an axis fixed in bodyA. Relative rotation is prevented. You can
/// use a joint limit to restrict the range of motion and a joint motor to
/// drive the motion or to model joint friction.
-class b2PrismaticJoint : public b2Joint
+class B2_API b2PrismaticJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
diff --git a/include/box2d/b2_pulley_joint.h b/include/box2d/b2_pulley_joint.h
index 14f12c41f..6b1445641 100644
--- a/include/box2d/b2_pulley_joint.h
+++ b/include/box2d/b2_pulley_joint.h
@@ -23,13 +23,14 @@
#ifndef B2_PULLEY_JOINT_H
#define B2_PULLEY_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
const float b2_minPulleyLength = 2.0f;
/// Pulley joint definition. This requires two ground anchors,
/// two dynamic body anchor points, and a pulley ratio.
-struct b2PulleyJointDef : public b2JointDef
+struct B2_API b2PulleyJointDef : public b2JointDef
{
b2PulleyJointDef()
{
@@ -80,7 +81,7 @@ struct b2PulleyJointDef : public b2JointDef
/// work better when combined with prismatic joints. You should also cover the
/// the anchor points with static shapes to prevent one side from going to
/// zero length.
-class b2PulleyJoint : public b2Joint
+class B2_API b2PulleyJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
@@ -129,7 +130,7 @@ class b2PulleyJoint : public b2Joint
b2Vec2 m_groundAnchorB;
float m_lengthA;
float m_lengthB;
-
+
// Solver shared
b2Vec2 m_localAnchorA;
b2Vec2 m_localAnchorB;
diff --git a/include/box2d/b2_revolute_joint.h b/include/box2d/b2_revolute_joint.h
index f202e3551..36ad5314e 100644
--- a/include/box2d/b2_revolute_joint.h
+++ b/include/box2d/b2_revolute_joint.h
@@ -23,6 +23,7 @@
#ifndef B2_REVOLUTE_JOINT_H
#define B2_REVOLUTE_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Revolute joint definition. This requires defining an anchor point where the
@@ -35,7 +36,7 @@
/// 1. you might not know where the center of mass will be.
/// 2. if you add/remove shapes from a body and recompute the mass,
/// the joints will be broken.
-struct b2RevoluteJointDef : public b2JointDef
+struct B2_API b2RevoluteJointDef : public b2JointDef
{
b2RevoluteJointDef()
{
@@ -90,7 +91,7 @@ struct b2RevoluteJointDef : public b2JointDef
/// a joint limit that specifies a lower and upper angle. You can use a motor
/// to drive the relative rotation about the shared point. A maximum motor torque
/// is provided so that infinite forces are not generated.
-class b2RevoluteJoint : public b2Joint
+class B2_API b2RevoluteJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
@@ -161,7 +162,7 @@ class b2RevoluteJoint : public b2Joint
void Draw(b2Draw* draw) const override;
protected:
-
+
friend class b2Joint;
friend class b2GearJoint;
diff --git a/include/box2d/b2_rope.h b/include/box2d/b2_rope.h
index 5f1cc4073..920e0a454 100644
--- a/include/box2d/b2_rope.h
+++ b/include/box2d/b2_rope.h
@@ -23,6 +23,7 @@
#ifndef B2_ROPE_H
#define B2_ROPE_H
+#include "b2_api.h"
#include "b2_math.h"
class b2Draw;
@@ -45,7 +46,7 @@ enum b2BendingModel
};
///
-struct b2RopeTuning
+struct B2_API b2RopeTuning
{
b2RopeTuning()
{
@@ -75,8 +76,8 @@ struct b2RopeTuning
bool warmStart;
};
-///
-struct b2RopeDef
+///
+struct B2_API b2RopeDef
{
b2RopeDef()
{
@@ -95,8 +96,8 @@ struct b2RopeDef
b2RopeTuning tuning;
};
-///
-class b2Rope
+///
+class B2_API b2Rope
{
public:
b2Rope();
diff --git a/include/box2d/b2_rope_joint.h b/include/box2d/b2_rope_joint.h
index b254b3a22..9d3ead211 100644
--- a/include/box2d/b2_rope_joint.h
+++ b/include/box2d/b2_rope_joint.h
@@ -23,13 +23,14 @@
#ifndef B2_ROPE_JOINT_H
#define B2_ROPE_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Rope joint definition. This requires two body anchor points and
/// a maximum lengths.
/// Note: by default the connected objects will not collide.
/// see collideConnected in b2JointDef.
-struct b2RopeJointDef : public b2JointDef
+struct B2_API b2RopeJointDef : public b2JointDef
{
b2RopeJointDef()
{
@@ -59,7 +60,7 @@ struct b2RopeJointDef : public b2JointDef
/// would have some sponginess, so I chose not to implement it
/// that way. See b2DistanceJoint if you want to dynamically
/// control length.
-class b2RopeJoint : public b2Joint
+class B2_API b2RopeJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
diff --git a/include/box2d/b2_settings.h b/include/box2d/b2_settings.h
index 3b17e12fb..e2f8f2ebe 100644
--- a/include/box2d/b2_settings.h
+++ b/include/box2d/b2_settings.h
@@ -23,9 +23,11 @@
#ifndef B2_SETTINGS_H
#define B2_SETTINGS_H
-#include <stddef.h>
-#include <assert.h>
-#include <float.h>
+#include <cstddef>
+#include <cassert>
+#include <cfloat>
+
+#include "b2_api.h"
#if !defined(NDEBUG)
#define b2DEBUG
@@ -134,22 +136,22 @@ typedef unsigned int uint32;
// Memory Allocation
/// Implement this function to use your own memory allocator.
-void* b2Alloc(int32 size);
+B2_API void* b2Alloc(int32 size);
/// If you implement b2Alloc, you should also implement this function.
-void b2Free(void* mem);
+B2_API void b2Free(void* mem);
/// Logging function.
-void b2Log(const char* string, ...);
+B2_API void b2Log(const char* string, ...);
/// Dump to a file. Only one dump file allowed at a time.
-void b2OpenDump(const char* fileName);
-void b2Dump(const char* string, ...);
-void b2CloseDump();
+B2_API void b2OpenDump(const char* fileName);
+B2_API void b2Dump(const char* string, ...);
+B2_API void b2CloseDump();
/// Version numbering scheme.
/// See http://en.wikipedia.org/wiki/Software_versioning
-struct b2Version
+struct B2_API b2Version
{
int32 major; ///< significant changes
int32 minor; ///< incremental changes
@@ -157,6 +159,6 @@ struct b2Version
};
/// Current version.
-extern b2Version b2_version;
+extern B2_API b2Version b2_version;
#endif
diff --git a/include/box2d/b2_shape.h b/include/box2d/b2_shape.h
index 27e3d14bc..cbed2b863 100644
--- a/include/box2d/b2_shape.h
+++ b/include/box2d/b2_shape.h
@@ -23,13 +23,14 @@
#ifndef B2_SHAPE_H
#define B2_SHAPE_H
+#include "b2_api.h"
#include "b2_math.h"
#include "b2_collision.h"
class b2BlockAllocator;
/// This holds the mass data computed for a shape.
-struct b2MassData
+struct B2_API b2MassData
{
/// The mass of the shape, usually in kilograms.
float mass;
@@ -44,10 +45,10 @@ struct b2MassData
/// A shape is used for collision detection. You can create a shape however you like.
/// Shapes used for simulation in b2World are created automatically when a b2Fixture
/// is created. Shapes may encapsulate a one or more child shapes.
-class b2Shape
+class B2_API b2Shape
{
public:
-
+
enum Type
{
e_circle = 0,
diff --git a/include/box2d/b2_stack_allocator.h b/include/box2d/b2_stack_allocator.h
index 780ab7945..1db2af5d9 100644
--- a/include/box2d/b2_stack_allocator.h
+++ b/include/box2d/b2_stack_allocator.h
@@ -23,12 +23,13 @@
#ifndef B2_STACK_ALLOCATOR_H
#define B2_STACK_ALLOCATOR_H
+#include "b2_api.h"
#include "b2_settings.h"
const int32 b2_stackSize = 100 * 1024; // 100k
const int32 b2_maxStackEntries = 32;
-struct b2StackEntry
+struct B2_API b2StackEntry
{
char* data;
int32 size;
@@ -38,7 +39,7 @@ struct b2StackEntry
// This is a stack allocator used for fast per step allocations.
// You must nest allocate/free pairs. The code will assert
// if you try to interleave multiple allocate/free pairs.
-class b2StackAllocator
+class B2_API b2StackAllocator
{
public:
b2StackAllocator();
diff --git a/include/box2d/b2_time_of_impact.h b/include/box2d/b2_time_of_impact.h
index bb3031fcb..14d4b7a90 100644
--- a/include/box2d/b2_time_of_impact.h
+++ b/include/box2d/b2_time_of_impact.h
@@ -23,11 +23,12 @@
#ifndef B2_TIME_OF_IMPACT_H
#define B2_TIME_OF_IMPACT_H
+#include "b2_api.h"
#include "b2_math.h"
#include "b2_distance.h"
/// Input parameters for b2TimeOfImpact
-struct b2TOIInput
+struct B2_API b2TOIInput
{
b2DistanceProxy proxyA;
b2DistanceProxy proxyB;
@@ -37,7 +38,7 @@ struct b2TOIInput
};
/// Output parameters for b2TimeOfImpact.
-struct b2TOIOutput
+struct B2_API b2TOIOutput
{
enum State
{
@@ -57,6 +58,13 @@ struct b2TOIOutput
/// non-tunneling collisions. If you change the time interval, you should call this function
/// again.
/// Note: use b2Distance to compute the contact point and normal at the time of impact.
-void b2TimeOfImpact(b2TOIOutput* output, const b2TOIInput* input);
+B2_API void b2TimeOfImpact(b2TOIOutput* output, const b2TOIInput* input);
+
+/// internal for testbed, do not use
+extern B2_API int32 b2_toiCalls, b2_toiIters, b2_toiMaxIters;
+/// internal for testbed, do not use
+extern B2_API int32 b2_toiRootIters, b2_toiMaxRootIters;
+/// internal for testbed, do not use
+extern B2_API float b2_toiTime, b2_toiMaxTime;
#endif
diff --git a/include/box2d/b2_time_step.h b/include/box2d/b2_time_step.h
index f0304a300..13d6292ec 100644
--- a/include/box2d/b2_time_step.h
+++ b/include/box2d/b2_time_step.h
@@ -22,10 +22,11 @@
#ifndef B2_TIME_STEP_H
#define B2_TIME_STEP_H
+#include "b2_api.h"
#include "b2_math.h"
/// Profiling data. Times are in milliseconds.
-struct b2Profile
+struct B2_API b2Profile
{
float step;
float collide;
@@ -38,7 +39,7 @@ struct b2Profile
};
/// This is an internal structure.
-struct b2TimeStep
+struct B2_API b2TimeStep
{
float dt; // time step
float inv_dt; // inverse time step (0 if dt == 0).
@@ -49,21 +50,21 @@ struct b2TimeStep
};
/// This is an internal structure.
-struct b2Position
+struct B2_API b2Position
{
b2Vec2 c;
float a;
};
/// This is an internal structure.
-struct b2Velocity
+struct B2_API b2Velocity
{
b2Vec2 v;
float w;
};
/// Solver Data
-struct b2SolverData
+struct B2_API b2SolverData
{
b2TimeStep step;
b2Position* positions;
diff --git a/include/box2d/b2_timer.h b/include/box2d/b2_timer.h
index a664de833..7893c3270 100644
--- a/include/box2d/b2_timer.h
+++ b/include/box2d/b2_timer.h
@@ -23,11 +23,12 @@
#ifndef B2_TIMER_H
#define B2_TIMER_H
+#include "b2_api.h"
#include "b2_settings.h"
/// Timer for profiling. This has platform specific code and may
/// not work on every platform.
-class b2Timer
+class B2_API b2Timer
{
public:
diff --git a/include/box2d/b2_weld_joint.h b/include/box2d/b2_weld_joint.h
index fd5537f34..f226c8a46 100644
--- a/include/box2d/b2_weld_joint.h
+++ b/include/box2d/b2_weld_joint.h
@@ -23,12 +23,13 @@
#ifndef B2_WELD_JOINT_H
#define B2_WELD_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Weld joint definition. You need to specify local anchor points
/// where they are attached and the relative body angle. The position
/// of the anchor points is important for computing the reaction torque.
-struct b2WeldJointDef : public b2JointDef
+struct B2_API b2WeldJointDef : public b2JointDef
{
b2WeldJointDef()
{
@@ -54,7 +55,7 @@ struct b2WeldJointDef : public b2JointDef
/// The bodyB angle minus bodyA angle in the reference state (radians).
float referenceAngle;
-
+
/// The rotational stiffness in N*m
/// Disable softness with a value of 0
float stiffness;
@@ -65,7 +66,7 @@ struct b2WeldJointDef : public b2JointDef
/// A weld joint essentially glues two bodies together. A weld joint may
/// distort somewhat because the island constraint solver is approximate.
-class b2WeldJoint : public b2Joint
+class B2_API b2WeldJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
diff --git a/include/box2d/b2_wheel_joint.h b/include/box2d/b2_wheel_joint.h
index 1b8f43739..8576adbd2 100644
--- a/include/box2d/b2_wheel_joint.h
+++ b/include/box2d/b2_wheel_joint.h
@@ -23,6 +23,7 @@
#ifndef B2_WHEEL_JOINT_H
#define B2_WHEEL_JOINT_H
+#include "b2_api.h"
#include "b2_joint.h"
/// Wheel joint definition. This requires defining a line of
@@ -31,7 +32,7 @@
/// can violate the constraint slightly. The joint translation is zero
/// when the local anchor points coincide in world space. Using local
/// anchors and a local axis helps when saving and loading a game.
-struct b2WheelJointDef : public b2JointDef
+struct B2_API b2WheelJointDef : public b2JointDef
{
b2WheelJointDef()
{
@@ -91,7 +92,7 @@ struct b2WheelJointDef : public b2JointDef
/// along an axis fixed in bodyA and rotation in the plane. In other words, it is a point to
/// line constraint with a rotational motor and a linear spring/damper. The spring/damper is
/// initialized upon creation. This joint is designed for vehicle suspensions.
-class b2WheelJoint : public b2Joint
+class B2_API b2WheelJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const override;
diff --git a/include/box2d/b2_world.h b/include/box2d/b2_world.h
index 3ddc136e3..57d37096c 100644
--- a/include/box2d/b2_world.h
+++ b/include/box2d/b2_world.h
@@ -23,6 +23,7 @@
#ifndef B2_WORLD_H
#define B2_WORLD_H
+#include "b2_api.h"
#include "b2_block_allocator.h"
#include "b2_contact_manager.h"
#include "b2_math.h"
@@ -42,7 +43,7 @@ class b2Joint;
/// The world class manages all physics entities, dynamic simulation,
/// and asynchronous queries. The world also contains efficient memory
/// management facilities.
-class b2World
+class B2_API b2World
{
public:
/// Construct a world object.
@@ -58,7 +59,7 @@ class b2World
/// Register a contact filter to provide specific control over collision.
/// Otherwise the default filter is used (b2_defaultFilter). The listener is
- /// owned by you and must remain in scope.
+ /// owned by you and must remain in scope.
void SetContactFilter(b2ContactFilter* filter);
/// Register a contact event listener. The listener is owned by you and must
@@ -185,7 +186,7 @@ class b2World
/// Change the global gravity vector.
void SetGravity(const b2Vec2& gravity);
-
+
/// Get the global gravity vector.
b2Vec2 GetGravity() const;
diff --git a/include/box2d/b2_world_callbacks.h b/include/box2d/b2_world_callbacks.h
index e1e75c9e9..da45640e2 100644
--- a/include/box2d/b2_world_callbacks.h
+++ b/include/box2d/b2_world_callbacks.h
@@ -23,6 +23,7 @@
#ifndef B2_WORLD_CALLBACKS_H
#define B2_WORLD_CALLBACKS_H
+#include "b2_api.h"
#include "b2_settings.h"
struct b2Vec2;
@@ -37,7 +38,7 @@ struct b2Manifold;
/// Joints and fixtures are destroyed when their associated
/// body is destroyed. Implement this listener so that you
/// may nullify references to these joints and shapes.
-class b2DestructionListener
+class B2_API b2DestructionListener
{
public:
virtual ~b2DestructionListener() {}
@@ -53,7 +54,7 @@ class b2DestructionListener
/// Implement this class to provide collision filtering. In other words, you can implement
/// this class if you want finer control over contact creation.
-class b2ContactFilter
+class B2_API b2ContactFilter
{
public:
virtual ~b2ContactFilter() {}
@@ -66,7 +67,7 @@ class b2ContactFilter
/// Contact impulses for reporting. Impulses are used instead of forces because
/// sub-step forces may approach infinity for rigid body collisions. These
/// match up one-to-one with the contact points in b2Manifold.
-struct b2ContactImpulse
+struct B2_API b2ContactImpulse
{
float normalImpulses[b2_maxManifoldPoints];
float tangentImpulses[b2_maxManifoldPoints];
@@ -82,7 +83,7 @@ struct b2ContactImpulse
/// You should strive to make your callbacks efficient because there may be
/// many callbacks per time step.
/// @warning You cannot create/destroy Box2D entities inside these callbacks.
-class b2ContactListener
+class B2_API b2ContactListener
{
public:
virtual ~b2ContactListener() {}
@@ -124,7 +125,7 @@ class b2ContactListener
/// Callback class for AABB queries.
/// See b2World::Query
-class b2QueryCallback
+class B2_API b2QueryCallback
{
public:
virtual ~b2QueryCallback() {}
@@ -136,7 +137,7 @@ class b2QueryCallback
/// Callback class for ray casts.
/// See b2World::RayCast
-class b2RayCastCallback
+class B2_API b2RayCastCallback
{
public:
virtual ~b2RayCastCallback() {}
--- a/include/box2d/b2_distance.h~ 2020-08-10 09:42:32.000000000 -0500
+++ b/include/box2d/b2_distance.h 2020-08-10 09:44:56.966717299 -0500
@@ -118,7 +118,7 @@
};
/// Perform a linear shape cast of shape B moving and shape A fixed. Determines the hit point, normal, and translation fraction.
-bool b2ShapeCast(b2ShapeCastOutput* output, const b2ShapeCastInput* input);
+B2_API bool b2ShapeCast(b2ShapeCastOutput* output, const b2ShapeCastInput* input);
//////////////////////////////////////////////////////////////////////////
Reference in new issue View Git Blame Copy Permalink