package vendor:box2d

Source

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

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

AssertCallbackFcn :: proc "c" (condition: cstring, fileName: cstring, lineNumber: 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 floating.
	linearDamping:          f32,
	// Angular damping is used to reduce the angular velocity. The damping parameter can be larger
	// than 1.0f but the damping effect becomes sensitive to the time step when the damping
	// parameter is large. Angular damping can be used to slow down rotating bodies.
	angularDamping:         f32,
	// Scale the gravity applied to this body. Non-dimensional.
	gravityScale:           f32,
	// Sleep speed threshold, default is 0.05 meters per second
	sleepThreshold:         f32,
	// Continuous collision safety factor. The solver only uses continuous collision if there is a
	// risk of tunneling. If the body is moving fast enough to risk tunneling then it is considered
	// a "fast body". This improves performance and prevents movement hitches. If a body moving N
	// meters risks tunneling, then the body will be considered fast if it moves more than a
	// safetyFactor times N meters over one full time step. Non-dimensional. Recommended range
	// [0.01, 0.5]. Default is 0.5 for high performance with low tunneling risk.
	safetyFactor:           f32,
	// Optional body name for debugging. Up to B2_NAME_LENGTH characters
	name:                   cstring,
	// Use this to store application specific body data.
	userData:               rawptr,
	// Motion locks to restrict linear and angular movement. Caution: may lead to softer
	// constraints along the locked direction
	motionLocks:            MotionLocks,
	// Set this flag to false if this body should never fall asleep.
	enableSleep:            bool,
	// Is this body initially awake or sleeping?
	isAwake:                bool,
	// Treat this dynamic body as a high speed object that performs continuous collision detection
	// against dynamic and kinematic bodies, but not other bullet bodies.
	// @warning Bullets should be used sparingly. They are not a solution for general
	// dynamic-versus-dynamic continuous collision. They do not guarantee accurate collision if
	// both bodies are fast moving because the bullet does a continuous check after all non-bullet
	// bodies have moved. You could get unlucky and have the bullet body end a time step very close
	// to a non-bullet body and the non-bullet body then moves over the bullet body. In continuous
	// collision, initial overlap is ignored to avoid freezing bodies in place. I do not recommend
	// using them for game projectiles if precise collision timing is needed. Instead consider
	// using a ray or shape cast. You can use a marching ray or shape cast for a projectile that
	// moves over time. If you want a fast moving projectile to collide with a fast moving target,
	// you need to consider the relative movement in your ray or shape cast. This is out of the
	// scope of Box2D. So what are good use cases for bullets? Pinball games or games with dynamic
	// containers that hold other objects. It should be a use case where it doesn't break the game
	// if there is a collision missed, but having them captured improves the quality of the game.
	isBullet:               bool,
	// Used to disable a body. A disabled body does not move or collide.
	isEnabled:              bool,
	// This allows this body to bypass rotational speed limits. Should only be used for circular
	// objects, like wheels.
	allowFastRotation:      bool,
	// Enable contact recycling. True by default. Leaving this enabled improves performance but may
	// lead to ghost collisions that should be avoided on characters.
	enableContactRecycling: bool,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:          i32,
}

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

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

BodyMoveEvent :: struct {
	// The body user data.
	userData:   rawptr,
	// The world transform of the body.
	transform:  Transform,
	// The id of the body that moved.
	bodyId:     BodyId,
	// Did the body fall asleep this time step?
	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, 
	// number of body types
	bodyTypeCount, 
}

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

Capacity :: struct {
	// Number of expected static shapes.
	staticShapeCount:  i32,
	// Number of expected dynamic and kinematic shapes.
	dynamicShapeCount: i32,
	// Number of expected static bodies.
	staticBodyCount:   i32,
	// Number of expected dynamic and kinematic bodies.
	dynamicBodyCount:  i32,
	// Number of expected contacts.
	contactCount:      i32,
	// Reserve arena allocator space, used for temporary allocations.
	arenaByteCount:    i32,
}

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

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

ChainDef :: struct {
	// Use this to store application specific shape data.
	userData:           rawptr,
	// Array of chain points. Each consecutive pair forms a segment. For a loop the last and first
	// point form a segment. Cloned.
	points:             [^][2]f32 `fmt:"v,pointCount"`,
	// The point count. At least 2 for an open chain and at least 3 for a loop.
	// segmentCount = isLoop ? pointCount : pointCount - 1
	pointCount:         i32,
	// Leading ghost point for an open chain. Distance from first point must be greater than
	// B2_LINEAR_SLOP. Ignored for loops.
	ghost1:             [2]f32,
	// Ending ghost point for an open chain. Distance from last point must be greater than
	// B2_LINEAR_SLOP. Ignored for loops.
	ghost2:             [2]f32,
	// One material for the whole chain or one for each segment. Cloned.
	materials:          [^]SurfaceMaterial `fmt:"v,materialCount"`,
	// The material count. Must be 1 or the segment count.
	materialCount:      i32,
	// Contact filtering data.
	filter:             Filter,
	// Indicates a closed chain formed by connecting the first and last point.
	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 transient contact id. This contact may be destroyed automatically when the world is
	// modified or simulated. Use b2Contact_IsValid before using this id.
	contactId: ContactId,
}

ContactData :: struct {
	// The contact id. You may hold onto this to track a contact across time steps. This id may
	// become orphaned. Use b2Contact_IsValid before using it for other functions.
	contactId: ContactId,
	// The first shape id.
	shapeIdA:  ShapeId,
	// The second shape id.
	shapeIdB:  ShapeId,
	// The manifold copied from the contact.
	manifold:  Manifold,
}

ContactEndTouchEvent :: struct {
	// Id of the first shape
	shapeIdA:  ShapeId,
	// Id of the second shape
	shapeIdB:  ShapeId,
	// The transient contact id. This contact may be destroyed automatically when the world is
	// modified or simulated. Use b2Contact_IsValid before using this id.
	contactId: ContactId,
}

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

ContactHitEvent :: struct {
	// Id of the first shape
	shapeIdA:      ShapeId,
	// Id of the second shape
	shapeIdB:      ShapeId,
	// Id of the contact.
	// @warning this contact may have been destroyed
	// @see b2Contact_IsValid
	contactId:     ContactId,
	// Point where the shapes hit. This is a mid-point between the two surfaces. It could be a
	// speculative point where the shapes were not touching at the beginning of the time step. The
	// point is reconstructed after the step, so when both bodies are moving it may trail the
	// impact by up to one step of motion.
	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,
}

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

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

Counters :: struct {
	byteCount:            uint,
	bodyCount:            i32,
	shapeCount:           i32,
	contactCount:         i32,
	jointCount:           i32,
	islandCount:          i32,
	stackUsed:            i32,
	staticTreeHeight:     i32,
	treeHeight:           i32,
	taskCount:            i32,
	colorCounts:          [24]i32,
	// Number of contacts touched by the collide pass (graph contacts + awake-set non-touching).
	awakeContactCount:    i32,
	// Number of contacts recycled in the most recent step.
	recycledContactCount: i32,
}

CustomFilterCallbackFcn :: proc "c" (shapeIdA: ShapeId, shapeIdB: ShapeId, userContext: rawptr) -> bool

