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. Typically in meters per second.
	linearVelocity:  [2]f32,
	// The initial angular velocity of the body. Radians per second.
	angularVelocity: f32,
	// Linear damping is use 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 use 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 velocity threshold, default is 0.05 meter per second
	sleepThreshold:  f32,
	// 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,
	// Automatically compute mass and related properties on this body from shapes.
	// Triggers whenever a shape is add/removed/changed. Default is true.
	automaticMass:   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,
	revision: 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,
	// The friction coefficient, usually in the range [0,1].
	friction:      f32,
	// The restitution (elasticity) usually in the range [0,1].
	restitution:   f32,
	// Contact filtering data.
	filter:        Filter,
	// Indicates a closed chain formed by connecting the first and last points
	isLoop:        bool,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue: i32,
}

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

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

ContactBeginTouchEvent :: struct {
	// Id of the first shape
	shapeIdA: ShapeId,
	// Id of the second shape
	shapeIdB: ShapeId,
}

ContactData :: struct {
	shapeIdA: ShapeId,
	shapeIdB: ShapeId,
	manifold: Manifold,
}

ContactEndTouchEvent :: struct {
	// Id of the first shape
	shapeIdA: ShapeId,
	// Id of the second shape
	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
	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,
}

Counters :: struct {
	staticBodyCount:  i32,
	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.
	DrawPolygon:          proc "c" (vertices: [^][2]f32, vertexCount: i32, color: HexColor, ctx: rawptr),
	// Draw a solid closed polygon provided in CCW order.
	DrawSolidPolygon:     proc "c" (transform: Transform, vertices: [^][2]f32, vertexCount: i32, radius: f32, colr: HexColor, ctx: rawptr),
	// Draw a circle.
	DrawCircle:           proc "c" (center: [2]f32, radius: f32, color: HexColor, ctx: rawptr),
	// Draw a solid circle.
	DrawSolidCircle:      proc "c" (transform: Transform, radius: f32, color: HexColor, ctx: rawptr),
	// Draw a capsule.
	DrawCapsule:          proc "c" (p1, p2: [2]f32, radius: f32, color: HexColor, ctx: rawptr),
	// Draw a solid capsule.
	DrawSolidCapsule:     proc "c" (p1, p2: [2]f32, radius: f32, color: HexColor, ctx: rawptr),
	// Draw a line segment.
	DrawSegment:          proc "c" (p1, p2: [2]f32, color: HexColor, ctx: rawptr),
	// Draw a transform. Choose your own length scale.
	DrawTransform:        proc "c" (transform: Transform, ctx: rawptr),
	// Draw a point.
	DrawPoint:            proc "c" (p: [2]f32, size: f32, color: HexColor, ctx: rawptr),
	// Draw a string.
	DrawString:           proc "c" (p: [2]f32, s: cstring, 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
	drawAABBs:            bool,
	// Option to draw the mass and center of mass of dynamic bodies
	drawMass:             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 friction impulses
	drawFrictionImpulses: bool,
	// User context that is passed as an argument to drawing callback functions
	userContext:          rawptr,
}

DistanceCache :: 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"`,
}

DistanceInput :: struct {
	// The proxy for shape A
	proxyA:     DistanceProxy,
	// The proxy for shape B
	proxyB:     DistanceProxy,
	// 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
	distance:     f32,
	// The final distance, zero if overlapped
	iterations:   i32,
	// Number of GJK iterations used
	simplexCount: i32,
}

DistanceProxy :: struct {
	// The point cloud
	points: [8][2]f32 `fmt:"v,count"`,
	// The number of points
	count:  i32,
	// The external radius of the point cloud
	radius: f32,
}

