pixel

package module
v2.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 31, 2024 License: MIT Imports: 9 Imported by: 72

README

**Important Notice **

Revived fork of the original Pixel library by faiface. This fork is intended to be a community-driven effort to continue the development of the library. We were unable to get a hold of the original author, to take ownership of the original repository to carry on the legacy of the wonderful work. If you are interested in contributing, please join us in the Discord Chat!

Pixel 2

Go Reference Go build status Coverage Status Go Report Card Discord Chat

A hand-crafted 2D game library in Go. Take a look into the features to see what it can do.

go get github.com/gopxl/pixel/v2

If you are using Modules (Go 1.11 or higher) and want a mutable copy of the source code:

git clone https://github.com/gopxl/pixel # clone outside of $GOPATH
cd pixel
go install ./...

See requirements for the list of libraries necessary for compilation.

Tutorial

The Wiki of this repo contains an extensive tutorial covering several topics of Pixel.

For the tutorial walking through the basics of Pixel, check out The Basics!

Examples

The examples repository contains a few examples demonstrating Pixel's functionality.

To run an example, navigate to it's directory, then go run the main.go file. For example:

$ cd pixel-examples/platformer
$ go run main.go

Here are some screenshots from the examples!

Lights Platformer
Lights Platformer
Smoke Typewriter
Smoke Typewriter
Raycaster Gizmo
Raycaster Gizmo

Release Schedule

We aim to release a new version the 1st of every month.

Features

Here's the list of the main features in Pixel. Although Pixel is still under heavy development, there should be no major breakage in the API. This is not a 100% guarantee, though.

  • Fast 2D graphics
    • Sprites
    • Primitive shapes with immediate mode style IMDraw (circles, rectangles, lines, ...)
    • Optimized drawing with Batch
    • Text drawing with text package
  • Audio through a separate Beep library.
  • Simple and convenient API
    • Drawing a sprite to a window is as simple as sprite.Draw(window, matrix)
    • Wanna know where the center of a window is? window.Bounds().Center()
    • ...
  • Full documentation and tutorial
  • Works on Linux, macOS and Windows
  • Window creation and manipulation (resizing, fullscreen, multiple windows, ...)
  • Keyboard (key presses, text input) and mouse input without events
  • Well integrated with the Go standard library
    • Use "image" package for loading pictures
    • Use "time" package for measuring delta time and FPS
    • Use "image/color" for colors, or use Pixel's own color.Color format, which supports easy multiplication and a few more features
    • Pixel uses float64 throughout the library, compatible with "math" package
  • Geometry transformations with Matrix
    • Moving, scaling, rotating
    • Easy camera implementation
  • Off-screen drawing to Canvas or any other target (Batch, IMDraw, ...)
  • Fully garbage collected, no Close or Dispose methods
  • Full Porter-Duff composition, which enables
    • 2D lighting
    • Cutting holes into objects
    • Much more...
  • Pixel let's you draw stuff and do your job, it doesn't impose any particular style or paradigm
  • Platform and backend independent core
  • Core Target/Triangles/Picture pattern makes it easy to create new drawing targets that do arbitrarily crazy stuff (e.g. graphical effects)
  • Small codebase, ~5K lines of code, including the backend glhf package

Here are some packages which use Pixel:

  • TilePix Makes handling TMX files built with Tiled trivially easy to work with using Pixel.
  • spriteplus Basic SpriteSheet and Animation implementations
  • PixelUI Imgui-based GUIs for Pixel
  • pixelutils Variety of game related utilities (sprite packer, id generator, ticker, sprite loader, voronoia diagrams)

Missing features

Pixel is in development and still missing few critical features. Here're the most critical ones.

  • Audio
  • Drawing text
  • Antialiasing (filtering is supported, though)
  • Advanced window manipulation (cursor hiding, window icon, ...)
  • Better support for Hi-DPI displays
  • Mobile (and perhaps HTML5?) backend
  • More advanced graphical effects (e.g. blur) (solved with the addition of GLSL effects)
  • Tests and benchmarks
  • Vulkan support

Implementing these features will get us to the 1.0 release. Contribute, so that it's as soon as possible!

Requirements

If you're using Windows and having trouble building Pixel, please check this guide on the wiki.

OpenGL development libraries are needed for compilation. The dependencies are same as for GLFW.

The OpenGL version used is OpenGL 3.3.

  • On macOS, you need Xcode or Command Line Tools for Xcode (xcode-select --install) for required headers and libraries.
  • On Ubuntu/Debian-like Linux distributions, you need libgl1-mesa-dev and xorg-dev packages.
  • On CentOS/Fedora-like Linux distributions, you need libX11-devel libXcursor-devel libXrandr-devel libXinerama-devel mesa-libGL-devel libXi-devel libXxf86vm-devel packages.
  • On Linux to use Wayland instead of X11, compile your project with -tags wayland.
  • See here for full details.

The combination of Go 1.8, macOS and latest XCode seems to be problematic as mentioned in issue #7. This issue is probably not related to Pixel. Upgrading to Go 1.8.1 fixes the issue.

Windows Subsystem for Linux

While pixel does run on Windows, you will likely have significantly better performance running in WSL2, which now has support for GUI applications built-in with WSLg.

Installation instructions here. If you already have an old version of WSL installed, make sure to follow the upgrade instructions to get WSL2 as well as update your distribution of choice to version 2. Additionally, if you have an old DISPLAY environment variable set in your ~/.bashrc (or equivalent) for WSL1, you should remove it. This is now configured automatically.

Once WSL is setup, follow the usual Go and OpenGL installation instructions for your chosen distribution of linux.

Finally, add export LIBGL_ALWAYS_INDIRECT=0 to your ~/.bashrc (or equivalent) if you see an error like Error: creating window failed: VersionUnavailable: GLX: Failed to create context: GLXBadFBConfig when attempting to launch an OpenGL application from WSL.

Contributing

Join us in the Discord Chat!

Pixel is currently in a developmental phase, with many of its key features already in place, while others are still in the works. We genuinely appreciate and value contributions, as they can significantly expedite the development process. I invite everyone to contribute in any way they can, even if it's just sharing an idea. We especially value the submission of issues and pull requests.

That said, it's important to remember that Pixel is being developed with a great deal of thought and attention to detail. Each component has gone through numerous design iterations to ensure quality. We place a high premium on code and API quality, with an emphasis on simplicity and expressiveness. When contributing, please bear these goals in mind. This doesn't mean that only flawless pull requests will be accepted. Rather, it means that there may be times when a proposal might not align with our vision, or when a pull request might require some revisions. This is completely normal and should not discourage you. After all, our shared goal is to achieve the best end result possible.

