vbo

vbo.go

package main

import (
	"github.com/go-gl/gl"
	"github.com/go-gl/glfw"
	"github.com/go-gl/glh"
	"log"
	"runtime"
)

var (
	verts   = [...][2]float32{{0, 0}, {100, 0}, {100, 100}, {0, 100}}
	indices = [...]gl.GLuint{0, 1, 2, 3}
)

func main() {
	err := initGL()
	if err != nil {
		log.Printf("InitGL: %v", err)
		return
	}

	defer glfw.Terminate()

	// Create vertex and index buffers.
	vb := gl.GenBuffer()
	ib := gl.GenBuffer()
	defer vb.Delete()
	defer ib.Delete()

	// Bind the vertex data.
	vb.Bind(gl.ARRAY_BUFFER)
	gl.BufferData(gl.ARRAY_BUFFER, len(verts)*4*2, verts[:], gl.STATIC_DRAW)
	gl.Finish()
	gl.BufferUnbind(gl.ARRAY_BUFFER)

	// Bind the index data.
	ib.Bind(gl.ELEMENT_ARRAY_BUFFER)
	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(indices)*4, indices[:], gl.STATIC_DRAW)
	gl.Finish()
	gl.BufferUnbind(gl.ELEMENT_ARRAY_BUFFER)

	// Ensure it all went right.
	err = glh.CheckGLError()
	if err != nil {
		log.Println(err)
		return
	}

	// Perform the rendering.
	for glfw.WindowParam(glfw.Opened) > 0 {
		gl.Clear(gl.COLOR_BUFFER_BIT)
		gl.LoadIdentity()

		// Render manually, so we have a visual reference
		// of what the vertexbuffer output /should/ be like.
		gl.Translatef(100, 100, 0)
		gl.Begin(gl.QUADS)
		{
			for _, i := range indices {
				gl.Vertex2f(verts[i][0], verts[i][1])
			}
		}
		gl.End()

		// Render vertex buffer. If all went well, this looks identical
		// to the manually drawn quad up there ^
		gl.Translatef(200, 0, 0)
		gl.PushClientAttrib(gl.CLIENT_VERTEX_ARRAY_BIT)
		{
			gl.EnableClientState(gl.VERTEX_ARRAY)
			ib.Bind(gl.ELEMENT_ARRAY_BUFFER)
			vb.Bind(gl.ARRAY_BUFFER)
			gl.VertexPointer(2, gl.FLOAT, 0, uintptr(0))

			gl.DrawElements(gl.QUADS, len(indices), gl.UNSIGNED_INT, uintptr(0))

			gl.BufferUnbind(gl.ARRAY_BUFFER)
			gl.BufferUnbind(gl.ELEMENT_ARRAY_BUFFER)
			gl.DisableClientState(gl.VERTEX_ARRAY)
		}
		gl.PopClientAttrib()

		// Ensure it all went right.
		err = glh.CheckGLError()
		if err != nil {
			log.Println(err)
			return
		}

		glfw.SwapBuffers()
	}
}

// initGL initializes GLFW and OpenGL.
func initGL() error {
	runtime.LockOSThread()

	err := glfw.Init()
	if err != nil {
		return err
	}

	err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed)
	if err != nil {
		glfw.Terminate()
		return err
	}

	glfw.SetWindowTitle("vbo test")
	glfw.SetSwapInterval(1)

	glfw.SetWindowSizeCallback(onResize)
	glfw.SetKeyCallback(onKey)

	gl.Init()

	err = glh.CheckGLError()
	if err != nil {
		return err
	}

	gl.ClearColor(0.2, 0.2, 0.23, 1.0)
	gl.Enable(gl.BLEND)
	gl.Disable(gl.DEPTH_TEST)
	return nil
}

// onKey handles key events.
func onKey(key, state int) {
	if key == glfw.KeyEsc {
		glfw.CloseWindow()
	}
}

// onResize handles window resize events.
func onResize(w, h int) {
	if w < 1 {
		w = 1
	}

	if h < 1 {
		h = 1
	}

	gl.Viewport(0, 0, w, h)
	gl.MatrixMode(gl.PROJECTION)
	gl.LoadIdentity()
	gl.Ortho(0, float64(w), float64(h), 0, 0, 1)
	gl.MatrixMode(gl.MODELVIEW)
	gl.LoadIdentity()
}