box2d

type B2AABB struct {
	LowerBound B2Vec2 ///< the lower vertex
	UpperBound B2Vec2 ///< the upper vertex
}

type B2Body struct {
	M_type uint8

	M_flags uint32

	M_islandIndex int

	M_xf    B2Transform // the body origin transform
	M_sweep B2Sweep     // the swept motion for CCD

	M_linearVelocity  B2Vec2
	M_angularVelocity float64

	M_force  B2Vec2
	M_torque float64

	M_world *B2World
	M_prev  *B2Body
	M_next  *B2Body

	M_fixtureList  *B2Fixture // linked list
	M_fixtureCount int

	M_jointList   *B2JointEdge   // linked list
	M_contactList *B2ContactEdge // linked list

	M_mass, M_invMass float64

	// Rotational inertia about the center of mass.
	M_I, M_invI float64

	M_linearDamping  float64
	M_angularDamping float64
	M_gravityScale   float64

	M_sleepTime float64

	M_userData interface{}
}

type B2BodyDef struct {

	/// The body type: static, kinematic, or dynamic.
	/// Note: if a dynamic body would have zero mass, the mass is set to one.
	Type uint8

	/// The world position of the body. Avoid creating bodies at the origin
	/// since this can lead to many overlapping shapes.
	Position B2Vec2

	/// The world angle of the body in radians.
	Angle float64

	/// The linear velocity of the body's origin in world co-ordinates.
	LinearVelocity B2Vec2

	/// The angular velocity of the body.
	AngularVelocity float64

	/// Linear damping is use to reduce the linear 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.
	/// Units are 1/time
	LinearDamping float64

	/// Angular damping is use 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.
	/// Units are 1/time
	AngularDamping float64

	/// Set this flag to false if this body should never fall asleep. Note that
	/// this increases CPU usage.
	AllowSleep bool

	/// Is this body initially awake or sleeping?
	Awake bool

	/// Should this body be prevented from rotating? Useful for characters.
	FixedRotation bool

	/// Is this a fast moving body that should be prevented from tunneling through
	/// other moving bodies? Note that all bodies are prevented from tunneling through
	/// kinematic and static bodies. This setting is only considered on dynamic bodies.
	/// @warning You should use this flag sparingly since it increases processing time.
	Bullet bool

	/// Does this body start out active?
	Active bool

	/// Use this to store application specific body data.
	UserData interface{}

	/// Scale the gravity applied to this body.
	GravityScale float64
}

type B2BroadPhase struct {
	M_tree B2DynamicTree

	M_proxyCount int

	M_moveBuffer   []int
	M_moveCapacity int
	M_moveCount    int

	M_pairBuffer   []B2Pair
	M_pairCapacity int
	M_pairCount    int

	M_queryProxyId int
}

type B2BroadPhaseAddPairCallback func(userDataA interface{}, userDataB interface{})

type B2BroadPhaseQueryCallback func(fixture *B2Fixture) bool

type B2ChainAndCircleContact struct {
	B2Contact
}

type B2ChainAndPolygonContact struct {
	B2Contact
}

type B2ChainShape struct {
	B2Shape

	/// The vertices. Owned by this class.
	M_vertices []B2Vec2

	/// The vertex count.
	M_count int

	M_prevVertex    B2Vec2
	M_nextVertex    B2Vec2
	M_hasPrevVertex bool
	M_hasNextVertex bool
}

type B2CircleContact struct {
	B2Contact
}

type B2CircleShape struct {
	B2Shape
	/// Position
	M_p B2Vec2
}

type B2ClipVertex struct {
	V  B2Vec2
	Id B2ContactID
}

type B2Contact struct {
	M_flags uint32

	// World pool and list pointers.
	M_prev B2ContactInterface //should be backed by a pointer
	M_next B2ContactInterface //should be backed by a pointer

	// Nodes for connecting bodies.
	M_nodeA *B2ContactEdge
	M_nodeB *B2ContactEdge

	M_fixtureA *B2Fixture
	M_fixtureB *B2Fixture

	M_indexA int
	M_indexB int

	M_manifold *B2Manifold

	M_toiCount     int
	M_toi          float64
	M_friction     float64
	M_restitution  float64
	M_tangentSpeed float64
}

type B2ContactCreateFcn func(fixtureA *B2Fixture, indexA int, fixtureB *B2Fixture, indexB int) B2ContactInterface // returned contact should be a pointer

type B2ContactDestroyFcn func(contact B2ContactInterface) // contact should be a pointer

type B2ContactEdge struct {
	Other   *B2Body            ///< provides quick access to the other body attached.
	Contact B2ContactInterface ///< the contact
	Prev    *B2ContactEdge     ///< the previous contact edge in the body's contact list
	Next    *B2ContactEdge     ///< the next contact edge in the body's contact list
}

