canvas/canvas.go

// Package canvas provides an API that tries to closely mirror that
// of the HTML5 canvas API, using OpenGL to do the rendering.
package canvas

import (
	"fmt"
	"image/color"
	"os"

	"github.com/golang/freetype/truetype"
	"github.com/tfriedel6/canvas/backend/backendbase"
	"golang.org/x/image/font"
)

//go:generate go run make_shaders.go
//go:generate go fmt

// Canvas represents an area on the viewport on which to draw
// using a set of functions very similar to the HTML5 canvas
type Canvas struct {
	b backendbase.Backend

	x, y, w, h     int
	fx, fy, fw, fh float64

	path   Path2D
	convex bool
	rect   bool

	state      drawState
	stateStack []drawState

	offscreen bool
	offscrBuf offscreenBuffer
	offscrImg Image

	images map[interface{}]*Image

	shadowBuf [][2]float64
}

type drawState struct {
	transform     mat
	fill          drawStyle
	stroke        drawStyle
	font          *Font
	fontSize      float64
	fontMetrics   font.Metrics
	textAlign     textAlign
	textBaseline  textBaseline
	lineAlpha     float64
	lineWidth     float64
	lineJoin      lineJoin
	lineCap       lineCap
	miterLimitSqr float64
	globalAlpha   float64

	lineDash       []float64
	lineDashPoint  int
	lineDashOffset float64

	scissor scissor
	clip    Path2D

	shadowColor   color.RGBA
	shadowOffsetX float64
	shadowOffsetY float64
	shadowBlur    float64

	/*
		The current transformation matrix.
		The current clipping region.
		The current dash list.
		The current values of the following attributes: strokeStyle, fillStyle, globalAlpha,
			lineWidth, lineCap, lineJoin, miterLimit, lineDashOffset, shadowOffsetX,
			shadowOffsetY, shadowBlur, shadowColor, globalCompositeOperation, font,
			textAlign, textBaseline, direction, imageSmoothingEnabled
	*/
}

type drawStyle struct {
	color          color.RGBA
	radialGradient *RadialGradient
	linearGradient *LinearGradient
	image          *Image
}

type scissor struct {
	on     bool
	tl, br vec
}

type lineJoin uint8
type lineCap uint8

// Line join and end constants for SetLineJoin and SetLineCap
const (
	Miter = iota
	Bevel
	Round
	Square
	Butt
)

type textAlign uint8

// Text alignment constants for SetTextAlign
const (
	Left = iota
	Center
	Right
	Start
	End
)

type textBaseline uint8

// Text baseline constants for SetTextBaseline
const (
	Alphabetic = iota
	Top
	Hanging
	Middle
	Ideographic
	Bottom
)

// Performance is a nonstandard setting to improve the
// performance of the rendering in some circumstances.
// Disabling self intersections will lead to incorrect
// rendering of self intersecting polygons, but will
// yield better performance when not using the polygons
// are not self intersecting. Assuming convex polygons
// will break concave polygons, but improve performance
// even further
var Performance = struct {
	IgnoreSelfIntersections bool
	AssumeConvex            bool
}{}

// New creates a new canvas with the given viewport coordinates.
// While all functions on the canvas use the top left point as
// the origin, since GL uses the bottom left coordinate, the
// coordinates given here also use the bottom left as origin
func New(backend backendbase.Backend, x, y, w, h int) *Canvas {
	if gli == nil {
		panic("LoadGL must be called before a canvas can be created")
	}
	cv := &Canvas{
		b:          backend,
		stateStack: make([]drawState, 0, 20),
		images:     make(map[interface{}]*Image),
	}
	cv.SetBounds(x, y, w, h)
	cv.state.lineWidth = 1
	cv.state.lineAlpha = 1
	cv.state.miterLimitSqr = 100
	cv.state.globalAlpha = 1
	cv.state.fill.color = color.RGBA{A: 255}
	cv.state.stroke.color = color.RGBA{A: 255}
	cv.state.transform = matIdentity()
	return cv
}

// NewOffscreen creates a new canvas with the given size. It
// does not render directly to the screen but renders to a
// texture instead. If alpha is set to true, the offscreen
// canvas will have an alpha channel
func NewOffscreen(backend backendbase.Backend, w, h int, alpha bool) *Canvas {
	cv := New(backend, 0, 0, w, h)
	cv.offscreen = true
	cv.offscrBuf.alpha = alpha
	return cv
}

