fully unified into one shader

updated shadow test

backend/goglbackend/clip.go

@@ -40,9 +40,7 @@ func (b *GoGLBackend) Clip(pts [][2]float64) {
 	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
 	gl.Uniform1f(b.shd.GlobalAlpha, 1)
 	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.UseLinearGradient, 0)
+	gl.Uniform1i(b.shd.Func, shdFuncSolid)
-	gl.Uniform1i(b.shd.UseRadialGradient, 0)
-	gl.Uniform1i(b.shd.UseImagePattern, 0)
 	gl.EnableVertexAttribArray(b.shd.Vertex)
 
 	gl.ColorMask(false, false, false, false)

backend/goglbackend/fill.go

@@ -38,9 +38,7 @@ func (b *GoGLBackend) Clear(pts [4][2]float64) {
 	gl.Uniform4f(b.shd.Color, 0, 0, 0, 0)
 	gl.Uniform1f(b.shd.GlobalAlpha, 1)
 	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.UseLinearGradient, 0)
+	gl.Uniform1i(b.shd.Func, shdFuncSolid)
-	gl.Uniform1i(b.shd.UseRadialGradient, 0)
-	gl.Uniform1i(b.shd.UseImagePattern, 0)
 
 	gl.Disable(gl.BLEND)
 
