golang opengl3

package main

import (
    "fmt"
    // gl "github.com/chsc/gogl/gl33"
    "github.com/go-gl/gl/v3.2-core/gl"
    "github.com/veandco/go-sdl2/sdl"
    // "math"
    // "github.com/Jragonmiris/mathgl"
    mathgl "github.com/go-gl/mathgl/mgl32"

    "runtime"
    // "time"
    "errors"
    "github.com/davecheney/profile"
    Image "image"
    _ "image/jpeg"
    _ "image/png"
    "os"
    "strings"
)

type attribute struct {
    vertices []float32
    colors   []float32
    uvs      []float32
}

var attributes []attribute

func BindTexture(path string) uint32 {
    f, e := os.Open(path)
    if e != nil {
        panic("file open error:" + e.Error())
    }

    img, _, e := Image.Decode(f)

    if e != nil {
        panic("file decode error:" + e.Error())
    }

    rgbaImg, ok := img.(*Image.NRGBA)
    if !ok {
        panic("texture must be an NRGBA image")
    }

    // taken from github.com/chsc/gogl/examples
    // flip image: first pixel is lower left corner
    imgWidth, imgHeight := img.Bounds().Dx(), img.Bounds().Dy()
    data := make([]byte, imgWidth*imgHeight*4)
    lineLen := imgWidth * 4
    dest := len(data) - lineLen
    for src := 0; src < len(rgbaImg.Pix); src += rgbaImg.Stride {
        copy(data[dest:dest+lineLen], rgbaImg.Pix[src:src+rgbaImg.Stride])
        dest -= lineLen
    }

    var texture uint32
    gl.ActiveTexture(gl.TEXTURE0)
    gl.BindTexture(gl.TEXTURE_2D, texture)
    gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
    gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
    gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
    gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
    gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
    gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(imgWidth), int32(imgHeight), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(data))

    if gl.GetError() != gl.NO_ERROR {

        panic("Failed to load a texture")
        return 0
    }

    return texture
}

func compileShader(source string, shaderType uint32) (uint32, error) {
    shader := gl.CreateShader(shaderType)

    csource := gl.Str(source)
    gl.ShaderSource(shader, 1, &csource, nil)
    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", source, log)
    }

    return shader, nil
}

func MakeProgram(vert, frag string) (uint32, error) {
    vertexShader, err := compileShader(vert, gl.VERTEX_SHADER)
    if err != nil {
        return 0, err
    }

    fragmentShader, err := compileShader(frag, gl.FRAGMENT_SHADER)
    if err != nil {
        return 0, err
    }

    program := gl.CreateProgram()

    gl.AttachShader(program, vertexShader)
    gl.AttachShader(program, fragmentShader)
    gl.LinkProgram(program)

    var status int32
    gl.GetProgramiv(program, gl.LINK_STATUS, &status)
    if status == gl.FALSE {
        var logLength int32
        gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &logLength)

        log := strings.Repeat("\x00", int(logLength+1))
        gl.GetProgramInfoLog(program, logLength, nil, gl.Str(log))

        return 0, errors.New(fmt.Sprintf("failed to link program: %v", log))
    }

    gl.DeleteShader(vertexShader)
    gl.DeleteShader(fragmentShader)

    return program, nil
}