func DeleteOffscreen(cv *Canvas) {
	if !cv.offscreen {
		return
	}
	gli.DeleteTextures(1, &cv.offscrBuf.tex)
	gli.DeleteFramebuffers(1, &cv.offscrBuf.frameBuf)
	gli.DeleteRenderbuffers(1, &cv.offscrBuf.renderStencilBuf)
}

// SetBounds updates the bounds of the canvas. This would
// usually be called for example when the window is resized
func (cv *Canvas) SetBounds(x, y, w, h int) {
	if !cv.offscreen {
		cv.x, cv.y = x, y
		cv.fx, cv.fy = float64(x), float64(y)
	}
	cv.w, cv.h = w, h
	cv.fw, cv.fh = float64(w), float64(h)
	activeCanvas = nil
}

// Width returns the internal width of the canvas
func (cv *Canvas) Width() int { return cv.w }

// Height returns the internal height of the canvas
func (cv *Canvas) Height() int { return cv.h }

// Size returns the internal width and height of the canvas
func (cv *Canvas) Size() (int, int) { return cv.w, cv.h }

func (cv *Canvas) tf(v vec) vec {
	v, _ = v.mulMat(cv.state.transform)
	return v
}

// Activate makes the canvas active and sets the viewport. Only needs
// to be called if any other GL code changes the viewport
func (cv *Canvas) Activate() {
	if cv.offscreen {
		gli.Viewport(0, 0, int32(cv.w), int32(cv.h))
		cv.enableTextureRenderTarget(&cv.offscrBuf)
		// cv.offscrImg.w = cv.offscrBuf.w
		// cv.offscrImg.h = cv.offscrBuf.h
		// cv.offscrImg.tex = cv.offscrBuf.tex
	} else {
		gli.Viewport(int32(cv.x), int32(cv.y), int32(cv.w), int32(cv.h))
		cv.disableTextureRenderTarget()
	}
	cv.applyScissor()
	gli.Clear(gl_STENCIL_BUFFER_BIT)
}

var activeCanvas *Canvas

func (cv *Canvas) activate() {
	if activeCanvas != cv {
		activeCanvas = cv
		cv.Activate()
	}
loop:
	for {
		select {
		case f := <-glChan:
			f()
		default:
			break loop
		}
	}
}

const alphaTexSize = 2048

var (
	gli       GL
	buf       uint32
	shadowBuf uint32
	alphaTex  uint32
	sr        *solidShader
	lgr       *linearGradientShader
	rgr       *radialGradientShader
	ipr       *imagePatternShader
	sar       *solidAlphaShader
	rgar      *radialGradientAlphaShader
	lgar      *linearGradientAlphaShader
	ipar      *imagePatternAlphaShader
	ir        *imageShader
	gauss15r  *gaussianShader
	gauss63r  *gaussianShader
	gauss127r *gaussianShader
	offscr1   offscreenBuffer
	offscr2   offscreenBuffer
	glChan    = make(chan func())
)

type offscreenBuffer struct {
	tex              uint32
	w                int
	h                int
	renderStencilBuf uint32
	frameBuf         uint32
	alpha            bool
}

type gaussianShader struct {
	id          uint32
	vertex      uint32
	texCoord    uint32
	canvasSize  int32
	kernelScale int32
	image       int32
	kernel      int32
}

