A rendering engine library for Go supporting both SDL2 and WebAssembly (HTML Canvas) targets.
Go to file
Noah a8da853de0 SDL: Support textures regenerating when flushed
* We store a Go image.Image copy of all textures in the SDL2 renderer.
* When the underlying SDL2 textures are freed, regenerate them when
  needed from the underlying Go Image.
2024-02-11 16:45:49 -08:00
canvas Functions to free up (SDL2) texture memory 2022-04-09 14:25:56 -07:00
event SDL2 GameController Support 2022-02-19 18:22:55 -08:00
examples Change public API to use int instead of int32 everywhere 2019-12-27 17:35:42 -08:00
sdl SDL: Support textures regenerating when flushed 2024-02-11 16:45:49 -08:00
.gitignore Add WebAssembly Hello World Example 2019-12-22 16:26:33 -08:00
LICENSE.md Clean up repository for stand-alone release 2019-12-22 15:53:52 -08:00
README.md Fix README for github URL 2021-10-06 22:19:19 -07:00
color.go Add support for SDL2 MultiGestureEvents 2021-10-06 19:35:24 -07:00
ellipse.go Better Ellipse Drawing Algorithm 2019-07-16 18:27:00 -07:00
functions.go Change public API to use int instead of int32 everywhere 2019-12-27 17:35:42 -08:00
go.mod Make it a Go module + minor tweaks 2020-03-09 17:28:49 -07:00
go.sum Maximize SDL2 window 2020-07-09 19:32:47 -07:00
image.go Make it a Go module + minor tweaks 2020-03-09 17:28:49 -07:00
interface.go Functions to free up (SDL2) texture memory 2022-04-09 14:25:56 -07:00
point.go Add Point Comparator Function and Tests 2020-04-06 22:59:40 -07:00
point_test.go Add Point Comparator Function and Tests 2020-04-06 22:59:40 -07:00
rect.go Bugfix in Rect.Intersects() 2021-10-09 21:33:13 -07:00
rect_test.go Change public API to use int instead of int32 everywhere 2019-12-27 17:35:42 -08:00
shapes.go Change public API to use int instead of int32 everywhere 2019-12-27 17:35:42 -08:00
text.go SetWindowIcon for SDL2 and Text.Update() 2021-12-30 16:39:48 -08:00
version.go Make it a Go module + minor tweaks 2020-03-09 17:28:49 -07:00

README.md

Render: Go Graphics Library

GoDoc

Render is a graphics rendering library for Go.

It supports SDL2 and HTML Canvas back-ends enabling its use for both desktop applications (Linux, Mac and Windows) and WebAssembly modules for running in the web browser.

Screenshot

Notice: github.com/SketchyMaze/render is a mirror to the upstream repository at git.kirsle.net/go/render. Issues and pull requests will be accepted at GitHub.

Example

package main

import (
    "git.kirsle.net/go/render"
    "git.kirsle.net/go/render/sdl"
)

func main() {
    mw := sdl.New("Hello World", 320, 240)

    if err := mw.Setup(); err != nil {
        panic(err)
    }

    // Text that we're gonna draw in the window.
    text := render.Text{
        Text:         "Hello, world!",
        Size:         24,
        Color:        render.SkyBlue,
        Shadow:       render.Blue,
        FontFilename: "DejaVuSans.ttf",
    }

    // Compute the rendered size of the text.
    rect, _ := mw.ComputeTextRect(text)

    for {
        // Blank the window.
        mw.Clear(render.White)

        // Poll for events (mouse clicks, keyboard keys, etc.)
        ev, err := mw.Poll()
        if err != nil {
            panic(err)
        }

        // Escape key closes the window.
        if ev.Escape {
            mw.Teardown()
            break
        }

        // Get the window size.
        w, h := mw.WindowSize()

        // Draw the text centered in the window.
        mw.DrawText(text, render.NewPoint(
            (w/2) - (rect.W/2),
            (h/2) - (rect.H/2),
        ))

        mw.Present()
    }
}

See the examples/ directory for examples. More will come eventually, including some WebAssembly examples.

Project Status: Alpha

This module was written as part of my drawing-based maze game, code named Project: Doodle. It is currently in alpha status and its API may change and be cleaned up in the future.

Drawing Methods (Engine)

This package provides some basic primitive drawing methods which are implemented for SDL2 (desktops) and HTML Canvas (WebAssembly). See the render.Engine interface. The drawing methods supported are:

  • Clear(Color): blank the window and fill it with this color.
  • DrawPoint(Color, Point): draw a single pixel at a coordinate.
  • DrawLine(Color, A Point, B Point): draw a line between two points.
  • DrawRect(Color, Rect): draw a rectangle outline between two points.
  • DrawBox(Color, Rect): draw a filled rectangle between two points.
  • DrawText(Text, Point): draw text at a location.
  • StoreTexture(name string, image.Image): load a Go image.Image object into the engine as a "texture" that can be re-used and pasted on the canvas.
  • LoadTexture(filename string): load an image from disk into a texture.
  • Copy(Texturer, src Rect, dst Rect): copy a texture onto the canvas.

Drawing Types

This package defines a handful of types useful for drawing operations. See the godoc for full details.

  • Color: an RGBA color holding uint8 values for each channel.
    • NewRGBA(red, green, blue, alpha uint8) to construct a new color.
  • Point: holds an X,Y pair of coordinates.
  • Rect: holds an X,Y and a W,H value.
  • Text: holds text and configuration for rendering (color, stroke, shadow, size, etc.)

Shape Generator Functions

The render package includes a few convenience functions for drawing complex shapes.

The generator functions return a channel that yields all of the Points that should be drawn to complete the shape. Example:

var (
    A Point = render.NewPoint(10, 10)
    B Point = render.NewPoint(15, 20)
)

for pt := range render.IterLine(A, B) {
    engine.DrawPoint(render.Red, pt)
}
  • IterLine(A Point, B Point): draw a line from A to B.
  • IterRect(A Point, B Point): iterate all the points to draw a rectangle.
  • IterEllipse(A Point, B Point): draw an elipse fitting inside the rectangle bounded by points A and B.

Multitouch Gesture Notes

Support for SDL2's MultiGestureEvent is added on October 6 2021. The event.State will have the property Touching=true while the engine believes multitouch gestures are afoot. This begins when the user touches the screen with two fingers, and then motion is detected.

SDL2 spams us with gesture events for each tiny change detected, and then just stops. The SDL driver in this repo doesn't set ev.State.Touching=false. One heuristic you may use in your program to detect when multitouch has ended is this:

SDL2 always emulates the mouse Button1 click for one of the fingers. Record the position at the first Touching=true event, and monitor for delta changes in position as the "mouse cursor" moves. When delta movements become stale and don't update, you can set State.Touching=false in your program.

License

MIT.