package vendor:box3d

Source

AABB :: struct {
	lowerBound: [3]f32,
	upperBound: [3]f32,
}

AllocFcn :: proc "c" (size, alignment: i32) -> rawptr

AssertFcn :: proc "c" (condition: cstring, fileName: cstring, lineNumber: i32) -> i32

BodyCastResult :: struct {
	// The shape hit.
	shapeId:        ShapeId,
	// The world point on the shape surface.
	point:          [3]f32,
	// The world normal vector on the shape surface.
	normal:         [3]f32,
	// The fraction along the ray hit.
	// hit point = origin + fraction * translation
	fraction:       f32,
	// The triangle index if the shape is a mesh or height-field.
	triangleIndex:  i32,
	// The user material id at the hit point. This can be per triangle
	// if the shape is a mesh, height-field, or compound with child mesh.
	userMaterialId: u64,
	// The number of iterations used. Diagnostic.
	iterations:     i32,
	// Did the cast hit? If false, all other fields are invalid.
	hit:            bool,
}

BodyDef :: struct {
	// The body type: static, kinematic, or dynamic.
	type:                   BodyType,
	// The initial world position of the body. Bodies should be created with the desired position.
	// @note Creating bodies at the origin and then moving them nearly doubles the cost of body creation, especially
	// if the body is moved after shapes have been added.
	position:               [3]f32,
	// The initial world rotation of the body.
	rotation:               quaternion128,
	// The initial linear velocity of the body's origin. Usually in meters per second.
	linearVelocity:         [3]f32,
	// The initial angular velocity of the body. Radians per second.
	angularVelocity:        [3]f32,
	// Linear damping is used to reduce the linear velocity. The damping parameter
	// can be larger than 1 but the damping effect becomes sensitive to the
	// time step when the damping parameter is large.
	// Generally linear damping is undesirable because it makes objects move slowly
	// as if they are floating.
	linearDamping:          f32,
	// Angular damping is used to reduce the angular velocity. The damping parameter
	// can be larger than 1.0f but the damping effect becomes sensitive to the
	// time step when the damping parameter is large.
	// Angular damping can be used to slow down rotating bodies.
	angularDamping:         f32,
	// Scale the gravity applied to this body. Non-dimensional.
	gravityScale:           f32,
	// Sleep speed threshold, default is 0.05 meters per second
	sleepThreshold:         f32,
	// Optional body name for debugging. Up to B3_BODY_NAME_LENGTH characters (including null termination)
	name:                   cstring,
	// Use this to store application specific body data.
	userData:               rawptr,
	// Motions locks to restrict linear and angular movement
	motionLocks:            MotionLocks,
	// Set this flag to false if this body should never fall asleep.
	enableSleep:            bool,
	// Is this body initially awake or sleeping?
	isAwake:                bool,
	// Treat this body as a high speed object that performs continuous collision detection
	// against dynamic and kinematic bodies, but not other bullet bodies.
	// @warning Bullets should be used sparingly. They are not a solution for general dynamic-versus-dynamic
	// continuous collision. They do not guarantee accurate collision if both bodies are fast moving because
	// the bullet does a continuous check after all non-bullet bodies have moved. You could get unlucky and have
	// the bullet body end a time step very close to a non-bullet body and the non-bullet body then moves over
	// the bullet body. In continuous collision, initial overlap is ignored to avoid freezing bodies in place.
	// I do not recommend using them for game projectiles if precise collision timing is needed. Instead consider
	// using a ray or shape cast. You can use a marching ray or shape cast for projectile that moves over time.
	// If you want a fast moving projectile to collide with a fast moving target, you need to consider the relative
	// movement in your ray or shape cast. This is out of the scope of Box3D.
	// So what are good use cases for bullets? Pinball games or games with dynamic containers that hold other objects.
	// It should be a use case where it doesn't break the game if there is a collision missed, but having them
	// captured improves the quality of the game.
	isBullet:               bool,
	// Used to disable a body. A disabled body does not move or collide.
	isEnabled:              bool,
	// This allows this body to bypass rotational speed limits. Should only be used
	// for circular objects, like wheels.
	allowFastRotation:      bool,
	// Enable contact recycling. True by default. Leaving this enabled improves performance
	// but may lead to ghost collision that should be avoided on characters.
	enableContactRecycling: bool,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:          i32,
}

BodyEvents :: struct {
	// Array of move events
	moveEvents: [^]BodyMoveEvent `fmt:"v,moveCount"`,
	// Number of move events
	moveCount:  i32,
}

BodyId :: struct {
	index1:     i32,
	world0:     u16,
	generation: u16,
}

BodyMoveEvent :: struct {
	// The body user data.
	userData:   rawptr,
	// The body transform.
	transform:  WorldTransform,
	// The body id.
	bodyId:     BodyId,
	// Did the body fall asleep this time step?
	fellAsleep: bool,
}

BodyPlaneResult :: struct {
	// The shape id on the body.
	shapeId: ShapeId,
	// The plane result.
	result:  PlaneResult,
}

BodyType :: enum i32 {
	// zero mass, zero velocity, may be manually moved
	staticBody    = 0, 
	// zero mass, velocity set by user, moved by solver
	kinematicBody = 1, 
	// positive mass, velocity determined by forces, moved by solver
	dynamicBody   = 2, 
}

BoxCastInput :: struct {
	// The AABB to cast, in the tree's frame.
	box:         AABB,
	// The sweep translation.
	translation: [3]f32,
	// The maximum fraction of the translation to consider, typically 1.
	maxFraction: f32,
}

BoxHull :: struct {
	// The embedded hull. So the offsets index into the arrays that follow.
	base:        HullData,
	boxVertices: [8]HullVertex,
	// < Box vertices.
	boxPoints:   [8][3]f32,
	// < Box points.
	boxEdges:    [24]HullHalfEdge,
	// < Box half-edges.
	boxFaces:    [6]HullFace,
	// < Box faces.
	padding:     [2]u8,
	// < Explicit padding, see b3HullData::padding.
	boxPlanes:   [6]Plane,
}

Capacity :: struct {
	// Number of expected static shapes.
	staticShapeCount:  i32,
	// Number of expected dynamic and kinematic shapes.
	dynamicShapeCount: i32,
	// Number of expected static bodies.
	staticBodyCount:   i32,
	// Number of expected dynamic and kinematic bodies.
	dynamicBodyCount:  i32,
	// Number of expected contacts.
	contactCount:      i32,
}

Capsule :: struct {
	// Local center of the first hemisphere
	center1: [3]f32,
	// Local center of the second hemisphere
	center2: [3]f32,
	// The radius of the hemispheres
	radius:  f32,
}

CastOutput :: struct {
	// The surface normal at the hit point.
	normal:        [3]f32,
	// The surface hit point in world space.
	point:         [3]f32,
	// The fraction of the input translation at collision.
	fraction:      f32,
	// The number of iterations used.
	iterations:    i32,
	// The index of the mesh or height field triangle hit.
	triangleIndex: i32,
	// The index of the compound child shape.
	childIndex:    i32,
	// The material index. May be -1 for null.
	materialIndex: i32,
	// Did the cast hit?
	hit:           bool,
}

CastResultFcn :: proc "c" (shapeId: ShapeId, point: [3]f32, normal: [3]f32, fraction: f32, userMateriald: u64, triangleIndex: i32, childIndex: i32, ctx: rawptr) -> f32

