engo: github.com/EngoEngine/engo Index | Files | Directories

package engo

import "github.com/EngoEngine/engo"

Index

Package Files

assets.go axis.go button.go clock.go cursor.go engo.go engo_glfw.go input.go input_data.go input_keys_glfw.go keys.go math.go message.go quadtree.go scene.go utils.go

Constants

const (
    // DefaultVerticalAxis is the name of the default vertical axis, as used internally in `engo` when `StandardInputs`
    // is defined.
    DefaultVerticalAxis = "vertical"

    // DefaultHorizontalAxis is the name of the default horizontal axis, as used internally in `engo` when `StandardInputs`
    // is defined.
    DefaultHorizontalAxis = "horizontal"
    // DefaultMouseXAxis is the name of the default horizontal mouse axis
    DefaultMouseXAxis = "mouse x"
    // DefaultMouseYAxis is the name of the default vertical mouse axis
    DefaultMouseYAxis = "mouse y"
)
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
)
const (
    // Epsilon is some tiny value that determines how precisely equal we want our
    // floats to be.
    Epsilon float32 = 1e-3
    // MinNormal is the smallest normal value possible.
    MinNormal = float32(1.1754943508222875e-38) // 1 / 2**(127 - 1)

    // RadToDeg is multiplied with a radian value to get the equivalant value in degrees.
    RadToDeg = 180 / math.Pi
    // DegToRad is multiplied with a degree value to get the equivalent value in radians.
    DegToRad = math.Pi / 180
)

Variables

var (
    // Time is the active FPS counter
    Time *Clock

    // Input handles all input: mouse, keyboard and touch
    Input *InputManager

    // Mailbox is used by all Systems to communicate
    Mailbox *MessageManager

    // CurrentBackEnd is the current back end used for window management
    CurrentBackEnd BackEnd
    // ResizeXOffset is how far the screen moves from (0,0) being the top-left corner
    // when the window is resized
    ResizeXOffset = float32(0)
    // ResizeYOffset is how far the screen moves from (0,0) being the top-left corner
    // when the window is resized
    ResizeYOffset = float32(0)
)
var (
    // Window is the glfw.Window used for engo
    Window *glfw.Window
    // Gl is the current OpenGL context
    Gl  *gl.Context
)
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 Files = &Formats{formats: make(map[string]FileLoader)}

Files manages global resource handling of registered file formats for game assets.

func CanvasHeight Uses

func CanvasHeight() float32

CanvasHeight gets the height of the current OpenGL Framebuffer

func CanvasScale Uses

func CanvasScale() float32

CanvasScale gets the ratio of the canvas to the window sizes

func CanvasWidth Uses

func CanvasWidth() float32

CanvasWidth gets the width of the current OpenGL Framebuffer

func CreateWindow Uses

func CreateWindow(title string, width, height int, fullscreen bool, msaa int)

CreateWindow sets up the GLFW window and prepares the OpenGL surface for rendering

func CrossProduct Uses

func CrossProduct(this, that Point) float32

CrossProduct returns the 2 dimensional cross product of this and that, which represents the magnitude of the three dimensional cross product

func CursorPos Uses

func CursorPos() (x, y float32)

CursorPos returns the current cursor position

func DestroyWindow Uses

func DestroyWindow()

DestroyWindow handles the termination of windows

func DotProduct Uses

func DotProduct(this, that Point) float32

DotProduct returns the dot product between this and that

func Exit Uses

func Exit()

Exit is the safest way to close your game, as `engo` will correctly attempt to close all windows, handlers and contexts

func FloatEqual Uses

func FloatEqual(a, b float32) bool

FloatEqual is a safe utility function to compare floats. It's Taken from http://floating-point-gui.de/errors/comparison/

It is slightly altered to not call Abs when not needed.

func FloatEqualThreshold Uses

func FloatEqualThreshold(a, b, epsilon float32) bool

FloatEqualThreshold is a utility function to compare floats. It's Taken from http://floating-point-gui.de/errors/comparison/

It is slightly altered to not call Abs when not needed.

This differs from FloatEqual in that it lets you pass in your comparison threshold, so that you can adjust the comparison value to your specific needs

func GameHeight Uses

func GameHeight() float32

GameHeight returns the current game height

func GameWidth Uses

func GameWidth() float32

GameWidth returns the current game width

func GetApplicationVersion Uses

func GetApplicationVersion() [3]int

GetApplicationVersion returns the major, minor, and revision of the game.

func GetKeyName Uses

func GetKeyName(k Key) string

GetKeyName returns the string returned from the given Key. So you can write "Press W to move forward" and get a W for QWERTY and Z for AZERTY

func GetTitle Uses

func GetTitle() string

GetTitle returns the title of the game.

func Headless Uses

func Headless() bool

Headless indicates whether or not OpenGL-calls should be made

func IsAndroidChrome Uses

func IsAndroidChrome() bool

IsAndroidChrome tells if the browser is Chrome for android

func LineTraceFraction Uses

func LineTraceFraction(tracer, boundary Line) float32

LineTraceFraction returns the trace fraction of tracer through boundary 1 means no intersection 0 means tracer's origin lies on the boundary line

func MultiplyMatrixVector Uses

func MultiplyMatrixVector(m *Matrix, v []float32) []float32

