box2d

type AABB struct {
	LowerBound, UpperBound Vec2
}

type 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 Vec2

	// The initial world rotation of the body. Use MakeRot if you have an angle.
	Rotation Rot

	// The initial linear velocity of the body's origin. Usually in meters per second.
	LinearVelocity Vec2

	// The initial angular velocity of the body. Radians per second.
	AngularVelocity float64

	// 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 float64

	// Angular damping is used to reduce the angular velocity. The damping parameter
	// can be larger than 1.0 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 float64

	// Scale the gravity applied to this body. Non-dimensional.
	GravityScale float64

	// Sleep speed threshold, default is 0.05 meters per second
	SleepThreshold float64

	// Optional body name for debugging. Up to 31 characters.
	Name string

	// Use this to store application specific body data. Deviation from
	// upstream: the C void* becomes a uint64 so the ECS wrapper can pack an
	// entity id directly.
	UserData uint64

	// Motions 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 body as a high speed object that performs continuous collision detection
	// against dynamic and kinematic bodies, but not other bullet bodies.
	//
	// Warning: bullets should be used sparingly. They are not a solution for general dynamic-versus-dynamic
	// continuous collision. They do not guarantee accurate collision if both bodies are fast moving because
	// the bullet does a continuous check after all non-bullet bodies have moved. You could get unlucky and have
	// the bullet body end a time step very close to a non-bullet body and the non-bullet body then moves over
	// the bullet body. In continuous collision, initial overlap is ignored to avoid freezing bodies in place.
	// I do not recommend using them for game projectiles if precise collision timing is needed. Instead consider
	// using a ray or shape cast. You can use a marching ray or shape cast for projectile that moves over time.
	// If you want a fast moving projectile to collide with a fast moving target, you need to consider the relative
	// movement in your ray or shape cast. This is out of the scope of 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 the 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
	// contains filtered or unexported fields
}

type BodyEvents struct {
	// Move events
	MoveEvents []BodyMoveEvent
}

type BodyID struct {
	// contains filtered or unexported fields
}

type BodyMoveEvent struct {
	// User data. Deviation from upstream: the C void* becomes a uint64 so the
	// ECS wrapper can pack an entity id directly.
	UserData   uint64
	Transform  Transform
	BodyID     BodyID
	FellAsleep bool
}

type BodyType int32

type Capsule struct {
	// Center1 is the local center of the first semicircle.
	Center1 Vec2

	// Center2 is the local center of the second semicircle.
	Center2 Vec2

	// Radius is the radius of the semicircles.
	Radius float64
}

type CastOutput struct {
	// Normal is the surface normal at the hit point.
	Normal Vec2

	// Point is the surface hit point.
	Point Vec2

	// Fraction is the fraction of the input translation at collision.
	Fraction float64

	// Iterations is the number of iterations used.
	Iterations int

	// Hit reports whether the cast hit.
	Hit bool
}

type CastResultFcn func(shapeID ShapeID, point, normal Vec2, fraction float64, ctx any) float64

type ChainDef struct {
	// Use this to store application specific shape data. Deviation from
	// upstream: the C void* becomes a uint64 so the ECS wrapper can pack an
	// entity id directly.
	UserData uint64

	// At least 4 points. These are cloned and may be temporary.
	Points []Vec2

	// Surface materials for each segment. These are cloned.
	// The length must be 1 or len(Points). This allows you to provide one
	// material for all segments or a unique material per segment. For open
	// chains, the material on the ghost segments are place holders.
	Materials []SurfaceMaterial

	// Contact filtering data.
	Filter Filter

	// Indicates a closed chain formed by connecting the first and last points
	IsLoop bool

	// Enable sensors to detect this chain. False by default.
	EnableSensorEvents bool
	// contains filtered or unexported fields
}

type ChainID struct {
	// contains filtered or unexported fields
}

type ChainSegment struct {
	// Ghost1 is the tail ghost vertex.
	Ghost1 Vec2

	// Segment is the line segment.
	Segment Segment

	// Ghost2 is the head ghost vertex.
	Ghost2 Vec2

	// ChainID is the owning chain shape index (internal usage only).
	ChainID int
}

type Circle struct {
	// Center is the local center.
	Center Vec2

	// Radius is the radius.
	Radius float64
}