ChildShape :: struct {
	// Tagged union.
	using _:         struct #raw_union {
		capsule: Capsule,
		// < Capsule.
		hull:    ^HullData,
		// < Hull.
		mesh:    Mesh,
		// < Mesh.
		sphere:  Sphere,
	},
	// Transform of the shape into compound local space.
	transform:       Transform,
	// Material indices. Index 0 is used for convex shapes.
	// todo limit to 64K?
	materialIndices: [4]i32,
	// The shape type (union tag).
	type:            ShapeType,
}

CollisionPlane :: struct {
	// The collision plane between the mover and some shape.
	plane:        Plane,
	// Setting this to FLT_MAX makes the plane as rigid as possible. Lower values can
	// make the plane collision soft. Usually in meters.
	pushLimit:    f32,
	// The push on the mover determined by b3SolvePlanes. Usually in meters.
	push:         f32,
	// Indicates if b3ClipVector should clip against this plane. Should be false for soft collision.
	clipVelocity: bool,
}

CompoundCapsule :: struct {
	// Local capsule.
	capsule:       Capsule,
	// Index to a shared material.
	materialIndex: i32,
}

CompoundCapsuleDef :: struct {
	// Local capsule.
	capsule:  Capsule,
	// Material properties.
	material: SurfaceMaterial,
}

CompoundData :: struct {
	// The compound version is always first.
	version:         u64,
	// The total number of bytes for this compound.
	byteCount:       i32,
	// Offset of the tree node array in bytes from the struct address.
	nodeOffset:      i32,
	// Immutable dynamic tree. The tree node pointer must be fixed up using the node offset
	tree:            DynamicTree,
	// Offset of the material array in bytes from the struct address.
	materialOffset:  i32,
	// The number of materials.
	materialCount:   i32,
	// Offset of the capsule array in bytes from the struct address.
	capsuleOffset:   i32,
	// The number of capsules.
	capsuleCount:    i32,
	// Offset of the hull instance array in bytes from the struct address.
	hullOffset:      i32,
	// The number of hull instances.
	hullCount:       i32,
	// The number of unique hulls. Diagnostic.
	sharedHullCount: i32,
	// Offset of the mesh instance array in bytes from the struct address.
	meshOffset:      i32,
	// The number of mesh instances.
	meshCount:       i32,
	// The number of unique meshes. Diagnostic.
	sharedMeshCount: i32,
	// Offset of the sphere array in bytes from the struct address.
	sphereOffset:    i32,
	// The number of spheres.
	sphereCount:     i32,
}

CompoundDef :: struct {
	// Capsule instances.
	capsules:     [^]CompoundCapsuleDef `fmt:"v,capsuleCount"`,
	// Number of capsules.
	capsuleCount: int,
	// Hulls instances.
	hulls:        [^]CompoundHullDef `fmt:"v,hullCount"`,
	// Number of hull instances.
	hullCount:    int,
	// Mesh instances.
	meshes:       [^]CompoundMeshDef `fmt:"v,meshCount"`,
	// Number of mesh instances.
	meshCount:    int,
	// Sphere instances.
	spheres:      [^]CompoundSphereDef `fmt:"v,sphereCount"`,
	// Number of spheres.
	sphereCount:  int,
}

CompoundHull :: struct {
	// Pointer to the unique shared hull.
	hull:          ^HullData,
	// The transform of this hull instance.
	transform:     Transform,
	// Index to a shared material.
	materialIndex: i32,
}

CompoundHullDef :: struct {
	// Shared hull.
	hull:      ^HullData,
	// Transform of the shared hull into compound local space.
	transform: Transform,
	// Material properties.
	material:  SurfaceMaterial,
}

CompoundMesh :: struct {
	// Pointer to the unique shared mesh.
	meshData:        [^]MeshData,
	// The transform of this mesh instance.
	transform:       Transform,
	// Non-uniform scale of this mesh instance.
	scale:           [3]f32,
	// This is used to access the surface material from b3GetCompoundMaterials.
	// Requires an extra level of indirection. The triangle material index
	// is clamped to B3_MAX_COMPOUND_MESH_MATERIALS.
	// materialIndex = materialIndices[triangle->materialIndex]
	materialIndices: [4]i32,
}

CompoundMeshDef :: struct {
	// Shared mesh.
	meshData:      ^MeshData,
	// Transform of the shared mesh into compound local space.
	transform:     Transform,
	// Local space non-uniform mesh scale. May have negative components.
	scale:         [3]f32,
	// Material properties.
	// This array must line up with the material indices on the triangles.
	materials:     [^]SurfaceMaterial `fmt:"v,materialCount"`,
	// Number of materials.
	materialCount: i32,
}