MultiplyMatrixVector multiplies the matrix m with the float32 vector v and returns the result. The size of vector v MUST be 2 or 3. If v is size 2, a 3rd component is automatically added with value of 1.0.

func RegisterScene Uses

func RegisterScene(s Scene)

RegisterScene registers the `Scene`, so it can later be used by `SetSceneByName`

func Run Uses

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 RunIteration Uses

func RunIteration()

RunIteration runs one iteration per frame

func RunPreparation Uses

func RunPreparation(defaultScene Scene)

RunPreparation is called automatically when calling Open. It should only be called once.

func ScaleOnResize Uses

func ScaleOnResize() bool

ScaleOnResize indicates whether or not the screen should resize (i.e. make things look smaller/bigger) whenever the window resized. If `false`, then the size of the screen does not affect the size of the things drawn - it just makes less/more objects visible

func SetCursor Uses

func SetCursor(c Cursor)

SetCursor sets the pointer of the mouse to the defined standard cursor

func SetCursorVisibility Uses

func SetCursorVisibility(visible bool)

SetCursorVisibility sets the visibility of the cursor. If true the cursor is visible, if false the cursor is not.

func SetFPSLimit Uses

func SetFPSLimit(limit int) error

SetFPSLimit can be used to change the value in the given `RunOpts` after already having called `engo.Run`.

func SetGlobalScale Uses

func SetGlobalScale(p Point)

SetGlobalScale sets the GlobalScale to the given dimensions. If either dimension is less than or equal to zero, GlobalScale is set to (1, 1).

func SetOverrideCloseAction Uses

func SetOverrideCloseAction(value bool)

SetOverrideCloseAction can be used to change the value in the given `RunOpts` after already having called `engo.Run`.

func SetScaleOnResize Uses

func SetScaleOnResize(b bool)

SetScaleOnResize can be used to change the value in the given `RunOpts` after already having called `engo.Run`.

func SetScene Uses

func SetScene(s Scene, forceNewWorld bool)

SetScene sets the currentScene to the given Scene, and optionally forcing to create a new ecs.World that goes with it.

func SetSceneByName Uses

func SetSceneByName(name string, forceNewWorld bool) error

SetSceneByName does a lookup for the `Scene` where its `Type()` equals `name`, and then sets it as current `Scene`

func SetTitle Uses

func SetTitle(title string)

SetTitle sets the title of the window

func SetVSync Uses

func SetVSync(enabled bool)

SetVSync sets whether or not to use VSync

func WindowHeight Uses

func WindowHeight() float32

WindowHeight gets the current window height

func WindowSize Uses

func WindowSize() (w, h int)

WindowSize gets the current window size

func WindowWidth Uses

func WindowWidth() float32

WindowWidth gets the current window width

type AABB Uses

type AABB struct {
    Min, Max Point
}

AABB describes two points of a rectangle: the upper-left corner and the lower-right corner. It should always hold that `Min.X <= Max.X` and `Min.Y <= Max.Y`.

type AABBer Uses

type AABBer interface {
    // AABB returns the axis aligned bounding box.
    AABB() AABB
}

AABBer is an interface for everything that provides information about its axis aligned bounding box.

type Action Uses

type Action int

Action corresponds to a control action such as move, press, release

type Axis Uses

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.

func (Axis) Value Uses

func (a Axis) Value() float32

Value returns the value of an Axis.

type AxisKeyPair Uses

type AxisKeyPair struct {
    Min Key
    Max Key
}

An AxisKeyPair is a set of Min/Max values used for detecting whether or not a key has been pressed.

func (AxisKeyPair) Value Uses

func (keys AxisKeyPair) Value() float32

Value returns the value of a keypress.

type AxisMouse Uses

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 Uses

func NewAxisMouse(d AxisMouseDirection) *AxisMouse

NewAxisMouse creates a new Mouse Axis in either direction AxisMouseVert or AxisMouseHori.

func (*AxisMouse) Value Uses

func (am *AxisMouse) Value() float32

Value returns the delta of a mouse movement.

type AxisMouseDirection Uses

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 Uses

type AxisPair interface {
    Value() float32
}

An AxisPair is a set of Min/Max values which could possible be used by an Axis.

type BackEnd Uses

type BackEnd uint

BackEnd represents the back end used for the window management / GL Surface

const (
    // BackEndGLFW uses glfw
    BackEndGLFW BackEnd = iota
    // BackEndWeb uses gopherjs
    BackEndWeb
    // BackEndMobile uses gomobile
    BackEndMobile
    // BackEndSDL uses sdl2
    BackEndSDL
    // BackEndHeadless does not use a window manager for the backend
    BackEndHeadless
    // BackEndVulkan uses glfw 3.3 from vulkan-go and vulkan as a render surface
    BackEndVulkan
)

type Button Uses

type Button struct {
    Triggers []Key
    Name     string
}

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) Down Uses

func (b Button) Down() bool

Down checks whether the current input is being held down.

func (Button) JustPressed Uses

func (b Button) JustPressed() bool

JustPressed checks whether an input was pressed in the previous frame.

func (Button) JustReleased Uses

func (b Button) JustReleased() bool

JustReleased checks whether an input was released in the previous frame.

type Clock Uses

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 Uses

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.

func (*Clock) Delta Uses