Take a look at CONTRIBUTING.md for further information.

License

MIT

Special Contributions

  • A significant shoutout to the original author faiface for starting and growing the Pixel community. We would not be here if not for him.
  • The active/inactive maintainers of the original Pixel repo:

Documentation

Overview

Package pixel implements platform and backend agnostic core of the Pixel game development library.

It specifies the core Target, Triangles, Picture pattern and implements standard elements, such as Sprite, Batch, Vec, Matrix and RGBA in addition to the basic Triangles and Picture implementations: TrianglesData and PictureData.

Index

Constants

View Source 
const (
	// List of all mouse buttons.
	MouseButton1 Button = iota
	MouseButton2
	MouseButton3
	MouseButton4
	MouseButton5
	MouseButton6
	MouseButton7
	MouseButton8

	// List of all keyboard buttons.
	KeySpace
	KeyApostrophe
	KeyComma
	KeyMinus
	KeyPeriod
	KeySlash
	Key0
	Key1
	Key2
	Key3
	Key4
	Key5
	Key6
	Key7
	Key8
	Key9
	KeySemicolon
	KeyEqual
	KeyA
	KeyB
	KeyC
	KeyD
	KeyE
	KeyF
	KeyG
	KeyH
	KeyI
	KeyJ
	KeyK
	KeyL
	KeyM
	KeyN
	KeyO
	KeyP
	KeyQ
	KeyR
	KeyS
	KeyT
	KeyU
	KeyV
	KeyW
	KeyX
	KeyY
	KeyZ
	KeyLeftBracket
	KeyBackslash
	KeyRightBracket
	KeyGraveAccent
	KeyWorld1
	KeyWorld2
	KeyEscape
	KeyEnter
	KeyTab
	KeyBackspace
	KeyInsert
	KeyDelete
	KeyRight
	KeyLeft
	KeyDown
	KeyUp
	KeyPageUp
	KeyPageDown
	KeyHome
	KeyEnd
	KeyCapsLock
	KeyScrollLock
	KeyNumLock
	KeyPrintScreen
	KeyPause
	KeyF1
	KeyF2
	KeyF3
	KeyF4
	KeyF5
	KeyF6
	KeyF7
	KeyF8
	KeyF9
	KeyF10
	KeyF11
	KeyF12
	KeyF13
	KeyF14
	KeyF15
	KeyF16
	KeyF17
	KeyF18
	KeyF19
	KeyF20
	KeyF21
	KeyF22
	KeyF23
	KeyF24
	KeyF25
	KeyKP0
	KeyKP1
	KeyKP2
	KeyKP3
	KeyKP4
	KeyKP5
	KeyKP6
	KeyKP7
	KeyKP8
	KeyKP9
	KeyKPDecimal
	KeyKPDivide
	KeyKPMultiply
	KeyKPSubtract
	KeyKPAdd
	KeyKPEnter
	KeyKPEqual
	KeyLeftShift
	KeyLeftControl
	KeyLeftAlt
	KeyLeftSuper
	KeyRightShift
	KeyRightControl
	KeyRightAlt
	KeyRightSuper
	KeyMenu

	// Last iota
	NumButtons int = iota

	// Aliases
	MouseButtonLeft   = MouseButton1
	MouseButtonRight  = MouseButton2
	MouseButtonMiddle = MouseButton3
)
View Source 
const (
	Joystick1 Joystick = iota
	Joystick2
	Joystick3
	Joystick4
	Joystick5
	Joystick6
	Joystick7
	Joystick8
	Joystick9
	Joystick10
	Joystick11
	Joystick12
	Joystick13
	Joystick14
	Joystick15
	Joystick16

	// Last iota
	NumJoysticks int = iota
)
View Source 
const (
	AxisLeftX GamepadAxis = iota
	AxisLeftY
	AxisRightX
	AxisRightY
	AxisLeftTrigger
	AxisRightTrigger

	// Last iota.
	NumAxes int = iota
)
View Source 
const (
	GamepadA GamepadButton = iota
	GamepadB
	GamepadX
	GamepadY
	GamepadLeftBumper
	GamepadRightBumper
	GamepadBack
	GamepadStart
	GamepadGuide
	GamepadLeftThumb
	GamepadRightThumb
	GamepadDpadUp
	GamepadDpadRight
	GamepadDpadDown
	GamepadDpadLeft

	// Last iota
	NumGamepadButtons int = iota

	// Aliases
	GamepadCross    = GamepadA
	GamepadCircle   = GamepadB
	GamepadSquare   = GamepadX
	GamepadTriangle = GamepadY
)

Variables

View Source 
var (
	Center      = Anchor{0.5, 0.5}
	Top         = Anchor{0.5, 0}
	TopRight    = Anchor{0, 0}
	Right       = Anchor{0, 0.5}
	BottomRight = Anchor{0, 1}
	Bottom      = Anchor{0.5, 1}
	BottomLeft  = Anchor{1, 1}
	Left        = Anchor{1, 0.5}
	TopLeft     = Anchor{1, 0}
)
View Source 
var IM = Matrix{1, 0, 0, 1, 0, 0}

IM stands for identity matrix. Does nothing, no transformation.

View Source 
var RGBAModel = color.ModelFunc(rgbaModel)

RGBAModel converts colors to RGBA format.

View Source 
var ZB = Constant(V(1, 0))

ZB is Zero Bezier Curve that skips calculation and always returns V(1, 0) Its mainly because Calculation uses lot of function calls and in case of particles, it can make some difference

View Source 
var ZR = Rect{Min: ZV, Max: ZV}

ZR is a zero rectangle.

View Source 
var ZV = Vec{0, 0}

ZV is a zero vector.

Functions

func Clamp 

func Clamp(x, min, max float64) float64

Clamp returns x clamped to the interval [min, max].

If x is less than min, min is returned. If x is more than max, max is returned. Otherwise, x is returned.

func DefaultDecoderFunc added in v2.3.0 

func DefaultDecoderFunc(r io.Reader) (image.Image, error)

DefaultDecoderFunc is a DecoderFunc that uses image.Decode to decode images. In order to decode, you must import the image formats you wish to use. ex. import _ "image/png"

func ImageFromEmbed added in v2.3.0 

func ImageFromEmbed(fs embed.FS, path string, decoder DecoderFunc) (image.Image, error)

ImageFromEmbed loads an image from an embedded file using the given decoder.