CompoundQueryFcn :: proc "c" (#by_ptr compound: CompoundData, childIndex: i32, ctx: rawptr) -> bool

CompoundSphere :: struct {
	// Local sphere.
	sphere:        Sphere,
	// Index to a shared material.
	materialIndex: i32,
}

CompoundSphereDef :: struct {
	// Local sphere.
	sphere:   Sphere,
	// Material properties.
	material: SurfaceMaterial,
}

ContactBeginTouchEvent :: struct {
	// Id of the first shape
	// 	@warning this shape may have been destroyed
	// 	@see b3Shape_IsValid
	shapeIdA:  ShapeId,
	// Id of the first shape
	// 	@warning this shape may have been destroyed
	// 	@see b3Shape_IsValid
	shapeIdB:  ShapeId,
	// Id of the contact.
	// 	@warning this contact may have been destroyed
	// 	@see b3Contact_IsValid
	contactId: ContactId,
}

ContactData :: struct {
	// The contact id. You may hold onto this to track a contact across time steps.
	// This id may become orphaned. Use b3Contact_IsValid before using it for other functions.
	contactId:     ContactId,
	// The first shape id.
	shapeIdA:      ShapeId,
	// The second shape id.
	shapeIdB:      ShapeId,
	// The contact manifold. This points to internal data and may become invalid. Do not store
	// this pointer.
	manifolds:     [^]Manifold `fmt:"v,manifoldCount"`,
	// The number of contact manifolds. For mesh and height-field collision there can be multiple manifolds.
	manifoldCount: i32,
}

ContactEndTouchEvent :: struct {
	// Id of the first shape
	// 	@warning this shape may have been destroyed
	// 	@see b3Shape_IsValid
	shapeIdA:  ShapeId,
	// Id of the first shape
	// 	@warning this shape may have been destroyed
	// 	@see b3Shape_IsValid
	shapeIdB:  ShapeId,
	// Id of the contact.
	// 	@warning this contact may have been destroyed
	// 	@see b3Contact_IsValid
	contactId: ContactId,
}

ContactEvents :: struct {
	// Array of begin touch events
	beginEvents: [^]ContactBeginTouchEvent `fmt:"v,beginCount"`,
	// Array of end touch events
	endEvents:   [^]ContactEndTouchEvent `fmt:"v,endCount"`,
	// Array of hit events
	hitEvents:   [^]ContactHitEvent `fmt:"v,hitCount"`,
	// Number of begin touch events
	beginCount:  i32,
	// Number of end touch events
	endCount:    i32,
	// Number of hit events
	hitCount:    i32,
}

ContactHitEvent :: struct {
	// Id of the first shape
	shapeIdA:        ShapeId,
	// Id of the second shape
	shapeIdB:        ShapeId,
	// Id of the contact.
	// 	@warning this contact may have been destroyed
	// 	@see b3Contact_IsValid
	contactId:       ContactId,
	// Point where the shapes hit at the beginning of the time step.
	// This is a mid-point between the two surfaces. It could be at speculative
	// point where the two shapes were not touching at the beginning of the time step.
	point:           [3]f32,
	// Normal vector pointing from shape A to shape B
	normal:          [3]f32,
	// The speed the shapes are approaching. Always positive. Typically in meters per second.
	approachSpeed:   f32,
	// User material on shape A
	userMaterialIdA: u64,
	// User material on shape B
	userMaterialIdB: u64,
}

ContactId :: struct {
	index1:     i32,
	world0:     u16,
	_:          i16,
	generation: u32,
}

CosSin :: struct {
	// cosine and sine
	cosine: f32,
	sine:   f32,
}

Counters :: struct {
	bodyCount:            i32,
	shapeCount:           i32,
	contactCount:         i32,
	jointCount:           i32,
	islandCount:          i32,
	stackUsed:            i32,
	arenaCapacity:        i32,
	staticTreeHeight:     i32,
	treeHeight:           i32,
	satCallCount:         i32,
	satCacheHitCount:     i32,
	byteCount:            i32,
	taskCount:            i32,
	colorCounts:          [24]i32,
	manifoldCounts:       [8]i32,
	// Number of contacts touched by the collide pass
	// graph contacts + awake-set non-touching
	awakeContactCount:    i32,
	// Number of contacts recycled in the most recent step.
	recycledContactCount: i32,
	// Maximum number of time of impact iterations
	distanceIterations:   i32,
	pushBackIterations:   i32,
	rootIterations:       i32,
}

CreateDebugShapeCallback :: proc "c" (debugShape: ^DebugShape, userContext: rawptr) -> rawptr

CustomFilterFcn :: proc "c" (shapeIdA: ShapeId, shapeIdB: ShapeId, ctx: rawptr) -> bool

DebugDraw :: struct {
	// Draws a shape and returns true if drawing should continue
	DrawShapeFcn:        proc "c" (userShape: rawptr, transform: WorldTransform, color: HexColor, ctx: rawptr) -> bool,
	// Draw a line segment.
	DrawSegmentFcn:      proc "c" (p1, p2: [3]f32, color: HexColor, ctx: rawptr),
	// Draw a transform. Choose your own length scale.
	DrawTransformFcn:    proc "c" (transform: WorldTransform, ctx: rawptr),
	// Draw a point.
	DrawPointFcn:        proc "c" (p: [3]f32, size: f32, color: HexColor, ctx: rawptr),
	// Draw a sphere.
	DrawSphereFcn:       proc "c" (p: [3]f32, radius: f32, color: HexColor, alpha: f32, ctx: rawptr),
	// Draw a capsule.
	DrawCapsuleFcn:      proc "c" (p1, p2: [3]f32, radius: f32, color: HexColor, alpha: f32, ctx: rawptr),
	// Draw a bounding box.
	DrawBoundsFcn:       proc "c" (aabb: AABB, color: HexColor, ctx: rawptr),
	// Draw an oriented box.
	DrawBoxFcn:          proc "c" (extents: [3]f32, transform: WorldTransform, color: HexColor, ctx: rawptr),
	// Draw a string in world space
	DrawStringFcn:       proc "c" (p: [3]f32, s: cstring, color: HexColor, ctx: rawptr),
	// World bounds to use for debug draw
	drawingBounds:       AABB,
	// Scale to use when drawing forces
	forceScale:          f32,
	// Global scaling for joint drawing
	jointScale:          f32,
	// Option to draw shapes
	drawShapes:          bool,
	// Option to draw joints
	drawJoints:          bool,
	// Option to draw additional information for joints
	drawJointExtras:     bool,
	// Option to draw the bounding boxes for shapes
	drawBounds:          bool,
	// Option to draw the mass and center of mass of dynamic bodies
	drawMass:            bool,
	// Option to draw body names
	drawBodyNames:       bool,
	// Option to draw contact points
	drawContacts:        bool,
	// Draw contact anchor A or B
	drawAnchorA:         i32,
	// Option to visualize the graph coloring used for contacts and joints
	drawGraphColors:     bool,
	// Option to draw contact features
	drawContactFeatures: bool,
	// Option to draw contact normals
	drawContactNormals:  bool,
	// Option to draw contact normal forces
	drawContactForces:   bool,
	// Option to draw contact friction forces
	drawFrictionForces:  bool,
	// Option to draw islands as bounding boxes
	drawIslands:         bool,
	// User context that is passed as an argument to drawing callback functions
	ctx:                 rawptr,
}

DebugMaterial :: enum u32 {
	Default  = 0, 
	Matte, 
	Soft, 
	Dead, 
	Glossy, 
	Metallic, 
}

DebugShape :: struct {
	// Shape id.
	shapeId: ShapeId,
	// Shape type.
	type:    ShapeType,
	// Tagged union.
	using _: struct #raw_union {
		capsule:     ^Capsule `raw_union_tag:"type=.capsuleShape"`,
		// < Capsule shape.
		compound:    ^CompoundData `raw_union_tag:"type=.compoundShape"`,
		// < Compound shape.
		heightField: ^HeightFieldData `raw_union_tag:"type=.heightShape"`,
		// < Height-field shape.
		hull:        ^HullData `raw_union_tag:"type=.hullShape"`,
		// < Convex hull shape.
		mesh:        ^Mesh `raw_union_tag:"type=.meshShape"`,
		// < Mesh shape with scale.
		sphere:      ^Sphere `raw_union_tag:"type=.sphereShape"`,
	},
}

DestroyDebugShapeCallback :: proc "c" (userShape: rawptr, userContext: rawptr)

DistanceInput :: struct {
	// The proxy for shape A
	proxyA:    ShapeProxy,
	// The proxy for shape B
	proxyB:    ShapeProxy,
	// Transform of shape B in shape A's frame, the relative pose B in A
	// (b3InvMulWorldTransforms( worldA, worldB )). The query is origin independent and runs in frame A.
	transform: Transform,
	// Should the proxy radius be considered?
	useRadii:  bool,
}

DistanceJointDef :: struct {
	// Base joint definition
	using base:       JointDef,
	// The rest length of this joint. Clamped to a stable minimum value.
	length:           f32,
	// Enable the distance constraint to behave like a spring. If false
	// then the distance joint will be rigid, overriding the limit and motor.
	enableSpring:     bool,
	// The lower spring force controls how much tension it can sustain
	lowerSpringForce: f32,
	// The upper spring force controls how much compression it can sustain
	upperSpringForce: f32,
	// The spring linear stiffness Hertz, cycles per second
	hertz:            f32,
	// The spring linear damping ratio, non-dimensional
	dampingRatio:     f32,
	// Enable/disable the joint limit
	enableLimit:      bool,
	// Minimum length. Clamped to a stable minimum value.
	minLength:        f32,
	// Maximum length. Must be greater than or equal to the minimum length.
	maxLength:        f32,
	// Enable/disable the joint motor
	enableMotor:      bool,
	// The maximum motor force, usually in newtons
	maxMotorForce:    f32,
	// The desired motor speed, usually in meters per second
	motorSpeed:       f32,
}

DistanceOutput :: struct {
	pointA:       [3]f32,
	// < Closest point on shapeA, in shape A's frame
	pointB:       [3]f32,
	// < Closest point on shapeB, in shape A's frame
	normal:       [3]f32,
	// < A to B normal in shape A's frame. Invalid if distance is zero.
	distance:     f32,
	// < The final distance, zero if overlapped
	iterations:   i32,
	// < Number of GJK iterations used
	simplexCount: i32,
}

DynamicTree :: struct {
	// The dynamic tree version. Always the first field. Useful
	// if the tree is serialized.
	version:         u64,
	// The tree nodes
	nodes:           [^]TreeNode `fmt:"v,nodeCapacity"`,
	// The root index
	root:            i32,
	// The number of nodes
	nodeCount:       i32,
	// The allocated node space
	nodeCapacity:    i32,
	// Number of proxies created
	proxyCount:      i32,
	// Node free list
	freeList:        i32,
	// Leaf indices for rebuild
	leafIndices:     [^]int,
	// Leaf bounding boxes for rebuild
	leafBoxes:       [^]AABB,
	// Leaf bounding box centers for rebuild
	leafCenters:     [^][3]f32,
	// Bins for sorting during rebuild
	binIndices:      [^]i32,
	// Allocated space for rebuilding
	rebuildCapacity: i32,
}

EnqueueTaskCallback :: proc "c" (task: rawptr, taskContext: rawptr, userContext: rawptr, taskName: cstring) -> rawptr

ExplosionDef :: struct {
	// Mask bits to filter shapes
	maskBits:       u64,
	// The center of the explosion in world space
	position:       [3]f32,
	// The radius of the explosion
	radius:         f32,
	// The falloff distance beyond the radius. Impulse is reduced to zero at this distance.
	falloff:        f32,
	// Impulse per unit area. This applies an impulse according to the shape area that
	// is facing the explosion. Explosions only apply to spheres, capsules, and hulls. This
	// may be negative for implosions.
	impulsePerArea: f32,
}

FeaturePair :: struct {
	// Incoming type (either edge on shape A or shape B)
	owner1: u8,
	// Incoming edge index (into associated shape array)
	index1: u8,
	// Outgoing type (either edge on shape A or shape B)
	owner2: u8,
	// Outgoing edge index (into associated shape array)
	index2: u8,
}

Filter :: struct {
	// The collision category bits. Normally you would just set one bit. The category bits should
	// 	represent your application object types. For example:
	// 	@code{.odin}
	// 	My_Categories :: enum u64 {
	// 		Static  = 0x00000001,
	// 		Dynamic = 0x00000002,
	// 		Debris  = 0x00000004,
	// 		Player  = 0x00000008,
	// 		// etc
	// 	};
	// 	@endcode
	//      Or use a bit_set.
	categoryBits: u64,
	// The collision mask bits. This states the categories that this
	// shape would accept for collision.
	// 	For example, you may want your player to only collide with static objects
	// 	and other players.
	// 	@code{.odin}
	// 	maskBits = u64(My_Categories.Static | My_Categories.Player);
	// 	@endcode
	maskBits:     u64,
	// Collision groups allow a certain group of objects to never collide (negative)
	// or always collide (positive). A group index of zero has no effect. Non-zero group filtering
	// always wins against the mask bits.
	// 	For example, you may want ragdolls to collide with other ragdolls but you don't want
	// 	ragdoll self-collision. In this case you would give each ragdoll a unique negative group index
	// 	and apply that group index to all shapes on the ragdoll.
	groupIndex:   i32,
}

FilterJointDef :: struct {
	// Base joint definition
	using base: JointDef,
}

FinishTaskCallback :: proc "c" (userTask: rawptr, userContext: rawptr)

FreeFcn :: proc "c" (mem: rawptr)

FrictionCallback :: proc "c" (frictionA: f32, userMaterialIdA: u64, frictionB: f32, userMaterialIdB: u64) -> f32

HeightFieldData :: struct {
	// Version must be first and match B3_HEIGHT_FIELD_VERSION
	version:        i64,
	// The total number of bytes for this height field.
	byteCount:      i32,
	// Hash of this height field (this field is zero when the hash is computed).
	hash:           u32,
	// The local axis-aligned bounding box.
	aabb:           AABB,
	// The minimum y value.
	minHeight:      f32,
	// The maximum y value
	maxHeight:      f32,
	// The quantization scale.
	heightScale:    f32,
	// The overall scale.
	scale:          [3]f32,
	// The number of grid columns along the local x-axis.
	columnCount:    i32,
	// The number of grid rows along the local z-axis.
	rowCount:       i32,
	// Offset of the compressed height array in bytes from the struct address.
	// uint16_t, one per grid point.
	heightsOffset:  i32,
	// Offset of the material index array in bytes from the struct address.
	// uint8_t, one per cell.
	materialOffset: i32,
	// Offset of the flag array in bytes from the struct address.
	// uint8_t, one per triangle.
	flagsOffset:    i32,
	// Triangle winding.
	clockwise:      bool,
	// Explicit padding. Identity is a content hash over raw bytes, so there must
	// be no unnamed padding for struct copies to scramble.
	padding:        [3]u8,
}

HeightFieldDef :: struct {
	// Grid point heights
	// count = countX * countZ
	heights:             [^]f32,
	// Grid cell material
	// A value of 0xFF is reserved for holes
	// count = (countX - 1) * (countZ - 1)
	materialIndices:     [^]u8,
	// The height field scale. All components must be positive values.
	scale:               [3]f32,
	// The number of grid lines along the x-axis.
	countX:              i32,
	// The number of grid lines along the z-axis.
	countZ:              i32,
	// Global minimum and maximum heights used for quantization. This is important
	// if you want height fields to be placed next to each other and line up exactly.
	// In that case, both height fields should use the same minimum and maximum heights.
	// All height values are clamped to this range.
	// These values are in unscaled space.
	globalMinimumHeight: f32,
	// The maximum.
	globalMaximumHeight: f32,
	// Use clock-wise winding. This effectively inverts the height-field along the y-axis.
	clockwiseWinding:    bool,
}

