main.go

package main

import (
    "fmt"
    "github.com/go-gl/gl/v4.1-core/gl"
    "github.com/go-gl/glfw/v3.2/glfw"
    "image"
    _ "image/png"
    "io/ioutil"
    "log"
    "os"
    "runtime"
    "strings"
)

const (
    vertexShaderSource   = "vertex.glsl"
    fragmentShaderSource = "fragment.glsl"
)

var (
    g_winWidth        = 400
    g_winHeight       = 400
    g_winTitle        = "test"
    g_textureFileName = "d.png"

    g_vertices = []float32{
        //x  y    z texture x y
        0.5, 0.5, 0, 1, 0,
        0.5, -0.5, 0, 1, 1,
        -0.5, -0.5, 0, 0, 1,
        -0.5, 0.5, 0, 0, 0,
    }
    g_indeces = []uint32{
        0, 1, 3,
        1, 2, 3,
    }
)

func main() {
    runtime.LockOSThread()
    window := initGLFW(g_winWidth, g_winHeight, g_winTitle)
    defer glfw.Terminate()
    glProgram := initGL()
    texture, err := loadTexture(g_textureFileName)
    log.Println(texture)
    vao := makeVao(g_vertices, g_indeces)
    if err != nil {
        panic(err)
    }
    for !window.ShouldClose() {
        gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
        gl.UseProgram(glProgram)

        gl.BindTexture(gl.TEXTURE_2D, texture)
        gl.BindVertexArray(vao)
        gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, nil)
        gl.BindVertexArray(0)

        glfw.PollEvents()
        window.SwapBuffers()
    }

}

func loadTexture(filename string) (uint32, error) {
    file, err := os.Open(filename)
    if err != nil {
        return 0, err
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        return 0, err
    }
    bounds := img.Bounds()
    width := bounds.Max.X - bounds.Min.X
    height := bounds.Max.Y - bounds.Min.Y

    var binImg []uint8
    for y := bounds.Min.Y; y <= bounds.Max.Y; y++ {
        for x := bounds.Min.X; x <= bounds.Max.X; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            binImg = append(binImg, uint8(r/256))
            binImg = append(binImg, uint8(g/256))
            binImg = append(binImg, uint8(b/256))
            binImg = append(binImg, uint8(a/256))
        }
    }

    var texture uint32
    gl.GenTextures(1, &texture)
    gl.BindTexture(gl.TEXTURE_2D, texture)
    gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(width), int32(height), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(binImg))
    gl.GenerateMipmap(gl.TEXTURE_2D)
    gl.BindTexture(gl.TEXTURE_2D, 0)
    return texture, nil
}

func makeVao(va []float32, vi []uint32) uint32 {
    var vao, vbo, ebo uint32
    gl.GenVertexArrays(1, &vao)
    gl.GenBuffers(1, &vbo)
    gl.GenBuffers(1, &ebo)

    gl.BindVertexArray(vao)

    gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
    gl.BufferData(gl.ARRAY_BUFFER, 4*len(va), gl.Ptr(va), gl.STATIC_DRAW)
    gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo)
    gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, 4*len(vi), gl.Ptr(vi), gl.STATIC_DRAW)
    gl.VertexAttribPointer(0, 3, gl.FLOAT, false, int32(5*4), nil)
    gl.VertexAttribPointer(1, 2, gl.FLOAT, false, int32(5*4), gl.PtrOffset(3*4))
    gl.EnableVertexAttribArray(0)
    gl.EnableVertexAttribArray(1)

    gl.BindBuffer(gl.ARRAY_BUFFER, 0)

    gl.BindVertexArray(0)
    return vao
}

func initGLFW(width, height int, title string) *glfw.Window {
    if err := glfw.Init(); err != nil {
        panic(err)
    }
    glfw.WindowHint(glfw.Resizable, glfw.False)
    glfw.WindowHint(glfw.ContextVersionMajor, 4)
    glfw.WindowHint(glfw.ContextVersionMinor, 1)
    glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
    glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)

    window, err := glfw.CreateWindow(width, height, title, nil, nil)
    if err != nil {
        panic(err)
    }
    window.MakeContextCurrent()
    return window
}

func initGL() uint32 {
    if err := gl.Init(); err != nil {
        panic(err)
    }

    vertexShader, err := compileShader(vertexShaderSource, gl.VERTEX_SHADER)
    if err != nil {
        panic(err)
    }
    defer gl.DeleteShader(vertexShader)

    fragmentShader, err := compileShader(fragmentShaderSource,
        gl.FRAGMENT_SHADER)
    if err != nil {
        panic(err)
    }
    defer gl.DeleteShader(fragmentShader)

    version := gl.GoStr(gl.GetString(gl.VERSION))
    log.Println("OpenGL version" + version)
    prog := gl.CreateProgram()
    gl.AttachShader(prog, vertexShader)
    gl.AttachShader(prog, fragmentShader)
    gl.LinkProgram(prog)
    var status int32
    gl.GetProgramiv(prog, gl.LINK_STATUS, &status)
    if status == gl.FALSE {
        log.Println("failed to link")
    }
    return prog
}

func compileShader(shaderSourceFile string, shaderType uint32) (uint32,
    error) {
    source, err := ioutil.ReadFile(shaderSourceFile)
    if err != nil {
        panic(err)
    }
    source = append(source, byte(0))
    shader := gl.CreateShader(shaderType)

    csources, free := gl.Strs(string(source))
    gl.ShaderSource(shader, 1, csources, nil)
    free()
    gl.CompileShader(shader)

    var status int32
    gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
    if status == gl.FALSE {
        var logLength int32
        gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
        log := strings.Repeat("\x00", int(logLength+1))
        gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
        return 0, fmt.Errorf("failed to compile %v: %v", shaderSourceFile, log)
    }
    return shader, nil
}