func (c *Clock) Delta() float32

Delta is the amount of seconds between the last tick and the one before that

func (*Clock) FPS Uses

func (c *Clock) FPS() float32

FPS is the amount of frames per second, computed every time a tick occurs at least a second after the previous update

func (*Clock) Pause Uses

func (c *Clock) Pause()

Pause pauses the clock

func (*Clock) Tick Uses

func (c *Clock) Tick()

Tick indicates a new tick/frame has occurred.

func (*Clock) Time Uses

func (c *Clock) Time() float32

Time is the number of seconds the clock has been running

func (*Clock) Unpause Uses

func (c *Clock) Unpause()

Unpause unpauses the clock

type Container Uses

type Container interface {
    // Contains reports whether the container contains the given point.
    Contains(p Point) bool
}

A Container is a 2D closed shape which contains a set of points.

type Cursor Uses

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 Uses

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 Uses

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 Uses

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

Formats manages resource handling of registered file formats.

func (*Formats) GetRoot Uses

func (formats *Formats) GetRoot() string

GetRoot returns the folder currently set at root.

func (*Formats) Load Uses

func (formats *Formats) Load(urls ...string) error

Load loads the given resource(s) into memory, stopping at the first error.

func (*Formats) LoadReaderData Uses

func (formats *Formats) LoadReaderData(url string, f io.Reader) error

LoadReaderData loads a resource when you already have the reader for it.

func (*Formats) Register Uses

func (formats *Formats) Register(ext string, loader FileLoader)

Register registers a resource loader for the given file format.

func (*Formats) Resource Uses

func (formats *Formats) Resource(url string) (Resource, error)

Resource returns the given resource, and an error if it didn't succeed.

func (*Formats) SetRoot Uses

func (formats *Formats) SetRoot(root string)

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`.

func (*Formats) Unload Uses

func (formats *Formats) Unload(url string) error

Unload releases the given resource from memory.

type HandlerIDPair Uses

type HandlerIDPair struct {
    MessageHandlerId
    MessageHandler
}

type Hider Uses

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 InputManager Uses

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
    // Modifier represents a special key pressed along with another key
    Modifier Modifier

    // Touches is the touches on the screen. There can be up to 5 recorded in Android,
    // and up to 4 on iOS. GLFW can also keep track of the touches. The latest touch is also
    // recorded in the Mouse so that touches readily work with the common.MouseSystem
    Touches map[int]Point
    // contains filtered or unexported fields
}

InputManager contains information about all forms of input.

func NewInputManager Uses

func NewInputManager() *InputManager

NewInputManager holds onto anything input related for engo

func (*InputManager) Axis Uses

func (im *InputManager) Axis(name string) Axis

Axis retrieves an Axis with a specified name.

func (*InputManager) Button Uses

func (im *InputManager) Button(name string) Button

Button retrieves a Button with a specified name.

func (*InputManager) RegisterAxis Uses

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 Uses

func (im *InputManager) RegisterButton(name string, keys ...Key)

RegisterButton registers a new button input.

type Key Uses

type Key int

Key correspends to a keyboard key

const (
    // KeyGrave represents the '`' keyboard key
    KeyGrave Key = Key(glfw.KeyGraveAccent)
    // KeyDash represents the '-' keyboard key
    KeyDash Key = Key(glfw.KeyMinus)
    // KeyApostrophe represents the `'` keyboard key
    KeyApostrophe Key = Key(glfw.KeyApostrophe)
    // KeySemicolon represents the ';' keyboard key
    KeySemicolon Key = Key(glfw.KeySemicolon)
    // KeyEquals reprsents the '=' keyboard key
    KeyEquals Key = Key(glfw.KeyEqual)
    // KeyComma represents the ',' keyboard key
    KeyComma Key = Key(glfw.KeyComma)
    // KeyPeriod represents the '.' keyboard key
    KeyPeriod Key = Key(glfw.KeyPeriod)
    // KeySlash represents the '/' keyboard key
    KeySlash Key = Key(glfw.KeySlash)
    // KeyBackslash represents the '\' keyboard key
    KeyBackslash Key = Key(glfw.KeyBackslash)
    // KeyBackspace represents the backspace keyboard key
    KeyBackspace Key = Key(glfw.KeyBackspace)
    // KeyTab represents the tab keyboard key
    KeyTab Key = Key(glfw.KeyTab)
    // KeyCapsLock represents the caps lock keyboard key
    KeyCapsLock Key = Key(glfw.KeyCapsLock)
    // KeySpace represents the space keyboard key
    KeySpace Key = Key(glfw.KeySpace)
    // KeyEnter represents the enter keyboard key
    KeyEnter Key = Key(glfw.KeyEnter)
    // KeyEscape represents the escape keyboard key
    KeyEscape Key = Key(glfw.KeyEscape)
    // KeyInsert represents the insert keyboard key
    KeyInsert Key = Key(glfw.KeyInsert)
    // KeyPrintScreen represents the print screen keyboard key often
    // represented by 'Prt Scrn', 'Prt Scn', or 'Print Screen'
    KeyPrintScreen Key = Key(glfw.KeyPrintScreen)
    // KeyDelete represents the delete keyboard key
    KeyDelete Key = Key(glfw.KeyDelete)
    // KeyPageUp represents the page up keyboard key
    KeyPageUp Key = Key(glfw.KeyPageUp)
    // KeyPageDown represents the page down keyboard key
    KeyPageDown Key = Key(glfw.KeyPageDown)
    // KeyHome represents the home keyboard key
    KeyHome Key = Key(glfw.KeyHome)
    // KeyEnd represents the end keyboard key
    KeyEnd Key = Key(glfw.KeyEnd)
    // KeyPause represents the pause keyboard key
    KeyPause Key = Key(glfw.KeyPause)
    // KeyScrollLock represents the scroll lock keyboard key
    KeyScrollLock Key = Key(glfw.KeyScrollLock)
    // KeyArrowLeft represents the arrow left keyboard key
    KeyArrowLeft Key = Key(glfw.KeyLeft)
    // KeyArrowRight represents the arrow right keyboard key
    KeyArrowRight Key = Key(glfw.KeyRight)
    // KeyArrowDown represents the down arrow keyboard key
    KeyArrowDown Key = Key(glfw.KeyDown)
    // KeyArrowUp represents the up arrow keyboard key
    KeyArrowUp Key = Key(glfw.KeyUp)
    // KeyLeftBracket represents the '[' keyboard key
    KeyLeftBracket Key = Key(glfw.KeyLeftBracket)
    // KeyLeftShift represents the left shift keyboard key
    KeyLeftShift Key = Key(glfw.KeyLeftShift)
    // KeyLeftControl represents the left control keyboard key
    KeyLeftControl Key = Key(glfw.KeyLeftControl)
    // KeyLeftSuper represents the left super keyboard key
    // (Windows key on Microsoft Windows, Command key on Apple OSX, and varies on Linux)
    KeyLeftSuper Key = Key(glfw.KeyLeftSuper)
    // KeyLeftAlt represents the left alt keyboard key
    KeyLeftAlt Key = Key(glfw.KeyLeftAlt)
    // KeyRightBracket represents the ']' keyboard key
    KeyRightBracket Key = Key(glfw.KeyRightBracket)
    // KeyRightShift represents the right shift keyboard key
    KeyRightShift Key = Key(glfw.KeyRightShift)
    // KeyRightControl represents the right control keyboard key
    KeyRightControl Key = Key(glfw.KeyRightControl)
    // KeyRightSuper represents the right super keyboard key
    // (Windows key on Microsoft Windows, Command key on Apple OSX, and varies on Linux)
    KeyRightSuper Key = Key(glfw.KeyRightSuper)
    // KeyRightAlt represents the left alt keyboard key
    KeyRightAlt Key = Key(glfw.KeyRightAlt)
    // KeyZero represents the '0' keyboard key
    KeyZero Key = Key(glfw.Key0)
    // KeyOne represents the '1' keyboard key
    KeyOne Key = Key(glfw.Key1)
    // KeyTwo represents the '2' keyboard key
    KeyTwo Key = Key(glfw.Key2)
    // KeyThree represents the '3' keyboard key
    KeyThree Key = Key(glfw.Key3)
    // KeyFour represents the '4' keyboard key
    KeyFour Key = Key(glfw.Key4)
    // KeyFive represents the '5' keyboard key
    KeyFive Key = Key(glfw.Key5)
    // KeySix represents the '6' keyboard key
    KeySix Key = Key(glfw.Key6)
    // KeySeven represents the '7' keyboard key
    KeySeven Key = Key(glfw.Key7)
    // KeyEight represents the '8' keyboard key
    KeyEight Key = Key(glfw.Key8)
    // KeyNine represents the  '9' keyboard key
    KeyNine Key = Key(glfw.Key9)
    // KeyF1 represents the 'F1' keyboard key
    KeyF1 Key = Key(glfw.KeyF1)
    // KeyF2 represents the 'F2' keyboard key
    KeyF2 Key = Key(glfw.KeyF2)
    // KeyF3 represents the 'F3' keyboard key
    KeyF3 Key = Key(glfw.KeyF3)
    // KeyF4 represents the 'F4' keyboard key
    KeyF4 Key = Key(glfw.KeyF4)
    // KeyF5 represents the 'F5' keyboard key
    KeyF5 Key = Key(glfw.KeyF5)
    // KeyF6 represents the 'F6' keyboard key
    KeyF6 Key = Key(glfw.KeyF6)
    // KeyF7 represents the 'F7' keyboard key
    KeyF7 Key = Key(glfw.KeyF7)
    // KeyF8 represents the 'F8' keyboard key
    KeyF8 Key = Key(glfw.KeyF8)
    // KeyF9 represents the 'F9' keyboard key
    KeyF9 Key = Key(glfw.KeyF9)
    // KeyF10 represents the 'F10' keyboard key
    KeyF10 Key = Key(glfw.KeyF10)
    // KeyF11 represents the 'F11' keyboard key
    KeyF11 Key = Key(glfw.KeyF11)
    // KeyF12 represents the 'F12' keyboard key
    KeyF12 Key = Key(glfw.KeyF12)
    // KeyA represents the 'A' keyboard key
    KeyA Key = Key(glfw.KeyA)
    // KeyB represents the 'B' keyboard key
    KeyB Key = Key(glfw.KeyB)
    // KeyC represents the 'C' keyboard key
    KeyC Key = Key(glfw.KeyC)
    // KeyD represents the 'D' keyboard key '
    KeyD Key = Key(glfw.KeyD)
    // KeyE represents the 'E' keyboard key
    KeyE Key = Key(glfw.KeyE)
    // KeyF represents the 'F' keyboard key
    KeyF Key = Key(glfw.KeyF)
    // KeyG represents the 'G' keyboard key
    KeyG Key = Key(glfw.KeyG)
    // KeyH represents the 'H' keyboard key
    KeyH Key = Key(glfw.KeyH)
    // KeyI represents the 'I' keyboard key
    KeyI Key = Key(glfw.KeyI)
    // KeyJ represents the 'J' keyboard key
    KeyJ Key = Key(glfw.KeyJ)
    // KeyK represents the 'K' keyboard key
    KeyK Key = Key(glfw.KeyK)
    // KeyL represents the 'L' keyboard key
    KeyL Key = Key(glfw.KeyL)
    // KeyM represents the 'M' keyboard key
    KeyM Key = Key(glfw.KeyM)
    // KeyN represents the 'N' keyboard key
    KeyN Key = Key(glfw.KeyN)
    // KeyO represents the 'O' keyboard key
    KeyO Key = Key(glfw.KeyO)
    // KeyP represents the 'P' keyboard key
    KeyP Key = Key(glfw.KeyP)
    // KeyQ represents the 'Q' keyboard key
    KeyQ Key = Key(glfw.KeyQ)
    // KeyR represents the 'R' keyboard key
    KeyR Key = Key(glfw.KeyR)
    // KeyS represents the 'S' keyboard key
    KeyS Key = Key(glfw.KeyS)
    // KeyT represents the 'T' keyboard key
    KeyT Key = Key(glfw.KeyT)
    // KeyU represents the 'U' keyboard key
    KeyU Key = Key(glfw.KeyU)
    // KeyV represents the 'V' keyboard key
    KeyV Key = Key(glfw.KeyV)
    // KeyW represents the 'W' keyboard key
    KeyW Key = Key(glfw.KeyW)
    // KeyX represents the 'X' keyboard key
    KeyX Key = Key(glfw.KeyX)
    // KeyY represents the 'Y' keyboard key
    KeyY Key = Key(glfw.KeyY)
    // KeyZ represents the 'Z' keyboard key
    KeyZ Key = Key(glfw.KeyZ)
    // KeyNumLock represents the NumLock keyboard key on the numpad
    KeyNumLock Key = Key(glfw.KeyNumLock)
    // KeyNumMultiply represents the NumMultiply keyboard key on the numpad
    KeyNumMultiply Key = Key(glfw.KeyKPMultiply)
    // KeyNumDivide represents the NumDivide keyboard key on the numpad
    KeyNumDivide Key = Key(glfw.KeyKPDivide)
    // KeyNumAdd represents the NumAdd keyboard key on the numpad
    KeyNumAdd Key = Key(glfw.KeyKPAdd)
    // KeyNumSubtract represents the NumSubtract keyboard key on the numpad
    KeyNumSubtract Key = Key(glfw.KeyKPSubtract)
    // KeyNumZero represents the NumZero keyboard key on the numpad
    KeyNumZero Key = Key(glfw.KeyKP0)
    // KeyNumOne represents the NumOne keyboard key on the numpad
    KeyNumOne Key = Key(glfw.KeyKP1)
    // KeyNumTwo represents the NumTwo keyboard key on the numpad
    KeyNumTwo Key = Key(glfw.KeyKP2)
    // KeyNumThree represents the NumThree keyboard key on the numpad
    KeyNumThree Key = Key(glfw.KeyKP3)
    // KeyNumFour represents the NumFour keyboard key on the numpad
    KeyNumFour Key = Key(glfw.KeyKP4)
    // KeyNumFive represents the NumFive keyboard key on the numpad
    KeyNumFive Key = Key(glfw.KeyKP5)
    // KeyNumSix represents the NumSix keyboard key on the numpad
    KeyNumSix Key = Key(glfw.KeyKP6)
    // KeyNumSeven represents the NumSeven keyboard key on the numpad
    KeyNumSeven Key = Key(glfw.KeyKP7)
    // KeyNumEight represents the NumEight keyboard key on the numpad
    KeyNumEight Key = Key(glfw.KeyKP8)
    // KeyNumNine represents the NumNine keyboard key on the numpad
    KeyNumNine Key = Key(glfw.KeyKP9)
    // KeyNumDecimal represents the NumDecimal keyboard key on the numpad
    KeyNumDecimal Key = Key(glfw.KeyKPDecimal)
    // KeyNumEnter represents the NumEnter keyboard key on the numpad
    KeyNumEnter Key = Key(glfw.KeyKPEnter)
)