DynamicTree :: struct {
	// The tree nodes
	nodes:           [^]TreeNode `fmt"v,nodeCount"`,
	// 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

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 u32 {
	// 		Static  = 0x00000001,
	// 		Dynamic = 0x00000002,
	// 		Debris  = 0x00000004,
	// 		Player  = 0x00000008,
	// 		// etc
	// 	};
	// 	@endcode
	//      Or use a bit_set.
	categoryBits: u32,
	// 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 = u32(My_Categories.Static | My_Categories.Player);
	// 	@endcode
	maskBits:     u32,
	// 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,
}

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

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

HexColor :: enum i32 {
	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                 = 12500670, 
	Gray1                = 1710618, 
	Gray2                = 3355443, 
	Gray3                = 5066061, 
	Gray4                = 6710886, 
	Gray5                = 8355711, 
	Gray6                = 10066329, 
	Gray7                = 11776947, 
	Gray8                = 13421772, 
	Gray9                = 15066597, 
	Green                = 65280, 
	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, 
	LightGoldenrod       = 15654274, 
	LightGoldenrodYellow = 16448210, 
	LightGray            = 13882323, 
	LightGreen           = 9498256, 
	LightPink            = 16758465, 
	LightSalmon          = 16752762, 
	LightSeaGreen        = 2142890, 
	LightSkyBlue         = 8900346, 
	LightSlateBlue       = 8679679, 
	LightSlateGray       = 7833753, 
	LightSteelBlue       = 11584734, 
	LightYellow          = 16777184, 
	Lime                 = 65280, 
	LimeGreen            = 3329330, 
	Linen                = 16445670, 
	Magenta              = 16711935, 
	Maroon               = 11546720, 
	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, 
	NavyBlue             = 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               = 10494192, 
	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, 
	VioletRed            = 13639824, 
	Wheat                = 16113331, 
	White                = 16777215, 
	WhiteSmoke           = 16119285, 
	Yellow               = 16776960, 
	YellowGreen          = 10145074, 
	Box2DRed             = 14430514, 
	Box2DBlue            = 3190463, 
	Box2DGreen           = 9226532, 
	Box2DYellow          = 16772748, 
}

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,
	revision: u16,
}

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

Manifold :: struct {
	// The manifold points, up to two are possible in 2D
	points:     [2]ManifoldPoint,
	// The unit normal vector in world space, points from shape A to bodyB
	normal:     [2]f32,
	// 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 bodyA's origin in world space
	// 	@note When used internally to the Box2D solver, these are relative to the center of mass.
	anchorA:          [2]f32,
	// Location of the contact point relative to bodyB's origin in world space
	anchorB:          [2]f32,
	// The separation of the contact point, negative if penetrating
	separation:       f32,
	// The impulse along the manifold normal vector.
	normalImpulse:    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.
	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

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,
	// 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,
	buildIslands:        f32,
	solveConstraints:    f32,
	prepareTasks:        f32,
	solverTasks:         f32,
	prepareConstraints:  f32,
	integrateVelocities: f32,
	warmStart:           f32,
	solveVelocities:     f32,
	integratePositions:  f32,
	relaxVelocities:     f32,
	applyRestitution:    f32,
	storeImpulses:       f32,
	finalizeBodies:      f32,
	splitIslands:        f32,
	sleepIslands:        f32,
	hitEvents:           f32,
	broadphase:          f32,
	continuous:          f32,
}

QueryFilter :: struct {
	// The collision category bits of this query. Normally you would just set one bit.
	categoryBits: u32,
	// The collision mask bits. This states the shape categories that this
	// query would accept for collision.
	maskBits:     u32,
}

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,
	hit:      bool,
}

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,
	// 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
	lowerAngle:       f32,
	// The upper angle for the joint limit in 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 point cloud to cast
	points:      [8][2]f32 `fmt:"v,count"`,
	// The number of points
	count:       i32,
	// The radius around the point cloud
	radius:      f32,
	// The translation of the shape cast
	translation: [2]f32,
	// The maximum fraction of the translation to consider, typically 1
	maxFraction: f32,
}

ShapeCastPairInput :: struct {
	proxyA:       DistanceProxy,
	// The proxy for shape A
	proxyB:       DistanceProxy,
	// 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,
}