type CollisionPlane struct {
	// Plane is the collision plane between the mover and some shape.
	Plane Plane

	// PushLimit caps the push applied by this plane. Setting it to a huge
	// value makes the plane as rigid as possible; lower values make the
	// collision soft. Usually in meters.
	PushLimit float64

	// Push is the push on the mover determined by SolvePlanes. Usually in
	// meters.
	Push float64

	// ClipVelocity indicates whether ClipVector should clip against this
	// plane. Should be false for soft collision.
	ClipVelocity bool
}

type ContactBeginTouchEvent struct {
	// Id of the first shape
	ShapeIDA ShapeID

	// Id of the second shape
	ShapeIDB ShapeID

	// The transient contact id. This id is valid until the world is modified
	// or simulated (upstream b2ContactId contactId).
	ContactID ContactID
}

type ContactData struct {
	// Id of the contact (upstream b2ContactId contactId).
	ContactID ContactID

	ShapeIDA ShapeID
	ShapeIDB ShapeID

	// The manifold of the contact. By convention the normal points from
	// shape A to shape B (upstream b2Manifold manifold).
	Manifold Manifold
}

type ContactDrawType int32

type ContactEndTouchEvent struct {
	// Id of the first shape.
	// Warning: this shape may have been destroyed. See Shape.IsValid.
	ShapeIDA ShapeID

	// Id of the second shape.
	// Warning: this shape may have been destroyed. See Shape.IsValid.
	ShapeIDB ShapeID

	// Id of the contact (upstream b2ContactId contactId).
	ContactID ContactID
}

type ContactEvents struct {
	// Begin touch events
	BeginEvents []ContactBeginTouchEvent

	// End touch events
	EndEvents []ContactEndTouchEvent

	// Hit events
	HitEvents []ContactHitEvent
}

type ContactHitEvent struct {
	// Id of the first shape
	ShapeIDA ShapeID

	// Id of the second shape
	ShapeIDB ShapeID

	// Id of the contact (upstream b2ContactId contactId).
	ContactID ContactID

	// Point where the shapes hit at the beginning of the time step.
	// This is a mid-point between the two surfaces. It could be at speculative
	// point where the two shapes were not touching at the beginning of the time step.
	Point Vec2

	// Normal vector pointing from shape A to shape B
	Normal Vec2

	// The speed the shapes are approaching. Always positive. Typically in meters per second.
	ApproachSpeed float64
}

type ContactID struct {
	// contains filtered or unexported fields
}

type CosSin struct {
	Cosine, Sine float64
}

type Counters struct {
	BodyCount        int
	ShapeCount       int
	ContactCount     int
	JointCount       int
	IslandCount      int
	StackUsed        int
	StaticTreeHeight int
	TreeHeight       int
	ByteCount        int
	TaskCount        int
	ColorCounts      [GraphColorCount]int
}

type CustomFilterFcn func(shapeIDA, shapeIDB ShapeID, ctx any) bool

type DebugDraw struct {
	// DrawPolygonFcn draws a closed polygon provided in CCW order.
	DrawPolygonFcn func(vertices []Vec2, color HexColor, ctx any)

	// DrawSolidPolygonFcn draws a solid closed polygon provided in CCW order.
	DrawSolidPolygonFcn func(transform Transform, vertices []Vec2, radius float64, color HexColor, ctx any)

	// DrawCircleFcn draws a circle.
	DrawCircleFcn func(center Vec2, radius float64, color HexColor, ctx any)

	// DrawSolidCircleFcn draws a solid circle.
	DrawSolidCircleFcn func(transform Transform, radius float64, color HexColor, ctx any)

	// DrawSolidCapsuleFcn draws a solid capsule.
	DrawSolidCapsuleFcn func(p1, p2 Vec2, radius float64, color HexColor, ctx any)

	// DrawLineFcn draws a line segment.
	DrawLineFcn func(p1, p2 Vec2, color HexColor, ctx any)

	// DrawTransformFcn draws a transform. Choose your own length scale.
	DrawTransformFcn func(transform Transform, ctx any)

	// DrawPointFcn draws a point.
	DrawPointFcn func(p Vec2, size float64, color HexColor, ctx any)

	// DrawStringFcn draws a string in world space.
	DrawStringFcn func(p Vec2, s string, color HexColor, ctx any)

	// World bounds to use for debug draw
	DrawingBounds AABB

	// Scale to use when drawing forces
	ForceScale float64

	// Global scaling for joint drawing
	JointScale float64

	// Option to draw contact points
	ContactDrawType ContactDrawType

	// Option to draw shapes
	DrawShapes bool

	// Option to draw joints
	DrawJoints bool

	// Option to draw additional information for joints
	DrawJointExtras bool

	// Option to draw the bounding boxes for shapes
	DrawBounds bool

	// Option to draw the mass and center of mass of dynamic bodies
	DrawMass bool

	// Option to draw body names
	DrawBodyNames bool

	// Option to 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
	Context any
}

