Merge pull request #141 from thegtproject/shaders
implemented custom fragment shader support
This commit is contained in:
Michal Štrba
GitHub
commit
d7dcc8d167
|
|
@ -17,7 +17,7 @@ import (
|
|||
// It supports TrianglesPosition, TrianglesColor, TrianglesPicture and PictureColor.
|
||||
type Canvas struct {
|
||||
gf *GLFrame
|
||||
shader *glhf.Shader
|
||||
shader *glShader
|
||||
|
||||
cmp pixel.ComposeMethod
|
||||
mat mgl32.Mat3
|
||||
|
|
@ -37,32 +37,32 @@ func NewCanvas(bounds pixel.Rect) *Canvas {
|
|||
col: mgl32.Vec4{1, 1, 1, 1},
|
||||
}
|
||||
|
||||
baseShader(c)
|
||||
c.SetBounds(bounds)
|
||||
|
||||
var shader *glhf.Shader
|
||||
mainthread.Call(func() {
|
||||
var err error
|
||||
shader, 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.shader = shader
|
||||
|
||||
c.shader.update()
|
||||
return c
|
||||
}
|
||||
|
||||
// SetUniform will update the named uniform with the value of any supported underlying
|
||||
// attribute variable. If the uniform already exists, including defaults, they will be reassigned
|
||||
// to the new value. The value can be a pointer.
|
||||
func (c *Canvas) SetUniform(Name string, Value interface{}) {
|
||||
c.shader.setUniform(Name, Value)
|
||||
}
|
||||
|
||||
// SetFragmentShader allows you to set a new fragment shader on the underlying
|
||||
// framebuffer. Argument "src" is the GLSL source, not a filename.
|
||||
func (c *Canvas) SetFragmentShader(src string) {
|
||||
c.shader.fs = src
|
||||
c.shader.update()
|
||||
}
|
||||
|
||||
// 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),
|
||||
GLTriangles: NewGLTriangles(c.shader.s, t),
|
||||
dst: c,
|
||||
}
|
||||
}
|
||||
|
|
@ -279,29 +279,41 @@ func (ct *canvasTriangles) draw(tex *glhf.Texture, bounds pixel.Rect) {
|
|||
|
||||
// save the current state vars to avoid race condition
|
||||
cmp := ct.dst.cmp
|
||||
smt := ct.dst.smooth
|
||||
mat := ct.dst.mat
|
||||
col := ct.dst.col
|
||||
smt := ct.dst.smooth
|
||||
|
||||
mainthread.CallNonBlock(func() {
|
||||
ct.dst.setGlhfBounds()
|
||||
setBlendFunc(cmp)
|
||||
|
||||
frame := ct.dst.gf.Frame()
|
||||
shader := ct.dst.shader
|
||||
shader := ct.dst.shader.s
|
||||
|
||||
frame.Begin()
|
||||
shader.Begin()
|
||||
|
||||
ct.dst.shader.uniformDefaults.transform = mat
|
||||
ct.dst.shader.uniformDefaults.colormask = col
|
||||
dstBounds := ct.dst.Bounds()
|
||||
shader.SetUniformAttr(canvasBounds, mgl32.Vec4{
|
||||
ct.dst.shader.uniformDefaults.bounds = mgl32.Vec4{
|
||||
float32(dstBounds.Min.X),
|
||||
float32(dstBounds.Min.Y),
|
||||
float32(dstBounds.W()),
|
||||
float32(dstBounds.H()),
|
||||
})
|
||||
shader.SetUniformAttr(canvasTransform, mat)
|
||||
shader.SetUniformAttr(canvasColorMask, col)
|
||||
}
|
||||
|
||||
bx, by, bw, bh := intBounds(bounds)
|
||||
ct.dst.shader.uniformDefaults.texbounds = mgl32.Vec4{
|
||||
float32(bx),
|
||||
float32(by),
|
||||
float32(bw),
|
||||
float32(bh),
|
||||
}
|
||||
|
||||
for loc, u := range ct.dst.shader.uniforms {
|
||||
ct.dst.shader.s.SetUniformAttr(loc, u.Value())
|
||||
}
|
||||
|
||||
if tex == nil {
|
||||
ct.vs.Begin()
|
||||
|
|
@ -310,14 +322,6 @@ func (ct *canvasTriangles) draw(tex *glhf.Texture, bounds pixel.Rect) {
|
|||
} else {
|
||||
tex.Begin()
|
||||
|
||||
bx, by, bw, bh := intBounds(bounds)
|
||||
shader.SetUniformAttr(canvasTexBounds, mgl32.Vec4{
|
||||
float32(bx),
|
||||
float32(by),
|
||||
float32(bw),
|
||||
float32(bh),
|
||||
})
|
||||
|
||||
if tex.Smooth() != smt {
|
||||
tex.SetSmooth(smt)
|
||||
}
|
||||
|
|
@ -358,74 +362,9 @@ const (
|
|||
canvasIntensity
|
||||
)
|
||||
|
||||
var canvasVertexFormat = glhf.AttrFormat{
|
||||
var defaultCanvasVertexFormat = glhf.AttrFormat{
|
||||
canvasPosition: {Name: "position", Type: glhf.Vec2},
|
||||
canvasColor: {Name: "color", Type: glhf.Vec4},
|
||||
canvasTexCoords: {Name: "texCoords", Type: glhf.Vec2},
|
||||
canvasIntensity: {Name: "intensity", Type: glhf.Float},
|
||||
}
|
||||
|
||||
const (
|
||||
canvasTransform int = iota
|
||||
canvasColorMask
|
||||
canvasBounds
|
||||
canvasTexBounds
|
||||
)
|
||||
|
||||
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;
|
||||
in float intensity;
|
||||
|
||||
out vec4 Color;
|
||||
out vec2 TexCoords;
|
||||
out float Intensity;
|
||||
|
||||
uniform mat3 transform;
|
||||
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;
|
||||
TexCoords = texCoords;
|
||||
Intensity = intensity;
|
||||
}
|
||||
`
|
||||
|
||||
var canvasFragmentShader = `
|
||||
#version 330 core
|
||||
|
||||
in vec4 Color;
|
||||
in vec2 TexCoords;
|
||||
in float Intensity;
|
||||
|
||||
out vec4 color;
|
||||
|
||||
uniform vec4 colorMask;
|
||||
uniform vec4 texBounds;
|
||||
uniform sampler2D tex;
|
||||
|
||||
void main() {
|
||||
if (Intensity == 0) {
|
||||
color = colorMask * Color;
|
||||
} else {
|
||||
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;
|
||||
}
|
||||
}
|
||||
`
|
||||
|
|
|
|||
|
|
@ -0,0 +1,268 @@
|
|||
package pixelgl
|
||||
|
||||
import (
|
||||
"github.com/faiface/glhf"
|
||||
"github.com/faiface/mainthread"
|
||||
"github.com/go-gl/mathgl/mgl32"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
// glShader is a type to assist with managing a canvas's underlying
|
||||
// shader configuration. This allows for customization of shaders on
|
||||
// a per canvas basis.
|
||||
type glShader struct {
|
||||
s *glhf.Shader
|
||||
vf, uf glhf.AttrFormat
|
||||
vs, fs string
|
||||
|
||||
uniforms []gsUniformAttr
|
||||
|
||||
uniformDefaults struct {
|
||||
transform mgl32.Mat3
|
||||
colormask mgl32.Vec4
|
||||
bounds mgl32.Vec4
|
||||
texbounds mgl32.Vec4
|
||||
}
|
||||
}
|
||||
|
||||
type gsUniformAttr struct {
|
||||
Name string
|
||||
Type glhf.AttrType
|
||||
value interface{}
|
||||
ispointer bool
|
||||
}
|
||||
|
||||
// reinitialize GLShader data and recompile the underlying gl shader object
|
||||
func (gs *glShader) update() {
|
||||
gs.uf = nil
|
||||
for _, u := range gs.uniforms {
|
||||
gs.uf = append(gs.uf, glhf.Attr{
|
||||
Name: u.Name,
|
||||
Type: u.Type,
|
||||
})
|
||||
}
|
||||
var shader *glhf.Shader
|
||||
mainthread.Call(func() {
|
||||
var err error
|
||||
shader, err = glhf.NewShader(
|
||||
gs.vf,
|
||||
gs.uf,
|
||||
gs.vs,
|
||||
gs.fs,
|
||||
)
|
||||
if err != nil {
|
||||
panic(errors.Wrap(err, "failed to create Canvas, there's a bug in the shader"))
|
||||
}
|
||||
})
|
||||
|
||||
gs.s = shader
|
||||
}
|
||||
|
||||
// gets the uniform index from GLShader
|
||||
func (gs *glShader) getUniform(Name string) int {
|
||||
for i, u := range gs.uniforms {
|
||||
if u.Name == Name {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// SetUniform appends a custom uniform name and value to the shader.
|
||||
// if the uniform already exists, it will simply be overwritten.
|
||||
//
|
||||
// example:
|
||||
//
|
||||
// utime := float32(time.Since(starttime)).Seconds())
|
||||
// mycanvas.shader.AddUniform("u_time", &utime)
|
||||
func (gs *glShader) setUniform(name string, value interface{}) {
|
||||
t, p := getAttrType(value)
|
||||
if loc := gs.getUniform(name); loc > -1 {
|
||||
gs.uniforms[loc].Name = name
|
||||
gs.uniforms[loc].Type = t
|
||||
gs.uniforms[loc].ispointer = p
|
||||
gs.uniforms[loc].value = value
|
||||
return
|
||||
}
|
||||
gs.uniforms = append(gs.uniforms, gsUniformAttr{
|
||||
Name: name,
|
||||
Type: t,
|
||||
ispointer: p,
|
||||
value: value,
|
||||
})
|
||||
}
|
||||
|
||||
// Sets up a base shader with everything needed for a Pixel
|
||||
// canvas to render correctly. The defaults can be overridden
|
||||
// by simply using the SetUniform function.
|
||||
func baseShader(c *Canvas) {
|
||||
gs := &glShader{
|
||||
vf: defaultCanvasVertexFormat,
|
||||
vs: defaultCanvasVertexShader,
|
||||
fs: baseCanvasFragmentShader,
|
||||
}
|
||||
|
||||
gs.setUniform("u_transform", &gs.uniformDefaults.transform)
|
||||
gs.setUniform("u_colormask", &gs.uniformDefaults.colormask)
|
||||
gs.setUniform("u_bounds", &gs.uniformDefaults.bounds)
|
||||
gs.setUniform("u_texbounds", &gs.uniformDefaults.texbounds)
|
||||
|
||||
c.shader = gs
|
||||
}
|
||||
|
||||
// Value returns the attribute's concrete value. If the stored value
|
||||
// is a pointer, we return the dereferenced value.
|
||||
func (gu *gsUniformAttr) Value() interface{} {
|
||||
if !gu.ispointer {
|
||||
return gu.value
|
||||
}
|
||||
switch gu.Type {
|
||||
case glhf.Vec2:
|
||||
return *gu.value.(*mgl32.Vec2)
|
||||
case glhf.Vec3:
|
||||
return *gu.value.(*mgl32.Vec3)
|
||||
case glhf.Vec4:
|
||||
return *gu.value.(*mgl32.Vec4)
|
||||
case glhf.Mat2:
|
||||
return *gu.value.(*mgl32.Mat2)
|
||||
case glhf.Mat23:
|
||||
return *gu.value.(*mgl32.Mat2x3)
|
||||
case glhf.Mat24:
|
||||
return *gu.value.(*mgl32.Mat2x4)
|
||||
case glhf.Mat3:
|
||||
return *gu.value.(*mgl32.Mat3)
|
||||
case glhf.Mat32:
|
||||
return *gu.value.(*mgl32.Mat3x2)
|
||||
case glhf.Mat34:
|
||||
return *gu.value.(*mgl32.Mat3x4)
|
||||
case glhf.Mat4:
|
||||
return *gu.value.(*mgl32.Mat4)
|
||||
case glhf.Mat42:
|
||||
return *gu.value.(*mgl32.Mat4x2)
|
||||
case glhf.Mat43:
|
||||
return *gu.value.(*mgl32.Mat4x3)
|
||||
case glhf.Int:
|
||||
return *gu.value.(*int32)
|
||||
case glhf.Float:
|
||||
return *gu.value.(*float32)
|
||||
default:
|
||||
panic("invalid attrtype")
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the type identifier for any (supported) attribute variable type
|
||||
// and whether or not it is a pointer of that type.
|
||||
func getAttrType(v interface{}) (glhf.AttrType, bool) {
|
||||
switch v.(type) {
|
||||
case int32:
|
||||
return glhf.Int, false
|
||||
case float32:
|
||||
return glhf.Float, false
|
||||
case mgl32.Vec2:
|
||||
return glhf.Vec2, false
|
||||
case mgl32.Vec3:
|
||||
return glhf.Vec3, false
|
||||
case mgl32.Vec4:
|
||||
return glhf.Vec4, false
|
||||
case mgl32.Mat2:
|
||||
return glhf.Mat2, false
|
||||
case mgl32.Mat2x3:
|
||||
return glhf.Mat23, false
|
||||
case mgl32.Mat2x4:
|
||||
return glhf.Mat24, false
|
||||
case mgl32.Mat3:
|
||||
return glhf.Mat3, false
|
||||
case mgl32.Mat3x2:
|
||||
return glhf.Mat32, false
|
||||
case mgl32.Mat3x4:
|
||||
return glhf.Mat34, false
|
||||
case mgl32.Mat4:
|
||||
return glhf.Mat4, false
|
||||
case mgl32.Mat4x2:
|
||||
return glhf.Mat42, false
|
||||
case mgl32.Mat4x3:
|
||||
return glhf.Mat43, false
|
||||
case *mgl32.Vec2:
|
||||
return glhf.Vec2, true
|
||||
case *mgl32.Vec3:
|
||||
return glhf.Vec3, true
|
||||
case *mgl32.Vec4:
|
||||
return glhf.Vec4, true
|
||||
case *mgl32.Mat2:
|
||||
return glhf.Mat2, true
|
||||
case *mgl32.Mat2x3:
|
||||
return glhf.Mat23, true
|
||||
case *mgl32.Mat2x4:
|
||||
return glhf.Mat24, true
|
||||
case *mgl32.Mat3:
|
||||
return glhf.Mat3, true
|
||||
case *mgl32.Mat3x2:
|
||||
return glhf.Mat32, true
|
||||
case *mgl32.Mat3x4:
|
||||
return glhf.Mat34, true
|
||||
case *mgl32.Mat4:
|
||||
return glhf.Mat4, true
|
||||
case *mgl32.Mat4x2:
|
||||
return glhf.Mat42, true
|
||||
case *mgl32.Mat4x3:
|
||||
return glhf.Mat43, true
|
||||
case *int32:
|
||||
return glhf.Int, true
|
||||
case *float32:
|
||||
return glhf.Float, true
|
||||
default:
|
||||
panic("invalid AttrType")
|
||||
}
|
||||
}
|
||||
|
||||
var defaultCanvasVertexShader = `
|
||||
#version 330 core
|
||||
|
||||
in vec2 position;
|
||||
in vec4 color;
|
||||
in vec2 texCoords;
|
||||
in float intensity;
|
||||
out vec4 Color;
|
||||
out vec2 texcoords;
|
||||
out vec2 glpos;
|
||||
out float Intensity;
|
||||
|
||||
uniform mat3 u_transform;
|
||||
uniform vec4 u_bounds;
|
||||
|
||||
void main() {
|
||||
vec2 transPos = (u_transform * vec3(position, 1.0)).xy;
|
||||
vec2 normPos = (transPos - u_bounds.xy) / u_bounds.zw * 2 - vec2(1, 1);
|
||||
gl_Position = vec4(normPos, 0.0, 1.0);
|
||||
Color = color;
|
||||
texcoords = texCoords;
|
||||
Intensity = intensity;
|
||||
glpos = transPos;
|
||||
}
|
||||
`
|
||||
|
||||
var baseCanvasFragmentShader = `
|
||||
#version 330 core
|
||||
|
||||
in vec4 Color;
|
||||
in vec2 texcoords;
|
||||
in float Intensity;
|
||||
|
||||
out vec4 fragColor;
|
||||
|
||||
uniform vec4 u_colormask;
|
||||
uniform vec4 u_texbounds;
|
||||
uniform sampler2D u_texture;
|
||||
|
||||
void main() {
|
||||
if (Intensity == 0) {
|
||||
fragColor = u_colormask * Color;
|
||||
} else {
|
||||
fragColor = vec4(0, 0, 0, 0);
|
||||
fragColor += (1 - Intensity) * Color;
|
||||
vec2 t = (texcoords - u_texbounds.xy) / u_texbounds.zw;
|
||||
fragColor += Intensity * Color * texture(u_texture, t);
|
||||
fragColor *= u_colormask;
|
||||
}
|
||||
}
|
||||
`
|
||||
|
|
@ -424,3 +424,8 @@ func (w *Window) Clear(c color.Color) {
|
|||
func (w *Window) Color(at pixel.Vec) pixel.RGBA {
|
||||
return w.canvas.Color(at)
|
||||
}
|
||||
|
||||
// Canvas returns the window's underlying Canvas
|
||||
func (w *Window) Canvas() *Canvas {
|
||||
return w.canvas
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue