package vendor:box2d

Source

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

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

AssertFcn :: proc "c" (condition, file_name: cstring, line_number: i32) -> i32

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:          [2]f32,
	// The initial world rotation of the body. Use b2MakeRot() if you have an angle.
	rotation:          Rot,
	// The initial linear velocity of the body's origin. Usually in meters per second.
	linearVelocity:    [2]f32,
	// The initial angular velocity of the body. Radians per second.
	angularVelocity:   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 f32ing.
	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 use 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 32 characters (excluding null termination)
	name:              cstring,
	// Use this to store application specific body data.
	userData:          rawptr,
	// Set this flag to false if this body should never fall asleep.
	enableSleep:       bool,
	// Is this body initially awake or sleeping?
	isAwake:           bool,
	// Should this body be prevented from rotating? Useful for characters.
	fixedRotation:     bool,
	// Treat this body as 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 may interfere with joint constraints.
	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,
	// 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 {
	transform:  Transform,
	bodyId:     BodyId,
	userData:   rawptr,
	fellAsleep: bool,
}

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, 
}

Capsule :: struct {
	// Local center of the first semicircle
	center1: [2]f32,
	// Local center of the second semicircle
	center2: [2]f32,
	// The radius of the semicircles
	radius:  f32,
}

CastOutput :: struct {
	// The surface normal at the hit point
	normal:     [2]f32,
	// The surface hit point
	point:      [2]f32,
	// The fraction of the input translation at collision
	fraction:   f32,
	// The number of iterations used
	iterations: i32,
	// Did the cast hit?
	hit:        bool,
}

CastResultFcn :: proc "c" (shapeId: ShapeId, point: [2]f32, normal: [2]f32, fraction: f32, ctx: rawptr) -> f32

ChainDef :: struct {
	// Use this to store application specific shape data.
	userData:           rawptr,
	// An array of at least 4 points. These are cloned and may be temporary.
	points:             [^][2]f32 `fmt:"v,count"`,
	// The point count, must be 4 or more.
	count:              i32,
	// Surface materials for each segment. These are cloned.
	materials:          [^]SurfaceMaterial `fmt:"v,materialCount"`,
	// The material count. Must be 1 or count. This allows you to provide one
	// material for all segments or a unique material per segment.
	materialCount:      i32,
	// Contact filtering data.
	filter:             Filter,
	// Indicates a closed chain formed by connecting the first and last points
	isLoop:             bool,
	// Enable sensors to detect this chain. False by default.
	enableSensorEvents: bool,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:      i32,
}

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

ChainSegment :: struct {
	// The tail ghost vertex
	ghost1:  [2]f32,
	// The line segment
	segment: Segment,
	// The head ghost vertex
	ghost2:  [2]f32,
	// The owning chain shape index (internal usage only)
	chainId: i32,
}

Circle :: struct {
	// The local center
	center: [2]f32,
	// The radius
	radius: f32,
}

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 b2SolvePlanes. Usually in meters.
	push:         f32,
	// Indicates if b2ClipVector should clip against this plane. Should be false for soft collision.
	clipVelocity: bool,
}

ContactBeginTouchEvent :: struct {
	// Id of the first shape
	shapeIdA: ShapeId,
	// Id of the second shape
	shapeIdB: ShapeId,
	// The initial contact manifold. This is recorded before the solver is called,
	// so all the impulses will be zero.
	manifold: Manifold,
}

ContactData :: struct {
	// Id of the first shape
	shapeIdA: ShapeId,
	// Id of the second shape
	shapeIdB: ShapeId,
	// The initial contact manifold. This is recorded before the solver is called,
	// so all the impulses will be zero.
	manifold: Manifold,
}

ContactEndTouchEvent :: struct {
	// Id of the first shape
	// @warning this shape may have been destroyed
	// @see b2Shape_IsValid
	shapeIdA: ShapeId,
	// Id of the second shape
	// @warning this shape may have been destroyed
	// @see b2Shape_IsValid
	shapeIdB: ShapeId,
}

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,
	// 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:         [2]f32,
	// Normal vector pointing from shape A to shape B
	normal:        [2]f32,
	// The speed the shapes are approaching. Always positive. Typically in meters per second.
	approachSpeed: f32,
}

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

Counters :: struct {
	bodyCount:        i32,
	shapeCount:       i32,
	contactCount:     i32,
	jointCount:       i32,
	islandCount:      i32,
	stackUsed:        i32,
	staticTreeHeight: i32,
	treeHeight:       i32,
	byteCount:        i32,
	taskCount:        i32,
	colorCounts:      [12]i32,
}

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