type DistanceInput struct {
	// ProxyA is the proxy for shape A.
	ProxyA ShapeProxy

	// ProxyB is the proxy for shape B.
	ProxyB ShapeProxy

	// TransformA is the world transform for shape A.
	TransformA Transform

	// TransformB is the world transform for shape B.
	TransformB Transform

	// UseRadii selects whether the proxy radius is considered.
	UseRadii bool
}

type DistanceJointDef struct {
	// Base joint definition
	Base JointDef

	// The rest length of this joint. Clamped to a stable minimum value.
	Length float64

	// 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 float64

	// The upper spring force controls how much compression it an sustain
	UpperSpringForce float64

	// The spring linear stiffness Hertz, cycles per second
	Hertz float64

	// The spring linear damping ratio, non-dimensional
	DampingRatio float64

	// Enable/disable the joint limit
	EnableLimit bool

	// Minimum length for limit. Clamped to a stable minimum value.
	MinLength float64

	// Maximum length for limit. Must be greater than or equal to the minimum length.
	MaxLength float64

	// Enable/disable the joint motor
	EnableMotor bool

	// The maximum motor force, usually in newtons
	MaxMotorForce float64

	// The desired motor speed, usually in meters per second
	MotorSpeed float64
	// contains filtered or unexported fields
}

type DistanceOutput struct {
	// PointA is the closest point on shapeA.
	PointA Vec2

	// PointB is the closest point on shapeB.
	PointB Vec2

	// Normal is the normal vector that points from A to B. Invalid if distance
	// is zero.
	Normal Vec2

	// Distance is the final distance, zero if overlapped.
	Distance float64

	// Iterations is the number of GJK iterations used.
	Iterations int

	// SimplexCount is the number of simplexes stored in the simplex array.
	SimplexCount int
}

type DynamicTree struct {
	// contains filtered or unexported fields
}

type ExplosionDef struct {
	// Mask bits to filter shapes
	MaskBits uint64

	// The center of the explosion in world space
	Position Vec2

	// The radius of the explosion
	Radius float64

	// The falloff distance beyond the radius. Impulse is reduced to zero at this distance.
	Falloff float64

	// 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 float64
}

type Filter struct {
	// The collision category bits. Normally you would just set one bit. The category bits should
	// represent your application object types. For example:
	//
	//	const (
	//		CategoryStatic  = 0x00000001
	//		CategoryDynamic = 0x00000002
	//		CategoryDebris  = 0x00000004
	//		CategoryPlayer  = 0x00000008
	//		// etc
	//	)
	CategoryBits uint64

	// 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:
	//
	//	maskBits = CategoryStatic | CategoryPlayer
	MaskBits uint64

	// 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 int
}

type FilterJointDef struct {
	// Base joint definition
	Base JointDef
	// contains filtered or unexported fields
}

type FrictionCallback func(frictionA float64, userMaterialIDA uint64, frictionB float64, userMaterialIDB uint64) float64

type HexColor int32

type Hull struct {
	// Points are the final points of the hull.
	Points [MaxPolygonVertices]Vec2

	// Count is the number of points.
	Count int
}

type JointDef struct {
	// User data. Deviation from upstream: the C void* becomes a uint64 so the
	// ECS wrapper can pack an entity id directly.
	UserData uint64

	// 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 float64

	// Torque threshold for joint events
	TorqueThreshold float64

	// Constraint hertz (advanced feature)
	ConstraintHertz float64

	// Constraint damping ratio (advanced feature)
	ConstraintDampingRatio float64

	// Debug draw scale
	DrawScale float64

	// Set this flag to true if the attached bodies should collide
	CollideConnected bool
}

