Remove everything that might depend on cgo

fixed text rendering test case

backend/goglbackend/clip.go

@@ -1,74 +0,0 @@
-package goglbackend
-
-import (
-	"unsafe"
-
-	"github.com/tfriedel6/canvas/backend/backendbase"
-	"github.com/tfriedel6/canvas/backend/goglbackend/gl"
-)
-
-func (b *GoGLBackend) ClearClip() {
-	b.activate()
-
-	gl.StencilMask(0xFF)
-	gl.Clear(gl.STENCIL_BUFFER_BIT)
-}
-
-func (b *GoGLBackend) Clip(pts []backendbase.Vec) {
-	b.activate()
-
-	b.ptsBuf = b.ptsBuf[:0]
-	b.ptsBuf = append(b.ptsBuf,
-		0, 0,
-		0, float32(b.fh),
-		float32(b.fw), float32(b.fh),
-		float32(b.fw), 0)
-	for _, pt := range pts {
-		b.ptsBuf = append(b.ptsBuf, float32(pt[0]), float32(pt[1]))
-	}
-
-	mode := uint32(gl.TRIANGLES)
-	if len(pts) == 4 {
-		mode = gl.TRIANGLE_FAN
-	}
-
-	gl.BindBuffer(gl.ARRAY_BUFFER, b.buf)
-	gl.BufferData(gl.ARRAY_BUFFER, len(b.ptsBuf)*4, unsafe.Pointer(&b.ptsBuf[0]), gl.STREAM_DRAW)
-	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
-
-	gl.UseProgram(b.shd.ID)
-	gl.Uniform4f(b.shd.Color, 1, 1, 1, 1)
-	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
-	gl.UniformMatrix3fv(b.shd.Matrix, 1, false, &mat3identity[0])
-	gl.Uniform1f(b.shd.GlobalAlpha, 1)
-	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.Func, shdFuncSolid)
-	gl.EnableVertexAttribArray(b.shd.Vertex)
-
-	gl.ColorMask(false, false, false, false)
-
-	// set bit 2 in the stencil buffer in the given shape
-	gl.StencilMask(0x04)
-	gl.StencilFunc(gl.ALWAYS, 4, 0)
-	gl.StencilOp(gl.REPLACE, gl.REPLACE, gl.REPLACE)
-	gl.DrawArrays(mode, 4, int32(len(pts)))
-
-	// on entire screen, where neither bit 1 or 2 are set, invert bit 1
-	gl.StencilMask(0x02)
-	gl.StencilFunc(gl.EQUAL, 0, 0x06)
-	gl.StencilOp(gl.KEEP, gl.INVERT, gl.INVERT)
-	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-
-	// on entire screen, clear bit 2
-	gl.StencilMask(0x04)
-	gl.StencilFunc(gl.ALWAYS, 0, 0)
-	gl.StencilOp(gl.ZERO, gl.ZERO, gl.ZERO)
-	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-
-	gl.DisableVertexAttribArray(b.shd.Vertex)
-
-	gl.ColorMask(true, true, true, true)
-	gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
-	gl.StencilMask(0xFF)
-	gl.StencilFunc(gl.EQUAL, 0, 0xFF)
-}

backend/goglbackend/fill.go

@@ -1,327 +0,0 @@
-package goglbackend
-
-import (
-	"image"
-	"math"
-	"unsafe"
-
-	"github.com/tfriedel6/canvas/backend/backendbase"
-	"github.com/tfriedel6/canvas/backend/goglbackend/gl"
-)
-
-func (b *GoGLBackend) Clear(pts [4]backendbase.Vec) {
-	b.activate()
-
-	// first check if the four points are aligned to form a nice rectangle, which can be more easily
-	// cleared using glScissor and glClear
-	aligned := pts[0][0] == pts[1][0] && pts[2][0] == pts[3][0] && pts[0][1] == pts[3][1] && pts[1][1] == pts[2][1]
-	if !aligned {
-		aligned = pts[0][0] == pts[3][0] && pts[1][0] == pts[2][0] && pts[0][1] == pts[1][1] && pts[2][1] == pts[3][1]
-	}
-	if aligned {
-		minX := math.Floor(math.Min(pts[0][0], pts[2][0]))
-		maxX := math.Ceil(math.Max(pts[0][0], pts[2][0]))
-		minY := math.Floor(math.Min(pts[0][1], pts[2][1]))
-		maxY := math.Ceil(math.Max(pts[0][1], pts[2][1]))
-		b.clearRect(int(minX), int(minY), int(maxX)-int(minX), int(maxY)-int(minY))
-		return
-	}
-
-	data := [8]float32{
-		float32(pts[0][0]), float32(pts[0][1]),
-		float32(pts[1][0]), float32(pts[1][1]),
-		float32(pts[2][0]), float32(pts[2][1]),
-		float32(pts[3][0]), float32(pts[3][1])}
-
-	gl.UseProgram(b.shd.ID)
-	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
-	gl.UniformMatrix3fv(b.shd.Matrix, 1, false, &mat3identity[0])
-	gl.Uniform4f(b.shd.Color, 0, 0, 0, 0)
-	gl.Uniform1f(b.shd.GlobalAlpha, 1)
-	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.Func, shdFuncSolid)
-
-	gl.Disable(gl.BLEND)
-
-	gl.BindBuffer(gl.ARRAY_BUFFER, b.buf)
-	gl.BufferData(gl.ARRAY_BUFFER, len(data)*4, unsafe.Pointer(&data[0]), gl.STREAM_DRAW)
-
-	gl.StencilFunc(gl.EQUAL, 0, 0xFF)
-
-	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
-	gl.EnableVertexAttribArray(b.shd.Vertex)
-	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-	gl.DisableVertexAttribArray(b.shd.Vertex)
-
-	gl.StencilFunc(gl.ALWAYS, 0, 0xFF)
-
-	gl.Enable(gl.BLEND)
-}
-
-func (b *GoGLBackend) clearRect(x, y, w, h int) {
-	gl.Enable(gl.SCISSOR_TEST)
-
-	var box [4]int32
-	gl.GetIntegerv(gl.SCISSOR_BOX, &box[0])
-
-	gl.Scissor(int32(x), int32(b.h-y-h), int32(w), int32(h))
-	gl.ClearColor(0, 0, 0, 0)
-	gl.Clear(gl.COLOR_BUFFER_BIT)
-	gl.Scissor(box[0], box[1], box[2], box[3])
-
-	gl.Disable(gl.SCISSOR_TEST)
-}
-
-func extent(pts []backendbase.Vec) (min, max backendbase.Vec) {
-	max[0] = -math.MaxFloat64
-	max[1] = -math.MaxFloat64
-	min[0] = math.MaxFloat64
-	min[1] = math.MaxFloat64
-	for _, v := range pts {
-		min[0] = math.Min(min[0], v[0])
-		min[1] = math.Min(min[1], v[1])
-		max[0] = math.Max(max[0], v[0])
-		max[1] = math.Max(max[1], v[1])
-	}
-	return
-}
-
-func (b *GoGLBackend) Fill(style *backendbase.FillStyle, pts []backendbase.Vec, tf backendbase.Mat, canOverlap bool) {
-	b.activate()
-
-	if style.Blur > 0 {
-		b.offscr1.alpha = true
-		b.enableTextureRenderTarget(&b.offscr1)
-		gl.ClearColor(0, 0, 0, 0)
-		gl.Clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
-	}
-
-	b.ptsBuf = b.ptsBuf[:0]
-	min, max := extent(pts)
-	b.ptsBuf = append(b.ptsBuf,
-		float32(min[0]), float32(min[1]),
-		float32(min[0]), float32(max[1]),
-		float32(max[0]), float32(max[1]),
-		float32(max[0]), float32(min[1]))
-	for _, pt := range pts {
-		b.ptsBuf = append(b.ptsBuf, float32(pt[0]), float32(pt[1]))
-	}
-
-	mode := uint32(gl.TRIANGLES)
-	if len(pts) == 4 {
-		mode = gl.TRIANGLE_FAN
-	}
-
-	gl.BindBuffer(gl.ARRAY_BUFFER, b.buf)
-	gl.BufferData(gl.ARRAY_BUFFER, len(b.ptsBuf)*4, unsafe.Pointer(&b.ptsBuf[0]), gl.STREAM_DRAW)
-
-	if !canOverlap || style.Color.A >= 255 {
-		vertex, _ := b.useShader(style, mat3(tf), false, 0)
-
-		gl.StencilFunc(gl.EQUAL, 0, 0xFF)
-		gl.EnableVertexAttribArray(vertex)
-		gl.VertexAttribPointer(vertex, 2, gl.FLOAT, false, 0, nil)
-		gl.DrawArrays(mode, 4, int32(len(pts)))
-		gl.DisableVertexAttribArray(vertex)
-		gl.StencilFunc(gl.ALWAYS, 0, 0xFF)
-	} else {
-		gl.ColorMask(false, false, false, false)
-		gl.StencilFunc(gl.ALWAYS, 1, 0xFF)
-		gl.StencilOp(gl.REPLACE, gl.REPLACE, gl.REPLACE)
-		gl.StencilMask(0x01)
-
-		gl.UseProgram(b.shd.ID)
-		gl.Uniform4f(b.shd.Color, 0, 0, 0, 0)
-		gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
-		m3 := mat3(tf)
-		gl.UniformMatrix3fv(b.shd.Matrix, 1, false, &m3[0])
-		gl.Uniform1f(b.shd.GlobalAlpha, 1)
-		gl.Uniform1i(b.shd.UseAlphaTex, 0)
-		gl.Uniform1i(b.shd.Func, shdFuncSolid)
-
-		gl.EnableVertexAttribArray(b.shd.Vertex)
-		gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
-		gl.DrawArrays(mode, 4, int32(len(pts)))
-		gl.DisableVertexAttribArray(b.shd.Vertex)
-
-		gl.ColorMask(true, true, true, true)
-
-		gl.StencilFunc(gl.EQUAL, 1, 0xFF)
-
-		vertex, _ := b.useShader(style, mat3identity, false, 0)
-		gl.EnableVertexAttribArray(vertex)
-		gl.VertexAttribPointer(vertex, 2, gl.FLOAT, false, 0, nil)
-
-		gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-		gl.DisableVertexAttribArray(vertex)
-
-		gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
-		gl.StencilFunc(gl.ALWAYS, 0, 0xFF)
-
-		gl.Clear(gl.STENCIL_BUFFER_BIT)
-		gl.StencilMask(0xFF)
-	}
-
-	if style.Blur > 0 {
-		b.drawBlurred(style.Blur, min, max)
-	}
-}
-
-func (b *GoGLBackend) FillImageMask(style *backendbase.FillStyle, mask *image.Alpha, pts [4]backendbase.Vec) {
-	b.activate()
-
-	w, h := mask.Rect.Dx(), mask.Rect.Dy()
-
-	gl.ActiveTexture(gl.TEXTURE1)
-	gl.BindTexture(gl.TEXTURE_2D, b.alphaTex)
-	gl.TexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, int32(mask.Stride), int32(h), gl.ALPHA, gl.UNSIGNED_BYTE, gl.Ptr(&mask.Pix[0]))
-	if w < alphaTexSize {
-		gl.TexSubImage2D(gl.TEXTURE_2D, 0, int32(w), 0, 1, int32(h), gl.ALPHA, gl.UNSIGNED_BYTE, gl.Ptr(&zeroes[0]))
-	}
-	if h < alphaTexSize {
-		gl.TexSubImage2D(gl.TEXTURE_2D, 0, 0, int32(h), int32(w), 1, gl.ALPHA, gl.UNSIGNED_BYTE, gl.Ptr(&zeroes[0]))
-	}
-
-	if style.Blur > 0 {
-		b.offscr1.alpha = true
-		b.enableTextureRenderTarget(&b.offscr1)
-		gl.ClearColor(0, 0, 0, 0)
-		gl.Clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
-	}
-
-	gl.StencilFunc(gl.EQUAL, 0, 0xFF)
-
-	gl.BindBuffer(gl.ARRAY_BUFFER, b.buf)
-
-	vertex, alphaTexCoord := b.useShader(style, mat3identity, true, 1)
-
-	gl.EnableVertexAttribArray(vertex)
-	gl.EnableVertexAttribArray(alphaTexCoord)
-
-	tw := float64(w) / alphaTexSize
-	th := float64(h) / alphaTexSize
-	var buf [16]float32
-	data := buf[:0]
-	for _, pt := range pts {
-		data = append(data, float32(math.Round(pt[0])), float32(math.Round(pt[1])))
-	}
-	data = append(data, 0, 0, 0, float32(th), float32(tw), float32(th), float32(tw), 0)
-
-	gl.BufferData(gl.ARRAY_BUFFER, len(data)*4, unsafe.Pointer(&data[0]), gl.STREAM_DRAW)
-
-	gl.VertexAttribPointer(vertex, 2, gl.FLOAT, false, 0, nil)
-	gl.VertexAttribPointer(alphaTexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
-	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-
-	gl.DisableVertexAttribArray(vertex)
-	gl.DisableVertexAttribArray(alphaTexCoord)
-
-	gl.ActiveTexture(gl.TEXTURE1)
-	gl.BindTexture(gl.TEXTURE_2D, b.alphaTex)
-
-	gl.StencilFunc(gl.ALWAYS, 0, 0xFF)
-
-	gl.ActiveTexture(gl.TEXTURE0)
-
-	if style.Blur > 0 {
-		min, max := extent(pts[:])
-		b.drawBlurred(style.Blur, min, max)
-	}
-}
-
-func (b *GoGLBackend) drawBlurred(size float64, min, max backendbase.Vec) {
-	b.offscr1.alpha = true
-	b.offscr2.alpha = true
-
-	// calculate box blur size
-	fsize := math.Max(1, math.Floor(size))
-	sizea := int(fsize)
-	sizeb := sizea
-	sizec := sizea
-	if size-fsize > 0.333333333 {
-		sizeb++
-	}
-	if size-fsize > 0.666666666 {
-		sizec++
-	}
-
-	min[0] -= fsize * 3
-	min[1] -= fsize * 3
-	max[0] += fsize * 3
-	max[1] += fsize * 3
-	min[0] = math.Max(0.0, math.Min(b.fw, min[0]))
-	min[1] = math.Max(0.0, math.Min(b.fh, min[1]))
-	max[0] = math.Max(0.0, math.Min(b.fw, max[0]))
-	max[1] = math.Max(0.0, math.Min(b.fh, max[1]))
-
-	gl.BindBuffer(gl.ARRAY_BUFFER, b.shadowBuf)
-	data := [16]float32{
-		float32(min[0]), float32(min[1]),
-		float32(min[0]), float32(max[1]),
-		float32(max[0]), float32(max[1]),
-		float32(max[0]), float32(min[1]),
-		float32(min[0] / b.fw), 1 - float32(min[1]/b.fh),
-		float32(min[0] / b.fw), 1 - float32(max[1]/b.fh),
-		float32(max[0] / b.fw), 1 - float32(max[1]/b.fh),
-		float32(max[0] / b.fw), 1 - float32(min[1]/b.fh),
-	}
-	gl.BufferData(gl.ARRAY_BUFFER, len(data)*4, unsafe.Pointer(&data[0]), gl.STREAM_DRAW)
-
-	gl.UseProgram(b.shd.ID)
-	gl.Uniform1i(b.shd.Image, 0)
-	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
-	gl.UniformMatrix3fv(b.shd.Matrix, 1, false, &mat3identity[0])
-	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.Func, shdFuncBoxBlur)
-
-	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
-	gl.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
-	gl.EnableVertexAttribArray(b.shd.Vertex)
-	gl.EnableVertexAttribArray(b.shd.TexCoord)
-
-	gl.Disable(gl.BLEND)
-
-	gl.ActiveTexture(gl.TEXTURE0)
-
-	gl.ClearColor(0, 0, 0, 0)
-
-	b.enableTextureRenderTarget(&b.offscr2)
-	gl.BindTexture(gl.TEXTURE_2D, b.offscr1.tex)
-	gl.Clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
-	b.box3(sizea, 0, false)
-	b.enableTextureRenderTarget(&b.offscr1)
-	gl.BindTexture(gl.TEXTURE_2D, b.offscr2.tex)
-	b.box3(sizeb, -0.5, false)
-	b.enableTextureRenderTarget(&b.offscr2)
-	gl.BindTexture(gl.TEXTURE_2D, b.offscr1.tex)
-	b.box3(sizec, 0, false)
-	b.enableTextureRenderTarget(&b.offscr1)
-	gl.BindTexture(gl.TEXTURE_2D, b.offscr2.tex)
-	b.box3(sizea, 0, true)
-	b.enableTextureRenderTarget(&b.offscr2)
-	gl.BindTexture(gl.TEXTURE_2D, b.offscr1.tex)
-	b.box3(sizeb, -0.5, true)
-	gl.Enable(gl.BLEND)
-	gl.BlendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA)
-	b.disableTextureRenderTarget()
-	gl.BindTexture(gl.TEXTURE_2D, b.offscr2.tex)
-	b.box3(sizec, 0, true)
-
-	gl.DisableVertexAttribArray(b.shd.Vertex)
-	gl.DisableVertexAttribArray(b.shd.TexCoord)
-
-	gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
-}
-
-func (b *GoGLBackend) box3(size int, offset float32, vertical bool) {
-	gl.Uniform1i(b.shd.BoxSize, int32(size))
-	if vertical {
-		gl.Uniform1i(b.shd.BoxVertical, 1)
-		gl.Uniform1f(b.shd.BoxScale, 1/float32(b.fh))
-	} else {
-		gl.Uniform1i(b.shd.BoxVertical, 0)
-		gl.Uniform1f(b.shd.BoxScale, 1/float32(b.fw))
-	}
-	gl.Uniform1f(b.shd.BoxOffset, offset)
-	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-}

backend/goglbackend/gl/conversions.go

@@ -1,109 +0,0 @@
-// Code generated by glow (https://github.com/go-gl/glow). DO NOT EDIT.
-
-package gl
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"unsafe"
-)
-
-// #include <stdlib.h>
-import "C"
-
-// Ptr takes a slice or pointer (to a singular scalar value or the first
-// element of an array or slice) and returns its GL-compatible address.
-//
-// For example:
-//
-// 	var data []uint8
-// 	...
-// 	gl.TexImage2D(gl.TEXTURE_2D, ..., gl.UNSIGNED_BYTE, gl.Ptr(&data[0]))
-func Ptr(data interface{}) unsafe.Pointer {
-	if data == nil {
-		return unsafe.Pointer(nil)
-	}
-	var addr unsafe.Pointer
-	v := reflect.ValueOf(data)
-	switch v.Type().Kind() {
-	case reflect.Ptr:
-		e := v.Elem()
-		switch e.Kind() {
-		case
-			reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
-			reflect.Float32, reflect.Float64:
-			addr = unsafe.Pointer(e.UnsafeAddr())
-		default:
-			panic(fmt.Errorf("unsupported pointer to type %s; must be a slice or pointer to a singular scalar value or the first element of an array or slice", e.Kind()))
-		}
-	case reflect.Uintptr:
-		addr = unsafe.Pointer(v.Pointer())
-	case reflect.Slice:
-		addr = unsafe.Pointer(v.Index(0).UnsafeAddr())
-	default:
-		panic(fmt.Errorf("unsupported type %s; must be a slice or pointer to a singular scalar value or the first element of an array or slice", v.Type()))
-	}
-	return addr
-}
-
-// PtrOffset takes a pointer offset and returns a GL-compatible pointer.
-// Useful for functions such as glVertexAttribPointer that take pointer
-// parameters indicating an offset rather than an absolute memory address.
-func PtrOffset(offset int) unsafe.Pointer {
-	return unsafe.Pointer(uintptr(offset))
-}
-
-// Str takes a null-terminated Go string and returns its GL-compatible address.
-// This function reaches into Go string storage in an unsafe way so the caller
-// must ensure the string is not garbage collected.
-func Str(str string) *uint8 {
-	if !strings.HasSuffix(str, "\x00") {
-		panic("str argument missing null terminator: " + str)
-	}
-	header := (*reflect.StringHeader)(unsafe.Pointer(&str))
-	return (*uint8)(unsafe.Pointer(header.Data))
-}
-
-// GoStr takes a null-terminated string returned by OpenGL and constructs a
-// corresponding Go string.
-func GoStr(cstr *uint8) string {
-	return C.GoString((*C.char)(unsafe.Pointer(cstr)))
-}
-
-// Strs takes a list of Go strings (with or without null-termination) and
-// returns their C counterpart.
-//
-// The returned free function must be called once you are done using the strings
-// in order to free the memory.
-//
-// If no strings are provided as a parameter this function will panic.
-func Strs(strs ...string) (cstrs **uint8, free func()) {
-	if len(strs) == 0 {
-		panic("Strs: expected at least 1 string")
-	}
-
-	// Allocate a contiguous array large enough to hold all the strings' contents.
-	n := 0
-	for i := range strs {
-		n += len(strs[i])
-	}
-	data := C.malloc(C.size_t(n))
-
-	// Copy all the strings into data.
-	dataSlice := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
-		Data: uintptr(data),
-		Len:  n,
-		Cap:  n,
-	}))
-	css := make([]*uint8, len(strs)) // Populated with pointers to each string.
-	offset := 0
-	for i := range strs {
-		copy(dataSlice[offset:offset+len(strs[i])], strs[i][:]) // Copy strs[i] into proper data location.
-		css[i] = (*uint8)(unsafe.Pointer(&dataSlice[offset]))   // Set a pointer to it.
-		offset += len(strs[i])
-	}
-
-	return (**uint8)(&css[0]), func() { C.free(data) }
-}

backend/goglbackend/gl/khrplatform.h

@@ -1,282 +0,0 @@
-#ifndef __khrplatform_h_
-#define __khrplatform_h_
-
-/*
-** Copyright (c) 2008-2009 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-
-/* Khronos platform-specific types and definitions.
- *
- * $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
- *
- * Adopters may modify this file to suit their platform. Adopters are
- * encouraged to submit platform specific modifications to the Khronos
- * group so that they can be included in future versions of this file.
- * Please submit changes by sending them to the public Khronos Bugzilla
- * (http://khronos.org/bugzilla) by filing a bug against product
- * "Khronos (general)" component "Registry".
- *
- * A predefined template which fills in some of the bug fields can be
- * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
- * must create a Bugzilla login first.
- *
- *
- * See the Implementer's Guidelines for information about where this file
- * should be located on your system and for more details of its use:
- *    http://www.khronos.org/registry/implementers_guide.pdf
- *
- * This file should be included as
- *        #include <KHR/khrplatform.h>
- * by Khronos client API header files that use its types and defines.
- *
- * The types in khrplatform.h should only be used to define API-specific types.
- *
- * Types defined in khrplatform.h:
- *    khronos_int8_t              signed   8  bit
- *    khronos_uint8_t             unsigned 8  bit
- *    khronos_int16_t             signed   16 bit
- *    khronos_uint16_t            unsigned 16 bit
- *    khronos_int32_t             signed   32 bit
- *    khronos_uint32_t            unsigned 32 bit
- *    khronos_int64_t             signed   64 bit
- *    khronos_uint64_t            unsigned 64 bit
- *    khronos_intptr_t            signed   same number of bits as a pointer
- *    khronos_uintptr_t           unsigned same number of bits as a pointer
- *    khronos_ssize_t             signed   size
- *    khronos_usize_t             unsigned size
- *    khronos_float_t             signed   32 bit floating point
- *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
- *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
- *                                         nanoseconds
- *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
- *    khronos_boolean_enum_t      enumerated boolean type. This should
- *      only be used as a base type when a client API's boolean type is
- *      an enum. Client APIs which use an integer or other type for
- *      booleans cannot use this as the base type for their boolean.
- *
- * Tokens defined in khrplatform.h:
- *
- *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
- *
- *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
- *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
- *
- * Calling convention macros defined in this file:
- *    KHRONOS_APICALL
- *    KHRONOS_APIENTRY
- *    KHRONOS_APIATTRIBUTES
- *
- * These may be used in function prototypes as:
- *
- *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
- *                                  int arg1,
- *                                  int arg2) KHRONOS_APIATTRIBUTES;
- */
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APICALL
- *-------------------------------------------------------------------------
- * This precedes the return type of the function in the function prototype.
- */
-#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
-#   define KHRONOS_APICALL __declspec(dllimport)
-#elif defined (__SYMBIAN32__)
-#   define KHRONOS_APICALL IMPORT_C
-#else
-#   define KHRONOS_APICALL
-#endif
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APIENTRY
- *-------------------------------------------------------------------------
- * This follows the return type of the function  and precedes the function
- * name in the function prototype.
- */
-#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
-    /* Win32 but not WinCE */
-#   define KHRONOS_APIENTRY __stdcall
-#else
-#   define KHRONOS_APIENTRY
-#endif
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APIATTRIBUTES
- *-------------------------------------------------------------------------
- * This follows the closing parenthesis of the function prototype arguments.
- */
-#if defined (__ARMCC_2__)
-#define KHRONOS_APIATTRIBUTES __softfp
-#else
-#define KHRONOS_APIATTRIBUTES
-#endif
-
-/*-------------------------------------------------------------------------
- * basic type definitions
- *-----------------------------------------------------------------------*/
-#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
-
-
-/*
- * Using <stdint.h>
- */
-#include <stdint.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(__VMS ) || defined(__sgi)
-
-/*
- * Using <inttypes.h>
- */
-#include <inttypes.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
-
-/*
- * Win32
- */
-typedef __int32                 khronos_int32_t;
-typedef unsigned __int32        khronos_uint32_t;
-typedef __int64                 khronos_int64_t;
-typedef unsigned __int64        khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(__sun__) || defined(__digital__)
-
-/*
- * Sun or Digital
- */
-typedef int                     khronos_int32_t;
-typedef unsigned int            khronos_uint32_t;
-#if defined(__arch64__) || defined(_LP64)
-typedef long int                khronos_int64_t;
-typedef unsigned long int       khronos_uint64_t;
-#else
-typedef long long int           khronos_int64_t;
-typedef unsigned long long int  khronos_uint64_t;
-#endif /* __arch64__ */
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif 0
-
-/*
- * Hypothetical platform with no float or int64 support
- */
-typedef int                     khronos_int32_t;
-typedef unsigned int            khronos_uint32_t;
-#define KHRONOS_SUPPORT_INT64   0
-#define KHRONOS_SUPPORT_FLOAT   0
-
-#else
-
-/*
- * Generic fallback
- */
-#include <stdint.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#endif
-
-
-/*
- * Types that are (so far) the same on all platforms
- */
-typedef signed   char          khronos_int8_t;
-typedef unsigned char          khronos_uint8_t;
-typedef signed   short int     khronos_int16_t;
-typedef unsigned short int     khronos_uint16_t;
-
-/*
- * Types that differ between LLP64 and LP64 architectures - in LLP64, 
- * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
- * to be the only LLP64 architecture in current use.
- */
-#ifdef _WIN64
-typedef signed   long long int khronos_intptr_t;
-typedef unsigned long long int khronos_uintptr_t;
-typedef signed   long long int khronos_ssize_t;
-typedef unsigned long long int khronos_usize_t;
-#else
-typedef signed   long  int     khronos_intptr_t;
-typedef unsigned long  int     khronos_uintptr_t;
-typedef signed   long  int     khronos_ssize_t;
-typedef unsigned long  int     khronos_usize_t;
-#endif
-
-#if KHRONOS_SUPPORT_FLOAT
-/*
- * Float type
- */
-typedef          float         khronos_float_t;
-#endif
-
-#if KHRONOS_SUPPORT_INT64
-/* Time types
- *
- * These types can be used to represent a time interval in nanoseconds or
- * an absolute Unadjusted System Time.  Unadjusted System Time is the number
- * of nanoseconds since some arbitrary system event (e.g. since the last
- * time the system booted).  The Unadjusted System Time is an unsigned
- * 64 bit value that wraps back to 0 every 584 years.  Time intervals
- * may be either signed or unsigned.
- */
-typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
-typedef khronos_int64_t        khronos_stime_nanoseconds_t;
-#endif
-
-/*
- * Dummy value used to pad enum types to 32 bits.
- */
-#ifndef KHRONOS_MAX_ENUM
-#define KHRONOS_MAX_ENUM 0x7FFFFFFF
-#endif
-
-/*
- * Enumerated boolean type
- *
- * Values other than zero should be considered to be true.  Therefore
- * comparisons should not be made against KHRONOS_TRUE.
- */
-typedef enum {
-    KHRONOS_FALSE = 0,
-    KHRONOS_TRUE  = 1,
-    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
-} khronos_boolean_enum_t;
-
-#endif /* __khrplatform_h_ */

backend/goglbackend/gl/procaddr.go

@@ -1,72 +0,0 @@
-// +build !android,!ios
-// Code generated by glow (https://github.com/go-gl/glow). DO NOT EDIT.
-
-// This file implements GlowGetProcAddress for every supported platform. The
-// correct version is chosen automatically based on build tags:
-//
-// windows: WGL
-// darwin: CGL
-// linux freebsd: GLX
-//
-// Use of EGL instead of the platform's default (listed above) is made possible
-// via the "egl" build tag.
-//
-// It is also possible to install your own function outside this package for
-// retrieving OpenGL function pointers, to do this see InitWithProcAddrFunc.
-
-package gl
-
-/*
-#cgo windows CFLAGS: -DTAG_WINDOWS
-#cgo windows LDFLAGS: -lopengl32
-#cgo darwin CFLAGS: -DTAG_DARWIN
-#cgo darwin,!ios LDFLAGS: -framework OpenGL
-#cgo linux freebsd CFLAGS: -DTAG_POSIX
-#cgo linux freebsd LDFLAGS: -lGL
-#cgo egl CFLAGS: -DTAG_EGL
-#cgo egl LDFLAGS: -lEGL
-// Check the EGL tag first as it takes priority over the platform's default
-// configuration of WGL/GLX/CGL.
-#if defined(TAG_EGL)
-	#include <stdlib.h>
-	#include <EGL/egl.h>
-	void* GlowGetProcAddress_glglesunion(const char* name) {
-		return eglGetProcAddress(name);
-	}
-#elif defined(TAG_WINDOWS)
-	#define WIN32_LEAN_AND_MEAN 1
-	#include <windows.h>
-	#include <stdlib.h>
-	static HMODULE ogl32dll = NULL;
-	void* GlowGetProcAddress_glglesunion(const char* name) {
-		void* pf = wglGetProcAddress((LPCSTR) name);
-		if (pf) {
-			return pf;
-		}
-		if (ogl32dll == NULL) {
-			ogl32dll = LoadLibraryA("opengl32.dll");
-		}
-		return GetProcAddress(ogl32dll, (LPCSTR) name);
-	}
-#elif defined(TAG_DARWIN)
-	#include <stdlib.h>
-	#include <dlfcn.h>
-	void* GlowGetProcAddress_glglesunion(const char* name) {
-		return dlsym(RTLD_DEFAULT, name);
-	}
-#elif defined(TAG_POSIX)
-	#include <stdlib.h>
-	#include <GL/glx.h>
-	void* GlowGetProcAddress_glglesunion(const char* name) {
-		return glXGetProcAddress((const GLubyte *) name);
-	}
-#endif
-*/
-import "C"
-import "unsafe"
-
-func getProcAddress(namea string) unsafe.Pointer {
-	cname := C.CString(namea)
-	defer C.free(unsafe.Pointer(cname))
-	return C.GlowGetProcAddress_glglesunion(cname)
-}