DebugDraw :: struct {
	// Draw a closed polygon provided in CCW order.
	DrawPolygonFcn:      proc "c" (transform: Transform, vertices: [^][2]f32, vertexCount: i32, color: HexColor, userContext: rawptr),
	// Draw a solid closed polygon provided in CCW order.
	DrawSolidPolygonFcn: proc "c" (transform: Transform, vertices: [^][2]f32, vertexCount: i32, radius: f32, color: HexColor, userContext: rawptr),
	// Draw a circle.
	DrawCircleFcn:       proc "c" (center: [2]f32, radius: f32, color: HexColor, userContext: rawptr),
	// Draw a solid circle.
	DrawSolidCircleFcn:  proc "c" (transform: Transform, center: [2]f32, radius: f32, color: HexColor, userContext: rawptr),
	// Draw a solid capsule.
	DrawSolidCapsuleFcn: proc "c" (p1: [2]f32, p2: [2]f32, radius: f32, color: HexColor, userContext: rawptr),
	// Draw a line segment.
	DrawLineFcn:         proc "c" (p1: [2]f32, p2: [2]f32, color: HexColor, userContext: rawptr),
	// Draw a transform. Choose your own length scale.
	DrawTransformFcn:    proc "c" (transform: Transform, userContext: rawptr),
	// Draw a point.
	DrawPointFcn:        proc "c" (p: [2]f32, size: f32, color: HexColor, userContext: rawptr),
	// Draw a string in world space.
	DrawStringFcn:       proc "c" (p: [2]f32, s: cstring, color: HexColor, userContext: rawptr),
	// Draw a bounding box.
	DrawBoundsFcn:       proc "c" (aabb: AABB, color: HexColor, userContext: rawptr),
	// World bounds used for debug draw. An empty box draws nothing.
	drawingBounds:       AABB,
	// Scale to use when drawing forces
	forceScale:          f32,
	// Global scaling for joint drawing
	jointScale:          f32,
	// Option to draw contact points
	drawContacts:        bool,
	// Draw anchor A for contact points (instead of anchorB)
	drawAnchorA:         bool,
	// Option to draw shapes
	drawShapes:          bool,
	// Option to draw chain shape normals
	drawChainNormals:    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 visualize the graph coloring used for contacts and joints
	drawGraphColors:     bool,
	// Option to draw contact feature ids
	drawContactFeatures: bool,
	// Option to draw contact normals
	drawContactNormals:  bool,
	// Option to draw contact normal forces
	drawContactForces:   bool,
	// Option to draw contact friction forces
	drawFrictionForces:  bool,
	// Option to draw islands as bounding boxes
	drawIslands:         bool,
	// User context that is passed as an argument to drawing callback functions
	userContext:         rawptr,
}

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

DistanceJointDef :: struct {
	// Base joint definition
	using base:       JointDef,
	// The rest length of this joint. Clamped to a stable minimum value.
	length:           f32,
	// Enable the distance constraint to behave like a spring. If false then the distance joint
	// will be rigid, overriding the limit and motor.
	enableSpring:     bool,
	// The lower spring force controls how much tension it can sustain.
	lowerSpringForce: f32,
	// The upper spring force controls how much compression it can sustain.
	upperSpringForce: f32,
	// The spring linear stiffness Hertz, cycles per second.
	hertz:            f32,
	// The spring linear damping ratio, non-dimensional
	dampingRatio:     f32,
	// Enable/disable the joint limit
	enableLimit:      bool,
	// Minimum length for limit. Clamped to a stable minimum value.
	minLength:        f32,
	// Maximum length for limit. 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,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

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

DynamicTree :: struct {}

EnqueueTaskCallbackFcn :: proc "c" (task: TaskCallbackFcn, 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{.cpp}
	// enum MyCategories
	// {
	//    Static  = 0x00000001,
	//    Dynamic = 0x00000002,
	//    Debris  = 0x00000004,
	//    Player  = 0x00000008,
	//    // etc
	// };
	// @endcode
	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{.c}
	// maskBits = Static | Player;
	// @endcode
	maskBits:     u64,
	// Collision groups allow a certain group of objects to never collide (negative) or always
	// collide (positive). A group index of zero has no effect. Non-zero group filtering always
	// wins against the mask bits. For example, you may want ragdolls to collide with other
	// ragdolls but you don't want ragdoll self-collision. In this case you would give each ragdoll
	// a unique negative group index and apply that group index to all shapes on the ragdoll.
	groupIndex:   i32,
}

FilterJointDef :: struct {
	// Base joint definition
	using base:    JointDef,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue: i32,
}

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

FreeCallbackFcn :: proc "c" (mem: rawptr, size: uint)

FrictionCallbackFcn :: proc "c" (frictionA: f32, userMaterialIdA: u64, frictionB: f32, userMaterialIdB: u64) -> 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,
}

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

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

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

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

JointType :: enum i32 {
	// constrain the distance between two points
	distanceJoint, 
	// filter collision between two bodies
	filterJoint, 
	// fully control the movement of a body
	motorJoint, 
	// control the movement of the dynamic character mover
	moverJoint, 
	// ground interaction for the dynamic character mover
	pogoJoint, 
	// slide along an axis
	prismaticJoint, 
	// rotate around a pivot
	revoluteJoint, 
	// bring two bodies together with some flex
	weldJoint, 
	// wheel spins with shock absorber
	wheelJoint, 
}

LocalManifold :: struct {
	// The unit normal vector in frame A, points from shape A to shape B
	normal:     [2]f32,
	// The manifold points, up to two are possible in 2D
	points:     [2]LocalManifoldPoint `fmt:"v,pointCount"`,
	// The number of contact points, will be 0, 1, or 2
	pointCount: i32,
}