type JointEvent struct {
	// The joint id
	JointID JointID

	// The user data from the joint for convenience. Deviation from upstream:
	// the C void* becomes a uint64 so the ECS wrapper can pack an entity id
	// directly.
	UserData uint64
}

type JointEvents struct {
	// Joint events
	JointEvents []JointEvent
}

type JointID struct {
	// contains filtered or unexported fields
}

type JointType int32

type Manifold struct {
	// Normal is the unit normal vector in world space, points from shape A to
	// body B.
	Normal Vec2

	// RollingImpulse is the angular impulse applied for rolling resistance.
	// N * m * s = kg * m^2 / s.
	RollingImpulse float64

	// Points are the manifold points, up to two are possible in 2D.
	Points [2]ManifoldPoint

	// PointCount is the number of contact points, will be 0, 1, or 2.
	PointCount int
}

type ManifoldPoint struct {
	// ClipPoint is the location of the contact point in world space when first
	// clipped. Subject to precision loss at large coordinates. This point lags
	// behind when contact recycling is used. Should only be used for
	// debugging; use AnchorA and/or AnchorB for game logic.
	ClipPoint Vec2

	// AnchorA is the location of the contact point relative to shapeA's origin
	// in world space. When used internally to the Box2D solver, this is
	// relative to the body center of mass.
	AnchorA Vec2

	// AnchorB is the location of the contact point relative to shapeB's origin
	// in world space. When used internally to the Box2D solver, this is
	// relative to the body center of mass.
	AnchorB Vec2

	// Separation is the separation of the contact point, negative if
	// penetrating.
	Separation float64

	// BaseSeparation is the cached separation used for contact recycling.
	BaseSeparation float64

	// NormalImpulse is the impulse along the manifold normal vector.
	NormalImpulse float64

	// TangentImpulse is the friction impulse.
	TangentImpulse float64

	// TotalNormalImpulse is 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 float64

	// NormalVelocity is the 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 float64

	// ID uniquely identifies a contact point between two shapes.
	ID uint16

	// Persisted reports whether this contact point existed the previous step.
	Persisted bool
}

type MassData struct {
	// Mass is the mass of the shape, usually in kilograms.
	Mass float64

	// Center is the position of the shape's centroid relative to the shape's
	// origin.
	Center Vec2

	// RotationalInertia is the rotational inertia of the shape about the shape
	// center.
	RotationalInertia float64
}

type Mat22 struct {
	CX, CY Vec2
}

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

type MotorJointDef struct {
	// Base joint definition
	Base JointDef

	// The desired linear velocity
	LinearVelocity Vec2

	// The maximum motor force in newtons
	MaxVelocityForce float64

	// The desired angular velocity
	AngularVelocity float64

	// The maximum motor torque in newton-meters
	MaxVelocityTorque float64

	// Linear spring hertz for position control
	LinearHertz float64

	// Linear spring damping ratio
	LinearDampingRatio float64

	// Maximum spring force in newtons
	MaxSpringForce float64

	// Angular spring hertz for position control
	AngularHertz float64

	// Angular spring damping ratio
	AngularDampingRatio float64

	// Maximum spring torque in newton-meters
	MaxSpringTorque float64
	// contains filtered or unexported fields
}

type OverlapResultFcn func(shapeID ShapeID, ctx any) bool

type Plane struct {
	Normal Vec2
	Offset float64
}

type PlaneResult struct {
	// Plane is the collision plane between the mover and a convex shape.
	Plane Plane

	// Point is the collision point on the shape.
	Point Vec2

	// Hit reports whether the collision registered a hit. If not, this plane
	// should be ignored.
	Hit bool
}

type PlaneResultFcn func(shapeID ShapeID, plane *PlaneResult, ctx any) bool

type PlaneSolverResult struct {
	// Translation is the translation of the mover.
	Translation Vec2

	// IterationCount is the number of iterations used by the plane solver.
	// For diagnostics.
	IterationCount int
}

type Polygon struct {
	// Vertices are the polygon vertices.
	Vertices [MaxPolygonVertices]Vec2

	// Normals are the outward normal vectors of the polygon sides.
	Normals [MaxPolygonVertices]Vec2

	// Centroid is the centroid of the polygon.
	Centroid Vec2

	// Radius is the external radius for rounded polygons.
	Radius float64

	// Count is the number of polygon vertices.
	Count int
}