func main() {
    defer profile.Start(profile.CPUProfile).Stop()
    var window *sdl.Window
    var context sdl.GLContext
    var event sdl.Event
    var running bool
    var err error

    runtime.LockOSThread()

    // if 0 != sdl.Init(sdl.INIT_EVERYTHING) {
    //  panic(sdl.GetError())
    // }
    window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED,
        sdl.WINDOWPOS_UNDEFINED,
        winWidth, winHeight, sdl.WINDOW_OPENGL)

    if err != nil {
        panic(err)
    }
    if window == nil {
        panic(sdl.GetError())
    }

    sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
    sdl.GL_SetAttribute(sdl.GL_RED_SIZE, 8)
    sdl.GL_SetAttribute(sdl.GL_GREEN_SIZE, 8)
    sdl.GL_SetAttribute(sdl.GL_BLUE_SIZE, 8)
    sdl.GL_SetAttribute(sdl.GL_ALPHA_SIZE, 8)

    context, _ = sdl.GL_CreateContext(window)
    sdl.GL_MakeCurrent(window, context)

    if context == nil {
        panic(sdl.GetError())
    }

    if err := gl.Init(); err != nil {
        panic("gl error: " + err.Error())
    }

    fmt.Println(gl.GetString(gl.VERSION))
    fmt.Println(gl.GetString(gl.VENDOR))
    fmt.Println(gl.GetString(gl.RENDERER))

    gl.ClearColor(.7, .7, .7, .5)
    gl.Viewport(0, 0, winWidth, winHeight)

    program, err := MakeProgram(vertexShaderSource, fragmentShaderSource)
    // defer program.Delete()

    if err != nil {
        fmt.Println("Error loading shaders: " + err.Error())
    }

    gl.BindFragDataLocation(program, 0, gl.Str("color\x00"))
    // texSampler := program.GetUniformLocation("myTextureSampler")
    gl.GetUniformLocation(program, gl.Str("myTextureSampler\x00"))

    matrixID := gl.GetUniformLocation(program, gl.Str("MVP\x00"))
    // Projection := mathgl.Perspective(45.0, winWidth/winHeight, 0.1, 100.0)
    // Projection := mathgl.Ortho2D(0.0, winWidth, winHeight, 0.0)
    Projection := mathgl.Ortho(0.0, winWidth, winHeight, 0.0, -5.0, 5.0)

    View := mathgl.LookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
    Model := mathgl.Ident4()

    gl.Enable(gl.DEPTH_TEST)
    gl.DepthFunc(gl.LESS)
    gl.Enable(gl.BLEND)
    gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)

    for i := 0; i < 10000; i++ {
        attributes = append(attributes, attribute{vertices: triangle_vertices, colors: triangle_colours, uvs: triangle_uvs})
        //attributes = append(attributes, attribute{vertices: triangle_vertices2, colors: triangle_colours, uvs: triangle_uvs})
    }
    running = true

    var vao uint32
    gl.GenVertexArrays(1, &vao)
    // defer vertexArray.Delete()
    gl.BindVertexArray(vao)

    var vbo uint32
    gl.GenBuffers(1, &vbo)
    gl.BindBuffer(gl.ARRAY_BUFFER, vbo)

    var colorvbo uint32
    gl.GenBuffers(1, &colorvbo)
    gl.BindBuffer(gl.ARRAY_BUFFER, colorvbo)

    var uvvbo uint32
    gl.GenBuffers(1, &uvvbo)
    gl.BindBuffer(gl.ARRAY_BUFFER, uvvbo)

    // element buffer
    var elementvbo uint32
    gl.GenBuffers(1, &elementvbo)
    // defer elementBuffer.Delete()
    gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementvbo)
    gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(elements)*2, gl.Ptr(elements), gl.STATIC_DRAW)

    texId := BindTexture("smiley.png")
    // texId2 := BindTexture("test.png")

    move := 1
    for running {
        for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
            switch t := event.(type) {
            case *sdl.QuitEvent:
                running = false
            case *sdl.MouseMotionEvent:

                fmt.Println(string(t.Timestamp))
            }
        }

        gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)

        // range of values
        for _, attr := range attributes {

            gl.UseProgram(program)

            gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
            gl.BufferData(gl.ARRAY_BUFFER, len(attr.vertices)*4, gl.Ptr(attr.vertices), gl.DYNAMIC_DRAW)

            positionAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertexPosition_modelspace\x00")))
            gl.EnableVertexAttribArray(positionAttrib)
            gl.VertexAttribPointer(positionAttrib, 3, gl.FLOAT, false, 0, nil)
            // defer positionAttrib.DisableArray()

            gl.BindBuffer(gl.ARRAY_BUFFER, colorvbo)
            gl.BufferData(gl.ARRAY_BUFFER, len(attr.colors)*4, gl.Ptr(attr.colors), gl.DYNAMIC_DRAW)

            colorAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertexColor\x00")))
            gl.EnableVertexAttribArray(colorAttrib)
            gl.VertexAttribPointer(colorAttrib, 3, gl.FLOAT, false, 0, nil)

            // defer colorAttrib.DisableArray()

            gl.BindBuffer(gl.ARRAY_BUFFER, uvvbo)
            gl.BufferData(gl.ARRAY_BUFFER, len(attr.uvs)*4, gl.Ptr(attr.uvs), gl.DYNAMIC_DRAW)

            uvAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertexUV\x00")))
            gl.EnableVertexAttribArray(uvAttrib)
            gl.VertexAttribPointer(uvAttrib, 2, gl.FLOAT, false, 0, nil)
            // defer uvAttrib.DisableArray()

            // fmt.Println(texId)
            // fmt.Println(texId2)
            // gl.ActiveTexture(gl.TEXTURE0)
            gl.BindBuffer(gl.TEXTURE_2D, texId)
            // texSampler.Uniform1i(0)

            // rot := mathgl.HomogRotate3DZ(float32(idx * 60))
            Model = mathgl.Ident4()
            Model = Model.Mul4(mathgl.Translate3D(float32(move), float32(100.0), float32(0.0)))
            Model = Model.Mul4(mathgl.Scale3D(float32(50), float32(50), float32(1)))

            MVP := Projection.Mul4(View).Mul4(Model)

            gl.UniformMatrix4fv(matrixID, 1, false, &MVP[0])

            // use array buffer
            gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementvbo)
            // defer elementBuffer.Unbind(gl.ELEMENT_ARRAY_BUFFER)

            // gl.DrawArrays(gl.TRIANGLES, 0, 3)
            gl.DrawElements(gl.TRIANGLES, int32(len(elements)), gl.UNSIGNED_SHORT, nil)

        }
        move += 1

        sdl.Delay(10)

        sdl.GL_SwapWindow(window)

    }

    sdl.GL_DeleteContext(context)
    window.Destroy()
    sdl.Quit()
}

