Add GL blender (#100)

* Add GL blender
* Add Width() and Height() to AcceleratedImage
* Add test verifying if Modify overrides pixels modified in RAM
* Disable checkptr in tests
* Add usage to FloatVertexBuffer
* Make Color pre-multiplied

Author: elgopher

Makefile

@@ -3,7 +3,7 @@ lint:
 	golangci-lint run -E goimports,unconvert,misspell,maligned,gocyclo,gocritic,gochecknoinits
 
 test:
-	go test -race -v ./...
+	go test -race -v -gcflags=all=-d=checkptr=0 ./...
 
 xvfb-test:
 	xvfb-run go test -race -v ./...

examples/image/modify/opengl/draw/main.go

@@ -49,7 +49,7 @@ func makeVertexBuffer(context *gl.Context) *gl.FloatVertexBuffer {
 		1, -1, 0, 0, 1, // bottom-right -> blue
 		-1, -1, 1, 1, 1, // bottom-left -> white
 	}
-	buffer := context.NewFloatVertexBuffer(len(vertices))
+	buffer := context.NewFloatVertexBuffer(len(vertices), gl.StaticDraw)
 	buffer.Upload(0, vertices)
 	return buffer
 }

examples/image/modify/opengl/selection/main.go

@@ -46,15 +46,15 @@ func makeVertexArray(context *gl.Context, buffer *gl.FloatVertexBuffer) *gl.Vert
 	return array
 }
 