HexColor :: enum u32 {
	AliceBlue            = 15792383, 
	AntiqueWhite         = 16444375, 
	Aqua                 = 65535, 
	Aquamarine           = 8388564, 
	Azure                = 15794175, 
	Beige                = 16119260, 
	Bisque               = 16770244, 
	Black                = 0, 
	BlanchedAlmond       = 16772045, 
	Blue                 = 255, 
	BlueViolet           = 9055202, 
	Brown                = 10824234, 
	Burlywood            = 14596231, 
	CadetBlue            = 6266528, 
	Chartreuse           = 8388352, 
	Chocolate            = 13789470, 
	Coral                = 16744272, 
	CornflowerBlue       = 6591981, 
	Cornsilk             = 16775388, 
	Crimson              = 14423100, 
	Cyan                 = 65535, 
	DarkBlue             = 139, 
	DarkCyan             = 35723, 
	DarkGoldenRod        = 12092939, 
	DarkGray             = 11119017, 
	DarkGreen            = 25600, 
	DarkKhaki            = 12433259, 
	DarkMagenta          = 9109643, 
	DarkOliveGreen       = 5597999, 
	DarkOrange           = 16747520, 
	DarkOrchid           = 10040012, 
	DarkRed              = 9109504, 
	DarkSalmon           = 15308410, 
	DarkSeaGreen         = 9419919, 
	DarkSlateBlue        = 4734347, 
	DarkSlateGray        = 3100495, 
	DarkTurquoise        = 52945, 
	DarkViolet           = 9699539, 
	DeepPink             = 16716947, 
	DeepSkyBlue          = 49151, 
	DimGray              = 6908265, 
	DodgerBlue           = 2003199, 
	FireBrick            = 11674146, 
	FloralWhite          = 16775920, 
	ForestGreen          = 2263842, 
	Fuchsia              = 16711935, 
	Gainsboro            = 14474460, 
	GhostWhite           = 16316671, 
	Gold                 = 16766720, 
	GoldenRod            = 14329120, 
	Gray                 = 8421504, 
	Green                = 32768, 
	GreenYellow          = 11403055, 
	HoneyDew             = 15794160, 
	HotPink              = 16738740, 
	IndianRed            = 13458524, 
	Indigo               = 4915330, 
	Ivory                = 16777200, 
	Khaki                = 15787660, 
	Lavender             = 15132410, 
	LavenderBlush        = 16773365, 
	LawnGreen            = 8190976, 
	LemonChiffon         = 16775885, 
	LightBlue            = 11393254, 
	LightCoral           = 15761536, 
	LightCyan            = 14745599, 
	LightGoldenRodYellow = 16448210, 
	LightGray            = 13882323, 
	LightGreen           = 9498256, 
	LightPink            = 16758465, 
	LightSalmon          = 16752762, 
	LightSeaGreen        = 2142890, 
	LightSkyBlue         = 8900346, 
	LightSlateGray       = 7833753, 
	LightSteelBlue       = 11584734, 
	LightYellow          = 16777184, 
	Lime                 = 65280, 
	LimeGreen            = 3329330, 
	Linen                = 16445670, 
	Magenta              = 16711935, 
	Maroon               = 8388608, 
	MediumAquaMarine     = 6737322, 
	MediumBlue           = 205, 
	MediumOrchid         = 12211667, 
	MediumPurple         = 9662683, 
	MediumSeaGreen       = 3978097, 
	MediumSlateBlue      = 8087790, 
	MediumSpringGreen    = 64154, 
	MediumTurquoise      = 4772300, 
	MediumVioletRed      = 13047173, 
	MidnightBlue         = 1644912, 
	MintCream            = 16121850, 
	MistyRose            = 16770273, 
	Moccasin             = 16770229, 
	NavajoWhite          = 16768685, 
	Navy                 = 128, 
	OldLace              = 16643558, 
	Olive                = 8421376, 
	OliveDrab            = 7048739, 
	Orange               = 16753920, 
	OrangeRed            = 16729344, 
	Orchid               = 14315734, 
	PaleGoldenRod        = 15657130, 
	PaleGreen            = 10025880, 
	PaleTurquoise        = 11529966, 
	PaleVioletRed        = 14381203, 
	PapayaWhip           = 16773077, 
	PeachPuff            = 16767673, 
	Peru                 = 13468991, 
	Pink                 = 16761035, 
	Plum                 = 14524637, 
	PowderBlue           = 11591910, 
	Purple               = 8388736, 
	RebeccaPurple        = 6697881, 
	Red                  = 16711680, 
	RosyBrown            = 12357519, 
	RoyalBlue            = 4286945, 
	SaddleBrown          = 9127187, 
	Salmon               = 16416882, 
	SandyBrown           = 16032864, 
	SeaGreen             = 3050327, 
	SeaShell             = 16774638, 
	Sienna               = 10506797, 
	Silver               = 12632256, 
	SkyBlue              = 8900331, 
	SlateBlue            = 6970061, 
	SlateGray            = 7372944, 
	Snow                 = 16775930, 
	SpringGreen          = 65407, 
	SteelBlue            = 4620980, 
	Tan                  = 13808780, 
	Teal                 = 32896, 
	Thistle              = 14204888, 
	Tomato               = 16737095, 
	Turquoise            = 4251856, 
	Violet               = 15631086, 
	Wheat                = 16113331, 
	White                = 16777215, 
	WhiteSmoke           = 16119285, 
	Yellow               = 16776960, 
	YellowGreen          = 10145074, 
	Box2DRed             = 14430514, 
	Box2DBlue            = 3190463, 
	Box2DGreen           = 9226532, 
	Box2DYellow          = 16772748, 
}

HullData :: struct {
	// Version must be first and match B3_HULL_VERSION
	version:        u64,
	// The total number of bytes for this hull.
	byteCount:      i32,
	// Hash of this hull (this field is zero when the hash is computed).
	hash:           u32,
	// Axis-aligned box in local space.
	aabb:           AABB,
	// Surface area, typically in squared meters.
	surfaceArea:    f32,
	// Volume, typically in m^3.
	volume:         f32,
	// The radius of the largest sphere at the center.
	innerRadius:    f32,
	// The local centroid
	center:         [3]f32,
	// The inertia tensor about the centroid.
	centralInertia: matrix[3, 3]f32,
	// The vertex count.
	vertexCount:    i32,
	// Offset of the vertex array in bytes from the struct address.
	vertexOffset:   i32,
	// Offset of the point array in bytes from the struct address.
	pointOffset:    i32,
	// This is the half-edge count (double the edge count)
	edgeCount:      i32,
	// Offset of the edge array in bytes from the struct address.
	edgeOffset:     i32,
	// The face count. Hulls faces are convex polygons.
	faceCount:      i32,
	// Offset of the face array in bytes from the struct address.
	faceOffset:     i32,
	// Offset of the face plane array in bytes from the struct address.
	planeOffset:    i32,
	// Explicit padding. Hull identity is a content hash and memcmp over raw bytes,
	// so there must be no unnamed padding for struct copies to scramble.
	padding:        i32,
}

HullFace :: struct {
	// A half-edge that has this vertex as the origin
	// Can be used along with edge twins and winding order
	// to traverse all the edges connected to this vertex.
	edge: u8,
}

HullHalfEdge :: struct {
	// Next edge index CCW
	next:   u8,
	// Twin edge index
	twin:   u8,
	// index of origin vertex and point
	origin: u8,
	// Face to the left of this edge
	face:   u8,
}

HullVertex :: struct {
	// A half-edge that has this vertex as the origin
	// Can be used along with edge twins and winding order
	// to traverse all the edges connected to this vertex.
	edge: u8,
}

JointDef :: struct {
	// User data pointer
	userData:               rawptr,
	// The first attached body
	bodyIdA:                BodyId,
	// The second attached body
	bodyIdB:                BodyId,
	// The first local joint frame
	localFrameA:            Transform,
	// The second local joint frame
	localFrameB:            Transform,
	// Force threshold for joint events
	forceThreshold:         f32,
	// Torque threshold for joint events
	torqueThreshold:        f32,
	// Constraint hertz (advanced feature)
	constraintHertz:        f32,
	// Constraint damping ratio (advanced feature)
	constraintDampingRatio: f32,
	// Debug draw scale
	drawScale:              f32,
	// Set this flag to true if the attached bodies should collide
	collideConnected:       bool,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:          i32,
}

JointEvent :: struct {
	// The joint id
	jointId:  JointId,
	// The user data from the joint for convenience
	userData: rawptr,
}

JointEvents :: struct {
	// Array of events
	jointEvents: [^]JointEvent `fmt:"v,count"`,
	// Number of events
	count:       i32,
}

JointId :: struct {
	index1:     i32,
	world0:     u16,
	generation: u16,
}

