README
¶
minieng
Forked from https://github.com/EngoEngine/engo
Documentation
¶
Index ¶
- Constants
- Variables
- func CanvasHeight() float32
- func CanvasScale() float32
- func CanvasWidth() float32
- func CloseEvent()
- func CreateWindow(title string, width, height int)
- func DestroyWindow()
- func Exit()
- func RegisterScene(s Scene)
- func Run(o RunOptions, defaultScene Scene)
- func RunIteration()
- func RunPreparation(defaultScene Scene)
- func SetScene(s Scene, forceNewWorld bool)
- func SetSceneByName(name string, forceNewWorld bool) error
- func WindowHeight() float32
- func WindowWidth() float32
- type Action
- type Axis
- type AxisKeyPair
- type AxisMouse
- type AxisMouseDirection
- type AxisPair
- type BasicEntity
- type Button
- type Clock
- type Cursor
- type Exiter
- type FileLoader
- type Formats
- type GLFW
- type Hider
- type Identifier
- type IdentifierSlice
- type Initializer
- type InputManager
- type Key
- type KeyManager
- type KeyState
- type Message
- type MessageHandler
- type MessageManager
- type Modifier
- type Mouse
- type MouseButton
- type MouseState
- type Prioritizer
- type Resource
- type RunOptions
- type Scene
- type Shower
- type System
- type WindowResizeMessage
- type World
Constants ¶
const ( // AxisMax is the maximum value a joystick or keypress axis will reach AxisMax float32 = 1 // AxisNeutral is the value an axis returns if there has been to state change. AxisNeutral float32 = 0 // AxisMin is the minimum value a joystick or keypress axis will reach AxisMin float32 = -1 )
const ( // KeyStateUp is a state for when the key is not currently being pressed KeyStateUp = iota // KeyStateDown is a state for when the key is currently being pressed KeyStateDown // KeyStateJustDown is a state for when a key was just pressed KeyStateJustDown // KeyStateJustUp is a state for when a key was just released KeyStateJustUp )
Variables ¶
var ( // Input handles all input: mouse, keyboard and touch Input *InputManager // Mailbox is used by all Systems to communicate Mailbox *MessageManager // Time ... Time *Clock )
var ( // Move is an action representing mouse movement Move = Action(0) // Press is an action representing a mouse press/click Press = Action(1) // Release is an action representing a mouse a release Release = Action(2) // Neutral represents a neutral action Neutral = Action(99) // Shift represents the shift modifier. // It is triggered when the shift key is pressed simultaneously with another key Shift = Modifier(0x0001) // Control represents the control modifier // It is triggered when the ctrl key is pressed simultaneously with another key Control = Modifier(0x0002) // Alt represents the alt modifier // It is triggered when the alt key is pressed simultaneously with another key Alt = Modifier(0x0004) // Super represents the super modifier // (Windows key on Microsoft Windows, Command key on Apple OSX, and varies on Linux) // It is triggered when the super key is pressed simultaneously with another key Super = Modifier(0x0008) )
var ( // Backend ... Backend = "GLFW" // ResizeXOffset ... ResizeXOffset = float32(0) // ResizeYOffset ... ResizeYOffset = float32(0) )
var Files = &Formats{formats: make(map[string]FileLoader)}
Files manages global resource handling of registered file formats for game assets.
Functions ¶
func Exit ¶
func Exit()
Exit is the safest way to close your game, as `engo` will correctly attempt to close all windows, handlers and contexts
func RegisterScene ¶
func RegisterScene(s Scene)
RegisterScene registers the `Scene`, so it can later be used by `SetSceneByName`
func Run ¶
func Run(o RunOptions, defaultScene Scene)
Run is called to create a window, initialize everything, and start the main loop. Once this function returns, the game window has been closed already. You can supply a lot of options within `RunOptions`, and your starting `Scene` should be defined in `defaultScene`.
func RunPreparation ¶
func RunPreparation(defaultScene Scene)
RunPreparation is called automatically when calling Open. It should only be called once.
func SetScene ¶
SetScene sets the currentScene to the given Scene, and optionally forcing to create a new World that goes with it.
func SetSceneByName ¶
SetSceneByName does a lookup for the `Scene` where its `Type()` equals `name`, and then sets it as current `Scene`
Types ¶
type Axis ¶
type Axis struct {
// Name represents the name of the axis (Horizontal, Vertical)
Name string
// Pairs represents the axis pairs of this acis
Pairs []AxisPair
}
An Axis is an input which is a spectrum of values. An example of this is the horizontal movement in a game, or how far a joystick is pressed.
type AxisKeyPair ¶
An AxisKeyPair is a set of Min/Max values used for detecting whether or not a key has been pressed.
func (AxisKeyPair) Value ¶
func (keys AxisKeyPair) Value() float32
Value returns the value of a keypress.
type AxisMouse ¶
type AxisMouse struct {
// contains filtered or unexported fields
}
AxisMouse is an axis for a single x or y component of the Mouse. The value returned from it is the delta movement, since the previous call and it is not constrained by the AxisMin and AxisMax values.
func NewAxisMouse ¶
func NewAxisMouse(d AxisMouseDirection) *AxisMouse
NewAxisMouse creates a new Mouse Axis in either direction AxisMouseVert or AxisMouseHori.
type AxisMouseDirection ¶
type AxisMouseDirection uint
AxisMouseDirection is the direction (X or Y) which the mouse is being tracked for.
const ( // AxisMouseVert is vertical mouse axis AxisMouseVert AxisMouseDirection = 0 // AxisMouseHori is vertical mouse axis AxisMouseHori AxisMouseDirection = 1 )
type AxisPair ¶
type AxisPair interface {
Value() float32
}
An AxisPair is a set of Min/Max values which could possible be used by an Axis.
type BasicEntity ¶
type BasicEntity struct {
// contains filtered or unexported fields
}
A BasicEntity is simply a set of components with a unique ID attached to it, nothing more. It belongs to any amount of Systems, and has a number of Components
func NewBasic ¶
func NewBasic() BasicEntity
NewBasic creates a new Entity with a new unique identifier. It is safe for concurrent use.
func NewBasics ¶
func NewBasics(amount int) []BasicEntity
NewBasics creates an amount of new entities with a new unique identifiers. It is safe for concurrent use, and performs better than NewBasic for large numbers of entities.
func (*BasicEntity) GetBasicEntity ¶
func (e *BasicEntity) GetBasicEntity() *BasicEntity
GetBasicEntity returns a Pointer to the BasicEntity itself By having this method, All Entities containing a BasicEntity now automatically have a GetBasicEntity Method This allows system.Add functions to recieve a single interface EG: s.AddByInterface(a interface{GetBasicEntity()*BasicEntity, GetSpaceComponent()*SpaceComponent){ s.Add(a.GetBasicEntity(),a.GetSpaceComponent()) }
func (BasicEntity) ID ¶
func (e BasicEntity) ID() uint64
ID returns the unique identifier of the entity.
type Button ¶
A Button is an input which can be either JustPressed, JustReleased or Down. Common uses would be for, a jump key or an action key.
func (Button) JustPressed ¶
JustPressed checks whether an input was pressed in the previous frame.
func (Button) JustReleased ¶
JustReleased checks whether an input was released in the previous frame.
type Clock ¶
type Clock struct {
// contains filtered or unexported fields
}
A Clock is a measurement built in `engo` to measure the actual frames per seconds (framerate).
func NewClock ¶
func NewClock() *Clock
NewClock creates a new timer which allows you to measure ticks per seconds. Be sure to call `Tick()` whenever you want a tick to occur - it does not automatically tick each frame.
type Cursor ¶
type Cursor uint8
Cursor is a reference to standard cursors, to be used in conjunction with `SetCursor`. What they look like, is different for each platform.
const ( // CursorNone can be used to reset the cursor. CursorNone Cursor = iota // CursorArrow represents an arrow cursor CursorArrow // CursorCrosshair represents a crosshair cursor CursorCrosshair // CursorHand represents a hand cursor CursorHand // CursorIBeam represents an IBeam cursor CursorIBeam // CursorHResize represents a HResize cursor CursorHResize // CursorVResize represents a VResize cursor CursorVResize )
type Exiter ¶
type Exiter interface {
// Exit is called when the user or the system requests to close the game
// This should be used to cleanup or prompt user if they're sure they want to close
// To prevent the default action (close/exit) make sure to set OverrideCloseAction in
// your RunOpts to `true`. You should then handle the exiting of the program by calling
// engo.Exit()
Exit()
}
Exiter is an optional interface a Scene can implement, indicating it'll have custom behavior whenever the game get closed.
type FileLoader ¶
type FileLoader interface {
// Load loads the given resource into memory.
Load(url string, data io.Reader) error
// Unload releases the given resource from memory.
Unload(url string) error
// Resource returns the given resource, and an error if it didn't succeed.
Resource(url string) (Resource, error)
}
FileLoader implements support for loading and releasing file resources.
type Formats ¶
type Formats struct {
// contains filtered or unexported fields
}
Formats manages resource handling of registered file formats.
func (*Formats) Register ¶
func (formats *Formats) Register(ext string, loader FileLoader)
Register registers a resource loader for the given file format.
func (*Formats) SetRoot ¶
SetRoot can be used to change the default directory from `assets` to whatever you want.
Whenever `root` does not start with the directory `assets`, you will not be able to support mobile (Android/iOS) since they require you to put all resources within the `assets` directory. More information about that is available here: https://godoc.org/golang.org/x/mobile/asset
You can, however, use subfolders within the `assets` folder, and set those as `root`.
type GLFW ¶
type GLFW struct {
// contains filtered or unexported fields
}
GLFW implements a platform based on github.com/go-gl/glfw (v3.2).
func (*GLFW) ClipboardText ¶
ClipboardText returns the current clipboard text, if available.
func (*GLFW) DisplaySize ¶
DisplaySize returns the dimension of the display.
func (*GLFW) FramebufferSize ¶
FramebufferSize returns the dimension of the framebuffer.
func (*GLFW) NewFrame ¶
func (p *GLFW) NewFrame()
NewFrame marks the begin of a render pass. It forwards all current state to imgui IO.
func (*GLFW) SetClipboardText ¶
SetClipboardText sets the text as the current clipboard text.
type Hider ¶
type Hider interface {
// Hide is called when an other Scene becomes active
Hide()
}
Hider is an optional interface a Scene can implement, indicating it'll have custom behavior whenever the Scene get hidden to make room fr other Scenes.
type Identifier ¶
type Identifier interface {
ID() uint64
}
Identifier is an interface for anything that implements the basic ID() uint64, as the BasicEntity does. It is useful as more specific interface for an entity registry than just the interface{} interface
type IdentifierSlice ¶
type IdentifierSlice []Identifier
IdentifierSlice implements the sort.Interface, so you can use the store entites in slices, and use the P=n*log n lookup for them
func (IdentifierSlice) Len ¶
func (is IdentifierSlice) Len() int
Len returns the length of the underlying slice part of the sort.Interface
func (IdentifierSlice) Less ¶
func (is IdentifierSlice) Less(i, j int) bool
Less will return true if the ID of element at i is less than j; part of the sort.Interface
func (IdentifierSlice) Swap ¶
func (is IdentifierSlice) Swap(i, j int)
Swap the elements at positions i and j part of the sort.Interface
type Initializer ¶
type Initializer interface {
// New initializes the given System, and may be used to initialize some
// values beforehand, like storing a reference to the World.
New(*World)
}
Initializer provides initialization of systems.
type InputManager ¶
type InputManager struct {
// Mouse is InputManager's reference to the mouse. It is recommended to use the
// Axis and Button system if at all possible.
Mouse Mouse
// contains filtered or unexported fields
}
InputManager contains information about all forms of input.
func NewInputManager ¶
func NewInputManager() *InputManager
NewInputManager holds onto anything input related for engo
func (*InputManager) Axis ¶
func (im *InputManager) Axis(name string) Axis
Axis retrieves an Axis with a specified name.
func (*InputManager) Button ¶
func (im *InputManager) Button(name string) Button
Button retrieves a Button with a specified name.
func (*InputManager) RegisterAxis ¶
func (im *InputManager) RegisterAxis(name string, pairs ...AxisPair)
RegisterAxis registers a new axis which can be used to retrieve inputs which are spectrums.
func (*InputManager) RegisterButton ¶
func (im *InputManager) RegisterButton(name string, keys ...Key)
RegisterButton registers a new button input.
type Key ¶
type Key int
Key correspends to a keyboard key
var ( // Grave represents the '`' keyboard key Grave Key = 192 // Dash represents the '-' keyboard key Dash Key = 189 // Apostrophe represents the `'` keyboard key Apostrophe Key = 222 // Semicolon represents the ';' keyboard key Semicolon Key = 186 // Equals reprsents the '=' keyboard key Equals Key = 187 // Comma represents the ',' keyboard key Comma Key = 188 // Period represents the '.' keyboard key Period Key = 190 // Slash represents the '/' keyboard key Slash Key = 191 // Backslash represents the '\' keyboard key Backslash Key = 220 //Backspace represents the backspace keyboard key Backspace Key = 8 // Tab represents the tab keyboard key Tab Key = 9 // CapsLock represents the caps lock keyboard key CapsLock Key = 20 // Space represents the space keyboard key Space Key = 32 // Enter represents the enter keyboard key Enter Key = 13 // Escape represents the escape keyboard key Escape Key = 27 // Insert represents the insert keyboard key Insert Key = 45 // PrintScreen represents the print screen keyboard key often // represented by 'Prt Scrn', 'Prt Scn', or 'Print Screen' PrintScreen Key = 42 // Delete represents the delete keyboard key Delete Key = 46 // PageUp represents the page up keyboard key PageUp Key = 33 // PageDown represents the page down keyboard key PageDown Key = 34 // Home represents the home keyboard key Home Key = 36 // End represents the end keyboard key End Key = 35 // Pause represents the pause keyboard key Pause Key = 19 // ScrollLock represents the scroll lock keyboard key ScrollLock Key = 145 // AllowLeft represents the arrow left keyboard key ArrowLeft Key = 37 // ArrowRight represents the arrow right keyboard key ArrowRight Key = 39 // ArrowDown represents the down arrow keyboard key ArrowDown Key = 40 // ArrowUp represents the up arrow keyboard key ArrowUp Key = 38 // LeftBracket represents the '[' keyboard key LeftBracket Key = 219 // LeftShift represents the left shift keyboard key LeftShift Key = 16 // LeftControl represents the left control keyboard key LeftControl Key = 17 // LeftSuper represents the left super keyboard key // (Windows key on Microsoft Windows, Command key on Apple OSX, and varies on Linux) LeftSuper Key = 73 // LeftAlt represents the left alt keyboard key LeftAlt Key = 18 // RightBracket represents the ']' keyboard key RightBracket Key = 221 // RightShift represents the right shift keyboard key RightShift Key = 16 // RightControl represents the right control keyboard key RightControl Key = 17 // RightSuper represents the right super keyboard key // (Windows key on Microsoft Windows, Command key on Apple OSX, and varies on Linux) RightSuper Key = 73 // RightAlt represents the left alt keyboard key RightAlt Key = 18 // Zero represents the '0' keyboard key Zero Key = 48 // One represents the '1' keyboard key One Key = 49 // Two represents the '2' keyboard key Two Key = 50 // Three represents the '3' keyboard key Three Key = 51 // Four represents the '4' keyboard key Four Key = 52 // Five represents the '5' keyboard key Five Key = 53 // Six represents the '6' keyboard key Six Key = 54 // Seven represents the '7' keyboard key Seven Key = 55 // Eight represents the '8' keyboard key Eight Key = 56 // Nine represents the '9' keyboard key Nine Key = 57 // F1 represents the 'F1' keyboard key F1 Key = 112 // F2 represents the 'F2' keyboard key F2 Key = 113 // F3 represents the 'F3' keyboard key F3 Key = 114 // F4 represents the 'F4' keyboard key F4 Key = 115 // F5 represents the 'F5' keyboard key F5 Key = 116 // F6 represents the 'F6' keyboard key F6 Key = 117 // F7 represents the 'F7' keyboard key F7 Key = 118 // F8 represents the 'F8' keyboard key F8 Key = 119 // F9 represents the 'F9' keyboard key F9 Key = 120 // F10 represents the 'F10' keyboard key F10 Key = 121 // F11 represents the 'F11' keyboard key F11 Key = 122 // F12 represents the 'F12' keyboard key F12 Key = 123 // A represents the 'A' keyboard key A Key = 65 // B represents the 'B' keyboard key B Key = 66 // C represents the 'C' keyboard key C Key = 67 // D represents the 'D' keyboard key ' D Key = 68 // E represents the 'E' keyboard key E Key = 69 // F represents the 'F' keyboard key F Key = 70 // G represents the 'G' keyboard key G Key = 71 // H represents the 'H' keyboard key H Key = 72 // I represents the 'I' keyboard key I Key = 73 // J represents the 'J' keyboard key J Key = 74 // K represents the 'K' keyboard key K Key = 75 // L represents the 'L' keyboard key L Key = 76 // M represents the 'M' keyboard key M Key = 77 // N represents the 'N' keyboard key N Key = 78 // O represents the 'O' keyboard key O Key = 79 // P represents the 'P' keyboard key P Key = 80 // Q represents the 'Q' keyboard key Q Key = 81 // R represents the 'R' keyboard key R Key = 82 // S represents the 'S' keyboard key S Key = 83 // T represents the 'T' keyboard key T Key = 84 // U represents the 'U' keyboard key U Key = 85 // V represents the 'V' keyboard key V Key = 86 // W represents the 'W' keyboard key W Key = 87 // X represents the 'X' keyboard key X Key = 88 // Y represents the 'Y' keyboard key Y Key = 89 // Z represents the 'Z' keyboard key Z Key = 90 // NumLock represents the NumLock keyboard key on the numpad NumLock Key = 144 // NumMultiply represents the NumMultiply keyboard key on the numpad NumMultiply Key = 106 // NumDivide represents the NumDivide keyboard key on the numpad NumDivide Key = 111 // NumAdd represents the NumAdd keyboard key on the numpad NumAdd Key = 107 // NumSubtract represents the NumSubtract keyboard key on the numpad NumSubtract Key = 109 // NumZero represents the NumZero keyboard key on the numpad NumZero Key = 96 // NumOne represents the NumOne keyboard key on the numpad NumOne Key = 97 // NumTwo represents the NumTwo keyboard key on the numpad NumTwo Key = 98 // NumThree represents the NumThree keyboard key on the numpad NumThree Key = 99 // NumFour represents the NumFour keyboard key on the numpad NumFour Key = 100 // NumFive represents the NumFive keyboard key on the numpad NumFive Key = 101 // NumSiz represents the NumSix keyboard key on the numpad NumSix Key = 102 // NumSeven represents the NumSeven keyboard key on the numpad NumSeven Key = 103 // NumEight represents the NumEight keyboard key on the numpad NumEight Key = 104 // NumNine represents the NumNine keyboard key on the numpad NumNine Key = 105 // NumDecimal represents the NumDecimal keyboard key on the numpad NumDecimal Key = 110 // NumEnter represents the NumEnter keyboard key on the numpad NumEnter Key = 13 )
those are default values for engo_js defined here because some of them are shared with engo_glfw. engo_glfw redefines the variables it needs to other values during init() so
type KeyManager ¶
type KeyManager struct {
// contains filtered or unexported fields
}
KeyManager tracks which keys are pressed and released at the current point of time.
func (*KeyManager) Set ¶
func (km *KeyManager) Set(k Key, state bool)
Set is used for updating whether or not a key is held down, or not held down.
type KeyState ¶
type KeyState struct {
// contains filtered or unexported fields
}
KeyState is used for detecting the state of a key press.
func (KeyState) JustPressed ¶
JustPressed returns whether a key was just pressed
func (KeyState) JustReleased ¶
JustReleased returns whether a key was just released
type Message ¶
type Message interface {
Type() string
}
A Message is used to send messages within the MessageManager
type MessageHandler ¶
type MessageHandler func(msg Message)
A MessageHandler is used to dispatch a message to the subscribed handler.
type MessageManager ¶
type MessageManager struct {
// contains filtered or unexported fields
}
MessageManager manages messages and subscribed handlers
func (*MessageManager) Dispatch ¶
func (mm *MessageManager) Dispatch(message Message)
Dispatch sends a message to all subscribed handlers of the message's type
func (*MessageManager) Listen ¶
func (mm *MessageManager) Listen(messageType string, handler MessageHandler)
Listen subscribes to the specified message type and calls the specified handler when fired
type Mouse ¶
type Mouse struct {
X, Y float32
ScrollX, ScrollY float32
Action Action
Button MouseButton
Modifer Modifier
}
Mouse ...
type MouseButton ¶
type MouseButton int
MouseButton corresponds to a mouse button.
const ( // MouseButtonLeft represents the left mouse button MouseButtonLeft MouseButton = 0 // MouseButtonRight represents the right mouse button MouseButtonRight MouseButton = 1 // MouseButtonMiddle represent the middle mosue button MouseButtonMiddle MouseButton = 2 // MouseButton4 represents the 4th mouse button MouseButton4 MouseButton = 3 // MouseButton5 represents the 5th mouse button MouseButton5 MouseButton = 4 // MouseButton6 represents the 6th mouse button MouseButton6 MouseButton = 5 // MouseButton7 represents the 7th mouse button MouseButton7 MouseButton = 6 // MouseButton4 represents the last mouse button MouseButtonLast MouseButton = 7 )
Mouse buttons
type MouseState ¶
type MouseState struct {
// X and Y are the coordinates of the Mouse, relative to the `Canvas`.
X, Y float32
// ScrollX and ScrollY are the amount of scrolling the user has done with his mouse wheel in the respective directions.
ScrollX, ScrollY float32
// Action indicates what the gamer currently has done with his mouse.
Action Action
// Button indicates which button is being pressed by the gamer (if any).
Button MouseButton
// Modifier indicates which modifier (shift, alt, etc.) has been pressed during the Action.
Modifier Modifier
}
MouseState represents the current state of the Mouse (or latest Touch-events).
type Prioritizer ¶
type Prioritizer interface {
// Priority indicates the order in which Systems should be executed per
// iteration, higher meaning sooner. The default priority is 0.
Priority() int
}
Prioritizer specifies the priority of systems.
type Resource ¶
type Resource interface {
// URL returns the uniform resource locator of the given resource.
URL() string
}
Resource represents a game resource, such as an image or a sound.
type RunOptions ¶
RunOptions ...
type Scene ¶
type Scene interface {
// Preload is called before loading resources
Preload()
// Setup is called before the main loop
Setup(*World)
// Type returns a unique string representation of the Scene, used to identify it
Type() string
}
Scene represents a screen ingame. i.e.: main menu, settings, but also the game itself
func CurrentScene ¶
func CurrentScene() Scene
CurrentScene returns the SceneWorld that is currently active
type Shower ¶
type Shower interface {
// Show is called whenever the other Scene becomes inactive, and this one becomes the active one
Show()
}
Shower is an optional interface a Scene can implement, indicating it'll have custom behavior whenever the Scene gets shown again after being hidden (due to switching to other Scenes)
type System ¶
type System interface {
// Update updates the system. It is invoked by the engine once every frame,
// with dt being the duration since the previous update.
Update(dt float32)
// Remove removes the given entity from the system.
Remove(e BasicEntity)
}
A System implements logic for processing entities possessing components of the same aspects as the system. A System should iterate over its Entities on `Update`, in any way suitable for the current implementation.
By convention, systems provide an Add method for adding entities and their associated components to the system; e.g.
Add(basic *ecs.BasicEntity, collision *CollisionComponent, space *SpaceComponent)
type WindowResizeMessage ¶
WindowResizeMessage is a message that's being dispatched whenever the game window is being resized by the gamer
func (WindowResizeMessage) Type ¶
func (WindowResizeMessage) Type() string
Type returns the type of the current object "WindowResizeMessage"
type World ¶
type World struct {
// contains filtered or unexported fields
}
World contains a bunch of Entities, and a bunch of Systems. It is the recommended way to run ecs.
func (*World) RemoveEntity ¶
func (w *World) RemoveEntity(e BasicEntity)
RemoveEntity removes the entity across all systems.
Source Files
Directories