mirror of
https://github.com/Ed94/Odin.git
synced 2026-06-13 01:21:38 -07:00
gingerBill
1202 lines
50 KiB
Odin
1202 lines
50 KiB
Odin
package vendor_box2d
|
|
|
|
foreign import lib {
|
|
"box2d.lib", // dummy
|
|
}
|
|
|
|
import "core:c"
|
|
|
|
|
|
// Prototype for user allocation function
|
|
// @param size the allocation size in bytes
|
|
// @param alignment the required alignment, guaranteed to be a power of 2
|
|
AllocFcn :: #type proc "c" (size: u32, alignment: i32) -> rawptr
|
|
|
|
// Prototype for user free function
|
|
// @param mem the memory previously allocated through `b2AllocFcn`
|
|
FreeFcn :: #type proc "c" (mem: rawptr)
|
|
|
|
// Prototype for the user assert callback. Return 0 to skip the debugger break.
|
|
AssertFcn :: #type proc "c" (condition, file_name: cstring, line_number: i32) -> i32
|
|
|
|
// Version numbering scheme.
|
|
//
|
|
// See https://semver.org/
|
|
Version :: struct {
|
|
major: i32, // Significant changes
|
|
minor: i32, // Incremental changes
|
|
revision: i32, // Bug fixes
|
|
}
|
|
|
|
when ODIN_OS == .Windows {
|
|
// Timer for profiling. This has platform specific code and may
|
|
// not work on every platform.
|
|
Timer :: struct {
|
|
start: i64,
|
|
}
|
|
} else when ODIN_OS == .Linux || ODIN_OS == .Darwin {
|
|
// Timer for profiling. This has platform specific code and may
|
|
// not work on every platform.
|
|
Timer :: struct {
|
|
start_sec: u64,
|
|
start_usec: u64,
|
|
}
|
|
} else {
|
|
// Timer for profiling. This has platform specific code and may
|
|
// not work on every platform.
|
|
Timer :: struct {
|
|
dummy: i32,
|
|
}
|
|
}
|
|
|
|
@(link_prefix="b2", default_calling_convention="c")
|
|
foreign lib {
|
|
// This allows the user to override the allocation functions. These should be
|
|
// set during application startup.
|
|
SetAllocator :: proc(allocFcn: AllocFcn, freefcn: FreeFcn) ---
|
|
// @return the total bytes allocated by Box2D
|
|
GetByteCount :: proc() -> c.int ---
|
|
// Override the default assert callback
|
|
// @param assertFcn a non-null assert callback
|
|
SetAssertFcn :: proc(assertfcn: AssertFcn) ---
|
|
|
|
|
|
CreateTimer :: proc() -> Timer ---
|
|
GetTicks :: proc(timer: ^Timer) -> i64 ---
|
|
GetMilliseconds :: proc(#by_ptr timer: Timer) -> f32 ---
|
|
GetMillisecondsAndReset :: proc(timer: ^Timer) -> f32 ---
|
|
SleepMilliseconds :: proc(milliseconds: c.int) ---
|
|
Yield :: proc() ---
|
|
|
|
|
|
// Box2D bases all length units on meters, but you may need different units for your game.
|
|
// You can set this value to use different units. This should be done at application startup
|
|
// and only modified once. Default value is 1.
|
|
// @warning This must be modified before any calls to Box2D
|
|
SetLengthUnitsPerMeter :: proc(lengthUnits: f32) ---
|
|
|
|
// Get the current length units per meter.
|
|
GetLengthUnitsPerMeter :: proc() -> f32 ---
|
|
}
|
|
|
|
@(link_prefix="b2", default_calling_convention="c")
|
|
foreign lib {
|
|
// Use this to initialize your world definition
|
|
// @ingroup world
|
|
DefaultWorldDef :: proc() -> WorldDef ---
|
|
|
|
// Use this to initialize your body definition
|
|
// @ingroup body
|
|
DefaultBodyDef :: proc() -> BodyDef ---
|
|
|
|
// Use this to initialize your filter
|
|
// @ingroup shape
|
|
DefaultFilter :: proc() -> Filter ---
|
|
|
|
// Use this to initialize your query filter
|
|
// @ingroup shape
|
|
DefaultQueryFilter :: proc() -> QueryFilter ---
|
|
|
|
// Use this to initialize your shape definition
|
|
// @ingroup shape
|
|
DefaultShapeDef :: proc() -> ShapeDef ---
|
|
|
|
// Use this to initialize your chain definition
|
|
// @ingroup shape
|
|
DefaultChainDef :: proc() -> ChainDef ---
|
|
|
|
// Use this to initialize your joint definition
|
|
// @ingroup distance_joint
|
|
DefaultDistanceJointDef :: proc() -> DistanceJointDef ---
|
|
|
|
// Use this to initialize your joint definition
|
|
// @ingroup motor_joint
|
|
DefaultMotorJointDef :: proc() -> MotorJointDef ---
|
|
|
|
// Use this to initialize your joint definition
|
|
// @ingroup mouse_joint
|
|
DefaultMouseJointDef :: proc() -> MouseJointDef ---
|
|
|
|
// Use this to initialize your joint definition
|
|
// @ingroupd prismatic_joint
|
|
DefaultPrismaticJointDef :: proc() -> PrismaticJointDef ---
|
|
|
|
// Use this to initialize your joint definition.
|
|
// @ingroup revolute_joint
|
|
DefaultRevoluteJointDef :: proc() -> RevoluteJointDef ---
|
|
|
|
// Use this to initialize your joint definition
|
|
// @ingroup weld_joint
|
|
DefaultWeldJointDef :: proc() -> WeldJointDef ---
|
|
|
|
// Use this to initialize your joint definition
|
|
// @ingroup wheel_joint
|
|
DefaultWheelJointDef :: proc() -> WheelJointDef ---
|
|
}
|
|
|
|
|
|
|
|
@(link_prefix="b2", default_calling_convention="c")
|
|
foreign lib {
|
|
|
|
/**
|
|
* @defgroup world World
|
|
* These functions allow you to create a simulation world.
|
|
*
|
|
* You can add rigid bodies and joint constraints to the world and run the simulation. You can get contact
|
|
* information to get contact points and normals as well as events. You can query to world, checking for overlaps and casting rays
|
|
* or shapes. There is also debugging information such as debug draw, timing information, and counters. You can find documentation
|
|
* here: https://box2d.org/
|
|
*/
|
|
|
|
/// Create a world for rigid body simulation. A world contains bodies, shapes, and constraints. You make create
|
|
/// up to 128 worlds. Each world is completely independent and may be simulated in parallel.
|
|
/// @return the world id.
|
|
CreateWorld :: proc(#by_ptr def: WorldDef) -> WorldId ---
|
|
|
|
/// Destroy a world
|
|
DestroyWorld :: proc(worldId: WorldId) ---
|
|
|
|
/// World id validation. Provides validation for up to 64K allocations.
|
|
World_IsValid :: proc(id: WorldId) -> bool ---
|
|
|
|
/// Simulate a world for one time step. This performs collision detection, integration, and constraint solution.
|
|
/// @param worldId The world to simulate
|
|
/// @param timeStep The amount of time to simulate, this should be a fixed number. Typically 1/60.
|
|
/// @param subStepCount The number of sub-steps, increasing the sub-step count can increase accuracy. Typically 4.
|
|
World_Step :: proc(worldId: WorldId, timeStep: f32 , subStepCount: c.int) ---
|
|
|
|
/// Call this to draw shapes and other debug draw data
|
|
World_Draw :: proc(worldId: WorldId, draw: DebugDraw) ---
|
|
|
|
/// Get the body events for the current time step. The event data is transient. Do not store a reference to this data.
|
|
World_GetBodyEvents :: proc(worldId: WorldId) -> BodyEvents ---
|
|
|
|
/// Get sensor events for the current time step. The event data is transient. Do not store a reference to this data.
|
|
World_GetSensorEvents :: proc(worldId: WorldId) -> SensorEvents ---
|
|
|
|
/// Get contact events for this current time step. The event data is transient. Do not store a reference to this data.
|
|
World_GetContactEvents :: proc(worldId: WorldId) -> ContactEvents ---
|
|
|
|
/// Overlap test for all shapes that *potentially* overlap the provided AABB
|
|
World_OverlapAABB :: proc(worldId: WorldId, aabb: AABB, filter: QueryFilter, fcn: OverlapResultFcn, ctx: rawptr) ---
|
|
|
|
/// Overlap test for for all shapes that overlap the provided circle
|
|
World_OverlapCircle :: proc(worldId: WorldId, #by_ptr circle: Circle, transform: Transform, filter: QueryFilter, fcn: OverlapResultFcn, ctx: rawptr) ---
|
|
|
|
/// Overlap test for all shapes that overlap the provided capsule
|
|
World_OverlapCapsule :: proc(worldId: WorldId, #by_ptr capsule: Capsule, transform: Transform, filter: QueryFilter, fcn: OverlapResultFcn, ctx: rawptr) ---
|
|
|
|
/// Overlap test for all shapes that overlap the provided polygon
|
|
World_OverlapPolygon :: proc(worldId: WorldId, #by_ptr polygon: Polygon, transform: Transform, filter: QueryFilter, fcn: OverlapResultFcn, ctx: rawptr) ---
|
|
|
|
/// Cast a ray into the world to collect shapes in the path of the ray.
|
|
/// Your callback function controls whether you get the closest point, any point, or n-points.
|
|
/// The ray-cast ignores shapes that contain the starting point.
|
|
/// @param worldId The world to cast the ray against
|
|
/// @param origin The start point of the ray
|
|
/// @param translation The translation of the ray from the start point to the end point
|
|
/// @param filter Contains bit flags to filter unwanted shapes from the results
|
|
/// @param fcn A user implemented callback function
|
|
/// @param context A user context that is passed along to the callback function
|
|
/// @note The callback function may receive shapes in any order
|
|
World_CastRay :: proc(worldId: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, ctx: rawptr) ---
|
|
|
|
/// Cast a ray into the world to collect the closest hit. This is a convenience function.
|
|
/// This is less general than b2World_CastRay() and does not allow for custom filtering.
|
|
World_CastRayClosest :: proc(worldId: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter) -> RayResult ---
|
|
|
|
/// Cast a circle through the world. Similar to a cast ray except that a circle is cast instead of a point.
|
|
World_CastCircle :: proc(worldId: WorldId, #by_ptr circle: Circle, originTransform: Transform, translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, ctx: rawptr) ---
|
|
|
|
/// Cast a capsule through the world. Similar to a cast ray except that a capsule is cast instead of a point.
|
|
World_CastCapsule :: proc(worldId: WorldId, #by_ptr capsule: Capsule, originTransform: Transform, translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, ctx: rawptr) ---
|
|
|
|
/// Cast a polygon through the world. Similar to a cast ray except that a polygon is cast instead of a point.
|
|
World_CastPolygon :: proc(worldId: WorldId, #by_ptr polygon: Polygon, originTransform: Transform, translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, ctx: rawptr) ---
|
|
|
|
/// Enable/disable sleep. If your application does not need sleeping, you can gain some performance
|
|
/// by disabling sleep completely at the world level.
|
|
/// @see WorldDef
|
|
World_EnableSleeping :: proc(worldId: WorldId, flag: bool) ---
|
|
|
|
/// Enable/disable continuous collision between dynamic and static bodies. Generally you should keep continuous
|
|
/// collision enabled to prevent fast moving objects from going through static objects. The performance gain from
|
|
/// disabling continuous collision is minor.
|
|
/// @see WorldDef
|
|
World_EnableContinuous :: proc(worldId: WorldId, flag: bool) ---
|
|
|
|
/// Adjust the restitution threshold. It is recommended not to make this value very small
|
|
/// because it will prevent bodies from sleeping. Typically in meters per second.
|
|
/// @see WorldDef
|
|
World_SetRestitutionThreshold :: proc(worldId: WorldId, value: f32) ---
|
|
|
|
/// Adjust the hit event threshold. This controls the collision velocity needed to generate a b2ContactHitEvent.
|
|
/// Typically in meters per second.
|
|
/// @see WorldDef::hitEventThreshold
|
|
World_SetHitEventThreshold :: proc(worldId: WorldId, value: f32) ---
|
|
|
|
/// Register the custom filter callback. This is optional.
|
|
World_SetCustomFilterCallback :: proc(worldId: WorldId, fcn: CustomFilterFcn, ctx: rawptr) ---
|
|
|
|
/// Register the pre-solve callback. This is optional.
|
|
World_SetPreSolveCallback :: proc(worldId: WorldId, fcn: PreSolveFcn, ctx: rawptr) ---
|
|
|
|
/// Set the gravity vector for the entire world. Box2D has no concept of an up direction and this
|
|
/// is left as a decision for the application. Typically in m/s^2.
|
|
/// @see WorldDef
|
|
World_SetGravity :: proc(worldId: WorldId, gravity: Vec2) ---
|
|
|
|
/// Get the gravity vector
|
|
World_GetGravity :: proc(worldId: WorldId) -> Vec2 ---
|
|
|
|
/// Apply a radial explosion
|
|
/// @param worldId The world id
|
|
/// @param position The center of the explosion
|
|
/// @param radius The radius of the explosion
|
|
/// @param impulse The impulse of the explosion, typically in kg * m / s or N * s.
|
|
World_Explode :: proc(worldId: WorldId, position: Vec2, radius: f32, impulse: f32) ---
|
|
|
|
/// Adjust contact tuning parameters
|
|
/// @param worldId The world id
|
|
/// @param hertz The contact stiffness (cycles per second)
|
|
/// @param dampingRatio The contact bounciness with 1 being critical damping (non-dimensional)
|
|
/// @param pushVelocity The maximum contact constraint push out velocity (meters per second)
|
|
/// @note Advanced feature
|
|
World_SetContactTuning :: proc(worldId: WorldId, hertz: f32, dampingRatio: f32, pushVelocity: f32) ---
|
|
|
|
/// Enable/disable constraint warm starting. Advanced feature for testing. Disabling
|
|
/// sleeping greatly reduces stability and provides no performance gain.
|
|
World_EnableWarmStarting :: proc(worldId: WorldId, flag: bool) ---
|
|
|
|
/// Get the current world performance profile
|
|
World_GetProfile :: proc(worldId: WorldId) -> Profile ---
|
|
|
|
/// Get world counters and sizes
|
|
World_GetCounters :: proc(worldId: WorldId) -> Counters ---
|
|
|
|
/// Dump memory stats to box2d_memory.txt
|
|
World_DumpMemoryStats :: proc(worldId: WorldId) ---
|
|
|
|
/**
|
|
* @defgroup body Body
|
|
* This is the body API.
|
|
*/
|
|
|
|
/// Create a rigid body given a definition. No reference to the definition is retained. So you can create the definition
|
|
/// on the stack and pass it as a pointer.
|
|
/// @code{.c}
|
|
/// BodyDef bodyDef = b2DefaultBodyDef();
|
|
/// BodyId myBodyId = b2CreateBody(myWorldId, &bodyDef);
|
|
/// @endcode
|
|
/// @warning This function is locked during callbacks.
|
|
CreateBody :: proc(worldId: WorldId, #by_ptr def: BodyDef) -> BodyId ---
|
|
|
|
/// Destroy a rigid body given an id. This destroys all shapes and joints attached to the body.
|
|
/// Do not keep references to the associated shapes and joints.
|
|
DestroyBody :: proc(bodyId: BodyId) ---
|
|
|
|
/// Body identifier validation. Can be used to detect orphaned ids. Provides validation for up to 64K allocations.
|
|
Body_IsValid :: proc(id: BodyId) -> bool ---
|
|
|
|
/// Get the body type: static, kinematic, or dynamic
|
|
Body_GetType :: proc(bodyId: BodyId) -> BodyType ---
|
|
|
|
/// Change the body type. This is an expensive operation. This automatically updates the mass
|
|
/// properties regardless of the automatic mass setting.
|
|
Body_SetType :: proc(bodyId: BodyId, type: BodyType) ---
|
|
|
|
/// Set the user data for a body
|
|
Body_SetUserData :: proc(bodyId: BodyId, userData: rawptr) ---
|
|
|
|
/// Get the user data stored in a body
|
|
Body_GetUserData :: proc(bodyId: BodyId) -> rawptr ---
|
|
|
|
/// Get the world position of a body. This is the location of the body origin.
|
|
Body_GetPosition :: proc(bodyId: BodyId) -> Vec2 ---
|
|
|
|
/// Get the world rotation of a body as a cosine/sine pair (complex number)
|
|
Body_GetRotation :: proc(bodyId: BodyId) -> Rot ---
|
|
|
|
/// Get the world transform of a body.
|
|
Body_GetTransform :: proc(bodyId: BodyId) -> Transform ---
|
|
|
|
/// Set the world transform of a body. This acts as a teleport and is fairly expensive.
|
|
/// @note Generally you should create a body with then intended transform.
|
|
/// @see BodyDef::position and BodyDef::angle
|
|
Body_SetTransform :: proc(bodyId: BodyId, position: Vec2, rotation: Rot) ---
|
|
|
|
/// Get a local point on a body given a world point
|
|
Body_GetLocalPoint :: proc(bodyId: BodyId, worldPoint: Vec2) -> Vec2 ---
|
|
|
|
/// Get a world point on a body given a local point
|
|
Body_GetWorldPoint :: proc(bodyId: BodyId, localPoint: Vec2) -> Vec2 ---
|
|
|
|
/// Get a local vector on a body given a world vector
|
|
Body_GetLocalVector :: proc(bodyId: BodyId, worldVector: Vec2) -> Vec2 ---
|
|
|
|
/// Get a world vector on a body given a local vector
|
|
Body_GetWorldVector :: proc(bodyId: BodyId, localVector: Vec2) -> Vec2 ---
|
|
|
|
/// Get the linear velocity of a body's center of mass. Typically in meters per second.
|
|
Body_GetLinearVelocity :: proc(bodyId: BodyId) -> Vec2 ---
|
|
|
|
/// Get the angular velocity of a body in radians per second
|
|
Body_GetAngularVelocity :: proc(bodyId: BodyId) -> f32 ---
|
|
|
|
/// Set the linear velocity of a body. Typically in meters per second.
|
|
Body_SetLinearVelocity :: proc(bodyId: BodyId, linearVelocity: Vec2) ---
|
|
|
|
/// Set the angular velocity of a body in radians per second
|
|
Body_SetAngularVelocity :: proc(bodyId: BodyId, angularVelocity: f32) ---
|
|
|
|
/// Apply a force at a world point. If the force is not applied at the center of mass,
|
|
/// it will generate a torque and affect the angular velocity. This optionally wakes up the body.
|
|
/// The force is ignored if the body is not awake.
|
|
/// @param bodyId The body id
|
|
/// @param force The world force vector, typically in newtons (N)
|
|
/// @param point The world position of the point of application
|
|
/// @param wake Option to wake up the body
|
|
Body_ApplyForce :: proc(bodyId: BodyId, force: Vec2, point: Vec2, wake: bool) ---
|
|
|
|
/// Apply a force to the center of mass. This optionally wakes up the body.
|
|
/// The force is ignored if the body is not awake.
|
|
/// @param bodyId The body id
|
|
/// @param force the world force vector, usually in newtons (N).
|
|
/// @param wake also wake up the body
|
|
Body_ApplyForceToCenter :: proc(bodyId: BodyId, force: Vec2, wake: bool) ---
|
|
|
|
/// Apply a torque. This affects the angular velocity without affecting the linear velocity.
|
|
/// This optionally wakes the body. The torque is ignored if the body is not awake.
|
|
/// @param bodyId The body id
|
|
/// @param torque about the z-axis (out of the screen), typically in N*m.
|
|
/// @param wake also wake up the body
|
|
Body_ApplyTorque :: proc(bodyId: BodyId, torque: f32, wake: bool) ---
|
|
|
|
/// Apply an impulse at a point. This immediately modifies the velocity.
|
|
/// It also modifies the angular velocity if the point of application
|
|
/// is not at the center of mass. This optionally wakes the body.
|
|
/// The impulse is ignored if the body is not awake.
|
|
/// @param bodyId The body id
|
|
/// @param impulse the world impulse vector, typically in N*s or kg*m/s.
|
|
/// @param point the world position of the point of application.
|
|
/// @param wake also wake up the body
|
|
/// @warning This should be used for one-shot impulses. If you need a steady force,
|
|
/// use a force instead, which will work better with the sub-stepping solver.
|
|
Body_ApplyLinearImpulse :: proc(bodyId: BodyId, impulse: Vec2, point: Vec2, wake: bool) ---
|
|
|
|
/// Apply an impulse to the center of mass. This immediately modifies the velocity.
|
|
/// The impulse is ignored if the body is not awake. This optionally wakes the body.
|
|
/// @param bodyId The body id
|
|
/// @param impulse the world impulse vector, typically in N*s or kg*m/s.
|
|
/// @param wake also wake up the body
|
|
/// @warning This should be used for one-shot impulses. If you need a steady force,
|
|
/// use a force instead, which will work better with the sub-stepping solver.
|
|
Body_ApplyLinearImpulseToCenter :: proc(bodyId: BodyId, impulse: Vec2, wake: bool) ---
|
|
|
|
/// Apply an angular impulse. The impulse is ignored if the body is not awake.
|
|
/// This optionally wakes the body.
|
|
/// @param bodyId The body id
|
|
/// @param impulse the angular impulse, typically in units of kg*m*m/s
|
|
/// @param wake also wake up the body
|
|
/// @warning This should be used for one-shot impulses. If you need a steady force,
|
|
/// use a force instead, which will work better with the sub-stepping solver.
|
|
Body_ApplyAngularImpulse :: proc(bodyId: BodyId, impulse: f32, wake: bool) ---
|
|
|
|
/// Get the mass of the body, typically in kilograms
|
|
Body_GetMass :: proc(bodyId: BodyId) -> f32 ---
|
|
|
|
/// Get the inertia tensor of the body, typically in kg*m^2
|
|
Body_GetInertiaTensor :: proc(bodyId: BodyId) -> f32 ---
|
|
|
|
/// Get the center of mass position of the body in local space
|
|
Body_GetLocalCenterOfMass :: proc(bodyId: BodyId) -> Vec2 ---
|
|
|
|
/// Get the center of mass position of the body in world space
|
|
Body_GetWorldCenterOfMass :: proc(bodyId: BodyId) -> Vec2 ---
|
|
|
|
/// Override the body's mass properties. Normally this is computed automatically using the
|
|
/// shape geometry and density. This information is lost if a shape is added or removed or if the
|
|
/// body type changes.
|
|
Body_SetMassData :: proc(bodyId: BodyId, massData: MassData) ---
|
|
|
|
/// Get the mass data for a body
|
|
Body_GetMassData :: proc(bodyId: BodyId) -> MassData ---
|
|
|
|
/// This update the mass properties to the sum of the mass properties of the shapes.
|
|
/// This normally does not need to be called unless you called SetMassData to override
|
|
/// the mass and you later want to reset the mass.
|
|
/// You may also use this when automatic mass computation has been disabled.
|
|
/// You should call this regardless of body type.
|
|
Body_ApplyMassFromShapes :: proc(bodyId: BodyId) ---
|
|
|
|
/// Set the automatic mass setting. Normally this is set in BodyDef before creation.
|
|
/// @see BodyDef::automaticMass
|
|
Body_SetAutomaticMass :: proc(bodyId: BodyId, automaticMass: bool ) ---
|
|
|
|
/// Get the automatic mass setting
|
|
Body_GetAutomaticMass :: proc(bodyId: BodyId) -> bool ---
|
|
|
|
/// Adjust the linear damping. Normally this is set in BodyDef before creation.
|
|
Body_SetLinearDamping :: proc(bodyId: BodyId, linearDamping: f32) ---
|
|
|
|
/// Get the current linear damping.
|
|
Body_GetLinearDamping :: proc(bodyId: BodyId) -> f32 ---
|
|
|
|
/// Adjust the angular damping. Normally this is set in BodyDef before creation.
|
|
Body_SetAngularDamping :: proc(bodyId: BodyId, angularDamping: f32) ---
|
|
|
|
/// Get the current angular damping.
|
|
Body_GetAngularDamping :: proc(bodyId: BodyId) -> f32 ---
|
|
|
|
/// Adjust the gravity scale. Normally this is set in BodyDef before creation.
|
|
/// @see BodyDef::gravityScale
|
|
Body_SetGravityScale :: proc(bodyId: BodyId, gravityScale: f32) ---
|
|
|
|
/// Get the current gravity scale
|
|
Body_GetGravityScale :: proc(bodyId: BodyId) -> f32 ---
|
|
|
|
/// @return true if this body is awake
|
|
Body_IsAwake :: proc(bodyId: BodyId) -> bool ---
|
|
|
|
/// Wake a body from sleep. This wakes the entire island the body is touching.
|
|
/// @warning Putting a body to sleep will put the entire island of bodies touching this body to sleep,
|
|
/// which can be expensive and possibly unintuitive.
|
|
Body_SetAwake :: proc(bodyId: BodyId, awake: bool) ---
|
|
|
|
/// Enable or disable sleeping for this body. If sleeping is disabled the body will wake.
|
|
Body_EnableSleep :: proc(bodyId: BodyId, enableSleep: bool) ---
|
|
|
|
/// Returns true if sleeping is enabled for this body
|
|
Body_IsSleepEnabled :: proc(bodyId: BodyId) -> bool ---
|
|
|
|
/// Set the sleep threshold, typically in meters per second
|
|
Body_SetSleepThreshold :: proc(bodyId: BodyId, sleepVelocity: f32) ---
|
|
|
|
/// Get the sleep threshold, typically in meters per second.
|
|
Body_GetSleepThreshold :: proc(bodyId: BodyId) -> f32 ---
|
|
|
|
/// Returns true if this body is enabled
|
|
Body_IsEnabled :: proc(bodyId: BodyId) -> bool ---
|
|
|
|
/// Disable a body by removing it completely from the simulation. This is expensive.
|
|
Body_Disable :: proc(bodyId: BodyId) ---
|
|
|
|
/// Enable a body by adding it to the simulation. This is expensive.
|
|
Body_Enable :: proc(bodyId: BodyId) ---
|
|
|
|
/// Set this body to have fixed rotation. This causes the mass to be reset in all cases.
|
|
Body_SetFixedRotation :: proc(bodyId: BodyId, flag: bool) ---
|
|
|
|
/// Does this body have fixed rotation?
|
|
Body_IsFixedRotation :: proc(bodyId: BodyId) -> bool ---
|
|
|
|
/// Set this body to be a bullet. A bullet does continuous collision detection
|
|
/// against dynamic bodies (but not other bullets).
|
|
Body_SetBullet :: proc(bodyId: BodyId, flag: bool) ---
|
|
|
|
/// Is this body a bullet?
|
|
Body_IsBullet :: proc(bodyId: BodyId) -> bool ---
|
|
|
|
/// Enable/disable hit events on all shapes
|
|
/// @see b2ShapeDef::enableHitEvents
|
|
Body_EnableHitEvents :: proc(bodyId: BodyId, enableHitEvents: bool) ---
|
|
|
|
/// Get the number of shapes on this body
|
|
Body_GetShapeCount :: proc(bodyId: BodyId) -> c.int ---
|
|
|
|
/// Get the number of joints on this body
|
|
Body_GetJointCount :: proc(bodyId: BodyId) -> c.int ---
|
|
|
|
/// Get the maximum capacity required for retrieving all the touching contacts on a body
|
|
Body_GetContactCapacity :: proc(bodyId: BodyId) -> c.int ---
|
|
|
|
/// Get the current world AABB that contains all the attached shapes. Note that this may not encompass the body origin.
|
|
/// If there are no shapes attached then the returned AABB is empty and centered on the body origin.
|
|
Body_ComputeAABB :: proc(bodyId: BodyId) -> AABB ---
|
|
}
|
|
|
|
/// Get the shape ids for all shapes on this body, up to the provided capacity.
|
|
/// @returns the number of shape ids stored in the user array
|
|
Body_GetShapes :: proc "c" (bodyId: BodyId, shapeArray: []ShapeId) -> c.int {
|
|
foreign lib {
|
|
b2Body_GetShapes :: proc "c" (bodyId: BodyId, shapeArray: [^]ShapeId, capacity: c.int) -> c.int ---
|
|
}
|
|
return b2Body_GetShapes(bodyId, raw_data(shapeArray), c.int(len(shapeArray)))
|
|
|
|
}
|
|
|
|
/// Get the joint ids for all joints on this body, up to the provided capacity
|
|
/// @returns the number of joint ids stored in the user array
|
|
Body_GetJoints :: proc "c" (bodyId: BodyId, jointArray: []JointId) -> c.int {
|
|
foreign lib {
|
|
b2Body_GetJoints :: proc "c" (bodyId: BodyId, jointArray: [^]JointId, capacity: c.int) -> c.int ---
|
|
}
|
|
return b2Body_GetJoints(bodyId, raw_data(jointArray), c.int(len(jointArray)))
|
|
|
|
}
|
|
|
|
/// Get the touching contact data for a body
|
|
Body_GetContactData :: proc "c" (bodyId: BodyId, contactData: []ContactData) -> c.int {
|
|
foreign lib {
|
|
b2Body_GetContactData :: proc "c" (bodyId: BodyId, contactData: [^]ContactData, capacity: c.int) -> c.int ---
|
|
}
|
|
return b2Body_GetContactData(bodyId, raw_data(contactData), c.int(len(contactData)))
|
|
|
|
}
|
|
|
|
@(link_prefix="b2", default_calling_convention="c")
|
|
foreign lib {
|
|
/**
|
|
* @defgroup shape Shape
|
|
* Functions to create, destroy, and access.
|
|
* Shapes bind raw geometry to bodies and hold material properties including friction and restitution.
|
|
*/
|
|
|
|
/// Create a circle shape and attach it to a body. The shape definition and geometry are fully cloned.
|
|
/// Contacts are not created until the next time step.
|
|
/// @return the shape id for accessing the shape
|
|
CreateCircleShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr circle: Circle) -> ShapeId ---
|
|
|
|
/// Create a line segment shape and attach it to a body. The shape definition and geometry are fully cloned.
|
|
/// Contacts are not created until the next time step.
|
|
/// @return the shape id for accessing the shape
|
|
CreateSegmentShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr segment: Segment) -> ShapeId ---
|
|
|
|
/// Create a capsule shape and attach it to a body. The shape definition and geometry are fully cloned.
|
|
/// Contacts are not created until the next time step.
|
|
/// @return the shape id for accessing the shape
|
|
CreateCapsuleShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr capsule: Capsule) -> ShapeId ---
|
|
|
|
/// Create a polygon shape and attach it to a body. The shape definition and geometry are fully cloned.
|
|
/// Contacts are not created until the next time step.
|
|
/// @return the shape id for accessing the shape
|
|
CreatePolygonShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr polygon: Polygon) -> ShapeId ---
|
|
|
|
/// Destroy a shape
|
|
DestroyShape :: proc(shapeId: ShapeId) ---
|
|
|
|
/// Shape identifier validation. Provides validation for up to 64K allocations.
|
|
Shape_IsValid :: proc(id: ShapeId) -> bool ---
|
|
|
|
/// Get the type of a shape
|
|
Shape_GetType :: proc(shapeId: ShapeId) -> ShapeType ---
|
|
|
|
/// Get the id of the body that a shape is attached to
|
|
Shape_GetBody :: proc(shapeId: ShapeId) -> BodyId ---
|
|
|
|
/// Returns true If the shape is a sensor
|
|
Shape_IsSensor :: proc(shapeId: ShapeId) -> bool ---
|
|
|
|
/// Set the user data for a shape
|
|
Shape_SetUserData :: proc(shapeId: ShapeId, userData: rawptr) ---
|
|
|
|
/// Get the user data for a shape. This is useful when you get a shape id
|
|
/// from an event or query.
|
|
Shape_GetUserData :: proc(shapeId: ShapeId) -> rawptr ---
|
|
|
|
/// Set the mass density of a shape, typically in kg/m^2.
|
|
/// This will not update the mass properties on the parent body.
|
|
/// @see b2ShapeDef::density, b2Body_ApplyMassFromShapes
|
|
Shape_SetDensity :: proc(shapeId: ShapeId, density: f32) ---
|
|
|
|
/// Get the density of a shape, typically in kg/m^2
|
|
Shape_GetDensity :: proc(shapeId: ShapeId) -> f32 ---
|
|
|
|
/// Set the friction on a shape
|
|
/// @see b2ShapeDef::friction
|
|
Shape_SetFriction :: proc(shapeId: ShapeId, friction: f32) ---
|
|
|
|
/// Get the friction of a shape
|
|
Shape_GetFriction :: proc(shapeId: ShapeId) -> f32 ---
|
|
|
|
/// Set the shape restitution (bounciness)
|
|
/// @see b2ShapeDef::restitution
|
|
Shape_SetRestitution :: proc(shapeId: ShapeId, restitution: f32) ---
|
|
|
|
/// Get the shape restitution
|
|
Shape_GetRestitution :: proc(shapeId: ShapeId) -> f32 ---
|
|
|
|
/// Get the shape filter
|
|
Shape_GetFilter :: proc(shapeId: ShapeId) -> Filter ---
|
|
|
|
/// Set the current filter. This is almost as expensive as recreating the shape.
|
|
/// @see b2ShapeDef::filter
|
|
Shape_SetFilter :: proc(shapeId: ShapeId, filter: Filter) ---
|
|
|
|
/// Enable sensor events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors.
|
|
/// @see b2ShapeDef::isSensor
|
|
Shape_EnableSensorEvents :: proc(shapeId: ShapeId, flag: bool) ---
|
|
|
|
/// Returns true if sensor events are enabled
|
|
Shape_AreSensorEventsEnabled :: proc(shapeId: ShapeId) -> bool ---
|
|
|
|
/// Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors.
|
|
/// @see b2ShapeDef::enableContactEvents
|
|
Shape_EnableContactEvents :: proc(shapeId: ShapeId, flag: bool) ---
|
|
|
|
/// Returns true if contact events are enabled
|
|
Shape_AreContactEventsEnabled :: proc(shapeId: ShapeId) -> bool ---
|
|
|
|
/// Enable pre-solve contact events for this shape. Only applies to dynamic bodies. These are expensive
|
|
/// and must be carefully handled due to multithreading. Ignored for sensors.
|
|
/// @see b2PreSolveFcn
|
|
Shape_EnablePreSolveEvents :: proc(shapeId: ShapeId, flag: bool) ---
|
|
|
|
/// Returns true if pre-solve events are enabled
|
|
Shape_ArePreSolveEventsEnabled :: proc(shapeId: ShapeId) -> bool ---
|
|
|
|
/// Enable contact hit events for this shape. Ignored for sensors.
|
|
/// @see WorldDef.hitEventThreshold
|
|
Shape_EnableHitEvents :: proc(shapeId: ShapeId, flag: bool) ---
|
|
|
|
/// Returns true if hit events are enabled
|
|
Shape_AreHitEventsEnabled :: proc(shapeId: ShapeId) -> bool ---
|
|
|
|
/// Test a point for overlap with a shape
|
|
Shape_TestPoint :: proc(shapeId: ShapeId, point: Vec2) -> bool ---
|
|
|
|
/// Ray cast a shape directly
|
|
Shape_RayCast :: proc(shapeId: ShapeId, origin: Vec2, translation: Vec2) -> CastOutput ---
|
|
|
|
/// Get a copy of the shape's circle. Asserts the type is correct.
|
|
Shape_GetCircle :: proc(shapeId: ShapeId) -> Circle ---
|
|
|
|
/// Get a copy of the shape's line segment. Asserts the type is correct.
|
|
Shape_GetSegment :: proc(shapeId: ShapeId) -> Segment ---
|
|
|
|
/// Get a copy of the shape's smooth line segment. These come from chain shapes.
|
|
/// Asserts the type is correct.
|
|
Shape_GetSmoothSegment :: proc(shapeId: ShapeId) -> SmoothSegment ---
|
|
|
|
/// Get a copy of the shape's capsule. Asserts the type is correct.
|
|
Shape_GetCapsule :: proc(shapeId: ShapeId) -> Capsule ---
|
|
|
|
/// Get a copy of the shape's convex polygon. Asserts the type is correct.
|
|
Shape_GetPolygon :: proc(shapeId: ShapeId) -> Polygon ---
|
|
|
|
/// Allows you to change a shape to be a circle or update the current circle.
|
|
/// This does not modify the mass properties.
|
|
/// @see b2Body_ApplyMassFromShapes
|
|
Shape_SetCircle :: proc(shapeId: ShapeId, #by_ptr circle: Circle) ---
|
|
|
|
/// Allows you to change a shape to be a capsule or update the current capsule.
|
|
/// This does not modify the mass properties.
|
|
/// @see b2Body_ApplyMassFromShapes
|
|
Shape_SetCapsule :: proc(shapeId: ShapeId, #by_ptr capsule: Capsule) ---
|
|
|
|
/// Allows you to change a shape to be a segment or update the current segment.
|
|
Shape_SetSegment :: proc(shapeId: ShapeId, #by_ptr segment: Segment) ---
|
|
|
|
/// Allows you to change a shape to be a polygon or update the current polygon.
|
|
/// This does not modify the mass properties.
|
|
/// @see b2Body_ApplyMassFromShapes
|
|
Shape_SetPolygon :: proc(shapeId: ShapeId, #by_ptr polygon: Polygon) ---
|
|
|
|
/// Get the parent chain id if the shape type is b2_smoothSegmentShape, otherwise
|
|
/// returns b2_nullChainId.
|
|
Shape_GetParentChain :: proc(shapeId: ShapeId) -> ChainId ---
|
|
|
|
/// Get the maximum capacity required for retrieving all the touching contacts on a shape
|
|
Shape_GetContactCapacity :: proc(shapeId: ShapeId) -> c.int ---
|
|
|
|
|
|
}
|
|
|
|
/// Get the touching contact data for a shape. The provided shapeId will be either shapeIdA or shapeIdB on the contact data.
|
|
Shape_GetContactData :: proc "c" (shapeId: ShapeId, contactData: []ContactData) -> c.int {
|
|
foreign lib {
|
|
b2Shape_GetContactData :: proc "c" (shapeId: ShapeId, contactData: [^]ContactData, capacity: c.int) -> c.int ---
|
|
}
|
|
return b2Shape_GetContactData(shapeId, raw_data(contactData), c.int(len(contactData)))
|
|
}
|
|
|
|
|
|
@(link_prefix="b2", default_calling_convention="c")
|
|
foreign lib {
|
|
/// Get the current world AABB
|
|
Shape_GetAABB :: proc(shapeId: ShapeId) -> AABB ---
|
|
|
|
/// Get the closest point on a shape to a target point. Target and result are in world space.
|
|
Shape_GetClosestPoint :: proc(shapeId: ShapeId, target: Vec2) -> Vec2 ---
|
|
|
|
/// Chain Shape
|
|
|
|
/// Create a chain shape
|
|
/// @see b2ChainDef for details
|
|
CreateChain :: proc(bodyId: BodyId, #by_ptr def: ChainDef) -> ChainId ---
|
|
|
|
/// Destroy a chain shape
|
|
DestroyChain :: proc(chainId: ChainId) ---
|
|
|
|
/// Set the chain friction
|
|
/// @see b2ChainDef::friction
|
|
Chain_SetFriction :: proc(chainId: ChainId, friction: f32) ---
|
|
|
|
/// Set the chain restitution (bounciness)
|
|
/// @see b2ChainDef::restitution
|
|
Chain_SetRestitution :: proc(chainId: ChainId, restitution: f32) ---
|
|
|
|
/// Chain identifier validation. Provides validation for up to 64K allocations.
|
|
Chain_IsValid :: proc(id: ChainId) -> bool ---
|
|
|
|
/**
|
|
* @defgroup joint Joint
|
|
* @brief Joints allow you to connect rigid bodies together while allowing various forms of relative motions.
|
|
*/
|
|
|
|
/// Destroy a joint
|
|
DestroyJoint :: proc(jointId: JointId) ---
|
|
|
|
/// Joint identifier validation. Provides validation for up to 64K allocations.
|
|
Joint_IsValid :: proc(id: JointId) -> bool ---
|
|
|
|
/// Get the joint type
|
|
Joint_GetType :: proc(jointId: JointId) -> JointType ---
|
|
|
|
/// Get body A id on a joint
|
|
Joint_GetBodyA :: proc(jointId: JointId) -> BodyId ---
|
|
|
|
/// Get body B id on a joint
|
|
Joint_GetBodyB :: proc(jointId: JointId) -> BodyId ---
|
|
|
|
/// Get the local anchor on bodyA
|
|
Joint_GetLocalAnchorA :: proc(jointId: JointId) -> Vec2 ---
|
|
|
|
/// Get the local anchor on bodyB
|
|
Joint_GetLocalAnchorB :: proc(jointId: JointId) -> Vec2 ---
|
|
|
|
/// Toggle collision between connected bodies
|
|
Joint_SetCollideConnected :: proc(jointId: JointId, shouldCollide: bool) ---
|
|
|
|
/// Is collision allowed between connected bodies?
|
|
Joint_GetCollideConnected :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the user data on a joint
|
|
Joint_SetUserData :: proc(jointId: JointId, userData: rawptr) ---
|
|
|
|
/// Get the user data on a joint
|
|
Joint_GetUserData :: proc(jointId: JointId) -> rawptr ---
|
|
|
|
/// Wake the bodies connect to this joint
|
|
Joint_WakeBodies :: proc(jointId: JointId) ---
|
|
|
|
/// Get the current constraint force for this joint
|
|
Joint_GetConstraintForce :: proc(jointId: JointId) -> Vec2 ---
|
|
|
|
/// Get the current constraint torque for this joint
|
|
Joint_GetConstraintTorque :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/**
|
|
* @defgroup distance_joint Distance Joint
|
|
* @brief Functions for the distance joint.
|
|
*/
|
|
|
|
/// Create a distance joint
|
|
/// @see b2DistanceJointDef for details
|
|
CreateDistanceJoint :: proc(worldId: WorldId, #by_ptr def: DistanceJointDef) -> JointId ---
|
|
|
|
/// Set the rest length of a distance joint
|
|
/// @param jointId The id for a distance joint
|
|
/// @param length The new distance joint length
|
|
DistanceJoint_SetLength :: proc(jointId: JointId, length: f32) ---
|
|
|
|
/// Get the rest length of a distance joint
|
|
DistanceJoint_GetLength :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Enable/disable the distance joint spring. When disabled the distance joint is rigid.
|
|
DistanceJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) ---
|
|
|
|
/// Is the distance joint spring enabled?
|
|
DistanceJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the spring stiffness in Hertz
|
|
DistanceJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) ---
|
|
|
|
/// Set the spring damping ratio, non-dimensional
|
|
DistanceJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) ---
|
|
|
|
/// Get the spring Hertz
|
|
DistanceJoint_GetHertz :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the spring damping ratio
|
|
DistanceJoint_GetDampingRatio :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Enable joint limit. The limit only works if the joint spring is enabled. Otherwise the joint is rigid
|
|
/// and the limit has no effect.
|
|
DistanceJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) ---
|
|
|
|
/// Is the distance joint limit enabled?
|
|
DistanceJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the minimum and maximum length parameters of a distance joint
|
|
DistanceJoint_SetLengthRange :: proc(jointId: JointId, minLength, maxLength: f32) ---
|
|
|
|
/// Get the distance joint minimum length
|
|
DistanceJoint_GetMinLength :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the distance joint maximum length
|
|
DistanceJoint_GetMaxLength :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the current length of a distance joint
|
|
DistanceJoint_GetCurrentLength :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Enable/disable the distance joint motor
|
|
DistanceJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) ---
|
|
|
|
/// Is the distance joint motor enabled?
|
|
DistanceJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the distance joint motor speed, typically in meters per second
|
|
DistanceJoint_SetMotorSpeed :: proc(jointId: JointId, motorSpeed: f32) ---
|
|
|
|
/// Get the distance joint motor speed, typically in meters per second
|
|
DistanceJoint_GetMotorSpeed :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the distance joint maximum motor force, typically in newtons
|
|
DistanceJoint_SetMaxMotorForce :: proc(jointId: JointId, force: f32) ---
|
|
|
|
/// Get the distance joint maximum motor force, typically in newtons
|
|
DistanceJoint_GetMaxMotorForce :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the distance joint current motor force, typically in newtons
|
|
DistanceJoint_GetMotorForce :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/**
|
|
* @defgroup motor_joint Motor Joint
|
|
* @brief Functions for the motor joint.
|
|
*
|
|
* The motor joint is used to drive the relative transform between two bodies. It takes
|
|
* a relative position and rotation and applies the forces and torques needed to achieve
|
|
* that relative transform over time.
|
|
*/
|
|
|
|
/// Create a motor joint
|
|
/// @see b2MotorJointDef for details
|
|
CreateMotorJoint :: proc(worldId: WorldId, def: MotorJointDef) -> JointId ---
|
|
|
|
/// Set the motor joint linear offset target
|
|
MotorJoint_SetLinearOffset :: proc(jointId: JointId, linearOffset: Vec2) ---
|
|
|
|
/// Get the motor joint linear offset target
|
|
MotorJoint_GetLinearOffset :: proc(jointId: JointId) -> Vec2 ---
|
|
|
|
/// Set the motor joint angular offset target in radians
|
|
MotorJoint_SetAngularOffset :: proc(jointId: JointId, angularOffset: f32) ---
|
|
|
|
/// Get the motor joint angular offset target in radians
|
|
MotorJoint_GetAngularOffset :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the motor joint maximum force, typically in newtons
|
|
MotorJoint_SetMaxForce :: proc(jointId: JointId, maxForce: f32) ---
|
|
|
|
/// Get the motor joint maximum force, typically in newtons
|
|
MotorJoint_GetMaxForce :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the motor joint maximum torque, typically in newton-meters
|
|
MotorJoint_SetMaxTorque :: proc(jointId: JointId, maxTorque: f32) ---
|
|
|
|
/// Get the motor joint maximum torque, typically in newton-meters
|
|
MotorJoint_GetMaxTorque :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the motor joint correction factor, typically in [0, 1]
|
|
MotorJoint_SetCorrectionFactor :: proc(jointId: JointId, correctionFactor: f32) ---
|
|
|
|
/// Get the motor joint correction factor, typically in [0, 1]
|
|
MotorJoint_GetCorrectionFactor :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @defgroup mouse_joint Mouse Joint
|
|
* @brief Functions for the mouse joint.
|
|
*
|
|
* The mouse joint is designed for use in the samples application, but you may find it useful in applications where
|
|
* the user moves a rigid body with a cursor.
|
|
*/
|
|
|
|
/// Create a mouse joint
|
|
/// @see b2MouseJointDef for details
|
|
CreateMouseJoint :: proc(worldId: WorldId, #by_ptr def: MouseJointDef) -> JointId ---
|
|
|
|
/// Set the mouse joint target
|
|
MouseJoint_SetTarget :: proc(jointId: JointId, target: Vec2) ---
|
|
|
|
/// Get the mouse joint target
|
|
MouseJoint_GetTarget :: proc(jointId: JointId) -> Vec2 ---
|
|
|
|
/// Set the mouse joint spring stiffness in Hertz
|
|
MouseJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) ---
|
|
|
|
/// Get the mouse joint spring stiffness in Hertz
|
|
MouseJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the mouse joint spring damping ratio, non-dimensional
|
|
MouseJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) ---
|
|
|
|
/// Get the mouse joint damping ratio, non-dimensional
|
|
MouseJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the mouse joint maximum force, typically in newtons
|
|
MouseJoint_SetMaxForce :: proc(jointId: JointId, maxForce: f32) ---
|
|
|
|
/// Get the mouse joint maximum force, typically in newtons
|
|
MouseJoint_GetMaxForce :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @defgroup prismatic_joint Prismatic Joint
|
|
* @brief A prismatic joint allows for translation along a single axis with no rotation.
|
|
*
|
|
* The prismatic joint is useful for things like pistons and moving platforms, where you want a body to translate
|
|
* along an axis and have no rotation. Also called a *slider* joint.
|
|
*/
|
|
|
|
/// Create a prismatic (slider) joint.
|
|
/// @see b2PrismaticJointDef for details
|
|
CreatePrismaticJoint :: proc(worldId: WorldId, #by_ptr def: PrismaticJointDef) -> JointId ---
|
|
|
|
/// Enable/disable the joint spring.
|
|
PrismaticJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) ---
|
|
|
|
/// Is the prismatic joint spring enabled or not?
|
|
PrismaticJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the prismatic joint stiffness in Hertz.
|
|
/// This should usually be less than a quarter of the simulation rate. For example, if the simulation
|
|
/// runs at 60Hz then the joint stiffness should be 15Hz or less.
|
|
PrismaticJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) ---
|
|
|
|
/// Get the prismatic joint stiffness in Hertz
|
|
PrismaticJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the prismatic joint damping ratio (non-dimensional)
|
|
PrismaticJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) ---
|
|
|
|
/// Get the prismatic spring damping ratio (non-dimensional)
|
|
PrismaticJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Enable/disable a prismatic joint limit
|
|
PrismaticJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) ---
|
|
|
|
/// Is the prismatic joint limit enabled?
|
|
PrismaticJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Get the prismatic joint lower limit
|
|
PrismaticJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the prismatic joint upper limit
|
|
PrismaticJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the prismatic joint limits
|
|
PrismaticJoint_SetLimits :: proc(jointId: JointId, lower: f32, upper: f32) ---
|
|
|
|
/// Enable/disable a prismatic joint motor
|
|
PrismaticJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) ---
|
|
|
|
/// Is the prismatic joint motor enabled?
|
|
PrismaticJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the prismatic joint motor speed, typically in meters per second
|
|
PrismaticJoint_SetMotorSpeed :: proc(jointId: JointId, motorSpeed: f32) ---
|
|
|
|
/// Get the prismatic joint motor speed, typically in meters per second
|
|
PrismaticJoint_GetMotorSpeed :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the prismatic joint maximum motor force, typically in newtons
|
|
PrismaticJoint_SetMaxMotorForce :: proc(jointId: JointId, force: f32) ---
|
|
|
|
/// Get the prismatic joint maximum motor force, typically in newtons
|
|
PrismaticJoint_GetMaxMotorForce :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the prismatic joint current motor force, typically in newtons
|
|
PrismaticJoint_GetMotorForce :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/**
|
|
* @defgroup revolute_joint Revolute Joint
|
|
* @brief A revolute joint allows for relative rotation in the 2D plane with no relative translation.
|
|
*
|
|
* The revolute joint is probably the most common joint. It can be used for ragdolls and chains.
|
|
* Also called a *hinge* or *pin* joint.
|
|
*/
|
|
|
|
/// Create a revolute joint
|
|
/// @see b2RevoluteJointDef for details
|
|
CreateRevoluteJoint :: proc(worldId: WorldId, #by_ptr def: RevoluteJointDef) -> JointId ---
|
|
|
|
/// Enable/disable the revolute joint spring
|
|
RevoluteJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) ---
|
|
|
|
/// Set the revolute joint spring stiffness in Hertz
|
|
RevoluteJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) ---
|
|
|
|
/// Get the revolute joint spring stiffness in Hertz
|
|
RevoluteJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the revolute joint spring damping ratio, non-dimensional
|
|
RevoluteJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) ---
|
|
|
|
/// Get the revolute joint spring damping ratio, non-dimensional
|
|
RevoluteJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the revolute joint current angle in radians relative to the reference angle
|
|
/// @see b2RevoluteJointDef::referenceAngle
|
|
RevoluteJoint_GetAngle :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Enable/disable the revolute joint limit
|
|
RevoluteJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) ---
|
|
|
|
/// Is the revolute joint limit enabled?
|
|
RevoluteJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Get the revolute joint lower limit in radians
|
|
RevoluteJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the revolute joint upper limit in radians
|
|
RevoluteJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the revolute joint limits in radians
|
|
RevoluteJoint_SetLimits :: proc(jointId: JointId, lower: f32, upper: f32) ---
|
|
|
|
/// Enable/disable a revolute joint motor
|
|
RevoluteJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) ---
|
|
|
|
/// Is the revolute joint motor enabled?
|
|
RevoluteJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the revolute joint motor speed in radians per second
|
|
RevoluteJoint_SetMotorSpeed :: proc(jointId: JointId, motorSpeed: f32) ---
|
|
|
|
/// Get the revolute joint motor speed in radians per second
|
|
RevoluteJoint_GetMotorSpeed :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the revolute joint current motor torque, typically in newton-meters
|
|
RevoluteJoint_GetMotorTorque :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the revolute joint maximum motor torque, typically in newton-meters
|
|
RevoluteJoint_SetMaxMotorTorque :: proc(jointId: JointId, torque: f32) ---
|
|
|
|
/// Get the revolute joint maximum motor torque, typically in newton-meters
|
|
RevoluteJoint_GetMaxMotorTorque :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @defgroup weld_joint Weld Joint
|
|
* @brief A weld joint fully constrains the relative transform between two bodies while allowing for springiness
|
|
*
|
|
* A weld joint constrains the relative rotation and translation between two bodies. Both rotation and translation
|
|
* can have damped springs.
|
|
*
|
|
* @note The accuracy of weld joint is limited by the accuracy of the solver. Long chains of weld joints may flex.
|
|
*/
|
|
|
|
/// Create a weld joint
|
|
/// @see b2WeldJointDef for details
|
|
CreateWeldJoint :: proc(worldId: WorldId, #by_ptr def: WeldJointDef) -> JointId ---
|
|
|
|
/// Set the weld joint linear stiffness in Hertz. 0 is rigid.
|
|
WeldJoint_SetLinearHertz :: proc(jointId: JointId, hertz: f32) ---
|
|
|
|
/// Get the weld joint linear stiffness in Hertz
|
|
WeldJoint_GetLinearHertz :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the weld joint linear damping ratio (non-dimensional)
|
|
WeldJoint_SetLinearDampingRatio :: proc(jointId: JointId, dampingRatio: f32) ---
|
|
|
|
/// Get the weld joint linear damping ratio (non-dimensional)
|
|
WeldJoint_GetLinearDampingRatio :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the weld joint angular stiffness in Hertz. 0 is rigid.
|
|
WeldJoint_SetAngularHertz :: proc(jointId: JointId, hertz: f32) ---
|
|
|
|
/// Get the weld joint angular stiffness in Hertz
|
|
WeldJoint_GetAngularHertz :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set weld joint angular damping ratio, non-dimensional
|
|
WeldJoint_SetAngularDampingRatio :: proc(jointId: JointId, dampingRatio: f32) ---
|
|
|
|
/// Get the weld joint angular damping ratio, non-dimensional
|
|
WeldJoint_GetAngularDampingRatio :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/**
|
|
* @defgroup wheel_joint Wheel Joint
|
|
* The wheel joint can be used to simulate wheels on vehicles.
|
|
*
|
|
* The wheel joint restricts body B to move along a local axis in body A. Body B is free to
|
|
* rotate. Supports a linear spring, linear limits, and a rotational motor.
|
|
*
|
|
*/
|
|
|
|
/// Create a wheel joint
|
|
/// @see b2WheelJointDef for details
|
|
CreateWheelJoint :: proc(worldId: WorldId, #by_ptr def: WheelJointDef) -> JointId ---
|
|
|
|
/// Enable/disable the wheel joint spring
|
|
WheelJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) ---
|
|
|
|
/// Is the wheel joint spring enabled?
|
|
WheelJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the wheel joint stiffness in Hertz
|
|
WheelJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) ---
|
|
|
|
/// Get the wheel joint stiffness in Hertz
|
|
WheelJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the wheel joint damping ratio, non-dimensional
|
|
WheelJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) ---
|
|
|
|
/// Get the wheel joint damping ratio, non-dimensional
|
|
WheelJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Enable/disable the wheel joint limit
|
|
WheelJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) ---
|
|
|
|
/// Is the wheel joint limit enabled?
|
|
WheelJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Get the wheel joint lower limit
|
|
WheelJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the wheel joint upper limit
|
|
WheelJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the wheel joint limits
|
|
WheelJoint_SetLimits :: proc(jointId: JointId, lower: f32, upper: f32) ---
|
|
|
|
/// Enable/disable the wheel joint motor
|
|
WheelJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) ---
|
|
|
|
/// Is the wheel joint motor enabled?
|
|
WheelJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool ---
|
|
|
|
/// Set the wheel joint motor speed in radians per second
|
|
WheelJoint_SetMotorSpeed :: proc(jointId: JointId, motorSpeed: f32) ---
|
|
|
|
/// Get the wheel joint motor speed in radians per second
|
|
WheelJoint_GetMotorSpeed :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Set the wheel joint maximum motor torque, typically in newton-meters
|
|
WheelJoint_SetMaxMotorTorque :: proc(jointId: JointId, torque: f32) ---
|
|
|
|
/// Get the wheel joint maximum motor torque, typically in newton-meters
|
|
WheelJoint_GetMaxMotorTorque :: proc(jointId: JointId) -> f32 ---
|
|
|
|
/// Get the wheel joint current motor torque, typically in newton-meters
|
|
WheelJoint_GetMotorTorque :: proc(jointId: JointId) -> f32 ---
|
|
}
|
|
|
|
|
|
|
|
IsValid :: proc{
|
|
Float_IsValid,
|
|
Vec2_IsValid,
|
|
Rot_IsValid,
|
|
World_IsValid,
|
|
Body_IsValid,
|
|
Shape_IsValid,
|
|
Chain_IsValid,
|
|
Joint_IsValid,
|
|
} |