type KeyManager Uses

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

KeyManager tracks which keys are pressed and released at the current point of time.

func NewKeyManager Uses

func NewKeyManager() *KeyManager

NewKeyManager creates a new KeyManager.

func (*KeyManager) Get Uses

func (km *KeyManager) Get(k Key) KeyState

Get retrieves a keys state.

func (*KeyManager) Set Uses

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 Uses

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

KeyState is used for detecting the state of a key press.

func (KeyState) Down Uses

func (key KeyState) Down() bool

Down returns wether a key is being pressed

func (KeyState) JustPressed Uses

func (key KeyState) JustPressed() bool

JustPressed returns whether a key was just pressed

func (KeyState) JustReleased Uses

func (key KeyState) JustReleased() bool

JustReleased returns whether a key was just released

func (*KeyState) State Uses

func (key *KeyState) State() int

State returns the raw state of a key.

func (KeyState) Up Uses

func (key KeyState) Up() bool

Up returns wheter a key is not being pressed

type Line Uses

type Line struct {
    P1  Point
    P2  Point
}

Line describes a line segment on a 2 dimensional euclidean space it can also be thought of as a 2 dimensional vector with an offset

func (*Line) Angle Uses

func (l *Line) Angle() float32

Angle returns the euclidean angle of l in radians relative to a vertical line, going positive as you head towards the positive x-axis (clockwise) and negative as you head towards the negative x-axis. Values returned are [-pi, pi].