JointType :: enum i32 {
	parallelJoint, 
	distanceJoint, 
	filterJoint, 
	motorJoint, 
	prismaticJoint, 
	revoluteJoint, 
	sphericalJoint, 
	weldJoint, 
	wheelJoint, 
}

LocalManifold :: struct {
	// Local normal in frame A.
	normal:          [3]f32,
	// The triangle normal.
	triangleNormal:  [3]f32,
	// The manifold points. From a point buffer.
	points:          LocalManifoldPoint,
	// The number of manifold points. Only bounded by the buffer capacity.
	pointCount:      i32,
	// The index of the triangle.
	triangleIndex:   i32,
	i1:              i32,
	// < Vertex 1 index.
	i2:              i32,
	// < Vertex 2 index.
	i3:              i32,
	// The squared distance of a sphere from a triangle. For ghost collision reduction.
	squaredDistance: f32,
	// The triangle feature involved.
	feature:         TriangleFeature,
	// MeshEdgeFlags.
	triangleFlags:   MeshEdgeFlags,
}

LocalManifoldPoint :: struct {
	// Local point in frame A.
	point:         [3]f32,
	// The contact point separation. Negative for overlap.
	separation:    f32,
	// The feature pair for this point.
	pair:          FeaturePair,
	// The triangle index when collide with a mesh or height-field.
	triangleIndex: i32,
}

LogFcn :: proc "c" (message: rawptr)

Manifold :: struct {
	// The manifold points. There may be 1 to 4 valid points.
	points:          [4]ManifoldPoint,
	// The unit normal vector in world space, points from shape A to shape B
	normal:          [3]f32,
	// Central friction angular impulse (applied about the normal)
	twistImpulse:    f32,
	// Central friction linear impulse
	frictionImpulse: [3]f32,
	// Rolling resistance angular impulse
	rollingImpulse:  [3]f32,
	// The number of contact points, will be 0 to 4
	pointCount:      i32,
}

ManifoldPoint :: struct {
	// Location of the contact point relative to the bodyA center of mass in world space.
	anchorA:            [3]f32,
	// Location of the contact point relative to the bodyB center of mass in world space.
	anchorB:            [3]f32,
	// The separation of the contact point, negative if penetrating
	separation:         f32,
	// Cached separation used for contact recycling
	baseSeparation:     f32,
	// The impulse along the manifold normal vector. Since Box3D uses sub-stepping, this is
	// result from the final sub-step.
	normalImpulse:      f32,
	// The total normal impulse applied during sub-stepping. This is important
	// to identify speculative contact points that had an interaction in the time step.
	totalNormalImpulse: f32,
	// Relative normal velocity pre-solve. Used for hit events. If the normal impulse is
	// zero then there was no hit. Negative means shapes are approaching.
	normalVelocity:     f32,
	// Local point for matching
	// Uniquely identifies a contact point between two shapes
	featureId:          u32,
	// Triangle index if one of the shapes is a mesh or height field
	triangleIndex:      i32,
	// Did this contact point exist in the previous step?
	persisted:          bool,
}

MassData :: struct {
	// The shape mass
	mass:    f32,
	// The local center of mass position.
	center:  [3]f32,
	// The inertia tensor about the shape center of mass.
	inertia: matrix[3, 3]f32,
}

Matrix3 :: matrix[3, 3]f32

Mesh :: struct {
	// Immutable pointer to the mesh data.
	data:  ^MeshData,
	// This scale may be non-uniform and have negative components. However,
	// no component may be very small in magnitude.
	scale: [3]f32,
}

MeshData :: struct {
	// Version must be first.
	version:         u64,
	// The total number of bytes for this mesh.
	byteCount:       i32,
	// Hash of this mesh (this field is zero when the hash is computed)
	hash:            u32,
	// Local axis-aligned box.
	bounds:          AABB,
	// Combined surface area of all triangles. Single-sided.
	surfaceArea:     f32,
	// The height of the bounding volume hierarchy.
	treeHeight:      i32,
	// The number of degenerate triangles. Diagnostic.
	degenerateCount: i32,
	// Offset of the node array in bytes from the struct address.
	nodeOffset:      i32,
	// The number of BVH nodes.
	nodeCount:       i32,
	// Offset of the vertex array in bytes from the struct address.
	vertexOffset:    i32,
	// The number of vertices.
	vertexCount:     i32,
	// Offset of the triangle array in bytes from the struct address.
	triangleOffset:  i32,
	// The number of triangles.
	triangleCount:   i32,
	// Offset of the material array in bytes from the struct address.
	materialOffset:  i32,
	// The number of materials.
	materialCount:   i32,
	// Offset of the triangle flag array in bytes from the struct address.
	flagsOffset:     i32,
}

MeshDef :: struct {
	// Triangle vertices
	vertices:        [^][3]f32 `fmt:"v,vertexCount"`,
	// Triangle vertex indices. 3 for each triangle.
	indices:         [^]i32,
	// Triangle material index. 1 per triangle. Indexes into b3ShapeDef::materials.
	// This allows different run-time material data to be associated with different
	// instances of this mesh.
	materialIndices: [^]u8,
	// Tolerance for vertex welding in length units.
	weldTolerance:   f32,
	// The vertex count. Must be 3 or more.
	vertexCount:     i32,
	// The triangle count. Must be 1 or more.
	triangleCount:   i32,
	// Optionally weld nearby vertices.
	weldVertices:    bool,
	// Use the median split instead of SAH to speed up mesh creation. Good
	// for meshes that are structured like a grid.
	useMedianSplit:  bool,
	// Compute triangle adjacency information using shared edges
	identifyEdges:   bool,
}

MeshEdgeFlag :: enum u32 {
	concaveEdge1        = 0, 
	concaveEdge2        = 1, 
	concaveEdge3        = 2, 
	inverseConcaveEdge1 = 4, 
	inverseConcaveEdge2 = 5, 
	inverseConcaveEdge3 = 6, 
}

MeshEdgeFlags :: distinct bit_set[MeshEdgeFlag; u32]

MeshNode :: struct {
	// The lower bound of the node AABB. Strategic placement for SIMD.
	lowerBound:     [3]f32,
	// Anonymous union.
	data:           struct #raw_union {
		// Internal node
		asNode: bit_field u32 {
			axis:        u32 | 2,
			childOffset: u32 | 30,
		},
		// Leaf node
		asLeaf: bit_field u32 {
			type:          u32 | 2,
			triangleCount: u32 | 30,
		},
	},
	// The upper bound of the node AABB.  Strategic placement for SIMD.
	upperBound:     [3]f32,
	// The index of the leaf triangles.
	triangleOffset: u32,
}

MeshQueryFcn :: proc "c" (x, y, z: [3]f32, triangleIndex: i32, ctx: rawptr) -> bool

MeshTriangle :: struct {
	index1: i32,
	// < Index of vertex 1.
	index2: i32,
	// < Index of vertex 2.
	index3: i32,
}

MotionLocks :: struct {
	// Prevent translation along the x-axis
	linearX:  bool,
	// Prevent translation along the y-axis
	linearY:  bool,
	// Prevent translation along the z-axis
	linearZ:  bool,
	// Prevent rotation around the x-axis
	angularX: bool,
	// Prevent rotation around the y-axis
	angularY: bool,
	// Prevent rotation around the z-axis
	angularZ: bool,
}