const (
    winTitle           = "OpenGL Shader"
    winWidth           = 640
    winHeight          = 480
    vertexShaderSource = `
#version 330 core

// Input vertex data, different for all executions of this shader.
in vec3 vertexPosition_modelspace;

in vec3 vertexColor;

in vec2 vertexUV;

// Output data ; will be interpolated for each fragment.
out vec2 UV;

// Output data ; will be interpolated for each fragment.
out vec3 fragmentColor;


// Values that stay constant for the whole mesh.
uniform mat4 MVP;
void main(){

    gl_Position = MVP * vec4 (vertexPosition_modelspace,.5); //* MVP;

    // The color of each vertex will be interpolated
    // to produce the color of each fragment
    fragmentColor = vertexColor;

    // UV of the vertex. No special space for this one.
    UV = vertexUV;
}
` + "\x00"
    fragmentShaderSource = `
#version 330 core

// Interpolated values from the vertex shaders
in vec3 fragmentColor;

// Interpolated values from the vertex shaders
in vec2 UV;

// Ouput data
out vec4 color;

// Values that stay constant for the whole mesh.
uniform sampler2D myTextureSampler;

void main()
{

    // // Output color = red
    // color = vec4(fragmentColor,1.0);

    // Output color = color of the texture at the specified UV
    color = texture2D( myTextureSampler, UV ).rgba;

}
` + "\x00"
)

var triangle_vertices = []float32{
    -0.5, 0.5, 1.0, // Top-left
    0.5, 0.5, 1.0, // Top-right
    0.5, -0.5, 1.0, // Bottom-right
    -0.5, -0.5, 1.0, // Bottom-left
}

var triangle_vertices2 = []float32{
    -.8, -.8, -.8,
    .2, -.8, -.8,
    -3, 0.2, -.8,
}

var elements = []uint16{
    0, 1, 2,
    2, 3, 0,
}

var triangle_uvs = []float32{
    0.0, 0.0,
    1.0, 0.0,
    1.0, 1.0,
    0.0, 1.0,
}

var triangle_colours = []float32{
    0.583, 0.771, 0.014,
    0.609, 0.115, 0.436,
    0.327, 0.483, 0.844,
}