go-opengl-pixel/pixelgl/canvas.go

432 lines
10 KiB
Go
Raw Normal View History

package pixelgl
import (
2017-03-05 17:28:52 -06:00
"fmt"
"image/color"
2017-02-11 07:09:47 -06:00
"github.com/faiface/glhf"
"github.com/faiface/mainthread"
"github.com/faiface/pixel"
"github.com/go-gl/mathgl/mgl32"
"github.com/pkg/errors"
)
2017-03-15 16:55:43 -05:00
// Canvas is an off-screen rectangular BasicTarget and Picture at the same time, that you can draw
// onto.
//
2017-03-05 17:28:52 -06:00
// It supports TrianglesPosition, TrianglesColor, TrianglesPicture and PictureColor.
type Canvas struct {
gf *GLFrame
shader *glhf.Shader
2017-03-31 08:03:06 -05:00
2017-04-09 17:30:50 -05:00
cmp pixel.ComposeMethod
2017-03-08 12:19:20 -06:00
mat mgl32.Mat3
col mgl32.Vec4
2017-01-21 20:05:46 -06:00
smooth bool
2017-04-12 09:00:56 -05:00
sprite *pixel.Sprite
}
2017-04-09 17:30:50 -05:00
var _ pixel.ComposeTarget = (*Canvas)(nil)
// NewCanvas creates a new empty, fully transparent Canvas with given bounds.
func NewCanvas(bounds pixel.Rect) *Canvas {
2017-03-05 17:28:52 -06:00
c := &Canvas{
gf: NewGLFrame(bounds),
mat: mgl32.Ident3(),
col: mgl32.Vec4{1, 1, 1, 1},
2017-03-05 17:28:52 -06:00
}
c.SetBounds(bounds)
var shader *glhf.Shader
mainthread.Call(func() {
var err error
shader, err = glhf.NewShader(
canvasVertexFormat,
canvasUniformFormat,
canvasVertexShader,
canvasFragmentShader,
)
if err != nil {
2017-03-05 17:28:52 -06:00
panic(errors.Wrap(err, "failed to create Canvas, there's a bug in the shader"))
}
})
c.shader = shader
2017-03-05 17:28:52 -06:00
return c
}
2017-03-05 17:28:52 -06:00
// 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.shader, t),
dst: c,
2017-01-21 20:05:46 -06:00
}
2017-03-05 17:28:52 -06:00
}
2017-01-21 20:05:46 -06:00
2017-03-05 17:28:52 -06:00
// 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 {
2017-03-06 12:04:57 -06:00
if cp, ok := p.(*canvasPicture); ok {
return &canvasPicture{
GLPicture: cp.GLPicture,
dst: c,
}
}
if gp, ok := p.(GLPicture); ok {
return &canvasPicture{
GLPicture: gp,
dst: c,
2017-03-06 06:05:45 -06:00
}
2017-03-05 17:28:52 -06:00
}
return &canvasPicture{
GLPicture: NewGLPicture(p),
dst: c,
2017-03-05 17:28:52 -06:00
}
}
// SetMatrix sets a Matrix that every point will be projected by.
func (c *Canvas) SetMatrix(m pixel.Matrix) {
2017-06-09 11:13:05 -05:00
// pixel.Matrix is 3x2 with an implicit 0, 0, 1 row after it. So
// [0] [2] [4] [0] [3] [6]
// [1] [3] [5] => [1] [4] [7]
// 0 0 1 0 0 1
// since all matrix ops are affine, the last row never changes, and we don't need to copy it
for i, j := range [...]int{0, 1, 3, 4, 6, 7} {
c.mat[j] = float32(m[i])
}
}
2017-03-05 17:28:52 -06:00
// SetColorMask sets a color that every color in triangles or a picture will be multiplied by.
func (c *Canvas) SetColorMask(col color.Color) {
2017-04-10 10:25:56 -05:00
rgba := pixel.Alpha(1)
2017-03-05 17:28:52 -06:00
if col != nil {
rgba = pixel.ToRGBA(col)
2017-03-05 17:28:52 -06:00
}
c.col = mgl32.Vec4{
float32(rgba.R),
float32(rgba.G),
float32(rgba.B),
float32(rgba.A),
2017-03-05 17:28:52 -06:00
}
}
2017-04-09 17:30:50 -05:00
// SetComposeMethod sets a Porter-Duff composition method to be used in the following draws onto
// this Canvas.
func (c *Canvas) SetComposeMethod(cmp pixel.ComposeMethod) {
c.cmp = cmp
}
2017-03-05 17:28:52 -06:00
// SetBounds resizes the Canvas to the new bounds. Old content will be preserved.
func (c *Canvas) SetBounds(bounds pixel.Rect) {
c.gf.SetBounds(bounds)
2017-04-12 09:02:39 -05:00
if c.sprite == nil {
c.sprite = pixel.NewSprite(nil, pixel.Rect{})
}
2017-04-12 09:00:56 -05:00
c.sprite.Set(c, c.Bounds())
//c.sprite.SetMatrix(pixel.IM.Moved(c.Bounds().Center()))
}
2017-03-05 17:28:52 -06:00
// Bounds returns the rectangular bounds of the Canvas.
func (c *Canvas) Bounds() pixel.Rect {
return c.gf.Bounds()
}
2017-03-15 16:55:43 -05:00
// SetSmooth sets whether stretched Pictures drawn onto this Canvas should be drawn smooth or
2017-03-05 17:28:52 -06:00
// pixely.
func (c *Canvas) SetSmooth(smooth bool) {
c.smooth = smooth
}
2017-03-15 16:55:43 -05:00
// Smooth returns whether stretched Pictures drawn onto this Canvas are set to be drawn smooth or
// pixely.
2017-03-05 17:28:52 -06:00
func (c *Canvas) Smooth() bool {
return c.smooth
}
2017-03-07 10:45:46 -06:00
// must be manually called inside mainthread
func (c *Canvas) setGlhfBounds() {
_, _, bw, bh := intBounds(c.gf.Bounds())
glhf.Bounds(0, 0, bw, bh)
2017-03-07 10:45:46 -06:00
}
2017-04-09 17:30:50 -05:00
// must be manually called inside mainthread
2017-04-09 17:41:56 -05:00
func setBlendFunc(cmp pixel.ComposeMethod) {
switch cmp {
2017-04-09 17:30:50 -05:00
case pixel.ComposeOver:
glhf.BlendFunc(glhf.One, glhf.OneMinusSrcAlpha)
case pixel.ComposeIn:
glhf.BlendFunc(glhf.DstAlpha, glhf.Zero)
case pixel.ComposeOut:
glhf.BlendFunc(glhf.OneMinusDstAlpha, glhf.Zero)
case pixel.ComposeAtop:
glhf.BlendFunc(glhf.DstAlpha, glhf.OneMinusSrcAlpha)
case pixel.ComposeRover:
2017-04-09 17:30:50 -05:00
glhf.BlendFunc(glhf.OneMinusDstAlpha, glhf.One)
case pixel.ComposeRin:
2017-04-09 17:30:50 -05:00
glhf.BlendFunc(glhf.Zero, glhf.SrcAlpha)
case pixel.ComposeRout:
2017-04-09 17:30:50 -05:00
glhf.BlendFunc(glhf.Zero, glhf.OneMinusSrcAlpha)
case pixel.ComposeRatop:
2017-04-09 17:30:50 -05:00
glhf.BlendFunc(glhf.OneMinusDstAlpha, glhf.SrcAlpha)
case pixel.ComposeXor:
glhf.BlendFunc(glhf.OneMinusDstAlpha, glhf.OneMinusSrcAlpha)
case pixel.ComposePlus:
glhf.BlendFunc(glhf.One, glhf.One)
case pixel.ComposeCopy:
glhf.BlendFunc(glhf.One, glhf.Zero)
2017-04-09 17:30:50 -05:00
default:
panic(errors.New("Canvas: invalid compose method"))
}
}
2017-03-15 16:55:43 -05:00
// Clear fills the whole Canvas with a single color.
2017-03-05 17:28:52 -06:00
func (c *Canvas) Clear(color color.Color) {
c.gf.Dirty()
2017-03-07 10:45:46 -06:00
rgba := pixel.ToRGBA(color)
2017-03-07 10:45:46 -06:00
2017-03-08 08:02:40 -06:00
// color masking
rgba = rgba.Mul(pixel.RGBA{
2017-03-08 08:02:40 -06:00
R: float64(c.col[0]),
G: float64(c.col[1]),
B: float64(c.col[2]),
A: float64(c.col[3]),
})
2017-03-05 17:28:52 -06:00
mainthread.CallNonBlock(func() {
2017-03-07 10:45:46 -06:00
c.setGlhfBounds()
c.gf.Frame().Begin()
2017-03-05 17:28:52 -06:00
glhf.Clear(
float32(rgba.R),
float32(rgba.G),
float32(rgba.B),
float32(rgba.A),
2017-03-05 17:28:52 -06:00
)
c.gf.Frame().End()
2017-03-05 17:28:52 -06:00
})
}
2017-03-07 10:45:46 -06:00
// Color returns the color of the pixel over the given position inside the Canvas.
func (c *Canvas) Color(at pixel.Vec) pixel.RGBA {
return c.gf.Color(at)
}
// Texture returns the underlying OpenGL Texture of this Canvas.
//
// Implements GLPicture interface.
func (c *Canvas) Texture() *glhf.Texture {
return c.gf.Texture()
2017-03-07 10:45:46 -06:00
}
2017-05-28 11:50:56 -05:00
// Frame returns the underlying OpenGL Frame of this Canvas.
2017-05-28 11:44:30 -05:00
func (c *Canvas) Frame() *glhf.Frame {
return c.gf.frame
}
// SetPixels replaces the content of the Canvas with the provided pixels. The provided slice must be
// an alpha-premultiplied RGBA sequence of correct length (4 * width * height).
func (c *Canvas) SetPixels(pixels []uint8) {
c.gf.Dirty()
mainthread.Call(func() {
tex := c.Texture()
tex.Begin()
tex.SetPixels(0, 0, tex.Width(), tex.Height(), pixels)
tex.End()
})
}
// Pixels returns an alpha-premultiplied RGBA sequence of the content of the Canvas.
func (c *Canvas) Pixels() []uint8 {
var pixels []uint8
mainthread.Call(func() {
tex := c.Texture()
tex.Begin()
pixels = tex.Pixels(0, 0, tex.Width(), tex.Height())
tex.End()
})
return pixels
}
// Draw draws the content of the Canvas onto another Target, transformed by the given Matrix, just
// like if it was a Sprite containing the whole Canvas.
func (c *Canvas) Draw(t pixel.Target, matrix pixel.Matrix) {
c.sprite.Draw(t, matrix)
}
// DrawColorMask draws the content of the Canvas onto another Target, transformed by the given
// Matrix and multiplied by the given mask, just like if it was a Sprite containing the whole Canvas.
2017-04-12 09:00:56 -05:00
//
// If the color mask is nil, a fully opaque white mask will be used causing no effect.
func (c *Canvas) DrawColorMask(t pixel.Target, matrix pixel.Matrix, mask color.Color) {
c.sprite.DrawColorMask(t, matrix, mask)
2017-04-12 09:00:56 -05:00
}
type canvasTriangles struct {
2017-03-05 17:28:52 -06:00
*GLTriangles
dst *Canvas
}
func (ct *canvasTriangles) draw(tex *glhf.Texture, bounds pixel.Rect) {
ct.dst.gf.Dirty()
2017-03-07 10:45:46 -06:00
2017-03-05 17:28:52 -06:00
// save the current state vars to avoid race condition
2017-04-09 17:41:56 -05:00
cmp := ct.dst.cmp
mat := ct.dst.mat
col := ct.dst.col
2017-04-09 17:41:56 -05:00
smt := ct.dst.smooth
mainthread.CallNonBlock(func() {
ct.dst.setGlhfBounds()
2017-04-09 17:41:56 -05:00
setBlendFunc(cmp)
frame := ct.dst.gf.Frame()
shader := ct.dst.shader
frame.Begin()
shader.Begin()
dstBounds := ct.dst.Bounds()
shader.SetUniformAttr(canvasBounds, mgl32.Vec4{
2017-05-21 12:25:06 -05:00
float32(dstBounds.Min.X),
float32(dstBounds.Min.Y),
float32(dstBounds.W()),
float32(dstBounds.H()),
2017-03-06 17:32:58 -06:00
})
shader.SetUniformAttr(canvasTransform, mat)
shader.SetUniformAttr(canvasColorMask, col)
if tex == nil {
2017-03-05 17:28:52 -06:00
ct.vs.Begin()
ct.vs.Draw()
ct.vs.End()
} else {
tex.Begin()
2017-03-05 17:28:52 -06:00
bx, by, bw, bh := intBounds(bounds)
shader.SetUniformAttr(canvasTexBounds, mgl32.Vec4{
float32(bx),
float32(by),
float32(bw),
float32(bh),
2017-03-05 17:28:52 -06:00
})
2017-04-09 17:41:56 -05:00
if tex.Smooth() != smt {
tex.SetSmooth(smt)
2017-03-05 17:28:52 -06:00
}
ct.vs.Begin()
ct.vs.Draw()
ct.vs.End()
tex.End()
}
shader.End()
frame.End()
})
}
2017-03-05 17:28:52 -06:00
func (ct *canvasTriangles) Draw() {
ct.draw(nil, pixel.Rect{})
2017-03-05 17:28:52 -06:00
}
type canvasPicture struct {
GLPicture
dst *Canvas
}
2017-03-05 17:28:52 -06:00
func (cp *canvasPicture) Draw(t pixel.TargetTriangles) {
ct := t.(*canvasTriangles)
if cp.dst != ct.dst {
2017-03-08 16:51:53 -06:00
panic(fmt.Errorf("(%T).Draw: TargetTriangles generated by different Canvas", cp))
2017-03-05 17:28:52 -06:00
}
ct.draw(cp.GLPicture.Texture(), cp.GLPicture.Bounds())
2017-03-05 17:28:52 -06:00
}
const (
2017-03-05 17:28:52 -06:00
canvasPosition int = iota
canvasColor
canvasTexCoords
2017-03-05 17:28:52 -06:00
canvasIntensity
)
2017-02-11 07:09:47 -06:00
var canvasVertexFormat = glhf.AttrFormat{
2017-03-05 17:28:52 -06:00
canvasPosition: {Name: "position", Type: glhf.Vec2},
canvasColor: {Name: "color", Type: glhf.Vec4},
canvasTexCoords: {Name: "texCoords", Type: glhf.Vec2},
2017-03-05 17:28:52 -06:00
canvasIntensity: {Name: "intensity", Type: glhf.Float},
}
const (
2017-03-05 17:28:52 -06:00
canvasTransform int = iota
canvasColorMask
2017-03-06 17:32:58 -06:00
canvasBounds
2017-03-06 09:09:09 -06:00
canvasTexBounds
)
2017-02-11 07:09:47 -06:00
var canvasUniformFormat = glhf.AttrFormat{
canvasTransform: {Name: "transform", Type: glhf.Mat3},
canvasColorMask: {Name: "colorMask", Type: glhf.Vec4},
canvasBounds: {Name: "bounds", Type: glhf.Vec4},
canvasTexBounds: {Name: "texBounds", Type: glhf.Vec4},
}
var canvasVertexShader = `
#version 330 core
in vec2 position;
in vec4 color;
in vec2 texCoords;
2017-03-05 17:28:52 -06:00
in float intensity;
out vec4 Color;
out vec2 TexCoords;
2017-03-05 17:28:52 -06:00
out float Intensity;
uniform mat3 transform;
2017-03-06 17:32:58 -06:00
uniform vec4 bounds;
void main() {
2017-03-05 17:28:52 -06:00
vec2 transPos = (transform * vec3(position, 1.0)).xy;
2017-04-13 13:30:32 -05:00
vec2 normPos = (transPos - bounds.xy) / bounds.zw * 2 - vec2(1, 1);
2017-03-05 17:28:52 -06:00
gl_Position = vec4(normPos, 0.0, 1.0);
Color = color;
TexCoords = texCoords;
2017-03-05 17:28:52 -06:00
Intensity = intensity;
}
`
var canvasFragmentShader = `
#version 330 core
in vec4 Color;
in vec2 TexCoords;
2017-03-05 17:28:52 -06:00
in float Intensity;
out vec4 color;
2017-03-05 17:28:52 -06:00
uniform vec4 colorMask;
2017-03-06 09:09:09 -06:00
uniform vec4 texBounds;
uniform sampler2D tex;
void main() {
2017-03-05 17:28:52 -06:00
if (Intensity == 0) {
color = colorMask * Color;
} else {
2017-03-05 17:28:52 -06:00
color = vec4(0, 0, 0, 0);
color += (1 - Intensity) * Color;
vec2 t = (TexCoords - texBounds.xy) / texBounds.zw;
color += Intensity * Color * texture(tex, t);
color *= colorMask;
}
}
`