ShapeDef :: struct {
	// Use this to store application specific shape data.
	userData:             rawptr,
	// The Coulomb (dry) friction coefficient, usually in the range [0,1].
	friction:             f32,
	// The restitution (bounce) usually in the range [0,1].
	restitution:          f32,
	// The density, usually in kg/m^2.
	density:              f32,
	// Collision filtering data.
	filter:               Filter,
	// Custom debug draw color.
	customColor:          u32,
	// A sensor shape generates overlap events but never generates a collision response.
	isSensor:             bool,
	// Enable sensor events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors.
	enableSensorEvents:   bool,
	// Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors.
	enableContactEvents:  bool,
	// Enable hit events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors.
	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,
	// Normally shapes on static bodies don't invoke contact creation when they are added to the world. This overrides
	// 	that behavior and causes contact creation. This significantly slows down static body creation which can be important
	// 	when there are many static shapes.
	forceContactCreation: bool,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:        i32,
}

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

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 smooth segment owned by a chain shape
	smoothSegmentShape, 
}

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

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

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

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: DistanceProxy,
	// The proxy for shape A
	proxyB: DistanceProxy,
	// The proxy for shape B
	sweepA: Sweep,
	// The movement of shape A
	sweepB: Sweep,
	// The movement of shape B
	tMax:   f32,
}

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

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

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

Timer :: struct {
	start: i64,
}

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

TreeNode :: struct {
	// The node bounding box
	aabb:         AABB,
	// Category bits for collision filtering
	categoryBits: u32,
	// 4
	using _:      struct #raw_union {
		// The node parent index
		parent: i32,
		// The node freelist next index
		next:   i32,
	},
	// Child 1 index
	child1:       i32,
	// Child 2 index
	child2:       i32,
	// User data
	// todo could be union with child index
	userData:     i32,
	// Leaf = 0, free node = -1
	height:       i16,
	// Has the AABB been enlarged?
	enlarged:     bool,
	// Padding for clarity
	_:            [9]u8,
}

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

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

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

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 velocity threshold, usually in m/s. Collisions above this
	// speed have restitution applied (will bounce).
	restitutionThreshold:   f32,
	// This parameter controls how fast overlap is resolved and has units of meters per second
	contactPushoutVelocity: f32,
	// Threshold velocity for hit events. Usually meters per second.
	hitEventThreshold:      f32,
	// Contact stiffness. Cycles per second.
	contactHertz:           f32,
	// Contact bounciness. Non-dimensional.
	contactDampingRatio:    f32,
	// Joint stiffness. Cycles per second.
	jointHertz:             f32,
	// Joint bounciness. Non-dimensional.
	jointDampingRatio:      f32,
	// Can bodies go to sleep to improve performance
	enableSleep:            bool,
	// Enable continuous collision
	enableContinous:        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.
	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,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:          i32,
}

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

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

Rot_identity :: Rot{1, 0}

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

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

bodyTypeCount :: len(BodyType)

defaultCategoryBits :: 0x00000001

defaultMaskBits :: 0xFFFFFFFF

emptyDistanceCache :: DistanceCache{}

maxPolygonVertices :: 8

nullBodyId :: BodyId{}

nullChainId :: ChainId{}

nullJointId :: JointId{}

nullShapeId :: ShapeId{}

nullWorldId :: WorldId{}

pi :: 3.14159265359

shapeTypeCount :: len(ShapeType)

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

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

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

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

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

AbsFloat :: proc "c" (a: f32) -> f32 {…}

AbsInt :: proc "c" (a: i32) -> i32 {…}

Add :: proc "c" (a, b: [2]f32) -> [2]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_EnableHitEvents :: proc "c" (bodyId: BodyId, enableHitEvents: bool) ---

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

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

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

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

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

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

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

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

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

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_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_GetPosition :: proc "c" (bodyId: BodyId) -> [2]f32 ---

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

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

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_GetWorldCenterOfMass :: proc "c" (bodyId: BodyId) -> [2]f32 ---