backend/goglbackend/gl/procaddr_mobile.go

@@ -1,312 +0,0 @@
-// +build android ios
-
-// Code generated by glow (https://github.com/go-gl/glow). DO NOT EDIT.
-
-// This file implements GlowGetProcAddress for every supported platform. The
-// correct version is chosen automatically based on build tags:
-//
-// windows: WGL
-// darwin: CGL
-// linux freebsd: GLX
-//
-// Use of EGL instead of the platform's default (listed above) is made possible
-// via the "egl" build tag.
-//
-// It is also possible to install your own function outside this package for
-// retrieving OpenGL function pointers, to do this see InitWithProcAddrFunc.
-
-package gl
-
-/*
-#cgo android LDFLAGS: -lGLESv2
-#cgo android CFLAGS: -DANDROID
-#cgo ios     CFLAGS: -DIOS
-#ifdef ANDROID
- #include <GLES2/gl2.h>
-#endif
-#ifdef IOS
- #include <OpenGLES/ES2/GL.h>
-#endif
-*/
-import "C"
-import "unsafe"
-
-func getProcAddress(namea string) unsafe.Pointer {
-	switch namea {
-	case "glActiveTexture":
-		return unsafe.Pointer(C.glActiveTexture)
-	case "glAttachShader":
-		return unsafe.Pointer(C.glAttachShader)
-	case "glBindAttribLocation":
-		return unsafe.Pointer(C.glBindAttribLocation)
-	case "glBindBuffer":
-		return unsafe.Pointer(C.glBindBuffer)
-	case "glBindFramebuffer":
-		return unsafe.Pointer(C.glBindFramebuffer)
-	case "glBindRenderbuffer":
-		return unsafe.Pointer(C.glBindRenderbuffer)
-	case "glBindTexture":
-		return unsafe.Pointer(C.glBindTexture)
-	case "glBlendColor":
-		return unsafe.Pointer(C.glBlendColor)
-	case "glBlendEquation":
-		return unsafe.Pointer(C.glBlendEquation)
-	case "glBlendEquationSeparate":
-		return unsafe.Pointer(C.glBlendEquationSeparate)
-	case "glBlendFunc":
-		return unsafe.Pointer(C.glBlendFunc)
-	case "glBlendFuncSeparate":
-		return unsafe.Pointer(C.glBlendFuncSeparate)
-	case "glBufferData":
-		return unsafe.Pointer(C.glBufferData)
-	case "glBufferSubData":
-		return unsafe.Pointer(C.glBufferSubData)
-	case "glCheckFramebufferStatus":
-		return unsafe.Pointer(C.glCheckFramebufferStatus)
-	case "glClear":
-		return unsafe.Pointer(C.glClear)
-	case "glClearColor":
-		return unsafe.Pointer(C.glClearColor)
-	case "glClearStencil":
-		return unsafe.Pointer(C.glClearStencil)
-	case "glColorMask":
-		return unsafe.Pointer(C.glColorMask)
-	case "glCompileShader":
-		return unsafe.Pointer(C.glCompileShader)
-	case "glCompressedTexImage2D":
-		return unsafe.Pointer(C.glCompressedTexImage2D)
-	case "glCompressedTexSubImage2D":
-		return unsafe.Pointer(C.glCompressedTexSubImage2D)
-	case "glCopyTexImage2D":
-		return unsafe.Pointer(C.glCopyTexImage2D)
-	case "glCopyTexSubImage2D":
-		return unsafe.Pointer(C.glCopyTexSubImage2D)
-	case "glCreateProgram":
-		return unsafe.Pointer(C.glCreateProgram)
-	case "glCreateShader":
-		return unsafe.Pointer(C.glCreateShader)
-	case "glCullFace":
-		return unsafe.Pointer(C.glCullFace)
-	case "glDeleteBuffers":
-		return unsafe.Pointer(C.glDeleteBuffers)
-	case "glDeleteFramebuffers":
-		return unsafe.Pointer(C.glDeleteFramebuffers)
-	case "glDeleteProgram":
-		return unsafe.Pointer(C.glDeleteProgram)
-	case "glDeleteRenderbuffers":
-		return unsafe.Pointer(C.glDeleteRenderbuffers)
-	case "glDeleteShader":
-		return unsafe.Pointer(C.glDeleteShader)
-	case "glDeleteTextures":
-		return unsafe.Pointer(C.glDeleteTextures)
-	case "glDepthFunc":
-		return unsafe.Pointer(C.glDepthFunc)
-	case "glDepthMask":
-		return unsafe.Pointer(C.glDepthMask)
-	case "glDetachShader":
-		return unsafe.Pointer(C.glDetachShader)
-	case "glDisable":
-		return unsafe.Pointer(C.glDisable)
-	case "glDisableVertexAttribArray":
-		return unsafe.Pointer(C.glDisableVertexAttribArray)
-	case "glDrawArrays":
-		return unsafe.Pointer(C.glDrawArrays)
-	case "glDrawElements":
-		return unsafe.Pointer(C.glDrawElements)
-	case "glEnable":
-		return unsafe.Pointer(C.glEnable)
-	case "glEnableVertexAttribArray":
-		return unsafe.Pointer(C.glEnableVertexAttribArray)
-	case "glFinish":
-		return unsafe.Pointer(C.glFinish)
-	case "glFlush":
-		return unsafe.Pointer(C.glFlush)
-	case "glFramebufferRenderbuffer":
-		return unsafe.Pointer(C.glFramebufferRenderbuffer)
-	case "glFramebufferTexture2D":
-		return unsafe.Pointer(C.glFramebufferTexture2D)
-	case "glFrontFace":
-		return unsafe.Pointer(C.glFrontFace)
-	case "glGenBuffers":
-		return unsafe.Pointer(C.glGenBuffers)
-	case "glGenFramebuffers":
-		return unsafe.Pointer(C.glGenFramebuffers)
-	case "glGenRenderbuffers":
-		return unsafe.Pointer(C.glGenRenderbuffers)
-	case "glGenTextures":
-		return unsafe.Pointer(C.glGenTextures)
-	case "glGenerateMipmap":
-		return unsafe.Pointer(C.glGenerateMipmap)
-	case "glGetActiveAttrib":
-		return unsafe.Pointer(C.glGetActiveAttrib)
-	case "glGetActiveUniform":
-		return unsafe.Pointer(C.glGetActiveUniform)
-	case "glGetAttachedShaders":
-		return unsafe.Pointer(C.glGetAttachedShaders)
-	case "glGetAttribLocation":
-		return unsafe.Pointer(C.glGetAttribLocation)
-	case "glGetBooleanv":
-		return unsafe.Pointer(C.glGetBooleanv)
-	case "glGetBufferParameteriv":
-		return unsafe.Pointer(C.glGetBufferParameteriv)
-	case "glGetError":
-		return unsafe.Pointer(C.glGetError)
-	case "glGetFloatv":
-		return unsafe.Pointer(C.glGetFloatv)
-	case "glGetFramebufferAttachmentParameteriv":
-		return unsafe.Pointer(C.glGetFramebufferAttachmentParameteriv)
-	case "glGetIntegerv":
-		return unsafe.Pointer(C.glGetIntegerv)
-	case "glGetProgramInfoLog":
-		return unsafe.Pointer(C.glGetProgramInfoLog)
-	case "glGetProgramiv":
-		return unsafe.Pointer(C.glGetProgramiv)
-	case "glGetRenderbufferParameteriv":
-		return unsafe.Pointer(C.glGetRenderbufferParameteriv)
-	case "glGetShaderInfoLog":
-		return unsafe.Pointer(C.glGetShaderInfoLog)
-	case "glGetShaderSource":
-		return unsafe.Pointer(C.glGetShaderSource)
-	case "glGetShaderiv":
-		return unsafe.Pointer(C.glGetShaderiv)
-	case "glGetString":
-		return unsafe.Pointer(C.glGetString)
-	case "glGetTexParameterfv":
-		return unsafe.Pointer(C.glGetTexParameterfv)
-	case "glGetTexParameteriv":
-		return unsafe.Pointer(C.glGetTexParameteriv)
-	case "glGetUniformLocation":
-		return unsafe.Pointer(C.glGetUniformLocation)
-	case "glGetUniformfv":
-		return unsafe.Pointer(C.glGetUniformfv)
-	case "glGetUniformiv":
-		return unsafe.Pointer(C.glGetUniformiv)
-	case "glGetVertexAttribPointerv":
-		return unsafe.Pointer(C.glGetVertexAttribPointerv)
-	case "glGetVertexAttribfv":
-		return unsafe.Pointer(C.glGetVertexAttribfv)
-	case "glGetVertexAttribiv":
-		return unsafe.Pointer(C.glGetVertexAttribiv)
-	case "glHint":
-		return unsafe.Pointer(C.glHint)
-	case "glIsBuffer":
-		return unsafe.Pointer(C.glIsBuffer)
-	case "glIsEnabled":
-		return unsafe.Pointer(C.glIsEnabled)
-	case "glIsFramebuffer":
-		return unsafe.Pointer(C.glIsFramebuffer)
-	case "glIsProgram":
-		return unsafe.Pointer(C.glIsProgram)
-	case "glIsRenderbuffer":
-		return unsafe.Pointer(C.glIsRenderbuffer)
-	case "glIsShader":
-		return unsafe.Pointer(C.glIsShader)
-	case "glIsTexture":
-		return unsafe.Pointer(C.glIsTexture)
-	case "glLineWidth":
-		return unsafe.Pointer(C.glLineWidth)
-	case "glLinkProgram":
-		return unsafe.Pointer(C.glLinkProgram)
-	case "glPixelStorei":
-		return unsafe.Pointer(C.glPixelStorei)
-	case "glPolygonOffset":
-		return unsafe.Pointer(C.glPolygonOffset)
-	case "glReadPixels":
-		return unsafe.Pointer(C.glReadPixels)
-	case "glRenderbufferStorage":
-		return unsafe.Pointer(C.glRenderbufferStorage)
-	case "glSampleCoverage":
-		return unsafe.Pointer(C.glSampleCoverage)
-	case "glScissor":
-		return unsafe.Pointer(C.glScissor)
-	case "glShaderSource":
-		return unsafe.Pointer(C.glShaderSource)
-	case "glStencilFunc":
-		return unsafe.Pointer(C.glStencilFunc)
-	case "glStencilFuncSeparate":
-		return unsafe.Pointer(C.glStencilFuncSeparate)
-	case "glStencilMask":
-		return unsafe.Pointer(C.glStencilMask)
-	case "glStencilMaskSeparate":
-		return unsafe.Pointer(C.glStencilMaskSeparate)
-	case "glStencilOp":
-		return unsafe.Pointer(C.glStencilOp)
-	case "glStencilOpSeparate":
-		return unsafe.Pointer(C.glStencilOpSeparate)
-	case "glTexImage2D":
-		return unsafe.Pointer(C.glTexImage2D)
-	case "glTexParameterf":
-		return unsafe.Pointer(C.glTexParameterf)
-	case "glTexParameterfv":
-		return unsafe.Pointer(C.glTexParameterfv)
-	case "glTexParameteri":
-		return unsafe.Pointer(C.glTexParameteri)
-	case "glTexParameteriv":
-		return unsafe.Pointer(C.glTexParameteriv)
-	case "glTexSubImage2D":
-		return unsafe.Pointer(C.glTexSubImage2D)
-	case "glUniform1f":
-		return unsafe.Pointer(C.glUniform1f)
-	case "glUniform1fv":
-		return unsafe.Pointer(C.glUniform1fv)
-	case "glUniform1i":
-		return unsafe.Pointer(C.glUniform1i)
-	case "glUniform1iv":
-		return unsafe.Pointer(C.glUniform1iv)
-	case "glUniform2f":
-		return unsafe.Pointer(C.glUniform2f)
-	case "glUniform2fv":
-		return unsafe.Pointer(C.glUniform2fv)
-	case "glUniform2i":
-		return unsafe.Pointer(C.glUniform2i)
-	case "glUniform2iv":
-		return unsafe.Pointer(C.glUniform2iv)
-	case "glUniform3f":
-		return unsafe.Pointer(C.glUniform3f)
-	case "glUniform3fv":
-		return unsafe.Pointer(C.glUniform3fv)
-	case "glUniform3i":
-		return unsafe.Pointer(C.glUniform3i)
-	case "glUniform3iv":
-		return unsafe.Pointer(C.glUniform3iv)
-	case "glUniform4f":
-		return unsafe.Pointer(C.glUniform4f)
-	case "glUniform4fv":
-		return unsafe.Pointer(C.glUniform4fv)
-	case "glUniform4i":
-		return unsafe.Pointer(C.glUniform4i)
-	case "glUniform4iv":
-		return unsafe.Pointer(C.glUniform4iv)
-	case "glUniformMatrix2fv":
-		return unsafe.Pointer(C.glUniformMatrix2fv)
-	case "glUniformMatrix3fv":
-		return unsafe.Pointer(C.glUniformMatrix3fv)
-	case "glUniformMatrix4fv":
-		return unsafe.Pointer(C.glUniformMatrix4fv)
-	case "glUseProgram":
-		return unsafe.Pointer(C.glUseProgram)
-	case "glValidateProgram":
-		return unsafe.Pointer(C.glValidateProgram)
-	case "glVertexAttrib1f":
-		return unsafe.Pointer(C.glVertexAttrib1f)
-	case "glVertexAttrib1fv":
-		return unsafe.Pointer(C.glVertexAttrib1fv)
-	case "glVertexAttrib2f":
-		return unsafe.Pointer(C.glVertexAttrib2f)
-	case "glVertexAttrib2fv":
-		return unsafe.Pointer(C.glVertexAttrib2fv)
-	case "glVertexAttrib3f":
-		return unsafe.Pointer(C.glVertexAttrib3f)
-	case "glVertexAttrib3fv":
-		return unsafe.Pointer(C.glVertexAttrib3fv)
-	case "glVertexAttrib4f":
-		return unsafe.Pointer(C.glVertexAttrib4f)
-	case "glVertexAttrib4fv":
-		return unsafe.Pointer(C.glVertexAttrib4fv)
-	case "glVertexAttribPointer":
-		return unsafe.Pointer(C.glVertexAttribPointer)
-	case "glViewport":
-		return unsafe.Pointer(C.glViewport)
-	}
-	return nil
-}

backend/goglbackend/gogl.go

@@ -1,400 +0,0 @@
-package goglbackend
-
-import (
-	"fmt"
-
-	"github.com/tfriedel6/canvas/backend/backendbase"
-	"github.com/tfriedel6/canvas/backend/goglbackend/gl"
-)
-
-const alphaTexSize = 2048
-
-var zeroes [alphaTexSize]byte
-
-// GLContext is a context that contains all the
-// shaders and buffers necessary for rendering
-type GLContext struct {
-	buf       uint32
-	shadowBuf uint32
-	alphaTex  uint32
-
-	shd unifiedShader
-
-	offscr1 offscreenBuffer
-	offscr2 offscreenBuffer
-
-	imageBufTex uint32
-	imageBuf    []byte
-
-	ptsBuf []float32
-}
-
-// NewGLContext creates all the necessary GL resources,
-// like shaders and buffers
-func NewGLContext() (*GLContext, error) {
-	ctx := &GLContext{
-		ptsBuf: make([]float32, 0, 4096),
-	}
-
-	err := gl.Init()
-	if err != nil {
-		return nil, err
-	}
-
-	gl.GetError() // clear error state
-
-	err = loadShader(unifiedVS, unifiedFS, &ctx.shd.shaderProgram)
-	if err != nil {
-		return nil, err
-	}
-	ctx.shd.shaderProgram.mustLoadLocations(&ctx.shd)
-	if err = glError(); err != nil {
-		return nil, err
-	}
-
-	gl.GenBuffers(1, &ctx.buf)
-	if err = glError(); err != nil {
-		return nil, err
-	}
-
-	gl.GenBuffers(1, &ctx.shadowBuf)
-	if err = glError(); err != nil {
-		return nil, err
-	}
-
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.GenTextures(1, &ctx.alphaTex)
-	gl.BindTexture(gl.TEXTURE_2D, ctx.alphaTex)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.ALPHA, alphaTexSize, alphaTexSize, 0, gl.ALPHA, gl.UNSIGNED_BYTE, nil)
-	// todo should use gl.RED on OpenGL, gl.ALPHA on OpenGL ES
-
-	gl.Enable(gl.BLEND)
-	gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
-	gl.Enable(gl.STENCIL_TEST)
-	gl.StencilMask(0xFF)
-	gl.Clear(gl.STENCIL_BUFFER_BIT)
-	gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
-	gl.StencilFunc(gl.EQUAL, 0, 0xFF)
-
-	gl.Disable(gl.SCISSOR_TEST)
-
-	return ctx, nil
-}
-
-// GoGLBackend is a canvas backend using Go-GL
-type GoGLBackend struct {
-	x, y, w, h     int
-	fx, fy, fw, fh float64
-
-	*GLContext
-
-	activateFn                 func()
-	disableTextureRenderTarget func()
-}
-
-type offscreenBuffer struct {
-	tex              uint32
-	w                int
-	h                int
-	renderStencilBuf uint32
-	frameBuf         uint32
-	alpha            bool
-}
-
-// New returns a new canvas backend. x, y, w, h define the target
-// rectangle in the window. ctx is a GLContext created with
-// NewGLContext, but can be nil for a default one. It makes sense
-// to pass one in when using for example an onscreen and an
-// offscreen backend using the same GL context.
-func New(x, y, w, h int, ctx *GLContext) (*GoGLBackend, error) {
-	if ctx == nil {
-		var err error
-		ctx, err = NewGLContext()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	b := &GoGLBackend{
-		w:         w,
-		h:         h,
-		fw:        float64(w),
-		fh:        float64(h),
-		GLContext: ctx,
-	}
-
-	b.activateFn = func() {
-		gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
-		gl.Viewport(int32(b.x), int32(b.y), int32(b.w), int32(b.h))
-		// todo reapply clipping since another application may have used the stencil buffer
-	}
-	b.disableTextureRenderTarget = func() {
-		gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
-		gl.Viewport(int32(b.x), int32(b.y), int32(b.w), int32(b.h))
-	}
-
-	return b, nil
-}
-
-// GoGLBackendOffscreen is a canvas backend using an offscreen
-// texture
-type GoGLBackendOffscreen struct {
-	GoGLBackend
-
-	TextureID uint32
-
-	offscrBuf offscreenBuffer
-	offscrImg Image
-}
-
-// NewOffscreen returns a new offscreen canvas backend. w, h define
-// the size of the offscreen texture. ctx is a GLContext created
-// with NewGLContext, but can be nil for a default one. It makes
-// sense to pass one in when using for example an onscreen and an
-// offscreen backend using the same GL context.
-func NewOffscreen(w, h int, alpha bool, ctx *GLContext) (*GoGLBackendOffscreen, error) {
-	b, err := New(0, 0, w, h, ctx)
-	if err != nil {
-		return nil, err
-	}
-	bo := &GoGLBackendOffscreen{GoGLBackend: *b}
-	bo.offscrBuf.alpha = alpha
-	bo.offscrImg.flip = true
-
-	bo.activateFn = func() {
-		bo.enableTextureRenderTarget(&bo.offscrBuf)
-		gl.Viewport(0, 0, int32(bo.w), int32(bo.h))
-		bo.offscrImg.w = bo.offscrBuf.w
-		bo.offscrImg.h = bo.offscrBuf.h
-		bo.offscrImg.tex = bo.offscrBuf.tex
-		bo.TextureID = bo.offscrBuf.tex
-	}
-	bo.disableTextureRenderTarget = func() {
-		bo.enableTextureRenderTarget(&bo.offscrBuf)
-	}
-
-	return bo, nil
-}
-
-// SetBounds updates the bounds of the canvas. This would
-// usually be called for example when the window is resized
-func (b *GoGLBackend) SetBounds(x, y, w, h int) {
-	b.x, b.y = x, y
-	b.fx, b.fy = float64(x), float64(y)
-	b.w, b.h = w, h
-	b.fw, b.fh = float64(w), float64(h)
-	if b == activeContext {
-		gl.Viewport(0, 0, int32(b.w), int32(b.h))
-		gl.Clear(gl.STENCIL_BUFFER_BIT)
-	}
-}
-
-// SetSize updates the size of the offscreen texture
-func (b *GoGLBackendOffscreen) SetSize(w, h int) {
-	b.GoGLBackend.SetBounds(0, 0, w, h)
-	b.offscrImg.w = b.offscrBuf.w
-	b.offscrImg.h = b.offscrBuf.h
-}
-
-// Size returns the size of the window or offscreen
-// texture
-func (b *GoGLBackend) Size() (int, int) {
-	return b.w, b.h
-}
-
-func glError() error {
-	glErr := gl.GetError()
-	if glErr != gl.NO_ERROR {
-		return fmt.Errorf("GL Error: %x", glErr)
-	}
-	return nil
-}
-
-// Activate only needs to be called if there is other
-// code also using the GL state
-func (b *GoGLBackend) Activate() {
-	b.activate()
-}
-
-var activeContext *GoGLBackend
-
-func (b *GoGLBackend) activate() {
-	if activeContext != b {
-		activeContext = b
-		b.activateFn()
-	}
-}
-
-// Delete deletes the offscreen texture. After calling this
-// the backend can no longer be used
-func (b *GoGLBackendOffscreen) Delete() {
-	gl.DeleteTextures(1, &b.offscrBuf.tex)
-	gl.DeleteFramebuffers(1, &b.offscrBuf.frameBuf)
-	gl.DeleteRenderbuffers(1, &b.offscrBuf.renderStencilBuf)
-}
-
-// CanUseAsImage returns true if the given backend can be
-// directly used by this backend to avoid a conversion.
-// Used internally
-func (b *GoGLBackend) CanUseAsImage(b2 backendbase.Backend) bool {
-	_, ok := b2.(*GoGLBackendOffscreen)
-	return ok
-}
-
-// AsImage returns nil, since this backend cannot be directly
-// used as an image. Used internally
-func (b *GoGLBackend) AsImage() backendbase.Image {
-	return nil
-}
-
-// AsImage returns an implementation of the Image interface
-// that can be used to render this offscreen texture
-// directly. Used internally
-func (b *GoGLBackendOffscreen) AsImage() backendbase.Image {
-	return &b.offscrImg
-}
-
-func (b *GoGLBackend) useShader(style *backendbase.FillStyle, tf [9]float32, useAlpha bool, alphaTexSlot int32) (vertexLoc, alphaTexCoordLoc uint32) {
-	gl.UseProgram(b.shd.ID)
-	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
-	gl.UniformMatrix3fv(b.shd.Matrix, 1, false, &tf[0])
-	if useAlpha {
-		gl.Uniform1i(b.shd.UseAlphaTex, 1)
-		gl.Uniform1i(b.shd.AlphaTex, alphaTexSlot)
-	} else {
-		gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	}
-	gl.Uniform1f(b.shd.GlobalAlpha, float32(style.Color.A)/255)
-
-	if lg := style.LinearGradient; lg != nil {
-		lg := lg.(*LinearGradient)
-		gl.ActiveTexture(gl.TEXTURE0)
-		gl.BindTexture(gl.TEXTURE_2D, lg.tex)
-		from := backendbase.Vec{style.Gradient.X0, style.Gradient.Y0}
-		to := backendbase.Vec{style.Gradient.X1, style.Gradient.Y1}
-		dir := to.Sub(from)
-		length := dir.Len()
-		dir = dir.Mulf(1 / length)
-		gl.Uniform2f(b.shd.From, float32(from[0]), float32(from[1]))
-		gl.Uniform2f(b.shd.Dir, float32(dir[0]), float32(dir[1]))
-		gl.Uniform1f(b.shd.Len, float32(length))
-		gl.Uniform1i(b.shd.Gradient, 0)
-		gl.Uniform1i(b.shd.Func, shdFuncLinearGradient)
-		return b.shd.Vertex, b.shd.TexCoord
-	}
-	if rg := style.RadialGradient; rg != nil {
-		rg := rg.(*RadialGradient)
-		gl.ActiveTexture(gl.TEXTURE0)
-		gl.BindTexture(gl.TEXTURE_2D, rg.tex)
-		gl.Uniform2f(b.shd.From, float32(style.Gradient.X0), float32(style.Gradient.Y0))
-		gl.Uniform2f(b.shd.To, float32(style.Gradient.X1), float32(style.Gradient.Y1))
-		gl.Uniform1f(b.shd.RadFrom, float32(style.Gradient.RadFrom))
-		gl.Uniform1f(b.shd.RadTo, float32(style.Gradient.RadTo))
-		gl.Uniform1i(b.shd.Gradient, 0)
-		gl.Uniform1i(b.shd.Func, shdFuncRadialGradient)
-		return b.shd.Vertex, b.shd.TexCoord
-	}
-	if ip := style.ImagePattern; ip != nil {
-		ipd := ip.(*ImagePattern).data
-		img := ipd.Image.(*Image)
-		gl.ActiveTexture(gl.TEXTURE0)
-		gl.BindTexture(gl.TEXTURE_2D, img.tex)
-		gl.Uniform2f(b.shd.ImageSize, float32(img.w), float32(img.h))
-		gl.Uniform1i(b.shd.Image, 0)
-		var f32mat [9]float32
-		for i, v := range ipd.Transform {
-			f32mat[i] = float32(v)
-		}
-		gl.UniformMatrix3fv(b.shd.ImageTransform, 1, false, &f32mat[0])
-		switch ipd.Repeat {
-		case backendbase.Repeat:
-			gl.Uniform2f(b.shd.Repeat, 1, 1)
-		case backendbase.RepeatX:
-			gl.Uniform2f(b.shd.Repeat, 1, 0)
-		case backendbase.RepeatY:
-			gl.Uniform2f(b.shd.Repeat, 0, 1)
-		case backendbase.NoRepeat:
-			gl.Uniform2f(b.shd.Repeat, 0, 0)
-		}
-		gl.Uniform1i(b.shd.Func, shdFuncImagePattern)
-		return b.shd.Vertex, b.shd.TexCoord
-	}
-
-	cr := float32(style.Color.R) / 255
-	cg := float32(style.Color.G) / 255
-	cb := float32(style.Color.B) / 255
-	ca := float32(style.Color.A) / 255
-	gl.Uniform4f(b.shd.Color, cr, cg, cb, ca)
-	gl.Uniform1f(b.shd.GlobalAlpha, 1)
-	gl.Uniform1i(b.shd.Func, shdFuncSolid)
-	return b.shd.Vertex, b.shd.TexCoord
-}
-
-func (b *GoGLBackend) enableTextureRenderTarget(offscr *offscreenBuffer) {
-	if offscr.w == b.w && offscr.h == b.h {
-		gl.BindFramebuffer(gl.FRAMEBUFFER, offscr.frameBuf)
-		return
-	}
-
-	if b.w == 0 || b.h == 0 {
-		return
-	}
-
-	if offscr.w != 0 && offscr.h != 0 {
-		gl.DeleteTextures(1, &offscr.tex)
-		gl.DeleteFramebuffers(1, &offscr.frameBuf)
-		gl.DeleteRenderbuffers(1, &offscr.renderStencilBuf)
-	}
-	offscr.w = b.w
-	offscr.h = b.h
-
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.GenTextures(1, &offscr.tex)
-	gl.BindTexture(gl.TEXTURE_2D, offscr.tex)
-	// todo do non-power-of-two textures work everywhere?
-	if offscr.alpha {
-		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(b.w), int32(b.h), 0, gl.RGBA, gl.UNSIGNED_BYTE, nil)
-	} else {
-		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGB, int32(b.w), int32(b.h), 0, gl.RGB, gl.UNSIGNED_BYTE, nil)
-	}
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-
-	gl.GenFramebuffers(1, &offscr.frameBuf)
-	gl.BindFramebuffer(gl.FRAMEBUFFER, offscr.frameBuf)
-
-	gl.GenRenderbuffers(1, &offscr.renderStencilBuf)
-	gl.BindRenderbuffer(gl.RENDERBUFFER, offscr.renderStencilBuf)
-	gl.RenderbufferStorage(gl.RENDERBUFFER, gl.STENCIL_INDEX8, int32(b.w), int32(b.h))
-	gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, offscr.renderStencilBuf)
-
-	gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, offscr.tex, 0)
-
-	if err := gl.CheckFramebufferStatus(gl.FRAMEBUFFER); err != gl.FRAMEBUFFER_COMPLETE {
-		// todo this should maybe not panic
-		panic(fmt.Sprintf("Failed to set up framebuffer for offscreen texture: %x", err))
-	}
-
-	gl.Clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
-}
-
-func mat3(m backendbase.Mat) (m3 [9]float32) {
-	m3[0] = float32(m[0])
-	m3[1] = float32(m[1])
-	m3[2] = 0
-	m3[3] = float32(m[2])
-	m3[4] = float32(m[3])
-	m3[5] = 0
-	m3[6] = float32(m[4])
-	m3[7] = float32(m[5])
-	m3[8] = 1
-	return
-}
-
-var mat3identity = [9]float32{1, 0, 0, 0, 1, 0, 0, 0, 1}

backend/goglbackend/gradients.go

