opengl_test.go

package main

import (
	"fmt"
	"strings"

	"github.com/go-gl/gl/v3.3-core/gl"
	"github.com/veandco/go-sdl2/sdl"
)

func DontPanic(err error) {
	if err != nil {
		panic(err)
	}
}

var GLversion = [...]int {3, 3}

func main() {
	DontPanic(
		sdl.Init(sdl.INIT_EVERYTHING))
	defer sdl.Quit()

	DontPanic(
		sdl.GLSetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_CORE))
	DontPanic(
		sdl.GLSetAttribute(sdl.GL_CONTEXT_MAJOR_VERSION, GLversion[0]))
	DontPanic(
		sdl.GLSetAttribute(sdl.GL_CONTEXT_MINOR_VERSION, GLversion[1]))

	window, err := sdl.CreateWindow("OpenGL", 200, 200, 1280, 720, sdl.WINDOW_OPENGL)
	DontPanic(err)

	window.GLCreateContext()
	defer window.Destroy()

	GLversionStr := fmt.Sprintf("%d%d0", GLversion[0], GLversion[1])

	gl.Init()
	version := gl.GoStr(gl.GetString(gl.VERSION))
	fmt.Println("OpenGL Version", version)

	vertexShaderSrc :=
		"#version "+ GLversionStr +" core \n"+
        "layout (location = 0) in vec3 aPos;"+
        "void main() {"+
			"gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);"+
		"}\x00"
	
	vertexShader := gl.CreateShader(gl.VERTEX_SHADER)
	csource, free := gl.Strs(vertexShaderSrc)
	gl.ShaderSource(vertexShader, 1, csource, nil)
	free()
	gl.CompileShader(vertexShader)
	var status int32
	gl.GetShaderiv(vertexShader, gl.COMPILE_STATUS, &status)
	if status == gl.FALSE {
		var logLength int32
		gl.GetShaderiv(vertexShader, gl.INFO_LOG_LENGTH, &logLength)
		log := strings.Repeat("\x00", int(logLength+1))
		gl.GetShaderInfoLog(vertexShader, logLength, nil, gl.Str(log))
		panic("Failed to compile vertex shader:\n" + log)
	}

	fragmentShaderSrc :=
		"#version "+ GLversionStr +" core \n"+
		"out vec4 FragColor;"+
		"void main() {"+
			"FragColor = vec4(1, 0.5, 0.2, 1);"+
		"}\x00"
	
	fragmentShader := gl.CreateShader(gl.FRAGMENT_SHADER)
	csource, free = gl.Strs(fragmentShaderSrc)
	gl.ShaderSource(fragmentShader, 1, csource, nil)
	free()
	gl.CompileShader(fragmentShader)
	gl.GetShaderiv(fragmentShader, gl.COMPILE_STATUS, &status)
	if status == gl.FALSE {
		var logLength int32
		gl.GetShaderiv(fragmentShader, gl.INFO_LOG_LENGTH, &logLength)
		log := strings.Repeat("\x00", int(logLength+1))
		gl.GetShaderInfoLog(fragmentShader, logLength, nil, gl.Str(log))
		panic("Failed to compile fragment shader:\n" + log)
	}

	shaderPrg := gl.CreateProgram()
	gl.AttachShader(shaderPrg, vertexShader)
	gl.AttachShader(shaderPrg, fragmentShader)
	gl.LinkProgram(shaderPrg)
	gl.GetProgramiv(shaderPrg, gl.LINK_STATUS, &status)
	if status == gl.FALSE {
		panic("Error in Linker, error logging not yet implemented.")
	}
	gl.DeleteShader(vertexShader)
	gl.DeleteShader(fragmentShader)

	vertices := []float32{
		-.5, -.5, 0,
		 .5, -.5, 0,
		  0,  .5, 0,
	}

	var vertexBuffer uint32
	gl.GenBuffers(1, &vertexBuffer)
	gl.BindBuffer(gl.ARRAY_BUFFER, vertexBuffer)
	var vertexArray uint32
	gl.GenVertexArrays(1, &vertexArray)
	gl.BindVertexArray(vertexArray)

	gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
	gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 3*4, nil)
	gl.EnableVertexAttribArray(0)
	gl.BindVertexArray(0)

	EventPoll:
	for {
		for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch event.(type) {
				case *sdl.QuitEvent:
					break EventPoll
			}
		}
		gl.ClearColor(0, 0, 0, 0)
		gl.Clear(gl.COLOR_BUFFER_BIT)
		gl.BindVertexArray(vertexArray)
		gl.DrawArrays(gl.TRIANGLES, 0, 3)
		window.GLSwap()
	}
}