// LoadGL needs to be called once per GL context to load the GL assets
// that canvas needs. The parameter is an implementation of the GL interface
// in this package that should make this package neutral to GL implementations.
// The goglimpl subpackage contains an implementation based on Go-GL v3.2
func LoadGL(glimpl GL) (err error) {
	gli = glimpl

	gli.GetError() // clear error state

	sr, err = loadSolidShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	lgr, err = loadLinearGradientShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	rgr, err = loadRadialGradientShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	ipr, err = loadImagePatternShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	sar, err = loadSolidAlphaShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	lgar, err = loadLinearGradientAlphaShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	rgar, err = loadRadialGradientAlphaShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	ipar, err = loadImagePatternAlphaShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	ir, err = loadImageShader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}

	gauss15s, err := loadGaussian15Shader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}
	gauss15r = (*gaussianShader)(gauss15s)

	gauss63s, err := loadGaussian63Shader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}
	gauss63r = (*gaussianShader)(gauss63s)

	gauss127s, err := loadGaussian127Shader()
	if err != nil {
		return
	}
	err = glError()
	if err != nil {
		return
	}
	gauss127r = (*gaussianShader)(gauss127s)

	gli.GenBuffers(1, &buf)
	err = glError()
	if err != nil {
		return
	}

	gli.GenBuffers(1, &shadowBuf)
	err = glError()
	if err != nil {
		return
	}

	gli.ActiveTexture(gl_TEXTURE0)
	gli.GenTextures(1, &alphaTex)
	gli.BindTexture(gl_TEXTURE_2D, alphaTex)
	gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MIN_FILTER, gl_NEAREST)
	gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, gl_NEAREST)
	gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_S, gl_CLAMP_TO_EDGE)
	gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_T, gl_CLAMP_TO_EDGE)
	gli.TexImage2D(gl_TEXTURE_2D, 0, gl_ALPHA, alphaTexSize, alphaTexSize, 0, gl_ALPHA, gl_UNSIGNED_BYTE, nil)

	gli.Enable(gl_BLEND)
	gli.BlendFunc(gl_SRC_ALPHA, gl_ONE_MINUS_SRC_ALPHA)
	gli.Enable(gl_STENCIL_TEST)
	gli.StencilMask(0xFF)
	gli.Clear(gl_STENCIL_BUFFER_BIT)
	gli.StencilOp(gl_KEEP, gl_KEEP, gl_KEEP)
	gli.StencilFunc(gl_EQUAL, 0, 0xFF)

	gli.Enable(gl_SCISSOR_TEST)

	return
}

func glError() error {
	glErr := gli.GetError()
	if glErr != gl_NO_ERROR {
		return fmt.Errorf("GL Error: %x", glErr)
	}
	return nil
}

// SetFillStyle sets the color, gradient, or image for any fill calls. To set a
// color, there are several acceptable formats: 3 or 4 int values for RGB(A) in
// the range 0-255, 3 or 4 float values for RGB(A) in the range 0-1, hex strings
// in the format "#AABBCC", "#AABBCCDD", "#ABC", or "#ABCD"
func (cv *Canvas) SetFillStyle(value ...interface{}) {
	cv.state.fill = cv.parseStyle(value...)
}

// SetStrokeStyle sets the color, gradient, or image for any line drawing calls.
// To set a color, there are several acceptable formats: 3 or 4 int values for
// RGB(A) in the range 0-255, 3 or 4 float values for RGB(A) in the range 0-1,
// hex strings in the format "#AABBCC", "#AABBCCDD", "#ABC", or "#ABCD"
func (cv *Canvas) SetStrokeStyle(value ...interface{}) {
	cv.state.stroke = cv.parseStyle(value...)
}

func (cv *Canvas) parseStyle(value ...interface{}) drawStyle {
	var style drawStyle
	if len(value) == 1 {
		switch v := value[0].(type) {
		case *LinearGradient:
			style.linearGradient = v
			return style
		case *RadialGradient:
			style.radialGradient = v
			return style
		}
	}
	c, ok := parseColor(value...)
	if ok {
		style.color = c
	} else if len(value) == 1 {
		switch v := value[0].(type) {
		case *Image, string:
			style.image = cv.getImage(v)
		}
	}
	return style
}

func (s *drawStyle) isOpaque() bool {
	if lg := s.linearGradient; lg != nil {
		return lg.opaque
	}
	if rg := s.radialGradient; rg != nil {
		return rg.opaque
	}
	if img := s.image; img != nil {
		return img.img.IsOpaque()
	}
	return s.color.A >= 255
}

func (cv *Canvas) backendFillStyle(s *drawStyle, alpha float64) backendbase.FillStyle {
	stl := backendbase.FillStyle{Color: s.color, FillMatrix: cv.state.transform}
	alpha *= cv.state.globalAlpha
	if lg := s.linearGradient; lg != nil {
		lg.load()
		stl.LinearGradient = lg.grad
	} else if rg := s.radialGradient; rg != nil {
		rg.load()
		stl.RadialGradient = rg.grad
	} else if img := s.image; img != nil {
		stl.Image = img.img
	} else {
		alpha *= float64(s.color.A) / 255
	}
	stl.Color.A = uint8(alpha * 255)
	return stl
}

