added support for loading and drawing images
This commit is contained in:
Thomas Friedel
parent
47e34cc670
commit
6c0234959e
4 changed files with 310 additions and 0 deletions
45
canvas.go
45
canvas.go
|
|
@ -214,3 +214,48 @@ func (cv *Canvas) Fill() {
|
|||
|
||||
gli.DisableVertexAttribArray(sr.vertex)
|
||||
}
|
||||
|
||||
func (cv *Canvas) DrawImage(img *Image, coords ...float32) {
|
||||
var sx, sy, sw, sh, dx, dy, dw, dh float32
|
||||
sw, sh = float32(img.w), float32(img.h)
|
||||
dw, dh = float32(img.w), float32(img.h)
|
||||
if len(coords) == 2 {
|
||||
dx, dy = coords[0], coords[1]
|
||||
} else if len(coords) == 4 {
|
||||
dx, dy = coords[0], coords[1]
|
||||
dw, dh = coords[2], coords[3]
|
||||
} else if len(coords) == 8 {
|
||||
sx, sy = coords[0], coords[1]
|
||||
sw, sh = coords[2], coords[3]
|
||||
dx, dy = coords[4], coords[5]
|
||||
dw, dh = coords[6], coords[7]
|
||||
}
|
||||
|
||||
dx0, dy0 := cv.ptToGL(dx, dy)
|
||||
dx1, dy1 := cv.ptToGL(dx+dw, dy+dh)
|
||||
sx /= float32(img.w)
|
||||
sy /= float32(img.h)
|
||||
sw /= float32(img.w)
|
||||
sh /= float32(img.h)
|
||||
|
||||
cv.activate()
|
||||
|
||||
gli.UseProgram(tr.id)
|
||||
|
||||
gli.ActiveTexture(gl_TEXTURE0)
|
||||
gli.BindTexture(gl_TEXTURE_2D, img.tex)
|
||||
gli.Uniform1i(tr.image, 0)
|
||||
|
||||
gli.BindBuffer(gl_ARRAY_BUFFER, buf)
|
||||
data := [16]float32{dx0, dy0, dx0, dy1, dx1, dy1, dx1, dy0,
|
||||
sx, sy, sx, sy + sh, sx + sw, sy + sh, sx + sw, sy}
|
||||
gli.BufferData(gl_ARRAY_BUFFER, len(data)*4, unsafe.Pointer(&data[0]), gl_STREAM_DRAW)
|
||||
|
||||
gli.VertexAttribPointer(tr.vertex, 2, gl_FLOAT, false, 0, nil)
|
||||
gli.VertexAttribPointer(tr.texCoord, 2, gl_FLOAT, false, 0, gli.PtrOffset(8*4))
|
||||
gli.EnableVertexAttribArray(tr.vertex)
|
||||
gli.EnableVertexAttribArray(tr.texCoord)
|
||||
gli.DrawArrays(gl_TRIANGLE_FAN, 0, 4)
|
||||
gli.DisableVertexAttribArray(tr.vertex)
|
||||
gli.DisableVertexAttribArray(tr.texCoord)
|
||||
}
|
||||
|
|
|
|||
139
images.go
Normal file
139
images.go
Normal file
|
|
@ -0,0 +1,139 @@
|
|||
package canvas
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"image"
|
||||
"io/ioutil"
|
||||
)
|
||||
|
||||
type Image struct {
|
||||
w, h int
|
||||
tex uint32
|
||||
}
|
||||
|
||||
func LoadImage(src interface{}) (*Image, error) {
|
||||
switch v := src.(type) {
|
||||
case *image.RGBA:
|
||||
return loadImageRGBA(v)
|
||||
case *image.Gray:
|
||||
return loadImageGray(v)
|
||||
case image.Image:
|
||||
return loadImageConverted(v)
|
||||
case string:
|
||||
data, err := ioutil.ReadFile(v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
img, _, err := image.Decode(bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return LoadImage(img)
|
||||
case []byte:
|
||||
img, _, err := image.Decode(bytes.NewReader(v))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return LoadImage(img)
|
||||
}
|
||||
return nil, errors.New("Unsupported source type")
|
||||
}
|
||||
|
||||
func loadImageRGBA(src *image.RGBA) (*Image, error) {
|
||||
img := &Image{w: src.Bounds().Dx(), h: src.Bounds().Dy()}
|
||||
gli.GenTextures(1, &img.tex)
|
||||
gli.BindTexture(gl_TEXTURE_2D, img.tex)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MIN_FILTER, gl_LINEAR_MIPMAP_LINEAR)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, gl_LINEAR)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_S, gl_CLAMP_TO_EDGE)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_T, gl_CLAMP_TO_EDGE)
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if src.Stride == img.w*4 {
|
||||
gli.TexImage2D(gl_TEXTURE_2D, 0, gl_RGBA, int32(img.w), int32(img.h), 0, gl_RGBA, gl_UNSIGNED_BYTE, gli.Ptr(&src.Pix[0]))
|
||||
} else {
|
||||
data := make([]uint8, 0, img.w*img.h*4)
|
||||
for y := 0; y < img.h; y++ {
|
||||
start := y * src.Stride
|
||||
end := start + img.w*4
|
||||
data = append(data, src.Pix[start:end]...)
|
||||
}
|
||||
gli.TexImage2D(gl_TEXTURE_2D, 0, gl_RGBA, int32(img.w), int32(img.h), 0, gl_RGBA, gl_UNSIGNED_BYTE, gli.Ptr(&data[0]))
|
||||
}
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
gli.GenerateMipmap(gl_TEXTURE_2D)
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return img, nil
|
||||
}
|
||||
|
||||
func loadImageGray(src *image.Gray) (*Image, error) {
|
||||
img := &Image{w: src.Bounds().Dx(), h: src.Bounds().Dy()}
|
||||
gli.GenTextures(1, &img.tex)
|
||||
gli.BindTexture(gl_TEXTURE_2D, img.tex)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MIN_FILTER, gl_LINEAR_MIPMAP_LINEAR)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, gl_LINEAR)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_S, gl_CLAMP_TO_EDGE)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_T, gl_CLAMP_TO_EDGE)
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if src.Stride == img.w {
|
||||
gli.TexImage2D(gl_TEXTURE_2D, 0, gl_RED, int32(img.w), int32(img.h), 0, gl_RED, gl_UNSIGNED_BYTE, gli.Ptr(&src.Pix[0]))
|
||||
} else {
|
||||
data := make([]uint8, 0, img.w*img.h)
|
||||
for y := 0; y < img.h; y++ {
|
||||
start := y * src.Stride
|
||||
end := start + img.w
|
||||
data = append(data, src.Pix[start:end]...)
|
||||
}
|
||||
gli.TexImage2D(gl_TEXTURE_2D, 0, gl_RED, int32(img.w), int32(img.h), 0, gl_RED, gl_UNSIGNED_BYTE, gli.Ptr(&data[0]))
|
||||
}
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
gli.GenerateMipmap(gl_TEXTURE_2D)
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return img, nil
|
||||
}
|
||||
|
||||
func loadImageConverted(src image.Image) (*Image, error) {
|
||||
img := &Image{w: src.Bounds().Dx(), h: src.Bounds().Dy()}
|
||||
gli.GenTextures(1, &img.tex)
|
||||
gli.BindTexture(gl_TEXTURE_2D, img.tex)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MIN_FILTER, gl_LINEAR_MIPMAP_LINEAR)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, gl_LINEAR)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_S, gl_CLAMP_TO_EDGE)
|
||||
gli.TexParameteri(gl_TEXTURE_2D, gl_TEXTURE_WRAP_T, gl_CLAMP_TO_EDGE)
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
data := make([]uint8, 0, img.w*img.h*4)
|
||||
for y := 0; y < img.h; y++ {
|
||||
for x := 0; x < img.w; x++ {
|
||||
ir, ig, ib, ia := src.At(x, y).RGBA()
|
||||
r, g, b, a := uint8(ir>>8), uint8(ig>>8), uint8(ib>>8), uint8(ia>>8)
|
||||
data = append(data, r, g, b, a)
|
||||
}
|
||||
}
|
||||
gli.TexImage2D(gl_TEXTURE_2D, 0, gl_RGBA, int32(img.w), int32(img.h), 0, gl_RGBA, gl_UNSIGNED_BYTE, gli.Ptr(&data[0]))
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
gli.GenerateMipmap(gl_TEXTURE_2D)
|
||||
if err := glError(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return img, nil
|
||||
}
|
||||
|
||||
func (img *Image) W() int { return img.w }
|
||||
func (img *Image) H() int { return img.h }
|
||||
func (img *Image) Size() (int, int) { return img.w, img.h }
|
||||
|
|
@ -102,3 +102,102 @@ func loadSolidShader() (*solidShader, error) {
|
|||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
type textureShader struct {
|
||||
id uint32
|
||||
vertex uint32
|
||||
texCoord uint32
|
||||
image int32
|
||||
}
|
||||
|
||||
func loadTextureShader() (*textureShader, error) {
|
||||
var vs, fs, program uint32
|
||||
|
||||
{
|
||||
csource, freeFunc := gli.Strs(textureVS + "\x00")
|
||||
defer freeFunc()
|
||||
|
||||
vs = gli.CreateShader(gl_VERTEX_SHADER)
|
||||
gli.ShaderSource(vs, 1, csource, nil)
|
||||
gli.CompileShader(vs)
|
||||
|
||||
var logLength int32
|
||||
gli.GetShaderiv(vs, gl_INFO_LOG_LENGTH, &logLength)
|
||||
if logLength > 0 {
|
||||
shLog := strings.Repeat("\x00", int(logLength+1))
|
||||
gli.GetShaderInfoLog(vs, logLength, nil, gli.Str(shLog))
|
||||
fmt.Printf("VERTEX_SHADER compilation log:\n\n%s\n", shLog)
|
||||
}
|
||||
|
||||
var status int32
|
||||
gli.GetShaderiv(vs, gl_COMPILE_STATUS, &status)
|
||||
if status != gl_TRUE {
|
||||
gli.DeleteShader(vs)
|
||||
return nil, errors.New("Error compiling GL_VERTEX_SHADER shader part")
|
||||
}
|
||||
if glErr := gli.GetError(); glErr != gl_NO_ERROR {
|
||||
return nil, errors.New("error compiling shader part, glError: " + fmt.Sprint(glErr))
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
csource, freeFunc := gli.Strs(textureFS + "\x00")
|
||||
defer freeFunc()
|
||||
|
||||
fs = gli.CreateShader(gl_FRAGMENT_SHADER)
|
||||
gli.ShaderSource(fs, 1, csource, nil)
|
||||
gli.CompileShader(fs)
|
||||
|
||||
var logLength int32
|
||||
gli.GetShaderiv(fs, gl_INFO_LOG_LENGTH, &logLength)
|
||||
if logLength > 0 {
|
||||
shLog := strings.Repeat("\x00", int(logLength+1))
|
||||
gli.GetShaderInfoLog(fs, logLength, nil, gli.Str(shLog))
|
||||
fmt.Printf("FRAGMENT_SHADER compilation log:\n\n%s\n", shLog)
|
||||
}
|
||||
|
||||
var status int32
|
||||
gli.GetShaderiv(fs, gl_COMPILE_STATUS, &status)
|
||||
if status != gl_TRUE {
|
||||
gli.DeleteShader(fs)
|
||||
return nil, errors.New("Error compiling GL_FRAGMENT_SHADER shader part")
|
||||
}
|
||||
if glErr := gli.GetError(); glErr != gl_NO_ERROR {
|
||||
return nil, errors.New("error compiling shader part, glError: " + fmt.Sprint(glErr))
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
program = gli.CreateProgram()
|
||||
gli.AttachShader(program, vs)
|
||||
gli.AttachShader(program, fs)
|
||||
gli.LinkProgram(program)
|
||||
|
||||
var logLength int32
|
||||
gli.GetProgramiv(program, gl_INFO_LOG_LENGTH, &logLength)
|
||||
if logLength > 0 {
|
||||
shLog := strings.Repeat("\x00", int(logLength+1))
|
||||
gli.GetProgramInfoLog(program, logLength, nil, gli.Str(shLog))
|
||||
fmt.Printf("Shader link log:\n\n%s\n", shLog)
|
||||
}
|
||||
|
||||
var status int32
|
||||
gli.GetProgramiv(program, gl_LINK_STATUS, &status)
|
||||
if status != gl_TRUE {
|
||||
gli.DeleteShader(vs)
|
||||
gli.DeleteShader(fs)
|
||||
return nil, errors.New("error linking shader")
|
||||
}
|
||||
if glErr := gli.GetError(); glErr != gl_NO_ERROR {
|
||||
return nil, errors.New("error linking shader, glError: " + fmt.Sprint(glErr))
|
||||
}
|
||||
}
|
||||
|
||||
result := &textureShader{}
|
||||
result.id = program
|
||||
result.vertex = uint32(gli.GetAttribLocation(program, gli.Str("vertex\x00")))
|
||||
result.texCoord = uint32(gli.GetAttribLocation(program, gli.Str("texCoord\x00")))
|
||||
result.image = gli.GetUniformLocation(program, gli.Str("image\x00"))
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
|
|
|||
27
opengl.go
27
opengl.go
|
|
@ -20,6 +20,7 @@ func glError() error {
|
|||
var (
|
||||
buf uint32
|
||||
sr *solidShader
|
||||
tr *textureShader
|
||||
)
|
||||
|
||||
func LoadGL(glimpl GL) (err error) {
|
||||
|
|
@ -36,6 +37,15 @@ func LoadGL(glimpl GL) (err error) {
|
|||
return
|
||||
}
|
||||
|
||||
tr, err = loadTextureShader()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
err = glError()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
gli.GenBuffers(1, &buf)
|
||||
err = glError()
|
||||
if err != nil {
|
||||
|
|
@ -61,3 +71,20 @@ uniform vec4 color;
|
|||
void main() {
|
||||
gl_FragColor = color;
|
||||
}`
|
||||
|
||||
var textureVS = `
|
||||
attribute vec2 vertex, texCoord;
|
||||
varying vec2 v_texCoord;
|
||||
void main() {
|
||||
v_texCoord = texCoord;
|
||||
gl_Position = vec4(vertex, 0.0, 1.0);
|
||||
}`
|
||||
var textureFS = `
|
||||
#ifdef GL_ES
|
||||
precision mediump float;
|
||||
#endif
|
||||
varying vec2 v_texCoord;
|
||||
uniform sampler2D image;
|
||||
void main() {
|
||||
gl_FragColor = texture2D(image, v_texCoord);
|
||||
}`
|
||||
|
|
|
|||
Loading…
Reference in a new issue