README
¶
engoBox2dSystem 
Physics, Collision, and Mouse systems for the Engo game engine that utilizes ByteArena's box2d Go port
This is a set of systems for use with the Engo game engine.
To use, make sure Engo is working first. Then you'll need the go port of box2d. Then you can run
go get github.com/Noofbiz/engoBox2dSystem
Check out the demos to see what you can do. They're currently a work in progress, so check back later for more!
Documentation
¶
Overview ¶
Package engoBox2dSystem provides a collision, physics, and mouse system for use with the engo game engine. These systems are integrated with the go port of the box2d physics engine.
Index ¶
- Constants
- Variables
- type Box2dComponent
- type Box2dFace
- type CollisionEndMessage
- type CollisionStartMessage
- type CollisionSystem
- func (c *CollisionSystem) Add(basic *ecs.BasicEntity, space *common.SpaceComponent, box *Box2dComponent)
- func (c *CollisionSystem) AddByInterface(o Collisionable)
- func (c *CollisionSystem) BeginContact(contact box2d.B2ContactInterface)
- func (c *CollisionSystem) EndContact(contact box2d.B2ContactInterface)
- func (c *CollisionSystem) New(w *ecs.World)
- func (c *CollisionSystem) PostSolve(contact box2d.B2ContactInterface, impulse *box2d.B2ContactImpulse)
- func (c *CollisionSystem) PreSolve(contact box2d.B2ContactInterface, oldManifold box2d.B2Manifold)
- func (c *CollisionSystem) Remove(basic ecs.BasicEntity)
- func (c *CollisionSystem) Update(dt float32)
- type Collisionable
- type Convert
- func (c *Convert) DegToRad(d float32) float64
- func (c *Convert) MetersToPx(m float64) float32
- func (c *Convert) PxToMeters(px float32) float64
- func (c *Convert) RadToDeg(r float64) float32
- func (c *Convert) ToBox2d2Vec(pt engo.Point) box2d.B2Vec2
- func (c *Convert) ToEngoPoint(vec box2d.B2Vec2) engo.Point
- type MouseComponent
- type MouseFace
- type MouseSystem
- func (m *MouseSystem) Add(basic *ecs.BasicEntity, mouse *MouseComponent, space *common.SpaceComponent, ...)
- func (m *MouseSystem) AddByInterface(o Mouseable)
- func (m *MouseSystem) New(w *ecs.World)
- func (m *MouseSystem) Priority() int
- func (m *MouseSystem) Remove(basic ecs.BasicEntity)
- func (m *MouseSystem) Update(dt float32)
- type Mouseable
- type PhysicsSystem
- type Physicsable
- type PostSolveMessage
- type PreSolveMessage
Constants ¶
const MouseSystemPriority = 100
MouseSystemPriority ensures the mouse system is updated before any other systems
Variables ¶
var Conv = &Convert{20}
Conv is the internal converter used by the system. Use this rather than create your own, but you can change the pixels per meter here and it'll change it for all the systems too.
var World = box2d.MakeB2World(box2d.B2Vec2{X: 0, Y: 0})
World is the box2d World used to generate bodies, test bodies for collisions, and simulate physics
Functions ¶
This section is empty.
Types ¶
type Box2dComponent ¶
Box2dComponent holds the box2d Body for use by Systems
func (*Box2dComponent) DestroyBody ¶
func (b *Box2dComponent) DestroyBody()
DestroyBody destroys the box2d body from the World this does it safely at the end of an Update, so no bodies are removed during a simulation step, which can cause a crash
func (*Box2dComponent) GetBox2dComponent ¶
func (b *Box2dComponent) GetBox2dComponent() *Box2dComponent
GetBox2dComponent gets the *Box2dComponent from anything with a one, so they can implement the interfaces and AddByInterface can work
type Box2dFace ¶
type Box2dFace interface {
GetBox2dComponent() *Box2dComponent
}
Box2dFace is an interface for the Box2dComponent
type CollisionEndMessage ¶
type CollisionEndMessage struct {
Contact box2d.B2ContactInterface
}
CollisionEndMessage is sent out for the box2d collision callback CollisionEnd
func (CollisionEndMessage) Type ¶
func (CollisionEndMessage) Type() string
Type implements the engo.Message interface
type CollisionStartMessage ¶
type CollisionStartMessage struct {
Contact box2d.B2ContactInterface
}
CollisionStartMessage is sent out for the box2d collision callback CollisionStart
func (CollisionStartMessage) Type ¶
func (CollisionStartMessage) Type() string
Type implements the engo.Message interface
type CollisionSystem ¶
type CollisionSystem struct {
// contains filtered or unexported fields
}
CollisionSystem is a system that handles the callbacks for box2d's collision system. This system does not require the physics system, but a they do need box2d bodies.
func (*CollisionSystem) Add ¶
func (c *CollisionSystem) Add(basic *ecs.BasicEntity, space *common.SpaceComponent, box *Box2dComponent)
Add adds the entity to the collision system. It also adds the body's user data to the BasicEntity's ID, which makes it easy to figure out which entities are which when comparing in the messages / callbacks
func (*CollisionSystem) AddByInterface ¶
func (c *CollisionSystem) AddByInterface(o Collisionable)
AddByInterface adds the entity to the collision system if it implements the Collisionable interface
func (*CollisionSystem) BeginContact ¶
func (c *CollisionSystem) BeginContact(contact box2d.B2ContactInterface)
BeginContact implements the B2ContactListener interface. when a BeginContact callback is made by box2d, it sends a message containing the information from the callback.
func (*CollisionSystem) EndContact ¶
func (c *CollisionSystem) EndContact(contact box2d.B2ContactInterface)
EndContact implements the B2ContactListener interface. when a EndContact callback is made by box2d, it sends a message containing the information from the callback.
func (*CollisionSystem) New ¶
func (c *CollisionSystem) New(w *ecs.World)
New sets the system to the contact listener for box2d, which allows the collision messages to be sent out.
func (*CollisionSystem) PostSolve ¶
func (c *CollisionSystem) PostSolve(contact box2d.B2ContactInterface, impulse *box2d.B2ContactImpulse)
PostSolve implements the B2ContactListener interface. this is called after the solver is finished. When it is called, a message is sent containing the information from the callback
func (*CollisionSystem) PreSolve ¶
func (c *CollisionSystem) PreSolve(contact box2d.B2ContactInterface, oldManifold box2d.B2Manifold)
PreSolve implements the B2ContactListener interface. this is called after a contact is updated but before it goes to the solver. When it is called, a message is sent containing the information from the callback
func (*CollisionSystem) Remove ¶
func (c *CollisionSystem) Remove(basic ecs.BasicEntity)
Remove removes the entity from the system
func (*CollisionSystem) Update ¶
func (c *CollisionSystem) Update(dt float32)
Update doesn't do anything, since the physics engine handles passing out the callbacks.
type Collisionable ¶
Collisionable is for the CollisionSystem's AddByInterface
type Convert ¶
type Convert struct {
// PixelsPerMeter is how many pixels in the space component are in one meter in the Box2d World
PixelsPerMeter float32
}
Convert handles conversion between the space component and the Box2d World
func (*Convert) MetersToPx ¶
MetersToPx converts from Box2d's meters to the space component's pixels
func (*Convert) PxToMeters ¶
PxToMeters converts from the space component's px to Box2d's meters
func (*Convert) ToBox2d2Vec ¶
ToBox2d2Vec converts an engo.Point into a box2d.B2Vec2
note that the units are converted, not just copying values
type MouseComponent ¶
type MouseComponent struct {
// Clicked is true whenever the Mouse was clicked over
// the entity space in this frame
Clicked bool
// Released is true whenever the left mouse button is released over the
// entity space in this frame
Released bool
// Hovered is true whenever the Mouse is hovering
// the entity space in this frame. This does not necessarily imply that
// the mouse button was pressed down in your entity space.
Hovered bool
// Dragged is true whenever the entity space was left-clicked,
// and then the mouse started moving (while holding)
Dragged bool
// RightClicked is true whenever the entity space was right-clicked
// in this frame
RightClicked bool
// RightDragged is true whenever the entity space was right-clicked,
// and then the mouse started moving (while holding)
RightDragged bool
// RightReleased is true whenever the right mouse button is released over
// the entity space in this frame. This does not necessarily imply that
// the mouse button was pressed down in your entity space.
RightReleased bool
// Enter is true whenever the Mouse entered the entity space in that frame,
// but wasn't in that space during the previous frame
Enter bool
// Leave is true whenever the Mouse was in the space on the previous frame,
// but now isn't
Leave bool
// Position of the mouse at any moment this is generally used
// in conjunction with Track = true
MouseX float32
MouseY float32
// Set manually this to true and your mouse component will track the mouse
// and your entity will always be able to receive an updated mouse
// component even if its space is not under the mouse cursor
// WARNING: you MUST know why you want to use this because it will
// have serious performance impacts if you have many entities with
// a MouseComponent in tracking mode.
// This is ideally used for a really small number of entities
// that must really be aware of the mouse details event when the
// mouse is not hovering them
Track bool
// Modifier is used to store the eventual modifiers that were pressed during
// the same time the different click events occurred
Modifier engo.Modifier
// IsHUDShader is used to update the mouse component properly for the common.HUDShader
IsHUDShader bool
// contains filtered or unexported fields
}
MouseComponent is the location for the MouseSystem to store its results; to be used / viewed by other Systems
func (*MouseComponent) GetMouseComponent ¶
func (m *MouseComponent) GetMouseComponent() *MouseComponent
GetMouseComponent gets the *MouseComponent
type MouseFace ¶
type MouseFace interface {
GetMouseComponent() *MouseComponent
}
MouseFace is an interface for the MouseComponent
type MouseSystem ¶
type MouseSystem struct {
// contains filtered or unexported fields
}
MouseSystem listens for mouse events and changes value for MouseComponent accordingly
func (*MouseSystem) Add ¶
func (m *MouseSystem) Add(basic *ecs.BasicEntity, mouse *MouseComponent, space *common.SpaceComponent, render *common.RenderComponent, box *Box2dComponent)
Add adds a new entity to the MouseSystem
func (*MouseSystem) AddByInterface ¶
func (m *MouseSystem) AddByInterface(o Mouseable)
AddByInterface adds the entity that implements the Mouseable interface to the MouseSystem
func (*MouseSystem) New ¶
func (m *MouseSystem) New(w *ecs.World)
New adds world and camera to the MouseSystem
func (*MouseSystem) Priority ¶
func (m *MouseSystem) Priority() int
Priority implements prioritizer interface
func (*MouseSystem) Remove ¶
func (m *MouseSystem) Remove(basic ecs.BasicEntity)
Remove removes an entity from the MouseSystem
func (*MouseSystem) Update ¶
func (m *MouseSystem) Update(dt float32)
Update updates the MouseComponent based on location of cursor and state of the mouse buttons
type Mouseable ¶
type Mouseable interface {
common.BasicFace
MouseFace
common.SpaceFace
common.RenderFace
Box2dFace
}
Mouseable is for he MouseSystem's AddByInterface
type PhysicsSystem ¶
type PhysicsSystem struct {
VelocityIterations, PositionIterations int
// contains filtered or unexported fields
}
PhysicsSystem provides a system that allows entites to follow the box2d physics engine calculations.
func (*PhysicsSystem) Add ¶
func (b *PhysicsSystem) Add(basic *ecs.BasicEntity, space *common.SpaceComponent, box *Box2dComponent)
Add adds the entity to the physics system An entity needs a github.com/EngoEngine/ecs.BasicEntity, github.com/EngoEngine/engo/common.SpaceComponent, and a Box2dComponent in order to be added to the system
func (*PhysicsSystem) AddByInterface ¶
func (b *PhysicsSystem) AddByInterface(o Physicsable)
AddByInterface adds an entity to the Physics system
func (*PhysicsSystem) Remove ¶
func (b *PhysicsSystem) Remove(basic ecs.BasicEntity)
Remove removes the entity from the physics system.
func (*PhysicsSystem) Update ¶
func (b *PhysicsSystem) Update(dt float32)
Update runs every time the systems update. Updates the box2d world and simulates physics based on the timestep, positions, and forces on the bodies.
type Physicsable ¶
Physicsable is for the PhysicsSystem's AddByInterface
type PostSolveMessage ¶
type PostSolveMessage struct {
Contact box2d.B2ContactInterface
Impulse *box2d.B2ContactImpulse
}
PostSolveMessage is sent out after a step of the physics engine
func (PostSolveMessage) Type ¶
func (PostSolveMessage) Type() string
Type implements the engo.Message interface
type PreSolveMessage ¶
type PreSolveMessage struct {
Contact box2d.B2ContactInterface
OldManifold box2d.B2Manifold
}
PreSolveMessage is sent out before a step of the physics engine
func (PreSolveMessage) Type ¶
func (PreSolveMessage) Type() string
Type implements the engo.Message interface
Source Files
Directories