func (*Line) AngleDeg Uses

func (l *Line) AngleDeg() float32

AngleDeg returns the euclidean angle of l in degrees relative to a vertical line, going positive as you head towards the positive x-axis (clockwise) and negative as you head towards the negative x-axis. Values returned are [-180, 180].

func (*Line) Magnitude Uses

func (l *Line) Magnitude() float32

Magnitude returns the length of the line

func (*Line) Normal Uses

func (l *Line) Normal() Point

Normal returns the left hand normal of the line segment l

func (*Line) PointDistance Uses

func (l *Line) PointDistance(point Point) float32

PointDistance Returns the euclidean distance from the point p to the line segment l

func (*Line) PointDistanceSquared Uses

func (l *Line) PointDistanceSquared(point Point) float32

PointDistanceSquared returns the squared euclidean distance from the point p to the line segment l

func (*Line) PointSide Uses

func (l *Line) PointSide(point Point) bool

PointSide returns which side of the line l the point p sits on true means the point is below/left of the line false means the point is above/right of the line or touching the line

type Matrix Uses

type Matrix struct {
    Val [9]float32
    // contains filtered or unexported fields
}

Matrix describes a 3x3 column-major matrix useful for 2D transformations.

func IdentityMatrix Uses

func IdentityMatrix() *Matrix

IdentityMatrix returns a new identity matrix.

func (*Matrix) Identity Uses

func (m *Matrix) Identity() *Matrix

Identity sets the matrix to the Identity matrix and returns the matrix.

func (*Matrix) Multiply Uses

func (m *Matrix) Multiply(m2 *Matrix) *Matrix

Multiply postmultiplies m matrix with m2 and stores the result in m, returning m. Multiplaction is the result of m2 times m.

func (*Matrix) Rotate Uses

func (m *Matrix) Rotate(deg float32) *Matrix

Rotate rorates m counter-clockwise by deg degrees.

func (*Matrix) RotateRad Uses

func (m *Matrix) RotateRad(rad float32) *Matrix

RotateRad rotates m counter-clockwise by rad radians.

func (*Matrix) RotationComponent Uses

func (m *Matrix) RotationComponent() float32

RotationComponent returns the current rotation component of m in degrees. This assumes uniform scaling.

func (*Matrix) RotationComponentRad Uses

func (m *Matrix) RotationComponentRad() float32

RotationComponentRad returns the current rotation component of m in radians. This assumes uniform scaling.

func (*Matrix) Scale Uses

func (m *Matrix) Scale(x, y float32) *Matrix

Scale scales m by x and y.

func (*Matrix) ScaleComponent Uses

func (m *Matrix) ScaleComponent() (x, y float32)

ScaleComponent returns the current scale component of m. This assumes uniform scaling.

func (*Matrix) Set Uses

func (m *Matrix) Set(val []float32) *Matrix

Set sets the matrix to the given float slice and returns the matrix. The float slice must have at least 9 elements. If the float slie contains more than 9 elements, only the first 9 will be copied.

func (*Matrix) Translate Uses

func (m *Matrix) Translate(x, y float32) *Matrix

Translate translates m by the point (x, y).

func (*Matrix) TranslatePoint Uses

func (m *Matrix) TranslatePoint(p Point) *Matrix

TranslatePoint translates m by the point p.

func (*Matrix) TranslationComponent Uses

func (m *Matrix) TranslationComponent() (x, y float32)

TranslationComponent returns the current translation component of m. This assumes uniform scaling.

type Message Uses

type Message interface {
    Type() string
}

A Message is used to send messages within the MessageManager

type MessageHandler Uses

type MessageHandler func(msg Message)

A MessageHandler is used to dispatch a message to the subscribed handler.

type MessageHandlerId Uses

type MessageHandlerId uint64

MessageHandlerId is used to track handlers, each handler will get a unique ID

type MessageManager Uses

type MessageManager struct {
    // this mutex will prevent race
    // conditions on listeners and
    // sync its state across the game
    sync.RWMutex
    // contains filtered or unexported fields
}

MessageManager manages messages and subscribed handlers

func (*MessageManager) Dispatch Uses

func (mm *MessageManager) Dispatch(message Message)

Dispatch sends a message to all subscribed handlers of the message's type To prevent any data races, be aware that these listeners occur as callbacks and can be executed at any time. If variables are altered in the handler, utilize channels, locks, semaphores, or any other method necessary to ensure the memory is not altered by multiple functions simultaneously.