LocalManifoldPoint :: struct {
	// Contact point in frame A
	point:      [2]f32,
	// The separation of the contact point, negative if penetrating. May be positive or negative.
	separation: f32,
	// Uniquely identifies a contact point between two shapes
	id:         u16,
}

LogCallbackFcn :: proc "c" (message: cstring)

Manifold :: struct {
	// The unit normal vector in world space, points from shape A to shape B.
	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 `fmt:"v,pointCount"`,
	// The number of contact points, will be 0, 1, or 2.
	pointCount:     i32,
}

ManifoldPoint :: struct {
	// Location of the contact point relative to bodyA's center of mass in world space. This can be
	// converted to a world point using:
	// b2Pos worldPointA = b2OffsetPos(b2Body_GetWorldCenter(myBodyIdA), anchorA);
	anchorA:            [2]f32,
	// Similar for body B.
	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 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. This includes
	// the warm starting impulse, the sub-step delta impulse, and the restitution impulse.
	totalNormalImpulse: f32,
	// Relative normal velocity pre-solve. Negative when approaching. This is only computed if hit
	// events are enabled. It may be computed otherwise as a side effect of SIMD bundling, but that
	// is not guaranteed.
	normalVelocity:     f32,
	// Cached separation used for contact recycling
	baseSeparation:     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 shape center.
	rotationalInertia: f32,
}

Mat22 :: matrix[2, 2]f32

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

MotorJointDef :: struct {
	// Base joint definition
	using base:          JointDef,
	// The desired linear velocity
	linearVelocity:      [2]f32,
	// The maximum motor force in newtons
	maxVelocityForce:    f32,
	// The desired angular velocity
	angularVelocity:     f32,
	// The maximum motor torque in newton-meters
	maxVelocityTorque:   f32,
	// Linear spring hertz for position control
	linearHertz:         f32,
	// Linear spring damping ratio
	linearDampingRatio:  f32,
	// Maximum spring force in newtons
	maxSpringForce:      f32,
	// Angular spring hertz for position control
	angularHertz:        f32,
	// Angular spring damping ratio
	angularDampingRatio: f32,
	// Maximum spring torque in newton-meters
	maxSpringTorque:     f32,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:       i32,
}

