From 926c419ef824c04ea1cce7e3a9d8a3cead7feb6c Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 13 Aug 2024 16:58:35 +0100 Subject: [PATCH] Change .lib to be /MT compatible; Fix comments --- vendor/box2d/box2d.odin | 804 +++++++++--------- vendor/box2d/lib/box2d_windows_amd64_avx2.lib | Bin 731030 -> 731030 bytes vendor/box2d/lib/box2d_windows_amd64_sse2.lib | Bin 745478 -> 745400 bytes vendor/box2d/types.odin | 2 +- 4 files changed, 403 insertions(+), 403 deletions(-) diff --git a/vendor/box2d/box2d.odin b/vendor/box2d/box2d.odin index 7f9f478a2..c7508312c 100644 --- a/vendor/box2d/box2d.odin +++ b/vendor/box2d/box2d.odin @@ -447,133 +447,133 @@ foreign lib { * 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. + // 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 + // Destroy a world DestroyWorld :: proc(worldId: WorldId) --- - /// World id validation. Provides validation for up to 64K allocations. + // 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. + // 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 + // 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. + // 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. + // 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. + // 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 + // 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 + // 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 + // 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 + // 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 + // 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. + // 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. + // 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. + // 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. + // 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 + // 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 + // 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 + // 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 + // 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. + // 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. + // 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 + // 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 + // 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. + // 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 + // 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. + // 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 + // Get the current world performance profile World_GetProfile :: proc(worldId: WorldId) -> Profile --- - /// Get world counters and sizes + // Get world counters and sizes World_GetCounters :: proc(worldId: WorldId) -> Counters --- - /// Dump memory stats to box2d_memory.txt + // Dump memory stats to box2d_memory.txt World_DumpMemoryStats :: proc(worldId: WorldId) --- /** @@ -581,241 +581,241 @@ foreign lib { * 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. + // 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. + // 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 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 + // 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. + // 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 + // Set the user data for a body Body_SetUserData :: proc(bodyId: BodyId, userData: rawptr) --- - /// Get the user data stored in a body + // 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. + // 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) + // 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. + // 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 + // 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 + // 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 + // 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 + // 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 + // 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. + // 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 + // 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. + // 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 + // 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 + // 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 + // 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 + // 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. + // 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. + // 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. + // 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 + // 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 + // 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 + // 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 + // 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. + // 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 + // 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. + // 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 + // 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 + // Get the automatic mass setting Body_GetAutomaticMass :: proc(bodyId: BodyId) -> bool --- - /// Adjust the linear damping. Normally this is set in BodyDef before creation. + // Adjust the linear damping. Normally this is set in BodyDef before creation. Body_SetLinearDamping :: proc(bodyId: BodyId, linearDamping: f32) --- - /// Get the current linear damping. + // Get the current linear damping. Body_GetLinearDamping :: proc(bodyId: BodyId) -> f32 --- - /// Adjust the angular damping. Normally this is set in BodyDef before creation. + // Adjust the angular damping. Normally this is set in BodyDef before creation. Body_SetAngularDamping :: proc(bodyId: BodyId, angularDamping: f32) --- - /// Get the current angular damping. + // 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 + // 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 + // Get the current gravity scale Body_GetGravityScale :: proc(bodyId: BodyId) -> f32 --- - /// @return true if this body is awake + // @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. + // 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. + // 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 + // Returns true if sleeping is enabled for this body Body_IsSleepEnabled :: proc(bodyId: BodyId) -> bool --- - /// Set the sleep threshold, typically in meters per second + // 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. + // Get the sleep threshold, typically in meters per second. Body_GetSleepThreshold :: proc(bodyId: BodyId) -> f32 --- - /// Returns true if this body is enabled + // 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. + // 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. + // 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. + // 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? + // 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). + // 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? + // Is this body a bullet? Body_IsBullet :: proc(bodyId: BodyId) -> bool --- - /// Enable/disable hit events on all shapes - /// @see b2ShapeDef::enableHitEvents + // 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 + // Get the number of shapes on this body Body_GetShapeCount :: proc(bodyId: BodyId) -> c.int --- - /// Get the number of joints on this body + // 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 + // 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. + // 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 +// 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 --- @@ -824,8 +824,8 @@ Body_GetShapes :: proc "c" (bodyId: BodyId, shapeArray: []ShapeId) -> c.int { } -/// 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 +// 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 --- @@ -834,7 +834,7 @@ Body_GetJoints :: proc "c" (bodyId: BodyId, jointArray: []JointId) -> c.int { } -/// Get the touching contact data for a body +// 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 --- @@ -851,157 +851,157 @@ foreign lib { * 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 + // 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 + // 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 + // 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 + // 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 + // Destroy a shape DestroyShape :: proc(shapeId: ShapeId) --- - /// Shape identifier validation. Provides validation for up to 64K allocations. + // Shape identifier validation. Provides validation for up to 64K allocations. Shape_IsValid :: proc(id: ShapeId) -> bool --- - /// Get the type of a shape + // Get the type of a shape Shape_GetType :: proc(shapeId: ShapeId) -> ShapeType --- - /// Get the id of the body that a shape is attached to + // 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 + // Returns true If the shape is a sensor Shape_IsSensor :: proc(shapeId: ShapeId) -> bool --- - /// Set the user data for a shape + // 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. + // 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 + // 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 + // 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 + // Set the friction on a shape + // @see b2ShapeDef::friction Shape_SetFriction :: proc(shapeId: ShapeId, friction: f32) --- - /// Get the friction of a shape + // Get the friction of a shape Shape_GetFriction :: proc(shapeId: ShapeId) -> f32 --- - /// Set the shape restitution (bounciness) - /// @see b2ShapeDef::restitution + // Set the shape restitution (bounciness) + // @see b2ShapeDef::restitution Shape_SetRestitution :: proc(shapeId: ShapeId, restitution: f32) --- - /// Get the shape restitution + // Get the shape restitution Shape_GetRestitution :: proc(shapeId: ShapeId) -> f32 --- - /// Get the shape filter + // 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 + // 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 + // 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 + // 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 + // 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 + // 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 + // 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 + // 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 + // 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 + // Returns true if hit events are enabled Shape_AreHitEventsEnabled :: proc(shapeId: ShapeId) -> bool --- - /// Test a point for overlap with a shape + // Test a point for overlap with a shape Shape_TestPoint :: proc(shapeId: ShapeId, point: Vec2) -> bool --- - /// Ray cast a shape directly + // 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. + // 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. + // 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. + // 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. + // 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. + // 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 + // 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 + // 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. + // 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 + // 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. + // 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 + // 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. +// 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 --- @@ -1012,30 +1012,30 @@ Shape_GetContactData :: proc "c" (shapeId: ShapeId, contactData: []ContactData) @(link_prefix="b2", default_calling_convention="c") foreign lib { - /// Get the current world AABB + // 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. + // 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 + // Chain Shape - /// Create a chain shape - /// @see b2ChainDef for details + // Create a chain shape + // @see b2ChainDef for details CreateChain :: proc(bodyId: BodyId, #by_ptr def: ChainDef) -> ChainId --- - /// Destroy a chain shape + // Destroy a chain shape DestroyChain :: proc(chainId: ChainId) --- - /// Set the chain friction - /// @see b2ChainDef::friction + // Set the chain friction + // @see b2ChainDef::friction Chain_SetFriction :: proc(chainId: ChainId, friction: f32) --- - /// Set the chain restitution (bounciness) - /// @see b2ChainDef::restitution + // 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 identifier validation. Provides validation for up to 64K allocations. Chain_IsValid :: proc(id: ChainId) -> bool --- /** @@ -1043,46 +1043,46 @@ foreign lib { * @brief Joints allow you to connect rigid bodies together while allowing various forms of relative motions. */ - /// Destroy a joint + // Destroy a joint DestroyJoint :: proc(jointId: JointId) --- - /// Joint identifier validation. Provides validation for up to 64K allocations. + // Joint identifier validation. Provides validation for up to 64K allocations. Joint_IsValid :: proc(id: JointId) -> bool --- - /// Get the joint type + // Get the joint type Joint_GetType :: proc(jointId: JointId) -> JointType --- - /// Get body A id on a joint + // Get body A id on a joint Joint_GetBodyA :: proc(jointId: JointId) -> BodyId --- - /// Get body B id on a joint + // Get body B id on a joint Joint_GetBodyB :: proc(jointId: JointId) -> BodyId --- - /// Get the local anchor on bodyA + // Get the local anchor on bodyA Joint_GetLocalAnchorA :: proc(jointId: JointId) -> Vec2 --- - /// Get the local anchor on bodyB + // Get the local anchor on bodyB Joint_GetLocalAnchorB :: proc(jointId: JointId) -> Vec2 --- - /// Toggle collision between connected bodies + // Toggle collision between connected bodies Joint_SetCollideConnected :: proc(jointId: JointId, shouldCollide: bool) --- - /// Is collision allowed between connected bodies? + // Is collision allowed between connected bodies? Joint_GetCollideConnected :: proc(jointId: JointId) -> bool --- - /// Set the user data on a joint + // Set the user data on a joint Joint_SetUserData :: proc(jointId: JointId, userData: rawptr) --- - /// Get the user data on a joint + // Get the user data on a joint Joint_GetUserData :: proc(jointId: JointId) -> rawptr --- - /// Wake the bodies connect to this joint + // Wake the bodies connect to this joint Joint_WakeBodies :: proc(jointId: JointId) --- - /// Get the current constraint force for this joint + // Get the current constraint force for this joint Joint_GetConstraintForce :: proc(jointId: JointId) -> Vec2 --- - /// Get the current constraint torque for this joint + // Get the current constraint torque for this joint Joint_GetConstraintTorque :: proc(jointId: JointId) -> f32 --- /** @@ -1090,74 +1090,74 @@ foreign lib { * @brief Functions for the distance joint. */ - /// Create a distance joint - /// @see b2DistanceJointDef for details + // 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 + // 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 + // 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. + // 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? + // Is the distance joint spring enabled? DistanceJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool --- - /// Set the spring stiffness in Hertz + // Set the spring stiffness in Hertz DistanceJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- - /// Set the spring damping ratio, non-dimensional + // Set the spring damping ratio, non-dimensional DistanceJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- - /// Get the spring Hertz + // Get the spring Hertz DistanceJoint_GetHertz :: proc(jointId: JointId) -> f32 --- - /// Get the spring damping ratio + // 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. + // 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? + // Is the distance joint limit enabled? DistanceJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool --- - /// Set the minimum and maximum length parameters of a distance joint + // 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 + // Get the distance joint minimum length DistanceJoint_GetMinLength :: proc(jointId: JointId) -> f32 --- - /// Get the distance joint maximum length + // Get the distance joint maximum length DistanceJoint_GetMaxLength :: proc(jointId: JointId) -> f32 --- - /// Get the current length of a distance joint + // Get the current length of a distance joint DistanceJoint_GetCurrentLength :: proc(jointId: JointId) -> f32 --- - /// Enable/disable the distance joint motor + // Enable/disable the distance joint motor DistanceJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- - /// Is the distance joint motor enabled? + // Is the distance joint motor enabled? DistanceJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- - /// Set the distance joint motor speed, typically in meters per second + // 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 + // 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 + // 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 + // 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 + // Get the distance joint current motor force, typically in newtons DistanceJoint_GetMotorForce :: proc(jointId: JointId) -> f32 --- /** @@ -1169,38 +1169,38 @@ foreign lib { * that relative transform over time. */ - /// Create a motor joint - /// @see b2MotorJointDef for details + // Create a motor joint + // @see b2MotorJointDef for details CreateMotorJoint :: proc(worldId: WorldId, def: MotorJointDef) -> JointId --- - /// Set the motor joint linear offset target + // Set the motor joint linear offset target MotorJoint_SetLinearOffset :: proc(jointId: JointId, linearOffset: Vec2) --- - /// Get the motor joint linear offset target + // Get the motor joint linear offset target MotorJoint_GetLinearOffset :: proc(jointId: JointId) -> Vec2 --- - /// Set the motor joint angular offset target in radians + // 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 + // Get the motor joint angular offset target in radians MotorJoint_GetAngularOffset :: proc(jointId: JointId) -> f32 --- - /// Set the motor joint maximum force, typically in newtons + // 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 + // 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 + // 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 + // 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] + // 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] + // Get the motor joint correction factor, typically in [0, 1] MotorJoint_GetCorrectionFactor :: proc(jointId: JointId) -> f32 --- /**@}*/ @@ -1213,32 +1213,32 @@ foreign lib { * the user moves a rigid body with a cursor. */ - /// Create a mouse joint - /// @see b2MouseJointDef for details + // Create a mouse joint + // @see b2MouseJointDef for details CreateMouseJoint :: proc(worldId: WorldId, #by_ptr def: MouseJointDef) -> JointId --- - /// Set the mouse joint target + // Set the mouse joint target MouseJoint_SetTarget :: proc(jointId: JointId, target: Vec2) --- - /// Get the mouse joint target + // Get the mouse joint target MouseJoint_GetTarget :: proc(jointId: JointId) -> Vec2 --- - /// Set the mouse joint spring stiffness in Hertz + // Set the mouse joint spring stiffness in Hertz MouseJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- - /// Get the mouse joint spring stiffness in Hertz + // Get the mouse joint spring stiffness in Hertz MouseJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- - /// Set the mouse joint spring damping ratio, non-dimensional + // Set the mouse joint spring damping ratio, non-dimensional MouseJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- - /// Get the mouse joint damping ratio, non-dimensional + // Get the mouse joint damping ratio, non-dimensional MouseJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- - /// Set the mouse joint maximum force, typically in newtons + // 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 + // Get the mouse joint maximum force, typically in newtons MouseJoint_GetMaxForce :: proc(jointId: JointId) -> f32 --- /**@}*/ @@ -1251,64 +1251,64 @@ foreign lib { * along an axis and have no rotation. Also called a *slider* joint. */ - /// Create a prismatic (slider) joint. - /// @see b2PrismaticJointDef for details + // Create a prismatic (slider) joint. + // @see b2PrismaticJointDef for details CreatePrismaticJoint :: proc(worldId: WorldId, #by_ptr def: PrismaticJointDef) -> JointId --- - /// Enable/disable the joint spring. + // Enable/disable the joint spring. PrismaticJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) --- - /// Is the prismatic joint spring enabled or not? + // 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. + // 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 + // Get the prismatic joint stiffness in Hertz PrismaticJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- - /// Set the prismatic joint damping ratio (non-dimensional) + // Set the prismatic joint damping ratio (non-dimensional) PrismaticJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- - /// Get the prismatic spring damping ratio (non-dimensional) + // Get the prismatic spring damping ratio (non-dimensional) PrismaticJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- - /// Enable/disable a prismatic joint limit + // Enable/disable a prismatic joint limit PrismaticJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) --- - /// Is the prismatic joint limit enabled? + // Is the prismatic joint limit enabled? PrismaticJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool --- - /// Get the prismatic joint lower limit + // Get the prismatic joint lower limit PrismaticJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 --- - /// Get the prismatic joint upper limit + // Get the prismatic joint upper limit PrismaticJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 --- - /// Set the prismatic joint limits + // Set the prismatic joint limits PrismaticJoint_SetLimits :: proc(jointId: JointId, lower: f32, upper: f32) --- - /// Enable/disable a prismatic joint motor + // Enable/disable a prismatic joint motor PrismaticJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- - /// Is the prismatic joint motor enabled? + // Is the prismatic joint motor enabled? PrismaticJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- - /// Set the prismatic joint motor speed, typically in meters per second + // 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 + // 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 + // 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 + // 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 + // Get the prismatic joint current motor force, typically in newtons PrismaticJoint_GetMotorForce :: proc(jointId: JointId) -> f32 --- /** @@ -1319,63 +1319,63 @@ foreign lib { * Also called a *hinge* or *pin* joint. */ - /// Create a revolute joint - /// @see b2RevoluteJointDef for details + // Create a revolute joint + // @see b2RevoluteJointDef for details CreateRevoluteJoint :: proc(worldId: WorldId, #by_ptr def: RevoluteJointDef) -> JointId --- - /// Enable/disable the revolute joint spring + // Enable/disable the revolute joint spring RevoluteJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) --- - /// Set the revolute joint spring stiffness in Hertz + // Set the revolute joint spring stiffness in Hertz RevoluteJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- - /// Get the revolute joint spring stiffness in Hertz + // Get the revolute joint spring stiffness in Hertz RevoluteJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- - /// Set the revolute joint spring damping ratio, non-dimensional + // 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 + // 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 + // 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 + // Enable/disable the revolute joint limit RevoluteJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) --- - /// Is the revolute joint limit enabled? + // Is the revolute joint limit enabled? RevoluteJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool --- - /// Get the revolute joint lower limit in radians + // Get the revolute joint lower limit in radians RevoluteJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 --- - /// Get the revolute joint upper limit in radians + // Get the revolute joint upper limit in radians RevoluteJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 --- - /// Set the revolute joint limits in radians + // Set the revolute joint limits in radians RevoluteJoint_SetLimits :: proc(jointId: JointId, lower: f32, upper: f32) --- - /// Enable/disable a revolute joint motor + // Enable/disable a revolute joint motor RevoluteJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- - /// Is the revolute joint motor enabled? + // Is the revolute joint motor enabled? RevoluteJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- - /// Set the revolute joint motor speed in radians per second + // 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 + // 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 + // 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 + // 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 + // Get the revolute joint maximum motor torque, typically in newton-meters RevoluteJoint_GetMaxMotorTorque :: proc(jointId: JointId) -> f32 --- /**@}*/ @@ -1390,32 +1390,32 @@ foreign lib { * @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 + // 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. + // 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 + // Get the weld joint linear stiffness in Hertz WeldJoint_GetLinearHertz :: proc(jointId: JointId) -> f32 --- - /// Set the weld joint linear damping ratio (non-dimensional) + // 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) + // 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. + // 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 + // Get the weld joint angular stiffness in Hertz WeldJoint_GetAngularHertz :: proc(jointId: JointId) -> f32 --- - /// Set weld joint angular damping ratio, non-dimensional + // Set weld joint angular damping ratio, non-dimensional WeldJoint_SetAngularDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- - /// Get the weld joint angular damping ratio, non-dimensional + // Get the weld joint angular damping ratio, non-dimensional WeldJoint_GetAngularDampingRatio :: proc(jointId: JointId) -> f32 --- /** @@ -1427,62 +1427,62 @@ foreign lib { * */ - /// Create a wheel joint - /// @see b2WheelJointDef for details + // Create a wheel joint + // @see b2WheelJointDef for details CreateWheelJoint :: proc(worldId: WorldId, #by_ptr def: WheelJointDef) -> JointId --- - /// Enable/disable the wheel joint spring + // Enable/disable the wheel joint spring WheelJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) --- - /// Is the wheel joint spring enabled? + // Is the wheel joint spring enabled? WheelJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool --- - /// Set the wheel joint stiffness in Hertz + // Set the wheel joint stiffness in Hertz WheelJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- - /// Get the wheel joint stiffness in Hertz + // Get the wheel joint stiffness in Hertz WheelJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- - /// Set the wheel joint damping ratio, non-dimensional + // Set the wheel joint damping ratio, non-dimensional WheelJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- - /// Get the wheel joint damping ratio, non-dimensional + // Get the wheel joint damping ratio, non-dimensional WheelJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- - /// Enable/disable the wheel joint limit + // Enable/disable the wheel joint limit WheelJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) --- - /// Is the wheel joint limit enabled? + // Is the wheel joint limit enabled? WheelJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool --- - /// Get the wheel joint lower limit + // Get the wheel joint lower limit WheelJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 --- - /// Get the wheel joint upper limit + // Get the wheel joint upper limit WheelJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 --- - /// Set the wheel joint limits + // Set the wheel joint limits WheelJoint_SetLimits :: proc(jointId: JointId, lower: f32, upper: f32) --- - /// Enable/disable the wheel joint motor + // Enable/disable the wheel joint motor WheelJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- - /// Is the wheel joint motor enabled? + // Is the wheel joint motor enabled? WheelJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- - /// Set the wheel joint motor speed in radians per second + // 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 + // 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 + // 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 + // 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 + // Get the wheel joint current motor torque, typically in newton-meters WheelJoint_GetMotorTorque :: proc(jointId: JointId) -> f32 --- } diff --git a/vendor/box2d/lib/box2d_windows_amd64_avx2.lib b/vendor/box2d/lib/box2d_windows_amd64_avx2.lib index 5f6b037e5860f50a9b8c5ecbb206c979694dba97..cea3f678dbe5590fbafda9ef893019bd9ed138f3 100644 GIT binary patch delta 1139 zcmbPsUT4~Qoe6R*CT6Av8LjK9x2Wc)~fD47BFl2hh!!(DRVOe3j+lZNZ?9o zGiJheuJOT@t8s#)>tq-hsvy!+KFF@uTA?1YHx?POJ(3K0+Zz#_?SVg&c69z$l+_69$;IFOwtmeavr`&q@t4>FId znk|SEqA#I^O^q|NX?NOZ1qOzGh%;8Tu-(vuNQ0d^XEPhv8S6H)?V5!UmozpvGlxVV zC}bxyfQ+$AW?;B9-B6cBdiyp%cB#n_X5vXJC+n zILgg}^MNm1wb*orHckPs|80dB7*Zf6mb7sy$-vc!OPCm#Ap+JBY@&`F1H%W1>L-gh z@0h_=i%q|ElN0QnH#a%wJ%xxTw6IA`U$&o%4{VdV3cuE(c+R8cAbAQ;2K8xkeD|90PU+21|&MVJzHsJP_sJP+Tv-4GzTv0^GNt ip$N8Wi!`?Y8z{yS*{46yV#=C6!GMKjyM+vQ95(>{Ph^S! delta 1139 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