// Bindings for Box3D package vendor_box3d import "base:intrinsics" import "base:runtime" import "core:c" ENABLE_VALIDATION :: false BOX3D_SHARED :: #config(BOX3D_SHARED, false) @(private) LIB_PATH :: ( "lib/box3d_wasm.o" when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else "lib/linux-amd64/libbox3d.a" when ODIN_OS == .Linux && ODIN_ARCH == .amd64 && !BOX3D_SHARED else "lib/linux-arm64/libbox3d.a" when ODIN_OS == .Linux && ODIN_ARCH == .arm64 && !BOX3D_SHARED else "lib/darwin/libbox3d.a" when ODIN_OS == .Darwin && (ODIN_ARCH == .amd64 || ODIN_ARCH == .arm64) && !BOX3D_SHARED else "lib/box3d.lib" when ODIN_OS == .Windows else "" ) when LIB_PATH != "" { when !#exists(LIB_PATH) { #panic("Could not find the compiled Box3D library at \"" + LIB_PATH + "\", it can be compiled by running `\"" + ODIN_ROOT + "vendor/box3d/src/build.sh\"`") } @(export) foreign import lib { LIB_PATH } } else { @(export) foreign import lib "system:box3d" } // This is used to indicate null for interfaces that work with indices instead of pointers NULL_INDEX :: -1 // Prototype for user allocation function. // @param size the allocation size in bytes // @param alignment the required alignment, guaranteed to be a power of 2 AllocFcn :: proc "c" (size, alignment: i32) -> rawptr // Prototype for user free function. // @param mem the memory previously allocated through `AllocFcn` FreeFcn :: proc "c" (mem: rawptr) // Prototype for the user assert callback. Return 0 to skip the debugger break. AssertFcn :: proc "c" (condition: cstring, fileName: cstring, lineNumber: c.int) -> c.int // Prototype for user log callback. Used to log warnings. LogFcn :: proc "c" (message: rawptr) BREAKPOINT :: intrinsics.debug_trap @(link_prefix="b3", default_calling_convention="c", require_results) foreign lib { // This allows the user to override the allocation functions. These should be // set during application startup. SetAllocator :: proc(allocFcn: AllocFcn, freeFcn: FreeFcn) --- // Total bytes allocated by Box3D GetByteCount :: proc() -> c.int --- // Override the default assert callback. // @param assertFcn a non-null assert callback SetAssertFcn :: proc(assertFcn: AssertFcn) --- // Internal assertion handler. Allows for host intervention. InternalAssert :: proc(condition: cstring, fileName: cstring, lineNumber: c.int) -> c.int --- // Override the default logging callback. SetLogFcn :: proc(logFcn: LogFcn) --- } // Version numbering scheme. // See https://semver.org/ Version :: struct { // Significant changes major: c.int, // Incremental changes minor: c.int, // Bug fixes revision: c.int, } HASH_INIT :: 5381 @(link_prefix="b3", default_calling_convention="c", require_results) foreign lib { // Get the current version of Box3D GetVersion :: proc() -> Version --- // @return true if the library was built with BOX3D_DOUBLE_PRECISION (large world mode) IsDoublePrecision :: proc() -> bool --- // Get the absolute number of system ticks. The value is platform specific. GetTicks :: proc() -> u64 --- // Get the milliseconds passed from an initial tick value. GetMilliseconds :: proc(ticks: u64) -> f32 --- // Get the milliseconds passed from an initial tick value. GetMillisecondsAndReset :: proc(ticks: ^u64) -> f32 --- // Yield to be used in a busy loop. Yield :: proc() --- // Sleep the current thread for a number of milliseconds. Sleep :: proc(milliseconds: c.int) --- // Simple djb2 hash function for determinism testing Hash :: proc(hash: u32, data: [^]u8, count: c.int) -> u32 --- // // Dump file support functions // WriteBinaryFile :: proc(data: rawptr, size: c.int, fileName: cstring) --- // ReadBinaryFile :: proc(prefix: cstring, fileName: cstring, memSize: ^c.int) -> rawptr --- } @(disabled=ODIN_DISABLE_ASSERT) ASSERT :: proc "c" (condition: bool, message := #caller_expression(condition), loc := #caller_location) { if !condition { @(cold) internal :: proc "c" (message: string, loc: runtime.Source_Code_Location) { _ = InternalAssert(cstring(raw_data(message)), cstring(raw_data(loc.file_path)), loc.line) } internal(message, loc) } } @(disabled=!ENABLE_VALIDATION) VALIDATE :: proc "c" (condition: bool, message := #caller_expression(condition), loc := #caller_location) { ASSERT(condition, message, loc) } /** * @defgroup world World * These functions allow you to create a simulation world. * * You can add rigid bodies and joint constraints to the world and run the simulation. You can get contact * information to get contact points and normals as well as events. You can query the world, checking for overlaps and casting * rays or shapes. There is also debugging information such as debug draw, timing information, and counters. You can find * documentation here: https://box2d.org/ * @{ */ // Opaque recording handle. Create with CreateRecording, destroy with DestroyRecording. Recording :: struct{} // Opaque incremental replay player with a keyframe ring for O(interval) backward seek. RecPlayer :: struct{} // Summary of a recording, read once at open so a viewer can frame and label it. RecPlayerInfo :: struct { frameCount: c.int, // total recorded steps workerCount: c.int, // worker count requested for the replay world timeStep: f32, // dt of the recorded steps subStepCount: c.int, // recorded sub-steps lengthScale: f32, // length units per meter in effect when recorded bounds: AABB, // accumulated world bounds over the recording, zero-extent if unavailable } // The kind of a recorded spatial query, matching the public query and cast functions. RecQueryType :: enum c.int { OverlapAABB, OverlapShape, CastRay, CastShape, CastRayClosest, CastMover, CollideMover, } // A spatial query recorded during a replayed frame, exposed for inspection. RecQueryInfo :: struct { type: RecQueryType, filter: QueryFilter, aabb: AABB, // world-space bounds of the query, swept for casts origin: Pos, // query origin (zero for overlap AABB) translation: Vec3, // ray and cast translation hitCount: c.int, // number of recorded results key: u64, // identity key, the hash of (id, name), 0 if untagged id: u64, // query id, 0 if none name: cstring, // query label, NULL if none } // One result of a recorded spatial query. RecQueryHit :: struct { shape: ShapeId, point: Pos, normal: Vec3, fraction: f32, } @(link_prefix="b3", default_calling_convention="c", require_results) foreign lib { // Create a world for rigid body simulation. A world contains bodies, shapes, and constraints. You may create // up to 128 worlds. Each world is completely independent and may be simulated in parallel. // @return the world id. CreateWorld :: proc(#by_ptr def: WorldDef) -> WorldId --- // Destroy a world DestroyWorld :: proc(worldId: WorldId) --- // Get the current number of worlds GetWorldCount :: proc() -> c.int --- // Get the maximum number of simultaneous worlds that have been created GetMaxWorldCount :: proc() -> c.int --- // 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. Usually 1/60. // @param subStepCount The number of sub-steps, increasing the sub-step count can increase accuracy. Usually 4. World_Step :: proc(worldId: WorldId, timeStep: f32, subStepCount: c.int) --- // Call this to draw shapes and other debug draw data World_Draw :: proc(worldId: WorldId, draw: ^DebugDraw, maskBits: u64) --- // Get the world's bounds. This is the bounding box that covers the current simulation. May have a small // amount of padding. World_GetBounds :: proc(worldId: WorldId) -> AABB --- // Get the body events for the current time step. The event data is transient. Do not store a reference to this data. World_GetBodyEvents :: proc(worldId: WorldId) -> BodyEvents --- // Get sensor events for the current time step. The event data is transient. Do not store a reference to this data. World_GetSensorEvents :: proc(worldId: WorldId) -> SensorEvents --- // Get contact events for this current time step. The event data is transient. Do not store a reference to this data. World_GetContactEvents :: proc(worldId: WorldId) -> ContactEvents --- // Get the joint events for the current time step. The event data is transient. Do not store a reference to this data. World_GetJointEvents :: proc(worldId: WorldId) -> JointEvents --- // Overlap test for all shapes that *potentially* overlap the provided AABB World_OverlapAABB :: proc(worldId: WorldId, aabb: AABB, filter: QueryFilter, fcn: OverlapResultFcn, ctx: rawptr) -> TreeStats --- // Overlap test for all shapes that overlap the provided shape proxy. The proxy points are relative // to the world origin, which lets the query stay precise far from the world origin. World_OverlapShape :: proc(worldId: WorldId, origin: Pos, #by_ptr proxy: ShapeProxy, filter: QueryFilter, fcn: OverlapResultFcn, ctx: rawptr) -> TreeStats --- // 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. // @note The callback function may receive shapes in any order // @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 // @return traversal performance counters World_CastRay :: proc(worldId: WorldId, origin: Pos, translation: Vec3, filter: QueryFilter, fcn: CastResultFcn, ctx: rawptr) -> TreeStats --- // Cast a ray into the world to collect the closest hit. This is a convenience function. Ignores initial overlap. // This is less general than World_CastRay() and does not allow for custom filtering. World_CastRayClosest :: proc(worldId: WorldId, origin: Pos, translation: Vec3, filter: QueryFilter) -> RayResult --- // Cast a shape through the world. Similar to a cast ray except that a shape is cast instead of a point. // The proxy points are relative to the origin and the hit points come back as world positions, so the // cast stays precise far from the world origin. // @see World_CastRay World_CastShape :: proc(worldId: WorldId, origin: Pos, #by_ptr proxy: ShapeProxy, translation: Vec3, filter: QueryFilter, fcn: CastResultFcn, ctx: rawptr) -> TreeStats --- // Cast a capsule mover through the world. This is a special shape cast that handles sliding along other shapes while reducing // clipping. This is not a good source of information about what the mover is touching. Instead use the planes returned by // World_CollideMover. // @param worldId World to cast the mover against // @param origin World position the mover capsule is relative to // @param mover Capsule mover, relative to the origin // @param translation Desired mover translation // @param filter Contains bit flags to filter unwanted shapes from the results // @param fcn Optional callback for custom shape filtering // @param context A user context that is passed along to the callback function // @return the translation fraction World_CastMover :: proc(worldId: WorldId, origin: Pos, #by_ptr mover: Capsule, translation: Vec3, filter: QueryFilter, fcn: MoverFilterFcn, ctx: rawptr) -> f32 --- // Collide a capsule mover with the world, gathering collision planes that can be fed to SolvePlanes. Useful for // kinematic character movement. The mover and the returned planes are relative to the origin. World_CollideMover :: proc(worldId: WorldId, origin: Pos, #by_ptr mover: Capsule, filter: QueryFilter, fcn: PlaneResultFcn, ctx: rawptr) --- // Enable/disable sleep. If your application does not need sleeping, you can gain some performance // by disabling sleep completely at the world level. // @see WorldDef World_EnableSleeping :: proc(worldId: WorldId, flag: bool) --- // Is body sleeping enabled? World_IsSleepingEnabled :: proc(worldId: WorldId) -> bool --- // Enable/disable continuous collision between dynamic and static bodies. Generally you should keep continuous // collision enabled to prevent fast moving objects from going through static objects. The performance gain from // disabling continuous collision is minor. // @see WorldDef World_EnableContinuous :: proc(worldId: WorldId, flag: bool) --- // Is continuous collision enabled? World_IsContinuousEnabled :: proc(worldId: WorldId) -> bool --- // Adjust the restitution threshold. It is recommended not to make this value very small // because it will prevent bodies from sleeping. Usually in meters per second. // @see WorldDef World_SetRestitutionThreshold :: proc(worldId: WorldId, value: f32) --- // Get the restitution speed threshold. Usually in meters per second. World_GetRestitutionThreshold :: proc(worldId: WorldId) -> f32 --- // Adjust the hit event threshold. This controls the collision speed needed to generate a ContactHitEvent. // Usually in meters per second. // @see WorldDef::hitEventThreshold World_SetHitEventThreshold :: proc(worldId: WorldId, value: f32) --- // Get the hit event speed threshold. Usually in meters per second. World_GetHitEventThreshold :: proc(worldId: WorldId) -> f32 --- // Register the custom filter callback. This is optional. World_SetCustomFilterCallback :: proc(worldId: WorldId, fcn: CustomFilterFcn, ctx: rawptr) --- // Register the pre-solve callback. This is optional. World_SetPreSolveCallback :: proc(worldId: WorldId, fcn: PreSolveFcn, ctx: rawptr) --- // Set the gravity vector for the entire world. Box3D has no concept of an up direction and this // is left as a decision for the application. Usually in m/s^2. // @see WorldDef World_SetGravity :: proc(worldId: WorldId, gravity: Vec3) --- // Get the gravity vector World_GetGravity :: proc(worldId: WorldId) -> Vec3 --- // Apply a radial explosion // @param worldId The world id // @param explosionDef The explosion definition World_Explode :: proc(worldId: WorldId, #by_ptr explosionDef: ExplosionDef) --- // 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 contactSpeed The maximum contact constraint push out speed (meters per second) // @note Advanced feature World_SetContactTuning :: proc(worldId: WorldId, hertz: f32, dampingRatio: f32, contactSpeed: f32) --- // Set the contact point recycling distance. Setting this to zero disables contact point recycling. // Usually in meters. World_SetContactRecycleDistance :: proc(worldId: WorldId, recycleDistance: f32) --- // Get the contact point recycling distance. Usually in meters. World_GetContactRecycleDistance :: proc(worldId: WorldId) -> f32 --- // Set the maximum linear speed. Usually in m/s. World_SetMaximumLinearSpeed :: proc(worldId: WorldId, maximumLinearSpeed: f32) --- // Get the maximum linear speed. Usually in m/s. World_GetMaximumLinearSpeed :: proc(worldId: WorldId) -> f32 --- // Enable/disable constraint warm starting. Advanced feature for testing. Disabling // warm starting greatly reduces stability and provides no performance gain. World_EnableWarmStarting :: proc(worldId: WorldId, flag: bool) --- // Is constraint warm starting enabled? World_IsWarmStartingEnabled :: proc(worldId: WorldId) -> bool --- // Get the number of awake bodies World_GetAwakeBodyCount :: proc(worldId: WorldId) -> c.int --- // Get the current world performance profile World_GetProfile :: proc(worldId: WorldId) -> Profile --- // Get world counters and sizes World_GetCounters :: proc(worldId: WorldId) -> Counters --- // Get max capacity. This can be used with WorldDef to avoid run-time allocations and copies World_GetMaxCapacity :: proc(worldId: WorldId) -> Capacity --- // Set the user data pointer. World_SetUserData :: proc(worldId: WorldId, userData: rawptr) --- // Get the user data pointer. World_GetUserData :: proc(worldId: WorldId) -> rawptr --- // Set the friction callback. Passing NULL resets to default. World_SetFrictionCallback :: proc(worldId: WorldId, callback: FrictionCallback) --- // Set the restitution callback. Passing NULL resets to default. World_SetRestitutionCallback :: proc(worldId: WorldId, callback: RestitutionCallback) --- // Set the worker count. Must be in the range [1, B3_MAX_WORKERS] World_SetWorkerCount :: proc(worldId: WorldId, count: c.int) --- // Get the worker count. World_GetWorkerCount :: proc(worldId: WorldId) -> c.int --- // Dump memory stats to log. World_DumpMemoryStats :: proc(worldId: WorldId) --- // Dump shape bounds to box3d_bounds.txt World_DumpShapeBounds :: proc(worldId: WorldId, type: BodyType) --- // This is for internal testing World_RebuildStaticTree :: proc(worldId: WorldId) --- // This is for internal testing World_EnableSpeculative :: proc(worldId: WorldId, flag: bool) --- // Dump world to a text file. Saves only awake bodies and associated static bodies. // Meshes are saved to binary m files. World_DumpAwake :: proc(worldId: WorldId) --- // Dump world to a text file. Meshes are saved to binary m files. World_Dump :: proc(worldId: WorldId) --- /** * @defgroup recording Recording * @brief Record and replay world state for debugging. * @{ */ // Create a recording buffer with an optional initial byte capacity. // Pass 0 to use the default (64 KiB). The buffer grows on demand. // @return a new recording, owned by the caller CreateRecording :: proc(byteCapacity: c.int) -> Recording --- // Destroy a recording and free its buffer. // @param recording may be NULL DestroyRecording :: proc(recording: ^Recording) --- // Get a pointer to the raw recording bytes. // Valid until the recording buffer is modified or destroyed. // @param recording the recording handle // @return pointer to the byte buffer, or NULL if no bytes have been written Recording_GetData :: proc(#by_ptr recording: Recording) -> [^]u8 --- // Get the number of bytes currently in the recording buffer. // @param recording the recording handle Recording_GetSize :: proc(#by_ptr recording: Recording) -> c.int --- // Begin recording world mutations into the provided buffer. // The buffer is reset on each call so a single Recording can be reused for multiple sessions. // @param worldId the world to record // @param recording the recording handle to write into World_StartRecording :: proc(worldId: WorldId, recording: ^Recording) --- // End the current recording session. Writes the trailing geometry registry and // backpatches the header. The buffer remains valid until the recording is destroyed. // @param worldId the world currently being recorded World_StopRecording :: proc(worldId: WorldId) --- // Save the recording buffer to a file. Returns true on success. // @param recording the recording to save // @param path file path to write SaveRecordingToFile :: proc(#by_ptr recording: Recording, path: cstring) -> bool --- // Load a recording from a file. Returns NULL on failure (file not found, wrong magic). // The caller owns the returned recording and must destroy it with DestroyRecording. // @param path file path to read LoadRecordingFromFile :: proc(path: cstring) -> Recording --- // Replay a recording from memory and verify it reproduces the same world-state hashes. // Stands up a fresh world, restores the seed snapshot, replays every op, and checks each embedded // StateHash record. Returns true if replay completed without id mismatches or hash divergences. // @param data pointer to recording bytes // @param size byte count of the recording // @param workerCount reserved for future multithreaded replay; pass 1 for now ValidateReplay :: proc(data: rawptr, size: c.int, workerCount: c.int) -> bool --- // Create a player over a recording. Owns a private copy of the bytes. // @param data pointer to recording bytes // @param size byte count of the recording // @param workerCount worker count for the replay world; pass 1 to match a serial recording. // Replaying at a different count re-partitions the constraint graph, so the StateHash check // becomes a cross-thread determinism test. Adjustable later with RecPlayer_SetWorkerCount. // @return a new player, or NULL on bad header or deserialization failure RecPlayer_Create :: proc(data: rawptr, size: c.int, workerCount: c.int) -> RecPlayer --- // Destroy the player and free all memory. Restores the previous global length scale. RecPlayer_Destroy :: proc(player: ^RecPlayer) --- // Advance one frame: dispatch ops until the next Step completes. // @return true when a frame was stepped, false at end-of-recording RecPlayer_StepFrame :: proc(player: ^RecPlayer) -> bool --- // Sub-step one frame. This will sub-step and return immediately after body creation. // The next call will execute the time step. This allows bodies to be rendered // at the creation pose. RecPlayer_SubStepFrame :: proc(player: ^RecPlayer) --- // Rewind to frame 0 (in-place restore so the world id stays stable). RecPlayer_Restart :: proc(player: ^RecPlayer) --- // Seek to a specific frame. Forward seek steps op-by-op; backward seek restores // the nearest keyframe then re-steps the remaining gap. RecPlayer_SeekFrame :: proc(player: ^RecPlayer, targetFrame: c.int) --- // @return the world currently driven by this player RecPlayer_GetWorldId :: proc(#by_ptr player: RecPlayer) -> WorldId --- // @return the last fully-stepped frame index (0 before any step) RecPlayer_GetFrame :: proc(#by_ptr player: RecPlayer) -> c.int --- // @return total number of recorded frames RecPlayer_GetFrameCount :: proc(#by_ptr player: RecPlayer) -> c.int --- // @return true when the op stream is exhausted RecPlayer_IsAtEnd :: proc(#by_ptr player: RecPlayer) -> bool --- // @return true when the op stream is paused between body creation and world step. RecPlayer_IsAtPreStep :: proc(#by_ptr player: RecPlayer) -> bool --- // @return true when any StateHash mismatch has been detected RecPlayer_HasDiverged :: proc(#by_ptr player: RecPlayer) -> bool --- // @return a summary of the recording read at open: frame count, recorded tuning, and bounds RecPlayer_GetInfo :: proc(#by_ptr player: RecPlayer) -> RecPlayerInfo --- // @return the first frame at which replay diverged, or -1 if it has not diverged RecPlayer_GetDivergeFrame :: proc(#by_ptr player: RecPlayer) -> c.int --- // Set the worker count of the replay world. Clamped to [1, B3_MAX_WORKERS]. Applied to the live // world at once and reused whenever the player rebuilds its world on Restart or a backward seek. // Replaying at a different count than recorded re-partitions the constraint graph, so the StateHash // check becomes a cross-thread determinism test. RecPlayer_SetWorkerCount :: proc(player: ^RecPlayer, count: c.int) --- // Tune the keyframe ring used to speed up backward seeking. A keyframe is a periodic snapshot the // player restores from instead of replaying from the start, trading memory for seek speed. // @param player the recording player // @param budgetBytes memory cap for the kept snapshots; the spacing widens to stay under it // @param minIntervalFrames finest spacing between keyframes, in frames // A zero budget or a non-positive interval keeps that value. Clears the existing ring, so call // RecPlayer_Restart afterward to repopulate it under the new policy. RecPlayer_SetKeyframePolicy :: proc(player: ^RecPlayer, budgetBytes: uint, minIntervalFrames: c.int) --- // @return the keyframe memory budget in bytes RecPlayer_GetKeyframeBudget :: proc(#by_ptr player: RecPlayer) -> uint --- // @return the finest keyframe spacing in frames RecPlayer_GetKeyframeMinInterval :: proc(#by_ptr player: RecPlayer) -> c.int --- // @return the current keyframe spacing in frames; starts at the min interval and doubles as the // ring evicts to stay under budget, so it reflects the effective backward-seek granularity now RecPlayer_GetKeyframeInterval :: proc(#by_ptr player: RecPlayer) -> c.int --- // @return the memory currently held by keyframe snapshots, in bytes RecPlayer_GetKeyframeBytes :: proc(#by_ptr player: RecPlayer) -> uint --- // @return the number of bodies tracked in creation order (including holes for destroyed bodies) RecPlayer_GetBodyCount :: proc(#by_ptr player: RecPlayer) -> c.int --- // Resolve a creation ordinal to the live body id at the current frame. // @return the body id, or a null id if that ordinal is out of range or its body is destroyed RecPlayer_GetBodyId :: proc(#by_ptr player: RecPlayer, index: c.int) -> BodyId --- // Wire host debug-shape callbacks into the player's replay world so a renderer can build // per-shape draw resources (the 3D sample needs this or the replay world draws nothing). // Rebuilds the current world under the new callbacks and rewinds to frame 0, so call it // once right after RecPlayer_Create and re-read the world id afterward. The callbacks // persist across Restart and backward seeks, which recreate the world internally. // @param player the player to configure // @param createDebugShape called when a replayed shape is added; returns a user draw handle // @param destroyDebugShape called when a replayed shape is removed; may be NULL // @param context user context passed to both callbacks RecPlayer_SetDebugShapeCallbacks :: proc(player: ^RecPlayer, createDebugShape: CreateDebugShapeCallback, destroyDebugShape: DestroyDebugShapeCallback, ctx: rawptr) --- // Draw the spatial queries recorded during the most recently replayed frame, layered on top of the // world. Call after World_Draw. NULL draw function pointers are skipped. // @param player a valid player handle // @param draw debug draw callbacks // @param queryIndex index of the frame query to draw, or -1 to draw all of them // @param selectedIndex index of the query to emphasize (reserved color plus a label), or -1 for none RecPlayer_DrawFrameQueries :: proc(player: ^RecPlayer, draw: ^DebugDraw, queryIndex: c.int, selectedIndex: c.int) --- // @return the number of spatial queries recorded for the most recently replayed frame RecPlayer_GetFrameQueryCount :: proc(#by_ptr player: RecPlayer) -> c.int --- // Get a recorded query from the most recently replayed frame by index. RecPlayer_GetFrameQuery :: proc(#by_ptr player: RecPlayer, index: c.int) -> RecQueryInfo --- // Get one result of a recorded query from the most recently replayed frame. RecPlayer_GetFrameQueryHit :: proc(#by_ptr player: RecPlayer, queryIndex: c.int, hitIndex: c.int) -> RecQueryHit --- /**@}*/ // recording /** @} */ // world /** * @defgroup body Body * This is the body API. * @{ */ // Create a rigid body given a definition. No reference to the definition is retained. So you can create the definition // on the stack and pass it as a pointer. // @code{.c} // BodyDef bodyDef = DefaultBodyDef(); // BodyId myBodyId = CreateBody(myWorldId, &bodyDef); // @endcode // @warning This function is locked during callbacks. CreateBody :: proc(worldId: WorldId, #by_ptr def: BodyDef) -> BodyId --- // Destroy a rigid body given an id. This destroys all shapes and joints attached to the body. // Do not keep references to the associated shapes and joints. DestroyBody :: proc(bodyId: BodyId) --- // Body identifier validation. A valid body exists in a world and is non-null. // This can be used to detect orphaned ids. Provides validation for up to 64K allocations. Body_IsValid :: proc(id: BodyId) -> bool --- // Get the body type: static, kinematic, or dynamic Body_GetType :: proc(bodyId: BodyId) -> BodyType --- // Change the body type. This is an expensive operation. This automatically updates the mass // properties regardless of the automatic mass setting. Body_SetType :: proc(bodyId: BodyId, type: BodyType) --- // Set the body name. Body_SetName :: proc(bodyId: BodyId, name: cstring) --- // Get the body name. Body_GetName :: proc(bodyId: BodyId) -> cstring --- // Set the user data for a body Body_SetUserData :: proc(bodyId: BodyId, userData: rawptr) --- // Get the user data stored in a body Body_GetUserData :: proc(bodyId: BodyId) -> rawptr --- // Get the world position of a body. This is the location of the body origin. Body_GetPosition :: proc(bodyId: BodyId) -> Pos --- // Get the world rotation of a body as a quaternion Body_GetRotation :: proc(bodyId: BodyId) -> Quat --- // Get the world transform of a body. Body_GetTransform :: proc(bodyId: BodyId) -> WorldTransform --- // Set the world transform of a body. This acts as a teleport and is fairly expensive. // @note Generally you should create a body with the intended transform. // @see BodyDef::position and BodyDef::rotation Body_SetTransform :: proc(bodyId: BodyId, position: Pos, rotation: Quat) --- // Get a local point on a body given a world point Body_GetLocalPoint :: proc(bodyId: BodyId, worldPoint: Pos) -> Vec3 --- // Get a world point on a body given a local point Body_GetWorldPoint :: proc(bodyId: BodyId, localPoint: Vec3) -> Pos --- // Get a local vector on a body given a world vector Body_GetLocalVector :: proc(bodyId: BodyId, worldVector: Vec3) -> Vec3 --- // Get a world vector on a body given a local vector Body_GetWorldVector :: proc(bodyId: BodyId, localVector: Vec3) -> Vec3 --- // Get the linear velocity of a body's center of mass. Usually in meters per second. Body_GetLinearVelocity :: proc(bodyId: BodyId) -> Vec3 --- // Get the angular velocity of a body in radians per second Body_GetAngularVelocity :: proc(bodyId: BodyId) -> Vec3 --- // Set the linear velocity of a body. Usually in meters per second. Body_SetLinearVelocity :: proc(bodyId: BodyId, linearVelocity: Vec3) --- // Set the angular velocity of a body in radians per second Body_SetAngularVelocity :: proc(bodyId: BodyId, angularVelocity: Vec3) --- // Set the velocity to reach the given transform after a given time step. // The result will be close but maybe not exact. This is meant for kinematic bodies. // The target is not applied if the velocity would be below the sleep threshold. // This will optionally wake the body if asleep, but only if the movement is significant. Body_SetTargetTransform :: proc(bodyId: BodyId, target: WorldTransform, timeStep: f32, wake: bool) --- // Get the linear velocity of a local point attached to a body. Usually in meters per second. Body_GetLocalPointVelocity :: proc(bodyId: BodyId, localPoint: Vec3) -> Vec3 --- // Get the linear velocity of a world point attached to a body. Usually in meters per second. Body_GetWorldPointVelocity :: proc(bodyId: BodyId, worldPoint: Pos) -> Vec3 --- // 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, usually 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: Vec3, point: Pos, wake: bool) --- // Apply a force to the center of mass. This optionally wakes up the body. // The force is ignored if the body is not awake. // @param bodyId The body id // @param force the world force vector, usually in newtons (N). // @param wake also wake up the body Body_ApplyForceToCenter :: proc(bodyId: BodyId, force: Vec3, 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 the world torque vector, usually in N*m. // @param wake also wake up the body Body_ApplyTorque :: proc(bodyId: BodyId, torque: Vec3, 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, usually 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: Vec3, point: Pos, 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, usually 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: Vec3, wake: bool) --- // Apply an angular impulse in world space. The impulse is ignored if the body is not awake. // This optionally wakes the body. // @param bodyId The body id // @param impulse the world angular impulse vector, usually 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 torque, // use a torque instead, which will work better with the sub-stepping solver. Body_ApplyAngularImpulse :: proc(bodyId: BodyId, impulse: Vec3, wake: bool) --- // Get the mass of the body, usually in kilograms Body_GetMass :: proc(bodyId: BodyId) -> f32 --- // Get the rotational inertia of the body in local space, usually in kg*m^2 Body_GetLocalRotationalInertia :: proc(bodyId: BodyId) -> Matrix3 --- // Get the inverse mass of the body, usually in 1/kilograms Body_GetInverseMass :: proc(bodyId: BodyId) -> f32 --- // Get the inverse rotational inertia of the body in world space, usually in 1/kg*m^2 Body_GetWorldInverseRotationalInertia :: proc(bodyId: BodyId) -> Matrix3 --- // Get the center of mass position of the body in local space Body_GetLocalCenter :: proc(bodyId: BodyId) -> Vec3 --- // Get the center of mass position of the body in world space Body_GetWorldCenter :: proc(bodyId: BodyId) -> Pos --- // Override the body's mass properties. Normally this is computed automatically using the // shape geometry and density. This information is lost if a shape is added or removed or if the // body type changes. Body_SetMassData :: proc(bodyId: BodyId, massData: MassData) --- // Get the mass data for a body Body_GetMassData :: proc(bodyId: BodyId) -> MassData --- // This updates 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) --- // Adjust the linear damping. Normally this is set in BodyDef before creation. Body_SetLinearDamping :: proc(bodyId: BodyId, linearDamping: f32) --- // Get the current linear damping. Body_GetLinearDamping :: proc(bodyId: BodyId) -> f32 --- // Adjust the angular damping. Normally this is set in BodyDef before creation. Body_SetAngularDamping :: proc(bodyId: BodyId, angularDamping: f32) --- // Get the current angular damping. Body_GetAngularDamping :: proc(bodyId: BodyId) -> f32 --- // Adjust the gravity scale. Normally this is set in BodyDef before creation. // @see BodyDef::gravityScale Body_SetGravityScale :: proc(bodyId: BodyId, gravityScale: f32) --- // Get the current gravity scale Body_GetGravityScale :: proc(bodyId: BodyId) -> f32 --- // @return true if this body is awake Body_IsAwake :: proc(bodyId: BodyId) -> bool --- // Wake a body from sleep. This wakes the entire island the body is touching. // @warning Putting a body to sleep will put the entire island of bodies touching this body to sleep, // which can be expensive and possibly unintuitive. Body_SetAwake :: proc(bodyId: BodyId, awake: bool) --- // Enable or disable sleeping for this body. If sleeping is disabled the body will wake. Body_EnableSleep :: proc(bodyId: BodyId, enableSleep: bool) --- // Returns true if sleeping is enabled for this body Body_IsSleepEnabled :: proc(bodyId: BodyId) -> bool --- // Set the sleep threshold, usually in meters per second Body_SetSleepThreshold :: proc(bodyId: BodyId, sleepThreshold: f32) --- // Get the sleep threshold, usually in meters per second. Body_GetSleepThreshold :: proc(bodyId: BodyId) -> f32 --- // Returns true if this body is enabled Body_IsEnabled :: proc(bodyId: BodyId) -> bool --- // Disable a body by removing it completely from the simulation. This is expensive. Body_Disable :: proc(bodyId: BodyId) --- // Enable a body by adding it to the simulation. This is expensive. Body_Enable :: proc(bodyId: BodyId) --- // Set the motion locks on this body. Body_SetMotionLocks :: proc(bodyId: BodyId, locks: MotionLocks) --- // Get the motion locks for this body. Body_GetMotionLocks :: proc(bodyId: BodyId) -> MotionLocks --- // Set this body to be a bullet. A bullet does continuous collision detection // against dynamic bodies (but not other bullets). Body_SetBullet :: proc(bodyId: BodyId, flag: bool) --- // Is this body a bullet? Body_IsBullet :: proc(bodyId: BodyId) -> bool --- // Allow this body to rotate fast. Useful for axially symmetric bodies, such as vehicle wheels. // Normally rotation speed is clamped to improve CCD. However, this clamping is unnecessary for // bodies that only rotate fast around an axis of symmetry. Body_AllowFastRotation :: proc(bodyId: BodyId, flag: bool) --- // Is this body allowed to rotate fast? Body_IsFastRotationAllowed :: proc(bodyId: BodyId) -> bool --- // Enable or disable contact recycling for this body. Contact recycling is a performance optimization // that reuses contact manifolds when bodies move slightly. Disabling it can avoid ghost collisions // on characters at the cost of higher per-step work. Existing contacts retain their prior setting; // only contacts created after this call see the new value. // @see BodyDef::enableContactRecycling Body_EnableContactRecycling :: proc(bodyId: BodyId, flag: bool) --- // Is contact recycling enabled on this body? Body_IsContactRecyclingEnabled :: proc(bodyId: BodyId) -> bool --- // Enable/disable hit events on all shapes // @see ShapeDef::enableHitEvents Body_EnableHitEvents :: proc(bodyId: BodyId, flag: bool) --- // Get the world that owns this body Body_GetWorld :: proc(bodyId: BodyId) -> WorldId --- // Get the number of shapes on this body Body_GetShapeCount :: proc(bodyId: BodyId) -> c.int --- // 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(bodyId: BodyId, shapeArray: [^]ShapeId, capacity: c.int) -> c.int --- // Get the number of joints on this body Body_GetJointCount :: proc(bodyId: BodyId) -> 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 Body_GetJoints :: proc(bodyId: BodyId, jointArray: [^]JointId, capacity: c.int) -> c.int --- // Get the maximum capacity required for retrieving all the touching contacts on a body Body_GetContactCapacity :: proc(bodyId: BodyId) -> c.int --- // Get the touching contact data for a body Body_GetContactData :: proc(bodyId: BodyId, contactData: [^]ContactData, capacity: c.int) -> c.int --- // Get the current world AABB that contains all the attached shapes. Note that this may not encompass the body origin. // If there are no shapes attached then the returned AABB is empty and centered on the body origin. Body_ComputeAABB :: proc(bodyId: BodyId) -> AABB --- // Get the closest point on a body to a world target. Body_GetClosestPoint :: proc(bodyId: BodyId, result: ^Vec3, target: Vec3) -> f32 --- // Cast a ray at a specific body using a specified body transform. Body_CastRay :: proc(bodyId: BodyId, origin: Pos, translation: Vec3, filter: QueryFilter, maxFraction: f32, bodyTransform: WorldTransform) -> BodyCastResult --- // Cast a shape at a specific body using a specified body transform. Body_CastShape :: proc(bodyId: BodyId, origin: Pos, #by_ptr proxy: ShapeProxy, translation: Vec3, filter: QueryFilter, maxFraction: f32, canEncroach: b32, bodyTransform: WorldTransform) -> BodyCastResult --- // Overlap a shape with a specific body using a specified body transform. Body_OverlapShape :: proc(bodyId: BodyId, origin: Pos, #by_ptr proxy: ShapeProxy, filter: QueryFilter, bodyTransform: WorldTransform) -> bool --- // Collide a character mover with a specific body using a specified body transform. Body_CollideMover :: proc(bodyId: BodyId, bodyPlanes: [^]BodyPlaneResult, planeCapacity: c.int, origin: Pos, #by_ptr mover: Capsule, filter: QueryFilter, bodyTransform: WorldTransform) -> c.int --- /** @} */ // body /** * @defgroup shape Shape * Functions to create, destroy, and access. * Shapes bind raw geometry to bodies and hold material properties including friction and restitution. * You may add multiple shapes to a single body. There are no hard limits on shape count per body. * * When you create a shape on a body the center of mass moves. This can lead to the body linear velocity * changing if the angular velocity is non-zero. * @{ */ // 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 CreateSphereShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, sphere: ^Sphere) -> ShapeId --- // Create a capsule shape and attach it to a body. The shape definition and geometry are fully cloned. // Contacts are not created until the next time step. // @return the shape id for accessing the shape CreateCapsuleShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, capsule: ^Capsule) -> ShapeId --- // Create a convex hull shape and attach it to a body. The shape definition is fully cloned. Contacts are not created // until the next time step. // @return the shape id for accessing the shape CreateHullShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, hull: ^HullData) -> ShapeId --- // Create a convex hull shape and attach it to a body. The hull is cloned then transformed with scale applied first. // Use this for non-uniform or mirrored scale or a baked local transform. The baked result is shared through the // world hull database. 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 CreateTransformedHullShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, hull: ^HullData, transform: Transform, scale: Vec3) -> ShapeId --- // Create a mesh hull shape and attach it to a body. The shape definition is fully cloned but the mesh is not. // Contacts are not created until the next time step. // Mesh collision only creates contacts on static bodies. // @warning this holds reference to the input mesh data which must remain valid for the lifetime of this shape // @return the shape id for accessing the shape CreateMeshShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, mesh: ^MeshData, scale: Vec3) -> ShapeId --- // Create a height-field shape and attach it to a body. The shape definition is fully cloned but the height field is not. // Contacts are not created until the next time step. // Height field is only allowed on static bodies. // @warning this holds reference to the input height field which must remain valid for the lifetime of this shape // @return the shape id for accessing the shape CreateHeightFieldShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, heightField: ^HeightFieldData) -> ShapeId --- // Baked compound shapes are only allowed on static bodies. // Note: runtime compounds are achieved by adding multiple shapes to a body. // Runtime compounds can be dynamic and/or kinematic. CreateBakedCompoundShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, compound: ^CompoundData) -> ShapeId --- // Destroy a shape. You may defer the body mass update which can improve performance if several shapes on a // body are destroyed at once. // @see Body_ApplyMassFromShapes DestroyShape :: proc(shapeId: ShapeId, updateBodyMass: bool) --- // Shape identifier validation. Provides validation for up to 64K allocations. Shape_IsValid :: proc(id: ShapeId) -> bool --- // Get the type of a shape Shape_GetType :: proc(shapeId: ShapeId) -> ShapeType --- // Get the id of the body that a shape is attached to Shape_GetBody :: proc(shapeId: ShapeId) -> BodyId --- // Get the world that owns this shape Shape_GetWorld :: proc(shapeId: ShapeId) -> WorldId --- // Returns true if the shape is a sensor Shape_IsSensor :: proc(shapeId: ShapeId) -> bool --- // Set the shape name. Shape_SetName :: proc(shapeId: ShapeId, name: cstring) --- // Get the shape name. Returns an empty string if the name isn't set. Shape_GetName :: proc(shapeId: ShapeId) -> cstring --- // Set the user data for a shape Shape_SetUserData :: proc(shapeId: ShapeId, userData: rawptr) --- // Get the user data for a shape. This is useful when you get a shape id // from an event or query. Shape_GetUserData :: proc(shapeId: ShapeId) -> rawptr --- // Set the mass density of a shape, usually in kg/m^3. // This will optionally update the mass properties on the parent body. // @see ShapeDef::density, Body_ApplyMassFromShapes Shape_SetDensity :: proc(shapeId: ShapeId, density: f32, updateBodyMass: bool) --- // Get the density of a shape, usually in kg/m^3 Shape_GetDensity :: proc(shapeId: ShapeId) -> f32 --- // Set the friction on a shape Shape_SetFriction :: proc(shapeId: ShapeId, friction: f32) --- // Get the friction of a shape Shape_GetFriction :: proc(shapeId: ShapeId) -> f32 --- // Set the shape restitution (bounciness) Shape_SetRestitution :: proc(shapeId: ShapeId, restitution: f32) --- // Get the shape restitution Shape_GetRestitution :: proc(shapeId: ShapeId) -> f32 --- // Set the shape base surface material. Does not change per triangle materials. Shape_SetSurfaceMaterial :: proc(shapeId: ShapeId, surfaceMaterial: SurfaceMaterial) --- // Get the base shape surface material. Shape_GetSurfaceMaterial :: proc(shapeId: ShapeId) -> SurfaceMaterial --- // Get the number of mesh surface materials. Shape_GetMeshMaterialCount :: proc(shapeId: ShapeId) -> c.int --- // Set a surface material for a mesh shape. Shape_SetMeshMaterial :: proc(shapeId: ShapeId, surfaceMaterial: SurfaceMaterial, index: c.int) --- // Get a surface material for a mesh shape Shape_GetMeshSurfaceMaterial :: proc(shapeId: ShapeId, index: c.int) -> SurfaceMaterial --- // Get the shape filter Shape_GetFilter :: proc(shapeId: ShapeId) -> Filter --- // Set the current filter. This is almost as expensive as recreating the shape. // @see ShapeDef::filter // @param shapeId the shape // @param filter the new filter // @param invokeContacts if true then the shape will have all contacts recomputed the next time step (expensive) Shape_SetFilter :: proc(shapeId: ShapeId, filter: Filter, invokeContacts: bool) --- // Enable sensor events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. // @see ShapeDef::isSensor Shape_EnableSensorEvents :: proc(shapeId: ShapeId, flag: bool) --- // Returns true if sensor events are enabled Shape_AreSensorEventsEnabled :: proc(shapeId: ShapeId) -> bool --- // Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. // @see ShapeDef::enableContactEvents Shape_EnableContactEvents :: proc(shapeId: ShapeId, flag: bool) --- // Returns true if contact events are enabled Shape_AreContactEventsEnabled :: proc(shapeId: ShapeId) -> bool --- // Enable pre-solve contact events for this shape. Only applies to dynamic bodies. These are expensive // and must be carefully handled due to multithreading. Ignored for sensors. // @see PreSolveFcn Shape_EnablePreSolveEvents :: proc(shapeId: ShapeId, flag: bool) --- // Returns true if pre-solve events are enabled Shape_ArePreSolveEventsEnabled :: proc(shapeId: ShapeId) -> bool --- // Enable contact hit events for this shape. Ignored for sensors. // @see WorldDef.hitEventThreshold Shape_EnableHitEvents :: proc(shapeId: ShapeId, flag: bool) --- // Returns true if hit events are enabled Shape_AreHitEventsEnabled :: proc(shapeId: ShapeId) -> bool --- // Ray cast a shape directly. The ray runs from origin to origin + translation and the hit point // comes back as a world position, so the cast stays precise far from the world origin. Shape_RayCast :: proc(shapeId: ShapeId, origin: Pos, translation: Vec3) -> WorldCastOutput --- // Get a copy of the shape's sphere. Asserts the type is correct. Shape_GetSphere :: proc(shapeId: ShapeId) -> Sphere --- // Get a copy of the shape's capsule. Asserts the type is correct. Shape_GetCapsule :: proc(shapeId: ShapeId) -> Capsule --- // Get the shape's convex hull. Asserts the type is correct. Shape_GetHull :: proc(shapeId: ShapeId) -> ^HullData --- // Get the shape's mesh. Asserts the type is correct. Shape_GetMesh :: proc(shapeId: ShapeId) -> Mesh --- // Get the shape's height field. Asserts the type is correct. Shape_GetHeightField :: proc(shapeId: ShapeId) -> ^HeightFieldData --- // Allows you to change a shape to be a sphere or update the current sphere. // This does not modify the mass properties. // @see Body_ApplyMassFromShapes Shape_SetSphere :: proc(shapeId: ShapeId, #by_ptr sphere: Sphere) --- // Allows you to change a shape to be a capsule or update the current capsule. // This does not modify the mass properties. // @see Body_ApplyMassFromShapes Shape_SetCapsule :: proc(shapeId: ShapeId, #by_ptr capsule: Capsule) --- // Allows you to change a shape to be a hull or update the current hull. // This does not modify the mass properties. // @see Body_ApplyMassFromShapes Shape_SetHull :: proc(shapeId: ShapeId, #by_ptr hull: HullData) --- // Allows you to change a shape to be a mesh or update the current mesh. // This does not modify the mass properties. // @see Body_ApplyMassFromShapes Shape_SetMesh :: proc(shapeId: ShapeId, #by_ptr meshData: MeshData, scale: Vec3) --- // 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. // @note Box3D uses speculative collision so some contact points may be separated. // @returns the number of elements filled in the provided array // @warning do not ignore the return value, it specifies the valid number of elements Shape_GetContactData :: proc(shapeId: ShapeId, contactData: [^]ContactData, capacity: c.int) -> c.int --- // Get the maximum capacity required for retrieving all the overlapped shapes on a sensor shape. // This returns 0 if the provided shape is not a sensor. // @param shapeId the id of a sensor shape // @returns the required capacity to get all the overlaps in Shape_GetSensorOverlaps Shape_GetSensorCapacity :: proc(shapeId: ShapeId) -> c.int --- // Get the overlap data for a sensor shape. // @param shapeId the id of a sensor shape // @param visitorIds a user allocated array that is filled with the overlapping shapes (visitors) // @param capacity the capacity of overlappedShapes // @returns the number of elements filled in the provided array // @warning do not ignore the return value, it specifies the valid number of elements // @warning overlaps may contain destroyed shapes so use Shape_IsValid to confirm each overlap Shape_GetSensorData :: proc(shapeId: ShapeId, visitorIds: [^]ShapeId, capacity: c.int) -> c.int --- // Get the current world AABB Shape_GetAABB :: proc(shapeId: ShapeId) -> AABB --- // Compute the mass data for a shape Shape_ComputeMassData :: proc(shapeId: ShapeId) -> MassData --- // Get the closest point on a shape to a target point. Target and result are in world space. Shape_GetClosestPoint :: proc(shapeId: ShapeId, target: Vec3) -> Vec3 --- // Apply a wind force to the body for this shape using the density of air. This considers // the projected area of the shape in the wind direction. This also considers // the relative velocity of the shape. // @param shapeId the shape id // @param wind the wind velocity in world space // @param drag the drag coefficient, the force that opposes the relative velocity // @param lift the lift coefficient, the force that is perpendicular to the relative velocity // @param maxSpeed the maximum relative speed. Speed cap is necessary for stability. Typically 10m/s or less. // @param wake should this wake the body Shape_ApplyWind :: proc(shapeId: ShapeId, wind: Vec3 , drag, lift: f32, maxSpeed: f32, wake: bool) --- /** @} */ // shape /** * @defgroup joint Joint * @brief Joints allow you to connect rigid bodies together while allowing various forms of relative motions. * @{ */ // Destroy a joint DestroyJoint :: proc(jointId: JointId, wakeAttached: bool) --- // Joint identifier validation. Provides validation for up to 64K allocations. Joint_IsValid :: proc(id: JointId) -> bool --- // Get the joint type Joint_GetType :: proc(jointId: JointId) -> JointType --- // Get body A id on a joint Joint_GetBodyA :: proc(jointId: JointId) -> BodyId --- // Get body B id on a joint Joint_GetBodyB :: proc(jointId: JointId) -> BodyId --- // Get the world that owns this joint Joint_GetWorld :: proc(jointId: JointId) -> WorldId --- // Set the local frame on bodyA Joint_SetLocalFrameA :: proc(jointId: JointId, localFrame: Transform) --- // Get the local frame on bodyA Joint_GetLocalFrameA :: proc(jointId: JointId) -> Transform --- // Set the local frame on bodyB Joint_SetLocalFrameB :: proc(jointId: JointId, localFrame: Transform) --- // Get the local frame on bodyB Joint_GetLocalFrameB :: proc(jointId: JointId) -> Transform --- // Toggle collision between connected bodies Joint_SetCollideConnected :: proc(jointId: JointId, shouldCollide: bool) --- // Is collision allowed between connected bodies? Joint_GetCollideConnected :: proc(jointId: JointId) -> bool --- // Set the user data on a joint Joint_SetUserData :: proc(jointId: JointId, userData: rawptr) --- // Get the user data on a joint Joint_GetUserData :: proc(jointId: JointId) -> rawptr --- // Wake the bodies connect to this joint Joint_WakeBodies :: proc(jointId: JointId) --- // Get the current constraint force for this joint Joint_GetConstraintForce :: proc(jointId: JointId) -> Vec3 --- // Get the current constraint torque for this joint Joint_GetConstraintTorque :: proc(jointId: JointId) -> Vec3 --- // Get the current linear separation error for this joint. Does not consider admissible movement. Usually in meters. Joint_GetLinearSeparation :: proc(jointId: JointId) -> f32 --- // Get the current angular separation error for this joint. Does not consider admissible movement. Usually in radians. Joint_GetAngularSeparation :: proc(jointId: JointId) -> f32 --- // Set the joint constraint tuning. Advanced feature. // @param jointId the joint // @param hertz the stiffness in Hertz (cycles per second) // @param dampingRatio the non-dimensional damping ratio (one for critical damping) Joint_SetConstraintTuning :: proc(jointId: JointId, hertz: f32, dampingRatio: f32) --- // Get the joint constraint tuning. Advanced feature. Joint_GetConstraintTuning :: proc(jointId: JointId, hertz: ^f32, dampingRatio: ^f32) --- // Set the force threshold for joint events (Newtons) Joint_SetForceThreshold :: proc(jointId: JointId, threshold: f32) --- // Get the force threshold for joint events (Newtons) Joint_GetForceThreshold :: proc(jointId: JointId) -> f32 --- // Set the torque threshold for joint events (N-m) Joint_SetTorqueThreshold :: proc(jointId: JointId, threshold: f32) --- // Get the torque threshold for joint events (N-m) Joint_GetTorqueThreshold :: proc(jointId: JointId) -> f32 --- /** * @defgroup parallel_joint Parallel Joint * @brief Functions for the parallel joint. * @{ */ // Create a parallel joint // @see ParallelJointDef for details CreateParallelJoint :: proc(worldId: WorldId, #by_ptr def: ParallelJointDef) -> JointId --- // Set the spring stiffness in Hertz ParallelJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- // Set the spring damping ratio, non-dimensional ParallelJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the spring Hertz ParallelJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- // Get the spring damping ratio ParallelJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the maximum spring torque, usually in newton-meters ParallelJoint_SetMaxTorque :: proc(jointId: JointId, force: f32) --- // Get the maximum spring torque, usually in newton-meters ParallelJoint_GetMaxTorque :: proc(jointId: JointId) -> f32 --- /** @} */ // parallel_joint /** * @defgroup distance_joint Distance Joint * @brief Functions for the distance joint. * @{ */ // Create a distance joint // @see DistanceJointDef for details CreateDistanceJoint :: proc(worldId: WorldId, #by_ptr def: DistanceJointDef) -> JointId --- // Set the rest length of a distance joint // @param jointId The id for a distance joint // @param length The new distance joint length DistanceJoint_SetLength :: proc(jointId: JointId, length: f32) --- // Get the rest length of a distance joint DistanceJoint_GetLength :: proc(jointId: JointId) -> f32 --- // Enable/disable the distance joint spring. When disabled the distance joint is rigid. DistanceJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) --- // Is the distance joint spring enabled? DistanceJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool --- // Set the force range for the spring. DistanceJoint_SetSpringForceRange :: proc(jointId: JointId, lowerForce, upperForce: f32) --- // Get the force range for the spring. DistanceJoint_GetSpringForceRange :: proc(jointId: JointId, lowerForce, upperForce: ^f32) --- // Set the spring stiffness in Hertz DistanceJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- // Set the spring damping ratio, non-dimensional DistanceJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the spring Hertz DistanceJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- // Get the spring damping ratio DistanceJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- // Enable joint limit. The limit only works if the joint spring is enabled. Otherwise the joint is rigid // and the limit has no effect. DistanceJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) --- // Is the distance joint limit enabled? DistanceJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool --- // Set the minimum and maximum length parameters of a distance joint DistanceJoint_SetLengthRange :: proc(jointId: JointId, minLength, maxLength: f32) --- // Get the distance joint minimum length DistanceJoint_GetMinLength :: proc(jointId: JointId) -> f32 --- // Get the distance joint maximum length DistanceJoint_GetMaxLength :: proc(jointId: JointId) -> f32 --- // Get the current length of a distance joint DistanceJoint_GetCurrentLength :: proc(jointId: JointId) -> f32 --- // Enable/disable the distance joint motor DistanceJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- // Is the distance joint motor enabled? DistanceJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- // Set the distance joint motor speed, usually in meters per second DistanceJoint_SetMotorSpeed :: proc(jointId: JointId, motorSpeed: f32) --- // Get the distance joint motor speed, usually in meters per second DistanceJoint_GetMotorSpeed :: proc(jointId: JointId) -> f32 --- // Set the distance joint maximum motor force, usually in newtons DistanceJoint_SetMaxMotorForce :: proc(jointId: JointId, force: f32) --- // Get the distance joint maximum motor force, usually in newtons DistanceJoint_GetMaxMotorForce :: proc(jointId: JointId) -> f32 --- // Get the distance joint current motor force, usually in newtons DistanceJoint_GetMotorForce :: proc(jointId: JointId) -> f32 --- /** @} */ // distance_joint /** * @defgroup motor_joint Motor Joint * @brief Functions for the motor joint. * * The motor joint is designed to control the movement of a body while still being * responsive to collisions. A spring controls the position and rotation. A velocity motor * can be used to control velocity and allows for friction in top-down games. Both types * of control can be combined. For example, you can have a spring with friction. * Position and velocity control have force and torque limits. * @{ */ // Create a motor joint // @see MotorJointDef for details CreateMotorJoint :: proc(worldId: WorldId, #by_ptr def: MotorJointDef) -> JointId --- // Set the desired relative linear velocity in meters per second MotorJoint_SetLinearVelocity :: proc(jointId: JointId, velocity: Vec3) --- // Get the desired relative linear velocity in meters per second MotorJoint_GetLinearVelocity :: proc(jointId: JointId) -> Vec3 --- // Set the desired relative angular velocity in radians per second MotorJoint_SetAngularVelocity :: proc(jointId: JointId, velocity: Vec3) --- // Get the desired relative angular velocity in radians per second MotorJoint_GetAngularVelocity :: proc(jointId: JointId) -> Vec3 --- // Set the motor joint maximum force, usually in newtons MotorJoint_SetMaxVelocityForce :: proc(jointId: JointId, maxForce: f32) --- // Get the motor joint maximum force, usually in newtons MotorJoint_GetMaxVelocityForce :: proc(jointId: JointId) -> f32 --- // Set the motor joint maximum torque, usually in newton-meters MotorJoint_SetMaxVelocityTorque :: proc(jointId: JointId, maxTorque: f32) --- // Get the motor joint maximum torque, usually in newton-meters MotorJoint_GetMaxVelocityTorque :: proc(jointId: JointId) -> f32 --- // Set the spring linear hertz stiffness MotorJoint_SetLinearHertz :: proc(jointId: JointId, hertz: f32) --- // Get the spring linear hertz stiffness MotorJoint_GetLinearHertz :: proc(jointId: JointId) -> f32 --- // Set the spring linear damping ratio. Use 1.0 for critical damping. MotorJoint_SetLinearDampingRatio :: proc(jointId: JointId, damping: f32) --- // Get the spring linear damping ratio. MotorJoint_GetLinearDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the spring angular hertz stiffness MotorJoint_SetAngularHertz :: proc(jointId: JointId, hertz: f32) --- // Get the spring angular hertz stiffness MotorJoint_GetAngularHertz :: proc(jointId: JointId) -> f32 --- // Set the spring angular damping ratio. Use 1.0 for critical damping. MotorJoint_SetAngularDampingRatio :: proc(jointId: JointId, damping: f32) --- // Get the spring angular damping ratio. MotorJoint_GetAngularDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the maximum spring force in newtons. MotorJoint_SetMaxSpringForce :: proc(jointId: JointId, maxForce: f32) --- // Get the maximum spring force in newtons. MotorJoint_GetMaxSpringForce :: proc(jointId: JointId) -> f32 --- // Set the maximum spring torque in newtons * meters MotorJoint_SetMaxSpringTorque :: proc(jointId: JointId, maxTorque: f32) --- // Get the maximum spring torque in newtons * meters MotorJoint_GetMaxSpringTorque :: proc(jointId: JointId) -> f32 --- /**@}*/ // motor_joint /** * @defgroup filter_joint Filter Joint * @brief Functions for the filter joint. * * The filter joint is used to disable collision between two bodies. As a side effect of being a joint, it also * keeps the two bodies in the same simulation island. * @{ */ // Create a filter joint. // @see FilterJointDef for details CreateFilterJoint :: proc(worldId: WorldId, #by_ptr def: FilterJointDef) -> JointId --- /**@}*/ // filter_joint /** * @defgroup prismatic_joint Prismatic Joint * @brief A prismatic joint allows for translation along a single axis with no rotation. * * The prismatic joint is useful for things like pistons and moving platforms, where you want a body to translate * along an axis and have no rotation. Also called a *slider* joint. * @{ */ // Create a prismatic (slider) joint. // @see PrismaticJointDef for details CreatePrismaticJoint :: proc(worldId: WorldId, #by_ptr def: PrismaticJointDef) -> JointId --- // Enable/disable the joint spring. PrismaticJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) --- // Is the prismatic joint spring enabled or not? PrismaticJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool --- // Set the prismatic joint stiffness in Hertz. // This should usually be less than a quarter of the simulation rate. For example, if the simulation // runs at 60Hz then the joint stiffness should be 15Hz or less. PrismaticJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- // Get the prismatic joint stiffness in Hertz PrismaticJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- // Set the prismatic joint damping ratio (non-dimensional) PrismaticJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the prismatic spring damping ratio (non-dimensional) PrismaticJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the prismatic joint target translation. Usually in meters. PrismaticJoint_SetTargetTranslation :: proc(jointId: JointId, targetTranslation: f32) --- // Get the prismatic joint target translation. Usually in meters. PrismaticJoint_GetTargetTranslation :: proc(jointId: JointId) -> f32 --- // Enable/disable a prismatic joint limit PrismaticJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) --- // Is the prismatic joint limit enabled? PrismaticJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool --- // Get the prismatic joint lower limit PrismaticJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 --- // Get the prismatic joint upper limit PrismaticJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 --- // Set the prismatic joint limits PrismaticJoint_SetLimits :: proc(jointId: JointId, lower, upper: f32) --- // Enable/disable a prismatic joint motor PrismaticJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- // Is the prismatic joint motor enabled? PrismaticJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- // Set the prismatic joint motor speed, usually in meters per second PrismaticJoint_SetMotorSpeed :: proc(jointId: JointId, motorSpeed: f32) --- // Get the prismatic joint motor speed, usually in meters per second PrismaticJoint_GetMotorSpeed :: proc(jointId: JointId) -> f32 --- // Set the prismatic joint maximum motor force, usually in newtons PrismaticJoint_SetMaxMotorForce :: proc(jointId: JointId, force: f32) --- // Get the prismatic joint maximum motor force, usually in newtons PrismaticJoint_GetMaxMotorForce :: proc(jointId: JointId) -> f32 --- // Get the prismatic joint current motor force, usually in newtons PrismaticJoint_GetMotorForce :: proc(jointId: JointId) -> f32 --- // Get the current joint translation, usually in meters. PrismaticJoint_GetTranslation :: proc(jointId: JointId) -> f32 --- // Get the current joint translation speed, usually in meters per second. PrismaticJoint_GetSpeed :: proc(jointId: JointId) -> f32 --- /**@}*/ // prismatic_joint /** * @defgroup revolute_joint Revolute Joint * @brief A revolute joint allows for relative rotation about a single axis with no relative translation. * * Also called a *hinge* or *pin* joint. * @{ */ // Create a revolute joint // @see RevoluteJointDef for details CreateRevoluteJoint :: proc(worldId: WorldId, #by_ptr def: RevoluteJointDef) -> JointId --- // Enable/disable the revolute joint spring RevoluteJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) --- // Is the revolute angular spring enabled? RevoluteJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool --- // Set the revolute joint spring stiffness in Hertz RevoluteJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- // Get the revolute joint spring stiffness in Hertz RevoluteJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- // Set the revolute joint spring damping ratio, non-dimensional RevoluteJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the revolute joint spring damping ratio, non-dimensional RevoluteJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the revolute joint target angle in radians RevoluteJoint_SetTargetAngle :: proc(jointId: JointId, targetRadians: f32) --- // Get the revolute joint target angle in radians RevoluteJoint_GetTargetAngle :: proc(jointId: JointId) -> f32 --- // Get the revolute joint current angle in radians relative to the reference angle // @see RevoluteJointDef::referenceAngle RevoluteJoint_GetAngle :: proc(jointId: JointId) -> f32 --- // Enable/disable the revolute joint limit RevoluteJoint_EnableLimit :: proc(jointId: JointId, enableLimit: bool) --- // Is the revolute joint limit enabled? RevoluteJoint_IsLimitEnabled :: proc(jointId: JointId) -> bool --- // Get the revolute joint lower limit in radians RevoluteJoint_GetLowerLimit :: proc(jointId: JointId) -> f32 --- // Get the revolute joint upper limit in radians RevoluteJoint_GetUpperLimit :: proc(jointId: JointId) -> f32 --- // Set the revolute joint limits in radians RevoluteJoint_SetLimits :: proc(jointId: JointId, lowerLimitRadians, upperLimitRadians: f32) --- // Enable/disable a revolute joint motor RevoluteJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- // Is the revolute joint motor enabled? RevoluteJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- // Set the revolute joint motor speed in radians per second RevoluteJoint_SetMotorSpeed :: proc(jointId: JointId, motorSpeed: f32) --- // Get the revolute joint motor speed in radians per second RevoluteJoint_GetMotorSpeed :: proc(jointId: JointId) -> f32 --- // Get the revolute joint current motor torque, usually in newton-meters RevoluteJoint_GetMotorTorque :: proc(jointId: JointId) -> f32 --- // Set the revolute joint maximum motor torque, usually in newton-meters RevoluteJoint_SetMaxMotorTorque :: proc(jointId: JointId, torque: f32) --- // Get the revolute joint maximum motor torque, usually in newton-meters RevoluteJoint_GetMaxMotorTorque :: proc(jointId: JointId) -> f32 --- /**@}*/ // revolute_joint /** * @defgroup spherical_joint Spherical Joint * @brief A spherical joint allows for relative rotation in the 3D space with no relative translation. * * Also called a *ball-in-socket* or *point-to-point* joint. * @{ */ // Create a spherical joint // @see SphericalJointDef for details CreateSphericalJoint :: proc(worldId: WorldId, #by_ptr def: SphericalJointDef) -> JointId --- // Enable/disable the spherical joint cone limit SphericalJoint_EnableConeLimit :: proc(jointId: JointId, enableLimit: bool) --- // Is the spherical joint cone limit enabled? SphericalJoint_IsConeLimitEnabled :: proc(jointId: JointId) -> bool --- // Get the spherical joint cone limit in radians SphericalJoint_GetConeLimit :: proc(jointId: JointId) -> f32 --- // Set the spherical joint limits in radians SphericalJoint_SetConeLimit :: proc(jointId: JointId, angleRadians: f32) --- // Get the spherical joint current cone angle in radians. SphericalJoint_GetConeAngle :: proc(jointId: JointId) -> f32 --- // Enable/disable the spherical joint limit SphericalJoint_EnableTwistLimit :: proc(jointId: JointId, enableLimit: bool) --- // Is the spherical joint limit enabled? SphericalJoint_IsTwistLimitEnabled :: proc(jointId: JointId) -> bool --- // Get the spherical joint lower limit in radians SphericalJoint_GetLowerTwistLimit :: proc(jointId: JointId) -> f32 --- // Get the spherical joint upper limit in radians SphericalJoint_GetUpperTwistLimit :: proc(jointId: JointId) -> f32 --- // Set the spherical joint limits in radians SphericalJoint_SetTwistLimits :: proc(jointId: JointId, lowerLimitRadians, upperLimitRadians: f32) --- // Get the spherical joint current twist angle in radians. SphericalJoint_GetTwistAngle :: proc(jointId: JointId) -> f32 --- // Enable/disable the spherical joint spring SphericalJoint_EnableSpring :: proc(jointId: JointId, enableSpring: bool) --- // Is the spherical angular spring enabled? SphericalJoint_IsSpringEnabled :: proc(jointId: JointId) -> bool --- // Set the spherical joint spring stiffness in Hertz SphericalJoint_SetSpringHertz :: proc(jointId: JointId, hertz: f32) --- // Get the spherical joint spring stiffness in Hertz SphericalJoint_GetSpringHertz :: proc(jointId: JointId) -> f32 --- // Set the spherical joint spring damping ratio, non-dimensional SphericalJoint_SetSpringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the spherical joint spring damping ratio, non-dimensional SphericalJoint_GetSpringDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the spherical joint spring target rotation SphericalJoint_SetTargetRotation :: proc(jointId: JointId, targetRotation: Quat) --- // Get the spherical joint spring target rotation SphericalJoint_GetTargetRotation :: proc(jointId: JointId) -> Quat --- // Enable/disable a spherical joint motor SphericalJoint_EnableMotor :: proc(jointId: JointId, enableMotor: bool) --- // Is the spherical joint motor enabled? SphericalJoint_IsMotorEnabled :: proc(jointId: JointId) -> bool --- // Set the spherical joint motor velocity in radians per second SphericalJoint_SetMotorVelocity :: proc(jointId: JointId, motorVelocity: Vec3) --- // Get the spherical joint motor velocity in radians per second SphericalJoint_GetMotorVelocity :: proc(jointId: JointId) -> Vec3 --- // Get the spherical joint current motor torque, usually in newton-meters SphericalJoint_GetMotorTorque :: proc(jointId: JointId) -> Vec3 --- // Set the spherical joint maximum motor torque, usually in newton-meters SphericalJoint_SetMaxMotorTorque :: proc(jointId: JointId, torque: f32) --- // Get the spherical joint maximum motor torque, usually in newton-meters SphericalJoint_GetMaxMotorTorque :: proc(jointId: JointId) -> f32 --- /**@}*/ // spherical_joint /** * @defgroup weld_joint Weld Joint * @brief A weld joint fully constrains the relative transform between two bodies while allowing for springiness * * A weld joint constrains the relative rotation and translation between two bodies. Both rotation and translation * can have damped springs. * * @note The accuracy of weld joint is limited by the accuracy of the solver. Long chains of weld joints may flex. * @{ */ // Create a weld joint // @see WeldJointDef for details CreateWeldJoint :: proc(worldId: WorldId, #by_ptr def: WeldJointDef) -> JointId --- // Set the weld joint linear stiffness in Hertz. 0 is rigid. WeldJoint_SetLinearHertz :: proc(jointId: JointId, hertz: f32) --- // Get the weld joint linear stiffness in Hertz WeldJoint_GetLinearHertz :: proc(jointId: JointId) -> f32 --- // Set the weld joint linear damping ratio (non-dimensional) WeldJoint_SetLinearDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the weld joint linear damping ratio (non-dimensional) WeldJoint_GetLinearDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the weld joint angular stiffness in Hertz. 0 is rigid. WeldJoint_SetAngularHertz :: proc(jointId: JointId, hertz: f32) --- // Get the weld joint angular stiffness in Hertz WeldJoint_GetAngularHertz :: proc(jointId: JointId) -> f32 --- // Set weld joint angular damping ratio, non-dimensional WeldJoint_SetAngularDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the weld joint angular damping ratio, non-dimensional WeldJoint_GetAngularDampingRatio :: proc(jointId: JointId) -> f32 --- /**@}*/ // weld_joint /** * @defgroup wheel_joint Wheel Joint * The wheel joint can be used to simulate wheels on vehicles. * * The wheel joint restricts body B to move along a local axis in body A. Body B is free to * rotate. Supports a linear spring, linear limits, and a rotational motor. * * @{ */ // Create a wheel joint. // @see WheelJointDef for details. CreateWheelJoint :: proc(worldId: WorldId, #by_ptr def: WheelJointDef) -> JointId --- // Enable/disable the wheel joint spring. WheelJoint_EnableSuspension :: proc(jointId: JointId, flag: bool) --- // Is the wheel joint spring enabled? WheelJoint_IsSuspensionEnabled :: proc(jointId: JointId) -> bool --- // Set the wheel joint stiffness in Hertz. WheelJoint_SetSuspensionHertz :: proc(jointId: JointId, hertz: f32) --- // Get the wheel joint stiffness in Hertz. WheelJoint_GetSuspensionHertz :: proc(jointId: JointId) -> f32 --- // Set the wheel joint damping ratio, non-dimensional. WheelJoint_SetSuspensionDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the wheel joint damping ratio, non-dimensional. WheelJoint_GetSuspensionDampingRatio :: proc(jointId: JointId) -> f32 --- // Enable/disable the wheel joint limit. WheelJoint_EnableSuspensionLimit :: proc(jointId: JointId, flag: bool) --- // Is the wheel joint limit enabled? WheelJoint_IsSuspensionLimitEnabled :: proc(jointId: JointId) -> bool --- // Get the wheel joint lower limit. WheelJoint_GetLowerSuspensionLimit :: proc(jointId: JointId) -> f32 --- // Get the wheel joint upper limit. WheelJoint_GetUpperSuspensionLimit :: proc(jointId: JointId) -> f32 --- // Set the wheel joint limits. WheelJoint_SetSuspensionLimits :: proc(jointId: JointId, lower, upper: f32) --- // Enable/disable the wheel joint motor. WheelJoint_EnableSpinMotor :: proc(jointId: JointId, flag: bool) --- // Is the wheel joint motor enabled? WheelJoint_IsSpinMotorEnabled :: proc(jointId: JointId) -> bool --- // Set the wheel joint motor speed in radians per second. WheelJoint_SetSpinMotorSpeed :: proc(jointId: JointId, speed: f32) --- // Get the wheel joint motor speed in radians per second. WheelJoint_GetSpinMotorSpeed :: proc(jointId: JointId) -> f32 --- // Set the wheel joint maximum motor torque, usually in newton-meters. WheelJoint_SetMaxSpinTorque :: proc(jointId: JointId, torque: f32) --- // Get the wheel joint maximum motor torque, usually in newton-meters. WheelJoint_GetMaxSpinTorque :: proc(jointId: JointId) -> f32 --- // Get the current spin speed in radians per second. WheelJoint_GetSpinSpeed :: proc(jointId: JointId) -> f32 --- // Get the wheel joint current motor torque, usually in newton-meters. WheelJoint_GetSpinTorque :: proc(jointId: JointId) -> f32 --- // Enable/disable wheel steering. Steering allows the wheel to rotate about the suspension axis. WheelJoint_EnableSteering :: proc(jointId: JointId, flag: bool) --- // Can the wheel steer? WheelJoint_IsSteeringEnabled :: proc(jointId: JointId) -> bool --- // Set the wheel joint steering stiffness in Hertz. WheelJoint_SetSteeringHertz :: proc(jointId: JointId, hertz: f32) --- // Get the wheel joint steering stiffness in Hertz. WheelJoint_GetSteeringHertz :: proc(jointId: JointId) -> f32 --- // Set the wheel joint steering damping ratio, non-dimensional. WheelJoint_SetSteeringDampingRatio :: proc(jointId: JointId, dampingRatio: f32) --- // Get the wheel joint steering damping ratio, non-dimensional. WheelJoint_GetSteeringDampingRatio :: proc(jointId: JointId) -> f32 --- // Set the wheel joint maximum steering torque in N*m. WheelJoint_SetMaxSteeringTorque :: proc(jointId: JointId, torque: f32) --- // Get the wheel joint maximum steering torque in N*m. WheelJoint_GetMaxSteeringTorque :: proc(jointId: JointId) -> f32 --- // Enable/disable the wheel joint steering limit. WheelJoint_EnableSteeringLimit :: proc(jointId: JointId, flag: bool) --- // Is the wheel joint steering limit enabled? WheelJoint_IsSteeringLimitEnabled :: proc(jointId: JointId) -> bool --- // Get the wheel joint lower steering limit in radians. WheelJoint_GetLowerSteeringLimit :: proc(jointId: JointId) -> f32 --- // Get the wheel joint upper steering limit in radians. WheelJoint_GetUpperSteeringLimit :: proc(jointId: JointId) -> f32 --- // Set the wheel joint steering limits in radians. WheelJoint_SetSteeringLimits :: proc(jointId: JointId, lowerRadians, upperRadians: f32) --- // Set the wheel joint target steering angle in radians. WheelJoint_SetTargetSteeringAngle :: proc(jointId: JointId, radians: f32) --- // Get the wheel joint target steering angle in radians. WheelJoint_GetTargetSteeringAngle :: proc(jointId: JointId) -> f32 --- // Get the current steering angle in radians. WheelJoint_GetSteeringAngle :: proc(jointId: JointId) -> f32 --- // Get the current steering torque in N*m. WheelJoint_GetSteeringTorque :: proc(jointId: JointId) -> f32 --- /**@}*/ // wheel_joint /**@}*/ // joint /** * @defgroup contact Contact * Access to contacts * @{ */ // Contact identifier validation. Provides validation for up to 2^32 allocations. Contact_IsValid :: proc(id: ContactId) -> bool --- // Get the manifolds for a contact. The manifold may have no points if the contact is not touching. Contact_GetData :: proc(contactId: ContactId) -> ContactData --- /**@}*/ // contact }