MotorJointDef :: struct {
	// Base joint definition
	using base:          JointDef,
	// The desired linear velocity
	linearVelocity:      [3]f32,
	// The maximum motor force in newtons
	maxVelocityForce:    f32,
	// The desired angular velocity
	angularVelocity:     [3]f32,
	// The maximum motor torque in newton-meters
	maxVelocityTorque:   f32,
	// Linear spring hertz for position control
	linearHertz:         f32,
	// Linear spring damping ratio
	linearDampingRatio:  f32,
	// Maximum spring force in newtons
	maxSpringForce:      f32,
	// Angular spring hertz for position control
	angularHertz:        f32,
	// Angular spring damping ratio
	angularDampingRatio: f32,
	// Maximum spring torque in newton-meters
	maxSpringTorque:     f32,
}

MoverFilterFcn :: proc "c" (shapeId: ShapeId, ctx: rawptr) -> bool

OverlapResultFcn :: proc "c" (shapeId: ShapeId, ctx: rawptr) -> bool

ParallelJointDef :: struct {
	// Base joint definition
	using base:   JointDef,
	// The spring stiffness Hertz, cycles per second
	hertz:        f32,
	// The spring damping ratio, non-dimensional
	dampingRatio: f32,
	// The maximum spring torque, typically in newton-meters.
	maxTorque:    f32,
}

Plane :: struct {
	normal: [3]f32,
	offset: f32,
}

PlaneResult :: struct {
	// Outward pointing plane.
	plane: Plane,
	// Closest point on the shape. May not be unique.
	point: [3]f32,
}

PlaneResultFcn :: proc "c" (shapeId: ShapeId, plane: [^]PlaneResult, planeCount: i32, ctx: rawptr) -> bool

PlaneSolverResult :: struct {
	// The final relative translation.
	delta:          [3]f32,
	// The number of iterations used by the plane solver. For diagnostics.
	iterationCount: i32,
}

Pos :: [3]f32

PreSolveFcn :: proc "c" (shapeIdA: ShapeId, shapeIdB: ShapeId, point: [3]f32, normal: [3]f32, ctx: rawptr) -> bool

PrismaticJointDef :: struct {
	// Base joint definition
	using base:        JointDef,
	// Enable a linear spring along the prismatic joint axis
	enableSpring:      bool,
	// The spring stiffness Hertz, cycles per second
	hertz:             f32,
	// The spring damping ratio, non-dimensional
	dampingRatio:      f32,
	// The target translation for the joint in meters. The spring-damper will drive
	// to this translation.
	targetTranslation: f32,
	// Enable/disable the joint limit
	enableLimit:       bool,
	// The lower translation limit
	lowerTranslation:  f32,
	// The upper translation limit
	upperTranslation:  f32,
	// Enable/disable the joint motor
	enableMotor:       bool,
	// The maximum motor force, typically in newtons
	maxMotorForce:     f32,
	// The desired motor speed, typically in meters per second
	motorSpeed:        f32,
}

Profile :: struct {
	step:                f32,
	pairs:               f32,
	collide:             f32,
	solve:               f32,
	solverSetup:         f32,
	constraints:         f32,
	prepareConstraints:  f32,
	integrateVelocities: f32,
	warmStart:           f32,
	solveImpulses:       f32,
	integratePositions:  f32,
	relaxImpulses:       f32,
	applyRestitution:    f32,
	storeImpulses:       f32,
	splitIslands:        f32,
	transforms:          f32,
	sensorHits:          f32,
	jointEvents:         f32,
	hitEvents:           f32,
	refit:               f32,
	bullets:             f32,
	sleepIslands:        f32,
	sensors:             f32,
}

Quat :: quaternion128

QueryFilter :: struct {
	// The collision category bits of this query. Normally you would just set one bit.
	categoryBits: u64,
	// The collision mask bits. This states the shape categories that this
	// query would accept for collision.
	maskBits:     u64,
	// Optional id combined with @ref name to identify this query in a recording, e.g. an entity id.
	// Need not be unique on its own. 0 with a null name means untagged. Ignored when not recording.
	id:           u64,
	// Optional label combined with @ref id to identify this query, e.g. "bullet". Need not be unique
	// on its own. The recorder hashes (id, name) into one stable key the viewer tracks the query by,
	// so the same id and name pair identifies the same query across frames. NULL means none. Ignored
	// when not recording.
	name:         cstring,
}

RayCastInput :: struct {
	// Start point of the ray cast.
	origin:      [3]f32,
	// Translation of the ray cast.
	// end = start + translation.
	translation: [3]f32,
	// The maximum fraction of the translation to consider, typically 1
	maxFraction: f32,
}

RayResult :: struct {
	// The shape hit.
	shapeId:        ShapeId,
	// The world point of the hit.
	point:          [3]f32,
	// The world normal of the shape surface at the hit point.
	normal:         [3]f32,
	// The user material id at the hit point. This can be per triangle
	// if the shape is a mesh, height-field, or compound with child mesh.
	userMaterialId: u64,
	// The fraction of the input ray.
	fraction:       f32,
	// The triangle index if the shape is a mesh, height-field, or compound with
	// child mesh.
	triangleIndex:  i32,
	// The child index if the shape is a compound.
	childIndex:     i32,
	// The number of BVH nodes visited. Diagnostic.
	nodeVisits:     i32,
	// The number of BVH leaves visited. Diagnostic.
	leafVisits:     i32,
	// Did the ray hit? If false, all other data is invalid.
	hit:            bool,
}

RecPlayer :: struct {}

RecPlayerInfo :: struct {
	frameCount:   i32,
	// total recorded steps
	workerCount:  i32,
	// worker count requested for the replay world
	timeStep:     f32,
	// dt of the recorded steps
	subStepCount: i32,
	// recorded sub-steps
	lengthScale:  f32,
	// length units per meter in effect when recorded
	bounds:       AABB,
}

RecQueryHit :: struct {
	shape:    ShapeId,
	point:    [3]f32,
	normal:   [3]f32,
	fraction: f32,
}

RecQueryInfo :: struct {
	type:        RecQueryType,
	filter:      QueryFilter,
	aabb:        AABB,
	// world-space bounds of the query, swept for casts
	origin:      [3]f32,
	// query origin (zero for overlap AABB)
	translation: [3]f32,
	// ray and cast translation
	hitCount:    i32,
	// 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,
}

RecQueryType :: enum i32 {
	OverlapAABB, 
	OverlapShape, 
	CastRay, 
	CastShape, 
	CastRayClosest, 
	CastMover, 
	CollideMover, 
}

Recording :: struct {}

RestitutionCallback :: proc "c" (restitutionA: f32, userMaterialIdA: u64, restitutionB: f32, userMaterialIdB: u64) -> f32

RevoluteJointDef :: struct {
	// Base joint definition.
	using base:     JointDef,
	// The bodyB angle minus bodyA angle in the reference state (radians).
	// This defines the zero angle for the joint limit.
	targetAngle:    f32,
	// Enable a rotational spring on the revolute hinge axis.
	enableSpring:   bool,
	// The spring stiffness Hertz, cycles per second.
	hertz:          f32,
	// The spring damping ratio, non-dimensional.
	dampingRatio:   f32,
	// A flag to enable joint limits.
	enableLimit:    bool,
	// The lower angle for the joint limit in radians. Minimum of -0.99*pi radians.
	lowerAngle:     f32,
	// The upper angle for the joint limit in radians. Maximum of 0.99*pi radians.
	upperAngle:     f32,
	// A flag to enable the joint motor.
	enableMotor:    bool,
	// The maximum motor torque, typically in newton-meters.
	maxMotorTorque: f32,
	// The desired motor speed in radians per second.
	motorSpeed:     f32,
}