@@ -134,9 +132,7 @@ func (b *GoGLBackend) Fill(style *backendbase.FillStyle, pts [][2]float64, canOv
 		gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
 		gl.Uniform1f(b.shd.GlobalAlpha, 1)
 		gl.Uniform1i(b.shd.UseAlphaTex, 0)
-		gl.Uniform1i(b.shd.UseLinearGradient, 0)
+		gl.Uniform1i(b.shd.Func, shdFuncSolid)
-		gl.Uniform1i(b.shd.UseRadialGradient, 0)
-		gl.Uniform1i(b.shd.UseImagePattern, 0)
 
 		gl.EnableVertexAttribArray(b.shd.Vertex)
 		gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
@@ -238,14 +234,16 @@ func (b *GoGLBackend) drawBlurred(size float64) {
 		0, 1, 0, 0, 1, 0, 1, 1}
 	gl.BufferData(gl.ARRAY_BUFFER, len(data)*4, unsafe.Pointer(&data[0]), gl.STREAM_DRAW)
 
-	gl.UseProgram(b.bbshd.ID)
+	gl.UseProgram(b.shd.ID)
-	gl.Uniform1i(b.bbshd.Image, 0)
+	gl.Uniform1i(b.shd.Image, 0)
-	gl.Uniform2f(b.bbshd.CanvasSize, float32(b.fw), float32(b.fh))
+	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
+	gl.Uniform1i(b.shd.UseAlphaTex, 0)
+	gl.Uniform1i(b.shd.Func, shdFuncBoxBlur)
 
-	gl.VertexAttribPointer(b.bbshd.Vertex, 2, gl.FLOAT, false, 0, nil)
+	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
-	gl.VertexAttribPointer(b.bbshd.TexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
+	gl.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
-	gl.EnableVertexAttribArray(b.bbshd.Vertex)
+	gl.EnableVertexAttribArray(b.shd.Vertex)
-	gl.EnableVertexAttribArray(b.bbshd.TexCoord)
+	gl.EnableVertexAttribArray(b.shd.TexCoord)
 
 	gl.Disable(gl.BLEND)
 
@@ -284,22 +282,20 @@ func (b *GoGLBackend) drawBlurred(size float64) {
 	b.disableTextureRenderTarget()
 	b.box3(sizec, true)
 
-	gl.DisableVertexAttribArray(b.bbshd.Vertex)
+	gl.DisableVertexAttribArray(b.shd.Vertex)
-	gl.DisableVertexAttribArray(b.bbshd.TexCoord)
+	gl.DisableVertexAttribArray(b.shd.TexCoord)
 
 	gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
 }
 
 func (b *GoGLBackend) box3(size int, vertical bool) {
-	gl.Uniform1i(b.bbshd.BoxSize, int32(size))
+	gl.Uniform1i(b.shd.BoxSize, int32(size))
 	if vertical {
-		gl.Uniform1i(b.bbshd.BoxVertical, 1)
+		gl.Uniform1i(b.shd.BoxVertical, 1)
-		gl.Uniform1f(b.bbshd.BoxScale, 1/float32(b.fh))
+		gl.Uniform1f(b.shd.BoxScale, 1/float32(b.fh))
 	} else {
-		gl.Uniform1i(b.bbshd.BoxVertical, 0)
+		gl.Uniform1i(b.shd.BoxVertical, 0)
-		gl.Uniform1f(b.bbshd.BoxScale, 1/float32(b.fw))
+		gl.Uniform1f(b.shd.BoxScale, 1/float32(b.fw))
 	}
 	gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
-
-	gl.StencilFunc(gl.ALWAYS, 0, 0xFF)
 }

backend/goglbackend/gogl.go

@@ -21,7 +21,6 @@ type GLContext struct {
 	alphaTex  uint32
 
 	shd unifiedShader
-	bbshd boxBlurShader
 
 	offscr1 offscreenBuffer
 	offscr2 offscreenBuffer
@@ -58,15 +57,6 @@ func NewGLContext() (*GLContext, error) {
 		return nil, err
 	}
 
-	err = loadShader(boxVS, boxFS, &ctx.bbshd.shaderProgram)
-	if err != nil {
-		return nil, err
-	}
-	ctx.bbshd.shaderProgram.mustLoadLocations(&ctx.bbshd)
-	if err = glError(); err != nil {
-		return nil, err
-	}
-
 	gl.GenBuffers(1, &ctx.buf)
 	if err = glError(); err != nil {
 		return nil, err
@@ -320,10 +310,7 @@ func (b *GoGLBackend) useShader(style *backendbase.FillStyle, useAlpha bool, alp
 		gl.Uniform1f(b.shd.GlobalAlpha, float32(style.Color.A)/255)
 		gl.Uniform1i(b.shd.AlphaTex, alphaTexSlot)
 		gl.Uniform1i(b.shd.UseAlphaTex, alphaVal)
-		gl.Uniform1i(b.shd.UseLinearGradient, 1)
+		gl.Uniform1i(b.shd.Func, shdFuncLinearGradient)
-		gl.Uniform1i(b.shd.UseRadialGradient, 0)
-		gl.Uniform1i(b.shd.UseImagePattern, 0)
-		gl.Uniform1i(b.shd.UseImage, 0)
 		return b.shd.Vertex, b.shd.TexCoord
 	}
 	if rg := style.RadialGradient; rg != nil {
@@ -342,10 +329,7 @@ func (b *GoGLBackend) useShader(style *backendbase.FillStyle, useAlpha bool, alp
 		gl.Uniform1f(b.shd.GlobalAlpha, float32(style.Color.A)/255)
 		gl.Uniform1i(b.shd.AlphaTex, alphaTexSlot)
 		gl.Uniform1i(b.shd.UseAlphaTex, alphaVal)
-		gl.Uniform1i(b.shd.UseLinearGradient, 0)
+		gl.Uniform1i(b.shd.Func, shdFuncRadialGradient)
-		gl.Uniform1i(b.shd.UseRadialGradient, 1)
-		gl.Uniform1i(b.shd.UseImagePattern, 0)
-		gl.Uniform1i(b.shd.UseImage, 0)
 		return b.shd.Vertex, b.shd.TexCoord
 	}
 	if ip := style.ImagePattern; ip != nil {
@@ -375,10 +359,7 @@ func (b *GoGLBackend) useShader(style *backendbase.FillStyle, useAlpha bool, alp
 		gl.Uniform1f(b.shd.GlobalAlpha, float32(style.Color.A)/255)
 		gl.Uniform1i(b.shd.AlphaTex, alphaTexSlot)
 		gl.Uniform1i(b.shd.UseAlphaTex, alphaVal)
-		gl.Uniform1i(b.shd.UseLinearGradient, 0)
+		gl.Uniform1i(b.shd.Func, shdFuncImagePattern)
-		gl.Uniform1i(b.shd.UseRadialGradient, 0)
-		gl.Uniform1i(b.shd.UseImagePattern, 1)
-		gl.Uniform1i(b.shd.UseImage, 0)
 		return b.shd.Vertex, b.shd.TexCoord
 	}
 
@@ -389,10 +370,7 @@ func (b *GoGLBackend) useShader(style *backendbase.FillStyle, useAlpha bool, alp
 	gl.Uniform1f(b.shd.GlobalAlpha, 1)
 	gl.Uniform1i(b.shd.AlphaTex, alphaTexSlot)
 	gl.Uniform1i(b.shd.UseAlphaTex, alphaVal)
-	gl.Uniform1i(b.shd.UseLinearGradient, 0)
+	gl.Uniform1i(b.shd.Func, shdFuncSolid)
-	gl.Uniform1i(b.shd.UseRadialGradient, 0)
-	gl.Uniform1i(b.shd.UseImagePattern, 0)
-	gl.Uniform1i(b.shd.UseImage, 0)
 	return b.shd.Vertex, b.shd.TexCoord
 }
 

backend/goglbackend/imagedata.go

@@ -90,10 +90,7 @@ func (b *GoGLBackend) PutImageData(img *image.RGBA, x, y int) {
 	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
 	gl.Uniform1f(b.shd.GlobalAlpha, 1)
 	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.UseLinearGradient, 0)
+	gl.Uniform1i(b.shd.Func, shdFuncImage)
-	gl.Uniform1i(b.shd.UseRadialGradient, 0)
-	gl.Uniform1i(b.shd.UseImagePattern, 0)
-	gl.Uniform1i(b.shd.UseImage, 1)
 	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
 	gl.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
 	gl.EnableVertexAttribArray(b.shd.Vertex)

backend/goglbackend/images.go

@@ -199,10 +199,7 @@ func (b *GoGLBackend) DrawImage(dimg backendbase.Image, sx, sy, sw, sh float64,
 	gl.Uniform2f(b.shd.CanvasSize, float32(b.fw), float32(b.fh))
 	gl.Uniform1f(b.shd.GlobalAlpha, float32(alpha))
 	gl.Uniform1i(b.shd.UseAlphaTex, 0)
-	gl.Uniform1i(b.shd.UseLinearGradient, 0)
+	gl.Uniform1i(b.shd.Func, shdFuncImage)
-	gl.Uniform1i(b.shd.UseRadialGradient, 0)
-	gl.Uniform1i(b.shd.UseImagePattern, 0)
-	gl.Uniform1i(b.shd.UseImage, 1)
 	gl.VertexAttribPointer(b.shd.Vertex, 2, gl.FLOAT, false, 0, nil)
 	gl.VertexAttribPointer(b.shd.TexCoord, 2, gl.FLOAT, false, 0, gl.PtrOffset(8*4))
 	gl.EnableVertexAttribArray(b.shd.Vertex)

backend/goglbackend/shaders.go

@@ -21,16 +21,15 @@ precision mediump float;
 
 varying vec2 v_cp, v_tc;
 
+uniform int func;
+
 uniform vec4 color;
 uniform float globalAlpha;
 
-uniform bool useLinearGradient;
-uniform bool useRadialGradient;
 uniform sampler2D gradient;
 uniform vec2 from, dir, to;
 uniform float len, radFrom, radTo;
 
-uniform bool useImagePattern;
 uniform vec2 imageSize;
 uniform sampler2D image;
 uniform mat3 imageTransform;
@@ -39,7 +38,9 @@ uniform vec2 repeat;
 uniform bool useAlphaTex;
 uniform sampler2D alphaTex;
 
-uniform bool useImage;
+uniform int boxSize;
+uniform bool boxVertical;
+uniform float boxScale;
 
 bool isNaN(float v) {
   return v < 0.0 || 0.0 < v || v == 0.0 ? false : true;
@@ -48,12 +49,29 @@ bool isNaN(float v) {
 void main() {
 	vec4 col = color;
 
-	if (useLinearGradient) {
+	if (func == 5) {
+		vec4 sum = vec4(0.0);
+		if (boxVertical) {
+			vec2 start = v_tc - vec2(0.0, (float)(boxSize) * boxScale);
+			for (int i=0; i<boxSize*2; i++) {
+				sum += texture2D(image, start + vec2(0.0, (float)(i) * boxScale));
+			}
+		} else {
+			vec2 start = v_tc - vec2((float)(boxSize) * boxScale, 0.0);
+			for (int i=0; i<boxSize*2; i++) {
+				sum += texture2D(image, start + vec2((float)(i) * boxScale, 0.0));
+			}
+		}
+		gl_FragColor = sum / float(boxSize * 2);
+		return;
+	}
+
+	if (func == 1) {
 		vec2 v = v_cp - from;
 		float r = dot(v, dir) / len;
 		r = clamp(r, 0.0, 1.0);
 		col = texture2D(gradient, vec2(r, 0.0));
-	} else if (useRadialGradient) {
+	} else if (func == 2) {
 		float o_a = 0.5 * sqrt(
 			pow(-2.0*from.x*from.x+2.0*from.x*to.x+2.0*from.x*v_cp.x-2.0*to.x*v_cp.x-2.0*from.y*from.y+2.0*from.y*to.y+2.0*from.y*v_cp.y-2.0*to.y*v_cp.y+2.0*radFrom*radFrom-2.0*radFrom*radTo, 2.0)
 			-4.0*(from.x*from.x-2.0*from.x*v_cp.x+v_cp.x*v_cp.x+from.y*from.y-2.0*from.y*v_cp.y+v_cp.y*v_cp.y-radFrom*radFrom)
@@ -70,7 +88,7 @@ void main() {
 		float o = max(o1, o2);
 		o = clamp(o, 0.0, 1.0);
 		col = texture2D(gradient, vec2(o, 0.0));
-	} else if (useImagePattern) {
+	} else if (func == 3) {
 		vec3 tfpt = vec3(v_cp, 1.0) * imageTransform;
 		vec2 imgpt = tfpt.xy / imageSize;
 		col = texture2D(image, mod(imgpt, 1.0));
@@ -80,7 +98,7 @@ void main() {
 		if (imgpt.y < 0.0 || imgpt.y > 1.0) {
 			col *= repeat.y;
 		}
-	} else if (useImage) {
+	} else if (func == 4) {
 		col = texture2D(image, v_tc);
 	}
 
@@ -94,52 +112,14 @@ void main() {
 }
 `
 
-var boxVS = `
+const (
-attribute vec2 vertex, texCoord;
+	shdFuncSolid int32 = iota
-
+	shdFuncLinearGradient
-uniform vec2 canvasSize;
+	shdFuncRadialGradient
-
+	shdFuncImagePattern
-varying vec2 v_cp, v_tc;
+	shdFuncImage
-
+	shdFuncBoxBlur
-void main() {
+)
-    v_tc = texCoord;
-	v_cp = vertex;
-	vec2 glp = vertex * 2.0 / canvasSize - 1.0;
-    gl_Position = vec4(glp.x, -glp.y, 0.0, 1.0);
-}
-`
-var boxFS = `
-#ifdef GL_ES
-precision mediump float;
-#endif
-
-varying vec2 v_cp, v_tc;
-
-uniform int boxSize;
-uniform bool boxVertical;
-uniform float boxScale;
-uniform sampler2D image;
-
-void main() {
-	vec4 color = vec4(0.0, 0.0, 0.0, 0.0);
-
-	vec4 sum = vec4(0.0);
-	if (boxVertical) {
-		vec2 start = v_tc - vec2(0.0, (float)(boxSize) * boxScale);
-		for (int i=0; i<boxSize*2; i++) {
-			sum += texture2D(image, start + vec2(0.0, (float)(i) * boxScale));
-		}
-	} else {
-		vec2 start = v_tc - vec2((float)(boxSize) * boxScale, 0.0);
-		for (int i=0; i<boxSize*2; i++) {
-			sum += texture2D(image, start + vec2((float)(i) * boxScale, 0.0));
-		}
-	}
-	color = sum / float(boxSize * 2);
-
-	gl_FragColor = color;
-}
-`
 
 type unifiedShader struct {
 	shaderProgram
@@ -151,32 +131,22 @@ type unifiedShader struct {
 	Color       int32
 	GlobalAlpha int32
 
+	Func int32
+
 	UseAlphaTex int32
 	AlphaTex    int32
 
-	UseLinearGradient int32
-	UseRadialGradient int32
 	Gradient       int32
 	From, To, Dir  int32
 	Len            int32
 	RadFrom, RadTo int32
 
-	UseImagePattern int32
 	ImageSize      int32
 	Image          int32
 	ImageTransform int32
 	Repeat         int32
 
-	UseImage int32
-}
-
-type boxBlurShader struct {
-	shaderProgram
-	Vertex      uint32
-	TexCoord    uint32
-	CanvasSize  int32
 	BoxSize     int32
 	BoxVertical int32
 	BoxScale    int32
-	Image       int32
 }