@@ -1,90 +0,0 @@
-package goglbackend
-
-import (
-	"github.com/tfriedel6/canvas/backend/backendbase"
-	"github.com/tfriedel6/canvas/backend/goglbackend/gl"
-)
-
-// LinearGradient is a gradient with any number of
-// stops and any number of colors. The gradient will
-// be drawn such that each point on the gradient
-// will correspond to a straight line
-type LinearGradient struct {
-	gradient
-}
-
-// RadialGradient is a gradient with any number of
-// stops and any number of colors. The gradient will
-// be drawn such that each point on the gradient
-// will correspond to a circle
-type RadialGradient struct {
-	gradient
-}
-
-type gradient struct {
-	b   *GoGLBackend
-	tex uint32
-}
-
-func (b *GoGLBackend) LoadLinearGradient(data backendbase.Gradient) backendbase.LinearGradient {
-	b.activate()
-
-	lg := &LinearGradient{
-		gradient: gradient{b: b},
-	}
-	gl.GenTextures(1, &lg.tex)
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, lg.tex)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-	lg.load(data)
-	return lg
-}
-
-func (b *GoGLBackend) LoadRadialGradient(data backendbase.Gradient) backendbase.RadialGradient {
-	b.activate()
-
-	rg := &RadialGradient{
-		gradient: gradient{b: b},
-	}
-	gl.GenTextures(1, &rg.tex)
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, rg.tex)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-	rg.load(data)
-	return rg
-}
-
-// Delete explicitly deletes the gradient
-func (g *gradient) Delete() {
-	g.b.activate()
-
-	gl.DeleteTextures(1, &g.tex)
-}
-
-func (lg *LinearGradient) Replace(data backendbase.Gradient) { lg.load(data) }
-func (rg *RadialGradient) Replace(data backendbase.Gradient) { rg.load(data) }
-
-func (g *gradient) load(stops backendbase.Gradient) {
-	g.b.activate()
-
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, g.tex)
-	var pixels [2048 * 4]byte
-	pp := 0
-	for i := 0; i < 2048; i++ {
-		c := stops.ColorAt(float64(i) / 2047)
-		pixels[pp] = c.R
-		pixels[pp+1] = c.G
-		pixels[pp+2] = c.B
-		pixels[pp+3] = c.A
-		pp += 4
-	}
-
-	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2048, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(&pixels[0]))
-}

backend/goglbackend/imagedata.go

@@ -1,102 +0,0 @@
-package goglbackend
-
-import (
-	"image"
-	"image/color"
-	"unsafe"
-
-	"github.com/tfriedel6/canvas/backend/goglbackend/gl"
-)
-
-// GetImageData returns an RGBA image of the current image
-func (b *GoGLBackend) GetImageData(x, y, w, h int) *image.RGBA {
-	b.activate()
-
-	if x < 0 {
-		w += x
-		x = 0
-	}
-	if y < 0 {
-		h += y
-		y = 0
-	}
-	if w > b.w {
-		w = b.w
-	}
-	if h > b.h {
-		h = b.h
-	}
-
-	var vp [4]int32
-	gl.GetIntegerv(gl.VIEWPORT, &vp[0])
-
-	size := int(vp[2] * vp[3] * 3)
-	if len(b.imageBuf) < size {
-		b.imageBuf = make([]byte, size)
-	}
-	gl.ReadPixels(vp[0], vp[1], vp[2], vp[3], gl.RGB, gl.UNSIGNED_BYTE, gl.Ptr(&b.imageBuf[0]))
-
-	rgba := image.NewRGBA(image.Rect(x, y, x+w, y+h))
-	for cy := y; cy < y+h; cy++ {
-		bp := (int(vp[3])-h+cy)*int(vp[2])*3 + x*3
-		for cx := x; cx < x+w; cx++ {
-			rgba.SetRGBA(cx, y+h-1-cy, color.RGBA{R: b.imageBuf[bp], G: b.imageBuf[bp+1], B: b.imageBuf[bp+2], A: 255})
-			bp += 3
-		}
-	}
-	return rgba
-}
-
-// PutImageData puts the given image at the given x/y coordinates
-func (b *GoGLBackend) PutImageData(img *image.RGBA, x, y int) {
-	b.activate()
-
-	gl.ActiveTexture(gl.TEXTURE0)
-	if b.imageBufTex == 0 {
-		gl.GenTextures(1, &b.imageBufTex)
-		gl.BindTexture(gl.TEXTURE_2D, b.imageBufTex)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-	} else {
-		gl.BindTexture(gl.TEXTURE_2D, b.imageBufTex)
-	}
-
-	w, h := img.Bounds().Dx(), img.Bounds().Dy()
-
-	if img.Stride == img.Bounds().Dx()*4 {
-		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(w), int32(h), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(&img.Pix[0]))
-	} else {
-		data := make([]uint8, 0, w*h*4)
-		for cy := 0; cy < h; cy++ {
-			start := cy * img.Stride
-			end := start + w*4
-			data = append(data, img.Pix[start:end]...)
-		}
-		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(w), int32(h), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(&data[0]))
-	}
-
-	dx, dy := float32(x), float32(y)
-	dw, dh := float32(w), float32(h)
-
-	gl.BindBuffer(gl.ARRAY_BUFFER, b.buf)
-	data := [16]float32{dx, dy, dx + dw, dy, dx + dw, dy + dh, dx, dy + dh,
-		0, 0, 1, 0, 1, 1, 0, 1}
-	gl.BufferData(gl.ARRAY_BUFFER, len(data)*4, unsafe.Pointer(&data[0]), gl.STREAM_DRAW)
-
-	gl.UseProgram(b.shd.ID)
-	gl.Uniform1i(b.shd.Image, 0)
-	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
-	gl.UniformMatrix3fv(b.shd.Matrix, 1, false, &mat3identity[0])
-	gl.Uniform1f(b.shd.GlobalAlpha, 1)
-	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.Func, shdFuncImage)
-	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
-	gl.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
-	gl.EnableVertexAttribArray(b.shd.Vertex)
-	gl.EnableVertexAttribArray(b.shd.TexCoord)
-	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-	gl.DisableVertexAttribArray(b.shd.Vertex)
-	gl.DisableVertexAttribArray(b.shd.TexCoord)
-}

backend/goglbackend/images.go

@@ -1,221 +0,0 @@
-package goglbackend
-
-import (
-	"errors"
-	"image"
-	"unsafe"
-
-	"github.com/tfriedel6/canvas/backend/backendbase"
-	"github.com/tfriedel6/canvas/backend/goglbackend/gl"
-)
-
-// Image represents a loaded image that can be used in various drawing functions
-type Image struct {
-	b    *GoGLBackend
-	w, h int
-	tex  uint32
-	flip bool
-}
-
-func (b *GoGLBackend) LoadImage(src image.Image) (backendbase.Image, error) {
-	b.activate()
-
-	var tex uint32
-	gl.GenTextures(1, &tex)
-	if tex == 0 {
-		return nil, errors.New("glGenTextures failed")
-	}
-
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, tex)
-	if src == nil {
-		return &Image{tex: tex}, nil
-	}
-
-	img, err := loadImage(src, tex)
-	if err != nil {
-		return nil, err
-	}
-	img.b = b
-
-	return img, nil
-}
-
-func loadImage(src image.Image, tex uint32) (*Image, error) {
-	var img *Image
-	var err error
-	switch v := src.(type) {
-	case *image.RGBA:
-		img, err = loadImageRGBA(v, tex)
-		if err != nil {
-			return nil, err
-		}
-	case image.Image:
-		img, err = loadImageConverted(v, tex)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, errors.New("Unsupported source type")
-	}
-	return img, nil
-}
-
-func loadImageRGBA(src *image.RGBA, tex uint32) (*Image, error) {
-	img := &Image{tex: tex, w: src.Bounds().Dx(), h: src.Bounds().Dy()}
-
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-	if err := glError(); err != nil {
-		return nil, err
-	}
-	if src.Stride == img.w*4 {
-		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(img.w), int32(img.h), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(&src.Pix[0]))
-	} else {
-		data := make([]uint8, 0, img.w*img.h*4)
-		for y := 0; y < img.h; y++ {
-			start := y * src.Stride
-			end := start + img.w*4
-			data = append(data, src.Pix[start:end]...)
-		}
-		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(img.w), int32(img.h), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(&data[0]))
-	}
-	if err := glError(); err != nil {
-		return nil, err
-	}
-	gl.GenerateMipmap(gl.TEXTURE_2D)
-	if err := glError(); err != nil {
-		return nil, err
-	}
-	return img, nil
-}
-
-func loadImageConverted(src image.Image, tex uint32) (*Image, error) {
-	img := &Image{tex: tex, w: src.Bounds().Dx(), h: src.Bounds().Dy()}
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-	if err := glError(); err != nil {
-		return nil, err
-	}
-	data := make([]uint8, 0, img.w*img.h*4)
-	for y := 0; y < img.h; y++ {
-		for x := 0; x < img.w; x++ {
-			ir, ig, ib, ia := src.At(x, y).RGBA()
-			r, g, b, a := uint8(ir>>8), uint8(ig>>8), uint8(ib>>8), uint8(ia>>8)
-			data = append(data, r, g, b, a)
-		}
-	}
-	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(img.w), int32(img.h), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(&data[0]))
-	if err := glError(); err != nil {
-		return nil, err
-	}
-	gl.GenerateMipmap(gl.TEXTURE_2D)
-	if err := glError(); err != nil {
-		return nil, err
-	}
-	return img, nil
-}
-
-// Width returns the width of the image
-func (img *Image) Width() int { return img.w }
-
-// Height returns the height of the image
-func (img *Image) Height() int { return img.h }
-
-// Size returns the width and height of the image
-func (img *Image) Size() (int, int) { return img.w, img.h }
-
-// Delete deletes the image from memory. Any draw calls
-// with a deleted image will not do anything
-func (img *Image) Delete() {
-	img.b.activate()
-
-	gl.DeleteTextures(1, &img.tex)
-}
-
-// Replace replaces the image with the new one
-func (img *Image) Replace(src image.Image) error {
-	img.b.activate()
-
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, img.tex)
-	newImg, err := loadImage(src, img.tex)
-	if err != nil {
-		return err
-	}
-	newImg.b = img.b
-	*img = *newImg
-	return nil
-}
-
-func (b *GoGLBackend) DrawImage(dimg backendbase.Image, sx, sy, sw, sh float64, pts [4]backendbase.Vec, alpha float64) {
-	b.activate()
-
-	img := dimg.(*Image)
-
-	sx /= float64(img.w)
-	sy /= float64(img.h)
-	sw /= float64(img.w)
-	sh /= float64(img.h)
-
-	if img.flip {
-		sy += sh
-		sh = -sh
-	}
-
-	var buf [16]float32
-	data := buf[:0]
-	for _, pt := range pts {
-		data = append(data, float32(pt[0]), float32(pt[1]))
-	}
-	data = append(data,
-		float32(sx), float32(sy),
-		float32(sx), float32(sy+sh),
-		float32(sx+sw), float32(sy+sh),
-		float32(sx+sw), float32(sy),
-	)
-
-	gl.StencilFunc(gl.EQUAL, 0, 0xFF)
-
-	gl.BindBuffer(gl.ARRAY_BUFFER, b.buf)
-	gl.BufferData(gl.ARRAY_BUFFER, len(data)*4, unsafe.Pointer(&data[0]), gl.STREAM_DRAW)
-
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, img.tex)
-
-	gl.UseProgram(b.shd.ID)
-	gl.Uniform1i(b.shd.Image, 0)
-	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
-	gl.UniformMatrix3fv(b.shd.Matrix, 1, false, &mat3identity[0])
-	gl.Uniform1f(b.shd.GlobalAlpha, float32(alpha))
-	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.Func, shdFuncImage)
-	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
-	gl.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
-	gl.EnableVertexAttribArray(b.shd.Vertex)
-	gl.EnableVertexAttribArray(b.shd.TexCoord)
-	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-	gl.DisableVertexAttribArray(b.shd.Vertex)
-	gl.DisableVertexAttribArray(b.shd.TexCoord)
-
-	gl.StencilFunc(gl.ALWAYS, 0, 0xFF)
-}
-
-type ImagePattern struct {
-	b    *GoGLBackend
-	data backendbase.ImagePatternData
-}
-
-func (b *GoGLBackend) LoadImagePattern(data backendbase.ImagePatternData) backendbase.ImagePattern {
-	return &ImagePattern{
-		b:    b,
-		data: data,
-	}
-}
-
-func (ip *ImagePattern) Delete()                                   {}
-func (ip *ImagePattern) Replace(data backendbase.ImagePatternData) { ip.data = data }

backend/goglbackend/shader.go

@@ -1,202 +0,0 @@
-package goglbackend
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/tfriedel6/canvas/backend/goglbackend/gl"
-)
-
-type shaderProgram struct {
-	ID, vs, fs uint32
-
-	attribs  map[string]uint32
-	uniforms map[string]int32
-}
-
-func loadShader(vs, fs string, sp *shaderProgram) error {
-	glError() // clear the current error
-
-	// compile vertex shader
-	{
-		sp.vs = gl.CreateShader(gl.VERTEX_SHADER)
-		csrc, freeFunc := gl.Strs(vs + "\x00")
-		defer freeFunc()
-		gl.ShaderSource(sp.vs, 1, csrc, nil)
-		gl.CompileShader(sp.vs)
-
-		var status int32
-		gl.GetShaderiv(sp.vs, gl.COMPILE_STATUS, &status)
-		if status != gl.TRUE {
-			var buf [65536]byte
-			var length int32
-			gl.GetShaderInfoLog(sp.vs, int32(len(buf)), &length, &buf[0])
-			clog := string(buf[:length])
-			gl.DeleteShader(sp.vs)
-			return fmt.Errorf("failed to compile vertex shader:\n\n%s", clog)
-		}
-		if err := glError(); err != nil {
-			return fmt.Errorf("gl error after compiling vertex shader: %v", err)
-		}
-	}
-
-	// compile fragment shader
-	{
-		sp.fs = gl.CreateShader(gl.FRAGMENT_SHADER)
-		csrc, freeFunc := gl.Strs(fs + "\x00")
-		defer freeFunc()
-		gl.ShaderSource(sp.fs, 1, csrc, nil)
-		gl.CompileShader(sp.fs)
-
-		var status int32
-		gl.GetShaderiv(sp.fs, gl.COMPILE_STATUS, &status)
-		if status != gl.TRUE {
-			var buf [65536]byte
-			var length int32
-			gl.GetShaderInfoLog(sp.fs, int32(len(buf)), &length, &buf[0])
-			clog := string(buf[:length])
-			gl.DeleteShader(sp.fs)
-			return fmt.Errorf("failed to compile fragment shader:\n\n%s", clog)
-		}
-		if err := glError(); err != nil {
-			return fmt.Errorf("gl error after compiling fragment shader: %v", err)
-		}
-	}
-
-	// link shader program
-	{
-		sp.ID = gl.CreateProgram()
-		gl.AttachShader(sp.ID, sp.vs)
-		gl.AttachShader(sp.ID, sp.fs)
-		gl.LinkProgram(sp.ID)
-
-		var status int32
-		gl.GetProgramiv(sp.ID, gl.LINK_STATUS, &status)
-		if status != gl.TRUE {
-			var buf [65536]byte
-			var length int32
-			gl.GetProgramInfoLog(sp.ID, int32(len(buf)), &length, &buf[0])
-			clog := string(buf[:length])
-			gl.DeleteProgram(sp.ID)
-			gl.DeleteShader(sp.vs)
-			gl.DeleteShader(sp.fs)
-			return fmt.Errorf("failed to link shader program:\n\n%s", clog)
-		}
-		if err := glError(); err != nil {
-			return fmt.Errorf("gl error after linking shader: %v", err)
-		}
-	}
-
-	gl.UseProgram(sp.ID)
-	var nameBuf [256]byte
-	var length, size int32
-	var xtype uint32
-	var count int32
-
-	// load the attributes
-	gl.GetProgramiv(sp.ID, gl.ACTIVE_ATTRIBUTES, &count)
-	sp.attribs = make(map[string]uint32, int(count))
-	for i := int32(0); i < count; i++ {
-		gl.GetActiveAttrib(sp.ID, uint32(i), int32(len(nameBuf)), &length, &size, &xtype, &nameBuf[0])
-		name := string(nameBuf[:length])
-		loc := gl.GetAttribLocation(sp.ID, &nameBuf[0])
-		sp.attribs[name] = uint32(loc)
-	}
-
-	// load the uniforms
-	gl.GetProgramiv(sp.ID, gl.ACTIVE_UNIFORMS, &count)
-	sp.uniforms = make(map[string]int32, int(count))
-	for i := int32(0); i < count; i++ {
-		gl.GetActiveUniform(sp.ID, uint32(i), int32(len(nameBuf)), &length, &size, &xtype, &nameBuf[0])
-		name := string(nameBuf[:length])
-		loc := gl.GetUniformLocation(sp.ID, &nameBuf[0])
-		sp.uniforms[name] = loc
-	}
-
-	return nil
-}
-
-func (sp *shaderProgram) use() {
-	gl.UseProgram(sp.ID)
-}
-
-func (sp *shaderProgram) delete() {
-	gl.DeleteProgram(sp.ID)
-	gl.DeleteShader(sp.vs)
-	gl.DeleteShader(sp.fs)
-}
-
-func (sp *shaderProgram) loadLocations(target interface{}) error {
-	val := reflect.ValueOf(target)
-	if val.Kind() != reflect.Ptr {
-		panic("target must be a pointer to a struct")
-	}
-	val = val.Elem()
-	if val.Kind() != reflect.Struct {
-		panic("target must be a pointer to a struct")
-	}
-
-	gl.UseProgram(sp.ID)
-
-	var errs strings.Builder
-
-	for name, loc := range sp.attribs {
-		field := val.FieldByName(sp.structName(name))
-		if field == (reflect.Value{}) {
-			fmt.Fprintf(&errs, "field for attribute \"%s\" not found; ", name)
-		} else if field.Type() != reflect.TypeOf(uint32(0)) {
-			fmt.Fprintf(&errs, "field for attribute \"%s\" must have type uint32; ", name)
-		} else {
-			field.Set(reflect.ValueOf(uint32(loc)))
-		}
-	}
-
-	for name, loc := range sp.uniforms {
-		field := val.FieldByName(sp.structName(name))
-		if field == (reflect.Value{}) {
-			fmt.Fprintf(&errs, "field for uniform \"%s\" not found; ", name)
-		} else if field.Type() != reflect.TypeOf(int32(0)) {
-			fmt.Fprintf(&errs, "field for uniform \"%s\" must have type int32; ", name)
-		} else {
-			field.Set(reflect.ValueOf(int32(loc)))
-		}
-	}
-
-	if errs.Len() > 0 {
-		return errors.New(strings.TrimSpace(errs.String()))
-	}
-	return nil
-}
-
-func (sp *shaderProgram) structName(name string) string {
-	rn, sz := utf8.DecodeRuneInString(name)
-	name = fmt.Sprintf("%c%s", unicode.ToUpper(rn), name[sz:])
-	idx := strings.IndexByte(name, '[')
-	if idx > 0 {
-		name = name[:idx]
-	}
-	return name
-}
-
-func (sp *shaderProgram) mustLoadLocations(target interface{}) {
-	err := sp.loadLocations(target)
-	if err != nil {
-		panic(err)
-	}
-}
-
-func (sp *shaderProgram) enableAllVertexAttribArrays() {
-	for _, loc := range sp.attribs {
-		gl.EnableVertexAttribArray(loc)
-	}
-}
-
-func (sp *shaderProgram) disableAllVertexAttribArrays() {
-	for _, loc := range sp.attribs {
-		gl.DisableVertexAttribArray(loc)
-	}
-}

backend/goglbackend/shaders.go

@@ -1,158 +0,0 @@
-package goglbackend
-
-var unifiedVS = `
-attribute vec2 vertex, texCoord;
-
-uniform vec2 canvasSize;
-uniform mat3 matrix;
-
-varying vec2 v_cp, v_tc;
-
-void main() {
-	v_tc = texCoord;
-	vec3 v = matrix * vec3(vertex.xy, 1.0);
-	vec2 tf = v.xy / v.z;
-	v_cp = tf;
-	vec2 glp = tf * 2.0 / canvasSize - 1.0;
-    gl_Position = vec4(glp.x, -glp.y, 0.0, 1.0);
-}
-`
-var unifiedFS = `
-#ifdef GL_ES
-precision mediump float;
-#endif
-
-varying vec2 v_cp, v_tc;
-
-uniform int func;
-
-uniform vec4 color;
-uniform float globalAlpha;
-
-uniform sampler2D gradient;
-uniform vec2 from, dir, to;
-uniform float len, radFrom, radTo;
-
-uniform vec2 imageSize;
-uniform sampler2D image;
-uniform mat3 imageTransform;
-uniform vec2 repeat;
-
-uniform bool useAlphaTex;
-uniform sampler2D alphaTex;
-
-uniform int boxSize;
-uniform bool boxVertical;
-uniform float boxScale;
-uniform float boxOffset;
-
-bool isNaN(float v) {
-  return v < 0.0 || 0.0 < v || v == 0.0 ? false : true;
-}
-
-void main() {
-	vec4 col = color;
-
-	if (func == 5) {
-		vec4 sum = vec4(0.0);
-		if (boxVertical) {
-			vec2 start = v_tc - vec2(0.0, (float(boxSize) * 0.5 + boxOffset) * boxScale);
-			for (int i=0; i <= boxSize; i++) {
-				sum += texture2D(image, start + vec2(0.0, float(i) * boxScale));
-			}
-		} else {
-			vec2 start = v_tc - vec2((float(boxSize) * 0.5 + boxOffset) * boxScale, 0.0);
-			for (int i=0; i <= boxSize; i++) {
-				sum += texture2D(image, start + vec2(float(i) * boxScale, 0.0));
-			}
-		}
-		gl_FragColor = sum / float(boxSize+1);
-		return;
-	}
-
-	if (func == 1) {
-		vec2 v = v_cp - from;
-		float r = dot(v, dir) / len;
-		r = clamp(r, 0.0, 1.0);
-		col = texture2D(gradient, vec2(r, 0.0));
-	} else if (func == 2) {
-		float o_a = 0.5 * sqrt(
-			pow(-2.0*from.x*from.x+2.0*from.x*to.x+2.0*from.x*v_cp.x-2.0*to.x*v_cp.x-2.0*from.y*from.y+2.0*from.y*to.y+2.0*from.y*v_cp.y-2.0*to.y*v_cp.y+2.0*radFrom*radFrom-2.0*radFrom*radTo, 2.0)
-			-4.0*(from.x*from.x-2.0*from.x*v_cp.x+v_cp.x*v_cp.x+from.y*from.y-2.0*from.y*v_cp.y+v_cp.y*v_cp.y-radFrom*radFrom)
-			*(from.x*from.x-2.0*from.x*to.x+to.x*to.x+from.y*from.y-2.0*from.y*to.y+to.y*to.y-radFrom*radFrom+2.0*radFrom*radTo-radTo*radTo)
-		);
-		float o_b = (from.x*from.x-from.x*to.x-from.x*v_cp.x+to.x*v_cp.x+from.y*from.y-from.y*to.y-from.y*v_cp.y+to.y*v_cp.y-radFrom*radFrom+radFrom*radTo);
-		float o_c = (from.x*from.x-2.0*from.x*to.x+to.x*to.x+from.y*from.y-2.0*from.y*to.y+to.y*to.y-radFrom*radFrom+2.0*radFrom*radTo-radTo*radTo);
-		float o1 = (-o_a + o_b) / o_c;
-		float o2 = (o_a + o_b) / o_c;
-		if (isNaN(o1) && isNaN(o2)) {
-			gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
-			return;
-		}
-		float o = max(o1, o2);
-		o = clamp(o, 0.0, 1.0);
-		col = texture2D(gradient, vec2(o, 0.0));
-	} else if (func == 3) {
-		vec3 tfpt = vec3(v_cp, 1.0) * imageTransform;
-		vec2 imgpt = tfpt.xy / imageSize;
-		col = texture2D(image, mod(imgpt, 1.0));
-		if (imgpt.x < 0.0 || imgpt.x > 1.0) {
-			col *= repeat.x;
-		}
-		if (imgpt.y < 0.0 || imgpt.y > 1.0) {
-			col *= repeat.y;
-		}
-	} else if (func == 4) {
-		col = texture2D(image, v_tc);
-	}
-
-	if (useAlphaTex) {
-		col.a *= texture2D(alphaTex, v_tc).a * globalAlpha;
-	} else {
-		col.a *= globalAlpha;
-	}
-
-    gl_FragColor = col;
-}
-`
-
-const (
-	shdFuncSolid int32 = iota
-	shdFuncLinearGradient
-	shdFuncRadialGradient
-	shdFuncImagePattern
-	shdFuncImage
-	shdFuncBoxBlur
-)
-
-type unifiedShader struct {
-	shaderProgram
-
-	Vertex   uint32
-	TexCoord uint32
-
-	CanvasSize  int32
-	Matrix      int32
-	Color       int32
-	GlobalAlpha int32
-
-	Func int32
-
-	UseAlphaTex int32
-	AlphaTex    int32
-
-	Gradient       int32
-	From, To, Dir  int32
-	Len            int32
-	RadFrom, RadTo int32
-
-	ImageSize      int32
-	Image          int32
-	ImageTransform int32
-	Repeat         int32
-
-	BoxSize     int32
-	BoxVertical int32
-	BoxScale    int32
-	BoxOffset   int32
-}

backend/xmobilebackend/clip.go

@@ -35,6 +35,7 @@ func (b *XMobileBackend) Clip(pts []backendbase.Vec) {
 	b.glctx.BindBuffer(gl.ARRAY_BUFFER, b.buf)
 	b.glctx.BufferData(gl.ARRAY_BUFFER, byteSlice(unsafe.Pointer(&b.ptsBuf[0]), len(b.ptsBuf)*4), gl.STREAM_DRAW)
 	b.glctx.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, 0)
+	b.glctx.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, 0)
 
 	b.glctx.UseProgram(b.shd.ID)
 	b.glctx.Uniform4f(b.shd.Color, 1, 1, 1, 1)
@@ -44,6 +45,7 @@ func (b *XMobileBackend) Clip(pts []backendbase.Vec) {
 	b.glctx.Uniform1i(b.shd.UseAlphaTex, 0)
 	b.glctx.Uniform1i(b.shd.Func, shdFuncSolid)
 	b.glctx.EnableVertexAttribArray(b.shd.Vertex)
+	b.glctx.EnableVertexAttribArray(b.shd.TexCoord)
 
 	b.glctx.ColorMask(false, false, false, false)
 
@@ -66,6 +68,7 @@ func (b *XMobileBackend) Clip(pts []backendbase.Vec) {
 	b.glctx.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
 
 	b.glctx.DisableVertexAttribArray(b.shd.Vertex)
+	b.glctx.DisableVertexAttribArray(b.shd.TexCoord)
 
 	b.glctx.ColorMask(true, true, true, true)
 	b.glctx.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)

backend/xmobilebackend/fill.go

@@ -49,9 +49,12 @@ func (b *XMobileBackend) Clear(pts [4]backendbase.Vec) {
 	b.glctx.StencilFunc(gl.EQUAL, 0, 0xFF)
 
 	b.glctx.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, 0)
+	b.glctx.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, 0)
 	b.glctx.EnableVertexAttribArray(b.shd.Vertex)
+	b.glctx.EnableVertexAttribArray(b.shd.TexCoord)
 	b.glctx.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
 	b.glctx.DisableVertexAttribArray(b.shd.Vertex)
+	b.glctx.DisableVertexAttribArray(b.shd.TexCoord)
 
 	b.glctx.StencilFunc(gl.ALWAYS, 0, 0xFF)
 
@@ -120,9 +123,12 @@ func (b *XMobileBackend) Fill(style *backendbase.FillStyle, pts []backendbase.Ve
 
 		b.glctx.StencilFunc(gl.EQUAL, 0, 0xFF)
 		b.glctx.EnableVertexAttribArray(vertex)
+		b.glctx.EnableVertexAttribArray(b.shd.TexCoord)
 		b.glctx.VertexAttribPointer(vertex, 2, gl.FLOAT, false, 0, 0)
+		b.glctx.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, 0)
 		b.glctx.DrawArrays(mode, 4, len(pts))
 		b.glctx.DisableVertexAttribArray(vertex)
+		b.glctx.DisableVertexAttribArray(b.shd.TexCoord)
 		b.glctx.StencilFunc(gl.ALWAYS, 0, 0xFF)
 	} else {
 		b.glctx.ColorMask(false, false, false, false)
@@ -140,9 +146,12 @@ func (b *XMobileBackend) Fill(style *backendbase.FillStyle, pts []backendbase.Ve
 		b.glctx.Uniform1i(b.shd.Func, shdFuncSolid)
 
 		b.glctx.EnableVertexAttribArray(b.shd.Vertex)
+		b.glctx.EnableVertexAttribArray(b.shd.TexCoord)
 		b.glctx.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, 0)
+		b.glctx.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, 0)
 		b.glctx.DrawArrays(mode, 4, len(pts))
 		b.glctx.DisableVertexAttribArray(b.shd.Vertex)
+		b.glctx.DisableVertexAttribArray(b.shd.TexCoord)
 
 		b.glctx.ColorMask(true, true, true, true)
 
@@ -150,10 +159,13 @@ func (b *XMobileBackend) Fill(style *backendbase.FillStyle, pts []backendbase.Ve
 
 		vertex, _ := b.useShader(style, mat3identity, false, 0)
 		b.glctx.EnableVertexAttribArray(vertex)
+		b.glctx.EnableVertexAttribArray(b.shd.TexCoord)
 		b.glctx.VertexAttribPointer(vertex, 2, gl.FLOAT, false, 0, 0)
+		b.glctx.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, 0)
 
 		b.glctx.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
 		b.glctx.DisableVertexAttribArray(vertex)
+		b.glctx.DisableVertexAttribArray(b.shd.TexCoord)
 
 		b.glctx.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
 		b.glctx.StencilFunc(gl.ALWAYS, 0, 0xFF)