type PreSolveFcn func(shapeIDA, shapeIDB ShapeID, point, normal Vec2, ctx any) bool

type PrismaticJointDef struct {
	// Base joint definition
	Base JointDef

	// Enable a linear spring along the prismatic joint axis
	EnableSpring bool

	// The spring stiffness Hertz, cycles per second
	Hertz float64

	// The spring damping ratio, non-dimensional
	DampingRatio float64

	// The target translation for the joint in meters. The spring-damper will drive
	// to this translation.
	TargetTranslation float64

	// Enable/disable the joint limit
	EnableLimit bool

	// The lower translation limit
	LowerTranslation float64

	// The upper translation limit
	UpperTranslation float64

	// Enable/disable the joint motor
	EnableMotor bool

	// The maximum motor force, typically in newtons
	MaxMotorForce float64

	// The desired motor speed, typically in meters per second
	MotorSpeed float64
	// contains filtered or unexported fields
}

type Profile struct {
	Step                float64
	Pairs               float64
	Collide             float64
	Solve               float64
	PrepareStages       float64
	SolveConstraints    float64
	PrepareConstraints  float64
	IntegrateVelocities float64
	WarmStart           float64
	SolveImpulses       float64
	IntegratePositions  float64
	RelaxImpulses       float64
	ApplyRestitution    float64
	StoreImpulses       float64
	SplitIslands        float64
	Transforms          float64
	SensorHits          float64
	JointEvents         float64
	HitEvents           float64
	Refit               float64
	Bullets             float64
	SleepIslands        float64
	Sensors             float64
}

type QueryFilter struct {
	// The collision category bits of this query. Normally you would just set one bit.
	CategoryBits uint64

	// The collision mask bits. This states the shape categories that this
	// query would accept for collision.
	MaskBits uint64
}

type RayCastInput struct {
	// Origin is the start point of the ray cast.
	Origin Vec2

	// Translation is the translation of the ray cast.
	Translation Vec2

	// MaxFraction is the maximum fraction of the translation to consider,
	// typically 1.
	MaxFraction float64
}

type RayResult struct {
	ShapeID    ShapeID
	Point      Vec2
	Normal     Vec2
	Fraction   float64
	NodeVisits int
	LeafVisits int
	Hit        bool
}

type RestitutionCallback func(restitutionA float64, userMaterialIDA uint64, restitutionB float64, userMaterialIDB uint64) float64

type RevoluteJointDef struct {
	// Base joint definition
	Base JointDef

	// The target angle for the joint in radians. The spring-damper will drive
	// to this angle.
	TargetAngle float64

	// Enable a rotational spring on the revolute hinge axis
	EnableSpring bool

	// The spring stiffness Hertz, cycles per second
	Hertz float64

	// The spring damping ratio, non-dimensional
	DampingRatio float64

	// A flag to enable joint limits
	EnableLimit bool

	// The lower angle for the joint limit in radians. Minimum of -0.99*pi radians.
	LowerAngle float64

	// The upper angle for the joint limit in radians. Maximum of 0.99*pi radians.
	UpperAngle float64

	// A flag to enable the joint motor
	EnableMotor bool

	// The maximum motor torque, typically in newton-meters
	MaxMotorTorque float64

	// The desired motor speed in radians per second
	MotorSpeed float64
	// contains filtered or unexported fields
}

type Rot struct {
	C, S float64
}

type Segment struct {
	// Point1 is the first point.
	Point1 Vec2

	// Point2 is the second point.
	Point2 Vec2
}

type SegmentDistanceResult struct {
	// Closest1 is the closest point on the first segment.
	Closest1 Vec2

	// Closest2 is the closest point on the second segment.
	Closest2 Vec2

	// Fraction1 is the barycentric coordinate on the first segment.
	Fraction1 float64

	// Fraction2 is the barycentric coordinate on the second segment.
	Fraction2 float64

	// DistanceSquared is the squared distance between the closest points.
	DistanceSquared float64
}

type SensorBeginTouchEvent struct {
	// The id of the sensor shape
	SensorShapeID ShapeID

	// The id of the shape that began touching the sensor shape
	VisitorShapeID ShapeID
}