SATCache :: struct {
	// The separation when the cache is populated. Negative for overlap.
	separation: f32,
	// b3SeparatingFeature.
	type:       u8,
	// Index of the feature on shape A.
	indexA:     u8,
	// Index of the feature on shape B.
	indexB:     u8,
	// Was the cache re-used?
	hit:        u8,
}

SegmentDistanceResult :: struct {
	point1:    [3]f32,
	fraction1: f32,
	point2:    [3]f32,
	fraction2: f32,
}

SensorBeginTouchEvent :: struct {
	// The id of the sensor shape
	sensorShapeId:  ShapeId,
	// The id of the shape that began touching the sensor shape
	visitorShapeId: ShapeId,
}

SensorEndTouchEvent :: struct {
	// The id of the sensor shape
	sensorShapeId:  ShapeId,
	// The id of the shape that began touching the sensor shape
	visitorShapeId: ShapeId,
}

SensorEvents :: struct {
	// Array of sensor begin touch events
	beginEvents: [^]SensorBeginTouchEvent `fmt:"v,beginCount"`,
	// Array of sensor end touch events
	endEvents:   [^]SensorEndTouchEvent `fmt:"v,endCount"`,
	// The number of begin touch events
	beginCount:  i32,
	// The number of end touch events
	endCount:    i32,
}

SeparatingFeature :: enum i32 {
	invalidAxis        = 0, 
	backsideAxis, 
	faceAxisA, 
	faceAxisB, 
	edgePairAxis, 
	closestPointsAxis, 
	// These are for testing
	manualFaceAxisA, 
	manualFaceAxisB, 
	manualEdgePairAxis, 
}

ShapeCastInput :: struct {
	// A generic query shape.
	proxy:       ShapeProxy,
	// The translation of the shape cast.
	translation: [3]f32,
	// The maximum fraction of the translation to consider, typically 1.
	maxFraction: f32,
	// Allow shape cast to encroach when initially touching. This only works if the radius is greater than zero.
	canEncroach: bool,
}

ShapeCastPairInput :: struct {
	proxyA:       ShapeProxy,
	// < The proxy for shape A
	proxyB:       ShapeProxy,
	// < The proxy for shape B
	transform:    Transform,
	// < Transform of shape B in shape A's frame, the relative pose B in A
	translationB: [3]f32,
	// < The translation of shape B, in A's frame
	maxFraction:  f32,
	// < The fraction of the translation to consider, typically 1
	canEncroach:  bool,
}

ShapeDef :: struct {
	// Use this to store application specific shape data.
	userData:              rawptr,
	// Surface material used on mesh shapes per triangle. Ignored for convex shapes. Ignored for compound shapes.
	materials:             [^]SurfaceMaterial `fmt:"v,materialCount"`,
	// Surface material count.
	materialCount:         i32,
	// The base surface material. Ignored for compound shapes.
	baseMaterial:          SurfaceMaterial,
	// The density, usually in kg/m^3.
	density:               f32,
	// Explosion scale for b3World_Explode. non-dimensional
	explosionScale:        f32,
	// Contact filtering data.
	filter:                Filter,
	// Enable custom filtering. Only one of the two shapes needs to enable custom filtering. See b3WorldDef.
	enableCustomFiltering: bool,
	// A sensor shape generates overlap events but never generates a collision response.
	// Sensors do not have continuous collision. Instead, use a ray or shape cast for those scenarios.
	// Sensors still contribute to the body mass if they have non-zero density.
	// @note Sensor events are disabled by default.
	// @see enableSensorEvents
	isSensor:              bool,
	// Enable sensor events for this shape. This applies to sensors and non-sensors. False by default, even for sensors.
	enableSensorEvents:    bool,
	// Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. False by default.
	enableContactEvents:   bool,
	// Enable hit events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. False by default.
	enableHitEvents:       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.
	enablePreSolveEvents:  bool,
	// When shapes are created they will scan the environment for collision the next time step. This can significantly slow down
	// static body creation when there are many static shapes.
	// This is flag is ignored for dynamic and kinematic shapes which always invoke contact creation.
	invokeContactCreation: bool,
	// Should the body update the mass properties when this shape is created. Default is true.
	updateBodyMass:        bool,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:         i32,
}

ShapeId :: struct {
	index1:     i32,
	world0:     u16,
	generation: u16,
}

ShapeProxy :: struct {
	// The point cloud.
	points: [^][3]f32 `fmt:"v,count"`,
	// The number of points. Do not exceed B3_MAX_SHAPE_CAST_POINTS.
	count:  i32,
	// The external radius of the point cloud.
	radius: f32,
}

ShapeType :: enum i32 {
	// A capsule is an extruded sphere
	capsuleShape, 
	// A compound shape composed of up to 64K spheres, capsules, hulls, and meshes
	compoundShape, 
	// A height field useful for terrain
	heightShape, 
	// A convex hull
	hullShape, 
	// A triangle soup
	meshShape, 
	// A sphere with an offset
	sphereShape, 
}

Simplex :: struct {
	vertices: [4]SimplexVertex `fmt:"v,count"`,
	// < vertices
	count:    i32,
}

SimplexCache :: struct {
	// Value use to compare length, area, volume of two simplexes.
	metric: f32,
	// todo use an index of 0xFF as a sentinel and remove the count
	// The number of stored simplex points
	count:  u16,
	// The cached simplex indices on shape A
	indexA: [4]u8,
	// The cached simplex indices on shape B
	indexB: [4]u8,
}

SimplexVertex :: struct {
	wA:     [3]f32,
	// < support point in proxyA
	wB:     [3]f32,
	// < support point in proxyB
	w:      [3]f32,
	// < wB - wA
	a:      f32,
	// < barycentric coordinates
	indexA: i32,
	// < wA index
	indexB: i32,
}

Sphere :: struct {
	// The local center
	center: [3]f32,
	// The radius
	radius: f32,
}

SphericalJointDef :: struct {
	// Base joint definition
	using base:       JointDef,
	// Enable a rotational spring that attempts to align the two joint frames.
	enableSpring:     bool,
	// The spring stiffness Hertz, cycles per second. This may be clamped internally
	// according to the time step to maintain stability. Non-negative number.
	hertz:            f32,
	// The spring damping ratio, non-dimensional. Non-negative number.
	dampingRatio:     f32,
	// Target spring rotation, joint frame B relative to joint frame A.
	targetRotation:   quaternion128,
	// A flag to enable the cone limit. The cone is centered on the frameA z-axis.
	enableConeLimit:  bool,
	// The angle for the cone limit in radians. Valid range is [0, pi]
	coneAngle:        f32,
	// A flag to enable the twist limit. The twist is centered on the frameB z-axis.
	enableTwistLimit: bool,
	// The angle for the lower twist limit in radians. Minimum of -0.99*pi radians.
	lowerTwistAngle:  f32,
	// The angle for the upper twist limit in radians. Maximum of 0.99*pi radians.
	upperTwistAngle:  f32,
	// A flag to enable the joint motor
	enableMotor:      bool,
	// The maximum motor torque, typically in newton-meters. Non-negative number.
	maxMotorTorque:   f32,
	// The desired motor angular velocity in radians per second.
	motorVelocity:    [3]f32,
}