type B2ContactFeature struct {
	IndexA uint8 ///< Feature index on shapeA
	IndexB uint8 ///< Feature index on shapeB
	TypeA  uint8 ///< The feature type on shapeA
	TypeB  uint8 ///< The feature type on shapeB
}

type B2ContactFilter struct {
}

type B2ContactFilterInterface interface {
	ShouldCollide(fixtureA *B2Fixture, fixtureB *B2Fixture) bool
}

type B2ContactID B2ContactFeature

type B2ContactImpulse struct {
	NormalImpulses  [B2_maxManifoldPoints]float64
	TangentImpulses [B2_maxManifoldPoints]float64
	Count           int
}

type B2ContactInterface interface {
	GetFlags() uint32
	SetFlags(flags uint32)

	GetPrev() B2ContactInterface
	SetPrev(prev B2ContactInterface)

	GetNext() B2ContactInterface
	SetNext(prev B2ContactInterface)

	GetNodeA() *B2ContactEdge
	SetNodeA(node *B2ContactEdge)

	GetNodeB() *B2ContactEdge
	SetNodeB(node *B2ContactEdge)

	GetFixtureA() *B2Fixture
	SetFixtureA(fixture *B2Fixture)

	GetFixtureB() *B2Fixture
	SetFixtureB(fixture *B2Fixture)

	GetChildIndexA() int
	SetChildIndexA(index int)

	GetChildIndexB() int
	SetChildIndexB(index int)

	GetManifold() *B2Manifold
	SetManifold(manifold *B2Manifold)

	GetTOICount() int
	SetTOICount(toiCount int)

	GetTOI() float64
	SetTOI(toiCount float64)

	GetFriction() float64
	SetFriction(friction float64)
	ResetFriction()

	GetRestitution() float64
	SetRestitution(restitution float64)
	ResetRestitution()

	GetTangentSpeed() float64
	SetTangentSpeed(tangentSpeed float64)

	IsTouching() bool
	IsEnabled() bool
	SetEnabled(bool)

	Evaluate(manifold *B2Manifold, xfA B2Transform, xfB B2Transform)

	FlagForFiltering()

	GetWorldManifold(worldManifold *B2WorldManifold)
}

type B2ContactListenerInterface interface {
	/// Called when two fixtures begin to touch.
	BeginContact(contact B2ContactInterface) // contact has to be backed by a pointer

	/// Called when two fixtures cease to touch.
	EndContact(contact B2ContactInterface) // contact has to be backed by a pointer

	/// This is called after a contact is updated. This allows you to inspect a
	/// contact before it goes to the solver. If you are careful, you can modify the
	/// contact manifold (e.g. disable contact).
	/// A copy of the old manifold is provided so that you can detect changes.
	/// Note: this is called only for awake bodies.
	/// Note: this is called even when the number of contact points is zero.
	/// Note: this is not called for sensors.
	/// Note: if you set the number of contact points to zero, you will not
	/// get an EndContact callback. However, you may get a BeginContact callback
	/// the next step.
	PreSolve(contact B2ContactInterface, oldManifold B2Manifold) // contact has to be backed by a pointer

	/// This lets you inspect a contact after the solver is finished. This is useful
	/// for inspecting impulses.
	/// Note: the contact manifold does not include time of impact impulses, which can be
	/// arbitrarily large if the sub-step is small. Hence the impulse is provided explicitly
	/// in a separate data structure.
	/// Note: this is only called for contacts that are touching, solid, and awake.
	PostSolve(contact B2ContactInterface, impulse *B2ContactImpulse) // contact has to be backed by a pointer
}

type B2ContactManager struct {
	M_broadPhase      B2BroadPhase
	M_contactList     B2ContactInterface
	M_contactCount    int
	M_contactFilter   B2ContactFilterInterface
	M_contactListener B2ContactListenerInterface
}

type B2ContactPositionConstraint struct {
	LocalPoints                [B2_maxManifoldPoints]B2Vec2
	LocalNormal                B2Vec2
	LocalPoint                 B2Vec2
	IndexA                     int
	IndexB                     int
	InvMassA, InvMassB         float64
	LocalCenterA, LocalCenterB B2Vec2
	InvIA, InvIB               float64
	Type                       uint8
	RadiusA, RadiusB           float64
	PointCount                 int
}

type B2ContactRegister struct {
	CreateFcn  B2ContactCreateFcn
	DestroyFcn B2ContactDestroyFcn
	Primary    bool
}

