hotload

Author: jackmott

.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch",
+            "type": "go",
+            "request": "launch",
+            "mode": "debug",
+            "remotePath": "",
+            "port": 2345,
+            "host": "127.0.0.1",
+            "program": "${fileDirname}",
+            "env": {},
+            "args": [],
+            "showLog": true
+        }
+    ]
+}

gogl/gogl.go

@@ -5,44 +5,17 @@ import (
 	"fmt"
 	"github.com/go-gl/gl/v3.3-core/gl"
 	"io/ioutil"
-	_ "os"
 	"strings"
-	"time"
 )
 
 type ShaderID uint32
 type ProgramID uint32
-type VAOID uint32
-type VBOID uint32
+type BufferID uint32
 
 func GetVersion() string {
 	return gl.GoStr(gl.GetString(gl.VERSION))
 }
 
-type programInfo struct {
-	vertPath string
-	fragPath string
-	modified time.Time
-}
-
-var loadedShaders []programInfo
-
-func CheckShadersForChanges() {
-	/*
-		for _, shaderInfo := range loadedShaders {
-			file, err := os.Stat(oriInfo.path)
-			if err != nil {
-				panic(err)
-			}
-			modTime := file.ModTime()
-			// check if greater than?
-			if !modTime.Equal(shaderInfo.modified) {
-				fmt.Println("Shader modified")
-			}
-		}
-	*/
-}
-
 func LoadShader(path string, shaderType uint32) (ShaderID, error) {
 	shaderFile, err := ioutil.ReadFile(path)
 	if err != nil {
@@ -114,28 +87,32 @@ func CreateProgram(vertPath string, fragPath string) (ProgramID, error) {
 	return ProgramID(shaderProgram), nil
 }
 
-func GenBindBuffer(target uint32) VBOID {
-	var VBO uint32
-	gl.GenBuffers(1, &VBO)
-	gl.BindBuffer(target, VBO)
-	return VBOID(VBO)
+func GenBindBuffer(target uint32) BufferID {
+	var buffer uint32
+	gl.GenBuffers(1, &buffer)
+	gl.BindBuffer(target, buffer)
+	return BufferID(buffer)
 }
 
-func GenBindVertexArray() VAOID {
+func GenBindVertexArray() BufferID {
 	var VAO uint32
 	gl.GenVertexArrays(1, &VAO)
 	gl.BindVertexArray(VAO)
-	return VAOID(VAO)
+	return BufferID(VAO)
 }
 
-func BindVertexArray(vaoID VAOID) {
+func BindVertexArray(vaoID BufferID) {
 	gl.BindVertexArray(uint32(vaoID))
 }
 
 func BufferDataFloat(target uint32, data []float32, usage uint32) {
 	gl.BufferData(target, len(data)*4, gl.Ptr(data), usage)
 }
 
+func BufferDataInt(target uint32, data []uint32, usage uint32) {
+	gl.BufferData(target, len(data)*4, gl.Ptr(data), usage)
+}
+
 func UnbindVertexArray() {
 	gl.BindVertexArray(0)
 }

gogl/shader.go

@@ -0,0 +1,61 @@
+package gogl
+
+import (
+	"fmt"
+	"github.com/go-gl/gl/v3.3-core/gl"
+	"os"
+	"time"
+)
+
+type Shader struct {
+	id               ProgramID
+	vertexPath       string
+	fragmentPath     string
+	vertexModified   time.Time
+	fragmentModified time.Time
+}
+
+func NewShader(vertexPath string, fragmentPath string) (*Shader, error) {
+	id, err := CreateProgram(vertexPath, fragmentPath)
+	if err != nil {
+		return nil, err
+	}
+	result := &Shader{id, vertexPath, fragmentPath, getModifiedTime(vertexPath), getModifiedTime(fragmentPath)}
+	return result, nil
+}
+
+func (shader *Shader) Use() {
+	UseProgram(shader.id)
+}
+
+func (shader *Shader) SetFloat(name string, f float32) {
+	name_cstr := gl.Str(name + "\x00")
+	location := gl.GetUniformLocation(uint32(shader.id), name_cstr)
+	gl.Uniform1f(location, f)
+}
+
+func getModifiedTime(filePath string) time.Time {
+	file, err := os.Stat(filePath)
+	if err != nil {
+		panic(err)
+	}
+	return file.ModTime()
+}
+
+func (shader *Shader) CheckShaderForChanges() {
+
+	vertexModTime := getModifiedTime(shader.vertexPath)
+	fragmentModTime := getModifiedTime(shader.fragmentPath)
+	// check if greater than?
+	if !vertexModTime.Equal(shader.vertexModified) ||
+		!fragmentModTime.Equal(shader.fragmentModified) {
+		id, err := CreateProgram(shader.vertexPath, shader.fragmentPath)
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			gl.DeleteProgram(uint32(shader.id))
+			shader.id = id
+		}
+	}
+
+}

hellotriangle/debug

@@ -32,24 +32,34 @@ func main() {
 
 	fmt.Println("OpenGL Version", gogl.GetVersion())
 
-	shaderProgram, err := gogl.CreateProgram("shaders/hello.vert", "shaders/hello.frag")
+	shaderProgram, err := gogl.NewShader("shaders/hello.vert", "shaders/hello.frag")
 	if err != nil {
 		panic(err)
 	}
 
 	vertices := []float32{
-		-0.5, -0.5, 0.0,
-		0.5, -0.5, 0.0,
-		0.0, 0.5, 0.0}
+		0.5, 0.5, 0.0, 1.0, 1.0,
+		0.5, -0.5, 0.0, 1.0, 0.0,
+		-0.5, -0.5, 0.0, 0.0, 0.0,
+		-0.5, 0.5, 0.0, 0.0, 1.0}
+
+	indices := []uint32{
+		0, 1, 3, // triangle 1
+		1, 2, 3, // triangle 2
+	}
 
 	gogl.GenBindBuffer(gl.ARRAY_BUFFER)
 	VAO := gogl.GenBindVertexArray()
-
 	gogl.BufferDataFloat(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW)
-	gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 3*4, nil)
+	gogl.GenBindBuffer(gl.ELEMENT_ARRAY_BUFFER)
+	gogl.BufferDataInt(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW)
+
+	gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 5*4, nil)
 	gl.EnableVertexAttribArray(0)
+	gl.VertexAttribPointer(1, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4))
+	gl.EnableVertexAttribArray(1)
 	gogl.UnbindVertexArray()
-
+	var x float32 = 0.0
 	for {
 		for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
 			switch event.(type) {
@@ -61,10 +71,13 @@ func main() {
 		gl.ClearColor(0.0, 0.0, 0.0, 0.0)
 		gl.Clear(gl.COLOR_BUFFER_BIT)
 
-		gogl.UseProgram(shaderProgram)
+		shaderProgram.Use()
+		shaderProgram.SetFloat("x", x)
+		shaderProgram.SetFloat("y", 0.0)
 		gogl.BindVertexArray(VAO)
-		gl.DrawArrays(gl.TRIANGLES, 0, 3)
+		gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, gl.PtrOffset(0))
 		window.GLSwap()
-		gogl.CheckShadersForChanges()
+		shaderProgram.CheckShaderForChanges()
+		x = x + .01
 	}
 }