DebugDraw :: struct {
	// Draw a closed polygon provided in CCW order.
	DrawPolygonFcn:       proc "c" (vertices: [^][2]f32, vertexCount: i32, color: HexColor, ctx: rawptr),
	// Draw a solid closed polygon provided in CCW order.
	DrawSolidPolygonFcn:  proc "c" (transform: Transform, vertices: [^][2]f32, vertexCount: i32, radius: f32, colr: HexColor, ctx: rawptr),
	// Draw a circle.
	DrawCircleFcn:        proc "c" (center: [2]f32, radius: f32, color: HexColor, ctx: rawptr),
	// Draw a solid circle.
	DrawSolidCircleFcn:   proc "c" (transform: Transform, radius: f32, color: HexColor, ctx: rawptr),
	// Draw a solid capsule.
	DrawSolidCapsuleFcn:  proc "c" (p1, p2: [2]f32, radius: f32, color: HexColor, ctx: rawptr),
	// Draw a line segment.
	DrawSegmentFcn:       proc "c" (p1, p2: [2]f32, color: HexColor, ctx: rawptr),
	// Draw a transform. Choose your own length scale.
	DrawTransformFcn:     proc "c" (transform: Transform, ctx: rawptr),
	// Draw a point.
	DrawPointFcn:         proc "c" (p: [2]f32, size: f32, color: HexColor, ctx: rawptr),
	// Draw a string in world space.
	DrawStringFcn:        proc "c" (p: [2]f32, s: cstring, color: HexColor, ctx: rawptr),
	// Bounds to use if restricting drawing to a rectangular region
	drawingBounds:        AABB,
	// Option to restrict drawing to a rectangular region. May suffer from unstable depth sorting.
	useDrawingBounds:     bool,
	// 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,
	// Option to visualize the graph coloring used for contacts and joints
	drawGraphColors:      bool,
	// Option to draw contact normals
	drawContactNormals:   bool,
	// Option to draw contact normal impulses
	drawContactImpulses:  bool,
	// Option to draw contact feature ids
	drawContactFeatures:  bool,
	// Option to draw contact friction impulses
	drawFrictionImpulses: bool,
	// Option to draw islands as bounding boxes
	drawIslands:          bool,
	// User context that is passed as an argument to drawing callback functions
	userContext:          rawptr,
}

DistanceInput :: struct {
	// The proxy for shape A
	proxyA:     ShapeProxy,
	// The proxy for shape B
	proxyB:     ShapeProxy,
	// The world transform for shape A
	transformA: Transform,
	// The world transform for shape B
	transformB: Transform,
	// Should the proxy radius be considered?
	useRadii:   bool,
}

DistanceJointDef :: struct {
	// The first attached body
	bodyIdA:          BodyId,
	// The second attached body
	bodyIdB:          BodyId,
	// The local anchor point relative to bodyA's origin
	localAnchorA:     [2]f32,
	// The local anchor point relative to bodyB's origin
	localAnchorB:     [2]f32,
	// 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 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,
	// Set this flag to true if the attached bodies should collide
	collideConnected: bool,
	// User data pointer
	userData:         rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

DistanceOutput :: struct {
	pointA:       [2]f32,
	// Closest point on shapeA
	pointB:       [2]f32,
	// Closest point on shapeB
	normal:       [2]f32,
	// Normal vector that points from A to B. 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 tree nodes
	nodes:           rawptr,
	// The root index
	root:            i32,
	// The number of nodes
	nodeCount:       i32,
	// The allocated node space
	nodeCapacity:    i32,
	// Node free list
	freeList:        i32,
	// Number of proxies created
	proxyCount:      i32,
	// Leaf indices for rebuild
	leafIndices:     [^]i32,
	// Leaf bounding boxes for rebuild
	leafBoxes:       [^]AABB,
	// Leaf bounding box centers for rebuild
	leafCenters:     [^][2]f32,
	// Bins for sorting during rebuild
	binIndices:      [^]i32,
	// Allocated space for rebuilding
	rebuildCapacity: i32,
}

EnqueueTaskCallback :: proc "c" (task: TaskCallback, itemCount: i32, minRange: i32, taskContext: rawptr, userContext: rawptr) -> rawptr

ExplosionDef :: struct {
	// / Mask bits to filter shapes
	maskBits:         u64,
	// / The center of the explosion in world space
	position:         [2]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 length. This applies an impulse according to the shape perimeter that
	// / is facing the explosion. Explosions only apply to circles, capsules, and polygons. This
	// / may be negative for implosions.
	impulsePerLength: f32,
}

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 {
	// / The first attached body.
	bodyIdA:       BodyId,
	// / The second attached body.
	bodyIdB:       BodyId,
	// / User data pointer
	userData:      rawptr,
	// / Used internally to detect a valid definition. DO NOT SET.
	internalValue: i32,
}

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

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

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

HexColor :: enum i32 {
	AliceBlue            = 0xF0F8FF, 
	AntiqueWhite         = 0xFAEBD7, 
	Aqua                 = 0x00FFFF, 
	Aquamarine           = 0x7FFFD4, 
	Azure                = 0xF0FFFF, 
	Beige                = 0xF5F5DC, 
	Bisque               = 0xFFE4C4, 
	Black                = 0x000000, 
	BlanchedAlmond       = 0xFFEBCD, 
	Blue                 = 0x0000FF, 
	BlueViolet           = 0x8A2BE2, 
	Brown                = 0xA52A2A, 
	Burlywood            = 0xDEB887, 
	CadetBlue            = 0x5F9EA0, 
	Chartreuse           = 0x7FFF00, 
	Chocolate            = 0xD2691E, 
	Coral                = 0xFF7F50, 
	CornflowerBlue       = 0x6495ED, 
	Cornsilk             = 0xFFF8DC, 
	Crimson              = 0xDC143C, 
	Cyan                 = 0x00FFFF, 
	DarkBlue             = 0x00008B, 
	DarkCyan             = 0x008B8B, 
	DarkGoldenRod        = 0xB8860B, 
	DarkGray             = 0xA9A9A9, 
	DarkGreen            = 0x006400, 
	DarkKhaki            = 0xBDB76B, 
	DarkMagenta          = 0x8B008B, 
	DarkOliveGreen       = 0x556B2F, 
	DarkOrange           = 0xFF8C00, 
	DarkOrchid           = 0x9932CC, 
	DarkRed              = 0x8B0000, 
	DarkSalmon           = 0xE9967A, 
	DarkSeaGreen         = 0x8FBC8F, 
	DarkSlateBlue        = 0x483D8B, 
	DarkSlateGray        = 0x2F4F4F, 
	DarkTurquoise        = 0x00CED1, 
	DarkViolet           = 0x9400D3, 
	DeepPink             = 0xFF1493, 
	DeepSkyBlue          = 0x00BFFF, 
	DimGray              = 0x696969, 
	DodgerBlue           = 0x1E90FF, 
	FireBrick            = 0xB22222, 
	FloralWhite          = 0xFFFAF0, 
	ForestGreen          = 0x228B22, 
	Fuchsia              = 0xFF00FF, 
	Gainsboro            = 0xDCDCDC, 
	GhostWhite           = 0xF8F8FF, 
	Gold                 = 0xFFD700, 
	GoldenRod            = 0xDAA520, 
	Gray                 = 0x808080, 
	Green                = 0x008000, 
	GreenYellow          = 0xADFF2F, 
	HoneyDew             = 0xF0FFF0, 
	HotPink              = 0xFF69B4, 
	IndianRed            = 0xCD5C5C, 
	Indigo               = 0x4B0082, 
	Ivory                = 0xFFFFF0, 
	Khaki                = 0xF0E68C, 
	Lavender             = 0xE6E6FA, 
	LavenderBlush        = 0xFFF0F5, 
	LawnGreen            = 0x7CFC00, 
	LemonChiffon         = 0xFFFACD, 
	LightBlue            = 0xADD8E6, 
	LightCoral           = 0xF08080, 
	LightCyan            = 0xE0FFFF, 
	LightGoldenRodYellow = 0xFAFAD2, 
	LightGray            = 0xD3D3D3, 
	LightGreen           = 0x90EE90, 
	LightPink            = 0xFFB6C1, 
	LightSalmon          = 0xFFA07A, 
	LightSeaGreen        = 0x20B2AA, 
	LightSkyBlue         = 0x87CEFA, 
	LightSlateGray       = 0x778899, 
	LightSteelBlue       = 0xB0C4DE, 
	LightYellow          = 0xFFFFE0, 
	Lime                 = 0x00FF00, 
	LimeGreen            = 0x32CD32, 
	Linen                = 0xFAF0E6, 
	Magenta              = 0xFF00FF, 
	Maroon               = 0x800000, 
	MediumAquaMarine     = 0x66CDAA, 
	MediumBlue           = 0x0000CD, 
	MediumOrchid         = 0xBA55D3, 
	MediumPurple         = 0x9370DB, 
	MediumSeaGreen       = 0x3CB371, 
	MediumSlateBlue      = 0x7B68EE, 
	MediumSpringGreen    = 0x00FA9A, 
	MediumTurquoise      = 0x48D1CC, 
	MediumVioletRed      = 0xC71585, 
	MidnightBlue         = 0x191970, 
	MintCream            = 0xF5FFFA, 
	MistyRose            = 0xFFE4E1, 
	Moccasin             = 0xFFE4B5, 
	NavajoWhite          = 0xFFDEAD, 
	Navy                 = 0x000080, 
	OldLace              = 0xFDF5E6, 
	Olive                = 0x808000, 
	OliveDrab            = 0x6B8E23, 
	Orange               = 0xFFA500, 
	OrangeRed            = 0xFF4500, 
	Orchid               = 0xDA70D6, 
	PaleGoldenRod        = 0xEEE8AA, 
	PaleGreen            = 0x98FB98, 
	PaleTurquoise        = 0xAFEEEE, 
	PaleVioletRed        = 0xDB7093, 
	PapayaWhip           = 0xFFEFD5, 
	PeachPuff            = 0xFFDAB9, 
	Peru                 = 0xCD853F, 
	Pink                 = 0xFFC0CB, 
	Plum                 = 0xDDA0DD, 
	PowderBlue           = 0xB0E0E6, 
	Purple               = 0x800080, 
	RebeccaPurple        = 0x663399, 
	Red                  = 0xFF0000, 
	RosyBrown            = 0xBC8F8F, 
	RoyalBlue            = 0x4169E1, 
	SaddleBrown          = 0x8B4513, 
	Salmon               = 0xFA8072, 
	SandyBrown           = 0xF4A460, 
	SeaGreen             = 0x2E8B57, 
	SeaShell             = 0xFFF5EE, 
	Sienna               = 0xA0522D, 
	Silver               = 0xC0C0C0, 
	SkyBlue              = 0x87CEEB, 
	SlateBlue            = 0x6A5ACD, 
	SlateGray            = 0x708090, 
	Snow                 = 0xFFFAFA, 
	SpringGreen          = 0x00FF7F, 
	SteelBlue            = 0x4682B4, 
	Tan                  = 0xD2B48C, 
	Teal                 = 0x008080, 
	Thistle              = 0xD8BFD8, 
	Tomato               = 0xFF6347, 
	Turquoise            = 0x40E0D0, 
	Violet               = 0xEE82EE, 
	Wheat                = 0xF5DEB3, 
	White                = 0xFFFFFF, 
	WhiteSmoke           = 0xF5F5F5, 
	Yellow               = 0xFFFF00, 
	YellowGreen          = 0x9ACD32, 
	Box2DRed             = 0xDC3132, 
	Box2DBlue            = 0x30AEBF, 
	Box2DGreen           = 0x8CC924, 
	Box2DYellow          = 0xFFEE8C, 
}

Hull :: struct {
	// The final points of the hull
	points: [8][2]f32 `fmt:"v,count"`,
	// The number of points
	count:  i32,
}

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

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

Manifold :: struct {
	// The unit normal vector in world space, points from shape A to bodyB
	normal:         [2]f32,
	// Angular impulse applied for rolling resistance. N * m * s = kg * m^2 / s
	rollingImpulse: f32,
	// The manifold points, up to two are possible in 2D
	points:         [2]ManifoldPoint,
	// The number of contacts points, will be 0, 1, or 2
	pointCount:     i32,
}

ManifoldPoint :: struct {
	// Location of the contact point in world space. Subject to precision loss at large coordinates.
	// 	@note Should only be used for debugging.
	point:              [2]f32,
	// Location of the contact point relative to shapeA's origin in world space
	// 	@note When used internally to the Box2D solver, this is relative to the body center of mass.
	anchorA:            [2]f32,
	// Location of the contact point relative to shapeB's origin in world space
	// @note When used internally to the Box2D solver, this is relative to the body center of mass.
	anchorB:            [2]f32,
	// The separation of the contact point, negative if penetrating
	separation:         f32,
	// The total normal impulse applied across sub-stepping and restitution. This is important
	// to identify speculative contact points that had an interaction in the time step.
	totalNormalImpulse: f32,
	// The friction impulse
	tangentImpulse:     f32,
	// The maximum normal impulse applied during sub-stepping
	// 	todo not sure this is needed
	maxNormalImpulse:   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,
	// Uniquely identifies a contact point between two shapes
	id:                 u16,
	// Did this contact point exist the previous step?
	persisted:          bool,
}

MassData :: struct {
	// The mass of the shape, usually in kilograms.
	mass:              f32,
	// The position of the shape's centroid relative to the shape's origin.
	center:            [2]f32,
	// The rotational inertia of the shape about the local origin.
	rotationalInertia: f32,
}

Mat22 :: matrix[2, 2]f32

MotorJointDef :: struct {
	// The first attached body
	bodyIdA:          BodyId,
	// The second attached body
	bodyIdB:          BodyId,
	// Position of bodyB minus the position of bodyA, in bodyA's frame
	linearOffset:     [2]f32,
	// The bodyB angle minus bodyA angle in radians
	angularOffset:    f32,
	// The maximum motor force in newtons
	maxForce:         f32,
	// The maximum motor torque in newton-meters
	maxTorque:        f32,
	// Position correction factor in the range [0,1]
	correctionFactor: f32,
	// Set this flag to true if the attached bodies should collide
	collideConnected: bool,
	// User data pointer
	userData:         rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

MouseJointDef :: struct {
	// The first attached body. This is assumed to be static.
	bodyIdA:          BodyId,
	// The second attached body.
	bodyIdB:          BodyId,
	// The initial target point in world space
	target:           [2]f32,
	// Stiffness in hertz
	hertz:            f32,
	// Damping ratio, non-dimensional
	dampingRatio:     f32,
	// Maximum force, typically in newtons
	maxForce:         f32,
	// Set this flag to true if the attached bodies should collide.
	collideConnected: bool,
	// User data pointer
	userData:         rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

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

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

PlaneResult :: struct {
	// The collision plane between the mover and convex shape
	plane: Plane,
	// The collision point on the shape.
	point: [2]f32,
	// Did the collision register a hit? If not this plane should be ignored.
	hit:   bool,
}

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

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

Polygon :: struct {
	// The polygon vertices
	vertices: [8][2]f32 `fmt:"v,count"`,
	// The outward normal vectors of the polygon sides
	normals:  [8][2]f32 `fmt:"v,count"`,
	// The centroid of the polygon
	centroid: [2]f32,
	// The external radius for rounded polygons
	radius:   f32,
	// The number of polygon vertices
	count:    i32,
}

PreSolveFcn :: proc "c" (shapeIdA, shapeIdB: ShapeId, manifold: ^Manifold, ctx: rawptr) -> bool

PrismaticJointDef :: struct {
	// The first attached body
	bodyIdA:           BodyId,
	// The second attached body
	bodyIdB:           BodyId,
	// The local anchor point relative to bodyA's origin
	localAnchorA:      [2]f32,
	// The local anchor point relative to bodyB's origin
	localAnchorB:      [2]f32,
	// The local translation unit axis in bodyA
	localAxisA:        [2]f32,
	// The constrained angle between the bodies: bodyB_angle - bodyA_angle
	referenceAngle:    f32,
	// The target translation for the joint in meters. The spring-damper will drive
	// to this translation.
	targetTranslation: f32,
	// 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,
	// 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,
	// Set this flag to true if the attached bodies should collide
	collideConnected:  bool,
	// User data pointer
	userData:          rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:     i32,
}

Profile :: struct {
	step:                f32,
	pairs:               f32,
	collide:             f32,
	solve:               f32,
	mergeIslands:        f32,
	prepareStages:       f32,
	solveConstraints:    f32,
	prepareConstraints:  f32,
	integrateVelocities: f32,
	warmStart:           f32,
	solveImpulses:       f32,
	integratePositions:  f32,
	relaxImpulses:       f32,
	applyRestitution:    f32,
	storeImpulses:       f32,
	splitIslands:        f32,
	transforms:          f32,
	hitEvents:           f32,
	refit:               f32,
	bullets:             f32,
	sleepIslands:        f32,
	sensors:             f32,
}

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,
}

RayCastInput :: struct {
	// Start point of the ray cast
	origin:      [2]f32,
	// Translation of the ray cast
	translation: [2]f32,
	// The maximum fraction of the translation to consider, typically 1
	maxFraction: f32,
}

RayResult :: struct {
	shapeId:    ShapeId,
	point:      [2]f32,
	normal:     [2]f32,
	fraction:   f32,
	nodeVisits: i32,
	leafVisits: i32,
	hit:        bool,
}

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

RevoluteJointDef :: struct {
	// The first attached body
	bodyIdA:          BodyId,
	// The second attached body
	bodyIdB:          BodyId,
	// The local anchor point relative to bodyA's origin
	localAnchorA:     [2]f32,
	// The local anchor point relative to bodyB's origin
	localAnchorB:     [2]f32,
	// The bodyB angle minus bodyA angle in the reference state (radians).
	// This defines the zero angle for the joint limit.
	referenceAngle:   f32,
	// The target angle for the joint in radians. The spring-damper will drive
	// to this angle.
	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,
	// Scale the debug draw
	drawSize:         f32,
	// Set this flag to true if the attached bodies should collide
	collideConnected: bool,
	// User data pointer
	userData:         rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

Rot :: struct {
	c: f32,
	s: f32,
}

Segment :: struct {
	// The first point
	point1: [2]f32,
	// The second point
	point2: [2]f32,
}

SegmentDistanceResult :: struct {
	// The closest point on the first segment
	closest1:        [2]f32,
	// The closest point on the second segment
	closest2:        [2]f32,
	// The barycentric coordinate on the first segment
	fraction1:       f32,
	// The barycentric coordinate on the second segment
	fraction2:       f32,
	// The squared distance between the closest points
	distanceSquared: f32,
}

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

SensorEndTouchEvent :: struct {
	// The id of the sensor shape
	sensorShapeId:  ShapeId,
	// The id of the dynamic 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,
}

ShapeCastInput :: struct {
	// A generic shape
	proxy:       ShapeProxy,
	// The translation of the shape cast
	translation: [2]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
	transformA:   Transform,
	// The world transform for shape A
	transformB:   Transform,
	// The world transform for shape B
	translationB: [2]f32,
	// The translation of shape B
	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,
	// The surface material for this shape.
	material:              SurfaceMaterial,
	// The density, usually in kg/m^2.
	// This is not part of the surface material because this is for the interior, which may have
	// other considerations, such as being hollow. For example a wood barrel may be hollow or full of water.
	density:               f32,
	// Collision filtering data.
	filter:                Filter,
	// 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 threading. 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: [8][2]f32 `fmt:"v,count"`,
	// The number of points. Must be greater than 0.
	count:  i32,
	// The external radius of the point cloud. May be zero.
	radius: f32,
}

ShapeType :: enum i32 {
	// A circle with an offset
	circleShape, 
	// A capsule is an extruded circle
	capsuleShape, 
	// A line segment
	segmentShape, 
	// A convex polygon
	polygonShape, 
	// A line segment owned by a chain shape
	chainSegmentShape, 
}

Simplex :: struct {
	v1:    SimplexVertex `fmt:"v,count"`,
	v2:    SimplexVertex `fmt:"v,count"`,
	v3:    SimplexVertex `fmt:"v,count"`,
	// vertices
	count: i32,
}

SimplexCache :: struct {
	// The number of stored simplex points
	count:  u16,
	// The cached simplex indices on shape A
	indexA: [3]u8 `fmt:"v,count"`,
	// The cached simplex indices on shape B
	indexB: [3]u8 `fmt:"v,count"`,
}

SimplexVertex :: struct {
	wA:     [2]f32,
	// support point in proxyA
	wB:     [2]f32,
	// support point in proxyB
	w:      [2]f32,
	// wB - wA
	a:      f32,
	// barycentric coordinate for closest point
	indexA: i32,
	// wA index
	indexB: i32,
}

SurfaceMaterial :: struct {
	// The Coulomb (dry) friction coefficient, usually in the range [0,1].
	friction:          f32,
	// The coefficient of restitution (bounce) usually in the range [0,1].
	// https://en.wikipedia.org/wiki/Coefficient_of_restitution
	restitution:       f32,
	// The rolling resistance usually in the range [0,1].
	rollingResistance: f32,
	// The tangent speed for conveyor belts
	tangentSpeed:      f32,
	// User material identifier. This is passed with query results and to friction and restitution
	// combining functions. It is not used internally.
	userMaterialId:    i32,
	// Custom debug draw color.
	customColor:       u32,
}

Sweep :: struct {
	localCenter: [2]f32,
	// Local center of mass position
	c1:          [2]f32,
	// Starting center of mass world position
	c2:          [2]f32,
	// Ending center of mass world position
	q1:          Rot,
	// Starting world rotation
	q2:          Rot,
}

TOIInput :: struct {
	proxyA:      ShapeProxy,
	// The proxy for shape A
	proxyB:      ShapeProxy,
	// The proxy for shape B
	sweepA:      Sweep,
	// The movement of shape A
	sweepB:      Sweep,
	// The movement of shape B
	maxFraction: f32,
}

TOIOutput :: struct {
	state:    TOIState,
	// The type of result
	fraction: f32,
}

TOIState :: enum i32 {
	Unknown, 
	Failed, 
	Overlapped, 
	Hit, 
	Separated, 
}

TaskCallback :: proc "c" (startIndex, endIndex: i32, workerIndex: u32, taskContext: rawptr)

Transform :: struct {
	p: [2]f32,
	q: Rot,
}

TreeQueryCallbackFcn :: proc "c" (proxyId: i32, userData: u64, ctx: rawptr) -> bool

TreeRayCastCallbackFcn :: proc "c" (#by_ptr input: RayCastInput, proxyId: i32, userData: u64, ctx: rawptr) -> f32

TreeShapeCastCallbackFcn :: proc "c" (#by_ptr input: ShapeCastInput, proxyId: i32, userData: u64, ctx: rawptr) -> f32

TreeStats :: struct {
	// Number of internal nodes visited during the query
	nodeVisits: i32,
	// Number of leaf nodes visited during the query
	leafVisits: i32,
}

Vec2 :: [2]f32

Version :: struct {
	major:    i32,
	// Significant changes
	minor:    i32,
	// Incremental changes
	revision: i32,
}

WeldJointDef :: struct {
	// The first attached body
	bodyIdA:             BodyId,
	// The second attached body
	bodyIdB:             BodyId,
	// The local anchor point relative to bodyA's origin
	localAnchorA:        [2]f32,
	// The local anchor point relative to bodyB's origin
	localAnchorB:        [2]f32,
	// The bodyB angle minus bodyA angle in the reference state (radians)
	referenceAngle:      f32,
	// Linear stiffness expressed as Hertz (cycles per second). Use zero for maximum stiffness.
	linearHertz:         f32,
	// Angular stiffness as Hertz (cycles per second). Use zero for maximum stiffness.
	angularHertz:        f32,
	// Linear damping ratio, non-dimensional. Use 1 for critical damping.
	linearDampingRatio:  f32,
	// Linear damping ratio, non-dimensional. Use 1 for critical damping.
	angularDampingRatio: f32,
	// Set this flag to true if the attached bodies should collide
	collideConnected:    bool,
	// User data pointer
	userData:            rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:       i32,
}

WheelJointDef :: struct {
	// The first attached body
	bodyIdA:          BodyId,
	// The second attached body
	bodyIdB:          BodyId,
	// The local anchor point relative to bodyA's origin
	localAnchorA:     [2]f32,
	// The local anchor point relative to bodyB's origin
	localAnchorB:     [2]f32,
	// The local translation unit axis in bodyA
	localAxisA:       [2]f32,
	// Enable a linear spring along the local axis
	enableSpring:     bool,
	// Spring stiffness in Hertz
	hertz:            f32,
	// Spring damping ratio, non-dimensional
	dampingRatio:     f32,
	// Enable/disable the joint linear limit
	enableLimit:      bool,
	// The lower translation limit
	lowerTranslation: f32,
	// The upper translation limit
	upperTranslation: f32,
	// Enable/disable the joint rotational motor
	enableMotor:      bool,
	// The maximum motor torque, typically in newton-meters
	maxMotorTorque:   f32,
	// The desired motor speed in radians per second
	motorSpeed:       f32,
	// Set this flag to true if the attached bodies should collide
	collideConnected: bool,
	// User data pointer
	userData:         rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

WorldDef :: struct {
	// Gravity vector. Box2D has no up-vector defined.
	gravity:              [2]f32,
	// Restitution speed threshold, usually in m/s. Collisions above this
	// speed have restitution applied (will bounce).
	restitutionThreshold: f32,
	// Threshold speed for hit events. Usually meters per second.
	hitEventThreshold:    f32,
	// Contact stiffness. Cycles per second. Increasing this increases the speed of overlap recovery, but can introduce jitter.
	contactHertz:         f32,
	// Contact bounciness. Non-dimensional. You can speed up overlap recovery by decreasing this with
	// the trade-off that overlap resolution becomes more energetic.
	contactDampingRatio:  f32,
	// This parameter controls how fast overlap is resolved and usually has units of meters per second. This only
	// puts a cap on the resolution speed. The resolution speed is increased by increasing the hertz and/or
	// decreasing the damping ratio.
	maxContactPushSpeed:  f32,
	// Maximum linear speed. Usually meters per second.
	maximumLinearSpeed:   f32,
	// Optional mixing callback for friction. The default uses sqrt(frictionA * frictionB).
	frictionCallback:     FrictionCallback,
	// Optional mixing callback for restitution. The default uses max(restitutionA, restitutionB).
	restitutionCallback:  RestitutionCallback,
	// Can bodies go to sleep to improve performance
	enableSleep:          bool,
	// Enable continuous collision
	enableContinuous:     bool,
	// Number of workers to use with the provided task system. Box2D performs best when using only
	// performance cores and accessing a single L2 cache. Efficiency cores and hyper-threading provide
	// little benefit and may even harm performance.
	// @note Box2D does not create threads. This is the number of threads your applications has created
	// that you are allocating to b2World_Step.
	// @warning Do not modify the default value unless you are also providing a task system and providing
	// task callbacks (enqueueTask and finishTask).
	workerCount:          i32,
	// Function to spawn tasks
	enqueueTask:          EnqueueTaskCallback,
	// Function to finish a task
	finishTask:           FinishTaskCallback,
	// User context that is provided to enqueueTask and finishTask
	userTaskContext:      rawptr,
	// User data
	userData:             rawptr,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:        i32,
}

WorldId :: struct {
	index1:     u16,
	generation: u16,
}

EPSILON :: math.F32_EPSILON

HASH_INIT :: 5381

MAX_POLYGON_VERTICES :: 8

Mat22_zero: matrix[2, 2]f32 : Mat22{0, 0, 0, 0}

PI :: math.PI

Rot_identity :: Rot{1, 0}

Transform_identity :: Transform{{0, 0}, {1, 0}}

Vec2_zero: [2]f32 : Vec2{0, 0}

bodyTypeCount :: len(BodyType)

emptySimplexCache :: SimplexCache{}

nullBodyId :: BodyId{}

nullChainId :: ChainId{}

nullJointId :: JointId{}

nullShapeId :: ShapeId{}

nullWorldId :: WorldId{}

shapeTypeCount :: len(ShapeType)

@(require_results)
AABB_Center :: proc "c" (a: AABB) -> [2]f32 {…}

@(require_results)
AABB_Contains :: proc "c" (a, b: AABB) -> bool {…}

@(require_results)
AABB_Extents :: proc "c" (a: AABB) -> [2]f32 {…}

@(require_results)
AABB_Overlaps :: proc "c" (a, b: AABB) -> bool {…}

@(require_results)
AABB_Union :: proc "c" (a, b: AABB) -> (c: AABB) {…}

@(require_results)
Abs :: proc "c" (a: [2]f32) -> (b: [2]f32) {…}

@(deprecated="Prefer the built-in 'abs(a)'")
@(require_results)
AbsFloat :: proc "c" (a: f32) -> f32 {…}

@(deprecated="Prefer the built-in 'abs(a)'")
@(require_results)
AbsInt :: proc "c" (a: i32) -> i32 {…}

@(deprecated="Prefer 'a + b'")
@(require_results)
Add :: proc "c" (a, b: [2]f32) -> [2]f32 {…}

@(require_results)
Atan2 :: proc "c" (y, x: f32) -> f32 {…}

Body_ApplyAngularImpulse :: proc "c" (bodyId: BodyId, impulse: f32, wake: bool) ---

Body_ApplyForce :: proc "c" (bodyId: BodyId, force: [2]f32, point: [2]f32, wake: bool) ---

Body_ApplyForceToCenter :: proc "c" (bodyId: BodyId, force: [2]f32, wake: bool) ---

Body_ApplyLinearImpulse :: proc "c" (
	bodyId:  BodyId, 
	impulse: [2]f32, 
	point:   [2]f32, 
	wake:    bool, 
) ---

Body_ApplyLinearImpulseToCenter :: proc "c" (bodyId: BodyId, impulse: [2]f32, wake: bool) ---

Body_ApplyMassFromShapes :: proc "c" (bodyId: BodyId) ---

Body_ApplyTorque :: proc "c" (bodyId: BodyId, torque: f32, wake: bool) ---

Body_ComputeAABB :: proc "c" (bodyId: BodyId) -> AABB ---

Body_Disable :: proc "c" (bodyId: BodyId) ---

Body_Enable :: proc "c" (bodyId: BodyId) ---

Body_EnableContactEvents :: proc "c" (bodyId: BodyId, flag: bool) ---

Body_EnableHitEvents :: proc "c" (bodyId: BodyId, flag: bool) ---

Body_EnableSleep :: proc "c" (bodyId: BodyId, enableSleep: bool) ---

Body_GetAngularDamping :: proc "c" (bodyId: BodyId) -> f32 ---

Body_GetAngularVelocity :: proc "c" (bodyId: BodyId) -> f32 ---

Body_GetContactCapacity :: proc "c" (bodyId: BodyId) -> i32 ---

@(require_results)
Body_GetContactData :: proc "c" (bodyId: BodyId, contactData: []ContactData) -> []ContactData {…}

Body_GetGravityScale :: proc "c" (bodyId: BodyId) -> f32 ---

Body_GetJointCount :: proc "c" (bodyId: BodyId) -> i32 ---

@(require_results)
Body_GetJoints :: proc "c" (bodyId: BodyId, jointArray: []JointId) -> []JointId {…}

Body_GetLinearDamping :: proc "c" (bodyId: BodyId) -> f32 ---

Body_GetLinearVelocity :: proc "c" (bodyId: BodyId) -> [2]f32 ---

Body_GetLocalCenterOfMass :: proc "c" (bodyId: BodyId) -> [2]f32 ---

Body_GetLocalPoint :: proc "c" (bodyId: BodyId, worldPoint: [2]f32) -> [2]f32 ---

Body_GetLocalPointVelocity :: proc "c" (bodyId: BodyId, localPoint: [2]f32) -> [2]f32 ---

Body_GetLocalVector :: proc "c" (bodyId: BodyId, worldVector: [2]f32) -> [2]f32 ---

Body_GetMass :: proc "c" (bodyId: BodyId) -> f32 ---

Body_GetMassData :: proc "c" (bodyId: BodyId) -> MassData ---

Body_GetName :: proc "c" (bodyId: BodyId) -> cstring ---

Body_GetPosition :: proc "c" (bodyId: BodyId) -> [2]f32 ---

Body_GetRotation :: proc "c" (bodyId: BodyId) -> Rot ---

Body_GetRotationalInertia :: proc "c" (bodyId: BodyId) -> f32 ---

Body_GetShapeCount :: proc "c" (bodyId: BodyId) -> i32 ---

@(require_results)
Body_GetShapes :: proc "c" (bodyId: BodyId, shapeArray: []ShapeId) -> []ShapeId {…}

Body_GetSleepThreshold :: proc "c" (bodyId: BodyId) -> f32 ---

Body_GetTransform :: proc "c" (bodyId: BodyId) -> Transform ---

Body_GetType :: proc "c" (bodyId: BodyId) -> BodyType ---

Body_GetUserData :: proc "c" (bodyId: BodyId) -> rawptr ---

Body_GetWorld :: proc "c" (bodyId: BodyId) -> WorldId ---

Body_GetWorldCenterOfMass :: proc "c" (bodyId: BodyId) -> [2]f32 ---

Body_GetWorldPoint :: proc "c" (bodyId: BodyId, localPoint: [2]f32) -> [2]f32 ---

Body_GetWorldPointVelocity :: proc "c" (bodyId: BodyId, worldPoint: [2]f32) -> [2]f32 ---

Body_GetWorldVector :: proc "c" (bodyId: BodyId, localVector: [2]f32) -> [2]f32 ---

Body_IsAwake :: proc "c" (bodyId: BodyId) -> bool ---

Body_IsBullet :: proc "c" (bodyId: BodyId) -> bool ---

Body_IsEnabled :: proc "c" (bodyId: BodyId) -> bool ---

Body_IsFixedRotation :: proc "c" (bodyId: BodyId) -> bool ---

Body_IsSleepEnabled :: proc "c" (bodyId: BodyId) -> bool ---

Body_IsValid :: proc "c" (id: BodyId) -> bool ---

Body_SetAngularDamping :: proc "c" (bodyId: BodyId, angularDamping: f32) ---

Body_SetAngularVelocity :: proc "c" (bodyId: BodyId, angularVelocity: f32) ---

Body_SetAwake :: proc "c" (bodyId: BodyId, awake: bool) ---

Body_SetBullet :: proc "c" (bodyId: BodyId, flag: bool) ---

Body_SetFixedRotation :: proc "c" (bodyId: BodyId, flag: bool) ---

Body_SetGravityScale :: proc "c" (bodyId: BodyId, gravityScale: f32) ---

Body_SetLinearDamping :: proc "c" (bodyId: BodyId, linearDamping: f32) ---

Body_SetLinearVelocity :: proc "c" (bodyId: BodyId, linearVelocity: [2]f32) ---

Body_SetMassData :: proc "c" (bodyId: BodyId, massData: MassData) ---

Body_SetName :: proc "c" (bodyId: BodyId, name: cstring) ---

Body_SetSleepThreshold :: proc "c" (bodyId: BodyId, sleepThreshold: f32) ---

Body_SetTargetTransform :: proc "c" (bodyId: BodyId, target: Transform, timeStep: f32) ---

Body_SetTransform :: proc "c" (bodyId: BodyId, position: [2]f32, rotation: Rot) ---