type B2ContactSolver struct {
	M_step                B2TimeStep
	M_positions           []B2Position
	M_velocities          []B2Velocity
	M_positionConstraints []B2ContactPositionConstraint
	M_velocityConstraints []B2ContactVelocityConstraint
	M_contacts            []B2ContactInterface // has to be backed by pointers
	M_count               int
}

type B2ContactSolverDef struct {
	Step       B2TimeStep
	Contacts   []B2ContactInterface // has to be backed by pointers
	Count      int
	Positions  []B2Position
	Velocities []B2Velocity
}

type B2ContactVelocityConstraint struct {
	Points             [B2_maxManifoldPoints]B2VelocityConstraintPoint
	Normal             B2Vec2
	NormalMass         B2Mat22
	K                  B2Mat22
	IndexA             int
	IndexB             int
	InvMassA, InvMassB float64
	InvIA, InvIB       float64
	Friction           float64
	Restitution        float64
	TangentSpeed       float64
	PointCount         int
	ContactIndex       int
}

type B2DestructionListenerInterface interface {
	/// Called when any fixture is about to be destroyed due
	/// to the destruction of its parent body.
	SayGoodbyeToFixture(fixture *B2Fixture)

	SayGoodbyeToJoint(joint B2JointInterface) // backed by pointer
}

type B2DistanceInput struct {
	ProxyA     B2DistanceProxy
	ProxyB     B2DistanceProxy
	TransformA B2Transform
	TransformB B2Transform
	UseRadii   bool
}

type B2DistanceJoint struct {
	*B2Joint

	M_frequencyHz  float64
	M_dampingRatio float64
	M_bias         float64

	// Solver shared
	M_localAnchorA B2Vec2
	M_localAnchorB B2Vec2
	M_gamma        float64
	M_impulse      float64
	M_length       float64

	// Solver temp
	M_indexA       int
	M_indexB       int
	M_u            B2Vec2
	M_rA           B2Vec2
	M_rB           B2Vec2
	M_localCenterA B2Vec2
	M_localCenterB B2Vec2
	M_invMassA     float64
	M_invMassB     float64
	M_invIA        float64
	M_invIB        float64
	M_mass         float64
}

type B2DistanceJointDef struct {
	B2JointDef

	/// The local anchor point relative to bodyA's origin.
	LocalAnchorA B2Vec2

	/// The local anchor point relative to bodyB's origin.
	LocalAnchorB B2Vec2

	/// The natural length between the anchor points.
	Length float64

	/// The mass-spring-damper frequency in Hertz. A value of 0
	/// disables softness.
	FrequencyHz float64

	/// The damping ratio. 0 = no damping, 1 = critical damping.
	DampingRatio float64
}

type B2DistanceOutput struct {
	PointA     B2Vec2 ///< closest point on shapeA
	PointB     B2Vec2 ///< closest point on shapeB
	Distance   float64
	Iterations int ///< number of GJK iterations used
}

type B2DistanceProxy struct {
	M_buffer   [2]B2Vec2
	M_vertices []B2Vec2 // is a memory blob using pointer arithmetic in original implementation
	M_count    int
	M_radius   float64
}

type B2DynamicTree struct {

	// Private members:
	M_root int

	M_nodes        []B2TreeNode
	M_nodeCount    int
	M_nodeCapacity int

	M_freeList int

	/// This is used to incrementally traverse the tree for re-balancing.
	M_path int

	M_insertionCount int
}

type B2EPAxis struct {
	Type       uint8
	Index      int
	Separation float64
}

type B2EPCollider struct {
	M_polygonB B2TempPolygon

	M_xf                            B2Transform
	M_centroidB                     B2Vec2
	M_v0, M_v1, M_v2, M_v3          B2Vec2
	M_normal0, M_normal1, M_normal2 B2Vec2
	M_normal                        B2Vec2
	M_type1, M_type2                uint8
	M_lowerLimit, M_upperLimit      B2Vec2
	M_radius                        float64
	M_front                         bool
}

type B2EdgeAndCircleContact struct {
	B2Contact
}

type B2EdgeAndPolygonContact struct {
	B2Contact
}

type B2EdgeShape struct {
	B2Shape
	/// These are the edge vertices
	M_vertex1, M_vertex2 B2Vec2

	/// Optional adjacent vertices. These are used for smooth collision.
	M_vertex0, M_vertex3       B2Vec2
	M_hasVertex0, M_hasVertex3 bool
}

type B2Filter struct {
	/// The collision category bits. Normally you would just set one bit.
	CategoryBits uint16

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

	/// Collision groups allow a certain group of objects to never collide (negative)
	/// or always collide (positive). Zero means no collision group. Non-zero group
	/// filtering always wins against the mask bits.
	GroupIndex int16
}