func (cv *Canvas) enableTextureRenderTarget(offscr *offscreenBuffer) {
	if offscr.w != cv.w || offscr.h != cv.h {
		if offscr.w != 0 && offscr.h != 0 {
			gli.DeleteTextures(1, &offscr.tex)
			gli.DeleteFramebuffers(1, &offscr.frameBuf)
			gli.DeleteRenderbuffers(1, &offscr.renderStencilBuf)
		}
		offscr.w = cv.w
		offscr.h = cv.h

		gli.ActiveTexture(gl_TEXTURE0)
		gli.GenTextures(1, &offscr.tex)
		gli.BindTexture(gl_TEXTURE_2D, offscr.tex)
		// todo do non-power-of-two textures work everywhere?
		if offscr.alpha {
			gli.TexImage2D(gl_TEXTURE_2D, 0, gl_RGBA, int32(cv.w), int32(cv.h), 0, gl_RGBA, gl_UNSIGNED_BYTE, nil)
		} else {
			gli.TexImage2D(gl_TEXTURE_2D, 0, gl_RGB, int32(cv.w), int32(cv.h), 0, gl_RGB, gl_UNSIGNED_BYTE, nil)
		}
		gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, gl_NEAREST)
		gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MIN_FILTER, gl_NEAREST)

		gli.GenFramebuffers(1, &offscr.frameBuf)
		gli.BindFramebuffer(gl_FRAMEBUFFER, offscr.frameBuf)

		gli.GenRenderbuffers(1, &offscr.renderStencilBuf)
		gli.BindRenderbuffer(gl_RENDERBUFFER, offscr.renderStencilBuf)
		gli.RenderbufferStorage(gl_RENDERBUFFER, gl_DEPTH24_STENCIL8, int32(cv.w), int32(cv.h))
		gli.FramebufferRenderbuffer(gl_FRAMEBUFFER, gl_DEPTH_STENCIL_ATTACHMENT, gl_RENDERBUFFER, offscr.renderStencilBuf)

		gli.FramebufferTexture(gl_FRAMEBUFFER, gl_COLOR_ATTACHMENT0, offscr.tex, 0)

		if err := gli.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))
		}

		gli.Clear(gl_COLOR_BUFFER_BIT | gl_STENCIL_BUFFER_BIT)
	} else {
		gli.BindFramebuffer(gl_FRAMEBUFFER, offscr.frameBuf)
	}
}

func (cv *Canvas) disableTextureRenderTarget() {
	if cv.offscreen {
		cv.enableTextureRenderTarget(&cv.offscrBuf)
	} else {
		gli.BindFramebuffer(gl_FRAMEBUFFER, 0)
	}
}

// SetLineWidth sets the line width for any line drawing calls
func (cv *Canvas) SetLineWidth(width float64) {
	if width < 0 {
		cv.state.lineWidth = 1
		cv.state.lineAlpha = 0
	} else if width < 1 {
		cv.state.lineWidth = 1
		cv.state.lineAlpha = width
	} else {
		cv.state.lineWidth = width
		cv.state.lineAlpha = 1
	}
}

// SetFont sets the font and font size. The font parameter can be a font loaded
// with the LoadFont function, a filename for a font to load (which will be
// cached), or nil, in which case the first loaded font will be used
func (cv *Canvas) SetFont(src interface{}, size float64) {
	if src == nil {
		cv.state.font = defaultFont
	} else {
		switch v := src.(type) {
		case *Font:
			cv.state.font = v
		case *truetype.Font:
			cv.state.font = &Font{font: v}
		case string:
			if f, ok := fonts[v]; ok {
				cv.state.font = f
			} else {
				f, err := LoadFont(v)
				if err != nil {
					fmt.Fprintf(os.Stderr, "Error loading font %s: %v\n", v, err)
					fonts[v] = nil
				} else {
					fonts[v] = f
					cv.state.font = f
				}
			}
		}
	}
	cv.state.fontSize = size

	fontFace := truetype.NewFace(cv.state.font.font, &truetype.Options{Size: size})
	cv.state.fontMetrics = fontFace.Metrics()
}

// SetTextAlign sets the text align for any text drawing calls.
// The value can be Left, Center, Right, Start, or End
func (cv *Canvas) SetTextAlign(align textAlign) {
	cv.state.textAlign = align
}

// SetTextBaseline sets the text baseline for any text drawing calls.
// The value can be Alphabetic (default), Top, Hanging, Middle,
// Ideographic, or Bottom
func (cv *Canvas) SetTextBaseline(baseline textBaseline) {
	cv.state.textBaseline = baseline
}

// SetLineJoin sets the style of line joints for rendering a path with Stroke.
// The value can be Miter, Bevel, or Round
func (cv *Canvas) SetLineJoin(join lineJoin) {
	cv.state.lineJoin = join
}