type SensorEndTouchEvent struct {
	// The id of the sensor shape.
	// Warning: this shape may have been destroyed. See Shape.IsValid.
	SensorShapeID ShapeID

	// The id of the shape that stopped touching the sensor shape.
	// Warning: this shape may have been destroyed. See Shape.IsValid.
	VisitorShapeID ShapeID
}

type SensorEvents struct {
	// Sensor begin touch events
	BeginEvents []SensorBeginTouchEvent

	// Sensor end touch events
	EndEvents []SensorEndTouchEvent
}

type ShapeCastInput struct {
	// Proxy is a generic shape.
	Proxy ShapeProxy

	// Translation is the translation of the shape cast.
	Translation Vec2

	// MaxFraction is the maximum fraction of the translation to consider,
	// typically 1.
	MaxFraction float64

	// CanEncroach allows the shape cast to encroach when initially touching.
	// This only works if the radius is greater than zero.
	CanEncroach bool
}

type ShapeCastPairInput struct {
	// ProxyA is the proxy for shape A.
	ProxyA ShapeProxy

	// ProxyB is the proxy for shape B.
	ProxyB ShapeProxy

	// TransformA is the world transform for shape A.
	TransformA Transform

	// TransformB is the world transform for shape B.
	TransformB Transform

	// TranslationB is the translation of shape B.
	TranslationB Vec2

	// MaxFraction is the fraction of the translation to consider, typically 1.
	MaxFraction float64

	// CanEncroach allows shapes with a radius to move slightly closer if
	// already touching.
	CanEncroach bool
}

type ShapeDef struct {
	// Use this to store application specific shape data. Deviation from
	// upstream: the C void* becomes a uint64 so the ECS wrapper can pack an
	// entity id directly.
	UserData uint64

	// 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 float64

	// Collision filtering data.
	Filter Filter

	// Enable custom filtering. Only one of the two shapes needs to enable custom filtering. See WorldDef.
	EnableCustomFiltering bool

	// A sensor shape generates overlap events but never generates a collision response.
	// Sensors do not have continuous collision. Instead, use a ray or shape cast for those scenarios.
	// Sensors still contribute to the body mass if they have non-zero density.
	//
	// Note: sensor events are disabled by default. See EnableSensorEvents.
	IsSensor bool

	// Enable sensor events for this shape. This applies to sensors and non-sensors. 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 is flag is ignored for dynamic and kinematic shapes which always invoke contact creation.
	InvokeContactCreation bool

	// Should the body update the mass properties when this shape is created. Default is true.
	// Set this to false to skip the recomputation while adding many shapes to one body; the
	// body is then left with stale mass data, so call World.ApplyBodyMassFromShapes for it
	// before simulating.
	UpdateBodyMass bool
	// contains filtered or unexported fields
}

type ShapeID struct {
	// contains filtered or unexported fields
}

type ShapeProxy struct {
	// Points is the point cloud.
	Points [MaxPolygonVertices]Vec2

	// Count is the number of points. Must be greater than 0.
	Count int

	// Radius is the external radius of the point cloud. May be zero.
	Radius float64
}

type ShapeType int32

type Simplex struct {
	// V1, V2, V3 are the vertices.
	V1, V2, V3 SimplexVertex

	// Count is the number of valid vertices.
	Count int
}

type SimplexCache struct {
	// Count is the number of stored simplex points.
	Count uint16

	// IndexA holds the cached simplex indices on shape A.
	IndexA [3]uint8

	// IndexB holds the cached simplex indices on shape B.
	IndexB [3]uint8
}

type SimplexVertex struct {
	// WA is the support point in proxyA.
	WA Vec2

	// WB is the support point in proxyB.
	WB Vec2

	// W is wA - wB.
	W Vec2

	// A is the barycentric coordinate for the closest point.
	A float64

	// IndexA is the wA index.
	IndexA int

	// IndexB is the wB index.
	IndexB int
}