We take a decoder function (png.Decode, jpeg.Decode, etc.) as an argument; in order to decode images, you have to register the format (png, jpeg, etc.) with the image package, this will increase the number of dependencies imposed on a project. We want to avoid importing these in Pixel as it will increase the size of the project and it will increase maintanence if we miss a format, or if a new format is added.

With this argument, you implicitly import and register the file formats you need and the Pixel project doesn't have to carry all formats around.

The decoder can be nil, and Pixel will fallback onto using image.Decode and require you to import the formats you wish to use.

See the example https://github.com/gopxl/pixel-examples/tree/main/core/loadingpictures.

func ImageFromFile added in v2.3.0 

func ImageFromFile(path string, decoder DecoderFunc) (image.Image, error)

ImageFromFile loads an image from a file using the given decoder.

We take a decoder function (png.Decode, jpeg.Decode, etc.) as an argument; in order to decode images, you have to register the format (png, jpeg, etc.) with the image package, this will increase the number of dependencies imposed on a project. We want to avoid importing these in Pixel as it will increase the size of the project and it will increase maintanence if we miss a format, or if a new format is added.

With this argument, you implicitly import and register the file formats you need and the Pixel project doesn't have to carry all formats around.

The decoder can be nil, and Pixel will fallback onto using image.Decode and require you to import the formats you wish to use.

See the example https://github.com/gopxl/pixel-examples/tree/main/core/loadingpictures.

Types

type Action added in v2.1.0 

type Action int
const (
	Release Action = iota
	Press
	Repeat
)
const UnknownAction Action = -1

func (Action) String added in v2.1.0 

func (a Action) String() string

String returns a human-readable string describing the Button.

type Anchor 

type Anchor Vec

Anchor is a vector used to define anchors, such as `Center`, `Top`, `TopRight`, etc.

func (Anchor) Opposite 

func (anchor Anchor) Opposite() Anchor

Opposite returns the opposite position of the anchor (ie. Top -> Bottom; BottomLeft -> TopRight, etc.).

func (Anchor) String 

func (anchor Anchor) String() string

String returns the string representation of an anchor.

type BasicTarget 

type BasicTarget interface {
	Target

	// SetMatrix sets a Matrix that every point will be projected by.
	SetMatrix(Matrix)

	// SetColorMask sets a color that will be multiplied with the TrianglesColor property of all
	// Triangles.
	SetColorMask(color.Color)
}

BasicTarget is a Target with additional basic adjustment methods.

type Batch 

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

Batch is a Target that allows for efficient drawing of many objects with the same Picture.

To put an object into a Batch, just draw it onto it: 

object.Draw(batch)

func NewBatch 

func NewBatch(container Triangles, pic Picture) *Batch

NewBatch creates an empty Batch with the specified Picture and container.

The container is where objects get accumulated. Batch will support precisely those Triangles properties, that the supplied container supports. If you retain access to the container and change it, call Dirty to notify Batch about the change.

Note, that if the container does not support TrianglesColor, color masking will not work.

func (*Batch) Clear 

func (b *Batch) Clear()

Clear removes all objects from the Batch.

func (*Batch) Dirty 

func (b *Batch) Dirty()

Dirty notifies Batch about an external modification of it's container. If you retain access to the Batch's container and change it, call Dirty to notify Batch about the change. 

container := &pixel.TrianglesData{}
batch := pixel.NewBatch(container, nil)
container.SetLen(10) // container changed from outside of Batch
batch.Dirty()        // notify Batch about the change

func (*Batch) Draw 

func (b *Batch) Draw(t Target)

Draw draws all objects that are currently in the Batch onto another Target.

func (*Batch) MakePicture 

func (b *Batch) MakePicture(p Picture) TargetPicture

MakePicture returns a specialized copy of the provided Picture that draws onto this Batch.

func (*Batch) MakeTriangles 

func (b *Batch) MakeTriangles(t Triangles) TargetTriangles

MakeTriangles returns a specialized copy of the provided Triangles that draws onto this Batch.

func (*Batch) SetColorMask 

func (b *Batch) SetColorMask(c color.Color)

SetColorMask sets a mask color used in the following draws onto the Batch.

func (*Batch) SetMatrix 

func (b *Batch) SetMatrix(m Matrix)

SetMatrix sets a Matrix that every point will be projected by.

type Bezier 

type Bezier struct {
	Start, StartHandle, EndHandle, End Vec
	// contains filtered or unexported fields
}

Bezier is cubic Bézier curve used for interpolation. For more info see https://en.wikipedia.org/wiki/B%C3%A9zier_curve, In case you are looking for visualization see https://www.desmos.com/calculator/d1ofwre0fr

func B 

func B(start, startHandle, endHandle, end Vec) Bezier

B returns new curve. if curve is just placeholder use constant. Handles are relative to start and end point so:

pixel.B(ZV, ZV, ZV, V(1, 0)) == Bezier{ZV, ZV, V(1, 0), V(1, 0)}

func Constant 

func Constant(constant Vec) Bezier

Constant returns Bezier curve that always return same point, This is usefull as placeholder, because it skips calculation

func Linear 

func Linear(start, end Vec) Bezier

Linear returns linear Bezier curve

func (Bezier) Point 

func (b Bezier) Point(t float64) Vec

Point returns point along the curve determinate by t (0 - 1) You can of course pass any value though its really hard to predict what value will it return

type Button added in v2.1.0 

type Button int
const UnknownButton Button = -1

func (Button) IsKeyboardButton added in v2.3.0 

func (b Button) IsKeyboardButton() bool

IsKeyboardButton returns true if the button is one of the keyboard buttons.

func (Button) IsMouseButton added in v2.3.0 

func (b Button) IsMouseButton() bool

IsMouseButton returns true if the button is one of the mouse buttons.

func (Button) String added in v2.1.0 

func (b Button) String() string

String returns a human-readable string describing the Button.

type Circle 

type Circle struct {
	Center Vec
	Radius float64
}

Circle is a 2D circle. It is defined by two properties:

  • Center vector
  • Radius float64

func C 

func C(center Vec, radius float64) Circle

C returns a new Circle with the given radius and center coordinates.

Note that a negative radius is valid.

func (Circle) Area 

func (c Circle) Area() float64

Area returns the area of the Circle.

func (Circle) Bounds 

func (c Circle) Bounds() Rect

func (Circle) Contains 

func (c Circle) Contains(u Vec) bool

Contains checks whether a vector `u` is contained within this Circle (including it's perimeter).

func (Circle) Formula 

func (c Circle) Formula() (h, k float64)

Formula returns the values of h and k, for the equation of the circle: (x-h)^2 + (y-k)^2 = r^2 where r is the radius of the circle.

func (Circle) Intersect 

func (c Circle) Intersect(d Circle) Circle

Intersect returns the maximal Circle which is covered by both `c` and `d`.

If `c` and `d` don't overlap, this function returns a zero-sized circle at the centerpoint between the two Circle's centers.

func (Circle) IntersectLine 

func (c Circle) IntersectLine(l Line) Vec

IntersectLine will return the shortest Vec such that if the Circle is moved by the Vec returned, the Line and Rect no longer intersect.

func (Circle) IntersectRect 

func (c Circle) IntersectRect(r Rect) Vec

IntersectRect returns a minimal required Vector, such that moving the circle by that vector would stop the Circle and the Rect intersecting. This function returns a zero-vector if the Circle and Rect do not overlap, and if only the perimeters touch.

This function will return a non-zero vector if:

  • The Rect contains the Circle, partially or fully
  • The Circle contains the Rect, partially of fully

func (Circle) IntersectionPoints 

func (c Circle) IntersectionPoints(l Line) []Vec

IntersectionPoints returns all the points where the Circle intersects with the line provided. This can be zero, one or two points, depending on the location of the shapes. The points of intersection will be returned in order of closest-to-l.A to closest-to-l.B.

func (Circle) Moved 

func (c Circle) Moved(delta Vec) Circle

Moved returns the Circle moved by the given vector delta.

func (Circle) Norm 

func (c Circle) Norm() Circle

Norm returns the Circle in normalized form - this sets the radius to its absolute value.

c := pixel.C(-10, pixel.ZV) c.Norm() // returns pixel.Circle{pixel.Vec{0, 0}, 10}

func (Circle) Resized 

func (c Circle) Resized(radiusDelta float64) Circle

Resized returns the Circle resized by the given delta. The Circles center is use as the anchor.

c := pixel.C(pixel.ZV, 10) c.Resized(-5) // returns pixel.Circle{pixel.Vec{0, 0}, 5} c.Resized(25) // returns pixel.Circle{pixel.Vec{0, 0}, 35}

func (Circle) String 

func (c Circle) String() string

String returns the string representation of the Circle. 

c := pixel.C(10.1234, pixel.ZV)
c.String()     // returns "Circle(10.12, Vec(0, 0))"
fmt.Println(c) // Circle(10.12, Vec(0, 0))

func (Circle) Union 

func (c Circle) Union(d Circle) Circle

Union returns the minimal Circle which covers both `c` and `d`.

type ComposeMethod 

type ComposeMethod int

ComposeMethod is a Porter-Duff composition method. 

const (
	ComposeOver ComposeMethod = iota
	ComposeIn
	ComposeOut
	ComposeAtop
	ComposeRover
	ComposeRin
	ComposeRout
	ComposeRatop
	ComposeXor
	ComposePlus
	ComposeCopy
)

Here's the list of all available Porter-Duff composition methods. Use ComposeOver for the basic alpha blending.

func (ComposeMethod) Compose 

func (cm ComposeMethod) Compose(a, b RGBA) RGBA

Compose composes two colors together according to the ComposeMethod. A is the foreground, B is the background.

type ComposeTarget 

type ComposeTarget interface {
	BasicTarget

	// SetComposeMethod sets a Porter-Duff composition method to be used.
	SetComposeMethod(ComposeMethod)
}

ComposeTarget is a BasicTarget capable of Porter-Duff composition.

type DecoderFunc added in v2.3.0 

type DecoderFunc func(io.Reader) (image.Image, error)

type Drawer 

type Drawer struct {
	Triangles Triangles
	Picture   Picture
	Cached    bool
	// contains filtered or unexported fields
}

Drawer glues all the fundamental interfaces (Target, Triangles, Picture) into a coherent and the only intended usage pattern.

Drawer makes it possible to draw any combination of Triangles and Picture onto any Target efficiently.

To create a Drawer, just assign it's Triangles and Picture fields: 

d := pixel.Drawer{Triangles: t, Picture: p}

If Triangles is nil, nothing will be drawn. If Picture is nil, Triangles will be drawn without a Picture.

Whenever you change the Triangles, call Dirty to notify Drawer that Triangles changed. You don't need to notify Drawer about a change of the Picture.

Note, that Drawer caches the results of MakePicture from Targets it's drawn to for each Picture it's set to. What it means is that using a Drawer with an unbounded number of Pictures leads to a memory leak, since Drawer caches them and never forgets. In such a situation, create a new Drawer for each Picture.

func (*Drawer) Dirty 

func (d *Drawer) Dirty()

Dirty marks the Triangles of this Drawer as changed. If not called, changes will not be visible when drawing.

func (*Drawer) Draw 

func (d *Drawer) Draw(t Target)

Draw efficiently draws Triangles with Picture onto the provided Target.

If Triangles is nil, nothing will be drawn. If Picture is nil, Triangles will be drawn without a Picture.

type GamepadAxis added in v2.1.0 

type GamepadAxis int

GamepadAxis corresponds to a gamepad axis. 

const UnknownGamepadAxis GamepadAxis = -1

Gamepad axis IDs.

func (GamepadAxis) String added in v2.1.0 

func (ga GamepadAxis) String() string

String returns a human-readable string describing the GamepadAxis.

type GamepadButton added in v2.1.0 

type GamepadButton int

GamepadButton corresponds to a gamepad button. 

const UnknownGampadButton GamepadButton = -1

Gamepad button IDs.

func (GamepadButton) String added in v2.1.0 

func (gb GamepadButton) String() string

String returns a human-readable string describing the GamepadButton.

type Joystick added in v2.1.0 

type Joystick int

Joystick is a joystick or controller (gamepad). 

const UnknownJoystick Joystick = -1

List all of the joysticks.

func (Joystick) String added in v2.1.0 

func (j Joystick) String() string

String returns a human-readable string describing the Joystick.

type Line 

type Line struct {
	A, B Vec
}

Line is a 2D line segment, between points A and B.

func L 

func L(from, to Vec) Line

L creates and returns a new Line.

func (Line) Bounds 

func (l Line) Bounds() Rect

Bounds returns the lines bounding box. This is in the form of a normalized Rect.

func (Line) Center 

func (l Line) Center() Vec

Center will return the point at center of the line; that is, the point equidistant from either end.

func (Line) Closest 

func (l Line) Closest(v Vec) Vec

Closest will return the point on the line which is closest to the Vec provided.

func (Line) Contains 

func (l Line) Contains(v Vec) bool

Contains returns whether the provided Vec lies on the line.

func (Line) Formula 

func (l Line) Formula() (m, b float64)

Formula will return the values that represent the line in the formula: y = mx + b This function will return math.Inf+, math.Inf- for a vertical line.

func (Line) Intersect 

func (l Line) Intersect(k Line) (Vec, bool)

Intersect will return the point of intersection for the two line segments. If the line segments do not intersect, this function will return the zero-vector and false.

func (Line) IntersectCircle 

func (l Line) IntersectCircle(c Circle) Vec

IntersectCircle will return the shortest Vec such that moving the Line by that Vec will cause the Line and Circle to no longer intesect. If they do not intersect at all, this function will return a zero-vector.

func (Line) IntersectRect 

func (l Line) IntersectRect(r Rect) Vec

IntersectRect will return the shortest Vec such that moving the Line by that Vec will cause the Line and Rect to no longer intesect. If they do not intersect at all, this function will return a zero-vector.

func (Line) Len 

func (l Line) Len() float64

Len returns the length of the line segment.

func (Line) Moved 

func (l Line) Moved(delta Vec) Line

Moved will return a line moved by the delta Vec provided.

func (Line) Rotated 

func (l Line) Rotated(around Vec, angle float64) Line

Rotated will rotate the line around the provided Vec.

func (Line) Scaled 

func (l Line) Scaled(scale float64) Line

Scaled will return the line scaled around the center point.

func (Line) ScaledXY 

func (l Line) ScaledXY(around Vec, scale float64) Line

ScaledXY will return the line scaled around the Vec provided.

func (Line) String 

func (l Line) String() string

type Matrix 

type Matrix [6]float64

Matrix is a 2x3 affine matrix that can be used for all kinds of spatial transforms, such as movement, scaling and rotations.

Matrix has a handful of useful methods, each of which adds a transformation to the matrix. For example: 

pixel.IM.Moved(pixel.V(100, 200)).Rotated(pixel.ZV, math.Pi/2)

This code creates a Matrix that first moves everything by 100 units horizontally and 200 units vertically and then rotates everything by 90 degrees around the origin.

Layout is: [0] [2] [4] [1] [3] [5] 

0   0   1  (implicit row)

func (Matrix) Chained 

func (m Matrix) Chained(next Matrix) Matrix

Chained adds another Matrix to this one. All tranformations by the next Matrix will be applied after the transformations of this Matrix.

func (Matrix) Moved 

func (m Matrix) Moved(delta Vec) Matrix

Moved moves everything by the delta vector.

func (Matrix) Project 

func (m Matrix) Project(u Vec) Vec

Project applies all transformations added to the Matrix to a vector u and returns the result.

Time complexity is O(1).

func (Matrix) Rotated 

func (m Matrix) Rotated(around Vec, angle float64) Matrix

Rotated rotates everything around a given point by the given angle in radians.

func (Matrix) Scaled 

func (m Matrix) Scaled(around Vec, scale float64) Matrix

Scaled scales everything around a given point by the scale factor.

func (Matrix) ScaledXY 

func (m Matrix) ScaledXY(around Vec, scale Vec) Matrix

ScaledXY scales everything around a given point by the scale factor in each axis respectively.

func (Matrix) String 

func (m Matrix) String() string

String returns a string representation of the Matrix. 

m := pixel.IM
fmt.Println(m) // Matrix(1 0 0 | 0 1 0)

func (Matrix) Unproject 

func (m Matrix) Unproject(u Vec) Vec

Unproject does the inverse operation to Project.

Time complexity is O(1).

type Picture 

type Picture interface {
	// Bounds returns the rectangle of the Picture. All data is located within this rectangle.
	// Querying properties outside the rectangle should return default value of that property.
	Bounds() Rect
}

Picture represents a rectangular area of raster data, such as a color. It has Bounds which specify the rectangle where data is located.

type PictureColor 

type PictureColor interface {
	Picture
	Color(at Vec) RGBA
}

PictureColor specifies Picture with Color property, so that every position inside the Picture's Bounds has a color.

Positions outside the Picture's Bounds must return full transparent (Alpha(0)).

type PictureData 

type PictureData struct {
	Pix    []color.RGBA
	Stride int
	Rect   Rect
}

PictureData specifies an in-memory rectangular area of pixels and implements Picture and PictureColor.

Pixels are small rectangles of unit size of form (x, y, x+1, y+1), where x and y are integers. PictureData contains and assigns a color to all pixels that are at least partially contained within it's Bounds (Rect).

The struct's innards are exposed for convenience, manual modification is at your own risk.

The format of the pixels is color.RGBA and not pixel.RGBA for a very serious reason: pixel.RGBA takes up 8x more memory than color.RGBA.

func MakePictureData 

func MakePictureData(rect Rect) *PictureData

MakePictureData creates a zero-initialized PictureData covering the given rectangle.

func PictureDataFromFile added in v2.3.0 

func PictureDataFromFile(path string, decoder DecoderFunc) (*PictureData, error)

PictureDataFromFile loads an image from a file using the given decoder and converts it into PictureData.

We take a decoder function (png.Decode, jpeg.Decode, etc.) as an argument; in order to decode images, you have to register the format (png, jpeg, etc.) with the image package, this will increase the number of dependencies imposed on a project. We want to avoid importing these in Pixel as it will increase the size of the project and it will increase maintanence if we miss a format, or if a new format is added.

With this argument, you implicitly import and register the file formats you need and the Pixel project doesn't have to carry all formats around.

The decoder can be nil, and Pixel will fallback onto using image.Decode and require you to import the formats you wish to use.

See the example https://github.com/gopxl/pixel-examples/tree/main/core/loadingpictures.

func PictureDataFromImage 

func PictureDataFromImage(img image.Image) *PictureData

PictureDataFromImage converts an image.Image into PictureData.

The resulting PictureData's Bounds will be the equivalent of the supplied image.Image's Bounds.

func PictureDataFromPicture 

func PictureDataFromPicture(pic Picture) *PictureData

PictureDataFromPicture converts an arbitrary Picture into PictureData (the conversion may be lossy, because PictureData works with unit-sized pixels).

Bounds are preserved.

func (*PictureData) Bounds 

func (pd *PictureData) Bounds() Rect

Bounds returns the bounds of this PictureData.

func (*PictureData) Color 

func (pd *PictureData) Color(at Vec) RGBA

Color returns the color located at the given position.

func (*PictureData) Image 

func (pd *PictureData) Image() *image.RGBA

Image converts PictureData into an image.RGBA.

The resulting image.RGBA's Bounds will be equivalent of the PictureData's Bounds.

func (*PictureData) Index 

func (pd *PictureData) Index(at Vec) int

Index returns the index of the pixel at the specified position inside the Pix slice.

type RGBA 

type RGBA struct {
	R, G, B, A float64
}

RGBA represents an alpha-premultiplied RGBA color with components within range [0, 1].

The difference between color.RGBA is that the value range is [0, 1] and the values are floats.

func Alpha 

func Alpha(a float64) RGBA

Alpha returns a white RGBA color with the given alpha component.

func RGB 

func RGB(r, g, b float64) RGBA

RGB returns a fully opaque RGBA color with the given RGB values.

A common way to construct a transparent color is to create one with RGB constructor, then multiply it by a color obtained from the Alpha constructor.

func ToRGBA 

func ToRGBA(c color.Color) RGBA

ToRGBA converts a color to RGBA format. Using this function is preferred to using RGBAModel, for performance (using RGBAModel introduces additional unnecessary allocations).

func (RGBA) Add 

func (c RGBA) Add(d RGBA) RGBA

Add adds color d to color c component-wise and returns the result (the components are not clamped).

func (RGBA) Mul 

func (c RGBA) Mul(d RGBA) RGBA

Mul multiplies color c by color d component-wise (the components are not clamped).

func (RGBA) RGBA 

func (c RGBA) RGBA() (r, g, b, a uint32)

RGBA returns alpha-premultiplied red, green, blue and alpha components of the RGBA color.

func (RGBA) Scaled 

func (c RGBA) Scaled(scale float64) RGBA

Scaled multiplies each component of color c by scale and returns the result (the components are not clamped).

func (RGBA) Sub 

func (c RGBA) Sub(d RGBA) RGBA

Sub subtracts color d from color c component-wise and returns the result (the components are not clamped).

type Rect 

type Rect struct {
	Min, Max Vec
}

Rect is a 2D rectangle aligned with the axes of the coordinate system. It is defined by two points, Min and Max.

The invariant should hold, that Max's components are greater or equal than Min's components respectively.

func R 

func R(minX, minY, maxX, maxY float64) Rect

R returns a new Rect with given the Min and Max coordinates.

Note that the returned rectangle is not automatically normalized.

func (Rect) AlignedTo 

func (rect Rect) AlignedTo(anchor Anchor) Rect

AlignedTo returns the rect moved by the given anchor.

func (Rect) AnchorPos 

func (r Rect) AnchorPos(anchor Anchor) Vec

AnchorPos returns the relative position of the given anchor.

func (Rect) Area 

func (r Rect) Area() float64

Area returns the area of r. If r is not normalized, area may be negative.

func (Rect) Bounds 

func (r Rect) Bounds() Rect

Bounds returns the bounding b ox for the rect (itself)

func (Rect) Center 

func (r Rect) Center() Vec

Center returns the position of the center of the Rect. `rect.Center()` is equivalent to `rect.Anchor(pixel.Anchor.Center)`

func (Rect) Contains 

func (r Rect) Contains(u Vec) bool

Contains checks whether a vector u is contained within this Rect (including it's borders).

func (Rect) Edges 

func (r Rect) Edges() [4]Line

Edges will return the four lines which make up the edges of the rectangle.

func (Rect) Empty added in v2.3.0 

func (r Rect) Empty() bool

Empty returns whether the Rect's Min and Max vectors are equal to ZV.

func (Rect) H 

func (r Rect) H() float64

H returns the height of the Rect.

func (Rect) Intersect 

func (r Rect) Intersect(s Rect) Rect

Intersect returns the maximal Rect which is covered by both r and s. Rects r and s must be normalized.

If r and s don't overlap, this function returns a zero-rectangle.

func (Rect) IntersectCircle 

func (r Rect) IntersectCircle(c Circle) Vec

IntersectCircle returns a minimal required Vector, such that moving the rect by that vector would stop the Circle and the Rect intersecting. This function returns a zero-vector if the Circle and Rect do not overlap, and if only the perimeters touch.

This function will return a non-zero vector if:

  • The Rect contains the Circle, partially or fully
  • The Circle contains the Rect, partially of fully

func (Rect) IntersectLine 

func (r Rect) IntersectLine(l Line) Vec

IntersectLine will return the shortest Vec such that if the Rect is moved by the Vec returned, the Line and Rect no longer intersect.

func (Rect) IntersectionPoints 

func (r Rect) IntersectionPoints(l Line) []Vec

IntersectionPoints returns all the points where the Rect intersects with the line provided. This can be zero, one or two points, depending on the location of the shapes. The points of intersection will be returned in order of closest-to-l.A to closest-to-l.B.

func (Rect) Intersects 

func (r Rect) Intersects(s Rect) bool

Intersects returns whether or not the given Rect intersects at any point with this Rect.

This function is overall about 5x faster than Intersect, so it is better to use if you have no need for the returned Rect from Intersect.

func (Rect) Moved 

func (r Rect) Moved(delta Vec) Rect

Moved returns the Rect moved (both Min and Max) by the given vector delta.

func (Rect) Norm 

func (r Rect) Norm() Rect

Norm returns the Rect in normal form, such that Max is component-wise greater or equal than Min.

func (Rect) Resized 

func (r Rect) Resized(anchor, size Vec) Rect

Resized returns the Rect resized to the given size while keeping the position of the given anchor. 

r.Resized(r.Min, size)      // resizes while keeping the position of the lower-left corner
r.Resized(r.Max, size)      // same with the top-right corner
r.Resized(r.Center(), size) // resizes around the center

This function does not make sense for resizing a rectangle of zero area and will panic. Use ResizedMin in the case of zero area.

func (Rect) ResizedMin 

func (r Rect) ResizedMin(size Vec) Rect

ResizedMin returns the Rect resized to the given size while keeping the position of the Rect's Min.

Sizes of zero area are safe here.

func (Rect) Size 

func (r Rect) Size() Vec

Size returns the vector of width and height of the Rect.

func (Rect) String 

func (r Rect) String() string

String returns the string representation of the Rect. 

r := pixel.R(100, 50, 200, 300)
r.String()     // returns "Rect(100, 50, 200, 300)"
fmt.Println(r) // Rect(100, 50, 200, 300)

func (Rect) Union 

func (r Rect) Union(s Rect) Rect

Union returns the minimal Rect which covers both r and s. Rects r and s must be normalized.

func (Rect) Vertices 

func (r Rect) Vertices() [4]Vec

Vertices returns a slice of the four corners which make up the rectangle.

func (Rect) W 

func (r Rect) W() float64

W returns the width of the Rect.

type Sprite 

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

Sprite is a drawable frame of a Picture. It's anchored by the center of it's Picture's frame.

Frame specifies a rectangular portion of the Picture that will be drawn. For example, this creates a Sprite that draws the whole Picture: 

sprite := pixel.NewSprite(pic, pic.Bounds())

Note, that Sprite caches the results of MakePicture from Targets it's drawn to for each Picture it's set to. What it means is that using a Sprite with an unbounded number of Pictures leads to a memory leak, since Sprite caches them and never forgets. In such a situation, create a new Sprite for each Picture.

func NewSprite 

func NewSprite(pic Picture, frame Rect) *Sprite

NewSprite creates a Sprite from the supplied frame of a Picture.

func (*Sprite) Draw 

func (s *Sprite) Draw(t Target, matrix Matrix)

Draw draws the Sprite onto the provided Target. The Sprite will be transformed by the given Matrix.

This method is equivalent to calling DrawColorMask with nil color mask.

func (*Sprite) DrawColorMask 

func (s *Sprite) DrawColorMask(t Target, matrix Matrix, mask color.Color)

DrawColorMask draws the Sprite onto the provided Target. The Sprite will be transformed by the given Matrix and all of it's color will be multiplied by the given mask.

If the mask is nil, a fully opaque white mask will be used, which causes no effect.

func (*Sprite) Frame 

func (s *Sprite) Frame() Rect

Frame returns the current Sprite's frame.

func (*Sprite) Picture 

func (s *Sprite) Picture() Picture

Picture returns the current Sprite's Picture.

func (*Sprite) Set 

func (s *Sprite) Set(pic Picture, frame Rect)

Set sets a new frame of a Picture for this Sprite.

func (*Sprite) SetCached 

func (s *Sprite) SetCached(cached bool)

SetCached makes the sprite cache all the incoming pictures if the argument is true, and doesn't make it do that if the argument is false.

type Target 

type Target interface {
	// MakeTriangles generates a specialized copy of the provided Triangles.
	//
	// When calling Draw method on the returned TargetTriangles, the TargetTriangles will be
	// drawn onto the Target that generated them.
	//
	// Note, that not every Target has to recognize all possible types of Triangles. Some may
	// only recognize TrianglesPosition and TrianglesColor and ignore all other properties (if
	// present) when making new TargetTriangles. This varies from Target to Target.
	MakeTriangles(Triangles) TargetTriangles

	// MakePicture generates a specialized copy of the provided Picture.
	//
	// When calling Draw method on the returned TargetPicture, the TargetPicture will be drawn
	// onto the Target that generated it together with the TargetTriangles supplied to the Draw
	// method.
	MakePicture(Picture) TargetPicture
}

Target is something that can be drawn onto, such as a window, a canvas, and so on.

You can notice, that there are no "drawing" methods in a Target. That's because all drawing happens indirectly through Triangles and Picture instances generated via MakeTriangles and MakePicture method.

type TargetPicture 

type TargetPicture interface {
	Picture

	// Draw draws the supplied TargetTriangles (which must be generated by the same Target as
	// this TargetPicture) with this TargetPicture. The TargetTriangles should utilize the data
	// from this TargetPicture in some way.
	Draw(TargetTriangles)
}

TargetPicture is a Picture generated by a Target using MakePicture method. This Picture can be drawn onto that (no other) Target together with a TargetTriangles generated by the same Target.

The TargetTriangles specify where, shape and how the Picture should be drawn.

type TargetTriangles 

type TargetTriangles interface {
	Triangles

	// Draw draws Triangles onto an associated Target.
	Draw()
}

TargetTriangles are Triangles generated by a Target with MakeTriangles method. They can be drawn onto that (no other) Target.

type Triangles 

type Triangles interface {
	// Len returns the number of vertices. The number of triangles is the number of vertices
	// divided by 3.
	Len() int

	// SetLen resizes Triangles to len vertices. If Triangles B were obtained by calling Slice
	// method on Triangles A, the relationship between A and B is undefined after calling SetLen
	// on either one of them.
	SetLen(len int)

	// Slice returns a sub-Triangles of this Triangles, covering vertices in range [i, j).
	//
	// If Triangles B were obtained by calling Slice(4, 9) on Triangles A, then A and B must
	// share the same underlying data. Modifying B must change the contents of A in range
	// [4, 9). The vertex with index 0 at B is the vertex with index 4 in A, and so on.
	//
	// Returned Triangles must have the same underlying type.
	Slice(i, j int) Triangles

	// Update copies vertex properties from the supplied Triangles into this Triangles.
	//
	// Properies not supported by these Triangles should be ignored. Properties not supported by
	// the supplied Triangles should be left untouched.
	//
	// The two Triangles must have the same Len.
	Update(Triangles)

	// Copy creates an exact independent copy of this Triangles (with the same underlying type).
	Copy() Triangles
}

Triangles represents a list of vertices, where each three vertices form a triangle. (First, second and third is the first triangle, fourth, fifth and sixth is the second triangle, etc.)

type TrianglesClipped 

type TrianglesClipped interface {
	Triangles
	ClipRect(i int) (rect Rect, is bool)
}

TrianglesClipped specifies Triangles with Clipping Rectangle property.

The first value returned from ClipRect method is the clipping rectangle. The second one specifies if the triangle is clipped.

type TrianglesColor 

type TrianglesColor interface {
	Triangles
	Color(i int) RGBA
}

TrianglesColor specifies Triangles with Color property.

type TrianglesData 

type TrianglesData []struct {
	Position  Vec
	Color     RGBA
	Picture   Vec
	Intensity float64
	ClipRect  Rect
	IsClipped bool
}

TrianglesData specifies a list of Triangles vertices with three common properties: TrianglesPosition, TrianglesColor and TrianglesPicture.

func MakeTrianglesData 

func MakeTrianglesData(len int) *TrianglesData

MakeTrianglesData creates TrianglesData of length len initialized with default property values.

Prefer this function to make(TrianglesData, len), because make zeros them, while this function does the correct intialization.

func (*TrianglesData) ClipRect 

func (td *TrianglesData) ClipRect(i int) (rect Rect, has bool)

ClipRect returns the clipping rectangle property of the i-th vertex.

func (*TrianglesData) Color 

func (td *TrianglesData) Color(i int) RGBA

Color returns the color property of i-th vertex.

func (*TrianglesData) Copy 

func (td *TrianglesData) Copy() Triangles

Copy returns an exact independent copy of this TrianglesData.

func (*TrianglesData) Len 

func (td *TrianglesData) Len() int

Len returns the number of vertices in TrianglesData.

func (*TrianglesData) Picture 

func (td *TrianglesData) Picture(i int) (pic Vec, intensity float64)

Picture returns the picture property of i-th vertex.

func (*TrianglesData) Position 

func (td *TrianglesData) Position(i int) Vec

Position returns the position property of i-th vertex.

func (*TrianglesData) SetLen 

func (td *TrianglesData) SetLen(len int)

SetLen resizes TrianglesData to len, while keeping the original content.

If len is greater than TrianglesData's current length, the new data is filled with default values ((0, 0), white, (0, 0), 0).

func (*TrianglesData) Slice 

func (td *TrianglesData) Slice(i, j int) Triangles

Slice returns a sub-Triangles of this TrianglesData.

func (*TrianglesData) Update 

func (td *TrianglesData) Update(t Triangles)

Update copies vertex properties from the supplied Triangles into this TrianglesData.

TrianglesPosition, TrianglesColor and TrianglesTexture are supported.

type TrianglesPicture 

type TrianglesPicture interface {
	Triangles
	Picture(i int) (pic Vec, intensity float64)
}

TrianglesPicture specifies Triangles with Picture property.

The first value returned from Picture method is Picture coordinates. The second one specifies the weight of the Picture. Value of 0 means, that Picture should be completely ignored, 1 means that is should be fully included and anything in between means anything in between.

type TrianglesPosition 

type TrianglesPosition interface {
	Triangles
	Position(i int) Vec
}

TrianglesPosition specifies Triangles with Position property.

type Vec 

type Vec struct {
	X, Y float64
}

Vec is a 2D vector type with X and Y coordinates.

Create vectors with the V constructor: 

u := pixel.V(1, 2)
v := pixel.V(8, -3)

Use various methods to manipulate them: 

  w := u.Add(v)
  fmt.Println(w)        // Vec(9, -1)
  fmt.Println(u.Sub(v)) // Vec(-7, 5)
  u = pixel.V(2, 3)
  v = pixel.V(8, 1)
  if u.X < 0 {
	     fmt.Println("this won't happen")
  }
  x := u.Unit().Dot(v.Unit())

func Lerp 

func Lerp(a, b Vec, t float64) Vec

Lerp returns a linear interpolation between vectors a and b.

This function basically returns a point along the line between a and b and t chooses which one. If t is 0, then a will be returned, if t is 1, b will be returned. Anything between 0 and 1 will return the appropriate point between a and b and so on.

func Unit 

func Unit(angle float64) Vec

Unit returns a vector of length 1 facing the given angle.

func V 

func V(x, y float64) Vec

V returns a new 2D vector with the given coordinates.

func (Vec) Add 

func (u Vec) Add(v Vec) Vec

Add returns the sum of vectors u and v.

func (Vec) Angle 

func (u Vec) Angle() float64

Angle returns the angle between the vector u and the x-axis. The result is in range [-Pi, Pi].

func (Vec) Cross 

func (u Vec) Cross(v Vec) float64

Cross return the cross product of vectors u and v.

func (Vec) Dot 

func (u Vec) Dot(v Vec) float64

Dot returns the dot product of vectors u and v.

func (Vec) Eq 

func (u Vec) Eq(v Vec) bool

Eq will compare two vectors and return whether they are equal accounting for rounding errors. At worst, the result is correct to 7 significant digits.

func (Vec) Floor 

func (u Vec) Floor() Vec

Floor converts x and y to their integer equivalents.

func (Vec) Len 

func (u Vec) Len() float64

Len returns the length of the vector u.

func (Vec) Map 

func (u Vec) Map(f func(float64) float64) Vec

Map applies the function f to both x and y components of the vector u and returns the modified vector. 

u := pixel.V(10.5, -1.5)
v := u.Map(math.Floor)   // v is Vec(10, -2), both components of u floored

func (Vec) Normal 

func (u Vec) Normal() Vec

Normal returns a vector normal to u. Equivalent to u.Rotated(math.Pi / 2), but faster.

func (Vec) Project 

func (u Vec) Project(v Vec) Vec

Project returns a projection (or component) of vector u in the direction of vector v.

Behaviour is undefined if v is a zero vector.

func (Vec) Rotated 

func (u Vec) Rotated(angle float64) Vec

Rotated returns the vector u rotated by the given angle in radians.

func (Vec) Scaled 

func (u Vec) Scaled(c float64) Vec

Scaled returns the vector u multiplied by c.

func (Vec) ScaledXY 

func (u Vec) ScaledXY(v Vec) Vec

ScaledXY returns the vector u multiplied by the vector v component-wise.

func (Vec) SqLen 

func (u Vec) SqLen() float64

SqLen returns the squared length of the vector u (faster to compute than Len).

func (Vec) String 

func (u Vec) String() string

String returns the string representation of the vector u. 

u := pixel.V(4.5, -1.3)
u.String()     // returns "Vec(4.5, -1.3)"
fmt.Println(u) // Vec(4.5, -1.3)

func (Vec) Sub 

func (u Vec) Sub(v Vec) Vec

Sub returns the difference betweeen vectors u and v.

func (Vec) To 

func (u Vec) To(v Vec) Vec

To returns the vector from u to v. Equivalent to v.Sub(u).

func (Vec) Unit 

func (u Vec) Unit() Vec

Unit returns a vector of length 1 facing the direction of u (has the same angle).

func (Vec) XY 

func (u Vec) XY() (x, y float64)

XY returns the components of the vector in two return values.

Source Files

View all Source files

Directories

Path Synopsis
backends
internal
opengl
Package opengl implements efficient OpenGL targets and utilities for the Pixel game development library, specifically Window and Canvas.
 Package opengl implements efficient OpenGL targets and utilities for the Pixel game development library, specifically Window and Canvas.
ext
atlas
gameloop
imdraw
Package imdraw implements a basic primitive geometry shape and pictured polygon drawing for Pixel with a nice immediate-mode-like API.
 Package imdraw implements a basic primitive geometry shape and pictured polygon drawing for Pixel with a nice immediate-mode-like API.
text
Package text implements efficient text drawing for the Pixel library.
 Package text implements efficient text drawing for the Pixel library.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.