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 zcmYjROGq0*7@lkzD`z4kDo%kLi!LRdz<5GLaj5uK_NXAv5iiw4WE1j;HMpB zbm)6Hoz)2i+Spc_?*r>nF~_Qn#?XqX1_8+ZBj1b`kps!KCoE#GBN6bav$ z&V@W7h|>s!V7`y)xR973xRQaFQWTd_|0cvK-P?qPizOW$61yQU0B?xhc^#@jOIcBI zNO+`U0f5_tbkaPH75WH81p2}zwowETL zb(s`9VD>ch@MwR=*h*7R7-#!@FS zxF^yaZzcz5UbR`Hs$3&c%Qq?ckt7uwI2Ii5&3M%>_6Q-$rQ#;ZvZ$y-ot sJ45I=#dng3Q~V@}`=u1k{{;Hr6D8I>u{%yw2r#24t3s$H6mdZO5B*PMiU0rr delta 1139 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 diff --git a/vendor/box2d/types.odin b/vendor/box2d/types.odin index 23f35e847..cd3a652a5 100644 --- a/vendor/box2d/types.odin +++ b/vendor/box2d/types.odin @@ -116,9 +116,9 @@ BodyType :: enum c.int { // positive mass, velocity determined by forces, moved by solver dynamicBody = 2, - // number of body types } +// number of body types bodyTypeCount :: len(BodyType) // A body definition holds all the data needed to construct a rigid body.