MoverJointDef :: struct {
	// Base joint definition
	using base:       JointDef,
	// The desired linear velocity
	linearVelocity:   [2]f32,
	// The maximum motor force in newtons.
	maxVelocityForce: [2]f32,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

OverlapResultCallbackFcn :: proc "c" (shapeId: ShapeId, userContext: rawptr) -> bool

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

PlaneResult :: struct {
	// The collision plane between the mover and a 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,
}

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

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

PogoJointDef :: struct {
	// Base joint definition
	using base:          JointDef,
	// Normal vector at the contact
	normal:              [2]f32,
	// The spring stiffness Hertz, cycles per second
	hertz:               f32,
	// The spring damping ratio, non-dimensional
	dampingRatio:        f32,
	// Spring length.
	restLength:          f32,
	// Maximum tension force. Controls how sticky the mover is to ground.
	maxTensionForce:     f32,
	// Maximum compression force. How hard the pogo pushes the mover up from the ground.
	maxCompressionForce: f32,
	// The initial pogo internal impulse. The pogo is typically recreated every frame. This gives a
	// way to move the internal state forward for smoother spring behavior.
	impulse:             f32,
	// The initial pogo internal velocity. The pogo is typically recreated every frame. This gives
	// a way to move the internal state forward for smoother spring behavior.
	velocity:            f32,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:       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,
}

Pos :: [2]f32

PreContinuousCallbackFcn :: proc "c" (shapeIdA: ShapeId, shapeIdB: ShapeId, point: [2]f32, normal: [2]f32, userContext: rawptr) -> bool

PreSolveCallbackFcn :: proc "c" (shapeIdA: ShapeId, shapeIdB: ShapeId, manifold: ^Manifold, userContext: rawptr)

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

Profile :: struct {
	step:                f32,
	pairs:               f32,
	collide:             f32,
	solve:               f32,
	solverSetup:         f32,
	constraints:         f32,
	prepareConstraints:  f32,
	integrateVelocities: f32,
	warmStart:           f32,
	solveImpulses:       f32,
	integratePositions:  f32,
	relaxImpulses:       f32,
	restitution:         f32,
	storeImpulses:       f32,
	splitIslands:        f32,
	transforms:          f32,
	sensorHits:          f32,
	jointEvents:         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 {
	// The shape hit.
	shapeId:    ShapeId,
	// The point of contact, on the surface of the hit shape.
	point:      [2]f32,
	// The unit normal vector at the point of contact.
	normal:     [2]f32,
	// The fraction of the input ray.
	fraction:   f32,
	// The number of BVH nodes visited. Diagnostic.
	nodeVisits: i32,
	// The number of BVH leaves visited. Diagnostic.
	leafVisits: i32,
	// Did the ray hit? If false, all other data is invalid.
	hit:        bool,
}

Recording :: struct {}

Replay :: struct {}

ReplayInfo :: struct {
	// total recorded steps
	frameCount:   i32,
	// worker count used for the replay world
	workerCount:  i32,
	// dt of the recorded steps
	timeStep:     f32,
	// recorded sub-steps
	subStepCount: i32,
	// length units per meter in effect when recorded
	lengthScale:  f32,
	// accumulated world bounds over the recording, zero-extent if unavailable
	bounds:       AABB,
}

ReplayQueryHit :: struct {
	// the shape hit
	shapeId:  ShapeId,
	// the hit point on the shape surface
	point:    [2]f32,
	// the unit normal vector at the hit point
	normal:   [2]f32,
	// the query translation fraction
	fraction: f32,
}

ReplayQueryInfo :: struct {
	// the query type
	type:        ReplayQueryType,
	// the query filter
	filter:      QueryFilter,
	// overlap AABB, relative to origin
	aabb:        AABB,
	// query origin
	origin:      [2]f32,
	// ray and cast translation
	translation: [2]f32,
	// number of recorded results
	hitCount:    i32,
}

ReplayQueryType :: enum i32 {
	replayQueryOverlapAABB, 
	replayQueryOverlapShape, 
	replayQueryCastRay, 
	replayQueryCastShape, 
	replayQueryCollideMover, 
	replayQueryCastRayClosest, 
	replayQueryCastMover, 
}

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

RevoluteJointDef :: struct {
	// Base joint definition
	using base:     JointDef,
	// 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,
	// 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 shape that began touching the sensor shape
	visitorShapeId: ShapeId,
}

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

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

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 {
	// The proxy for shape A
	proxyA:       ShapeProxy,
	// The proxy for shape B
	proxyB:       ShapeProxy,
	// Transform of shape B in shape A's frame, the relative pose B in A
	transform:    Transform,
	// The translation of shape B, in A's frame
	translationB: [2]f32,
	// The fraction of the translation to consider, typically 1
	maxFraction:  f32,
	// Allows shapes with a radius to move slightly closer if already touching
	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,
	// Enable custom filtering. Only one of the two shapes needs to enable custom filtering. See
	// b2World_SetCustomFilterCallback.
	enableCustomFiltering: bool,
	// A sensor shape generates overlap events but never generates a collision response. Fast
	// moving sensors may miss overlaps. 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. Both shapes
	// involved must have this flag set to true. False by default, even for sensors.
	enableSensorEvents:    bool,
	// Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Only one
	// shape involved needs this flag set to true. Ignored for sensors. False by default.
	enableContactEvents:   bool,
	// Enable hit events for this shape. Only applies to kinematic and dynamic bodies. Only one
	// shape involved needs this flag set to true. Ignored for sensors. False by default.
	enableHitEvents:       bool,
	// Enable pre-solve contact events for this shape. Only applies to dynamic bodies. These are
	// expensive and must be carefully handled due to multithreading. Ignored for sensors.
	enablePreSolveEvents:  bool,
	// When shapes are created they will scan the environment for collision the next time step.
	// This can significantly slow down static body creation when there are many static shapes.
	// This 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.
	// Warning: if this is false, you MUST call b2Body_UpdateMassFromShapes or b2Body_SetMassData
	// before simulating the world.
	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, 
	// The number of shape types
	shapeTypeCount, 
}

Simplex :: struct {
	v1:    SimplexVertex,
	v2:    SimplexVertex,
	// vertices
	v3:    SimplexVertex,
	// number of valid 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 {
	// support point in proxyA
	wA:     [2]f32,
	// support point in proxyB
	wB:     [2]f32,
	// wB - wA
	w:      [2]f32,
	// barycentric coordinate for closest point
	a:      f32,
	// wA index
	indexA: i32,
	// wB 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:    u64,
	// Custom debug draw color.
	customColor:       u32,
}

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

TOIInput :: struct {
	// The proxy for shape A
	proxyA:      ShapeProxy,
	// The proxy for shape B
	proxyB:      ShapeProxy,
	// The movement of shape A
	sweepA:      Sweep,
	// The movement of shape B
	sweepB:      Sweep,
	// Defines the sweep interval [0, maxFraction]
	maxFraction: f32,
}

TOIOutput :: struct {
	// The type of result
	state:    TOIState,
	// The hit point
	point:    [2]f32,
	// The hit normal
	normal:   [2]f32,
	// The sweep time of the collision
	fraction: f32,
}

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

TaskCallbackFcn :: proc "c" (taskContext: rawptr)

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

TreeBoxCastCallbackFcn :: proc "c" (input: ^BoxCastInput, proxyId: i32, userData: u64, userContext: rawptr) -> f32

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

TreeRayCastCallbackFcn :: proc "c" (input: ^RayCastInput, proxyId: i32, userData: u64, userContext: 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 {
	// Significant changes
	major:    i32,
	// Incremental changes
	minor:    i32,
	// Bug fixes
	revision: i32,
}

WeldJointDef :: struct {
	// Base joint definition
	using base:          JointDef,
	// 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,
	// Angular damping ratio, non-dimensional. Use 1 for critical damping.
	angularDampingRatio: f32,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:       i32,
}

WheelJointDef :: struct {
	// Base joint definition
	using base:       JointDef,
	// 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,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:    i32,
}

WorldCastOutput :: CastOutput

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,
	// Number of iterations of the restitution solver. More iterations can lead to less box
	// spinning.
	// @see B2_MAX_RESTITUTION_ITERATIONS
	restitutionIterations:        i32,
	// Enable full contact propagation in the restitution solver. Expensive. (Experimental)
	enableRestitutionPropagation: bool,
	// 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.
	contactSpeed:                 f32,
	// Maximum linear speed. Usually meters per second.
	maximumLinearSpeed:           f32,
	// Optional mixing callback for friction. The default uses sqrt(frictionA * frictionB).
	frictionCallback:             FrictionCallbackFcn,
	// Optional mixing callback for restitution. The default uses max(restitutionA, restitutionB).
	restitutionCallback:          RestitutionCallbackFcn,
	// Can bodies go to sleep to improve performance
	enableSleep:                  bool,
	// Enable continuous collision
	enableContinuous:             bool,
	// Number of workers for multithreading. Box2D performs best when using performance cores and
	// accessing a single L3 cache (uniform memory). Efficiency cores and SMT provide little
	// benefit and may even harm performance. This is clamped to the range [1, B2_MAX_WORKERS]. If
	// task callbacks are provided then Box2D will use the user provided task system. If no task
	// callbacks are installed then Box2D will run single-threaded with a worker count of 1, or use
	// the internal scheduler with a worker count greater than 1.
	workerCount:                  i32,
	// Function to spawn tasks
	enqueueTask:                  EnqueueTaskCallbackFcn,
	// Function to finish a task
	finishTask:                   FinishTaskCallbackFcn,
	// User context that is provided to enqueueTask and finishTask
	userTaskContext:              rawptr,
	// User data
	userData:                     rawptr,
	// Optional initial capacities
	capacity:                     Capacity,
	// Used internally to detect a valid definition. DO NOT SET.
	internalValue:                i32,
}

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

WorldTransform :: Transform

AABB_MARGIN_FRACTION :: 0.125

CONTACT_RECYCLE_COS_ANGLE :: 0.98

DEFAULT_CATEGORY_BITS :: 1

DEFAULT_MASK_BITS: u64 : max(u64)

EPSILON :: math.F32_EPSILON

GRAPH_COLOR_COUNT :: 24

HASH_INIT :: 5381

MAX_POLYGON_VERTICES :: 8

MAX_RESTITUTION_ITERATIONS :: 63

MAX_ROTATION :: 0.25 * PI

MAX_TASKS :: 256

MAX_WORKERS :: 32

MAX_WORLDS :: 128