Uniforms and better logging

logging/logging.go

@@ -0,0 +1,19 @@
+package logging
+
+import (
+	"log"
+	"os"
+)
+
+var (
+	InfoLog *log.Logger
+	WarnLog *log.Logger
+	ErrLog  *log.Logger
+)
+
+func init() {
+
+	InfoLog = log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
+	WarnLog = log.New(os.Stdout, "WARN: ", log.Ldate|log.Ltime|log.Lshortfile)
+	ErrLog = log.New(os.Stderr, "Err: ", log.Ldate|log.Ltime|log.Lshortfile)
+}

main.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/bloeys/go-sdl-engine/input"
+	"github.com/bloeys/go-sdl-engine/logging"
 	"github.com/bloeys/go-sdl-engine/shaders"
 	"github.com/bloeys/go-sdl-engine/timing"
 	"github.com/go-gl/gl/v4.6-core/gl"
@@ -25,7 +26,7 @@ func main() {
 
 	err := sdl.Init(sdl.INIT_EVERYTHING)
 	if err != nil {
-		panic("Failed to init SDL. Err: " + err.Error())
+		logging.ErrLog.Panicln("Failed to init SDL. Err:", err.Error())
 	}
 	defer sdl.Quit()
 
@@ -70,19 +71,19 @@ func main() {
 		winHeight,
 		sdl.WINDOW_OPENGL)
 	if err != nil {
-		panic("Failed to create window. Err: " + err.Error())
+		logging.ErrLog.Panicln("Failed to create window. Err: " + err.Error())
 	}
 	defer window.Destroy()
 
 	//Create GL context
 	glContext, err = window.GLCreateContext()
 	if err != nil {
-		panic("Creating OpenGL context failed. Err: " + err.Error())
+		logging.ErrLog.Panicln("Creating OpenGL context failed. Err: " + err.Error())
 	}
 	defer sdl.GLDeleteContext(glContext)
 
 	if err := gl.Init(); err != nil {
-		panic("Initing OpenGL Context failed. Err: " + err.Error())
+		logging.ErrLog.Panicln("Initing OpenGL Context failed. Err: " + err.Error())
 	}
 
 	initGL()
@@ -100,16 +101,23 @@ func initGL() {
 	gl.Viewport(0, 0, winWidth, winHeight)
 }
 
+var simpleProg shaders.Program
+
 func loadShaders() {
 
-	simpleProg := shaders.NewProgram("simple")
 	simpleVert, err := shaders.NewShaderFromFile("./res/shaders/simple.vert.glsl", shaders.Vertex)
 	panicIfErr(err, "Parsing vert shader failed")
+
 	simpleFrag, err := shaders.NewShaderFromFile("./res/shaders/simple.frag.glsl", shaders.Fragment)
 	panicIfErr(err, "Parsing frag shader failed")
 
+	simpleProg = shaders.NewProgram("simple")
 	simpleProg.AttachShader(simpleVert)
 	simpleProg.AttachShader(simpleFrag)
+
+	simpleProg.SetUniformF32("r", 255)
+
+	simpleProg.Link()
 }
 
 func gameLoop() {
@@ -164,5 +172,5 @@ func panicIfErr(err error, msg string) {
 		return
 	}
 
-	panic(msg + "; Err: " + err.Error())
+	logging.ErrLog.Panicln(msg+". Err:", err.Error())
 }

res/shaders/simple.frag.glsl

@@ -1,5 +1,9 @@
 #version 400
 
-void main() {
+uniform float r;
 
+out vec4 color;
+
+void main() {
+    color = vec4(r,r,r,0);
 }

res/shaders/simple.vert.glsl

@@ -1,5 +1,7 @@
 #version 400
 
+uniform float r;
+
 void main() {
 
 }

shaders/program.go

@@ -2,9 +2,9 @@ package shaders
 
 import (
 	"fmt"
-	"log"
 	"strings"
 
+	"github.com/bloeys/go-sdl-engine/logging"
 	"github.com/go-gl/gl/v4.6-core/gl"
 )
 
@@ -20,7 +20,7 @@ func NewProgram(name string) Program {
 	p.Shaders = make([]Shader, 0)
 
 	if p.ID = gl.CreateProgram(); p.ID == 0 {
-		log.Fatalln("Creating OpenGL program failed")
+		logging.ErrLog.Fatalln("Creating OpenGL program failed")
 	}
 
 	return p
@@ -79,6 +79,72 @@ func (p *Program) Use() {
 	gl.UseProgram(p.ID)
 }
 
+func (p *Program) GetUniformLocation(name string) int32 {
+	return gl.GetUniformLocation(p.ID, gl.Str(name+"\x00"))
+}
+
+//SetUniformF32 handles setting uniform values of 1-4 floats.
+//Returns false if len(floats) is <1 or >4, or if the uniform was not found.
+//Uniforms aren't found if it doesn't exist or was not used in the shader
+func (p *Program) SetUniformF32(name string, floats ...float32) bool {
+
+	loc := p.GetUniformLocation(name)
+	if loc == 0 {
+		logging.WarnLog.Printf(
+			"Uniform with name '%s' was not found. "+
+				"This is either because it doesn't exist or isn't used in the shader",
+			name)
+		return false
+	}
+
+	switch len(floats) {
+	case 1:
+		gl.Uniform1f(loc, floats[0])
+	case 2:
+		gl.Uniform2f(loc, floats[0], floats[1])
+	case 3:
+		gl.Uniform3f(loc, floats[0], floats[1], floats[2])
+	case 4:
+		gl.Uniform4f(loc, floats[0], floats[1], floats[2], floats[3])
+	default:
+		logging.ErrLog.Println("Invalid input size in SetUniformF32. Size must be 1-4 but got", len(floats))
+		return false
+	}
+
+	return true
+}
+
+//SetUniformI32 handles setting uniform values of 1-4 ints.
+//Returns false if len(ints) is <1 or >4, or if the uniform was not found.
+//Uniforms aren't found if it doesn't exist or was not used in the shader
+func (p *Program) SetUniformI32(name string, ints ...int32) bool {
+
+	loc := p.GetUniformLocation(name)
+	if loc == 0 {
+		logging.WarnLog.Printf(
+			"Uniform with name '%s' was not found. "+
+				"This is either because it doesn't exist or isn't used in the shader",
+			name)
+		return false
+	}
+
+	switch len(ints) {
+	case 1:
+		gl.Uniform1i(loc, ints[0])
+	case 2:
+		gl.Uniform2i(loc, ints[0], ints[1])
+	case 3:
+		gl.Uniform3i(loc, ints[0], ints[1], ints[2])
+	case 4:
+		gl.Uniform4i(loc, ints[0], ints[1], ints[2], ints[3])
+	default:
+		logging.ErrLog.Println("Invalid input size in SetUniformI32. Size must be 1-4 but got", len(ints))
+		return false
+	}
+
+	return true
+}
+
 //Delete deletes all shaders and then deletes the program
 func (p *Program) Delete() {
 	for _, v := range p.Shaders {

shaders/shader.go

@@ -2,10 +2,10 @@ package shaders
 
 import (
 	"fmt"
-	"log"
 	"os"
 	"strings"
 
+	"github.com/bloeys/go-sdl-engine/logging"
 	"github.com/go-gl/gl/v4.6-core/gl"
 )
 
@@ -33,7 +33,7 @@ func NewShaderFromString(sourceString string, st ShaderType) (Shader, error) {
 
 	newShader := Shader{Type: st}
 	if newShader.ID = gl.CreateShader(st.GLType()); newShader.ID == 0 {
-		log.Fatalln("Creating shader failed. ShaderType:", st)
+		logging.ErrLog.Panicln("Creating shader failed. ShaderType:", st)
 	}
 
 	gl.ShaderSource(newShader.ID, 1, glString, nil)

shaders/shader_type.go

@@ -1,8 +1,7 @@
 package shaders
 
 import (
-	"log"
-
+	"github.com/bloeys/go-sdl-engine/logging"
 	"github.com/go-gl/gl/v4.6-core/gl"
 )
 
@@ -25,7 +24,7 @@ func (t ShaderType) GLType() uint32 {
 		return gl.FRAGMENT_SHADER
 	}
 
-	log.Panicf("Converting ShaderType->GL Shader Type failed. Unknown ShaderType of value: %v\n", t)
+	logging.ErrLog.Panicf("Converting ShaderType->GL Shader Type failed. Unknown ShaderType of value: %v\n", t)
 	return 0
 }
 
@@ -39,7 +38,7 @@ func (t ShaderType) FromGLShaderType(glShaderType int) ShaderType {
 	case gl.FRAGMENT_SHADER:
 		return Fragment
 	default:
-		log.Printf("Converting GL shader type->ShaderType failed. Unknown GL shader type of value: %v\n", glShaderType)
+		logging.ErrLog.Panicf("Converting GL shader type->ShaderType failed. Unknown GL shader type of value: %v\n", glShaderType)
 		return Unknown
 	}
 }