@@ -203,7 +215,7 @@ func (b *XMobileBackend) FillImageMask(style *backendbase.FillStyle, mask *image
 	var buf [16]float32
 	data := buf[:0]
 	for _, pt := range pts {
-		data = append(data, float32(pt[0]), float32(pt[1]))
+		data = append(data, float32(math.Round(pt[0])), float32(math.Round(pt[1])))
 	}
 	data = append(data, 0, 0, 0, float32(th), float32(tw), float32(th), float32(tw), 0)
 

canvas.go

@@ -27,10 +27,11 @@ type Canvas struct {
 	state      drawState
 	stateStack []drawState
 
-	images       map[interface{}]*Image
-	fonts        map[interface{}]*Font
-	fontCtxs     map[fontKey]*frCache
-	fontTriCache map[*Font]*fontTriCache
+	images        map[interface{}]*Image
+	fonts         map[interface{}]*Font
+	fontCtxs      map[fontKey]*frCache
+	fontPathCache map[*Font]*fontPathCache
+	fontTriCache  map[*Font]*fontTriCache
 
 	shadowBuf []backendbase.Vec
 }
@@ -139,12 +140,13 @@ var Performance = struct {
 // coordinates given here also use the bottom left as origin
 func New(backend backendbase.Backend) *Canvas {
 	cv := &Canvas{
-		b:            backend,
-		stateStack:   make([]drawState, 0, 20),
-		images:       make(map[interface{}]*Image),
-		fonts:        make(map[interface{}]*Font),
-		fontCtxs:     make(map[fontKey]*frCache),
-		fontTriCache: make(map[*Font]*fontTriCache),
+		b:             backend,
+		stateStack:    make([]drawState, 0, 20),
+		images:        make(map[interface{}]*Image),
+		fonts:         make(map[interface{}]*Font),
+		fontCtxs:      make(map[fontKey]*frCache),
+		fontPathCache: make(map[*Font]*fontPathCache),
+		fontTriCache:  make(map[*Font]*fontTriCache),
 	}
 	cv.state.lineWidth = 1
 	cv.state.lineAlpha = 1
@@ -482,6 +484,7 @@ func (cv *Canvas) reduceCache(keepSize, rec int) {
 	oldest := time.Now()
 	var oldestFontKey fontKey
 	var oldestFontKey2 *Font
+	var oldestFontKey3 *Font
 	var oldestImageKey interface{}
 	for src, img := range cv.images {
 		w, h := img.img.Size()
@@ -499,7 +502,7 @@ func (cv *Canvas) reduceCache(keepSize, rec int) {
 			oldestImageKey = nil
 		}
 	}
-	for fnt, cache := range cv.fontTriCache {
+	for fnt, cache := range cv.fontPathCache {
 		total += cache.size()
 		if cache.lastUsed.Before(oldest) {
 			oldest = cache.lastUsed
@@ -508,6 +511,16 @@ func (cv *Canvas) reduceCache(keepSize, rec int) {
 			oldestImageKey = nil
 		}
 	}
+	for fnt, cache := range cv.fontTriCache {
+		total += cache.size()
+		if cache.lastUsed.Before(oldest) {
+			oldest = cache.lastUsed
+			oldestFontKey3 = fnt
+			oldestFontKey2 = nil
+			oldestFontKey = fontKey{}
+			oldestImageKey = nil
+		}
+	}
 	if total <= keepSize {
 		return
 	}
@@ -516,7 +529,9 @@ func (cv *Canvas) reduceCache(keepSize, rec int) {
 		cv.images[oldestImageKey].Delete()
 		delete(cv.images, oldestImageKey)
 	} else if oldestFontKey2 != nil {
-		delete(cv.fontTriCache, oldestFontKey2)
+		delete(cv.fontPathCache, oldestFontKey2)
+	} else if oldestFontKey3 != nil {
+		delete(cv.fontTriCache, oldestFontKey3)
 	} else {
 		cv.fontCtxs[oldestFontKey].ctx = nil
 		delete(cv.fontCtxs, oldestFontKey)

canvas_test.go

@@ -1,657 +0,0 @@
-package canvas_test
-
-import (
-	"fmt"
-	"image"
-	_ "image/jpeg"
-	"image/png"
-	"math"
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/go-gl/gl/v3.2-core/gl"
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/softwarebackend"
-	"github.com/tfriedel6/canvas/sdlcanvas"
-)
-
-var usesw = false
-
-func run(t *testing.T, fn func(cv *canvas.Canvas)) {
-	var img *image.RGBA
-	if !usesw {
-		wnd, cv, err := sdlcanvas.CreateWindow(100, 100, "test")
-		if err != nil {
-			t.Fatalf("Failed to create window: %v", err)
-			return
-		}
-		defer wnd.Destroy()
-
-		gl.Disable(gl.MULTISAMPLE)
-
-		wnd.StartFrame()
-
-		cv.ClearRect(0, 0, 100, 100)
-		fn(cv)
-		img = cv.GetImageData(0, 0, 100, 100)
-	} else {
-		backend := softwarebackend.New(100, 100)
-		cv := canvas.New(backend)
-
-		cv.SetFillStyle("#000")
-		cv.FillRect(0, 0, 100, 100)
-		fn(cv)
-		img = cv.GetImageData(0, 0, 100, 100)
-	}
-
-	caller, _, _, ok := runtime.Caller(1)
-	if !ok {
-		t.Fatal("Failed to get caller")
-	}
-
-	callerFunc := runtime.FuncForPC(caller)
-	if callerFunc == nil {
-		t.Fatal("Failed to get caller function")
-	}
-
-	const prefix = "canvas_test.Test"
-	callerFuncName := callerFunc.Name()
-	callerFuncName = callerFuncName[strings.Index(callerFuncName, prefix)+len(prefix):]
-
-	fileName := fmt.Sprintf("testdata/%s.png", callerFuncName)
-
-	_, err := os.Stat(fileName)
-	if err != nil && !os.IsNotExist(err) {
-		t.Fatalf("Failed to stat file \"%s\": %v", fileName, err)
-	}
-
-	if os.IsNotExist(err) {
-		err = writeImage(img, fileName)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return
-	}
-
-	f, err := os.Open(fileName)
-	if err != nil {
-		t.Fatalf("Failed to open file \"%s\": %v", fileName, err)
-	}
-	defer f.Close()
-
-	refImg, err := png.Decode(f)
-	if err != nil {
-		t.Fatalf("Failed to decode file \"%s\": %v", fileName, err)
-	}
-
-	if b := img.Bounds(); b.Min.X != 0 || b.Min.Y != 0 || b.Max.X != 100 || b.Max.Y != 100 {
-		t.Fatalf("Image bounds must be 0,0,100,100")
-	}
-	if b := refImg.Bounds(); b.Min.X != 0 || b.Min.Y != 0 || b.Max.X != 100 || b.Max.Y != 100 {
-		t.Fatalf("Image bounds must be 0,0,100,100")
-	}
-
-	for y := 0; y < 100; y++ {
-		for x := 0; x < 100; x++ {
-			r1, g1, b1, a1 := img.At(x, y).RGBA()
-			r2, g2, b2, a2 := refImg.At(x, y).RGBA()
-			if r1 != r2 || g1 != g2 || b1 != b2 || a1 != a2 {
-				writeImage(img, fmt.Sprintf("testdata/%s_fail.png", callerFuncName))
-				t.FailNow()
-			}
-		}
-	}
-}
-
-func writeImage(img *image.RGBA, fileName string) error {
-	f, err := os.OpenFile(fileName, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0777)
-	if err != nil {
-		return fmt.Errorf("Failed to create file \"%s\"", fileName)
-	}
-	defer f.Close()
-
-	err = png.Encode(f, img)
-	if err != nil {
-		return fmt.Errorf("Failed to encode PNG")
-	}
-	return nil
-}
-
-func TestFillRect(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFillStyle("#F00")
-		cv.FillRect(10, 10, 10, 10)
-
-		cv.SetFillStyle("#F008")
-		cv.FillRect(30, 10, 10, 10)
-
-		cv.SetFillStyle(64, 96, 128, 160)
-		cv.FillRect(50, 10, 10, 10)
-
-		cv.SetFillStyle(0.5, 0.7, 0.2, 0.8)
-		cv.FillRect(70, 10, 10, 10)
-	})
-}
-
-func TestFillConvexPath(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFillStyle("#0F0")
-		cv.BeginPath()
-		cv.MoveTo(20, 20)
-		cv.LineTo(60, 20)
-		cv.LineTo(80, 80)
-		cv.LineTo(40, 80)
-		cv.ClosePath()
-		cv.Fill()
-	})
-}
-func TestFillConcavePath(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFillStyle("#0F0")
-		cv.BeginPath()
-		cv.MoveTo(20, 20)
-		cv.LineTo(60, 20)
-		cv.LineTo(60, 60)
-		cv.LineTo(50, 60)
-		cv.LineTo(50, 40)
-		cv.LineTo(20, 40)
-		cv.ClosePath()
-		cv.Fill()
-	})
-}
-
-func TestFillHammer(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFillStyle("#0F0")
-		cv.BeginPath()
-		cv.Translate(50, 50)
-		cv.Scale(0.7, 0.7)
-		cv.MoveTo(-6, 60)
-		cv.LineTo(-6, -50)
-		cv.LineTo(-25, -50)
-		cv.LineTo(-12, -60)
-		cv.LineTo(25, -60)
-		cv.LineTo(25, -50)
-		cv.LineTo(6, -50)
-		cv.LineTo(6, 60)
-		cv.ClosePath()
-		cv.Fill()
-	})
-}
-
-func TestDrawPath(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#00F")
-		cv.SetLineJoin(canvas.Miter)
-		cv.SetLineWidth(8)
-		cv.BeginPath()
-		cv.MoveTo(10, 10)
-		cv.LineTo(30, 10)
-		cv.LineTo(30, 30)
-		cv.LineTo(10, 30)
-		cv.ClosePath()
-		cv.Stroke()
-
-		cv.SetLineJoin(canvas.Round)
-		cv.BeginPath()
-		cv.MoveTo(40, 10)
-		cv.LineTo(60, 10)
-		cv.LineTo(60, 30)
-		cv.LineTo(40, 30)
-		cv.ClosePath()
-		cv.Stroke()
-
-		cv.SetLineJoin(canvas.Bevel)
-		cv.BeginPath()
-		cv.MoveTo(70, 10)
-		cv.LineTo(90, 10)
-		cv.LineTo(90, 30)
-		cv.LineTo(70, 30)
-		cv.ClosePath()
-		cv.Stroke()
-
-		cv.SetLineCap(canvas.Butt)
-		cv.BeginPath()
-		cv.MoveTo(10, 40)
-		cv.LineTo(30, 40)
-		cv.LineTo(30, 60)
-		cv.LineTo(10, 60)
-		cv.Stroke()
-
-		cv.SetLineCap(canvas.Round)
-		cv.BeginPath()
-		cv.MoveTo(40, 40)
-		cv.LineTo(60, 40)
-		cv.LineTo(60, 60)
-		cv.LineTo(40, 60)
-		cv.Stroke()
-
-		cv.SetLineCap(canvas.Square)
-		cv.BeginPath()
-		cv.MoveTo(70, 40)
-		cv.LineTo(90, 40)
-		cv.LineTo(90, 60)
-		cv.LineTo(70, 60)
-		cv.Stroke()
-	})
-}
-
-func TestMiterLimit(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#0F0")
-		cv.SetLineJoin(canvas.Miter)
-		cv.SetLineWidth(2.5)
-		cv.SetMiterLimit(30)
-		y, step := 20.0, 4.0
-		for i := 0; i < 20; i++ {
-			cv.LineTo(20, y)
-			y += step
-			cv.LineTo(80, y)
-			y += step
-			step *= 0.9
-		}
-		cv.Stroke()
-	})
-}
-
-func TestLineDash(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#0F0")
-		cv.SetLineWidth(2.5)
-		cv.SetLineDash([]float64{4, 6, 8})
-		cv.BeginPath()
-		cv.MoveTo(20, 20)
-		cv.LineTo(80, 20)
-		cv.LineTo(80, 80)
-		cv.LineTo(50, 80)
-		cv.LineTo(50, 50)
-		cv.LineTo(20, 50)
-		cv.ClosePath()
-		cv.MoveTo(30, 30)
-		cv.LineTo(70, 30)
-		cv.LineTo(70, 70)
-		cv.LineTo(60, 70)
-		cv.LineTo(60, 40)
-		cv.LineTo(30, 40)
-		cv.ClosePath()
-		cv.Stroke()
-		ld := cv.GetLineDash()
-		if ld[0] != 4 || ld[1] != 6 || ld[2] != 8 || ld[3] != 4 || ld[4] != 6 || ld[5] != 8 {
-			t.Fail()
-		}
-	})
-}
-
-func TestLineDashOffset(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#0F0")
-		cv.SetLineWidth(2.5)
-		cv.SetLineDash([]float64{4, 6, 8})
-		cv.SetLineDashOffset(5)
-		cv.BeginPath()
-		cv.MoveTo(20, 20)
-		cv.LineTo(80, 20)
-		cv.LineTo(80, 80)
-		cv.LineTo(50, 80)
-		cv.LineTo(50, 50)
-		cv.LineTo(20, 50)
-		cv.ClosePath()
-		cv.MoveTo(30, 30)
-		cv.LineTo(70, 30)
-		cv.LineTo(70, 70)
-		cv.LineTo(60, 70)
-		cv.LineTo(60, 40)
-		cv.LineTo(30, 40)
-		cv.ClosePath()
-		cv.Stroke()
-		ld := cv.GetLineDash()
-		if ld[0] != 4 || ld[1] != 6 || ld[2] != 8 || ld[3] != 4 || ld[4] != 6 || ld[5] != 8 {
-			t.Fail()
-		}
-	})
-}
-
-func TestCurves(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#00F")
-		cv.SetLineWidth(2.5)
-		cv.BeginPath()
-		cv.Arc(30, 30, 15, 0, 4, false)
-		cv.ClosePath()
-		cv.MoveTo(30, 70)
-		cv.LineTo(40, 70)
-		cv.ArcTo(50, 70, 50, 55, 5)
-		cv.ArcTo(50, 40, 55, 40, 5)
-		cv.QuadraticCurveTo(70, 40, 80, 60)
-		cv.BezierCurveTo(70, 80, 60, 80, 50, 90)
-		cv.Stroke()
-	})
-}
-
-func TestAlpha(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#F00")
-		cv.SetLineWidth(2.5)
-		cv.BeginPath()
-		cv.Arc(30, 30, 15, 0, 4, false)
-		cv.ClosePath()
-		cv.MoveTo(30, 70)
-		cv.LineTo(40, 70)
-		cv.ArcTo(50, 70, 50, 55, 5)
-		cv.ArcTo(50, 40, 55, 40, 5)
-		cv.QuadraticCurveTo(70, 40, 80, 60)
-		cv.BezierCurveTo(70, 80, 60, 80, 50, 90)
-		cv.Stroke()
-
-		cv.SetStrokeStyle("#0F08")
-		cv.SetLineWidth(5)
-		cv.BeginPath()
-		cv.MoveTo(10, 10)
-		cv.LineTo(90, 90)
-		cv.LineTo(90, 10)
-		cv.LineTo(10, 90)
-		cv.ClosePath()
-		cv.Stroke()
-
-		cv.SetGlobalAlpha(0.5)
-		cv.SetStrokeStyle("#FFF8")
-		cv.SetLineWidth(8)
-		cv.BeginPath()
-		cv.MoveTo(50, 10)
-		cv.LineTo(50, 90)
-		cv.Stroke()
-	})
-}
-
-func TestClosePath(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#0F0")
-		cv.SetLineWidth(2.5)
-		cv.BeginPath()
-		cv.MoveTo(20, 20)
-		cv.LineTo(40, 20)
-		cv.LineTo(40, 40)
-		cv.LineTo(20, 40)
-		cv.ClosePath()
-		cv.MoveTo(60, 20)
-		cv.LineTo(80, 20)
-		cv.LineTo(80, 40)
-		cv.LineTo(60, 40)
-		cv.ClosePath()
-		cv.Stroke()
-
-		cv.SetFillStyle("#00F")
-		cv.BeginPath()
-		cv.MoveTo(20, 60)
-		cv.LineTo(40, 60)
-		cv.LineTo(40, 80)
-		cv.LineTo(20, 80)
-		cv.ClosePath()
-		cv.MoveTo(60, 60)
-		cv.LineTo(80, 60)
-		cv.LineTo(80, 80)
-		cv.LineTo(60, 80)
-		cv.ClosePath()
-		cv.Fill()
-	})
-}
-
-func TestLineDash2(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#0F0")
-		cv.SetLineWidth(2.5)
-		cv.BeginPath()
-		cv.MoveTo(20, 20)
-		cv.LineTo(40, 20)
-		cv.LineTo(40, 40)
-		cv.LineTo(20, 40)
-		cv.ClosePath()
-		cv.MoveTo(60, 20)
-		cv.LineTo(80, 20)
-		cv.LineTo(80, 40)
-		cv.LineTo(60, 40)
-		cv.ClosePath()
-		cv.SetLineDash([]float64{4, 4})
-		cv.MoveTo(20, 60)
-		cv.LineTo(40, 60)
-		cv.LineTo(40, 80)
-		cv.LineTo(20, 80)
-		cv.ClosePath()
-		cv.MoveTo(60, 60)
-		cv.LineTo(80, 60)
-		cv.LineTo(80, 80)
-		cv.LineTo(60, 80)
-		cv.ClosePath()
-		cv.Stroke()
-	})
-}
-func TestText(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFont("testdata/Roboto-Light.ttf", 48)
-		cv.SetFillStyle("#F00")
-		cv.FillText("A BC", 0, 46)
-		cv.SetStrokeStyle("#0F0")
-		cv.SetLineWidth(1)
-		cv.StrokeText("D EF", 0, 90)
-	})
-}
-
-func TestConvex(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFillStyle("#F00")
-		cv.BeginPath()
-		cv.MoveTo(10, 10)
-		cv.LineTo(20, 10)
-		cv.LineTo(20, 20)
-		cv.LineTo(10, 20)
-		cv.LineTo(10, 10)
-		cv.ClosePath()
-		cv.Fill()
-
-		cv.SetFillStyle("#0F0")
-		cv.BeginPath()
-		cv.MoveTo(30, 10)
-		cv.LineTo(40, 10)
-		cv.LineTo(40, 15)
-		cv.LineTo(35, 15)
-		cv.LineTo(35, 20)
-		cv.LineTo(40, 20)
-		cv.LineTo(40, 25)
-		cv.LineTo(30, 25)
-		cv.ClosePath()
-		cv.Fill()
-
-		cv.SetFillStyle("#00F")
-		cv.BeginPath()
-		cv.MoveTo(50, 10)
-		cv.LineTo(50, 25)
-		cv.LineTo(60, 25)
-		cv.LineTo(60, 20)
-		cv.LineTo(55, 20)
-		cv.LineTo(55, 15)
-		cv.LineTo(60, 15)
-		cv.LineTo(60, 10)
-		cv.ClosePath()
-		cv.Fill()
-
-		cv.SetFillStyle("#FFF")
-		cv.BeginPath()
-		cv.MoveTo(20, 35)
-		cv.LineTo(80, 35)
-		cv.ArcTo(90, 35, 90, 45, 10)
-		cv.LineTo(90, 80)
-		cv.ArcTo(90, 90, 80, 90, 10)
-		cv.LineTo(20, 90)
-		cv.ArcTo(10, 90, 10, 80, 10)
-		cv.LineTo(10, 45)
-		cv.ArcTo(10, 35, 20, 35, 10)
-		cv.ClosePath()
-		cv.Fill()
-	})
-}
-
-func TestConvexSelfIntersecting(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFillStyle("#F00")
-		cv.BeginPath()
-		cv.MoveTo(33.7, 31.5)
-		cv.LineTo(35.4, 55.0)
-		cv.LineTo(53.0, 33.5)
-		cv.LineTo(56.4, 62.4)
-		cv.ClosePath()
-		cv.Fill()
-	})
-}
-
-func TestTransform(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		path := cv.NewPath2D()
-		path.MoveTo(-10, -10)
-		path.LineTo(10, -10)
-		path.LineTo(0, 10)
-		path.ClosePath()
-
-		cv.Translate(40, 20)
-		cv.BeginPath()
-		cv.LineTo(10, 10)
-		cv.LineTo(30, 10)
-		cv.LineTo(20, 30)
-		cv.ClosePath()
-		cv.SetStrokeStyle("#F00")
-		cv.Stroke()
-		cv.SetStrokeStyle("#0F0")
-		cv.StrokePath(path)
-		cv.Translate(20, 0)
-		cv.SetStrokeStyle("#00F")
-		cv.StrokePath(path)
-		cv.Translate(-40, 30)
-		cv.BeginPath()
-		cv.LineTo(10, 10)
-		cv.LineTo(30, 10)
-		cv.LineTo(20, 30)
-		cv.ClosePath()
-		cv.Translate(20, 0)
-		cv.SetStrokeStyle("#FF0")
-		cv.Stroke()
-		cv.Translate(20, 0)
-		cv.SetStrokeStyle("#F0F")
-		cv.StrokePath(path)
-	})
-}
-
-func TestTransform2(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetStrokeStyle("#FFF")
-		cv.SetLineWidth(16)
-		cv.MoveTo(20, 20)
-		cv.LineTo(20, 50)
-		cv.Scale(2, 1)
-		cv.LineTo(45, 80)
-		cv.SetLineJoin(canvas.Round)
-		cv.SetLineCap(canvas.Round)
-		cv.Stroke()
-	})
-}
-
-func TestImage(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.DrawImage("testdata/cat.jpg", 5, 5, 40, 40)
-		cv.DrawImage("testdata/cat.jpg", 100, 100, 100, 100, 55, 55, 40, 40)
-		cv.Save()
-		cv.Translate(75, 25)
-		cv.Rotate(math.Pi / 2)
-		cv.Translate(-20, -20)
-		cv.DrawImage("testdata/cat.jpg", 0, 0, 40, 40)
-		cv.Restore()
-		cv.SetTransform(1, 0, 0.2, 1, 0, 0)
-		cv.DrawImage("testdata/cat.jpg", -8, 55, 40, 40)
-	})
-}
-
-func TestGradient(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.Translate(50, 50)
-		cv.Scale(0.8, 0.7)
-		cv.Rotate(math.Pi * 0.1)
-		cv.Translate(-50, -50)
-
-		lg := cv.CreateLinearGradient(10, 10, 40, 20)
-		lg.AddColorStop(0, 0.5, 0, 0)
-		lg.AddColorStop(0.5, "#008000")
-		lg.AddColorStop(1, 0, 0, 128)
-		cv.SetFillStyle(lg)
-		cv.FillRect(0, 0, 50, 100)
-
-		rg := cv.CreateRadialGradient(75, 15, 10, 75, 75, 20)
-		rg.AddColorStop(0, 1.0, 0, 0, 0.5)
-		rg.AddColorStop(0.5, "#00FF0080")
-		rg.AddColorStop(1, 0, 0, 255, 128)
-		cv.SetFillStyle(rg)
-		cv.FillRect(50, 0, 50, 100)
-	})
-}
-
-func TestImagePattern(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.Translate(50, 50)
-		cv.Scale(0.95, 1.05)
-		cv.Rotate(-math.Pi * 0.1)
-
-		cv.SetFillStyle("testdata/cat.jpg")
-		cv.FillRect(-40, -40, 80, 80)
-	})
-}
-
-func TestImagePattern2(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		ptrn := cv.CreatePattern("testdata/cat.jpg", canvas.NoRepeat)
-		ptrn.SetTransform([6]float64{0, 0.1, 0.1, 0, 0, 0})
-
-		cv.Translate(50, 50)
-		cv.Scale(0.95, 1.05)
-		cv.Rotate(-math.Pi * 0.1)
-
-		cv.SetFillStyle(ptrn)
-		cv.FillRect(-40, -40, 80, 80)
-	})
-}
-
-func TestShadow(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		cv.SetFillStyle("#800")
-		cv.SetShadowColor("#00F")
-		cv.SetShadowOffset(6, 6)
-		cv.FillRect(10, 10, 60, 25)
-		cv.SetShadowBlur(6)
-		cv.FillRect(10, 55, 60, 25)
-		cv.SetFillStyle("#0F0")
-		cv.SetShadowColor("#F0F")
-		cv.SetGlobalAlpha(0.5)
-		cv.FillRect(50, 15, 30, 60)
-	})
-}
-
-func TestReadme(t *testing.T) {
-	run(t, func(cv *canvas.Canvas) {
-		w, h := 100.0, 100.0
-		cv.SetFillStyle("#000")
-		cv.FillRect(0, 0, w, h)
-
-		for r := 0.0; r < math.Pi*2; r += math.Pi * 0.1 {
-			cv.SetFillStyle(int(r*10), int(r*20), int(r*40))
-			cv.BeginPath()
-			cv.MoveTo(w*0.5, h*0.5)
-			cv.Arc(w*0.5, h*0.5, math.Min(w, h)*0.4, r, r+0.1*math.Pi, false)
-			cv.ClosePath()
-			cv.Fill()
-		}
-
-		cv.SetStrokeStyle("#FFF")
-		cv.SetLineWidth(10)
-		cv.BeginPath()
-		cv.Arc(w*0.5, h*0.5, math.Min(w, h)*0.4, 0, math.Pi*2, false)
-		cv.Stroke()
-	})
-}

color.go

@@ -199,14 +199,16 @@ func parseColor(value ...interface{}) (c color.RGBA, ok bool) {
 				}
 			} else {
 				v = strings.Replace(v, " ", "", -1)
-				var ir, ig, ib, ia int
+				var ir, ig, ib int
 				n, err := fmt.Sscanf(v, "rgb(%d,%d,%d)", &ir, &ig, &ib)
 				if err == nil && n == 3 {
 					return color.RGBA{R: uint8(ir), G: uint8(ig), B: uint8(ib), A: 255}, true
 				}
-				n, err = fmt.Sscanf(v, "rgba(%d,%d,%d,%d)", &ir, &ig, &ib, &ia)
+				var fa float64
+				n, err = fmt.Sscanf(v, "rgba(%d,%d,%d,%f)", &ir, &ig, &ib, &fa)
+				fa = math.Max(0, math.Min(1, fa))
 				if err == nil && n == 4 {
-					return color.RGBA{R: uint8(ir), G: uint8(ig), B: uint8(ib), A: uint8(ia)}, true
+					return color.RGBA{R: uint8(ir), G: uint8(ig), B: uint8(ib), A: uint8(fa * 255)}, true
 				}
 			}
 		}

earcut.go

@@ -0,0 +1,907 @@
+package canvas
+
+import (
+	"math"
+	"sort"
+
+	"github.com/tfriedel6/canvas/backend/backendbase"
+)
+
+// Go port of https://github.com/mapbox/earcut.hpp
+
+type node struct {
+	i    int
+	x, y float64
+
+	// previous and next vertice nodes in a polygon ring
+	prev *node
+	next *node
+
+	// z-order curve value
+	z int
+
+	// previous and next nodes in z-order
+	prevZ *node
+	nextZ *node
+
+	// indicates whether this is a steiner point
+	steiner bool
+}
+
+type earcut struct {
+	indices    []int
+	vertices   int
+	hashing    bool
+	minX, minY float64
+	maxX, maxY float64
+	invSize    float64
+	nodes      []node
+}
+
+func (ec *earcut) run(points [][]backendbase.Vec) {
+	if len(points) == 0 {
+		return
+	}
+
+	var x, y float64
+	threshold := 80
+	ln := 0
+
+	for i := 0; threshold >= 0 && i < len(points); i++ {
+		threshold -= len(points[i])
+		ln += len(points[i])
+	}
+
+	//estimate size of nodes and indices
+	ec.nodes = make([]node, 0, ln*3/2)
+	ec.indices = make([]int, 0, ln+len(points[0]))
+	ec.vertices = 0
+
+	outerNode := ec.linkedList(points[0], true)
+	if outerNode == nil || outerNode.prev == outerNode.next {
+		return
+	}
+
+	if len(points) > 1 {
+		outerNode = ec.eliminateHoles(points, outerNode)
+	}
+
+	// if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+	ec.hashing = threshold < 0
+	if ec.hashing {
+		p := outerNode.next
+		ec.minX, ec.maxX = outerNode.x, outerNode.x
+		ec.minY, ec.maxY = outerNode.y, outerNode.y
+		for {
+			x = p.x
+			y = p.y
+			ec.minX = math.Min(ec.minX, x)
+			ec.minY = math.Min(ec.minY, y)
+			ec.maxX = math.Min(ec.maxX, x)
+			ec.maxY = math.Min(ec.maxY, y)
+			p = p.next
+			if p != outerNode {
+				break
+			}
+		}
+
+		// minX, minY and size are later used to transform coords into integers for z-order calculation
+		ec.invSize = math.Max(ec.maxX-ec.minX, ec.maxY-ec.minY)
+		if ec.invSize != 0 {
+			ec.invSize = 1 / ec.invSize
+		}
+	}
+
+	ec.earcutLinked(outerNode, 0)
+
+	ec.nodes = ec.nodes[:0]
+}
+
+// create a circular doubly linked list from polygon points in the specified winding order
+func (ec *earcut) linkedList(points []backendbase.Vec, clockwise bool) *node {
+	var sum float64
+	ln := len(points)
+	var i, j int
+	var last *node
+
+	// calculate original winding order of a polygon ring
+	if ln > 0 {
+		j = ln - 1
+	}
+	for i < ln {
+		p1 := points[i]
+		p2 := points[j]
+		p20 := p2[0]
+		p10 := p1[0]
+		p11 := p1[1]
+		p21 := p2[1]
+		sum += (p20 - p10) * (p11 + p21)
+		j = i
+		i++
+	}
+
+	// link points into circular doubly-linked list in the specified winding order
+	if clockwise == (sum > 0) {
+		for i := 0; i < ln; i++ {
+			last = ec.insertNode(ec.vertices+i, points[i], last)
+		}
+	} else {
+		for i = ln - 1; i >= 0; i-- {
+			last = ec.insertNode(ec.vertices+i, points[i], last)
+		}
+	}
+
+	if last != nil && ec.equals(last, last.next) {
+		ec.removeNode(last)
+		last = last.next
+	}
+
+	ec.vertices += ln
+
+	return last
+}
+
+// eliminate colinear or duplicate points
+func (ec *earcut) filterPoints(start, end *node) *node {
+	if end == nil {
+		end = start
+	}
+
+	p := start
+	var again bool
+	for {
+		again = false
+
+		if !p.steiner && (ec.equals(p, p.next) || ec.area(p.prev, p, p.next) == 0) {
+			ec.removeNode(p)
+			p, end = p.prev, p.prev
+
+			if p == p.next {
+				break
+			}
+			again = true
+
+		} else {
+			p = p.next
+		}
+		if !again && p == end {
+			break
+		}
+	}
+
+	return end
+}
+
+// main ear slicing loop which triangulates a polygon (given as a linked list)
+func (ec *earcut) earcutLinked(ear *node, pass int) {
+	if ear == nil {
+		return
+	}
+
+	// interlink polygon nodes in z-order
+	if pass == 0 && ec.hashing {
+		ec.indexCurve(ear)
+	}
+
+	stop := ear
+	var prev, next *node
+
+	iterations := 0
+
+	// iterate through ears, slicing them one by one
+	for ear.prev != ear.next {
+		iterations++
+		prev = ear.prev
+		next = ear.next
+
+		var e bool
+		if ec.hashing {
+			e = ec.isEarHashed(ear)
+		} else {
+			e = ec.isEar(ear)
+		}
+		if e {
+			// cut off the triangle
+			ec.indices = append(ec.indices, prev.i, ear.i, next.i)
+
+			ec.removeNode(ear)
+
+			// skipping the next vertice leads to less sliver triangles
+			ear = next.next
+			stop = next.next
+
+			continue
+		}
+
+		ear = next
+
+		// if we looped through the whole remaining polygon and can't find any more ears
+		if ear == stop {
+			// try filtering points and slicing again
+			if pass == 0 {
+				ec.earcutLinked(ec.filterPoints(ear, nil), 1)
+			} else if pass == 1 {
+				// if this didn't work, try curing all small self-intersections locally
+				ear = ec.cureLocalIntersections(ec.filterPoints(ear, nil))
+				ec.earcutLinked(ear, 2)
+			} else if pass == 2 {
+				// as a last resort, try splitting the remaining polygon into two
+				ec.splitEarcut(ear)
+			}
+
+			break
+		}
+	}
+}
+
+// check whether a polygon node forms a valid ear with adjacent nodes
+func (ec *earcut) isEar(ear *node) bool {
+	a := ear.prev
+	b := ear
+	c := ear.next
+
+	if ec.area(a, b, c) >= 0 {
+		return false // reflex, can't be an ear
+	}
+
+	// now make sure we don't have other points inside the potential ear
+	p := ear.next.next
+
+	for p != ear.prev {
+		if ec.pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+			ec.area(p.prev, p, p.next) >= 0 {
+			return false
+		}
+		p = p.next
+	}
+
+	return true
+}
+
+func (ec *earcut) isEarHashed(ear *node) bool {
+	a := ear.prev
+	b := ear
+	c := ear.next
+
+	if ec.area(a, b, c) >= 0 {
+		return false // reflex, can't be an ear
+	}
+
+	// triangle bbox; min & max are calculated like this for speed
+
+	minTX := math.Min(a.x, math.Min(b.x, c.x))
+	minTY := math.Min(a.y, math.Min(b.y, c.y))
+	maxTX := math.Max(a.x, math.Max(b.x, c.x))
+	maxTY := math.Max(a.y, math.Max(b.y, c.y))
+
+	// z-order range for the current triangle bbox;
+	minZ := ec.zOrder(minTX, minTY)
+	maxZ := ec.zOrder(maxTX, maxTY)
+
+	// first look for points inside the triangle in increasing z-order
+	p := ear.nextZ
+
+	for p != nil && p.z <= maxZ {
+		if p != ear.prev && p != ear.next &&
+			ec.pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+			ec.area(p.prev, p, p.next) >= 0 {
+			return false
+		}
+		p = p.nextZ
+	}
+
+	// then look for points in decreasing z-order
+	p = ear.prevZ
+
+	for p != nil && p.z >= minZ {
+		if p != ear.prev && p != ear.next &&
+			ec.pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+			ec.area(p.prev, p, p.next) >= 0 {
+			return false
+		}
+		p = p.prevZ
+	}
+
+	return true
+}
+
+// go through all polygon nodes and cure small local self-intersections
+func (ec *earcut) cureLocalIntersections(start *node) *node {
+	p := start
+	for {
+		a := p.prev
+		b := p.next.next
+
+		// a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])
+		if !ec.equals(a, b) && ec.intersects(a, p, p.next, b) && ec.locallyInside(a, b) && ec.locallyInside(b, a) {
+			ec.indices = append(ec.indices, a.i, p.i, b.i)
+
+			// remove two nodes involved
+			ec.removeNode(p)
+			ec.removeNode(p.next)
+
+			p, start = b, b
+		}
+		p = p.next
+		if p == start {
+			break
+		}
+	}
+
+	return ec.filterPoints(p, nil)
+}
+
+// try splitting polygon into two and triangulate them independently
+func (ec *earcut) splitEarcut(start *node) {
+	// look for a valid diagonal that divides the polygon into two
+	a := start
+	for {
+		b := a.next.next
+		for b != a.prev {
+			if a.i != b.i && ec.isValidDiagonal(a, b) {
+				// split the polygon in two by the diagonal
+				c := ec.splitPolygon(a, b)
+
+				// filter colinear points around the cuts
+				a = ec.filterPoints(a, a.next)
+				c = ec.filterPoints(c, c.next)
+
+				// run earcut on each half
+				ec.earcutLinked(a, 0)
+				ec.earcutLinked(c, 0)
+				return
+			}
+			b = b.next
+		}
+		a = a.next
+		if a == start {
+			break
+		}
+	}
+}
+
+// link every hole into the outer loop, producing a single-ring polygon without holes
+func (ec *earcut) eliminateHoles(points [][]backendbase.Vec, outerNode *node) *node {
+	ln := len(points)
+
+	queue := make([]*node, 0, ln)
+	for i := 1; i < ln; i++ {
+		list := ec.linkedList(points[i], false)
+		if list != nil {
+			if list == list.next {
+				list.steiner = true
+			}
+			queue = append(queue, ec.getLeftmost(list))
+		}
+	}
+	sort.Slice(queue, func(a, b int) bool {
+		return queue[a].x < queue[b].x
+	})
+
+	// process holes from left to right
+	for i := 0; i < len(queue); i++ {
+		ec.eliminateHole(queue[i], outerNode)
+		outerNode = ec.filterPoints(outerNode, outerNode.next)
+	}
+
+	return outerNode
+}
+
+// find a bridge between vertices that connects hole with an outer ring and and link it
+func (ec *earcut) eliminateHole(hole, outerNode *node) {
+	outerNode = ec.findHoleBridge(hole, outerNode)
+	if outerNode != nil {
+		b := ec.splitPolygon(outerNode, hole)
+
+		// filter out colinear points around cuts
+		ec.filterPoints(outerNode, outerNode.next)
+		ec.filterPoints(b, b.next)
+	}
+}
+
+// David Eberly's algorithm for finding a bridge between hole and outer polygon
+func (ec *earcut) findHoleBridge(hole, outerNode *node) *node {
+	p := outerNode
+	hx := hole.x
+	hy := hole.y
+	qx := math.Inf(-1)
+	var m *node
+
+	// find a segment intersected by a ray from the hole's leftmost Vertex to the left;
+	// segment's endpoint with lesser x will be potential connection Vertex
+	for {
+		if hy <= p.y && hy >= p.next.y && p.next.y != p.y {
+			x := p.x + (hy-p.y)*(p.next.x-p.x)/(p.next.y-p.y)
+			if x <= hx && x > qx {
+				qx = x
+				if x == hx {
+					if hy == p.y {
+						return p
+					}
+					if hy == p.next.y {
+						return p.next
+					}
+				}
+				if p.x < p.next.x {
+					m = p
+				} else {
+					m = p.next
+				}
+			}
+		}
+		p = p.next
+		if p == outerNode {
+			break
+		}
+	}
+
+	if m == nil {
+		return nil
+	}
+
+	if hx == qx {
+		return m // hole touches outer segment; pick leftmost endpoint
+	}
+
+	// look for points inside the triangle of hole Vertex, segment intersection and endpoint;
+	// if there are no points found, we have a valid connection;
+	// otherwise choose the Vertex of the minimum angle with the ray as connection Vertex
+
+	stop := m
+	tanMin := math.Inf(1)
+	tanCur := 0.0
+
+	p = m
+	mx := m.x
+	my := m.y
+
+	for {
+		var pt1, pt2 float64
+		if hy < my {
+			pt1 = hx
+			pt2 = qx
+		} else {
+			pt1 = qx
+			pt2 = hx
+		}
+		if hx >= p.x && p.x >= mx && hx != p.x &&
+			ec.pointInTriangle(pt1, hy, mx, my, pt2, hy, p.x, p.y) {
+
+			tanCur = math.Abs(hy-p.y) / (hx - p.x) // tangential
+
+			if ec.locallyInside(p, hole) &&
+				(tanCur < tanMin || (tanCur == tanMin && (p.x > m.x || ec.sectorContainsSector(m, p)))) {
+				m = p
+				tanMin = tanCur
+			}
+		}
+
+		p = p.next
+		if p == stop {
+			break
+		}
+	}
+
+	return m
+}
+
+// whether sector in vertex m contains sector in vertex p in the same coordinates
+func (ec *earcut) sectorContainsSector(m, p *node) bool {
+	return ec.area(m.prev, m, p.prev) < 0 && ec.area(p.next, m, m.next) < 0
+}
+
+// interlink polygon nodes in z-order
+func (ec *earcut) indexCurve(start *node) {
+	if start == nil {
+		panic("start must not be nil")
+	}
+	p := start
+
+	for {
+		if p.z <= 0 {
+			p.z = ec.zOrder(p.x, p.y)
+		}
+		p.prevZ = p.prev
+		p.nextZ = p.next
+		p = p.next
+		if p == start {
+			break
+		}
+	}
+
+	p.prevZ.nextZ = nil
+	p.prevZ = nil
+
+	ec.sortLinked(p)
+}
+
+// Simon Tatham's linked list merge sort algorithm
+// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+func (ec *earcut) sortLinked(list *node) *node {
+	if list == nil {
+		panic("list must not be nil")
+	}
+	var p, q, e, tail *node
+	var i, numMerges, pSize, qSize int
+	inSize := 1
+
+	for {
+		p = list
+		list = nil
+		tail = nil
+		numMerges = 0
+
+		for p != nil {
+			numMerges++
+			q = p
+			pSize = 0
+			for i = 0; i < inSize; i++ {
+				pSize++
+				q = q.nextZ
+				if q == nil {
+					break
+				}
+			}
+
+			qSize = inSize
+
+			for pSize > 0 || (qSize > 0 && q != nil) {
+
+				if pSize == 0 {
+					e = q
+					q = q.nextZ
+					qSize--
+				} else if qSize == 0 || q == nil {
+					e = p
+					p = p.nextZ
+					pSize--
+				} else if p.z <= q.z {
+					e = p
+					p = p.nextZ
+					pSize--
+				} else {
+					e = q
+					q = q.nextZ
+					qSize--
+				}
+
+				if tail != nil {
+					tail.nextZ = e
+				} else {
+					list = e
+				}
+
+				e.prevZ = tail
+				tail = e
+			}
+
+			p = q
+		}
+
+		tail.nextZ = nil
+
+		if numMerges <= 1 {
+			return list
+		}
+
+		inSize *= 2
+	}
+}
+
+// z-order of a Vertex given coords and size of the data bounding box
+func (ec *earcut) zOrder(x, y float64) int {
+	// coords are transformed into non-negative 15-bit integer range
+	x2 := int(32767.0 * (x - ec.minX) * ec.invSize)
+	y2 := int(32767.0 * (y - ec.minY) * ec.invSize)
+
+	x2 = (x2 | (x2 << 8)) & 0x00FF00FF
+	x2 = (x2 | (x2 << 4)) & 0x0F0F0F0F
+	x2 = (x2 | (x2 << 2)) & 0x33333333
+	x2 = (x2 | (x2 << 1)) & 0x55555555
+
+	y2 = (y2 | (y2 << 8)) & 0x00FF00FF
+	y2 = (y2 | (y2 << 4)) & 0x0F0F0F0F
+	y2 = (y2 | (y2 << 2)) & 0x33333333
+	y2 = (y2 | (y2 << 1)) & 0x55555555
+
+	return x2 | (y2 << 1)
+}
+
+// find the leftmost node of a polygon ring
+func (ec *earcut) getLeftmost(start *node) *node {
+	p := start
+	leftmost := start
+	for {
+		if p.x < leftmost.x || (p.x == leftmost.x && p.y < leftmost.y) {
+			leftmost = p
+		}
+		p = p.next
+		if p == start {
+			break
+		}
+	}
+
+	return leftmost
+}
+
+// check if a point lies within a convex triangle
+func (ec *earcut) pointInTriangle(ax, ay, bx, by, cx, cy, px, py float64) bool {
+	return (cx-px)*(ay-py)-(ax-px)*(cy-py) >= 0 &&
+		(ax-px)*(by-py)-(bx-px)*(ay-py) >= 0 &&
+		(bx-px)*(cy-py)-(cx-px)*(by-py) >= 0
+}
+
+// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+func (ec *earcut) isValidDiagonal(a, b *node) bool {
+	return a.next.i != b.i && a.prev.i != b.i && !ec.intersectsPolygon(a, b) && // dones't intersect other edges
+		((ec.locallyInside(a, b) && ec.locallyInside(b, a) && ec.middleInside(a, b) && // locally visible
+			(ec.area(a.prev, a, b.prev) != 0.0 || ec.area(a, b.prev, b) != 0.0)) || // does not create opposite-facing sectors
+			(ec.equals(a, b) && ec.area(a.prev, a, a.next) > 0 && ec.area(b.prev, b, b.next) > 0)) // special zero-length case
+}
+
+// signed area of a triangle
+func (ec *earcut) area(p, q, r *node) float64 {
+	return (q.y-p.y)*(r.x-q.x) - (q.x-p.x)*(r.y-q.y)
+}
+
+// check if two points are equal
+func (ec *earcut) equals(p1, p2 *node) bool {
+	return p1.x == p2.x && p1.y == p2.y
+}
+
+// check if two segments intersect
+func (ec *earcut) intersects(p1, q1, p2, q2 *node) bool {
+	o1 := ec.sign(ec.area(p1, q1, p2))
+	o2 := ec.sign(ec.area(p1, q1, q2))
+	o3 := ec.sign(ec.area(p2, q2, p1))
+	o4 := ec.sign(ec.area(p2, q2, q1))
+
+	if o1 != o2 && o3 != o4 {
+		return true // general case
+	}
+
+	if o1 == 0 && ec.onSegment(p1, p2, q1) {
+		// p1, q1 and p2 are collinear and p2 lies on p1q1
+		return true
+	}
+	if o2 == 0 && ec.onSegment(p1, q2, q1) {
+		// p1, q1 and q2 are collinear and q2 lies on p1q1
+		return true
+	}
+	if o3 == 0 && ec.onSegment(p2, p1, q2) {
+		// p2, q2 and p1 are collinear and p1 lies on p2q2
+		return true
+	}
+	if o4 == 0 && ec.onSegment(p2, q1, q2) {
+		// p2, q2 and q1 are collinear and q1 lies on p2q2
+		return true
+	}
+
+	return false
+}
+
+// for collinear points p, q, r, check if point q lies on segment pr
+func (ec *earcut) onSegment(p, q, r *node) bool {
+	return q.x <= math.Max(p.x, r.x) &&
+		q.x >= math.Min(p.x, r.x) &&
+		q.y <= math.Max(p.y, r.y) &&
+		q.y >= math.Min(p.y, r.y)
+}
+
+func (ec *earcut) sign(val float64) int {
+	if val < 0 {
+		return -1
+	} else if val > 0 {
+		return 1
+	}
+	return 0
+}
+
+// check if a polygon diagonal intersects any polygon segments
+func (ec *earcut) intersectsPolygon(a, b *node) bool {
+	p := a
+	for {
+		if p.i != a.i && p.next.i != a.i && p.i != b.i && p.next.i != b.i &&
+			ec.intersects(p, p.next, a, b) {
+			return true
+		}
+		p = p.next
+		if p == a {
+			break
+		}
+	}
+
+	return false
+}
+
+// check if a polygon diagonal is locally inside the polygon
+func (ec *earcut) locallyInside(a, b *node) bool {
+	if ec.area(a.prev, a, a.next) < 0 {
+		return ec.area(a, b, a.next) >= 0 && ec.area(a, a.prev, b) >= 0
+	}
+	return ec.area(a, b, a.prev) < 0 || ec.area(a, a.next, b) < 0
+}
+
+// check if the middle Vertex of a polygon diagonal is inside the polygon
+func (ec *earcut) middleInside(a, b *node) bool {
+	p := a
+	inside := false
+	px := (a.x + b.x) / 2
+	py := (a.y + b.y) / 2
+	for {
+		if ((p.y > py) != (p.next.y > py)) && p.next.y != p.y &&
+			(px < (p.next.x-p.x)*(py-p.y)/(p.next.y-p.y)+p.x) {
+			inside = !inside
+		}
+		p = p.next
+		if p == a {
+			break
+		}
+	}
+
+	return inside
+}
+
+// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits
+// polygon into two; if one belongs to the outer ring and another to a hole, it merges it into a
+// single ring
+func (ec *earcut) splitPolygon(a, b *node) *node {
+	ec.nodes = append(ec.nodes, node{i: a.i, x: a.x, y: a.y})
+	a2 := &ec.nodes[len(ec.nodes)-1]
+	ec.nodes = append(ec.nodes, node{i: b.i, x: b.x, y: b.y})
+	b2 := &ec.nodes[len(ec.nodes)-1]
+	an := a.next
+	bp := b.prev
+
+	a.next = b
+	b.prev = a
+
+	a2.next = an
+	an.prev = a2
+
+	b2.next = a2
+	a2.prev = b2
+
+	bp.next = b2
+	b2.prev = bp
+
+	return b2
+}
+
+// create a node and util::optionally link it with previous one (in a circular doubly linked list)
+func (ec *earcut) insertNode(i int, pt backendbase.Vec, last *node) *node {
+	ec.nodes = append(ec.nodes, node{i: i, x: pt[0], y: pt[1]})
+	p := &ec.nodes[len(ec.nodes)-1]
+
+	if last == nil {
+		p.prev = p
+		p.next = p
+	} else {
+		if last == nil {
+			panic("last must not be nil")
+		}
+		p.next = last.next
+		p.prev = last
+		last.next.prev = p
+		last.next = p
+	}
+	return p
+}
+
+func (ec *earcut) removeNode(p *node) {
+	p.next.prev = p.prev
+	p.prev.next = p.next
+
+	if p.prevZ != nil {
+		p.prevZ.nextZ = p.nextZ
+	}
+	if p.nextZ != nil {
+		p.nextZ.prevZ = p.prevZ
+	}
+}
+
+// sortFontContours takes the contours of a font glyph
+// and checks whether each contour is the outside or a
+// hole, and returns an array that is sorted so that
+// it contains an index of an outer contour followed by
+// any number of indices of hole contours followed by
+// a terminating -1
+func sortFontContours(contours [][]backendbase.Vec) []int {
+	type cut struct {
+		idx   int
+		count int
+	}
+	type info struct {
+		cuts     []cut
+		cutTotal int
+		outer    bool
+	}
+
+	cutBuf := make([]cut, len(contours)*len(contours))
+	cinf := make([]info, len(contours))
+	for i := range contours {
+		cinf[i].cuts = cutBuf[i*len(contours) : i*len(contours)]
+	}
+
+	// go through each contour, pick one point on it, and
+	// project that point to the right. count the number of
+	// other contours that it cuts
+	for i, p1 := range contours {
+		pt := p1[0]
+		for j, p2 := range contours {
+			if i == j {
+				continue
+			}
+
+			for k := range p2 {
+				a, b := p2[k], p2[(k+1)%len(p2)]
+				if a == b {
+					continue
+				}
+
+				minY := math.Min(a[1], b[1])
+				maxY := math.Max(a[1], b[1])
+
+				if pt[1] <= minY || pt[1] > maxY {
+					continue
+				}
+
+				r := (pt[1] - a[1]) / (b[1] - a[1])
+				x := (b[0]-a[0])*r + a[0]
+				if x <= pt[0] {
+					continue
+				}
+
+				found := false
+				for l := range cinf[i].cuts {
+					if cinf[i].cuts[l].idx == j {
+						cinf[i].cuts[l].count++
+						found = true
+						break
+					}
+				}
+				if !found {
+					cinf[i].cuts = append(cinf[i].cuts, cut{idx: j, count: 1})
+				}
+				cinf[i].cutTotal++
+			}
+		}
+	}
+
+	// any contour with an even number of cuts is outer,
+	// odd number of cuts means it is a hole
+	for i := range cinf {
+		cinf[i].outer = cinf[i].cutTotal%2 == 0
+	}
+
+	// go through them again, pick any outer contour, then
+	// find any hole where the first outer contour it cuts
+	// an odd number of times is the picked contour and add
+	// it to the list of its holes
+	result := make([]int, 0, len(contours)*2)
+	for i := range cinf {
+		if !cinf[i].outer {
+			continue
+		}
+		result = append(result, i)
+
+		for j := range cinf {
+			if cinf[j].outer {
+				continue
+			}
+			for _, cut := range cinf[j].cuts {
+				if cut.count%2 == 0 {
+					continue
+				}
+				if cut.idx == i {
+					result = append(result, j)
+					break
+				}
+			}
+		}
+
+		result = append(result, -1)
+	}
+
+	return result
+}

examples/android/CanvasAndroidExample/.gitignore

@@ -1,10 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-.DS_Store
-/build
-/captures
-.externalNativeBuild

examples/android/CanvasAndroidExample/.idea/codeStyles/Project.xml

@@ -1,29 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <Objective-C-extensions>
-      <file>
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Import" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Macro" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Typedef" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Enum" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Constant" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Global" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Struct" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="FunctionPredecl" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Function" />
-      </file>
-      <class>
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Property" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Synthesize" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InitMethod" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="StaticMethod" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InstanceMethod" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="DeallocMethod" />
-      </class>
-      <extensions>
-        <pair source="cpp" header="h" fileNamingConvention="NONE" />
-        <pair source="c" header="h" fileNamingConvention="NONE" />
-      </extensions>
-    </Objective-C-extensions>
-  </code_scheme>
-</component>

examples/android/CanvasAndroidExample/.idea/encodings.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Encoding">
-    <file url="PROJECT" charset="UTF-8" />
-  </component>
-</project>

examples/android/CanvasAndroidExample/.idea/gradle.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/app" />
-          </set>
-        </option>
-        <option name="resolveModulePerSourceSet" value="false" />
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>

examples/android/CanvasAndroidExample/.idea/misc.xml

@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="NullableNotNullManager">
-    <option name="myDefaultNullable" value="android.support.annotation.Nullable" />
-    <option name="myDefaultNotNull" value="android.support.annotation.NonNull" />
-    <option name="myNullables">
-      <value>
-        <list size="5">
-          <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
-          <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nullable" />
-          <item index="2" class="java.lang.String" itemvalue="javax.annotation.CheckForNull" />
-          <item index="3" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.Nullable" />
-          <item index="4" class="java.lang.String" itemvalue="android.support.annotation.Nullable" />
-        </list>
-      </value>
-    </option>
-    <option name="myNotNulls">
-      <value>
-        <list size="4">
-          <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.NotNull" />
-          <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nonnull" />
-          <item index="2" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.NonNull" />
-          <item index="3" class="java.lang.String" itemvalue="android.support.annotation.NonNull" />
-        </list>
-      </value>
-    </option>
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/build/classes" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="Android" />
-  </component>
-</project>

examples/android/CanvasAndroidExample/.idea/runConfigurations.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunConfigurationProducerService">
-    <option name="ignoredProducers">
-      <set>
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
-      </set>
-    </option>
-  </component>
-</project>

examples/android/CanvasAndroidExample/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../../.." vcs="Git" />
-  </component>
-</project>

examples/android/CanvasAndroidExample/app/.gitignore

@@ -1 +0,0 @@
-/build

examples/android/CanvasAndroidExample/app/build.gradle

@@ -1,27 +0,0 @@
-apply plugin: 'com.android.application'
-
-android {
-    compileSdkVersion 26
-    defaultConfig {
-        applicationId "com.example.canvasandroidexample"
-        minSdkVersion 15
-        targetSdkVersion 26
-        versionCode 1
-        versionName "1.0"
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
-    }
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
-        }
-    }
-}
-
-dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
-    implementation fileTree(dir: 'libs', include: ['*.aar'])
-    testImplementation 'junit:junit:4.12'
-    androidTestImplementation 'com.android.support.test:runner:1.0.2'
-    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
-}

examples/android/CanvasAndroidExample/app/proguard-rules.pro

@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

examples/android/CanvasAndroidExample/app/src/androidTest/java/com/example/canvasandroidexample/ExampleInstrumentedTest.java

@@ -1,26 +0,0 @@
-package com.example.canvasandroidexample;
-
-import android.content.Context;
-import android.support.test.InstrumentationRegistry;
-import android.support.test.runner.AndroidJUnit4;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.*;
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
- */
-@RunWith(AndroidJUnit4.class)
-public class ExampleInstrumentedTest {
-    @Test
-    public void useAppContext() {
-        // Context of the app under test.
-        Context appContext = InstrumentationRegistry.getTargetContext();
-
-        assertEquals("com.example.canvasandroidexample", appContext.getPackageName());
-    }
-}

examples/android/CanvasAndroidExample/app/src/main/AndroidManifest.xml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.example.canvasandroidexample">
-
-    <application
-        android:allowBackup="true"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:roundIcon="@mipmap/ic_launcher_round"
-        android:supportsRtl="true"
-        android:theme="@style/AppTheme">
-        <activity android:name=".MainActivity">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN"/>
-
-                <category android:name="android.intent.category.LAUNCHER"/>
-            </intent-filter>
-        </activity>
-    </application>
-
-</manifest>

examples/android/CanvasAndroidExample/app/src/main/java/com/example/canvasandroidexample/MainActivity.java

@@ -1,61 +0,0 @@
-package com.example.canvasandroidexample;
-
-import android.app.Activity;
-import android.opengl.*;
-import android.os.Bundle;
-import android.view.MotionEvent;
-import android.view.View;
-
-import javax.microedition.khronos.egl.EGLConfig;
-import javax.microedition.khronos.opengles.GL10;
-
-import canvasandroidexample.Canvasandroidexample;
-
-public class MainActivity extends Activity implements GLSurfaceView.Renderer {
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        GLSurfaceView view = new GLSurfaceView(this);
-        view.setEGLContextClientVersion(2);
-        view.setEGLConfigChooser(8, 8, 8, 8, 0, 8);
-        view.setRenderer(this);
-        view.setOnTouchListener(new View.OnTouchListener() {
-            @Override
-            public boolean onTouch(View v, MotionEvent event) {
-                int x = Math.round(event.getX());
-                int y = Math.round(event.getY());
-                if (event.getAction() == MotionEvent.ACTION_DOWN) {
-                    Canvasandroidexample.touchEvent("down", x, y);
-                } else if (event.getAction() == MotionEvent.ACTION_UP) {
-                    Canvasandroidexample.touchEvent("up", x, y);
-                } else if (event.getAction() == MotionEvent.ACTION_MOVE) {
-                    Canvasandroidexample.touchEvent("move", x, y);
-                }
-                return true;
-            }
-        });
-        setContentView(view);
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-    }
-
-    @Override
-    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-        Canvasandroidexample.onSurfaceCreated();
-    }
-
-    @Override
-    public void onSurfaceChanged(GL10 gl, int width, int height) {
-        Canvasandroidexample.onSurfaceChanged(width, height);
-    }
-
-    @Override
-    public void onDrawFrame(GL10 gl) {
-        Canvasandroidexample.onDrawFrame();
-    }
-}

examples/android/CanvasAndroidExample/app/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -1,34 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        xmlns:aapt="http://schemas.android.com/aapt"
-        android:width="108dp"
-        android:height="108dp"
-        android:viewportHeight="108"
-        android:viewportWidth="108">
-    <path
-        android:fillType="evenOdd"
-        android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
-        android:strokeColor="#00000000"
-        android:strokeWidth="1">
-        <aapt:attr name="android:fillColor">
-            <gradient
-                android:endX="78.5885"
-                android:endY="90.9159"
-                android:startX="48.7653"
-                android:startY="61.0927"
-                android:type="linear">
-                <item
-                    android:color="#44000000"
-                    android:offset="0.0"/>
-                <item
-                    android:color="#00000000"
-                    android:offset="1.0"/>
-            </gradient>
-        </aapt:attr>
-    </path>
-    <path
-        android:fillColor="#FFFFFF"
-        android:fillType="nonZero"
-        android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
-        android:strokeColor="#00000000"
-        android:strokeWidth="1"/>
-</vector>

examples/android/CanvasAndroidExample/app/src/main/res/drawable/ic_launcher_background.xml

@@ -1,171 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportHeight="108"
-    android:viewportWidth="108">
-    <path
-        android:fillColor="#26A69A"
-        android:pathData="M0,0h108v108h-108z"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M9,0L9,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,0L19,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,0L29,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,0L39,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,0L49,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,0L59,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,0L69,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,0L79,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M89,0L89,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M99,0L99,108"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,9L108,9"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,19L108,19"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,29L108,29"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,39L108,39"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,49L108,49"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,59L108,59"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,69L108,69"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,79L108,79"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,89L108,89"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,99L108,99"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,29L89,29"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,39L89,39"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,49L89,49"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,59L89,59"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,69L89,69"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,79L89,79"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,19L29,89"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,19L39,89"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,19L49,89"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,19L59,89"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,19L69,89"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,19L79,89"
-        android:strokeColor="#33FFFFFF"
-        android:strokeWidth="0.8"/>
-</vector>

examples/android/CanvasAndroidExample/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
-</adaptive-icon>

examples/android/CanvasAndroidExample/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
-</adaptive-icon>

examples/android/CanvasAndroidExample/app/src/main/res/values/colors.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <color name="colorPrimary">#3F51B5</color>
-    <color name="colorPrimaryDark">#303F9F</color>
-    <color name="colorAccent">#FF4081</color>
-</resources>

examples/android/CanvasAndroidExample/app/src/main/res/values/strings.xml

@@ -1,3 +0,0 @@
-<resources>
-    <string name="app_name">CanvasAndroidExample</string>
-</resources>

examples/android/CanvasAndroidExample/app/src/main/res/values/styles.xml

@@ -1,8 +0,0 @@
-<resources>
-
-    <!-- Base application theme. -->
-    <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
-        <!-- Customize your theme here. -->
-    </style>
-
-</resources>

examples/android/CanvasAndroidExample/app/src/test/java/com/example/canvasandroidexample/ExampleUnitTest.java

@@ -1,17 +0,0 @@
-package com.example.canvasandroidexample;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
- */
-public class ExampleUnitTest {
-    @Test
-    public void addition_isCorrect() {
-        assertEquals(4, 2 + 2);
-    }
-}

examples/android/CanvasAndroidExample/build.gradle

@@ -1,27 +0,0 @@
-// Top-level build file where you can add configuration options common to all sub-projects/modules.
-
-buildscript {
-    
-    repositories {
-        google()
-        jcenter()
-    }
-    dependencies {
-        classpath 'com.android.tools.build:gradle:3.1.2'
-        
-
-        // NOTE: Do not place your application dependencies here; they belong
-        // in the individual module build.gradle files
-    }
-}
-
-allprojects {
-    repositories {
-        google()
-        jcenter()
-    }
-}
-
-task clean(type: Delete) {
-    delete rootProject.buildDir
-}

