mstar/canvas
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

made DrawStyle public for use by backends; changed color to be color.RGBA

Browse source
This commit is contained in:
Thomas Friedel 2019-02-14 12:38:27 +01:00
parent 1e5180dd65
commit 7dbcd9b420
10 changed files with 132 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

0
backend/goglbackend/gogl.go → backend/gogl/gogl.go
View file

0
backend/goglbackend/rects.go → backend/gogl/rects.go
View file

0
backend/goglbackend/shader.go → backend/gogl/shader.go
View file

0
backend/goglbackend/shaders.go → backend/gogl/shaders.go
View file

63
canvas.go
View file

@ -4,6 +4,7 @@ package canvas
import ( import (
"fmt" "fmt"
"image/color"
"os" "os"
"github.com/golang/freetype/truetype" "github.com/golang/freetype/truetype"
@ -35,8 +36,8 @@ type Canvas struct {
type drawState struct { type drawState struct {
transform mat transform mat
fill drawStyle fill DrawStyle
stroke drawStyle stroke DrawStyle
font *Font font *Font
fontSize float64 fontSize float64
fontMetrics font.Metrics fontMetrics font.Metrics
@ -72,11 +73,11 @@ type drawState struct {
*/ */
} }
type drawStyle struct { type DrawStyle struct {
color glColor Color color.RGBA
radialGradient *RadialGradient RadialGradient *RadialGradient
linearGradient *LinearGradient LinearGradient *LinearGradient
image *Image Image *Image
} }
type scissor struct { type scissor struct {
@ -146,8 +147,8 @@ func New(backend Backend, x, y, w, h int) *Canvas {
cv.state.lineAlpha = 1 cv.state.lineAlpha = 1
cv.state.miterLimitSqr = 100 cv.state.miterLimitSqr = 100
cv.state.globalAlpha = 1 cv.state.globalAlpha = 1
cv.state.fill.color = glColor{a: 1} cv.state.fill.Color = color.RGBA{A: 255}
cv.state.stroke.color = glColor{a: 1} cv.state.stroke.Color = color.RGBA{A: 255}
cv.state.transform = matIdentity() cv.state.transform = matIdentity()
return cv return cv
} }
@ -454,45 +455,45 @@ func (cv *Canvas) SetStrokeStyle(value ...interface{}) {
cv.state.stroke = parseStyle(value...) cv.state.stroke = parseStyle(value...)
} }
func parseStyle(value ...interface{}) drawStyle { func parseStyle(value ...interface{}) DrawStyle {
var style drawStyle var style DrawStyle
if len(value) == 1 { if len(value) == 1 {
switch v := value[0].(type) { switch v := value[0].(type) {
case *LinearGradient: case *LinearGradient:
style.linearGradient = v style.LinearGradient = v
return style return style
case *RadialGradient: case *RadialGradient:
style.radialGradient = v style.RadialGradient = v
return style return style
} }
} }
c, ok := parseColor(value...) c, ok := parseColor(value...)
if ok { if ok {
style.color = c style.Color = c
} else if len(value) == 1 { } else if len(value) == 1 {
switch v := value[0].(type) { switch v := value[0].(type) {
case *Image, string: case *Image, string:
style.image = getImage(v) style.Image = getImage(v)
} }
} }
return style return style
} }
func (s *drawStyle) isOpaque() bool { func (s *DrawStyle) isOpaque() bool {
if lg := s.linearGradient; lg != nil { if lg := s.LinearGradient; lg != nil {
return lg.opaque return lg.opaque
} }
if rg := s.radialGradient; rg != nil { if rg := s.RadialGradient; rg != nil {
return rg.opaque return rg.opaque
} }
if img := s.image; img != nil { if img := s.Image; img != nil {
return img.opaque return img.opaque
} }
return s.color.a >= 1 return s.Color.A >= 255
} }
func (cv *Canvas) useShader(style *drawStyle) (vertexLoc uint32) { func (cv *Canvas) useShader(style *DrawStyle) (vertexLoc uint32) {
if lg := style.linearGradient; lg != nil { if lg := style.LinearGradient; lg != nil {
lg.load() lg.load()
gli.ActiveTexture(gl_TEXTURE0) gli.ActiveTexture(gl_TEXTURE0)
gli.BindTexture(gl_TEXTURE_2D, lg.tex) gli.BindTexture(gl_TEXTURE_2D, lg.tex)
@ -510,7 +511,7 @@ func (cv *Canvas) useShader(style *drawStyle) (vertexLoc uint32) {
gli.Uniform1f(lgr.globalAlpha, float32(cv.state.globalAlpha)) gli.Uniform1f(lgr.globalAlpha, float32(cv.state.globalAlpha))
return lgr.vertex return lgr.vertex
} }
if rg := style.radialGradient; rg != nil { if rg := style.RadialGradient; rg != nil {
rg.load() rg.load()
gli.ActiveTexture(gl_TEXTURE0) gli.ActiveTexture(gl_TEXTURE0)
gli.BindTexture(gl_TEXTURE_2D, rg.tex) gli.BindTexture(gl_TEXTURE_2D, rg.tex)
@ -531,7 +532,7 @@ func (cv *Canvas) useShader(style *drawStyle) (vertexLoc uint32) {
gli.Uniform1f(rgr.globalAlpha, float32(cv.state.globalAlpha)) gli.Uniform1f(rgr.globalAlpha, float32(cv.state.globalAlpha))
return rgr.vertex return rgr.vertex
} }
if img := style.image; img != nil { if img := style.Image; img != nil {
gli.UseProgram(ipr.id) gli.UseProgram(ipr.id)
gli.ActiveTexture(gl_TEXTURE0) gli.ActiveTexture(gl_TEXTURE0)
gli.BindTexture(gl_TEXTURE_2D, img.tex) gli.BindTexture(gl_TEXTURE_2D, img.tex)
@ -544,14 +545,14 @@ func (cv *Canvas) useShader(style *drawStyle) (vertexLoc uint32) {
gli.UseProgram(sr.id) gli.UseProgram(sr.id)
gli.Uniform2f(sr.canvasSize, float32(cv.fw), float32(cv.fh)) gli.Uniform2f(sr.canvasSize, float32(cv.fw), float32(cv.fh))
c := style.color c := colorGoToGL(style.Color)
gli.Uniform4f(sr.color, float32(c.r), float32(c.g), float32(c.b), float32(c.a)) gli.Uniform4f(sr.color, float32(c.r), float32(c.g), float32(c.b), float32(c.a))
gli.Uniform1f(sr.globalAlpha, float32(cv.state.globalAlpha)) gli.Uniform1f(sr.globalAlpha, float32(cv.state.globalAlpha))
return sr.vertex return sr.vertex
} }
func (cv *Canvas) useAlphaShader(style *drawStyle, alphaTexSlot int32) (vertexLoc, alphaTexCoordLoc uint32) { func (cv *Canvas) useAlphaShader(style *DrawStyle, alphaTexSlot int32) (vertexLoc, alphaTexCoordLoc uint32) {
if lg := style.linearGradient; lg != nil { if lg := style.LinearGradient; lg != nil {
lg.load() lg.load()
gli.ActiveTexture(gl_TEXTURE0) gli.ActiveTexture(gl_TEXTURE0)
gli.BindTexture(gl_TEXTURE_2D, lg.tex) gli.BindTexture(gl_TEXTURE_2D, lg.tex)
@ -570,7 +571,7 @@ func (cv *Canvas) useAlphaShader(style *drawStyle, alphaTexSlot int32) (vertexLo
gli.Uniform1f(lgar.globalAlpha, float32(cv.state.globalAlpha)) gli.Uniform1f(lgar.globalAlpha, float32(cv.state.globalAlpha))
return lgar.vertex, lgar.alphaTexCoord return lgar.vertex, lgar.alphaTexCoord
} }
if rg := style.radialGradient; rg != nil { if rg := style.RadialGradient; rg != nil {
rg.load() rg.load()
gli.ActiveTexture(gl_TEXTURE0) gli.ActiveTexture(gl_TEXTURE0)
gli.BindTexture(gl_TEXTURE_2D, rg.tex) gli.BindTexture(gl_TEXTURE_2D, rg.tex)
@ -592,7 +593,7 @@ func (cv *Canvas) useAlphaShader(style *drawStyle, alphaTexSlot int32) (vertexLo
gli.Uniform1f(rgar.globalAlpha, float32(cv.state.globalAlpha)) gli.Uniform1f(rgar.globalAlpha, float32(cv.state.globalAlpha))
return rgar.vertex, rgar.alphaTexCoord return rgar.vertex, rgar.alphaTexCoord
} }
if img := style.image; img != nil { if img := style.Image; img != nil {
gli.UseProgram(ipar.id) gli.UseProgram(ipar.id)
gli.ActiveTexture(gl_TEXTURE0) gli.ActiveTexture(gl_TEXTURE0)
gli.BindTexture(gl_TEXTURE_2D, img.tex) gli.BindTexture(gl_TEXTURE_2D, img.tex)
@ -606,7 +607,7 @@ func (cv *Canvas) useAlphaShader(style *drawStyle, alphaTexSlot int32) (vertexLo
gli.UseProgram(sar.id) gli.UseProgram(sar.id)
gli.Uniform2f(sar.canvasSize, float32(cv.fw), float32(cv.fh)) gli.Uniform2f(sar.canvasSize, float32(cv.fw), float32(cv.fh))
c := style.color c := colorGoToGL(style.Color)
gli.Uniform4f(sar.color, float32(c.r), float32(c.g), float32(c.b), float32(c.a)) gli.Uniform4f(sar.color, float32(c.r), float32(c.g), float32(c.b), float32(c.a))
gli.Uniform1i(sar.alphaTex, alphaTexSlot) gli.Uniform1i(sar.alphaTex, alphaTexSlot)
gli.Uniform1f(sar.globalAlpha, float32(cv.state.globalAlpha)) gli.Uniform1f(sar.globalAlpha, float32(cv.state.globalAlpha))
@ -834,7 +835,7 @@ func (cv *Canvas) SetTransform(a, b, c, d, e, f float64) {
// then no shadow is drawn // then no shadow is drawn
func (cv *Canvas) SetShadowColor(color ...interface{}) { func (cv *Canvas) SetShadowColor(color ...interface{}) {
if c, ok := parseColor(color...); ok { if c, ok := parseColor(color...); ok {
cv.state.shadowColor = c cv.state.shadowColor = colorGoToGL(c)
} }
} }

29
canvas_test.go
View file

@ -2,6 +2,7 @@ package canvas_test
import ( import (
"fmt" "fmt"
"image"
"image/png" "image/png"
"math" "math"
"os" "os"
@ -23,7 +24,7 @@ func run(t *testing.T, fn func(cv *canvas.Canvas)) {
} }
defer wnd.Destroy() defer wnd.Destroy()
cv := canvas.NewOffscreen(100, 100, false) cv := canvas.NewOffscreen(wnd.Backend, 100, 100, false)
gl.Disable(gl.MULTISAMPLE) gl.Disable(gl.MULTISAMPLE)
@ -58,15 +59,9 @@ func run(t *testing.T, fn func(cv *canvas.Canvas)) {
} }
if os.IsNotExist(err) { if os.IsNotExist(err) {
f, err := os.OpenFile(fileName, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0777) err = writeImage(img, fileName)
if err != nil { if err != nil {
t.Fatalf("Failed to create file \"%s\"", fileName) t.Fatal(err)
}
defer f.Close()
err = png.Encode(f, img)
if err != nil {
t.Fatalf("Failed to encode PNG")
} }
return return
} }
@ -95,15 +90,31 @@ func run(t *testing.T, fn func(cv *canvas.Canvas)) {
r2, g2, b2, a2 := img2.At(x, y).RGBA() r2, g2, b2, a2 := img2.At(x, y).RGBA()
r3, g3, b3, a3 := refImg.At(x, y).RGBA() r3, g3, b3, a3 := refImg.At(x, y).RGBA()
if r1 != r3 || g1 != g3 || b1 != b3 || a1 != a3 { if r1 != r3 || g1 != g3 || b1 != b3 || a1 != a3 {
writeImage(img, fmt.Sprintf("testdata/%s_fail.png", callerFuncName))
t.FailNow() t.FailNow()
} }
if r2 != r3 || g2 != g3 || b2 != b3 || a2 != a3 { if r2 != r3 || g2 != g3 || b2 != b3 || a2 != a3 {
writeImage(img2, fmt.Sprintf("testdata/%s_fail.png", callerFuncName))
t.FailNow() 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) { func TestFillRect(t *testing.T) {
run(t, func(cv *canvas.Canvas) { run(t, func(cv *canvas.Canvas) {
cv.SetFillStyle("#F00") cv.SetFillStyle("#F00")

94
color.go
View file

@ -3,6 +3,7 @@ package canvas
import ( import (
"fmt" "fmt"
"image/color" "image/color"
"math"
"strconv" "strconv"
"strings" "strings"
) )
@ -21,7 +22,7 @@ func colorGoToGL(color color.Color) glColor {
return c return c
} }
func colorGLToGo(c glColor) color.Color { func colorGLToGo(c glColor) color.RGBA {
if c.r < 0 { if c.r < 0 {
c.r = 0 c.r = 0
} else if c.r > 1 { } else if c.r > 1 {
@ -74,18 +75,18 @@ func parseHexRunePair(rn1, rn2 rune) (int, bool) {
return i1*16 + i2, true return i1*16 + i2, true
} }
func parseColorComponent(value interface{}) (float64, bool) { func parseColorComponent(value interface{}) (uint8, bool) {
switch v := value.(type) { switch v := value.(type) {
case float32: case float32:
return float64(v), true return uint8(math.Floor(float64(v) * 255)), true
case float64: case float64:
return v, true return uint8(math.Floor(v * 255)), true
case int: case int:
return float64(v) / 255, true return uint8(v), true
case uint: case uint:
return float64(v) / 255, true return uint8(v), true
case uint8: case uint8:
return float64(v) / 255, true return v, true
case string: case string:
if len(v) == 0 { if len(v) == 0 {
return 0, false return 0, false
@ -99,7 +100,7 @@ func parseColorComponent(value interface{}) (float64, bool) {
if err != nil { if err != nil {
return 0, false return 0, false
} }
return float64(conv) / 255, true return uint8(conv), true
} else if strings.ContainsRune(v, '.') { } else if strings.ContainsRune(v, '.') {
conv, err := strconv.ParseFloat(v, 32) conv, err := strconv.ParseFloat(v, 32)
if err != nil { if err != nil {
@ -110,45 +111,78 @@ func parseColorComponent(value interface{}) (float64, bool) {
} else if conv > 1 { } else if conv > 1 {
conv = 1 conv = 1
} }
return float64(conv), true return uint8(conv), true
} else { } else {
conv, err := strconv.ParseUint(v, 10, 8) conv, err := strconv.ParseUint(v, 10, 8)
if err != nil { if err != nil {
return 0, false return 0, false
} }
return float64(conv) / 255, true return uint8(conv), true
} }
} }
return 0, false return 0, false
} }
func parseColor(value ...interface{}) (c glColor, ok bool) { func parseColor(value ...interface{}) (c color.RGBA, ok bool) {
if len(value) == 1 { if len(value) == 1 {
switch v := value[0].(type) { switch v := value[0].(type) {
case color.Color: case color.Color:
c = colorGoToGL(v) r, g, b, a := v.RGBA()
c = color.RGBA{R: uint8(r >> 8), G: uint8(g >> 8), B: uint8(b >> 8), A: uint8(a >> 8)}
ok = true ok = true
return return
case [3]float32: case [3]float32:
return glColor{r: float64(v[0]), g: float64(v[1]), b: float64(v[2]), a: 1}, true return color.RGBA{
R: uint8(math.Floor(float64(v[0] * 255))),
G: uint8(math.Floor(float64(v[1] * 255))),
B: uint8(math.Floor(float64(v[2] * 255))),
A: 255}, true
case [4]float32: case [4]float32:
return glColor{r: float64(v[0]), g: float64(v[1]), b: float64(v[2]), a: float64(v[3])}, true return color.RGBA{
R: uint8(math.Floor(float64(v[0] * 255))),
G: uint8(math.Floor(float64(v[1] * 255))),
B: uint8(math.Floor(float64(v[2] * 255))),
A: uint8(math.Floor(float64(v[3] * 255)))}, true
case [3]float64: case [3]float64:
return glColor{r: v[0], g: v[1], b: v[2], a: 1}, true return color.RGBA{
R: uint8(math.Floor(v[0] * 255)),
G: uint8(math.Floor(v[1] * 255)),
B: uint8(math.Floor(v[2] * 255)),
A: 255}, true
case [4]float64: case [4]float64:
return glColor{r: v[0], g: v[1], b: v[2], a: v[3]}, true return color.RGBA{
R: uint8(math.Floor(v[0] * 255)),
G: uint8(math.Floor(v[1] * 255)),
B: uint8(math.Floor(v[2] * 255)),
A: uint8(math.Floor(v[3] * 255))}, true
case [3]int: case [3]int:
return glColor{r: float64(v[0]) / 255, g: float64(v[1]) / 255, b: float64(v[2]) / 255, a: 1}, true return color.RGBA{
R: uint8(v[0]),
G: uint8(v[1]),
B: uint8(v[2]),
A: 255}, true
case [4]int: case [4]int:
return glColor{r: float64(v[0]) / 255, g: float64(v[1]) / 255, b: float64(v[2]) / 255, a: float64(v[3]) / 255}, true return color.RGBA{
R: uint8(v[0]),
G: uint8(v[1]),
B: uint8(v[2]),
A: uint8(v[3])}, true
case [3]uint: case [3]uint:
return glColor{r: float64(v[0]) / 255, g: float64(v[1]) / 255, b: float64(v[2]) / 255, a: 1}, true return color.RGBA{
R: uint8(v[0]),
G: uint8(v[1]),
B: uint8(v[2]),
A: 255}, true
case [4]uint: case [4]uint:
return glColor{r: float64(v[0]) / 255, g: float64(v[1]) / 255, b: float64(v[2]) / 255, a: float64(v[3]) / 255}, true return color.RGBA{
R: uint8(v[0]),
G: uint8(v[1]),
B: uint8(v[2]),
A: uint8(v[3])}, true
case [3]uint8: case [3]uint8:
return glColor{r: float64(v[0]) / 255, g: float64(v[1]) / 255, b: float64(v[2]) / 255, a: 1}, true return color.RGBA{R: v[0], G: v[1], B: v[2], A: 255}, true
case [4]uint8: case [4]uint8:
return glColor{r: float64(v[0]) / 255, g: float64(v[1]) / 255, b: float64(v[2]) / 255, a: float64(v[3]) / 255}, true return color.RGBA{R: v[0], G: v[1], B: v[2], A: v[3]}, true
case string: case string:
if len(v) == 0 { if len(v) == 0 {
return return
@ -180,7 +214,7 @@ func parseColor(value ...interface{}) (c glColor, ok bool) {
} }
ia = ia*16 + ia ia = ia*16 + ia
} }
return glColor{r: float64(ir) / 255, g: float64(ig) / 255, b: float64(ib) / 255, a: float64(ia) / 255}, true return color.RGBA{R: uint8(ir), G: uint8(ig), B: uint8(ib), A: uint8(ia)}, true
} else if len(str) == 6 || len(str) == 8 { } else if len(str) == 6 || len(str) == 8 {
var ir, ig, ib int var ir, ig, ib int
ia := 255 ia := 255
@ -202,7 +236,7 @@ func parseColor(value ...interface{}) (c glColor, ok bool) {
return return
} }
} }
return glColor{r: float64(ir) / 255, g: float64(ig) / 255, b: float64(ib) / 255, a: float64(ia) / 255}, true return color.RGBA{R: uint8(ir), G: uint8(ig), B: uint8(ib), A: uint8(ia)}, true
} else { } else {
return return
} }
@ -211,16 +245,16 @@ func parseColor(value ...interface{}) (c glColor, ok bool) {
var ir, ig, ib, ia int var ir, ig, ib, ia int
n, err := fmt.Sscanf(v, "rgb(%d,%d,%d)", &ir, &ig, &ib) n, err := fmt.Sscanf(v, "rgb(%d,%d,%d)", &ir, &ig, &ib)
if err == nil && n == 3 { if err == nil && n == 3 {
return glColor{r: float64(ir) / 255, g: float64(ig) / 255, b: float64(ib) / 255, a: 1}, true 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) n, err = fmt.Sscanf(v, "rgba(%d,%d,%d,%d)", &ir, &ig, &ib, &ia)
if err == nil && n == 4 { if err == nil && n == 4 {
return glColor{r: float64(ir) / 255, g: float64(ig) / 255, b: float64(ib) / 255, a: float64(ia) / 255}, true return color.RGBA{R: uint8(ir), G: uint8(ig), B: uint8(ib), A: uint8(ia)}, true
} }
} }
} }
} else if len(value) == 3 || len(value) == 4 { } else if len(value) == 3 || len(value) == 4 {
var pr, pg, pb, pa float64 var pr, pg, pb, pa uint8
pr, ok = parseColorComponent(value[0]) pr, ok = parseColorComponent(value[0])
if !ok { if !ok {
return return
@ -239,10 +273,10 @@ func parseColor(value ...interface{}) (c glColor, ok bool) {
return return
} }
} else { } else {
pa = 1 pa = 255
} }
return glColor{r: pr, g: pg, b: pb, a: pa}, true return color.RGBA{R: pr, G: pg, B: pb, A: pa}, true
} }
return glColor{r: 0, g: 0, b: 0, a: 1}, false return color.RGBA{A: 255}, false
} }

3
gradients.go
View file

@ -143,7 +143,8 @@ func (g *gradient) colorAt(pos float64) glColor {
// don't have to be added in order, they are sorted into the // don't have to be added in order, they are sorted into the
// right place // right place
func (g *gradient) AddColorStop(pos float64, color ...interface{}) { func (g *gradient) AddColorStop(pos float64, color ...interface{}) {
c, _ := parseColor(color...) gc, _ := parseColor(color...)
c := colorGoToGL(gc)
if c.a < 1 { if c.a < 1 {
g.opaque = false g.opaque = false
} }

11
sdlcanvas/sdlcanvas.go
View file

@ -5,12 +5,14 @@ import (
_ "image/gif" // Imported here so that applications based on this package support these formats by default _ "image/gif" // Imported here so that applications based on this package support these formats by default
_ "image/jpeg" _ "image/jpeg"
_ "image/png" _ "image/png"
"log"
"runtime" "runtime"
"time" "time"
"unicode/utf8" "unicode/utf8"
"github.com/go-gl/gl/v3.2-core/gl" "github.com/go-gl/gl/v3.2-core/gl"
"github.com/tfriedel6/canvas" "github.com/tfriedel6/canvas"
"github.com/tfriedel6/canvas/backend/gogl"
"github.com/tfriedel6/canvas/glimpl/gogl" "github.com/tfriedel6/canvas/glimpl/gogl"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
) )
@ -21,6 +23,7 @@ type Window struct {
Window *sdl.Window Window *sdl.Window
WindowID uint32 WindowID uint32
GLContext sdl.GLContext GLContext sdl.GLContext
Backend canvas.Backend
canvas *canvas.Canvas canvas *canvas.Canvas
frameTimes [10]time.Time frameTimes [10]time.Time
frameIndex int frameIndex int
@ -86,6 +89,11 @@ func CreateWindow(w, h int, title string) (*Window, *canvas.Canvas, error) {
return nil, nil, fmt.Errorf("Error initializing GL: %v", err) return nil, nil, fmt.Errorf("Error initializing GL: %v", err)
} }
backend, err := goglbackend.New(0, 0, 1280, 720)
if err != nil {
log.Fatalf("Error loading GoGL backend: %v", err)
}
sdl.GLSetSwapInterval(1) sdl.GLSetSwapInterval(1)
gl.Enable(gl.MULTISAMPLE) gl.Enable(gl.MULTISAMPLE)
@ -94,11 +102,12 @@ func CreateWindow(w, h int, title string) (*Window, *canvas.Canvas, error) {
return nil, nil, fmt.Errorf("Error loading canvas GL assets: %v", err) return nil, nil, fmt.Errorf("Error loading canvas GL assets: %v", err)
} }
cv := canvas.New(0, 0, w, h) cv := canvas.New(backend, 0, 0, w, h)
wnd := &Window{ wnd := &Window{
Window: window, Window: window,
WindowID: windowID, WindowID: windowID,
GLContext: glContext, GLContext: glContext,
Backend: backend,
canvas: cv, canvas: cv,
events: make([]sdl.Event, 0, 100), events: make([]sdl.Event, 0, 100),
} }

8
shadows.go
View file

@ -47,8 +47,8 @@ func (cv *Canvas) drawShadow(tris []float32) {
gli.StencilFunc(gl_EQUAL, 1, 0xFF) gli.StencilFunc(gl_EQUAL, 1, 0xFF)
var style drawStyle var style DrawStyle
style.color = cv.state.shadowColor style.Color = colorGLToGo(cv.state.shadowColor)
vertex := cv.useShader(&style) vertex := cv.useShader(&style)
gli.EnableVertexAttribArray(vertex) gli.EnableVertexAttribArray(vertex)
@ -82,8 +82,8 @@ func (cv *Canvas) drawTextShadow(offset image.Point, strWidth, strHeight int, x,
gli.BindBuffer(gl_ARRAY_BUFFER, buf) gli.BindBuffer(gl_ARRAY_BUFFER, buf)
var style drawStyle var style DrawStyle
style.color = cv.state.shadowColor style.Color = colorGLToGo(cv.state.shadowColor)
vertex, alphaTexCoord := cv.useAlphaShader(&style, 1) vertex, alphaTexCoord := cv.useAlphaShader(&style, 1)