Body_GetWorldPoint :: proc "c" (bodyId: BodyId, localPoint: [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_SetAutomaticMass :: proc "c" (bodyId: BodyId, automaticMass: bool) ---

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_SetSleepThreshold :: proc "c" (bodyId: BodyId, sleepVelocity: f32) ---

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

Body_SetType :: proc "c" (bodyId: BodyId, type: BodyType) ---

Body_SetUserData :: proc "c" (bodyId: BodyId, userData: rawptr) ---

Chain_IsValid :: proc "c" (id: ChainId) -> bool ---

Chain_SetFriction :: proc "c" (chainId: ChainId, friction: f32) ---

Chain_SetRestitution :: proc "c" (chainId: ChainId, restitution: f32) ---

Clamp :: proc "c" (v: [2]f32, a, b: [2]f32) -> (c: [2]f32) {…}

ClampFloat :: proc "c" (a, lower, upper: f32) -> f32 {…}

ClampInt :: proc "c" (a, lower, upper: i32) -> i32 {…}

CollideCapsuleAndCircle :: proc "c" (#by_ptr capsuleA: Capsule, xfA: Transform, #by_ptr circleB: Circle, xfB: Transform) -> Manifold ---

CollideCapsules :: proc "c" (#by_ptr capsuleA: Capsule, xfA: Transform, #by_ptr capsuleB: Capsule, xfB: Transform) -> Manifold ---

CollideCircles :: proc "c" (#by_ptr circleA: Circle, xfA: Transform, #by_ptr circleB: Circle, xfB: Transform) -> Manifold ---

CollidePolygonAndCapsule :: proc "c" (#by_ptr polygonA: Polygon, xfA: Transform, #by_ptr capsuleB: Capsule, xfB: Transform) -> Manifold ---

CollidePolygonAndCircle :: proc "c" (#by_ptr polygonA: Polygon, xfA: Transform, #by_ptr circleB: Circle, xfB: Transform) -> Manifold ---

CollidePolygons :: proc "c" (#by_ptr polygonA: Polygon, xfA: Transform, #by_ptr polygonB: Polygon, xfB: Transform) -> Manifold ---

CollideSegmentAndCapsule :: proc "c" (#by_ptr segmentA: Segment, xfA: Transform, #by_ptr capsuleB: Capsule, xfB: Transform) -> Manifold ---

CollideSegmentAndCircle :: proc "c" (#by_ptr segmentA: Segment, xfA: Transform, #by_ptr circleB: Circle, xfB: Transform) -> Manifold ---

CollideSegmentAndPolygon :: proc "c" (#by_ptr segmentA: Segment, xfA: Transform, #by_ptr polygonB: Polygon, xfB: Transform) -> Manifold ---

CollideSmoothSegmentAndCapsule :: proc "c" (#by_ptr smoothSegmentA: SmoothSegment, xfA: Transform, #by_ptr capsuleB: Capsule, xfB: Transform, cache: ^DistanceCache) -> Manifold ---

CollideSmoothSegmentAndCircle :: proc "c" (#by_ptr smoothSegmentA: SmoothSegment, xfA: Transform, #by_ptr circleB: Circle, xfB: Transform) -> Manifold ---

CollideSmoothSegmentAndPolygon :: proc "c" (#by_ptr smoothSegmentA: SmoothSegment, xfA: Transform, #by_ptr polygonB: Polygon, xfB: Transform, cache: ^DistanceCache) -> Manifold ---

ComputeAngularVelocity :: proc "c" (q1: Rot, q2: Rot, inv_h: f32) -> f32 {…}

ComputeCapsuleAABB :: proc "c" (#by_ptr shape: Capsule, transform: Transform) -> AABB ---

ComputeCapsuleMass :: proc "c" (#by_ptr shape: Capsule, density: f32) -> MassData ---

ComputeCircleAABB :: proc "c" (#by_ptr shape: Circle, transform: Transform) -> AABB ---

ComputeCircleMass :: proc "c" (#by_ptr shape: Circle, density: f32) -> MassData ---

ComputeHull :: proc "c" (points: [][2]f32) -> Hull {…}

ComputePolygonAABB :: proc "c" (#by_ptr shape: Polygon, transform: Transform) -> AABB ---

ComputePolygonMass :: proc "c" (#by_ptr shape: Polygon, density: f32) -> MassData ---

ComputeSegmentAABB :: proc "c" (#by_ptr shape: Segment, transform: Transform) -> AABB ---

CreateBody :: proc "c" (worldId: WorldId, #by_ptr def: BodyDef) -> BodyId ---

CreateCapsuleShape :: proc "c" (bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr capsule: Capsule) -> ShapeId ---

CreateChain :: proc "c" (bodyId: BodyId, #by_ptr def: ChainDef) -> ChainId ---

CreateCircleShape :: proc "c" (bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr circle: Circle) -> ShapeId ---

CreateDistanceJoint :: proc "c" (worldId: WorldId, #by_ptr def: DistanceJointDef) -> JointId ---

CreateMotorJoint :: proc "c" (worldId: WorldId, def: MotorJointDef) -> JointId ---

CreateMouseJoint :: proc "c" (worldId: WorldId, #by_ptr def: MouseJointDef) -> JointId ---

CreatePolygonShape :: proc "c" (bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr polygon: Polygon) -> ShapeId ---

CreatePrismaticJoint :: proc "c" (worldId: WorldId, #by_ptr def: PrismaticJointDef) -> JointId ---

CreateRevoluteJoint :: proc "c" (worldId: WorldId, #by_ptr def: RevoluteJointDef) -> JointId ---

CreateSegmentShape :: proc "c" (bodyId: BodyId, #by_ptr def: ShapeDef, #by_ptr segment: Segment) -> ShapeId ---

CreateTimer :: proc "c" () -> Timer ---

CreateWeldJoint :: proc "c" (worldId: WorldId, #by_ptr def: WeldJointDef) -> JointId ---

CreateWheelJoint :: proc "c" (worldId: WorldId, #by_ptr def: WheelJointDef) -> JointId ---

CreateWorld :: proc "c" (#by_ptr def: WorldDef) -> WorldId ---

Cross :: proc "c" (a, b: [2]f32) -> f32 {…}

CrossSV :: proc "c" (s: f32, v: [2]f32) -> [2]f32 {…}

CrossVS :: proc "c" (v: [2]f32, s: f32) -> [2]f32 {…}

DefaultBodyDef :: proc "c" () -> BodyDef ---

DefaultChainDef :: proc "c" () -> ChainDef ---

DefaultDistanceJointDef :: proc "c" () -> DistanceJointDef ---

DefaultFilter :: proc "c" () -> Filter ---

DefaultMotorJointDef :: proc "c" () -> MotorJointDef ---

DefaultMouseJointDef :: proc "c" () -> MouseJointDef ---

DefaultPrismaticJointDef :: proc "c" () -> PrismaticJointDef ---

DefaultQueryFilter :: proc "c" () -> QueryFilter ---

DefaultRevoluteJointDef :: proc "c" () -> RevoluteJointDef ---

DefaultShapeDef :: proc "c" () -> ShapeDef ---

DefaultWeldJointDef :: proc "c" () -> WeldJointDef ---

DefaultWheelJointDef :: proc "c" () -> WheelJointDef ---

DefaultWorldDef :: proc "c" () -> WorldDef ---

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

DestroyChain :: proc "c" (chainId: ChainId) ---

DestroyJoint :: proc "c" (jointId: JointId) ---

DestroyShape :: proc "c" (shapeId: ShapeId) ---

DestroyWorld :: proc "c" (worldId: WorldId) ---

Distance :: proc "c" (a, b: [2]f32) -> f32 {…}

DistanceJoint_EnableLimit :: proc "c" (jointId: JointId, enableLimit: bool) ---

DistanceJoint_EnableMotor :: proc "c" (jointId: JointId, enableMotor: bool) ---

DistanceJoint_EnableSpring :: proc "c" (jointId: JointId, enableSpring: bool) ---

DistanceJoint_GetCurrentLength :: proc "c" (jointId: JointId) -> f32 ---

DistanceJoint_GetDampingRatio :: proc "c" (jointId: JointId) -> f32 ---

DistanceJoint_GetHertz :: proc "c" (jointId: JointId) -> f32 ---

DistanceJoint_GetLength :: proc "c" (jointId: JointId) -> f32 ---

DistanceJoint_GetMaxLength :: proc "c" (jointId: JointId) -> f32 ---

DistanceJoint_GetMaxMotorForce :: proc "c" (jointId: JointId) -> f32 ---

DistanceJoint_GetMinLength :: proc "c" (jointId: JointId) -> f32 ---