// SetLineEnd is a synonym for SetLineCap that was misnamed by mistake. Deprecated
func (cv *Canvas) SetLineEnd(cap lineCap) {
	cv.SetLineCap(cap)
}

// SetLineCap sets the style of line endings for rendering a path with Stroke
// The value can be Butt, Square, or Round
func (cv *Canvas) SetLineCap(cap lineCap) {
	cv.state.lineCap = cap
}

// SetLineDash sets the line dash style
func (cv *Canvas) SetLineDash(dash []float64) {
	l := len(dash)
	if l%2 == 0 {
		d2 := make([]float64, l)
		copy(d2, dash)
		cv.state.lineDash = d2
	} else {
		d2 := make([]float64, l*2)
		copy(d2[:l], dash)
		copy(d2[l:], dash)
		cv.state.lineDash = d2
	}
	cv.state.lineDashPoint = 0
	cv.state.lineDashOffset = 0
}

func (cv *Canvas) SetLineDashOffset(offset float64) {
	cv.state.lineDashOffset = offset
}

// GetLineDash gets the line dash style
func (cv *Canvas) GetLineDash() []float64 {
	result := make([]float64, len(cv.state.lineDash))
	copy(result, cv.state.lineDash)
	return result
}

// SetMiterLimit sets the limit for how far a miter line join can be extend.
// The fallback is a bevel join
func (cv *Canvas) SetMiterLimit(limit float64) {
	cv.state.miterLimitSqr = limit * limit
}

// SetGlobalAlpha sets the global alpha value
func (cv *Canvas) SetGlobalAlpha(alpha float64) {
	cv.state.globalAlpha = alpha
}

// Save saves the current draw state to a stack
func (cv *Canvas) Save() {
	cv.stateStack = append(cv.stateStack, cv.state)
}

// Restore restores the last draw state from the stack if available
func (cv *Canvas) Restore() {
	l := len(cv.stateStack)
	if l <= 0 {
		return
	}
	cv.state.scissor = scissor{}
	cv.applyScissor()
	gli.StencilMask(0xFF)
	gli.Clear(gl_STENCIL_BUFFER_BIT)
	for _, st := range cv.stateStack {
		if len(st.clip.p) > 0 {
			cv.clip(st.clip.p)
		}
	}
	cv.state = cv.stateStack[l-1]
	cv.stateStack = cv.stateStack[:l-1]
	cv.applyScissor()
}

// Scale updates the current transformation with a scaling by the given values
func (cv *Canvas) Scale(x, y float64) {
	cv.state.transform = matScale(vec{x, y}).mul(cv.state.transform)
}

// Translate updates the current transformation with a translation by the given values
func (cv *Canvas) Translate(x, y float64) {
	cv.state.transform = matTranslate(vec{x, y}).mul(cv.state.transform)
}

// Rotate updates the current transformation with a rotation by the given angle
func (cv *Canvas) Rotate(angle float64) {
	cv.state.transform = matRotate(angle).mul(cv.state.transform)
}

// Transform updates the current transformation with the given matrix
func (cv *Canvas) Transform(a, b, c, d, e, f float64) {
	cv.state.transform = mat{a, b, 0, c, d, 0, e, f, 1}.mul(cv.state.transform)
}

// SetTransform replaces the current transformation with the given matrix
func (cv *Canvas) SetTransform(a, b, c, d, e, f float64) {
	cv.state.transform = mat{a, b, 0, c, d, 0, e, f, 1}
}

// SetShadowColor sets the color of the shadow. If it is fully transparent (default)
// then no shadow is drawn
func (cv *Canvas) SetShadowColor(color ...interface{}) {
	if c, ok := parseColor(color...); ok {
		cv.state.shadowColor = c
	}
}

// SetShadowOffsetX sets the x offset of the shadow
func (cv *Canvas) SetShadowOffsetX(offset float64) {
	cv.state.shadowOffsetX = offset
}

// SetShadowOffsetY sets the y offset of the shadow
func (cv *Canvas) SetShadowOffsetY(offset float64) {
	cv.state.shadowOffsetY = offset
}

// SetShadowOffset sets the offset of the shadow
func (cv *Canvas) SetShadowOffset(x, y float64) {
	cv.state.shadowOffsetX = x
	cv.state.shadowOffsetY = y
}

// SetShadowBlur sets the gaussian blur radius of the shadow
// (0 for no blur)
func (cv *Canvas) SetShadowBlur(r float64) {
	cv.state.shadowBlur = r
}