type SurfaceMaterial struct {
	// The Coulomb (dry) friction coefficient, usually in the range [0,1].
	Friction float64

	// The coefficient of restitution (bounce) usually in the range [0,1].
	// https://en.wikipedia.org/wiki/Coefficient_of_restitution
	Restitution float64

	// The rolling resistance usually in the range [0,1].
	RollingResistance float64

	// The tangent speed for conveyor belts
	TangentSpeed float64

	// User material identifier. This is passed with query results and to friction and restitution
	// combining functions. It is not used internally.
	UserMaterialID uint64

	// Custom debug draw color.
	CustomColor uint32
}

type Sweep struct {
	// LocalCenter is the local center of mass position.
	LocalCenter Vec2

	// C1 is the starting center of mass world position.
	C1 Vec2

	// C2 is the ending center of mass world position.
	C2 Vec2

	// Q1 is the starting world rotation.
	Q1 Rot

	// Q2 is the ending world rotation.
	Q2 Rot
}

type TOIInput struct {
	// ProxyA is the proxy for shape A.
	ProxyA ShapeProxy

	// ProxyB is the proxy for shape B.
	ProxyB ShapeProxy

	// SweepA is the movement of shape A.
	SweepA Sweep

	// SweepB is the movement of shape B.
	SweepB Sweep

	// MaxFraction defines the sweep interval [0, maxFraction].
	MaxFraction float64
}

type TOIOutput struct {
	// State is the type of result.
	State TOIState

	// Point is the hit point.
	Point Vec2

	// Normal is the hit normal.
	Normal Vec2

	// Fraction is the sweep time of the collision.
	Fraction float64
}

type TOIState int

type Transform struct {
	P Vec2
	Q Rot
}

type TreeNode struct {
	// AABB is the node bounding box.
	AABB AABB

	// CategoryBits holds the category bits for collision filtering.
	CategoryBits uint64

	// UserData is the user data of a leaf node. Upstream shares storage with
	// Child1/Child2; it is meaningless for internal nodes.
	UserData uint64

	// Child1 is the first child of an internal node (NullIndex for a leaf).
	// int32 like upstream so the node stays one 64-byte cache line (see the
	// file header).
	Child1 int32

	// Child2 is the second child of an internal node (NullIndex for a leaf).
	Child2 int32

	// Parent is the parent index of an allocated node and the free-list next
	// index of a free node. Upstream reuses this single slot for both
	// meanings (union parent/next).
	Parent int32

	// Height is the node height. Leaves have height zero.
	Height uint16

	// Flags is a bit mask of allocatedNode, enlargedNode and leafNode.
	Flags uint16
}

type TreeQueryCallbackFcn func(proxyID int, userData uint64, context any) bool

type TreeRayCastCallbackFcn func(input *RayCastInput, proxyID int, userData uint64, context any) float64

type TreeShapeCastCallbackFcn func(input *ShapeCastInput, proxyID int, userData uint64, context any) float64

type TreeStats struct {
	// NodeVisits is the number of internal nodes visited during the query.
	NodeVisits int

	// LeafVisits is the number of leaf nodes visited during the query.
	LeafVisits int
}

type Vec2 struct {
	X, Y float64
}

type Version struct {
	Major    int
	Minor    int
	Revision int
}

type WeldJointDef struct {
	// Base joint definition
	Base JointDef

	// Linear stiffness expressed as Hertz (cycles per second). Use zero for maximum stiffness.
	LinearHertz float64

	// Angular stiffness as Hertz (cycles per second). Use zero for maximum stiffness.
	AngularHertz float64

	// Linear damping ratio, non-dimensional. Use 1 for critical damping.
	LinearDampingRatio float64

	// Linear damping ratio, non-dimensional. Use 1 for critical damping.
	AngularDampingRatio float64
	// contains filtered or unexported fields
}

type WheelJointDef struct {
	// Base joint definition
	Base JointDef

	// Enable a linear spring along the local axis
	EnableSpring bool

	// Spring stiffness in Hertz
	Hertz float64

	// Spring damping ratio, non-dimensional
	DampingRatio float64

	// Enable/disable the joint linear limit
	EnableLimit bool

	// The lower translation limit
	LowerTranslation float64

	// The upper translation limit
	UpperTranslation float64

	// Enable/disable the joint rotational motor
	EnableMotor bool

	// The maximum motor torque, typically in newton-meters
	MaxMotorTorque float64

	// The desired motor speed in radians per second
	MotorSpeed float64
	// contains filtered or unexported fields
}

type World struct {
	// contains filtered or unexported fields
}