type B2Fixture struct {
	M_density float64

	M_next *B2Fixture
	M_body *B2Body

	M_shape B2ShapeInterface

	M_friction    float64
	M_restitution float64

	M_proxies    []B2FixtureProxy
	M_proxyCount int

	M_filter B2Filter

	M_isSensor bool

	M_userData interface{}
}

type B2FixtureDef struct {

	/// The shape, this must be set. The shape will be cloned, so you
	/// can create the shape on the stack.
	Shape B2ShapeInterface

	/// Use this to store application specific fixture data.
	UserData interface{}

	/// The friction coefficient, usually in the range [0,1].
	Friction float64

	/// The restitution (elasticity) usually in the range [0,1].
	Restitution float64

	/// The density, usually in kg/m^2.
	Density float64

	/// A sensor shape collects contact information but never generates a collision
	/// response.
	IsSensor bool

	/// Contact filtering data.
	Filter B2Filter
}

type B2FixtureProxy struct {
	Aabb       B2AABB
	Fixture    *B2Fixture
	ChildIndex int
	ProxyId    int
}

type B2FrictionJoint struct {
	*B2Joint

	M_localAnchorA B2Vec2
	M_localAnchorB B2Vec2

	// Solver shared
	M_linearImpulse  B2Vec2
	M_angularImpulse float64
	M_maxForce       float64
	M_maxTorque      float64

	// Solver temp
	M_indexA       int
	M_indexB       int
	M_rA           B2Vec2
	M_rB           B2Vec2
	M_localCenterA B2Vec2
	M_localCenterB B2Vec2
	M_invMassA     float64
	M_invMassB     float64
	M_invIA        float64
	M_invIB        float64
	M_linearMass   B2Mat22
	M_angularMass  float64
}

type B2FrictionJointDef struct {
	B2JointDef

	/// The local anchor point relative to bodyA's origin.
	LocalAnchorA B2Vec2

	/// The local anchor point relative to bodyB's origin.
	LocalAnchorB B2Vec2

	/// The maximum friction force in N.
	MaxForce float64

	/// The maximum friction torque in N-m.
	MaxTorque float64
}

type B2GearJoint struct {
	*B2Joint

	M_joint1 B2JointInterface // backed by pointer
	M_joint2 B2JointInterface // backed by pointer

	M_typeA uint8
	M_typeB uint8

	// Body A is connected to body C
	// Body B is connected to body D
	M_bodyC *B2Body
	M_bodyD *B2Body

	// Solver shared
	M_localAnchorA B2Vec2
	M_localAnchorB B2Vec2
	M_localAnchorC B2Vec2
	M_localAnchorD B2Vec2

	M_localAxisC B2Vec2
	M_localAxisD B2Vec2

	M_referenceAngleA float64
	M_referenceAngleB float64

	M_constant float64
	M_ratio    float64

	M_impulse float64

	// Solver temp
	M_indexA, M_indexB, M_indexC, M_indexD int
	M_lcA, M_lcB, M_lcC, M_lcD             B2Vec2
	M_mA, M_mB, M_mC, M_mD                 float64
	M_iA, M_iB, M_iC, M_iD                 float64
	M_JvAC, M_JvBD                         B2Vec2
	M_JwA, M_JwB, M_JwC, M_JwD             float64
	M_mass                                 float64
}

type B2GearJointDef struct {
	B2JointDef

	/// The first revolute/prismatic joint attached to the gear joint.
	Joint1 B2JointInterface // has to be backed by pointer

	/// The second revolute/prismatic joint attached to the gear joint.
	Joint2 B2JointInterface // has to be backed by pointer

	/// The gear ratio.
	/// @see b2GearJoint for explanation.
	Ratio float64
}

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

type B2Island struct {
	M_listener B2ContactListenerInterface

	M_bodies   []*B2Body
	M_contacts []B2ContactInterface // has to be backed by pointers
	M_joints   []B2JointInterface   // has to be backed by pointers

	M_positions  []B2Position
	M_velocities []B2Velocity

	M_bodyCount    int
	M_jointCount   int
	M_contactCount int

	M_bodyCapacity    int
	M_contactCapacity int
	M_jointCapacity   int
}

type B2Jacobian struct {
	Linear   B2Vec2
	AngularA float64
	AngularB float64
}

type B2Joint struct {
	M_type             uint8
	M_prev             B2JointInterface // has to be backed by pointer
	M_next             B2JointInterface // has to be backed by pointer
	M_edgeA            *B2JointEdge
	M_edgeB            *B2JointEdge
	M_bodyA            *B2Body
	M_bodyB            *B2Body
	M_index            int
	M_islandFlag       bool
	M_collideConnected bool
	M_userData         interface{}
}