-func makeVertexBuffer(gl *gl.Context) *gl.FloatVertexBuffer {
+func makeVertexBuffer(ctx *gl.Context) *gl.FloatVertexBuffer {
 	// xy -> st
 	vertices := []float32{
 		-1, 1, 0, 1, // top-left
 		1, 1, 1, 1, // top-right
 		1, -1, 1, 0, // bottom-right
 		-1, -1, 0, 0, // bottom-left
 	}
-	buffer := gl.NewFloatVertexBuffer(len(vertices))
+	buffer := ctx.NewFloatVertexBuffer(len(vertices), gl.StaticDraw)
 	buffer.Upload(0, vertices)
 	return buffer
 }

examples/tools/blend/blend.go

@@ -7,6 +7,7 @@ import (
 	"github.com/jacekolszak/pixiq/loop"
 	"github.com/jacekolszak/pixiq/tools/blend"
 	"github.com/jacekolszak/pixiq/tools/clear"
+	"github.com/jacekolszak/pixiq/tools/glblend"
 )
 
 func main() {
@@ -19,7 +20,15 @@ func main() {
 		face := face(gl)
 
 		sourceBlender := blend.NewSource()
+		glSourceBlender, err := glblend.NewSource(gl.Context())
+		if err != nil {
+			panic(err)
+		}
 		sourceOverBlender := blend.NewSourceOver()
+		glSourceOverBlender, err := glblend.NewSourceOver(gl.Context())
+		if err != nil {
+			panic(err)
+		}
 
 		clearTool := clear.New()
 		clearTool.SetColor(colornames.Aliceblue)
@@ -31,11 +40,18 @@ func main() {
 
 			// source blending overrides the target with source colors
 			// fully transparent pixels (RGBA 0x00000000) are rendered as black on the screen.
-			sourceBlender.BlendSourceToTarget(face, screen.Selection(15, 7))
+			sourceBlender.BlendSourceToTarget(face, screen.Selection(10, 7))
+
+			// similar source blending using video card
+			glSourceBlender.BlendSourceToTarget(face, screen.Selection(20, 7))
+
 			// source-over blending mixes source and target colors together taking
 			// into account alpha channels of both. In places where source has
 			// transparent pixels the original target colors are preserved.
-			sourceOverBlender.BlendSourceToTarget(face, screen.Selection(15, 24))
+			sourceOverBlender.BlendSourceToTarget(face, screen.Selection(10, 24))
+
+			// similar source-over blending using video card
+			glSourceOverBlender.BlendSourceToTarget(face, screen.Selection(20, 24))
 
 			if window.ShouldClose() {
 				frame.StopLoopEventually()

gl/api.go

@@ -114,6 +114,8 @@ type API interface {
 	GetError() uint32
 	// ReadPixels reads a block of pixels from the frame buffer
 	ReadPixels(x int32, y int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer)
+	// BlendFunc specifies pixel arithmetic
+	BlendFunc(sfactor uint32, dfactor uint32)
 	// Finish blocks until all GL execution is complete
 	Finish()
 	// Ptr takes a slice or pointer (to a singular scalar value or the first

gl/command.go

@@ -13,11 +13,20 @@ type Command interface {
 	RunGL(renderer *Renderer, selections []image.AcceleratedImageSelection)
 }
 
-// Renderer is an API for drawing primitives
+// Renderer is an API for drawing primitives.
+//
+// It is using blending with formula:
+//   R = S*sf + D*df
+// where S is source color component, sf is a source factor, D is destination color
+// component, df is a destination factor.
+// By default sf is 1 and df is 0 (gl.SourceBlendFactors), which means that formula is
+//   R = S
+// BlendFactors can be changed by calling SetBlendFactors method.
 type Renderer struct {
-	program   *Program
-	api       API
-	allImages allImages
+	program      *Program
+	api          API
+	allImages    allImages
+	blendFactors BlendFactors
 }
 
 // BindTexture assigns image.AcceleratedImage to a given textureUnit and uniform attribute.
@@ -146,12 +155,48 @@ var (
 	Triangles = Mode{glMode: triangles}
 )
 
+// BlendFactor is source or destination factor
+type BlendFactor uint32
+
+const (
+	// Zero is GL_ZERO. Multiplies all components by 0.
+	Zero = BlendFactor(0)
+	// One is GL_ONE. Multiplies all components by 1.
+	One = BlendFactor(1)
+	// OneMinusSrcAlpha is GL_ONE_MINUS_SRC_ALPHA. Multiplies all components by 1 minus
+	// the source alpha value.
+	OneMinusSrcAlpha = BlendFactor(0x0303)
+	// SrcAlpha is GL_SRC_ALPHA. Multiplies all components by the source alpha value.
+	SrcAlpha = BlendFactor(0x0302)
+	// DstAlpha is GL_DST_ALPHA. Multiplies all components by the destination alpha value.
+	DstAlpha = BlendFactor(0x0304)
+	// OneMinusDstAlpha is GL_ONE_MINUS_DST_ALPHA. Multiplies all components by 1 minus
+	// the destination alpha value.
+	OneMinusDstAlpha = BlendFactor(0x0305)
+)
+
+// BlendFactors contains source and destination factors used by blending formula
+// R = S*sf + D*df
+type BlendFactors struct {
+	SrcFactor, DstFactor BlendFactor
+}
+
+// SourceBlendFactors is default BlendFactors used by AcceleratedCommand.
+var SourceBlendFactors = BlendFactors{SrcFactor: One, DstFactor: Zero}
+
+// SetBlendFactors sets source and dest factors for blending formula:
+// R = S*sf + D*df
+func (r *Renderer) SetBlendFactors(factors BlendFactors) {
+	r.blendFactors = factors
+}
+
 // DrawArrays draws primitives (such as triangles) using vertices defined in VertexArray.
 //
 // Before primitive is drawn this method validates if
 func (r *Renderer) DrawArrays(array *VertexArray, mode Mode, first, count int) {
 	r.validateAttributeTypes(array)
 	r.api.BindVertexArray(array.id)
+	r.api.BlendFunc(uint32(r.blendFactors.SrcFactor), uint32(r.blendFactors.DstFactor))
 	r.api.DrawArrays(mode.glMode, int32(first), int32(count))
 }
 
@@ -216,32 +261,27 @@ func (c *AcceleratedCommand) Run(output image.AcceleratedImageSelection, selecti
 	y := int32(loc.Y)
 	w := int32(loc.Width)
 	h := int32(loc.Height)
-	if x < 0 {
-		w += x
-		x = 0
-	}
 	if x+w > int32(img.width) {
 		w = int32(img.width) - x
 	}
-	if y < 0 {
-		h += y
-		y = 0
-	}
 	if y+h > int32(img.height) {
 		h = int32(img.height) - y
 	}
 	y = int32(img.height) - h - y
 
 	c.program.use()
 	c.api.Enable(scissorTest)
+	c.api.Enable(blend)
 	c.api.BindFramebuffer(framebuffer, img.frameBufferID)
 	c.api.Scissor(x, y, w, h)
 	c.api.Viewport(x, y, w, h)
 
 	renderer := &Renderer{
-		program:   c.program,
-		api:       c.api,
-		allImages: c.allImages,
+		program:      c.program,
+		api:          c.api,
+		allImages:    c.allImages,
+		blendFactors: SourceBlendFactors,
 	}
+
 	c.command.RunGL(renderer, selections)
 }

gl/consts.go

@@ -3,7 +3,9 @@ package gl
 // Camel-cased GL constants
 const (
 	arrayBuffer              = 0x8892
+	streamDraw               = 0x88E0
 	staticDraw               = 0x88E4
+	dynamicDraw              = 0x88E8
 	float                    = 0x1406
 	floatVec2                = 0x8B50
 	floatVec3                = 0x8B51
@@ -37,6 +39,10 @@ const (
 	textureMinFilter         = 0x2801
 	textureMagFilter         = 0x2800
 	nearest                  = 0x2600
+	textureWrapS             = 0x2802
+	textureWrapT             = 0x2803
+	clampToBorder            = 0x812D
 	noError                  = 0
 	outOfMemory              = 0x0505
+	blend                    = 0x0BE2
 )

gl/context.go

@@ -66,15 +66,38 @@ func (c *Context) Error() error {
 	return glError(code)
 }
 
-// NewFloatVertexBuffer creates an OpenGL's Vertex Buffer Object (VBO) containing only float32 numbers.
-func (c *Context) NewFloatVertexBuffer(size int) *FloatVertexBuffer {
+// Usage defines how Vertex Buffer will be used. This is a hint for OpenGL implementation.
+type Usage struct {
+	glUsage uint32
+}
+
+var (
+	// StreamDraw tells OpenGL implementation that vertex buffer will be modified once
+	// and used at most a few times.
+	// Vertex Buffer is modified by the application, and used as the source
+	// for GL drawing and image specification commands.
+	StreamDraw = Usage{glUsage: streamDraw}
+	// StaticDraw tells OpenGL implementation that vertex buffer will be modified once
+	// and used many times.
+	// Vertex Buffer is modified by the application, and used as the source
+	// for GL drawing and image specification commands.
+	StaticDraw = Usage{glUsage: staticDraw}
+	// DynamicDraw tells OpenGL implementation that vertex buffer will be modified
+	// repeatedly and used many times.
+	// Vertex Buffer is modified by the application, and used as the source
+	// for GL drawing and image specification commands.
+	DynamicDraw = Usage{glUsage: dynamicDraw}
+)
+
+// NewFloatVertexBuffer creates an OpenGL's Vertex Buffer Object (VBO) containing only float32 numb)ers.
+func (c *Context) NewFloatVertexBuffer(size int, usage Usage) *FloatVertexBuffer {
 	if size < 0 {
 		panic("negative size")
 	}
 	var id uint32
 	c.api.GenBuffers(1, &id)
 	c.api.BindBuffer(arrayBuffer, id)
-	c.api.BufferData(arrayBuffer, size*4, c.api.Ptr(nil), staticDraw) // FIXME: Parametrize usage
+	c.api.BufferData(arrayBuffer, size*4, c.api.Ptr(nil), usage.glUsage)
 	vb := &FloatVertexBuffer{
 		id:   id,
 		size: size,

gl/gl_test.go

@@ -43,7 +43,7 @@ func TestContext_NewFloatVertexBuffer(t *testing.T) {
 				context := gl.NewContext(apiStub{})
 				// when
 				assert.Panics(t, func() {
-					context.NewFloatVertexBuffer(size)
+					context.NewFloatVertexBuffer(size, gl.StaticDraw)
 				})
 			})
 		}
@@ -57,7 +57,7 @@ func TestContext_NewFloatVertexBuffer(t *testing.T) {
 			t.Run(name, func(t *testing.T) {
 				context := gl.NewContext(apiStub{})
 				// when
-				buffer := context.NewFloatVertexBuffer(size)
+				buffer := context.NewFloatVertexBuffer(size, gl.StaticDraw)
 				// then
 				assert.NotNil(t, buffer)
 				// and
@@ -94,7 +94,7 @@ func TestFloatVertexBuffer_Upload(t *testing.T) {
 		for name, test := range tests {
 			t.Run(name, func(t *testing.T) {
 				context := gl.NewContext(apiStub{})
-				buffer := context.NewFloatVertexBuffer(test.size)
+				buffer := context.NewFloatVertexBuffer(test.size, gl.StaticDraw)
 				assert.Panics(t, func() {
 					// when
 					buffer.Upload(test.offset, test.data)
@@ -104,7 +104,7 @@ func TestFloatVertexBuffer_Upload(t *testing.T) {
 	})
 	t.Run("should panic when offset is negative", func(t *testing.T) {
 		context := gl.NewContext(apiStub{})
-		buffer := context.NewFloatVertexBuffer(1)
+		buffer := context.NewFloatVertexBuffer(1, gl.StaticDraw)
 		assert.Panics(t, func() {
 			// when
 			buffer.Upload(-1, []float32{1})
@@ -115,7 +115,7 @@ func TestFloatVertexBuffer_Upload(t *testing.T) {
 func TestFloatVertexBuffer_Download(t *testing.T) {
 	t.Run("should panic when offset is negative", func(t *testing.T) {
 		context := gl.NewContext(apiStub{})
-		buffer := context.NewFloatVertexBuffer(1)
+		buffer := context.NewFloatVertexBuffer(1, gl.StaticDraw)
 		defer buffer.Delete()
 		output := make([]float32, 1)
 		assert.Panics(t, func() {
@@ -125,7 +125,7 @@ func TestFloatVertexBuffer_Download(t *testing.T) {
 	})
 	t.Run("should panic when buffer has been deleted", func(t *testing.T) {
 		context := gl.NewContext(apiStub{})
-		buffer := context.NewFloatVertexBuffer(1)
+		buffer := context.NewFloatVertexBuffer(1, gl.StaticDraw)
 		buffer.Delete()
 		output := make([]float32, 1)
 		// when
@@ -167,7 +167,7 @@ func TestVertexArray_Set(t *testing.T) {
 		context := gl.NewContext(apiStub{})
 		vao := context.NewVertexArray(gl.VertexLayout{gl.Float})
 		defer vao.Delete()
-		buffer := context.NewFloatVertexBuffer(1)
+		buffer := context.NewFloatVertexBuffer(1, gl.StaticDraw)
 		pointer := gl.VertexBufferPointer{
 			Buffer: buffer,
 			Offset: -1,
@@ -181,7 +181,7 @@ func TestVertexArray_Set(t *testing.T) {
 	t.Run("should panic when stride is negative", func(t *testing.T) {
 		context := gl.NewContext(apiStub{})
 		vao := context.NewVertexArray(gl.VertexLayout{gl.Float})
-		buffer := context.NewFloatVertexBuffer(1)
+		buffer := context.NewFloatVertexBuffer(1, gl.StaticDraw)
 		pointer := gl.VertexBufferPointer{
 			Buffer: buffer,
 			Offset: 0,
@@ -195,7 +195,7 @@ func TestVertexArray_Set(t *testing.T) {
 	t.Run("should panic when location is negative", func(t *testing.T) {
 		context := gl.NewContext(apiStub{})
 		vao := context.NewVertexArray(gl.VertexLayout{gl.Float})
-		buffer := context.NewFloatVertexBuffer(1)
+		buffer := context.NewFloatVertexBuffer(1, gl.StaticDraw)
 		pointer := gl.VertexBufferPointer{
 			Buffer: buffer,
 			Offset: 0,
@@ -209,7 +209,7 @@ func TestVertexArray_Set(t *testing.T) {
 	t.Run("should panic when location is higher than number of arguments", func(t *testing.T) {
 		context := gl.NewContext(apiStub{})
 		vao := context.NewVertexArray(gl.VertexLayout{gl.Float})
-		buffer := context.NewFloatVertexBuffer(1)
+		buffer := context.NewFloatVertexBuffer(1, gl.StaticDraw)
 		pointer := gl.VertexBufferPointer{
 			Buffer: buffer,
 			Offset: 0,
@@ -298,6 +298,14 @@ func TestContext_NewAcceleratedImage(t *testing.T) {
 			context.NewAcceleratedImage(1, capabilities.MaxTextureSize()+1)
 		})
 	})
+	t.Run("should create AcceleratedImage", func(t *testing.T) {
+		context := gl.NewContext(apiStub{})
+		// when
+		img := context.NewAcceleratedImage(4, 2)
+		// then
+		assert.Equal(t, 4, img.Width())
+		assert.Equal(t, 2, img.Height())
+	})
 }
 func TestProgram_AcceleratedCommand(t *testing.T) {
 	t.Run("should return command", func(t *testing.T) {
@@ -539,6 +547,7 @@ func (a apiStub) GetTexImage(target uint32, level int32, format uint32, xtype ui
 func (a apiStub) GetError() uint32 { return 0 }
 func (a apiStub) ReadPixels(x int32, y int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) {
 }
-func (a apiStub) Finish()                             {}
-func (a apiStub) Ptr(data interface{}) unsafe.Pointer { return nil }
-func (a apiStub) PtrOffset(offset int) unsafe.Pointer { return nil }
+func (a apiStub) BlendFunc(sfactor uint32, dfactor uint32) {}
+func (a apiStub) Finish()                                  {}
+func (a apiStub) Ptr(data interface{}) unsafe.Pointer      { return nil }
+func (a apiStub) PtrOffset(offset int) unsafe.Pointer      { return nil }