func (*MessageManager) Listen Uses

func (mm *MessageManager) Listen(messageType string, handler MessageHandler) MessageHandlerId

Listen subscribes to the specified message type and calls the specified handler when fired

func (*MessageManager) ListenOnce Uses

func (mm *MessageManager) ListenOnce(messageType string, handler MessageHandler)

ListenOnce is a convenience wrapper around StopListen() to only listen to a specified message once

func (*MessageManager) StopListen Uses

func (mm *MessageManager) StopListen(messageType string, handlerID MessageHandlerId)

StopListen removes a previously added handler from the listener queue

type Modifier Uses

type Modifier int

Modifier represents a special key pressed along with another key

type Mouse Uses

type Mouse struct {
    X, Y             float32
    ScrollX, ScrollY float32
    Action           Action
    Button           MouseButton
    Modifer          Modifier
}

Mouse represents the mouse

type MouseButton Uses

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 Uses

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 Point Uses

type Point struct {
    X, Y float32
}

Point describes a coordinate in a 2 dimensional euclidean space it can also be thought of as a 2 dimensional vector from the origin

func GetGlobalScale Uses

func GetGlobalScale() Point

GetGlobalScale returns the GlobalScale factor set in the RunOptions or via SetGlobalScale()

func LineIntersection Uses

func LineIntersection(one, two Line) (Point, bool)

LineIntersection returns the point where the line segments one and two intersect and true if there is intersection, nil and false when line segments one and two do not intersect

func (*Point) Add Uses

func (p *Point) Add(p2 Point) *Point

Add sets the components of p to the pointwise summation of p + p2

func (*Point) AddScalar Uses

func (p *Point) AddScalar(s float32) *Point

AddScalar adds s to each component of p

func (*Point) Equal Uses

func (p *Point) Equal(p2 Point) bool

Equal indicates whether two points have the same value, avoiding issues with float precision

func (*Point) Multiply Uses

func (p *Point) Multiply(p2 Point) *Point

Multiply sets the components of p to the pointwise product of p * p2

func (*Point) MultiplyMatrixVector Uses

func (p *Point) MultiplyMatrixVector(m *Matrix) *Point

MultiplyMatrixVector multiplies the matrix m with the point and returns the result.

func (*Point) MultiplyScalar Uses

func (p *Point) MultiplyScalar(s float32) *Point

MultiplyScalar multiplies each component of p by s

func (*Point) Normalize Uses

func (p *Point) Normalize() (Point, float32)

Normalize returns the unit vector from p, and its magnitude. if you try to normalize the null vector, the return value will be null values

func (*Point) PointDistance Uses

func (p *Point) PointDistance(p2 Point) float32

PointDistance returns the euclidean distance between p and p2

func (*Point) PointDistanceSquared Uses

func (p *Point) PointDistanceSquared(p2 Point) float32

PointDistanceSquared returns the squared euclidean distance between p and p2

func (*Point) ProjectOnto Uses

func (p *Point) ProjectOnto(p2 Point) Point

ProjectOnto returns the vector produced by projecting p on to p2 returns an empty Point if they can't project onto one another

func (*Point) Set Uses

func (p *Point) Set(x, y float32) *Point

Set sets the coordinates of p to x and y

func (*Point) Subtract Uses

func (p *Point) Subtract(p2 Point) *Point

Subtract sets the components of p to the pointwise difference of p - p2

func (*Point) SubtractScalar Uses

func (p *Point) SubtractScalar(s float32) *Point

SubtractScalar subtracts s from each component of p

func (Point) Within Uses

func (p Point) Within(c Container) bool

Within reports whether the point is contained within the given container.

type Quadtree Uses

type Quadtree struct {
    MaxObjects int // Maximum objects a node can hold before splitting into 4 subnodes
    MaxLevels  int // Total max levels inside root Quadtree

    Total int
    // contains filtered or unexported fields
}

Quadtree implementation which can store AABBer values

func NewQuadtree Uses

func NewQuadtree(bounds AABB, usePool bool, maxObjects int) *Quadtree

NewQuadtree creates a new quadtree for the given bounds. When setting usePool to true, the internal values will be taken from a sync.Pool which reduces the allocation overhead. maxObjects tells the tree how many objects should be stored within a level before the quadtree cell is split.

func (*Quadtree) Clear Uses

func (qt *Quadtree) Clear()

Clear removes all items from the quadtree

func (*Quadtree) Destroy Uses

func (qt *Quadtree) Destroy()

Destroy frees the nodes if the Quadtree uses the node pool

func (*Quadtree) Insert Uses

func (qt *Quadtree) Insert(item AABBer)

Insert inserts the given item to the quadtree

func (*Quadtree) Remove Uses

func (qt *Quadtree) Remove(item AABBer)

Remove removes the given item from the quadtree

func (*Quadtree) Retrieve Uses

func (qt *Quadtree) Retrieve(find AABB, filter func(aabb AABBer) bool) []AABBer

Retrieve returns all objects that could collide with the given bounding box and passing the given filter function.

type Resource Uses

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 Uses

type RunOptions struct {
    // NoRun indicates the Open function should return immediately, without looping
    NoRun bool

    // Title is the Window title
    Title string

    // HeadlessMode indicates whether or not OpenGL calls should be made
    HeadlessMode bool

    // Fullscreen indicates the game should run in fullscreen mode if run on a desktop
    Fullscreen bool

    Width, Height int

    // GlobalScale scales all size/render components by the scale factor
    // Any point passed less than or equal to zero will result in the scale being set to
    // engo.Point{1, 1}.
    // All the systems in common should scale themselves accordingly (collision, camera, render, etc)
    // However, custom systems should be aware of this if this is set.
    GlobalScale Point

    // VSync indicates whether or not OpenGL should wait for the monitor to swp the buffers
    VSync bool

    // Resizable indicates whether or not the Window should be resizable.  Defaults to `false`.
    NotResizable bool

    // ScaleOnResize indicates whether or not engo should make things larger/smaller whenever the screen resizes
    ScaleOnResize bool

    // FPSLimit indicates the maximum number of frames per second
    FPSLimit int

    // OverrideCloseAction indicates that (when true) engo will never close whenever the gamer wants to close the
    // game - that will be your responsibility
    OverrideCloseAction bool

    // StandardInputs is an easy way to map common inputs to actions, such as "jump" being <SPACE>, and "action" being
    // <ENTER>.
    StandardInputs bool

    // MSAA indicates the amount of samples that should be taken. Leaving it blank will default to 1, and you may
    // use any positive value you wish. It may be possible that the operating system / environment doesn't support
    // the requested amount. In that case, GLFW will (hopefully) pick the highest supported sampling count. The higher
    // the value, the bigger the performance cost.
    //
    // Our `RenderSystem` automatically calls `gl.Enable(gl.MULTISAMPLE)` (which is required to make use of it), but
    // if you're going to use your own rendering `System` instead, you will have to call it yourself.
    //
    // Also note that this value is entirely ignored in WebGL - most browsers enable it by default when available, and
    // none of them (at time of writing) allow you to tune it.
    //
    // More info at https://www.opengl.org/wiki/Multisampling
    // "With multisampling, each pixel at the edge of a polygon is sampled multiple times."
    MSAA int

    // AssetsRoot is the path where all resources (images, audio files, fonts, etc.) can be found. Leaving this at
    // empty-string, will default this to `assets`.
    //
    // Whenever using any value that does not start with the directory `assets`, you will not be able to support
    // mobile (Android/iOS), because they **require** all assets to be within the `assets` directory. You may however
    // use any subfolder-structure within that `assets` directory.
    AssetsRoot string

    // MobileWidth and MobileHeight are the width and height given from the Android/iOS OpenGL Surface used for Gomobile bind
    MobileWidth, MobileHeight int

    // Update is the function called each frame during the runLoop to update all of the
    // systems. If left blank, it defaults to &ecs.World{}. Use this if you plan on utilizing
    // engo's window / GL management but don't want to use the ECS paradigm.
    Update Updater

    // ApplicationXXXVersion is the major, minor, and revision versions of the game.
    // defaults to 0.0.0
    ApplicationMajorVersion, ApplicationMinorVersion, ApplicationRevisionVersion int
}

RunOptions are the options used to Run engo

type Scene Uses

type Scene interface {
    // Preload is called before loading resources
    Preload()

    // Setup is called before the main loop
    Setup(Updater)

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

func CurrentScene() Scene

CurrentScene returns the SceneWorld that is currently active

type Shower Uses

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 TextMessage Uses

type TextMessage struct {
    Char rune
}

TextMessage is a message that is dispatched whenever a character is typed on the keyboard. This is not the same as a keypress, as it returns the rune of the character typed by the user, which could be a combination of keypresses.

func (TextMessage) Type Uses

func (TextMessage) Type() string

Type returns the type of the message, "TextMessage"

type Trace Uses

type Trace struct {
    Fraction    float32
    EndPosition Point
    Line
}

Trace describes all the values computed from a line trace

func LineTrace Uses

func LineTrace(tracer Line, boundaries []Line) Trace

LineTrace runs a series of line traces from tracer to each boundary line and returns the nearest trace values

type Updater Uses

type Updater interface {
    Update(float32)
}

Updater is an interface for what handles your game's Update during each frame. typically, this will be an *ecs.World, but you can implement your own Upodater and use engo without using engo's ecs

type WindowResizeMessage Uses

type WindowResizeMessage struct {
    OldWidth, OldHeight int
    NewWidth, NewHeight int
}

WindowResizeMessage is a message that's being dispatched whenever the game window is being resized by the gamer

func (WindowResizeMessage) Type Uses

func (WindowResizeMessage) Type() string

Type returns the type of the current object "WindowResizeMessage"

Directories

PathSynopsis
commonPackage common contains ECS implementations of commonly used game systems.
common/internal/decode/convertPackage convert resamples and converts audio data
common/internal/decode/mp3
common/internal/decode/vorbisPackage vorbis provides Ogg/Vorbis decoder.
common/internal/decode/wavPackage wav provides WAV (RIFF) decoder.
mathPackage math currently is a wrapper to github.com/engoengine/math.
math/imath
math/span

Package engo imports 15 packages (graph) and is imported by 22 packages. Updated 2020-08-14. Refresh now. Tools for package owners.