examples/android/CanvasAndroidExample/gradle.properties

@@ -1,13 +0,0 @@
-# Project-wide Gradle settings.
-# IDE (e.g. Android Studio) users:
-# Gradle settings configured through the IDE *will override*
-# any settings specified in this file.
-# For more details on how to configure your build environment visit
-# http://www.gradle.org/docs/current/userguide/build_environment.html
-# Specifies the JVM arguments used for the daemon process.
-# The setting is particularly useful for tweaking memory settings.
-org.gradle.jvmargs=-Xmx1536m
-# When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. More details, visit
-# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true

examples/android/CanvasAndroidExample/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-#Thu May 10 15:38:02 CEST 2018
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip

examples/android/CanvasAndroidExample/gradlew

@@ -1,172 +0,0 @@
-#!/usr/bin/env sh
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"

examples/android/CanvasAndroidExample/gradlew.bat

@@ -1,84 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

examples/android/CanvasAndroidExample/settings.gradle

@@ -1 +0,0 @@
-include ':app'

examples/android/README.md

@@ -1,3 +0,0 @@
-As of this writing, gomobile does not support go modules. In this case this project can only be compiled while it is in the GOPATH/src directory.
-
-The go bindings are generated with the ```gomobile bind -target android``` command, which results in a .aar and a .jar file. These should be placed in the CanvasAndroidExample/app/libs directory, and then the project should compile.

examples/android/android.go

@@ -1,42 +0,0 @@
-package canvasandroidexample
-
-import (
-	"math"
-
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/goglbackend"
-)
-
-var cv *canvas.Canvas
-var mx, my float64
-
-func TouchEvent(typ string, x, y int) {
-	mx, my = float64(x), float64(y)
-}
-
-func OnSurfaceCreated() {
-}
-
-func OnSurfaceChanged(w, h int) {
-	backend, err := goglbackend.New(0, 0, w, h, nil)
-	if err != nil {
-		panic(err)
-	}
-	cv = canvas.New(backend)
-}
-
-func OnDrawFrame() {
-	if cv == nil {
-		return
-	}
-	w, h := float64(cv.Width()), float64(cv.Height())
-
-	cv.SetFillStyle("#000")
-	cv.FillRect(0, 0, w, h)
-	cv.SetFillStyle("#0F0")
-	cv.FillRect(w*0.25, h*0.25, w*0.5, h*0.5)
-	cv.SetLineWidth(6)
-	sqrSize := math.Min(w, h) * 0.1
-	cv.SetStrokeStyle("#F00")
-	cv.StrokeRect(mx-sqrSize/2, my-sqrSize/2, sqrSize, sqrSize)
-}

examples/drawing/drawing.go

@@ -1,134 +0,0 @@
-package main
-
-import (
-	"image/color"
-	"log"
-	"math"
-
-	"github.com/tfriedel6/canvas/sdlcanvas"
-)
-
-func main() {
-	wnd, cv, err := sdlcanvas.CreateWindow(1280, 720, "Canvas Example")
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	defer wnd.Destroy()
-
-	lg := cv.CreateLinearGradient(320, 200, 480, 520)
-	lg.AddColorStop(0, "#ff000040")
-	lg.AddColorStop(1, "#00ff0040")
-	lg.AddColorStop(0.5, "#0000ff40")
-
-	rg := cv.CreateRadialGradient(540, 300, 80, 740, 300, 100)
-	rg.AddColorStop(0, "#ff0000")
-	rg.AddColorStop(1, "#00ff00")
-	rg.AddColorStop(0.5, "#0000ff")
-
-	wnd.MainLoop(func() {
-		w, h := float64(cv.Width()), float64(cv.Height())
-
-		// Clear the screen
-		cv.SetFillStyle("#000")
-		cv.FillRect(0, 0, w, h)
-
-		// Estimated size used for scaling
-		const (
-			contentWidth  = 1000
-			contentHeight = 350
-		)
-
-		// Calculate scaling
-		sx := w / contentWidth
-		sy := h / contentHeight
-		scale := math.Min(sx, sy)
-		cv.Save()
-		defer cv.Restore()
-		cv.Scale(scale, scale)
-
-		// Draw lines with different colors and line thickness
-		for x := 1.0; x < 10.5; x += 1.0 {
-			cv.SetStrokeStyle(int(x*25), 255, 255)
-			cv.SetLineWidth(x)
-			cv.BeginPath()
-			cv.MoveTo(x*10+20, 20)
-			cv.LineTo(x*10+20, 120)
-			cv.Stroke()
-		}
-
-		// Draw a path
-		cv.BeginPath()
-		cv.MoveTo(160, 20)
-		cv.LineTo(180, 20)
-		cv.LineTo(180, 40)
-		cv.LineTo(200, 40)
-		cv.LineTo(200, 60)
-		cv.LineTo(220, 60)
-		cv.LineTo(220, 80)
-		cv.LineTo(240, 80)
-		cv.LineTo(240, 100)
-		cv.LineTo(260, 100)
-		cv.LineTo(260, 120)
-		cv.ArcTo(160, 120, 160, 100, 20)
-		cv.ClosePath()
-		cv.SetStrokeStyle(color.RGBA{R: 255, G: 128, B: 128, A: 255})
-		cv.SetLineWidth(4)
-		cv.Stroke()
-
-		// Fill a polygon
-		cv.BeginPath()
-		cv.MoveTo(300, 20)
-		cv.LineTo(340, 20)
-		cv.QuadraticCurveTo(370, 20, 370, 50)
-		cv.QuadraticCurveTo(370, 80, 400, 80)
-		cv.LineTo(400, 80)
-		cv.LineTo(400, 120)
-		cv.LineTo(360, 120)
-		cv.BezierCurveTo(330, 120, 330, 80, 300, 80)
-		cv.ClosePath()
-		cv.SetFillStyle(color.RGBA{R: 128, G: 255, B: 128, A: 255})
-		cv.Fill()
-
-		// Draw with alpha
-		cv.SetGlobalAlpha(0.5)
-		cv.SetFillStyle("#FF0000")
-		cv.BeginPath()
-		cv.Arc(100, 275, 60, 0, math.Pi*2, false)
-		cv.Fill()
-		cv.SetFillStyle("#00FF00")
-		cv.BeginPath()
-		cv.Arc(140, 210, 60, 0, math.Pi*2, false)
-		cv.Fill()
-		cv.SetFillStyle("#0000FF")
-		cv.BeginPath()
-		cv.Arc(180, 275, 60, 0, math.Pi*2, false)
-		cv.Fill()
-		cv.SetGlobalAlpha(1)
-
-		// Clipped drawing
-		cv.Save()
-		cv.BeginPath()
-		cv.Arc(340, 240, 80, 0, math.Pi*2, true)
-		cv.Clip()
-		cv.SetStrokeStyle(0, 255, 0)
-		for x := 1.0; x < 12.5; x += 1.0 {
-			cv.BeginPath()
-			cv.MoveTo(260, 140+16*x)
-			cv.LineTo(420, 140+16*x)
-			cv.Stroke()
-		}
-		cv.SetFillStyle(0, 0, 255)
-		for x := 1.0; x < 12.5; x += 1.0 {
-			cv.FillRect(246+x*14, 150, 6, 180)
-		}
-		cv.Restore()
-
-		// Draw images
-		cv.DrawImage("cat.jpg", 480, 40, 320, 265)
-
-		// Draw text
-		cv.SetFont("Righteous-Regular.ttf", 40)
-		cv.FillText("<-- Cat", 820, 180)
-	})
-}

examples/events/events.go

@@ -1,77 +0,0 @@
-package main
-
-import (
-	"log"
-	"math"
-	"time"
-
-	"github.com/tfriedel6/canvas/sdlcanvas"
-)
-
-type circle struct {
-	x, y  float64
-	color string
-}
-
-func main() {
-	wnd, cv, err := sdlcanvas.CreateWindow(1280, 720, "Canvas Example")
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	defer wnd.Destroy()
-
-	var mx, my, action float64
-	circles := make([]circle, 0, 100)
-
-	wnd.MouseMove = func(x, y int) {
-		mx, my = float64(x), float64(y)
-	}
-	wnd.MouseDown = func(button, x, y int) {
-		action = 1
-		circles = append(circles, circle{x: mx, y: my, color: "#F00"})
-	}
-	wnd.KeyDown = func(scancode int, rn rune, name string) {
-		switch name {
-		case "Escape":
-			wnd.Close()
-		case "Space":
-			action = 1
-			circles = append(circles, circle{x: mx, y: my, color: "#0F0"})
-		case "Enter":
-			action = 1
-			circles = append(circles, circle{x: mx, y: my, color: "#00F"})
-		}
-	}
-
-	lastTime := time.Now()
-
-	wnd.MainLoop(func() {
-		now := time.Now()
-		diff := now.Sub(lastTime)
-		lastTime = now
-		action -= diff.Seconds() * 3
-		action = math.Max(0, action)
-
-		w, h := float64(cv.Width()), float64(cv.Height())
-
-		// Clear the screen
-		cv.SetFillStyle("#000")
-		cv.FillRect(0, 0, w, h)
-
-		// Draw a circle around the cursor
-		cv.SetStrokeStyle("#F00")
-		cv.SetLineWidth(6)
-		cv.BeginPath()
-		cv.Arc(mx, my, 24+action*24, 0, math.Pi*2, false)
-		cv.Stroke()
-
-		// Draw circles where the user has clicked
-		for _, circle := range circles {
-			cv.SetFillStyle(circle.color)
-			cv.BeginPath()
-			cv.Arc(circle.x, circle.y, 24, 0, math.Pi*2, false)
-			cv.Fill()
-		}
-	})
-}

examples/glfw/glfw.go

@@ -1,89 +0,0 @@
-package main
-
-import (
-	"log"
-	"runtime"
-
-	"github.com/go-gl/gl/v3.2-core/gl"
-	"github.com/go-gl/glfw/v3.3/glfw"
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/goglbackend"
-)
-
-func main() {
-	runtime.LockOSThread()
-
-	// init GLFW
-	err := glfw.Init()
-	if err != nil {
-		log.Fatalf("Error initializing GLFW: %v", err)
-	}
-	defer glfw.Terminate()
-
-	// the stencil size setting is required for the canvas to work
-	glfw.WindowHint(glfw.StencilBits, 8)
-	glfw.WindowHint(glfw.DepthBits, 0)
-
-	// create window
-	window, err := glfw.CreateWindow(1280, 720, "GLFW Test", nil, nil)
-	if err != nil {
-		log.Fatalf("Error creating window: %v", err)
-	}
-	window.MakeContextCurrent()
-
-	// init GL
-	err = gl.Init()
-	if err != nil {
-		log.Fatalf("Error initializing GL: %v", err)
-	}
-
-	// set vsync on, enable multisample (if available)
-	glfw.SwapInterval(1)
-	gl.Enable(gl.MULTISAMPLE)
-
-	// load GL backend
-	backend, err := goglbackend.New(0, 0, 0, 0, nil)
-	if err != nil {
-		log.Fatalf("Error loading canvas GL assets: %v", err)
-	}
-
-	var sx, sy float64 = 1, 1
-	window.SetCursorPosCallback(func(w *glfw.Window, xpos, ypos float64) {
-		mx, my = xpos*sx, ypos*sy
-	})
-
-	// initialize canvas with zero size, since size is set in main loop
-	cv := canvas.New(backend)
-
-	for !window.ShouldClose() {
-		window.MakeContextCurrent()
-
-		// find window size and scaling
-		ww, wh := window.GetSize()
-		fbw, fbh := window.GetFramebufferSize()
-		sx = float64(fbw) / float64(ww)
-		sy = float64(fbh) / float64(wh)
-
-		glfw.PollEvents()
-
-		// set canvas size
-		backend.SetBounds(0, 0, fbw, fbh)
-
-		// call the run function to do all the drawing
-		run(cv, float64(fbw), float64(fbh))
-
-		// swap back and front buffer
-		window.SwapBuffers()
-	}
-}
-
-var mx, my float64
-
-func run(cv *canvas.Canvas, w, h float64) {
-	cv.SetFillStyle("#000")
-	cv.FillRect(0, 0, w, h)
-	cv.SetFillStyle("#00F")
-	cv.FillRect(w*0.25, h*0.25, w*0.5, h*0.5)
-	cv.SetStrokeStyle("#0F0")
-	cv.StrokeRect(mx-32, my-32, 64, 64)
-}

examples/gomobile/gomobile.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"log"
-	"math"
-	"time"
-
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/xmobilebackend"
-	"golang.org/x/mobile/app"
-	"golang.org/x/mobile/event/lifecycle"
-	"golang.org/x/mobile/event/paint"
-	"golang.org/x/mobile/event/size"
-	"golang.org/x/mobile/gl"
-)
-
-func main() {
-	app.Main(func(a app.App) {
-		var cv, painter *canvas.Canvas
-		var cvb *xmobilebackend.XMobileBackendOffscreen
-		var painterb *xmobilebackend.XMobileBackend
-		var w, h int
-
-		var glctx gl.Context
-		for e := range a.Events() {
-			switch e := a.Filter(e).(type) {
-			case lifecycle.Event:
-				switch e.Crosses(lifecycle.StageVisible) {
-				case lifecycle.CrossOn:
-					var err error
-					glctx = e.DrawContext.(gl.Context)
-					ctx, err := xmobilebackend.NewGLContext(glctx)
-					if err != nil {
-						log.Fatal(err)
-					}
-					cvb, err = xmobilebackend.NewOffscreen(0, 0, false, ctx)
-					if err != nil {
-						log.Fatalln(err)
-					}
-					painterb, err = xmobilebackend.New(0, 0, 0, 0, ctx)
-					if err != nil {
-						log.Fatalln(err)
-					}
-					cv = canvas.New(cvb)
-					painter = canvas.New(painterb)
-					a.Send(paint.Event{})
-				case lifecycle.CrossOff:
-					cvb.Delete()
-					glctx = nil
-				}
-			case size.Event:
-				w, h = e.WidthPx, e.HeightPx
-			case paint.Event:
-				if glctx != nil {
-					fw, fh := float64(w), float64(h)
-					color := math.Sin(float64(time.Now().UnixNano())*0.000000002)*0.3 + 0.7
-
-					cvb.SetSize(w, h)
-					cv.SetFillStyle(color*0.2, color*0.2, color*0.8)
-					cv.FillRect(fw*0.25, fh*0.25, fw*0.5, fh*0.5)
-
-					painterb.SetBounds(0, 0, w, h)
-					painter.DrawImage(cv)
-
-					a.Publish()
-					a.Send(paint.Event{})
-				}
-			}
-		}
-	})
-}

examples/ios/CanvasIOSExample/.gitignore

@@ -1,4 +0,0 @@
-xcuserdata
-project.xcworkspace
-Example.framework
-

examples/ios/CanvasIOSExample/CanvasIOSExample.xcodeproj/project.pbxproj

@@ -1,325 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 48;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		A02D492720AB3AA900E68C35 /* MainViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = A02D492620AB3AA900E68C35 /* MainViewController.swift */; };
-		A094B52520AB3D0C000BCEA6 /* Example.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A094B52420AB3D0C000BCEA6 /* Example.framework */; };
-		A0F2843E20AAD80F0049BD39 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = A0F2843D20AAD80F0049BD39 /* AppDelegate.swift */; };
-		A0F2844520AAD8100049BD39 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = A0F2844420AAD8100049BD39 /* Assets.xcassets */; };
-		A0F2844820AAD8100049BD39 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = A0F2844620AAD8100049BD39 /* LaunchScreen.storyboard */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		A02D492620AB3AA900E68C35 /* MainViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainViewController.swift; sourceTree = "<group>"; };
-		A094B52420AB3D0C000BCEA6 /* Example.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = Example.framework; sourceTree = "<group>"; };
-		A0F2843A20AAD80F0049BD39 /* CanvasIOSExample.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = CanvasIOSExample.app; sourceTree = BUILT_PRODUCTS_DIR; };
-		A0F2843D20AAD80F0049BD39 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
-		A0F2844420AAD8100049BD39 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
-		A0F2844720AAD8100049BD39 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
-		A0F2844920AAD8100049BD39 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		A0F2843720AAD80F0049BD39 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A094B52520AB3D0C000BCEA6 /* Example.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		A0F2843120AAD80F0049BD39 = {
-			isa = PBXGroup;
-			children = (
-				A0F2843C20AAD80F0049BD39 /* CanvasIOSExample */,
-				A0F2843B20AAD80F0049BD39 /* Products */,
-			);
-			sourceTree = "<group>";
-		};
-		A0F2843B20AAD80F0049BD39 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				A0F2843A20AAD80F0049BD39 /* CanvasIOSExample.app */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		A0F2843C20AAD80F0049BD39 /* CanvasIOSExample */ = {
-			isa = PBXGroup;
-			children = (
-				A0F2843D20AAD80F0049BD39 /* AppDelegate.swift */,
-				A02D492620AB3AA900E68C35 /* MainViewController.swift */,
-				A0F2844420AAD8100049BD39 /* Assets.xcassets */,
-				A0F2844620AAD8100049BD39 /* LaunchScreen.storyboard */,
-				A0F2844920AAD8100049BD39 /* Info.plist */,
-				A094B52420AB3D0C000BCEA6 /* Example.framework */,
-			);
-			path = CanvasIOSExample;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		A0F2843920AAD80F0049BD39 /* CanvasIOSExample */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = A0F2844C20AAD8100049BD39 /* Build configuration list for PBXNativeTarget "CanvasIOSExample" */;
-			buildPhases = (
-				A0F2843620AAD80F0049BD39 /* Sources */,
-				A0F2843720AAD80F0049BD39 /* Frameworks */,
-				A0F2843820AAD80F0049BD39 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = CanvasIOSExample;
-			productName = CanvasIOSExample;
-			productReference = A0F2843A20AAD80F0049BD39 /* CanvasIOSExample.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		A0F2843220AAD80F0049BD39 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastSwiftUpdateCheck = 0910;
-				LastUpgradeCheck = 0910;
-				ORGANIZATIONNAME = example;
-				TargetAttributes = {
-					A0F2843920AAD80F0049BD39 = {
-						CreatedOnToolsVersion = 9.1;
-						ProvisioningStyle = Automatic;
-					};
-				};
-			};
-			buildConfigurationList = A0F2843520AAD80F0049BD39 /* Build configuration list for PBXProject "CanvasIOSExample" */;
-			compatibilityVersion = "Xcode 8.0";
-			developmentRegion = en;
-			hasScannedForEncodings = 0;
-			knownRegions = (
-				en,
-				Base,
-			);
-			mainGroup = A0F2843120AAD80F0049BD39;
-			productRefGroup = A0F2843B20AAD80F0049BD39 /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				A0F2843920AAD80F0049BD39 /* CanvasIOSExample */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		A0F2843820AAD80F0049BD39 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A0F2844820AAD8100049BD39 /* LaunchScreen.storyboard in Resources */,
-				A0F2844520AAD8100049BD39 /* Assets.xcassets in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		A0F2843620AAD80F0049BD39 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A0F2843E20AAD80F0049BD39 /* AppDelegate.swift in Sources */,
-				A02D492720AB3AA900E68C35 /* MainViewController.swift in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXVariantGroup section */
-		A0F2844620AAD8100049BD39 /* LaunchScreen.storyboard */ = {
-			isa = PBXVariantGroup;
-			children = (
-				A0F2844720AAD8100049BD39 /* Base */,
-			);
-			name = LaunchScreen.storyboard;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		A0F2844A20AAD8100049BD39 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_ANALYZER_NONNULL = YES;
-				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				CODE_SIGN_IDENTITY = "iPhone Developer";
-				COPY_PHASE_STRIP = NO;
-				DEBUG_INFORMATION_FORMAT = dwarf;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				ENABLE_TESTABILITY = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu11;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 11.1;
-				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				SDKROOT = iphoneos;
-				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
-				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-			};
-			name = Debug;
-		};
-		A0F2844B20AAD8100049BD39 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_ANALYZER_NONNULL = YES;
-				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				CODE_SIGN_IDENTITY = "iPhone Developer";
-				COPY_PHASE_STRIP = NO;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				ENABLE_NS_ASSERTIONS = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu11;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 11.1;
-				MTL_ENABLE_DEBUG_INFO = NO;
-				SDKROOT = iphoneos;
-				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
-				VALIDATE_PRODUCT = YES;
-			};
-			name = Release;
-		};
-		A0F2844D20AAD8100049BD39 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				CODE_SIGN_STYLE = Automatic;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(PROJECT_DIR)/CanvasIOSExample",
-				);
-				INFOPLIST_FILE = CanvasIOSExample/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.CanvasIOSExample;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 4.0;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Debug;
-		};
-		A0F2844E20AAD8100049BD39 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				CODE_SIGN_STYLE = Automatic;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(PROJECT_DIR)/CanvasIOSExample",
-				);
-				INFOPLIST_FILE = CanvasIOSExample/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.CanvasIOSExample;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 4.0;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		A0F2843520AAD80F0049BD39 /* Build configuration list for PBXProject "CanvasIOSExample" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				A0F2844A20AAD8100049BD39 /* Debug */,
-				A0F2844B20AAD8100049BD39 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		A0F2844C20AAD8100049BD39 /* Build configuration list for PBXNativeTarget "CanvasIOSExample" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				A0F2844D20AAD8100049BD39 /* Debug */,
-				A0F2844E20AAD8100049BD39 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = A0F2843220AAD80F0049BD39 /* Project object */;
-}

examples/ios/CanvasIOSExample/CanvasIOSExample/AppDelegate.swift

@@ -1,38 +0,0 @@
-import UIKit
-
-@UIApplicationMain
-class AppDelegate: UIResponder, UIApplicationDelegate {
-
-    var window: UIWindow?
-
-    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
-        
-        window = UIWindow(frame: UIScreen.main.bounds)
-        window?.rootViewController = MainViewController()
-        self.window?.makeKeyAndVisible()
-        
-        return true
-    }
-
-    func applicationWillResignActive(_ application: UIApplication) {
-        // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
-        // Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game.
-    }
-
-    func applicationDidEnterBackground(_ application: UIApplication) {
-        // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
-        // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
-    }
-
-    func applicationWillEnterForeground(_ application: UIApplication) {
-        // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
-    }
-
-    func applicationDidBecomeActive(_ application: UIApplication) {
-        // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
-    }
-
-    func applicationWillTerminate(_ application: UIApplication) {
-        // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
-    }
-}

examples/ios/CanvasIOSExample/CanvasIOSExample/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -1,93 +0,0 @@
-{
-  "images" : [
-    {
-      "idiom" : "iphone",
-      "size" : "20x20",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "20x20",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "29x29",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "29x29",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "40x40",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "40x40",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "60x60",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "60x60",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "20x20",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "20x20",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "29x29",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "29x29",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "40x40",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "40x40",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "76x76",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "76x76",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "83.5x83.5",
-      "scale" : "2x"
-    }
-  ],
-  "info" : {
-    "version" : 1,
-    "author" : "xcode"
-  }
-}

examples/ios/CanvasIOSExample/CanvasIOSExample/Base.lproj/LaunchScreen.storyboard

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" systemVersion="17A277" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
-    <dependencies>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
-        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
-        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
-    </dependencies>
-    <scenes>
-        <!--View Controller-->
-        <scene sceneID="EHf-IW-A2E">
-            <objects>
-                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
-                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
-                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
-                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
-                        <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
-                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
-                    </view>
-                </viewController>
-                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
-            </objects>
-            <point key="canvasLocation" x="53" y="375"/>
-        </scene>
-    </scenes>
-</document>

examples/ios/CanvasIOSExample/CanvasIOSExample/Info.plist

@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>$(DEVELOPMENT_LANGUAGE)</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-	<key>LSRequiresIPhoneOS</key>
-	<true/>
-	<key>UILaunchStoryboardName</key>
-	<string>LaunchScreen</string>
-	<key>UIRequiredDeviceCapabilities</key>
-	<array>
-		<string>armv7</string>
-	</array>
-	<key>UISupportedInterfaceOrientations</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-	<key>UISupportedInterfaceOrientations~ipad</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-</dict>
-</plist>

examples/ios/CanvasIOSExample/CanvasIOSExample/MainViewController.swift

@@ -1,54 +0,0 @@
-import UIKit
-import GLKit
-import Example
-
-class MainViewController : UIViewController, GLKViewDelegate {
-    var loaded:Bool?
-    
-    override func viewDidLoad() {
-        loaded = false
-        let view = GLKView(frame: UIScreen.main.bounds)
-        let context : EAGLContext? = EAGLContext(api: .openGLES2)
-        view.context = context!
-        view.drawableColorFormat = .RGBA8888
-        view.drawableDepthFormat = .formatNone
-        view.drawableStencilFormat = .format8
-        view.drawableMultisample = .multisample4X
-        view.delegate = self
-        self.view = view
-    }
-    
-    func glkView(_ view: GLKView, drawIn rect: CGRect) {
-        if loaded == nil || !loaded! {
-            loaded = true
-            let scale = UIScreen.main.nativeScale
-            ExampleLoadGL(Int(rect.width * scale), Int(rect.height * scale))
-        }
-        
-        ExampleDrawFrame()
-        DispatchQueue.main.async {
-            view.setNeedsDisplay()
-        }
-    }
-    
-    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
-        let scale = UIScreen.main.nativeScale
-        let touch = touches.first!
-        let loc = touch.location(in: self.view)
-        ExampleTouchEvent("down", Int(loc.x*scale), Int(loc.y*scale))
-    }
-    
-    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
-        let scale = UIScreen.main.nativeScale
-        let touch = touches.first!
-        let loc = touch.location(in: self.view)
-        ExampleTouchEvent("move", Int(loc.x*scale), Int(loc.y*scale))
-    }
-    
-    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
-        let scale = UIScreen.main.nativeScale
-        let touch = touches.first!
-        let loc = touch.location(in: self.view)
-        ExampleTouchEvent("up", Int(loc.x*scale), Int(loc.y*scale))
-    }
-}

examples/ios/README.md

@@ -1,7 +0,0 @@
-As of this writing, gomobile does not support go modules. In this case this project can only be compiled while it is in the GOPATH/src directory.
-
-Run this command:
-
-gomobile bind -target ios -tags ios
-
-Then add the resulting Example.framework into the Xcode project, and it should compile and run from there

examples/ios/ios.go

@@ -1,39 +0,0 @@
-package example
-
-import (
-	"math"
-
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/goglbackend"
-)
-
-var cv *canvas.Canvas
-var mx, my float64
-
-func TouchEvent(typ string, x, y int) {
-	mx, my = float64(x), float64(y)
-}
-
-func LoadGL(w, h int) {
-	backend, err := goglbackend.New(0, 0, w, h, nil)
-	if err != nil {
-		panic(err)
-	}
-	cv = canvas.New(backend)
-}
-
-func DrawFrame() {
-	if cv == nil {
-		return
-	}
-	w, h := float64(cv.Width()), float64(cv.Height())
-
-	cv.SetFillStyle("#000")
-	cv.FillRect(0, 0, w, h)
-	cv.SetFillStyle("#0F0")
-	cv.FillRect(w*0.25, h*0.25, w*0.5, h*0.5)
-	cv.SetLineWidth(6)
-	sqrSize := math.Min(w, h) * 0.1
-	cv.SetStrokeStyle("#F00")
-	cv.StrokeRect(mx-sqrSize/2, my-sqrSize/2, sqrSize, sqrSize)
-}

examples/sdl/sdl.go

@@ -1,130 +0,0 @@
-package main
-
-import (
-	"log"
-	"runtime"
-	"time"
-
-	"github.com/go-gl/gl/v3.2-core/gl"
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/goglbackend"
-	"github.com/veandco/go-sdl2/sdl"
-)
-
-func main() {
-	runtime.LockOSThread()
-
-	// init SDL
-	err := sdl.Init(sdl.INIT_VIDEO)
-	if err != nil {
-		log.Fatalf("Error initializing SDL: %v", err)
-	}
-	defer sdl.Quit()
-
-	// the stencil size setting is required for the canvas to work
-	sdl.GLSetAttribute(sdl.GL_RED_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_GREEN_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_BLUE_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_ALPHA_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_DEPTH_SIZE, 0)
-	sdl.GLSetAttribute(sdl.GL_STENCIL_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_DOUBLEBUFFER, 1)
-	sdl.GLSetAttribute(sdl.GL_MULTISAMPLEBUFFERS, 1)
-	sdl.GLSetAttribute(sdl.GL_MULTISAMPLESAMPLES, 4)
-
-	// create window
-	const title = "SDL Test"
-	window, err := sdl.CreateWindow(title, sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, 1280, 720, sdl.WINDOW_RESIZABLE|sdl.WINDOW_OPENGL|sdl.WINDOW_ALLOW_HIGHDPI)
-	if err != nil {
-		// fallback in case multisample is not available
-		sdl.GLSetAttribute(sdl.GL_MULTISAMPLEBUFFERS, 0)
-		sdl.GLSetAttribute(sdl.GL_MULTISAMPLESAMPLES, 0)
-		window, err = sdl.CreateWindow(title, sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, 1280, 720, sdl.WINDOW_RESIZABLE|sdl.WINDOW_OPENGL|sdl.WINDOW_ALLOW_HIGHDPI)
-		if err != nil {
-			log.Fatalf("Error creating window: %v", err)
-		}
-	}
-	defer window.Destroy()
-
-	// create GL context
-	glContext, err := window.GLCreateContext()
-	if err != nil {
-		log.Fatalf("Error creating GL context: %v", err)
-	}
-
-	// init GL
-	err = gl.Init()
-	if err != nil {
-		log.Fatalf("Error initializing GL: %v", err)
-	}
-
-	// enable vsync and multisample (if available)
-	sdl.GLSetSwapInterval(1)
-	gl.Enable(gl.MULTISAMPLE)
-
-	// load GL backend
-	backend, err := goglbackend.New(0, 0, 0, 0, nil)
-	if err != nil {
-		log.Fatalf("Error loading canvas GL assets: %v", err)
-	}
-
-	// initialize canvas with zero size, since size is set in main loop
-	cv := canvas.New(backend)
-
-	for running := true; running; {
-		err := window.GLMakeCurrent(glContext)
-		if err != nil {
-			time.Sleep(10 * time.Millisecond)
-			continue
-		}
-
-		// find window size and scaling
-		ww, wh := window.GetSize()
-		fbw, fbh := window.GLGetDrawableSize()
-		sx := float64(fbw) / float64(ww)
-		sy := float64(fbh) / float64(wh)
-
-		// handle events
-		for {
-			event := sdl.PollEvent()
-			if event == nil {
-				break
-			}
-
-			switch e := event.(type) {
-			case *sdl.KeyboardEvent:
-				if e.Type == sdl.KEYDOWN && e.Keysym.Scancode == sdl.SCANCODE_ESCAPE {
-					running = false
-				}
-			case *sdl.MouseMotionEvent:
-				mx, my = float64(e.X)*sx, float64(e.Y)*sy
-			case *sdl.QuitEvent:
-				running = false
-			case *sdl.WindowEvent:
-				if e.Type == sdl.WINDOWEVENT_CLOSE {
-					running = false
-				}
-			}
-		}
-
-		// set canvas size
-		backend.SetBounds(0, 0, int(fbw), int(fbh))
-
-		// call the run function to do all the drawing
-		run(cv, float64(fbw), float64(fbh))
-
-		// swap back and front buffer
-		window.GLSwap()
-	}
-}
-
-var mx, my float64
-
-func run(cv *canvas.Canvas, w, h float64) {
-	cv.SetFillStyle("#000")
-	cv.FillRect(0, 0, w, h)
-	cv.SetFillStyle("#0F0")
-	cv.FillRect(w*0.25, h*0.25, w*0.5, h*0.5)
-	cv.SetStrokeStyle("#00F")
-	cv.StrokeRect(mx-32, my-32, 64, 64)
-}

examples/shiny/shiny.go

@@ -1,58 +0,0 @@
-package main
-
-import (
-	"log"
-
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/xmobilebackend"
-	"golang.org/x/exp/shiny/driver/gldriver"
-	"golang.org/x/exp/shiny/screen"
-	"golang.org/x/exp/shiny/widget"
-	"golang.org/x/exp/shiny/widget/glwidget"
-	"golang.org/x/exp/shiny/widget/node"
-)
-
-var cv *canvas.Canvas
-var sheet *widget.Sheet
-
-func main() {
-	gldriver.Main(func(s screen.Screen) {
-		glw := glwidget.NewGL(draw)
-		sheet = widget.NewSheet(glw)
-		ctx, err := xmobilebackend.NewGLContext(glw.Ctx)
-		if err != nil {
-			log.Fatal(err)
-		}
-		backend, err := xmobilebackend.New(0, 0, 600, 600, ctx)
-		if err != nil {
-			log.Fatal(err)
-		}
-		cv = canvas.New(backend)
-
-		err = widget.RunWindow(s, sheet, &widget.RunWindowOptions{
-			NewWindowOptions: screen.NewWindowOptions{
-				Title:  "Shiny Canvas Example",
-				Width:  600,
-				Height: 600,
-			},
-		})
-		if err != nil {
-			log.Fatal(err)
-		}
-	})
-}
-
-func draw(w *glwidget.GL) {
-	cv.Save()
-	defer cv.Restore()
-
-	cv.Translate(0, 600)
-	cv.Scale(1, -1)
-
-	cv.ClearRect(0, 0, 600, 600)
-	cv.SetFillStyle("#FF00FF")
-	cv.FillRect(100, 100, 200, 200)
-
-	w.Publish()
-	w.Mark(node.MarkNeedsPaintBase)
-}

glfwcanvas/glfwcanvas.go

@@ -1,184 +0,0 @@
-package glfwcanvas
-
-import (
-	"fmt"
-	_ "image/gif" // Imported here so that applications based on this package support these formats by default
-	_ "image/jpeg"
-	_ "image/png"
-	"math"
-	"runtime"
-	"time"
-
-	"github.com/go-gl/gl/v3.2-core/gl"
-	"github.com/go-gl/glfw/v3.3/glfw"
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/goglbackend"
-)
-
-// Window represents the opened window with GL context. The Mouse* and Key*
-// functions can be set for callbacks
-type Window struct {
-	Window     *glfw.Window
-	canvas     *canvas.Canvas
-	frameTimes [10]time.Time
-	frameIndex int
-	frameCount int
-	fps        float32
-	close      bool
-	MouseDown  func(button, x, y int)
-	MouseMove  func(x, y int)
-	MouseUp    func(button, x, y int)
-	MouseWheel func(x, y int)
-	KeyDown    func(scancode int, rn rune, name string)
-	KeyUp      func(scancode int, rn rune, name string)
-	KeyChar    func(rn rune)
-	SizeChange func(w, h int)
-}
-
-// CreateWindow creates a window using SDL and initializes the OpenGL context
-func CreateWindow(w, h int, title string) (*Window, *canvas.Canvas, error) {
-	runtime.LockOSThread()
-
-	// init GLFW
-	err := glfw.Init()
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error initializing GLFW: %v", err)
-	}
-
-	// the stencil size setting is required for the canvas to work
-	glfw.WindowHint(glfw.StencilBits, 8)
-	glfw.WindowHint(glfw.DepthBits, 0)
-
-	// create window
-	window, err := glfw.CreateWindow(w, h, title, nil, nil)
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error creating window: %v", err)
-	}
-	window.MakeContextCurrent()
-
-	// init GL
-	err = gl.Init()
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error initializing GL: %v", err)
-	}
-
-	// set vsync on, enable multisample (if available)
-	glfw.SwapInterval(1)
-	gl.Enable(gl.MULTISAMPLE)
-
-	// load canvas GL backend
-	fbw, fbh := window.GetFramebufferSize()
-	backend, err := goglbackend.New(0, 0, fbw, fbh, nil)
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error loading GoGL backend: %v", err)
-	}
-
-	cv := canvas.New(backend)
-	wnd := &Window{
-		Window: window,
-		canvas: cv,
-	}
-
-	var mx, my int
-
-	window.SetMouseButtonCallback(func(w *glfw.Window, button glfw.MouseButton, action glfw.Action, mod glfw.ModifierKey) {
-		if action == glfw.Press && wnd.MouseDown != nil {
-			wnd.MouseDown(int(button), mx, my)
-		} else if action == glfw.Release && wnd.MouseUp != nil {
-			wnd.MouseUp(int(button), mx, my)
-		}
-	})
-	window.SetCursorPosCallback(func(w *glfw.Window, xpos, ypos float64) {
-		mx, my = int(math.Round(xpos)), int(math.Round(ypos))
-		if wnd.MouseMove != nil {
-			wnd.MouseMove(mx, my)
-		}
-	})
-	window.SetScrollCallback(func(w *glfw.Window, xoff, yoff float64) {
-		if wnd.MouseWheel != nil {
-			wnd.MouseWheel(int(math.Round(xoff)), int(math.Round(yoff)))
-		}
-	})
-	window.SetKeyCallback(func(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
-		if action == glfw.Press && wnd.KeyDown != nil {
-			wnd.KeyDown(scancode, keyRune(key), keyName(key))
-		} else if action == glfw.Release && wnd.KeyUp != nil {
-			wnd.KeyUp(scancode, keyRune(key), keyName(key))
-		}
-	})
-	window.SetCharCallback(func(w *glfw.Window, char rune) {
-		if wnd.KeyChar != nil {
-			wnd.KeyChar(char)
-		}
-	})
-	window.SetSizeCallback(func(w *glfw.Window, width, height int) {
-		if wnd.SizeChange != nil {
-			wnd.SizeChange(width, height)
-		} else {
-			fbw, fbh := window.GetFramebufferSize()
-			backend.SetBounds(0, 0, fbw, fbh)
-		}
-	})
-	window.SetCloseCallback(func(w *glfw.Window) {
-		wnd.Close()
-	})
-
-	return wnd, cv, nil
-}
-
-// FPS returns the frames per second (averaged over 10 frames)
-func (wnd *Window) FPS() float32 {
-	return wnd.fps
-}
-
-// Close can be used to end a call to MainLoop
-func (wnd *Window) Close() {
-	wnd.close = true
-}
-
-// StartFrame handles events and gets the window ready for rendering
-func (wnd *Window) StartFrame() {
-	wnd.Window.MakeContextCurrent()
-	glfw.PollEvents()
-}
-
-// FinishFrame updates the FPS count and displays the frame
-func (wnd *Window) FinishFrame() {
-	now := time.Now()
-	wnd.frameTimes[wnd.frameIndex] = now
-	wnd.frameIndex++
-	wnd.frameIndex %= len(wnd.frameTimes)
-	if wnd.frameCount < len(wnd.frameTimes) {
-		wnd.frameCount++
-	} else {
-		diff := now.Sub(wnd.frameTimes[wnd.frameIndex]).Seconds()
-		wnd.fps = float32(wnd.frameCount-1) / float32(diff)
-	}
-
-	wnd.Window.SwapBuffers()
-}
-
-// MainLoop runs a main loop and calls run on every frame
-func (wnd *Window) MainLoop(run func()) {
-	for !wnd.close {
-		wnd.StartFrame()
-		run()
-		wnd.FinishFrame()
-	}
-}
-
-// Size returns the current width and height of the window.
-// Note that this size may not be the same as the size of the
-// framebuffer, since some operating systems scale the window.
-// Use the Width/Height/Size function on Canvas to determine
-// the drawing size
-func (wnd *Window) Size() (int, int) {
-	return wnd.Window.GetSize()
-}
-
-// FramebufferSize returns the current width and height of
-// the framebuffer, which is also the internal size of the
-// canvas
-func (wnd *Window) FramebufferSize() (int, int) {
-	return wnd.Window.GetFramebufferSize()
-}

glfwcanvas/keynames.go

@@ -1,216 +0,0 @@
-package glfwcanvas
-
-import "github.com/go-gl/glfw/v3.3/glfw"
-
-var keyNameMap [347]string
-var keyRuneMap [347]rune
-
-func init() {
-	keyNameMap[glfw.KeyEscape] = "Escape"
-	keyNameMap[glfw.Key0] = "Digit0"
-	keyNameMap[glfw.Key1] = "Digit1"
-	keyNameMap[glfw.Key2] = "Digit2"
-	keyNameMap[glfw.Key3] = "Digit3"
-	keyNameMap[glfw.Key4] = "Digit4"
-	keyNameMap[glfw.Key5] = "Digit5"
-	keyNameMap[glfw.Key6] = "Digit6"
-	keyNameMap[glfw.Key7] = "Digit7"
-	keyNameMap[glfw.Key8] = "Digit8"
-	keyNameMap[glfw.Key9] = "Digit9"
-	keyNameMap[glfw.KeyMinus] = "Minus"
-	keyNameMap[glfw.KeyEqual] = "Equal"
-	keyNameMap[glfw.KeyBackspace] = "Backspace"
-	keyNameMap[glfw.KeyTab] = "Tab"
-	keyNameMap[glfw.KeyQ] = "KeyQ"
-	keyNameMap[glfw.KeyW] = "KeyW"
-	keyNameMap[glfw.KeyE] = "KeyE"
-	keyNameMap[glfw.KeyR] = "KeyR"
-	keyNameMap[glfw.KeyT] = "KeyT"
-	keyNameMap[glfw.KeyY] = "KeyY"
-	keyNameMap[glfw.KeyU] = "KeyU"
-	keyNameMap[glfw.KeyI] = "KeyI"
-	keyNameMap[glfw.KeyO] = "KeyO"
-	keyNameMap[glfw.KeyP] = "KeyP"
-	keyNameMap[glfw.KeyLeftBracket] = "BracketLeft"
-	keyNameMap[glfw.KeyRightBracket] = "BracketRight"
-	keyNameMap[glfw.KeyEnter] = "Enter"
-	keyNameMap[glfw.KeyLeftControl] = "ControlLeft"
-	keyNameMap[glfw.KeyA] = "KeyA"
-	keyNameMap[glfw.KeyS] = "KeyS"
-	keyNameMap[glfw.KeyD] = "KeyD"
-	keyNameMap[glfw.KeyF] = "KeyF"
-	keyNameMap[glfw.KeyG] = "KeyG"
-	keyNameMap[glfw.KeyH] = "KeyH"
-	keyNameMap[glfw.KeyJ] = "KeyJ"
-	keyNameMap[glfw.KeyK] = "KeyK"
-	keyNameMap[glfw.KeyL] = "KeyL"
-	keyNameMap[glfw.KeySemicolon] = "Semicolon"
-	keyNameMap[glfw.KeyApostrophe] = "Quote"
-	keyNameMap[glfw.KeyGraveAccent] = "Backquote"
-	keyNameMap[glfw.KeyLeftShift] = "ShiftLeft"
-	keyNameMap[glfw.KeyBackslash] = "Backslash"
-	keyNameMap[glfw.KeyZ] = "KeyZ"
-	keyNameMap[glfw.KeyX] = "KeyX"
-	keyNameMap[glfw.KeyC] = "KeyC"
-	keyNameMap[glfw.KeyV] = "KeyV"
-	keyNameMap[glfw.KeyB] = "KeyB"
-	keyNameMap[glfw.KeyN] = "KeyN"
-	keyNameMap[glfw.KeyM] = "KeyM"
-	keyNameMap[glfw.KeyComma] = "Comma"
-	keyNameMap[glfw.KeyPeriod] = "Period"
-	keyNameMap[glfw.KeySlash] = "Slash"
-	keyNameMap[glfw.KeyRightShift] = "ShiftRight"
-	keyNameMap[glfw.KeyKPMultiply] = "NumpadMultiply"
-	keyNameMap[glfw.KeyLeftAlt] = "AltLeft"
-	keyNameMap[glfw.KeySpace] = "Space"
-	keyNameMap[glfw.KeyCapsLock] = "CapsLock"
-	keyNameMap[glfw.KeyF1] = "F1"
-	keyNameMap[glfw.KeyF2] = "F2"
-	keyNameMap[glfw.KeyF3] = "F3"
-	keyNameMap[glfw.KeyF4] = "F4"
-	keyNameMap[glfw.KeyF5] = "F5"
-	keyNameMap[glfw.KeyF6] = "F6"
-	keyNameMap[glfw.KeyF7] = "F7"
-	keyNameMap[glfw.KeyF8] = "F8"
-	keyNameMap[glfw.KeyF9] = "F9"
-	keyNameMap[glfw.KeyF10] = "F10"
-	keyNameMap[glfw.KeyPause] = "Pause"
-	keyNameMap[glfw.KeyScrollLock] = "ScrollLock"
-	keyNameMap[glfw.KeyKP7] = "Numpad7"
-	keyNameMap[glfw.KeyKP8] = "Numpad8"
-	keyNameMap[glfw.KeyKP9] = "Numpad9"
-	keyNameMap[glfw.KeyKPSubtract] = "NumpadSubtract"
-	keyNameMap[glfw.KeyKP4] = "Numpad4"
-	keyNameMap[glfw.KeyKP5] = "Numpad5"
-	keyNameMap[glfw.KeyKP6] = "Numpad6"
-	keyNameMap[glfw.KeyKPAdd] = "NumpadAdd"
-	keyNameMap[glfw.KeyKP1] = "Numpad1"
-	keyNameMap[glfw.KeyKP2] = "Numpad2"
-	keyNameMap[glfw.KeyKP3] = "Numpad3"
-	keyNameMap[glfw.KeyKP0] = "Numpad0"
-	keyNameMap[glfw.KeyKPDecimal] = "NumpadDecimal"
-	keyNameMap[glfw.KeyPrintScreen] = "PrintScreen"
-	// keyNameMap[glfw.KeyNonUSBackslash] = "IntlBackslash"
-	keyNameMap[glfw.KeyF11] = "F11"
-	keyNameMap[glfw.KeyF12] = "F12"
-	keyNameMap[glfw.KeyKPEqual] = "NumpadEqual"
-	keyNameMap[glfw.KeyF13] = "F13"
-	keyNameMap[glfw.KeyF14] = "F14"
-	keyNameMap[glfw.KeyF15] = "F15"
-	keyNameMap[glfw.KeyF16] = "F16"
-	keyNameMap[glfw.KeyF17] = "F17"
-	keyNameMap[glfw.KeyF18] = "F18"
-	keyNameMap[glfw.KeyF19] = "F19"
-	// keyNameMap[glfw.KeyUndo] = "Undo"
-	// keyNameMap[glfw.KeyPaste] = "Paste"
-	// keyNameMap[glfw.KeyAudioNext] = "MediaTrackPrevious"
-	// keyNameMap[glfw.KeyCut] = "Cut"
-	// keyNameMap[glfw.KeyCopy] = "Copy"
-	// keyNameMap[glfw.KeyAudioNext] = "MediaTrackNext"
-	keyNameMap[glfw.KeyKPEnter] = "NumpadEnter"
-	keyNameMap[glfw.KeyRightControl] = "ControlRight"
-	// keyNameMap[glfw.KeyMute] = "AudioVolumeMute"
-	// keyNameMap[glfw.KeyAudioPlay] = "MediaPlayPause"
-	// keyNameMap[glfw.KeyAudioStop] = "MediaStop"
-	// keyNameMap[glfw.KeyVolumeDown] = "AudioVolumeDown"
-	// keyNameMap[glfw.KeyVolumeUp] = "AudioVolumeUp"
-	keyNameMap[glfw.KeyKPDivide] = "NumpadDivide"
-	keyNameMap[glfw.KeyRightAlt] = "AltRight"
-	// keyNameMap[glfw.KeyHelp] = "Help"
-	keyNameMap[glfw.KeyHome] = "Home"
-	keyNameMap[glfw.KeyUp] = "ArrowUp"
-	keyNameMap[glfw.KeyPageUp] = "PageUp"
-	keyNameMap[glfw.KeyLeft] = "ArrowLeft"
-	keyNameMap[glfw.KeyRight] = "ArrowRight"
-	keyNameMap[glfw.KeyEnd] = "End"
-	keyNameMap[glfw.KeyDown] = "ArrowDown"
-	keyNameMap[glfw.KeyInsert] = "Insert"
-	keyNameMap[glfw.KeyDelete] = "Delete"
-	// keyNameMap[glfw.KeyApplication] = "ContextMenu"
-
-	keyRuneMap[glfw.Key0] = '0'
-	keyRuneMap[glfw.Key1] = '1'
-	keyRuneMap[glfw.Key2] = '2'
-	keyRuneMap[glfw.Key3] = '3'
-	keyRuneMap[glfw.Key4] = '4'
-	keyRuneMap[glfw.Key5] = '5'
-	keyRuneMap[glfw.Key6] = '6'
-	keyRuneMap[glfw.Key7] = '7'
-	keyRuneMap[glfw.Key8] = '8'
-	keyRuneMap[glfw.Key9] = '9'
-	keyRuneMap[glfw.KeyMinus] = '-'
-	keyRuneMap[glfw.KeyEqual] = '='
-	keyRuneMap[glfw.KeyTab] = '\t'
-	keyRuneMap[glfw.KeyQ] = 'Q'
-	keyRuneMap[glfw.KeyW] = 'W'
-	keyRuneMap[glfw.KeyE] = 'E'
-	keyRuneMap[glfw.KeyR] = 'R'
-	keyRuneMap[glfw.KeyT] = 'T'
-	keyRuneMap[glfw.KeyY] = 'Y'
-	keyRuneMap[glfw.KeyU] = 'U'
-	keyRuneMap[glfw.KeyI] = 'I'
-	keyRuneMap[glfw.KeyO] = 'O'
-	keyRuneMap[glfw.KeyP] = 'P'
-	keyRuneMap[glfw.KeyLeftBracket] = '['
-	keyRuneMap[glfw.KeyRightBracket] = ']'
-	keyRuneMap[glfw.KeyEnter] = '\n'
-	keyRuneMap[glfw.KeyA] = 'A'
-	keyRuneMap[glfw.KeyS] = 'S'
-	keyRuneMap[glfw.KeyD] = 'D'
-	keyRuneMap[glfw.KeyF] = 'F'
-	keyRuneMap[glfw.KeyG] = 'G'
-	keyRuneMap[glfw.KeyH] = 'H'
-	keyRuneMap[glfw.KeyJ] = 'J'
-	keyRuneMap[glfw.KeyK] = 'K'
-	keyRuneMap[glfw.KeyL] = 'L'
-	keyRuneMap[glfw.KeySemicolon] = ';'
-	keyRuneMap[glfw.KeyApostrophe] = '\''
-	keyRuneMap[glfw.KeyGraveAccent] = '`'
-	keyRuneMap[glfw.KeyBackslash] = '\\'
-	keyRuneMap[glfw.KeyZ] = 'Z'
-	keyRuneMap[glfw.KeyX] = 'X'
-	keyRuneMap[glfw.KeyC] = 'C'
-	keyRuneMap[glfw.KeyV] = 'V'
-	keyRuneMap[glfw.KeyB] = 'B'
-	keyRuneMap[glfw.KeyN] = 'N'
-	keyRuneMap[glfw.KeyM] = 'M'
-	keyRuneMap[glfw.KeyComma] = ','
-	keyRuneMap[glfw.KeyPeriod] = '.'
-	keyRuneMap[glfw.KeySlash] = '/'
-	keyRuneMap[glfw.KeyKPMultiply] = '*'
-	keyRuneMap[glfw.KeySpace] = ' '
-	keyRuneMap[glfw.KeyKP7] = '7'
-	keyRuneMap[glfw.KeyKP8] = '8'
-	keyRuneMap[glfw.KeyKP9] = '9'
-	keyRuneMap[glfw.KeyKPSubtract] = '-'
-	keyRuneMap[glfw.KeyKP4] = '4'
-	keyRuneMap[glfw.KeyKP5] = '5'
-	keyRuneMap[glfw.KeyKP6] = '6'
-	keyRuneMap[glfw.KeyKPAdd] = '+'
-	keyRuneMap[glfw.KeyKP1] = '1'
-	keyRuneMap[glfw.KeyKP2] = '2'
-	keyRuneMap[glfw.KeyKP3] = '3'
-	keyRuneMap[glfw.KeyKP0] = '0'
-	keyRuneMap[glfw.KeyKPDecimal] = '.'
-	keyRuneMap[glfw.KeyKPEqual] = '='
-	keyRuneMap[glfw.KeyKPEnter] = '\n'
-	keyRuneMap[glfw.KeyKPDivide] = '/'
-}
-
-func keyName(key glfw.Key) string {
-	if int(key) >= len(keyNameMap) {
-		return "Unidentified"
-	}
-	name := keyNameMap[key]
-	if name == "" {
-		return "Unidentified"
-	}
-	return name
-}
-
-func keyRune(key glfw.Key) rune {
-	if int(key) >= len(keyNameMap) {
-		return 0
-	}
-	return keyRuneMap[key]
-}

go.mod

@@ -1,14 +1,14 @@
 module github.com/tfriedel6/canvas
 
 require (
-	github.com/go-gl/gl v0.0.0-20181026044259-55b76b7df9d2
-	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72
+	github.com/go-gl/gl v0.0.0-20190320180904-bf2b1f2f34d7
+	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200707082815-5321531c36a2
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
-	github.com/veandco/go-sdl2 v0.4.0
-	golang.org/x/exp v0.0.0-20181106170214-d68db9428509
-	golang.org/x/image v0.0.0-20200119044424-58c23975cae1
-	golang.org/x/mobile v0.0.0-20181026062114-a27dd33d354d
-	golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 // indirect
+	github.com/veandco/go-sdl2 v0.4.4
+	golang.org/x/exp v0.0.0-20200513190911-00229845015e
+	golang.org/x/image v0.0.0-20200801110659-972c09e46d76
+	golang.org/x/mobile v0.0.0-20200801112145-973feb4309de
+	golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed // indirect
 )
 
 go 1.13

go.sum

@@ -1,17 +1,46 @@
-github.com/go-gl/gl v0.0.0-20181026044259-55b76b7df9d2 h1:78Hza2KHn2PX1jdydQnffaU2A/xM0g3Nx1xmMdep9Gk=
-github.com/go-gl/gl v0.0.0-20181026044259-55b76b7df9d2/go.mod h1:482civXOzJJCPzJ4ZOX/pwvXBWSnzD4OKMdH4ClKGbk=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72 h1:b+9H1GAsx5RsjvDFLoS5zkNBzIQMuVKUYQDmxU3N5XE=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/go-gl/gl v0.0.0-20190320180904-bf2b1f2f34d7/go.mod h1:482civXOzJJCPzJ4ZOX/pwvXBWSnzD4OKMdH4ClKGbk=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200707082815-5321531c36a2 h1:Ac1OEHHkbAZ6EUnJahF0GKcU0FjPc/V8F1DvjhKngFE=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200707082815-5321531c36a2/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
-github.com/veandco/go-sdl2 v0.4.0 h1:l9q6K+Dvpd/VlZdw2ufApKnWhAQqx9UL8Zrvbjtm3Lw=
-github.com/veandco/go-sdl2 v0.4.0/go.mod h1:FB+kTpX9YTE+urhYiClnRzpOXbiWgaU3+5F2AB78DPg=
-golang.org/x/exp v0.0.0-20181106170214-d68db9428509 h1:k21GX33vzpH/syMF7TgrLxe8ILtvwbyuHtEO3ebR82E=
-golang.org/x/exp v0.0.0-20181106170214-d68db9428509/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/image v0.0.0-20200119044424-58c23975cae1 h1:5h3ngYt7+vXCDZCup/HkCQgW5XwmSvR/nA2JmJ0RErg=
-golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/mobile v0.0.0-20181026062114-a27dd33d354d h1:DuZZDdMFwDrzmycNhCaWSve7Vh+BIrjm7ttgb4fD3Os=
-golang.org/x/mobile v0.0.0-20181026062114-a27dd33d354d/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 h1:YAFjXN64LMvktoUZH9zgY4lGc/msGN7HQfoSuKCgaDU=
-golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+github.com/veandco/go-sdl2 v0.4.4 h1:coOJGftOdvNvGoUIZmm4XD+ZRQF4mg9ZVHmH3/42zFQ=
+github.com/veandco/go-sdl2 v0.4.4/go.mod h1:FB+kTpX9YTE+urhYiClnRzpOXbiWgaU3+5F2AB78DPg=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56/go.mod h1:JhuoJpWY28nO4Vef9tZUw9qufEGTyX1+7lmHxV5q5G4=
+golang.org/x/exp v0.0.0-20200513190911-00229845015e h1:rMqLP+9XLy+LdbCXHjJHAmTfXCr93W7oruWA6Hq1Alc=
+golang.org/x/exp v0.0.0-20200513190911-00229845015e/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.0.0-20200801110659-972c09e46d76 h1:U7GPaoQyQmX+CBRWXKrvRzWTbd+slqeSh8uARsIyhAw=
+golang.org/x/image v0.0.0-20200801110659-972c09e46d76/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mobile v0.0.0-20200801112145-973feb4309de h1:OVJ6QQUBAesB8CZijKDSsXX7xYVtUhrkY0gwMfbi4p4=
+golang.org/x/mobile v0.0.0-20200801112145-973feb4309de/go.mod h1:skQtrUTUwhdJvXM/2KKJzY8pDgNr9I/FOMqDVRPBUS4=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191209134235-331c550502dd/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed h1:WBkVNH1zd9jg/dK4HCM4lNANnmd12EHC9z+LmcCG4ns=
+golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200117012304-6edc0a871e69/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

images.go

