diff --git a/canvas.go b/canvas.go index aa61d01..3636c4b 100644 --- a/canvas.go +++ b/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) +} diff --git a/images.go b/images.go new file mode 100644 index 0000000..7fe97ab --- /dev/null +++ b/images.go @@ -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 } diff --git a/made_shaders.go b/made_shaders.go index 016439f..78ce9ec 100755 --- a/made_shaders.go +++ b/made_shaders.go @@ -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 +} diff --git a/opengl.go b/opengl.go index 3ab50d6..3194068 100644 --- a/opengl.go +++ b/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); +}`