package pixelgl import ( "fmt" "image/color" "math" "github.com/faiface/glhf" "github.com/faiface/mainthread" "github.com/faiface/pixel" "github.com/go-gl/mathgl/mgl32" "github.com/pkg/errors" ) // Canvas is an off-screen rectangular BasicTarget that you can draw onto. // // It supports TrianglesPosition, TrianglesColor, TrianglesPicture and PictureColor. type Canvas struct { f *glhf.Frame s *glhf.Shader smooth bool mat mgl32.Mat3 col mgl32.Vec4 pixels []uint8 dirty bool bounds pixel.Rect orig *Canvas } // NewCanvas creates a new empty, fully transparent Canvas with given bounds. If the smooth flag // set, then stretched Pictures will be smoothed and will not be drawn pixely onto this Canvas. func NewCanvas(bounds pixel.Rect, smooth bool) *Canvas { c := &Canvas{ smooth: smooth, mat: mgl32.Ident3(), col: mgl32.Vec4{1, 1, 1, 1}, } c.orig = c mainthread.Call(func() { var err error c.s, err = glhf.NewShader( canvasVertexFormat, canvasUniformFormat, canvasVertexShader, canvasFragmentShader, ) if err != nil { panic(errors.Wrap(err, "failed to create Canvas, there's a bug in the shader")) } }) c.SetBounds(bounds) return c } // MakeTriangles creates a specialized copy of the supplied Triangles that draws onto this Canvas. // // TrianglesPosition, TrianglesColor and TrianglesPicture are supported. func (c *Canvas) MakeTriangles(t pixel.Triangles) pixel.TargetTriangles { return &canvasTriangles{ GLTriangles: NewGLTriangles(c.s, t), c: c, } } // MakePicture create a specialized copy of the supplied Picture that draws onto this Canvas. // // PictureColor is supported. func (c *Canvas) MakePicture(p pixel.Picture) pixel.TargetPicture { if cp, ok := p.(*canvasPicture); ok { tp := new(canvasPicture) *tp = *cp tp.c = c return tp } bounds := p.Bounds() bx, by, bw, bh := intBounds(bounds) pixels := make([]uint8, 4*bw*bh) if p, ok := p.(pixel.PictureColor); ok { for y := 0; y < bh; y++ { for x := 0; x < bw; x++ { at := pixel.V( math.Max(float64(bx+x), bounds.Pos.X()), math.Max(float64(by+y), bounds.Pos.Y()), ) color := p.Color(at) pixels[(y*bw+x)*4+0] = uint8(color.R * 255) pixels[(y*bw+x)*4+1] = uint8(color.G * 255) pixels[(y*bw+x)*4+2] = uint8(color.B * 255) pixels[(y*bw+x)*4+3] = uint8(color.A * 255) } } } var tex *glhf.Texture mainthread.Call(func() { tex = glhf.NewTexture(bw, bh, c.smooth, pixels) }) cp := &canvasPicture{ tex: tex, borders: pixel.R( float64(bx), float64(by), float64(bw), float64(bh), ), bounds: bounds, c: c, } cp.orig = cp return cp } // SetMatrix sets a Matrix that every point will be projected by. func (c *Canvas) SetMatrix(m pixel.Matrix) { for i := range m { c.mat[i] = float32(m[i]) } } // SetColorMask sets a color that every color in triangles or a picture will be multiplied by. func (c *Canvas) SetColorMask(col color.Color) { nrgba := pixel.NRGBA{R: 1, G: 1, B: 1, A: 1} if col != nil { nrgba = pixel.NRGBAModel.Convert(col).(pixel.NRGBA) } c.col = mgl32.Vec4{ float32(nrgba.R), float32(nrgba.G), float32(nrgba.B), float32(nrgba.A), } } // SetBounds resizes the Canvas to the new bounds. Old content will be preserved. // // If this Canvas was created using Slice-ing, then the relation between this Canvas and it's // Original is unspecified (but Original will always return valid stuff). func (c *Canvas) SetBounds(bounds pixel.Rect) { if c.Bounds() == bounds { return } mainthread.Call(func() { oldF := c.f _, _, w, h := intBounds(bounds) c.f = glhf.NewFrame(w, h, c.smooth) // preserve old content if oldF != nil { relBounds := c.bounds relBounds.Pos -= bounds.Pos ox, oy, ow, oh := intBounds(relBounds) oldF.Blit( c.f, ox, oy, ox+ow, oy+oh, ox, oy, ox+ow, oy+oh, ) } }) c.bounds = bounds c.orig = c // detach from the Original c.dirty = true } // Bounds returns the rectangular bounds of the Canvas. func (c *Canvas) Bounds() pixel.Rect { return c.bounds } // SetSmooth sets whether the stretched Pictures drawn onto this Canvas should be drawn smooth or // pixely. func (c *Canvas) SetSmooth(smooth bool) { c.smooth = smooth } // Smooth returns whether the stretched Pictures drawn onto this Canvas are set to be drawn smooth // or pixely. func (c *Canvas) Smooth() bool { return c.smooth } // must be manually called inside mainthread func (c *Canvas) setGlhfBounds() { bounds := c.bounds bounds.Pos -= c.orig.bounds.Pos bx, by, bw, bh := intBounds(bounds) glhf.Bounds(bx, by, bw, bh) } // Clear fill the whole Canvas with a single color. func (c *Canvas) Clear(color color.Color) { c.orig.dirty = true nrgba := pixel.NRGBAModel.Convert(color).(pixel.NRGBA) mainthread.CallNonBlock(func() { c.setGlhfBounds() c.f.Begin() glhf.Clear( float32(nrgba.R), float32(nrgba.G), float32(nrgba.B), float32(nrgba.A), ) c.f.End() }) } // Slice returns a sub-Canvas with the specified Bounds. // // The returned value is *Canvas, the type of the return value is a general pixel.Picture just so // that Canvas implements pixel.Picture interface. func (c *Canvas) Slice(bounds pixel.Rect) pixel.Picture { sc := new(Canvas) *sc = *c sc.bounds = bounds return sc } // Original returns the most original Canvas that this Canvas was created from using Slice-ing. // // The returned value is *Canvas, the type of the return value is a general pixel.Picture just so // that Canvas implements pixel.Picture interface. func (c *Canvas) Original() pixel.Picture { return c.orig } // Color returns the color of the pixel over the given position inside the Canvas. func (c *Canvas) Color(at pixel.Vec) pixel.NRGBA { if c.orig.dirty { mainthread.Call(func() { c.f.Texture.Begin() c.orig.pixels = c.f.Texture.Pixels(0, 0, c.f.Texture.Width(), c.f.Texture.Height()) c.f.Texture.End() }) c.orig.dirty = false } if !c.bounds.Contains(at) { return pixel.NRGBA{} } bx, by, bw, _ := intBounds(c.orig.bounds) x, y := int(at.X())-bx, int(at.Y())-by off := y*bw + x return pixel.NRGBA{ R: float64(c.orig.pixels[off*4+0]) / 255, G: float64(c.orig.pixels[off*4+1]) / 255, B: float64(c.orig.pixels[off*4+2]) / 255, A: float64(c.orig.pixels[off*4+3]) / 255, } } type canvasTriangles struct { *GLTriangles c *Canvas } func (ct *canvasTriangles) draw(cp *canvasPicture) { ct.c.orig.dirty = true // save the current state vars to avoid race condition mat := ct.c.mat col := ct.c.col mainthread.CallNonBlock(func() { ct.c.setGlhfBounds() ct.c.f.Begin() ct.c.s.Begin() ct.c.s.SetUniformAttr(canvasBounds, mgl32.Vec4{ float32(ct.c.bounds.X()), float32(ct.c.bounds.Y()), float32(ct.c.bounds.W()), float32(ct.c.bounds.H()), }) ct.c.s.SetUniformAttr(canvasTransform, mat) ct.c.s.SetUniformAttr(canvasColorMask, col) if cp == nil { ct.vs.Begin() ct.vs.Draw() ct.vs.End() } else { cp.tex.Begin() ct.c.s.SetUniformAttr(canvasTexBorders, mgl32.Vec4{ float32(cp.borders.X()), float32(cp.borders.Y()), float32(cp.borders.W()), float32(cp.borders.H()), }) ct.c.s.SetUniformAttr(canvasTexBounds, mgl32.Vec4{ float32(cp.bounds.X()), float32(cp.bounds.Y()), float32(cp.bounds.W()), float32(cp.bounds.H()), }) if cp.tex.Smooth() != ct.c.smooth { cp.tex.SetSmooth(ct.c.smooth) } ct.vs.Begin() ct.vs.Draw() ct.vs.End() cp.tex.End() } ct.c.s.End() ct.c.f.End() }) } func (ct *canvasTriangles) Draw() { ct.draw(nil) } type canvasPicture struct { tex *glhf.Texture borders pixel.Rect bounds pixel.Rect orig *canvasPicture c *Canvas } func (cp *canvasPicture) Bounds() pixel.Rect { return cp.bounds } func (cp *canvasPicture) Slice(r pixel.Rect) pixel.Picture { sp := new(canvasPicture) *sp = *cp sp.bounds = r return sp } func (cp *canvasPicture) Original() pixel.Picture { return cp.orig } func (cp *canvasPicture) Draw(t pixel.TargetTriangles) { ct := t.(*canvasTriangles) if cp.c != ct.c { panic(fmt.Errorf("%T.Draw: TargetTriangles generated by different Canvas", cp)) } ct.draw(cp) } const ( canvasPosition int = iota canvasColor canvasTexture canvasIntensity ) var canvasVertexFormat = glhf.AttrFormat{ canvasPosition: {Name: "position", Type: glhf.Vec2}, canvasColor: {Name: "color", Type: glhf.Vec4}, canvasTexture: {Name: "texture", Type: glhf.Vec2}, canvasIntensity: {Name: "intensity", Type: glhf.Float}, } const ( canvasTransform int = iota canvasColorMask canvasBounds canvasTexBorders canvasTexBounds ) var canvasUniformFormat = glhf.AttrFormat{ canvasTransform: {Name: "transform", Type: glhf.Mat3}, canvasColorMask: {Name: "colorMask", Type: glhf.Vec4}, canvasBounds: {Name: "bounds", Type: glhf.Vec4}, canvasTexBorders: {Name: "texBorders", Type: glhf.Vec4}, canvasTexBounds: {Name: "texBounds", Type: glhf.Vec4}, } var canvasVertexShader = ` #version 330 core in vec2 position; in vec4 color; in vec2 texture; in float intensity; out vec4 Color; out vec2 Texture; out float Intensity; uniform mat3 transform; uniform vec4 borders; uniform vec4 bounds; void main() { vec2 transPos = (transform * vec3(position, 1.0)).xy; vec2 normPos = (transPos - bounds.xy) / (bounds.zw) * 2 - vec2(1, 1); gl_Position = vec4(normPos, 0.0, 1.0); Color = color; Texture = texture; Intensity = intensity; } ` var canvasFragmentShader = ` #version 330 core in vec4 Color; in vec2 Texture; in float Intensity; out vec4 color; uniform vec4 colorMask; uniform vec4 texBorders; uniform vec4 texBounds; uniform sampler2D tex; void main() { if (Intensity == 0) { color = colorMask * Color; } else { color = vec4(0, 0, 0, 0); color += (1 - Intensity) * colorMask * Color; float bx = texBounds.x; float by = texBounds.y; float bw = texBounds.z; float bh = texBounds.w; if (bx <= Texture.x && Texture.x <= bx + bw && by <= Texture.y && Texture.y <= by + bh) { vec2 t = (Texture - texBorders.xy) / texBorders.zw; color += Intensity * colorMask * Color * texture(tex, t); } } } `