@@ -141,6 +141,12 @@ func (img *Image) Delete() {
 
 // Replace replaces the image with the new one
 func (img *Image) Replace(src interface{}) error {
+	if img.src == src {
+		if origImg, ok := img.src.(image.Image); ok {
+			img.img.Replace(origImg)
+			return nil
+		}
+	}
 	newImg, err := img.cv.LoadImage(src)
 	if err != nil {
 		return err

path2d.go

@@ -372,9 +372,6 @@ func (p *Path2D) ClosePath() {
 	if len(p.p) < 2 {
 		return
 	}
-	if isSamePoint(p.p[len(p.p)-1].pos, p.p[0].pos, 0.1) {
-		return
-	}
 	closeIdx := 0
 	for i := len(p.p) - 1; i >= 0; i-- {
 		if p.p[i].flags&pathMove != 0 {
@@ -382,7 +379,9 @@ func (p *Path2D) ClosePath() {
 			break
 		}
 	}
-	p.LineTo(p.p[closeIdx].pos[0], p.p[closeIdx].pos[1])
+	if !isSamePoint(p.p[len(p.p)-1].pos, p.p[0].pos, 0.1) {
+		p.LineTo(p.p[closeIdx].pos[0], p.p[closeIdx].pos[1])
+	}
 	p.p[len(p.p)-1].next = p.p[closeIdx].next
 	p.p[len(p.p)-1].flags |= pathAttach
 }

sdlcanvas/keynames.go

@@ -1,216 +0,0 @@
-package sdlcanvas
-
-import "github.com/veandco/go-sdl2/sdl"
-
-var keyNameMap [262]string
-var keyRuneMap [262]rune
-
-func init() {
-	keyNameMap[sdl.SCANCODE_ESCAPE] = "Escape"
-	keyNameMap[sdl.SCANCODE_0] = "Digit0"
-	keyNameMap[sdl.SCANCODE_1] = "Digit1"
-	keyNameMap[sdl.SCANCODE_2] = "Digit2"
-	keyNameMap[sdl.SCANCODE_3] = "Digit3"
-	keyNameMap[sdl.SCANCODE_4] = "Digit4"
-	keyNameMap[sdl.SCANCODE_5] = "Digit5"
-	keyNameMap[sdl.SCANCODE_6] = "Digit6"
-	keyNameMap[sdl.SCANCODE_7] = "Digit7"
-	keyNameMap[sdl.SCANCODE_8] = "Digit8"
-	keyNameMap[sdl.SCANCODE_9] = "Digit9"
-	keyNameMap[sdl.SCANCODE_MINUS] = "Minus"
-	keyNameMap[sdl.SCANCODE_EQUALS] = "Equal"
-	keyNameMap[sdl.SCANCODE_BACKSPACE] = "Backspace"
-	keyNameMap[sdl.SCANCODE_TAB] = "Tab"
-	keyNameMap[sdl.SCANCODE_Q] = "KeyQ"
-	keyNameMap[sdl.SCANCODE_W] = "KeyW"
-	keyNameMap[sdl.SCANCODE_E] = "KeyE"
-	keyNameMap[sdl.SCANCODE_R] = "KeyR"
-	keyNameMap[sdl.SCANCODE_T] = "KeyT"
-	keyNameMap[sdl.SCANCODE_Y] = "KeyY"
-	keyNameMap[sdl.SCANCODE_U] = "KeyU"
-	keyNameMap[sdl.SCANCODE_I] = "KeyI"
-	keyNameMap[sdl.SCANCODE_O] = "KeyO"
-	keyNameMap[sdl.SCANCODE_P] = "KeyP"
-	keyNameMap[sdl.SCANCODE_LEFTBRACKET] = "BracketLeft"
-	keyNameMap[sdl.SCANCODE_RIGHTBRACKET] = "BracketRight"
-	keyNameMap[sdl.SCANCODE_RETURN] = "Enter"
-	keyNameMap[sdl.SCANCODE_LCTRL] = "ControlLeft"
-	keyNameMap[sdl.SCANCODE_A] = "KeyA"
-	keyNameMap[sdl.SCANCODE_S] = "KeyS"
-	keyNameMap[sdl.SCANCODE_D] = "KeyD"
-	keyNameMap[sdl.SCANCODE_F] = "KeyF"
-	keyNameMap[sdl.SCANCODE_G] = "KeyG"
-	keyNameMap[sdl.SCANCODE_H] = "KeyH"
-	keyNameMap[sdl.SCANCODE_J] = "KeyJ"
-	keyNameMap[sdl.SCANCODE_K] = "KeyK"
-	keyNameMap[sdl.SCANCODE_L] = "KeyL"
-	keyNameMap[sdl.SCANCODE_SEMICOLON] = "Semicolon"
-	keyNameMap[sdl.SCANCODE_APOSTROPHE] = "Quote"
-	keyNameMap[sdl.SCANCODE_GRAVE] = "Backquote"
-	keyNameMap[sdl.SCANCODE_LSHIFT] = "ShiftLeft"
-	keyNameMap[sdl.SCANCODE_BACKSLASH] = "Backslash"
-	keyNameMap[sdl.SCANCODE_Z] = "KeyZ"
-	keyNameMap[sdl.SCANCODE_X] = "KeyX"
-	keyNameMap[sdl.SCANCODE_C] = "KeyC"
-	keyNameMap[sdl.SCANCODE_V] = "KeyV"
-	keyNameMap[sdl.SCANCODE_B] = "KeyB"
-	keyNameMap[sdl.SCANCODE_N] = "KeyN"
-	keyNameMap[sdl.SCANCODE_M] = "KeyM"
-	keyNameMap[sdl.SCANCODE_COMMA] = "Comma"
-	keyNameMap[sdl.SCANCODE_PERIOD] = "Period"
-	keyNameMap[sdl.SCANCODE_SLASH] = "Slash"
-	keyNameMap[sdl.SCANCODE_RSHIFT] = "ShiftRight"
-	keyNameMap[sdl.SCANCODE_KP_MULTIPLY] = "NumpadMultiply"
-	keyNameMap[sdl.SCANCODE_LALT] = "AltLeft"
-	keyNameMap[sdl.SCANCODE_SPACE] = "Space"
-	keyNameMap[sdl.SCANCODE_CAPSLOCK] = "CapsLock"
-	keyNameMap[sdl.SCANCODE_F1] = "F1"
-	keyNameMap[sdl.SCANCODE_F2] = "F2"
-	keyNameMap[sdl.SCANCODE_F3] = "F3"
-	keyNameMap[sdl.SCANCODE_F4] = "F4"
-	keyNameMap[sdl.SCANCODE_F5] = "F5"
-	keyNameMap[sdl.SCANCODE_F6] = "F6"
-	keyNameMap[sdl.SCANCODE_F7] = "F7"
-	keyNameMap[sdl.SCANCODE_F8] = "F8"
-	keyNameMap[sdl.SCANCODE_F9] = "F9"
-	keyNameMap[sdl.SCANCODE_F10] = "F10"
-	keyNameMap[sdl.SCANCODE_PAUSE] = "Pause"
-	keyNameMap[sdl.SCANCODE_SCROLLLOCK] = "ScrollLock"
-	keyNameMap[sdl.SCANCODE_KP_7] = "Numpad7"
-	keyNameMap[sdl.SCANCODE_KP_8] = "Numpad8"
-	keyNameMap[sdl.SCANCODE_KP_9] = "Numpad9"
-	keyNameMap[sdl.SCANCODE_KP_MINUS] = "NumpadSubtract"
-	keyNameMap[sdl.SCANCODE_KP_4] = "Numpad4"
-	keyNameMap[sdl.SCANCODE_KP_5] = "Numpad5"
-	keyNameMap[sdl.SCANCODE_KP_6] = "Numpad6"
-	keyNameMap[sdl.SCANCODE_KP_PLUS] = "NumpadAdd"
-	keyNameMap[sdl.SCANCODE_KP_1] = "Numpad1"
-	keyNameMap[sdl.SCANCODE_KP_2] = "Numpad2"
-	keyNameMap[sdl.SCANCODE_KP_3] = "Numpad3"
-	keyNameMap[sdl.SCANCODE_KP_0] = "Numpad0"
-	keyNameMap[sdl.SCANCODE_KP_DECIMAL] = "NumpadDecimal"
-	keyNameMap[sdl.SCANCODE_PRINTSCREEN] = "PrintScreen"
-	keyNameMap[sdl.SCANCODE_NONUSBACKSLASH] = "IntlBackslash"
-	keyNameMap[sdl.SCANCODE_F11] = "F11"
-	keyNameMap[sdl.SCANCODE_F12] = "F12"
-	keyNameMap[sdl.SCANCODE_KP_EQUALS] = "NumpadEqual"
-	keyNameMap[sdl.SCANCODE_F13] = "F13"
-	keyNameMap[sdl.SCANCODE_F14] = "F14"
-	keyNameMap[sdl.SCANCODE_F15] = "F15"
-	keyNameMap[sdl.SCANCODE_F16] = "F16"
-	keyNameMap[sdl.SCANCODE_F17] = "F17"
-	keyNameMap[sdl.SCANCODE_F18] = "F18"
-	keyNameMap[sdl.SCANCODE_F19] = "F19"
-	keyNameMap[sdl.SCANCODE_UNDO] = "Undo"
-	keyNameMap[sdl.SCANCODE_PASTE] = "Paste"
-	keyNameMap[sdl.SCANCODE_AUDIOPREV] = "MediaTrackPrevious"
-	keyNameMap[sdl.SCANCODE_CUT] = "Cut"
-	keyNameMap[sdl.SCANCODE_COPY] = "Copy"
-	keyNameMap[sdl.SCANCODE_AUDIONEXT] = "MediaTrackNext"
-	keyNameMap[sdl.SCANCODE_KP_ENTER] = "NumpadEnter"
-	keyNameMap[sdl.SCANCODE_RCTRL] = "ControlRight"
-	keyNameMap[sdl.SCANCODE_MUTE] = "AudioVolumeMute"
-	keyNameMap[sdl.SCANCODE_AUDIOPLAY] = "MediaPlayPause"
-	keyNameMap[sdl.SCANCODE_AUDIOSTOP] = "MediaStop"
-	keyNameMap[sdl.SCANCODE_VOLUMEDOWN] = "AudioVolumeDown"
-	keyNameMap[sdl.SCANCODE_VOLUMEUP] = "AudioVolumeUp"
-	keyNameMap[sdl.SCANCODE_KP_DIVIDE] = "NumpadDivide"
-	keyNameMap[sdl.SCANCODE_RALT] = "AltRight"
-	keyNameMap[sdl.SCANCODE_HELP] = "Help"
-	keyNameMap[sdl.SCANCODE_HOME] = "Home"
-	keyNameMap[sdl.SCANCODE_UP] = "ArrowUp"
-	keyNameMap[sdl.SCANCODE_PAGEUP] = "PageUp"
-	keyNameMap[sdl.SCANCODE_LEFT] = "ArrowLeft"
-	keyNameMap[sdl.SCANCODE_RIGHT] = "ArrowRight"
-	keyNameMap[sdl.SCANCODE_END] = "End"
-	keyNameMap[sdl.SCANCODE_DOWN] = "ArrowDown"
-	keyNameMap[sdl.SCANCODE_INSERT] = "Insert"
-	keyNameMap[sdl.SCANCODE_DELETE] = "Delete"
-	keyNameMap[sdl.SCANCODE_APPLICATION] = "ContextMenu"
-
-	keyRuneMap[sdl.SCANCODE_0] = '0'
-	keyRuneMap[sdl.SCANCODE_1] = '1'
-	keyRuneMap[sdl.SCANCODE_2] = '2'
-	keyRuneMap[sdl.SCANCODE_3] = '3'
-	keyRuneMap[sdl.SCANCODE_4] = '4'
-	keyRuneMap[sdl.SCANCODE_5] = '5'
-	keyRuneMap[sdl.SCANCODE_6] = '6'
-	keyRuneMap[sdl.SCANCODE_7] = '7'
-	keyRuneMap[sdl.SCANCODE_8] = '8'
-	keyRuneMap[sdl.SCANCODE_9] = '9'
-	keyRuneMap[sdl.SCANCODE_MINUS] = '-'
-	keyRuneMap[sdl.SCANCODE_EQUALS] = '='
-	keyRuneMap[sdl.SCANCODE_TAB] = '\t'
-	keyRuneMap[sdl.SCANCODE_Q] = 'Q'
-	keyRuneMap[sdl.SCANCODE_W] = 'W'
-	keyRuneMap[sdl.SCANCODE_E] = 'E'
-	keyRuneMap[sdl.SCANCODE_R] = 'R'
-	keyRuneMap[sdl.SCANCODE_T] = 'T'
-	keyRuneMap[sdl.SCANCODE_Y] = 'Y'
-	keyRuneMap[sdl.SCANCODE_U] = 'U'
-	keyRuneMap[sdl.SCANCODE_I] = 'I'
-	keyRuneMap[sdl.SCANCODE_O] = 'O'
-	keyRuneMap[sdl.SCANCODE_P] = 'P'
-	keyRuneMap[sdl.SCANCODE_LEFTBRACKET] = '['
-	keyRuneMap[sdl.SCANCODE_RIGHTBRACKET] = ']'
-	keyRuneMap[sdl.SCANCODE_RETURN] = '\n'
-	keyRuneMap[sdl.SCANCODE_A] = 'A'
-	keyRuneMap[sdl.SCANCODE_S] = 'S'
-	keyRuneMap[sdl.SCANCODE_D] = 'D'
-	keyRuneMap[sdl.SCANCODE_F] = 'F'
-	keyRuneMap[sdl.SCANCODE_G] = 'G'
-	keyRuneMap[sdl.SCANCODE_H] = 'H'
-	keyRuneMap[sdl.SCANCODE_J] = 'J'
-	keyRuneMap[sdl.SCANCODE_K] = 'K'
-	keyRuneMap[sdl.SCANCODE_L] = 'L'
-	keyRuneMap[sdl.SCANCODE_SEMICOLON] = ';'
-	keyRuneMap[sdl.SCANCODE_APOSTROPHE] = '\''
-	keyRuneMap[sdl.SCANCODE_GRAVE] = '`'
-	keyRuneMap[sdl.SCANCODE_BACKSLASH] = '\\'
-	keyRuneMap[sdl.SCANCODE_Z] = 'Z'
-	keyRuneMap[sdl.SCANCODE_X] = 'X'
-	keyRuneMap[sdl.SCANCODE_C] = 'C'
-	keyRuneMap[sdl.SCANCODE_V] = 'V'
-	keyRuneMap[sdl.SCANCODE_B] = 'B'
-	keyRuneMap[sdl.SCANCODE_N] = 'N'
-	keyRuneMap[sdl.SCANCODE_M] = 'M'
-	keyRuneMap[sdl.SCANCODE_COMMA] = ','
-	keyRuneMap[sdl.SCANCODE_PERIOD] = '.'
-	keyRuneMap[sdl.SCANCODE_SLASH] = '/'
-	keyRuneMap[sdl.SCANCODE_KP_MULTIPLY] = '*'
-	keyRuneMap[sdl.SCANCODE_SPACE] = ' '
-	keyRuneMap[sdl.SCANCODE_KP_7] = '7'
-	keyRuneMap[sdl.SCANCODE_KP_8] = '8'
-	keyRuneMap[sdl.SCANCODE_KP_9] = '9'
-	keyRuneMap[sdl.SCANCODE_KP_MINUS] = '-'
-	keyRuneMap[sdl.SCANCODE_KP_4] = '4'
-	keyRuneMap[sdl.SCANCODE_KP_5] = '5'
-	keyRuneMap[sdl.SCANCODE_KP_6] = '6'
-	keyRuneMap[sdl.SCANCODE_KP_PLUS] = '+'
-	keyRuneMap[sdl.SCANCODE_KP_1] = '1'
-	keyRuneMap[sdl.SCANCODE_KP_2] = '2'
-	keyRuneMap[sdl.SCANCODE_KP_3] = '3'
-	keyRuneMap[sdl.SCANCODE_KP_0] = '0'
-	keyRuneMap[sdl.SCANCODE_KP_DECIMAL] = '.'
-	keyRuneMap[sdl.SCANCODE_KP_EQUALS] = '='
-	keyRuneMap[sdl.SCANCODE_KP_ENTER] = '\n'
-	keyRuneMap[sdl.SCANCODE_KP_DIVIDE] = '/'
-}
-
-func keyName(s sdl.Scancode) string {
-	if int(s) >= len(keyNameMap) {
-		return "Unidentified"
-	}
-	name := keyNameMap[s]
-	if name == "" {
-		return "Unidentified"
-	}
-	return name
-}
-
-func keyRune(s sdl.Scancode) rune {
-	if int(s) >= len(keyNameMap) {
-		return 0
-	}
-	return keyRuneMap[s]
-}

sdlcanvas/sdlcanvas.go

@@ -1,275 +0,0 @@
-package sdlcanvas
-
-import (
-	"fmt"
-	_ "image/gif" // Imported here so that applications based on this package support these formats by default
-	_ "image/jpeg"
-	_ "image/png"
-	"runtime"
-	"time"
-	"unicode/utf8"
-
-	"github.com/go-gl/gl/v3.2-core/gl"
-	"github.com/tfriedel6/canvas"
-	"github.com/tfriedel6/canvas/backend/goglbackend"
-	"github.com/veandco/go-sdl2/sdl"
-)
-
-// Window represents the opened window with GL context. The Mouse* and Key*
-// functions can be set for callbacks
-type Window struct {
-	Window     *sdl.Window
-	WindowID   uint32
-	GLContext  sdl.GLContext
-	Backend    *goglbackend.GoGLBackend
-	canvas     *canvas.Canvas
-	frameTimes [10]time.Time
-	frameIndex int
-	frameCount int
-	fps        float32
-	close      bool
-	events     []sdl.Event
-	Event      func(event sdl.Event)
-	MouseDown  func(button, x, y int)
-	MouseMove  func(x, y int)
-	MouseUp    func(button, x, y int)
-	MouseWheel func(x, y int)
-	KeyDown    func(scancode int, rn rune, name string)
-	KeyUp      func(scancode int, rn rune, name string)
-	KeyChar    func(rn rune)
-	SizeChange func(w, h int)
-}
-
-// CreateWindow creates a window using SDL and initializes the OpenGL context
-func CreateWindow(w, h int, title string) (*Window, *canvas.Canvas, error) {
-	runtime.LockOSThread()
-
-	// init SDL
-	err := sdl.Init(sdl.INIT_VIDEO)
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error initializing SDL: %v", err)
-	}
-
-	sdl.GLSetAttribute(sdl.GL_RED_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_GREEN_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_BLUE_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_ALPHA_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_DEPTH_SIZE, 0)
-	sdl.GLSetAttribute(sdl.GL_STENCIL_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_DOUBLEBUFFER, 1)
-	sdl.GLSetAttribute(sdl.GL_MULTISAMPLEBUFFERS, 1)
-	sdl.GLSetAttribute(sdl.GL_MULTISAMPLESAMPLES, 4)
-
-	// create window
-	window, err := sdl.CreateWindow(title, sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, int32(w), int32(h), sdl.WINDOW_RESIZABLE|sdl.WINDOW_OPENGL|sdl.WINDOW_ALLOW_HIGHDPI)
-	if err != nil {
-		sdl.GLSetAttribute(sdl.GL_MULTISAMPLEBUFFERS, 0)
-		sdl.GLSetAttribute(sdl.GL_MULTISAMPLESAMPLES, 0)
-		window, err = sdl.CreateWindow(title, sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, int32(w), int32(h), sdl.WINDOW_RESIZABLE|sdl.WINDOW_OPENGL|sdl.WINDOW_ALLOW_HIGHDPI)
-		if err != nil {
-			return nil, nil, fmt.Errorf("Error creating window: %v", err)
-		}
-	}
-	windowID, err := window.GetID()
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error getting window ID: %v", err)
-	}
-
-	// create GL context
-	glContext, err := window.GLCreateContext()
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error creating GL context: %v", err)
-	}
-
-	// init GL
-	err = gl.Init()
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error initializing GL: %v", err)
-	}
-
-	// load canvas GL backend
-	fbw, fbh := window.GLGetDrawableSize()
-	backend, err := goglbackend.New(0, 0, int(fbw), int(fbh), nil)
-	if err != nil {
-		return nil, nil, fmt.Errorf("Error loading GoGL backend: %v", err)
-	}
-
-	sdl.GLSetSwapInterval(1)
-	gl.Enable(gl.MULTISAMPLE)
-
-	cv := canvas.New(backend)
-	wnd := &Window{
-		Window:    window,
-		WindowID:  windowID,
-		GLContext: glContext,
-		Backend:   backend,
-		canvas:    cv,
-		events:    make([]sdl.Event, 0, 100),
-	}
-
-	return wnd, cv, nil
-}
-
-// Destroy destroys the GL context and the window
-func (wnd *Window) Destroy() {
-	sdl.GLDeleteContext(wnd.GLContext)
-	wnd.Window.Destroy()
-}
-
-// FPS returns the frames per second (averaged over 10 frames)
-func (wnd *Window) FPS() float32 {
-	return wnd.fps
-}
-
-// Close can be used to end a call to MainLoop
-func (wnd *Window) Close() {
-	wnd.close = true
-}
-
-// StartFrame handles events and gets the window ready for rendering
-func (wnd *Window) StartFrame() error {
-	err := wnd.Window.GLMakeCurrent(wnd.GLContext)
-	if err != nil {
-		return err
-	}
-
-	wnd.events = wnd.events[:0]
-	for {
-		event := sdl.PollEvent()
-		if event == nil {
-			break
-		}
-
-		handled := false
-		switch e := event.(type) {
-		case *sdl.MouseButtonEvent:
-			if e.Type == sdl.MOUSEBUTTONDOWN {
-				if wnd.MouseDown != nil {
-					wnd.MouseDown(int(e.Button), int(e.X), int(e.Y))
-					handled = true
-				}
-			} else if e.Type == sdl.MOUSEBUTTONUP {
-				if wnd.MouseUp != nil {
-					wnd.MouseUp(int(e.Button), int(e.X), int(e.Y))
-					handled = true
-				}
-			}
-		case *sdl.MouseMotionEvent:
-			if wnd.MouseMove != nil {
-				wnd.MouseMove(int(e.X), int(e.Y))
-				handled = true
-			}
-		case *sdl.MouseWheelEvent:
-			if wnd.MouseWheel != nil {
-				wnd.MouseWheel(int(e.X), int(e.Y))
-				handled = true
-			}
-		case *sdl.KeyboardEvent:
-			if e.Type == sdl.KEYDOWN {
-				if wnd.KeyDown != nil {
-					wnd.KeyDown(int(e.Keysym.Scancode), keyRune(e.Keysym.Scancode), keyName(e.Keysym.Scancode))
-					handled = true
-				}
-			} else if e.Type == sdl.KEYUP {
-				if wnd.KeyUp != nil {
-					wnd.KeyUp(int(e.Keysym.Scancode), keyRune(e.Keysym.Scancode), keyName(e.Keysym.Scancode))
-					handled = true
-				}
-			}
-		case *sdl.TextInputEvent:
-			if wnd.KeyChar != nil {
-				rn, _ := utf8.DecodeRune(e.Text[:])
-				wnd.KeyChar(rn)
-				handled = true
-			}
-		case *sdl.WindowEvent:
-			if e.WindowID == wnd.WindowID {
-				if e.Event == sdl.WINDOWEVENT_SIZE_CHANGED {
-					fbw, fbh := wnd.Window.GLGetDrawableSize()
-					if wnd.SizeChange != nil {
-						wnd.SizeChange(int(e.Data1), int(e.Data2))
-						handled = true
-					} else {
-						wnd.Backend.SetBounds(0, 0, int(fbw), int(fbh))
-					}
-				}
-			}
-		}
-
-		if !handled && wnd.Event != nil {
-			wnd.Event(event)
-			handled = true
-		}
-
-		if !handled {
-			wnd.events = append(wnd.events, event)
-		}
-	}
-
-	return nil
-}
-
-// FinishFrame updates the FPS count and displays the frame
-func (wnd *Window) FinishFrame() {
-	now := time.Now()
-	wnd.frameTimes[wnd.frameIndex] = now
-	wnd.frameIndex++
-	wnd.frameIndex %= len(wnd.frameTimes)
-	if wnd.frameCount < len(wnd.frameTimes) {
-		wnd.frameCount++
-	} else {
-		diff := now.Sub(wnd.frameTimes[wnd.frameIndex]).Seconds()
-		wnd.fps = float32(wnd.frameCount-1) / float32(diff)
-	}
-
-	wnd.Window.GLSwap()
-}
-
-// MainLoop runs a main loop and calls run on every frame
-func (wnd *Window) MainLoop(run func()) {
-	// main loop
-	for !wnd.close {
-		err := wnd.StartFrame()
-		if err != nil {
-			time.Sleep(10 * time.Millisecond)
-			continue
-		}
-
-		for _, event := range wnd.events {
-			switch e := event.(type) {
-			case *sdl.WindowEvent:
-				if e.Event == sdl.WINDOWEVENT_CLOSE {
-					wnd.close = true
-				}
-			case *sdl.QuitEvent:
-				wnd.close = true
-			case *sdl.KeyboardEvent:
-				if e.Type == sdl.KEYDOWN && e.Keysym.Scancode == sdl.SCANCODE_ESCAPE {
-					wnd.close = true
-				}
-			}
-		}
-
-		run()
-
-		wnd.FinishFrame()
-	}
-}
-
-// Size returns the current width and height of the window.
-// Note that this size may not be the same as the size of the
-// framebuffer, since some operating systems scale the window.
-// Use the Width/Height/Size function on Canvas to determine
-// the drawing size
-func (wnd *Window) Size() (int, int) {
-	w, h := wnd.Window.GetSize()
-	return int(w), int(h)
-}
-
-// FramebufferSize returns the current width and height of
-// the framebuffer, which is also the internal size of the
-// canvas
-func (wnd *Window) FramebufferSize() (int, int) {
-	w, h := wnd.Window.GLGetDrawableSize()
-	return int(w), int(h)
-}

text.go

@@ -34,16 +34,29 @@ type frCache struct {
 	lastUsed time.Time
 }
 
-type fontTriCache struct {
+type fontPathCache struct {
 	cache    map[truetype.Index]*Path2D
 	lastUsed time.Time
 }
 
+func (fpc *fontPathCache) size() int {
+	size := 0
+	pps := int(unsafe.Sizeof(pathPoint{}))
+	for _, p := range fpc.cache {
+		size += len(p.p) * pps
+	}
+	return size
+}
+
+type fontTriCache struct {
+	cache    map[truetype.Index][]backendbase.Vec
+	lastUsed time.Time
+}
+
 func (ftc *fontTriCache) size() int {
 	size := 0
-	pps := int(unsafe.Sizeof(pathPoint{}))
 	for _, p := range ftc.cache {
-		size += len(p.p) * pps
+		size += len(p) * 16
 	}
 	return size
 }
@@ -140,11 +153,17 @@ func (cv *Canvas) FillText(str string, x, y float64) {
 	scale := (scaleX + scaleY) * 0.5
 	fontSize := fixed.Int26_6(math.Round(float64(cv.state.fontSize) * scale))
 
-	// if fontSize > fixed.I(30) {
-	// if time.Now().Second()%2 == 0 {
-	// 	cv.fillText2(str, x, y)
-	// 	return
-	// }
+	// if the font size is large or rotated or skewed in some way, use the
+	// triangulated font rendering
+	if fontSize > fixed.I(25) {
+		cv.fillText2(str, x, y)
+		return
+	}
+	mat := cv.state.transform
+	if mat[1] != 0 || mat[2] != 0 || mat[0] != mat[3] {
+		cv.fillText2(str, x, y)
+		return
+	}
 
 	frc := cv.getFRContext(cv.state.font, fontSize)
 	fnt := cv.state.font.font
@@ -258,9 +277,11 @@ func (cv *Canvas) fillText2(str string, x, y float64) {
 			continue
 		}
 
-		path := cv.runePath(rn)
+		tris := cv.runeTris(rn)
 		tf := scaleMat.Mul(backendbase.MatTranslate(backendbase.Vec{x, y})).Mul(cv.state.transform)
-		cv.fillPath(path, tf)
+		cv.drawShadow(tris, nil, false)
+		stl := cv.backendFillStyle(&cv.state.fill, 1)
+		cv.b.Fill(&stl, tris, tf, false)
 
 		x += float64(advance) / 64
 	}
@@ -483,7 +504,7 @@ func (cv *Canvas) runePath(rn rune) *Path2D {
 		idx = cv.state.font.font.Index(' ')
 	}
 
-	if cache, ok := cv.fontTriCache[cv.state.font]; ok {
+	if cache, ok := cv.fontPathCache[cv.state.font]; ok {
 		if path, ok := cache.cache[idx]; ok {
 			cache.lastUsed = time.Now()
 			return path
@@ -553,10 +574,10 @@ func (cv *Canvas) runePath(rn rune) *Path2D {
 		from = to
 	}
 
-	cache, ok := cv.fontTriCache[cv.state.font]
+	cache, ok := cv.fontPathCache[cv.state.font]
 	if !ok {
-		cache = &fontTriCache{cache: make(map[truetype.Index]*Path2D, 1024)}
-		cv.fontTriCache[cv.state.font] = cache
+		cache = &fontPathCache{cache: make(map[truetype.Index]*Path2D, 1024)}
+		cv.fontPathCache[cv.state.font] = cache
 	}
 	cache.lastUsed = time.Now()
 	cache.cache[idx] = path
@@ -564,6 +585,149 @@ func (cv *Canvas) runePath(rn rune) *Path2D {
 	return path
 }
 
+func (cv *Canvas) runeTris(rn rune) []backendbase.Vec {
+	idx := cv.state.font.font.Index(rn)
+	if idx == 0 {
+		idx = cv.state.font.font.Index(' ')
+	}
+
+	if cache, ok := cv.fontTriCache[cv.state.font]; ok {
+		if tris, ok := cache.cache[idx]; ok {
+			cache.lastUsed = time.Now()
+			return tris
+		}
+	}
+
+	const scale = 1.0 / 64.0
+
+	var gb truetype.GlyphBuf
+	gb.Load(cv.state.font.font, baseFontSize, idx, font.HintingFull)
+
+	contours := make([][]backendbase.Vec, 0, len(gb.Ends))
+
+	from := 0
+	for _, to := range gb.Ends {
+		ps := gb.Points[from:to]
+
+		start := ps[0]
+		others := []truetype.Point(nil)
+		if ps[0].Flags&0x01 != 0 {
+			others = ps[1:]
+		} else {
+			last := ps[len(ps)-1]
+			if last.Flags&0x01 != 0 {
+				start = last
+				others = ps[:len(ps)-1]
+			} else {
+				start = truetype.Point{
+					X: (start.X + last.X) / 2,
+					Y: (start.Y + last.Y) / 2,
+				}
+				others = ps
+			}
+		}
+
+		p0, on0 := start, true
+		path := &Path2D{cv: cv, p: make([]pathPoint, 0, 50), standalone: true, noSelfIntersection: true}
+		path.MoveTo(float64(p0.X)*scale, -float64(p0.Y)*scale)
+		for _, p := range others {
+			on := p.Flags&0x01 != 0
+			if on {
+				if on0 {
+					path.LineTo(float64(p.X)*scale, -float64(p.Y)*scale)
+				} else {
+					path.QuadraticCurveTo(float64(p0.X)*scale, -float64(p0.Y)*scale, float64(p.X)*scale, -float64(p.Y)*scale)
+				}
+			} else {
+				if on0 {
+					// No-op.
+				} else {
+					mid := fixed.Point26_6{
+						X: (p0.X + p.X) / 2,
+						Y: (p0.Y + p.Y) / 2,
+					}
+					path.QuadraticCurveTo(float64(p0.X)*scale, -float64(p0.Y)*scale, float64(mid.X)*scale, -float64(mid.Y)*scale)
+				}
+			}
+			p0, on0 = p, on
+		}
+
+		if on0 {
+			path.LineTo(float64(start.X)*scale, -float64(start.Y)*scale)
+		} else {
+			path.QuadraticCurveTo(float64(p0.X)*scale, -float64(p0.Y)*scale, float64(start.X)*scale, -float64(start.Y)*scale)
+		}
+		path.ClosePath()
+
+		contour := make([]backendbase.Vec, len(path.p))
+		for i, pt := range path.p {
+			contour[i] = pt.pos
+		}
+
+		contours = append(contours, contour)
+
+		from = to
+	}
+
+	idxs := sortFontContours(contours)
+	sortedContours := make([][]backendbase.Vec, 0, len(idxs))
+	trisList := make([][]backendbase.Vec, 0, len(contours))
+
+	for i := 0; i < len(idxs); {
+		var j int
+		for j = i; j < len(idxs); j++ {
+			if idxs[j] == -1 {
+				break
+			}
+		}
+
+		sortedContours = sortedContours[:j-i]
+		for k, idx := range idxs[i:j] {
+			sortedContours[k] = contours[idx]
+		}
+
+		var ec earcut
+		ec.run(sortedContours)
+
+		tris := make([]backendbase.Vec, len(ec.indices))
+		for i, idx := range ec.indices {
+			pidx := 0
+			poly := sortedContours[pidx]
+			for idx >= len(poly) {
+				idx -= len(poly)
+				pidx++
+				poly = sortedContours[pidx]
+			}
+			tris[i] = poly[idx]
+		}
+		trisList = append(trisList, tris)
+
+		i = j + 1
+	}
+
+	count := 0
+	for _, tris := range trisList {
+		count += len(tris)
+	}
+
+	allTris := make([]backendbase.Vec, count)
+	pos := 0
+	for _, tris := range trisList {
+		copy(allTris[pos:], tris)
+		pos += len(tris)
+	}
+
+	cache, ok := cv.fontTriCache[cv.state.font]
+	if !ok {
+		cache = &fontTriCache{cache: make(map[truetype.Index][]backendbase.Vec, 1024)}
+		cv.fontTriCache[cv.state.font] = cache
+	}
+	cache.lastUsed = time.Now()
+	cache.cache[idx] = allTris
+
+	return allTris
+}
+
 // TextMetrics is the result of a MeasureText call
 type TextMetrics struct {
 	Width                    float64