Update actions

.github/workflows/build-nmage.yml

@@ -5,20 +5,61 @@ on:
   workflow_dispatch:
 
 jobs:
-  build-nmage-macos:
-    runs-on: macos-12
-    steps:
-    
-      - name: Install golang
-        uses: actions/setup-go@v3
-        with:
-          go-version: '>=1.22'
+  build-nmage-windows:
+    runs-on: windows-latest
 
-      - name: Install assimp-go dylib
-        run: sudo mkdir -p /usr/local/lib && sudo wget https://github.com/bloeys/assimp-go/releases/download/v0.4.2/libassimp_darwin_amd64.dylib -O /usr/local/lib/libassimp.5.dylib
+    steps:
+      - name: Install golang
+        uses: actions/setup-go@v5
+        with:
+          go-version: ">=1.23"
+
+      - name: Install assimp-go dll
+        run: |
+          New-Item -ItemType Directory -Force -Path C:\Windows\System32
+          Invoke-WebRequest -Uri "https://github.com/bloeys/assimp-go/releases/download/v0.4.2/libassimp-5.dll" -OutFile "C:\Windows\System32\assimp.dll"
 
       - name: Install SDL2
-        run: brew install sdl2{,_image,_mixer,_ttf,_gfx} pkg-config
+        run: |
+          choco install sdl2 sdl2_image sdl2_ttf sdl2_gfx pkg-config
+
+      - name: Clone nmage
+        run: git clone https://github.com/bloeys/nmage
+
+      - name: Build nmage
+        working-directory: nmage
+        run: go build .
+
+  build-nmage-macos:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        # Based on: https://github.com/actions/runner-images?tab=readme-ov-file#available-images
+        os:
+          - macos-13 # x86
+          - macos-14 # Arm
+
+    steps:
+      - name: Install golang
+        uses: actions/setup-go@v5
+        with:
+          go-version: ">=1.23"
+
+      - name: Determine architecture
+        id: arch
+        run: |
+          if [ "$(uname -m)" = "arm64" ]; then
+            echo "arch=arm64" >> "$GITHUB_OUTPUT"
+          else
+            echo "arch=amd64" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Install assimp-go dylib
+        run: sudo mkdir -p /usr/local/lib && sudo wget https://github.com/bloeys/assimp-go/releases/download/v0.4.2/libassimp_darwin_${{ steps.arch.outputs.arch }}.dylib -O /usr/local/lib/libassimp.5.dylib
+
+      - name: Install SDL2
+        run: brew install sdl2{,_image,_ttf,_gfx} pkg-config
 
       - name: Clone nmage
         run: git clone https://github.com/bloeys/nmage

buffers/buf_usage.go

@@ -9,25 +9,48 @@ import (
 
 type BufUsage int
 
+// Full docs for buffer usage can be found here: https://registry.khronos.org/OpenGL-Refpages/gl4/html/glBufferData.xhtml
 const (
 	BufUsage_Unknown BufUsage = iota
 
 	//Buffer is set only once and used many times
-	BufUsage_Static
+	BufUsage_Static_Draw
 	//Buffer is changed a lot and used many times
-	BufUsage_Dynamic
+	BufUsage_Dynamic_Draw
 	//Buffer is set only once and used by the GPU at most a few times
-	BufUsage_Stream
+	BufUsage_Stream_Draw
+
+	BufUsage_Static_Read
+	BufUsage_Dynamic_Read
+	BufUsage_Stream_Read
+
+	BufUsage_Static_Copy
+	BufUsage_Dynamic_Copy
+	BufUsage_Stream_Copy
 )
 
 func (b BufUsage) ToGL() uint32 {
 	switch b {
-	case BufUsage_Static:
+	case BufUsage_Static_Draw:
 		return gl.STATIC_DRAW
-	case BufUsage_Dynamic:
+	case BufUsage_Dynamic_Draw:
 		return gl.DYNAMIC_DRAW
-	case BufUsage_Stream:
+	case BufUsage_Stream_Draw:
 		return gl.STREAM_DRAW
+
+	case BufUsage_Static_Read:
+		return gl.STATIC_READ
+	case BufUsage_Dynamic_Read:
+		return gl.DYNAMIC_READ
+	case BufUsage_Stream_Read:
+		return gl.STREAM_READ
+
+	case BufUsage_Static_Copy:
+		return gl.STATIC_COPY
+	case BufUsage_Dynamic_Copy:
+		return gl.DYNAMIC_COPY
+	case BufUsage_Stream_Copy:
+		return gl.STREAM_COPY
 	}
 
 	assert.T(false, fmt.Sprintf("Unexpected BufUsage value '%v'", b))

buffers/element.go

@@ -1,23 +1,23 @@
 package buffers
 
 import (
-	"fmt"
-
 	"github.com/bloeys/nmage/assert"
+	"github.com/bloeys/nmage/logging"
 	"github.com/go-gl/gl/v4.1-core/gl"
 )
 
-//Element represents an element that makes up a buffer (e.g. Vec3 at an offset of 12 bytes)
+// Element represents an element that makes up a buffer (e.g. Vec3 at an offset of 12 bytes)
 type Element struct {
 	Offset int
 	ElementType
 }
 
-//ElementType is the type of an element thats makes up a buffer (e.g. Vec3)
-type ElementType int
+// ElementType is the type of an element thats makes up a buffer (e.g. Vec3)
+type ElementType uint8
 
 const (
 	DataTypeUnknown ElementType = iota
+
 	DataTypeUint32
 	DataTypeInt32
 	DataTypeFloat32
@@ -25,35 +25,54 @@ const (
 	DataTypeVec2
 	DataTypeVec3
 	DataTypeVec4
+
+	DataTypeMat2
+	DataTypeMat3
+	DataTypeMat4
+
+	DataTypeStruct
 )
 
 func (dt ElementType) GLType() uint32 {
 
 	switch dt {
+
 	case DataTypeUint32:
 		return gl.UNSIGNED_INT
 	case DataTypeInt32:
 		return gl.INT
-
 	case DataTypeFloat32:
 		fallthrough
+
 	case DataTypeVec2:
 		fallthrough
 	case DataTypeVec3:
 		fallthrough
 	case DataTypeVec4:
+		fallthrough
+	case DataTypeMat2:
+		fallthrough
+	case DataTypeMat3:
+		fallthrough
+	case DataTypeMat4:
 		return gl.FLOAT
 
+	case DataTypeStruct:
+		logging.ErrLog.Fatalf("ElementType.GLType of DataTypeStruct is not supported")
+		return 0
+
 	default:
-		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, "Unknown data type passed. DataType '%d'", dt)
 		return 0
 	}
 }
 
-//CompSize returns the size in bytes for one component of the type (e.g. for Vec2 its 4)
+// CompSize returns the size in bytes for one component of the type (e.g. for Vec2 its 4).
+// Bools return 1, although in layout=std140 its 4
 func (dt ElementType) CompSize() int32 {
 
 	switch dt {
+
 	case DataTypeUint32:
 		fallthrough
 	case DataTypeFloat32:
@@ -65,15 +84,25 @@ func (dt ElementType) CompSize() int32 {
 	case DataTypeVec3:
 		fallthrough
 	case DataTypeVec4:
+		fallthrough
+	case DataTypeMat2:
+		fallthrough
+	case DataTypeMat3:
+		fallthrough
+	case DataTypeMat4:
 		return 4
 
+	case DataTypeStruct:
+		logging.ErrLog.Fatalf("ElementType.CompSize of DataTypeStruct is not supported")
+		return 0
+
 	default:
-		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, "Unknown data type passed. DataType '%d'", dt)
 		return 0
 	}
 }
 
-//CompCount returns the number of components in the element (e.g. for Vec2 its 2)
+// CompCount returns the number of components in the element (e.g. for Vec2 its 2)
 func (dt ElementType) CompCount() int32 {
 
 	switch dt {
@@ -91,16 +120,28 @@ func (dt ElementType) CompCount() int32 {
 	case DataTypeVec4:
 		return 4
 
+	case DataTypeMat2:
+		return 2 * 2
+	case DataTypeMat3:
+		return 3 * 3
+	case DataTypeMat4:
+		return 4 * 4
+
+	case DataTypeStruct:
+		logging.ErrLog.Fatalf("ElementType.CompCount of DataTypeStruct is not supported")
+		return 0
+
 	default:
-		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, "Unknown data type passed. DataType '%d'", dt)
 		return 0
 	}
 }
 
-//Size returns the total size in bytes (e.g. for vec3 its 3*4=12 bytes)
+// Size returns the total size in bytes (e.g. for vec3 its 3*4=12 bytes)
 func (dt ElementType) Size() int32 {
 
 	switch dt {
+
 	case DataTypeUint32:
 		fallthrough
 	case DataTypeFloat32:
@@ -115,8 +156,123 @@ func (dt ElementType) Size() int32 {
 	case DataTypeVec4:
 		return 4 * 4
 
+	case DataTypeMat2:
+		return 2 * 2 * 4
+	case DataTypeMat3:
+		return 3 * 3 * 4
+	case DataTypeMat4:
+		return 4 * 4 * 4
+
+	case DataTypeStruct:
+		logging.ErrLog.Fatalf("ElementType.Size of DataTypeStruct is not supported")
+		return 0
+
 	default:
-		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, "Unknown data type passed. DataType '%d'", dt)
 		return 0
 	}
 }
+
+func (dt ElementType) GlStd140SizeBytes() uint8 {
+
+	switch dt {
+
+	case DataTypeUint32:
+		fallthrough
+	case DataTypeFloat32:
+		fallthrough
+	case DataTypeInt32:
+		return 4
+
+	case DataTypeVec2:
+		return 4 * 2
+
+	case DataTypeVec3:
+		return 4 * 3
+
+	case DataTypeVec4:
+		return 4 * 4
+
+		// Matrices follow: (vec4Alignment) * numColumns
+	case DataTypeMat2:
+		return 2 * 2 * 4
+	case DataTypeMat3:
+		return 3 * 3 * 4
+	case DataTypeMat4:
+		return 4 * 4 * 4
+
+	case DataTypeStruct:
+		logging.ErrLog.Fatalf("ElementType.GlStd140SizeBytes of DataTypeStruct is not supported")
+		return 0
+
+	default:
+		assert.T(false, "Unknown data type passed. DataType '%d'", dt)
+		return 0
+	}
+}
+
+func (dt ElementType) GlStd140AlignmentBoundary() uint16 {
+
+	switch dt {
+
+	case DataTypeUint32:
+		fallthrough
+	case DataTypeFloat32:
+		fallthrough
+	case DataTypeInt32:
+		return 4
+
+	case DataTypeVec2:
+		return 8
+
+	case DataTypeVec3:
+		fallthrough
+	case DataTypeVec4:
+		fallthrough
+	case DataTypeMat2:
+		fallthrough
+	case DataTypeMat3:
+		fallthrough
+	case DataTypeMat4:
+		fallthrough
+	case DataTypeStruct:
+		return 16
+
+	default:
+		assert.T(false, "Unknown data type passed. DataType '%d'", dt)
+		return 0
+	}
+}
+
+func (dt ElementType) String() string {
+
+	switch dt {
+
+	case DataTypeUint32:
+		return "uint32"
+	case DataTypeFloat32:
+		return "float32"
+	case DataTypeInt32:
+		return "int32"
+
+	case DataTypeVec2:
+		return "Vec2"
+	case DataTypeVec3:
+		return "Vec3"
+	case DataTypeVec4:
+		return "Vec4"
+
+	case DataTypeMat2:
+		return "Mat2"
+	case DataTypeMat3:
+		return "Mat3"
+	case DataTypeMat4:
+		return "Mat4"
+
+	case DataTypeStruct:
+		return "Struct"
+
+	default:
+		return "Unknown"
+	}
+}

buffers/index_buffer.go

@@ -27,9 +27,9 @@ func (ib *IndexBuffer) SetData(values []uint32) {
 	ib.IndexBufCount = int32(len(values))
 
 	if sizeInBytes == 0 {
-		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, 0, gl.Ptr(nil), BufUsage_Static.ToGL())
+		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, 0, gl.Ptr(nil), BufUsage_Static_Draw.ToGL())
 	} else {
-		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, sizeInBytes, gl.Ptr(&values[0]), BufUsage_Static.ToGL())
+		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, sizeInBytes, gl.Ptr(&values[0]), BufUsage_Static_Draw.ToGL())
 	}
 }
 

buffers/uniform_buffer.go

@@ -0,0 +1,747 @@
+package buffers
+
+import (
+	"math"
+	"reflect"
+
+	"github.com/bloeys/gglm/gglm"
+	"github.com/bloeys/nmage/assert"
+	"github.com/bloeys/nmage/logging"
+	"github.com/go-gl/gl/v4.1-core/gl"
+)
+
+type UniformBufferFieldInput struct {
+	Id   uint16
+	Type ElementType
+	// Count should be set in case this field is an array of type `[Count]Type`.
+	// Count=0 is valid and is equivalent to Count=1, which means the type is NOT an array, but a single field.
+	Count uint16
+
+	// Subfields is used when type is a struct, in which case it holds the fields of the struct.
+	// Ids do not have to be unique across structs.
+	Subfields []UniformBufferFieldInput
+}
+
+type UniformBufferField struct {
+	Id            uint16
+	AlignedOffset uint16
+	// Count should be set in case this field is an array of type `[Count]Type`.
+	// Count=0 is valid and is equivalent to Count=1, which means the type is NOT an array, but a single field.
+	Count uint16
+	Type  ElementType
+
+	// Subfields is used when type is a struct, in which case it holds the fields of the struct.
+	// Ids do not have to be unique across structs.
+	Subfields []UniformBufferField
+}
+
+type UniformBuffer struct {
+	Id uint32
+	// Size is the allocated memory in bytes on the GPU for this uniform buffer
+	Size   uint32
+	Fields []UniformBufferField
+}
+
+func (ub *UniformBuffer) Bind() {
+	gl.BindBuffer(gl.UNIFORM_BUFFER, ub.Id)
+}
+
+func (ub *UniformBuffer) UnBind() {
+	gl.BindBuffer(gl.UNIFORM_BUFFER, 0)
+}
+
+func (ub *UniformBuffer) SetBindPoint(bindPointIndex uint32) {
+	gl.BindBufferBase(gl.UNIFORM_BUFFER, bindPointIndex, ub.Id)
+}
+
+func addUniformBufferFieldsToArray(startAlignedOffset uint16, arrayToAddTo *[]UniformBufferField, fieldsToAdd []UniformBufferFieldInput) (totalSize uint32) {
+
+	if len(fieldsToAdd) == 0 {
+		return 0
+	}
+
+	// This function is recursive so only size the array once
+	if cap(*arrayToAddTo) == 0 {
+		*arrayToAddTo = make([]UniformBufferField, 0, len(fieldsToAdd))
+	}
+
+	var alignedOffset uint16 = 0
+	fieldIdToTypeMap := make(map[uint16]ElementType, len(fieldsToAdd))
+
+	for i := 0; i < len(fieldsToAdd); i++ {
+
+		f := fieldsToAdd[i]
+		if f.Count == 0 {
+			f.Count = 1
+		}
+
+		existingFieldType, ok := fieldIdToTypeMap[f.Id]
+		assert.T(!ok, "Uniform buffer field id is reused within the same uniform buffer. FieldId=%d was first used on a field with type=%s and then used on a different field with type=%s\n", f.Id, existingFieldType.String(), f.Type.String())
+
+		// To understand this take an example. Say we have a total offset of 100 and we are adding a vec4.
+		// Vec4s must be aligned to a 16 byte boundary but 100 is not (100 % 16 != 0).
+		//
+		// To fix this, we take the alignment error which is alignErr=100 % 16=4, but this is error to the nearest
+		// boundary, which is below the offset.
+		//
+		// To get the nearest boundary larger than the offset we can:
+		// offset + (boundary - alignErr) == 100 + (16 - 4) == 112; 112 % 16 == 0, meaning its a boundary
+		//
+		// Note that arrays of scalars/vectors are always aligned to 16 bytes, like a vec4
+		//
+		// Official spec and full details in subsection 'Standard Uniform Block Layout' at http://www.opengl.org/registry/specs/ARB/uniform_buffer_object.txt
+		var alignmentBoundary uint16 = 16
+		if f.Count == 1 {
+			alignmentBoundary = f.Type.GlStd140AlignmentBoundary()
+		}
+
+		alignmentError := alignedOffset % alignmentBoundary
+		if alignmentError != 0 {
+			alignedOffset += alignmentBoundary - alignmentError
+		}
+
+		newField := UniformBufferField{Id: f.Id, Type: f.Type, AlignedOffset: startAlignedOffset + alignedOffset, Count: f.Count}
+		*arrayToAddTo = append(*arrayToAddTo, newField)
+
+		// Prepare aligned offset for the next field.
+		//
+		// Matrices are treated as an array of column vectors, where each column is a vec4,
+		// that's why we have a multiplier depending on how many columns we have when calculating
+		// the offset
+		multiplier := uint16(1)
+		if f.Type == DataTypeMat2 {
+			multiplier = 2
+		} else if f.Type == DataTypeMat3 {
+			multiplier = 3
+		} else if f.Type == DataTypeMat4 {
+			multiplier = 4
+		}
+
+		if f.Type == DataTypeStruct {
+
+			subfieldsAlignedOffset := uint16(addUniformBufferFieldsToArray(startAlignedOffset+alignedOffset, arrayToAddTo, f.Subfields))
+
+			// Pad structs to 16 byte boundary
+			padTo16Boundary(&subfieldsAlignedOffset)
+			alignedOffset += subfieldsAlignedOffset * f.Count
+
+		} else {
+
+			// Elements advance the alignedOffset by their actual byte size.
+			// Aligned offset is padded if the place its at is not aligned to the boundary required by the next element.
+			//
+			// The exception is structs, because fields after a struct field are always aligned at a 16 byte boundary.
+			//
+			// For example, a vec3 starting at offset 80, taking 12 bytes, would put the aligned offset at 92.
+			// If the next element is a float32 (alignment boundary = 4) then no padding is required and
+			// the float will start at 92 and end at 96.
+			// However, if the element after the vec3 is a vec3 (alignment boundary = 16), then it would require
+			// a padding of 4 bytes so that it can start at 96, which is aligned to 16. In this case the second vec3
+			// would start at 96 and end at 96+12=108.
+			alignedOffset = newField.AlignedOffset + uint16(f.Type.GlStd140SizeBytes())*f.Count*multiplier - startAlignedOffset
+		}
+	}
+
+	return uint32(alignedOffset)
+}
+
+func padTo16Boundary[T uint16 | int | int32](val *T) {
+	alignmentError := *val % 16
+	if alignmentError != 0 {
+		*val += 16 - alignmentError
+	}
+}
+
+func (ub *UniformBuffer) getField(fieldId uint16, fieldType ElementType) UniformBufferField {
+
+	for i := 0; i < len(ub.Fields); i++ {
+
+		f := ub.Fields[i]
+
+		if f.Id != fieldId {
+			continue
+		}
+
+		assert.T(f.Type == fieldType, "Uniform buffer field id is reused within the same uniform buffer. FieldId=%d was first used on a field with type=%v, but is now being used on a field with type=%v\n", fieldId, f.Type.String(), fieldType.String())
+
+		return f
+	}
+
+	logging.ErrLog.Panicf("couldn't find uniform buffer field of id=%d and type=%s\n", fieldId, fieldType.String())
+	return UniformBufferField{}
+}
+
+func (ub *UniformBuffer) SetInt32(fieldId uint16, val int32) {
+
+	f := ub.getField(fieldId, DataTypeInt32)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4, gl.Ptr(&val))
+}
+
+func (ub *UniformBuffer) SetUint32(fieldId uint16, val uint32) {
+
+	f := ub.getField(fieldId, DataTypeUint32)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4, gl.Ptr(&val))
+}
+
+func (ub *UniformBuffer) SetFloat32(fieldId uint16, val float32) {
+
+	f := ub.getField(fieldId, DataTypeFloat32)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4, gl.Ptr(&val))
+}
+
+func (ub *UniformBuffer) SetVec2(fieldId uint16, val *gglm.Vec2) {
+	f := ub.getField(fieldId, DataTypeVec2)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4*2, gl.Ptr(&val.Data[0]))
+}
+
+func (ub *UniformBuffer) SetVec3(fieldId uint16, val *gglm.Vec3) {
+	f := ub.getField(fieldId, DataTypeVec3)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4*3, gl.Ptr(&val.Data[0]))
+}
+
+func (ub *UniformBuffer) SetVec4(fieldId uint16, val *gglm.Vec4) {
+	f := ub.getField(fieldId, DataTypeVec4)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4*4, gl.Ptr(&val.Data[0]))
+}
+
+func (ub *UniformBuffer) SetMat2(fieldId uint16, val *gglm.Mat2) {
+	f := ub.getField(fieldId, DataTypeMat2)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4*4, gl.Ptr(&val.Data[0][0]))
+}
+
+func (ub *UniformBuffer) SetMat3(fieldId uint16, val *gglm.Mat3) {
+	f := ub.getField(fieldId, DataTypeMat3)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4*9, gl.Ptr(&val.Data[0][0]))
+}
+
+func (ub *UniformBuffer) SetMat4(fieldId uint16, val *gglm.Mat4) {
+	f := ub.getField(fieldId, DataTypeMat4)
+	gl.BufferSubData(gl.UNIFORM_BUFFER, int(f.AlignedOffset), 4*16, gl.Ptr(&val.Data[0][0]))
+}
+
+func (ub *UniformBuffer) SetStruct(inputStruct any) {
+	setStruct(ub.Fields, make([]byte, ub.Size), inputStruct, 1000_000, false, 0)
+}
+
+func setStruct(fields []UniformBufferField, buf []byte, inputStruct any, maxFieldsToConsume int, onlyBufWrite bool, writeOffset int) (bytesWritten, fieldsConsumed int) {
+
+	if len(fields) == 0 {
+		return
+	}
+
+	if inputStruct == nil {
+		logging.ErrLog.Panicf("UniformBuffer.SetStruct called with a value that is nil")
+	}
+
+	structVal := reflect.ValueOf(inputStruct)
+	if structVal.Kind() != reflect.Struct {
+		logging.ErrLog.Panicf("UniformBuffer.SetStruct called with a value that is not a struct. Val=%v\n", inputStruct)
+	}
+
+	// Needed because fieldIndex can move faster than struct fields in case of struct fields
+	structFieldIndex := 0
+	for fieldIndex := 0; fieldIndex < len(fields) && fieldIndex < maxFieldsToConsume; fieldIndex++ {
+
+		ubField := &fields[fieldIndex]
+		valField := structVal.Field(structFieldIndex)
+
+		fieldsConsumed++
+		structFieldIndex++
+
+		kind := valField.Kind()
+		if kind == reflect.Pointer {
+			valField = valField.Elem()
+		}
+
+		var elementType reflect.Type
+		isArray := kind == reflect.Slice || kind == reflect.Array
+		if isArray {
+			elementType = valField.Type().Elem()
+			kind = elementType.Kind()
+		} else {
+			elementType = valField.Type()
+		}
+
+		if isArray {
+			assert.T(valField.Len() == int(ubField.Count), "ubo field of id=%d is an array/slice field of length=%d but got input of length=%d\n", ubField.Id, ubField.Count, valField.Len())
+		}
+
+		typeMatches := false
+		bytesWritten = int(ubField.AlignedOffset) + writeOffset
+
+		switch ubField.Type {
+
+		case DataTypeUint32:
+
+			typeMatches = elementType.Name() == "uint32"
+			if typeMatches {
+
+				if isArray {
+					Write32BitIntegerSliceToByteBufWithAlignment(buf, &bytesWritten, 16, valField.Slice(0, valField.Len()).Interface().([]uint32))
+				} else {
+					Write32BitIntegerToByteBuf(buf, &bytesWritten, uint32(valField.Uint()))
+				}
+			}
+
+		case DataTypeFloat32:
+
+			typeMatches = elementType.Name() == "float32"
+			if typeMatches {
+
+				if isArray {
+					WriteF32SliceToByteBufWithAlignment(buf, &bytesWritten, 16, valField.Slice(0, valField.Len()).Interface().([]float32))
+				} else {
+					WriteF32ToByteBuf(buf, &bytesWritten, float32(valField.Float()))
+				}
+			}
+
+		case DataTypeInt32:
+
+			typeMatches = elementType.Name() == "int32"
+			if typeMatches {
+
+				if isArray {
+					Write32BitIntegerSliceToByteBufWithAlignment(buf, &bytesWritten, 16, valField.Slice(0, valField.Len()).Interface().([]int32))
+				} else {
+					Write32BitIntegerToByteBuf(buf, &bytesWritten, uint32(valField.Int()))
+				}
+			}
+
+		case DataTypeVec2:
+
+			typeMatches = elementType.Name() == "Vec2"
+
+			if typeMatches {
+
+				if isArray {
+					WriteVec2SliceToByteBufWithAlignment(buf, &bytesWritten, 16, valField.Slice(0, valField.Len()).Interface().([]gglm.Vec2))
+				} else {
+					v2 := valField.Interface().(gglm.Vec2)
+					WriteF32SliceToByteBuf(buf, &bytesWritten, v2.Data[:])
+				}
+			}
+
+		case DataTypeVec3:
+
+			typeMatches = elementType.Name() == "Vec3"
+
+			if typeMatches {
+
+				if isArray {
+					WriteVec3SliceToByteBufWithAlignment(buf, &bytesWritten, 16, valField.Slice(0, valField.Len()).Interface().([]gglm.Vec3))
+				} else {
+					v3 := valField.Interface().(gglm.Vec3)
+					WriteF32SliceToByteBuf(buf, &bytesWritten, v3.Data[:])
+				}
+			}
+
+		case DataTypeVec4:
+
+			typeMatches = elementType.Name() == "Vec4"
+
+			if typeMatches {
+
+				if isArray {
+					WriteVec4SliceToByteBufWithAlignment(buf, &bytesWritten, 16, valField.Slice(0, valField.Len()).Interface().([]gglm.Vec4))
+				} else {
+					v3 := valField.Interface().(gglm.Vec4)
+					WriteF32SliceToByteBuf(buf, &bytesWritten, v3.Data[:])
+				}
+			}
+
+		case DataTypeMat2:
+
+			typeMatches = elementType.Name() == "Mat2"
+
+			if typeMatches {
+
+				if isArray {
+					m2Arr := valField.Interface().([]gglm.Mat2)
+					WriteMat2SliceToByteBufWithAlignment(buf, &bytesWritten, 16*2, m2Arr)
+				} else {
+					m := valField.Interface().(gglm.Mat2)
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[0][:])
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[1][:])
+				}
+			}
+
+		case DataTypeMat3:
+
+			typeMatches = elementType.Name() == "Mat3"
+
+			if typeMatches {
+
+				if isArray {
+					m3Arr := valField.Interface().([]gglm.Mat3)
+					WriteMat3SliceToByteBufWithAlignment(buf, &bytesWritten, 16*3, m3Arr)
+				} else {
+					m := valField.Interface().(gglm.Mat3)
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[0][:])
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[1][:])
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[2][:])
+				}
+			}
+
+		case DataTypeMat4:
+
+			typeMatches = elementType.Name() == "Mat4"
+
+			if typeMatches {
+
+				if isArray {
+					m4Arr := valField.Interface().([]gglm.Mat4)
+					WriteMat4SliceToByteBufWithAlignment(buf, &bytesWritten, 16*4, m4Arr)
+				} else {
+					m := valField.Interface().(gglm.Mat4)
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[0][:])
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[1][:])
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[2][:])
+					WriteF32SliceToByteBuf(buf, &bytesWritten, m.Data[3][:])
+				}
+			}
+
+		case DataTypeStruct:
+
+			typeMatches = kind == reflect.Struct
+
+			if typeMatches {
+
+				if isArray {
+
+					offset := 0
+					arrSize := valField.Len()
+					fieldsToUse := fields[fieldIndex+1:]
+					for i := 0; i < arrSize; i++ {
+
+						setStructBytesWritten, setStructFieldsConsumed := setStruct(fieldsToUse, buf, valField.Index(i).Interface(), elementType.NumField(), true, offset*i)
+
+						if offset == 0 {
+							offset = setStructBytesWritten
+							padTo16Boundary(&offset)
+
+							bytesWritten += offset * arrSize
+
+							// Tracking consumed fields is needed because if we have a struct inside another struct
+							// elementType.NumField() will only give us the fields consumed by the first struct,
+							// but we need to count all fields of all nested structs inside this one
+							fieldIndex += setStructFieldsConsumed
+							fieldsConsumed += setStructFieldsConsumed
+						}
+					}
+
+				} else {
+
+					setStructBytesWritten, setStructFieldsConsumed := setStruct(fields[fieldIndex+1:], buf, valField.Interface(), valField.NumField(), true, writeOffset)
+
+					bytesWritten += setStructBytesWritten
+					fieldIndex += setStructFieldsConsumed
+					fieldsConsumed += setStructFieldsConsumed
+				}
+			}
+
+		default:
+			assert.T(false, "Unknown uniform buffer data type passed. DataType '%d'", ubField.Type)
+		}
+
+		if !typeMatches {
+			logging.ErrLog.Panicf("Struct field ordering and types must match uniform buffer fields, but at field index %d got UniformBufferField=%v but a struct field of type %s\n", fieldIndex, ubField, valField.String())
+		}
+	}
+
+	if bytesWritten == 0 {
+		return 0, fieldsConsumed
+	}
+
+	if !onlyBufWrite {
+		gl.BufferSubData(gl.UNIFORM_BUFFER, 0, bytesWritten, gl.Ptr(&buf[0]))
+	}
+
+	return bytesWritten - int(fields[0].AlignedOffset) - writeOffset, fieldsConsumed
+}
+
+func Write32BitIntegerToByteBuf[T uint32 | int32](buf []byte, startIndex *int, val T) {
+
+	assert.T(*startIndex+4 <= len(buf), "failed to write uint32/int32 to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d", *startIndex, len(buf))
+
+	buf[*startIndex] = byte(val)
+	buf[*startIndex+1] = byte(val >> 8)
+	buf[*startIndex+2] = byte(val >> 16)
+	buf[*startIndex+3] = byte(val >> 24)
+
+	*startIndex += 4
+}
+
+func Write32BitIntegerSliceToByteBufWithAlignment[T uint32 | int32](buf []byte, startIndex *int, alignmentPerField int, vals []T) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerField <= len(buf), "failed to write uint32/int32 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerField, *startIndex, len(buf), len(vals)*alignmentPerField)
+
+	for i := 0; i < len(vals); i++ {
+
+		val := vals[i]
+
+		buf[*startIndex] = byte(val)
+		buf[*startIndex+1] = byte(val >> 8)
+		buf[*startIndex+2] = byte(val >> 16)
+		buf[*startIndex+3] = byte(val >> 24)
+
+		*startIndex += alignmentPerField
+	}
+}
+
+func WriteF32ToByteBuf(buf []byte, startIndex *int, val float32) {
+
+	assert.T(*startIndex+4 <= len(buf), "failed to write float32 to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d", *startIndex, len(buf))
+
+	bits := math.Float32bits(val)
+
+	buf[*startIndex] = byte(bits)
+	buf[*startIndex+1] = byte(bits >> 8)
+	buf[*startIndex+2] = byte(bits >> 16)
+	buf[*startIndex+3] = byte(bits >> 24)
+
+	*startIndex += 4
+}
+
+func WriteF32SliceToByteBuf(buf []byte, startIndex *int, vals []float32) {
+
+	assert.T(*startIndex+len(vals)*4 <= len(buf), "failed to write slice of float32 to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", *startIndex, len(buf), len(vals)*4)
+
+	for i := 0; i < len(vals); i++ {
+
+		bits := math.Float32bits(vals[i])
+
+		buf[*startIndex] = byte(bits)
+		buf[*startIndex+1] = byte(bits >> 8)
+		buf[*startIndex+2] = byte(bits >> 16)
+		buf[*startIndex+3] = byte(bits >> 24)
+
+		*startIndex += 4
+	}
+}
+
+func WriteF32SliceToByteBufWithAlignment(buf []byte, startIndex *int, alignmentPerField int, vals []float32) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerField <= len(buf), "failed to write slice of float32 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerField, *startIndex, len(buf), len(vals)*alignmentPerField)
+
+	for i := 0; i < len(vals); i++ {
+
+		bits := math.Float32bits(vals[i])
+
+		buf[*startIndex] = byte(bits)
+		buf[*startIndex+1] = byte(bits >> 8)
+		buf[*startIndex+2] = byte(bits >> 16)
+		buf[*startIndex+3] = byte(bits >> 24)
+
+		*startIndex += alignmentPerField
+	}
+}
+
+func WriteVec2SliceToByteBufWithAlignment(buf []byte, startIndex *int, alignmentPerVector int, vals []gglm.Vec2) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerVector <= len(buf), "failed to write slice of gglm.Vec2 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerVector, *startIndex, len(buf), len(vals)*alignmentPerVector)
+
+	for i := 0; i < len(vals); i++ {
+
+		bitsX := math.Float32bits(vals[i].X())
+		bitsY := math.Float32bits(vals[i].Y())
+
+		buf[*startIndex] = byte(bitsX)
+		buf[*startIndex+1] = byte(bitsX >> 8)
+		buf[*startIndex+2] = byte(bitsX >> 16)
+		buf[*startIndex+3] = byte(bitsX >> 24)
+
+		buf[*startIndex+4] = byte(bitsY)
+		buf[*startIndex+5] = byte(bitsY >> 8)
+		buf[*startIndex+6] = byte(bitsY >> 16)
+		buf[*startIndex+7] = byte(bitsY >> 24)
+
+		*startIndex += alignmentPerVector
+	}
+}
+
+func WriteVec3SliceToByteBufWithAlignment(buf []byte, startIndex *int, alignmentPerVector int, vals []gglm.Vec3) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerVector <= len(buf), "failed to write slice of gglm.Vec3 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerVector, *startIndex, len(buf), len(vals)*alignmentPerVector)
+
+	for i := 0; i < len(vals); i++ {
+
+		bitsX := math.Float32bits(vals[i].X())
+		bitsY := math.Float32bits(vals[i].Y())
+		bitsZ := math.Float32bits(vals[i].Z())
+
+		buf[*startIndex] = byte(bitsX)
+		buf[*startIndex+1] = byte(bitsX >> 8)
+		buf[*startIndex+2] = byte(bitsX >> 16)
+		buf[*startIndex+3] = byte(bitsX >> 24)
+
+		buf[*startIndex+4] = byte(bitsY)
+		buf[*startIndex+5] = byte(bitsY >> 8)
+		buf[*startIndex+6] = byte(bitsY >> 16)
+		buf[*startIndex+7] = byte(bitsY >> 24)
+
+		buf[*startIndex+8] = byte(bitsZ)
+		buf[*startIndex+9] = byte(bitsZ >> 8)
+		buf[*startIndex+10] = byte(bitsZ >> 16)
+		buf[*startIndex+11] = byte(bitsZ >> 24)
+
+		*startIndex += alignmentPerVector
+	}
+}
+
+func WriteVec4SliceToByteBufWithAlignment(buf []byte, startIndex *int, alignmentPerVector int, vals []gglm.Vec4) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerVector <= len(buf), "failed to write slice of gglm.Vec4 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerVector, *startIndex, len(buf), len(vals)*alignmentPerVector)
+
+	for i := 0; i < len(vals); i++ {
+
+		bitsX := math.Float32bits(vals[i].X())
+		bitsY := math.Float32bits(vals[i].Y())
+		bitsZ := math.Float32bits(vals[i].Z())
+		bitsW := math.Float32bits(vals[i].W())
+
+		buf[*startIndex] = byte(bitsX)
+		buf[*startIndex+1] = byte(bitsX >> 8)
+		buf[*startIndex+2] = byte(bitsX >> 16)
+		buf[*startIndex+3] = byte(bitsX >> 24)
+
+		buf[*startIndex+4] = byte(bitsY)
+		buf[*startIndex+5] = byte(bitsY >> 8)
+		buf[*startIndex+6] = byte(bitsY >> 16)
+		buf[*startIndex+7] = byte(bitsY >> 24)
+
+		buf[*startIndex+8] = byte(bitsZ)
+		buf[*startIndex+9] = byte(bitsZ >> 8)
+		buf[*startIndex+10] = byte(bitsZ >> 16)
+		buf[*startIndex+11] = byte(bitsZ >> 24)
+
+		buf[*startIndex+12] = byte(bitsW)
+		buf[*startIndex+13] = byte(bitsW >> 8)
+		buf[*startIndex+14] = byte(bitsW >> 16)
+		buf[*startIndex+15] = byte(bitsW >> 24)
+
+		*startIndex += alignmentPerVector
+	}
+}
+
+func WriteMat2SliceToByteBufWithAlignment(buf []byte, startIndex *int, alignmentPerMatrix int, vals []gglm.Mat2) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerMatrix <= len(buf), "failed to write slice of gglm.Mat2 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerMatrix, *startIndex, len(buf), len(vals)*alignmentPerMatrix)
+
+	for i := 0; i < len(vals); i++ {
+
+		m := &vals[i]
+
+		WriteVec2SliceToByteBufWithAlignment(
+			buf,
+			startIndex,
+			16,
+			[]gglm.Vec2{
+				{Data: m.Data[0]},
+				{Data: m.Data[1]},
+			},
+		)
+	}
+}
+
+func WriteMat3SliceToByteBufWithAlignment(buf []byte, startIndex *int, alignmentPerMatrix int, vals []gglm.Mat3) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerMatrix <= len(buf), "failed to write slice of gglm.Mat3 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerMatrix, *startIndex, len(buf), len(vals)*alignmentPerMatrix)
+
+	for i := 0; i < len(vals); i++ {
+
+		m := &vals[i]
+
+		WriteVec3SliceToByteBufWithAlignment(
+			buf,
+			startIndex,
+			16,
+			[]gglm.Vec3{
+				{Data: m.Data[0]},
+				{Data: m.Data[1]},
+				{Data: m.Data[2]},
+			},
+		)
+	}
+}
+
+func WriteMat4SliceToByteBufWithAlignment(buf []byte, startIndex *int, alignmentPerMatrix int, vals []gglm.Mat4) {
+
+	assert.T(*startIndex+len(vals)*alignmentPerMatrix <= len(buf), "failed to write slice of gglm.Mat2 with custom alignment=%d to buffer because the buffer doesn't have enough space. Start index=%d, Buffer length=%d, but needs %d bytes free", alignmentPerMatrix, *startIndex, len(buf), len(vals)*alignmentPerMatrix)
+
+	for i := 0; i < len(vals); i++ {
+
+		m := &vals[i]
+
+		WriteVec4SliceToByteBufWithAlignment(
+			buf,
+			startIndex,
+			16,
+			[]gglm.Vec4{
+				{Data: m.Data[0]},
+				{Data: m.Data[1]},
+				{Data: m.Data[2]},
+				{Data: m.Data[3]},
+			},
+		)
+	}
+}
+
+func ReflectValueMatchesUniformBufferField(v reflect.Value, ubField *UniformBufferField) bool {
+
+	if v.Kind() == reflect.Pointer {
+		v = v.Elem()
+	}
+
+	switch ubField.Type {
+
+	case DataTypeUint32:
+		t := v.Type()
+		return t.Name() == "uint32"
+	case DataTypeFloat32:
+		t := v.Type()
+		return t.Name() == "float32"
+	case DataTypeInt32:
+		t := v.Type()
+		return t.Name() == "int32"
+	case DataTypeVec2:
+		_, ok := v.Interface().(gglm.Vec2)
+		return ok
+	case DataTypeVec3:
+		_, ok := v.Interface().(gglm.Vec3)
+		return ok
+	case DataTypeVec4:
+		_, ok := v.Interface().(gglm.Vec4)
+		return ok
+	case DataTypeMat2:
+		_, ok := v.Interface().(gglm.Mat2)
+		return ok
+	case DataTypeMat3:
+		_, ok := v.Interface().(gglm.Mat3)
+		return ok
+	case DataTypeMat4:
+		_, ok := v.Interface().(gglm.Mat4)
+		return ok
+
+	default:
+		assert.T(false, "Unknown uniform buffer data type passed. DataType '%d'", ubField.Type)
+		return false
+	}
+}
+
+func NewUniformBuffer(fields []UniformBufferFieldInput, usage BufUsage) UniformBuffer {
+
+	ub := UniformBuffer{}
+
+	ub.Size = addUniformBufferFieldsToArray(0, &ub.Fields, fields)
+
+	gl.GenBuffers(1, &ub.Id)
+	if ub.Id == 0 {
+		logging.ErrLog.Panicln("Failed to create OpenGL buffer for a uniform buffer")
+	}
+
+	ub.Bind()
+	gl.BufferData(gl.UNIFORM_BUFFER, int(ub.Size), gl.Ptr(nil), usage.ToGL())
+	ub.UnBind()
+
+	return ub
+}

buffers/vertex_buffer.go

@@ -55,7 +55,7 @@ func NewVertexBuffer(layout ...Element) VertexBuffer {
 
 	gl.GenBuffers(1, &vb.Id)
 	if vb.Id == 0 {
-		logging.ErrLog.Println("Failed to create OpenGL buffer")
+		logging.ErrLog.Panicln("Failed to create OpenGL buffer")
 	}
 
 	vb.SetLayout(layout...)

engine/engine.go

@@ -107,9 +107,9 @@ func (w *Window) handleInputs() {
 	}
 
 	// If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
-	imIo.SetMouseButtonDown(imgui.MouseButtonLeft, isSdlButtonLeftDown)
-	imIo.SetMouseButtonDown(imgui.MouseButtonRight, isSdlButtonRightDown)
-	imIo.SetMouseButtonDown(imgui.MouseButtonMiddle, isSdlButtonMiddleDown)
+	imIo.SetMouseButtonDown(int(imgui.MouseButtonLeft), isSdlButtonLeftDown)
+	imIo.SetMouseButtonDown(int(imgui.MouseButtonRight), isSdlButtonRightDown)
+	imIo.SetMouseButtonDown(int(imgui.MouseButtonMiddle), isSdlButtonMiddleDown)
 }
 
 func (w *Window) handleWindowResize() {

engine/game.go

@@ -41,7 +41,6 @@ func Run(g Game, w *Window, rend renderer.Render, ui nmageimgui.ImguiInfo) {
 
 	for isRunning {
 
-		//PERF: Cache these
 		width, height = w.SDLWin.GetSize()
 		fbWidth, fbHeight = w.SDLWin.GLGetDrawableSize()
 

go.mod

@@ -1,6 +1,6 @@
 module github.com/bloeys/nmage
 
-go 1.22
+go 1.23
 
 require github.com/veandco/go-sdl2 v0.4.35
 
@@ -8,12 +8,15 @@ require github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6
 
 require (
 	github.com/bloeys/assimp-go v0.4.4
-	github.com/bloeys/gglm v0.49.0
+	github.com/bloeys/gglm v0.50.0
 )
 
 require (
-	github.com/AllenDang/cimgui-go v0.0.0-20230720025235-f2ff398a66b2
+	github.com/AllenDang/cimgui-go v0.0.0-20240912193335-545751598105
 	github.com/mandykoh/prism v0.35.1
 )
 
-require github.com/mandykoh/go-parallel v0.1.0 // indirect
+require (
+	github.com/mandykoh/go-parallel v0.1.0 // indirect
+	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect
+)

go.sum

@@ -1,9 +1,11 @@
 github.com/AllenDang/cimgui-go v0.0.0-20230720025235-f2ff398a66b2 h1:3HA/5qD8Rimxz/y1sLyVaM7ws1dzjXzMt4hOBiwHggo=
 github.com/AllenDang/cimgui-go v0.0.0-20230720025235-f2ff398a66b2/go.mod h1:iNfbIyOBN8k3XScMxULbrwYbPsXEAUD0Jb6UwrspQb8=
+github.com/AllenDang/cimgui-go v0.0.0-20240912193335-545751598105 h1:bhXqv2EG5YCLdgkLSFCpqeVz4cCoNbi4RDFrHrwxQ1o=
+github.com/AllenDang/cimgui-go v0.0.0-20240912193335-545751598105/go.mod h1:CYfBRenCaNtSvKVzChYh6gswUSo6c5IUcYeV6eCCRw0=
 github.com/bloeys/assimp-go v0.4.4 h1:Yn5e/RpE0Oes0YMBy8O7KkwAO4R/RpgrZPJCt08dVIU=
 github.com/bloeys/assimp-go v0.4.4/go.mod h1:my3yRxT7CfOztmvi+0svmwbaqw0KFrxaHxncoyaEIP0=
-github.com/bloeys/gglm v0.49.0 h1:YtbyHpszYhjnxw7KVV0LaCdBktRMqfGx/i37EMomxsE=
-github.com/bloeys/gglm v0.49.0/go.mod h1:qwJQ0WzV191wAMwlGicbfbChbKoSedMk7gFFX6GnyOk=
+github.com/bloeys/gglm v0.50.0 h1:DlGLp9z8KMNx+hNR6PjnPmC0HjDRC19QwAKL1iwhOxs=
+github.com/bloeys/gglm v0.50.0/go.mod h1:5s2U/NiOrtJyrSup1j8wK+QOBmGIO03ub0LHMvuNSK8=
 github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6 h1:zDw5v7qm4yH7N8C8uWd+8Ii9rROdgWxQuGoJ9WDXxfk=
 github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw=
 github.com/mandykoh/go-parallel v0.1.0 h1:7vJMNMC4dsbgZdkAb2A8tV5ENY1v7VxIO1wzQWZoT8k=
@@ -15,6 +17,8 @@ github.com/veandco/go-sdl2 v0.4.35/go.mod h1:OROqMhHD43nT4/i9crJukyVecjPNYYuCofe
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
 golang.org/x/image v0.5.0 h1:5JMiNunQeQw++mMOz48/ISeNu3Iweh/JaZU8ZLqHRrI=
 golang.org/x/image v0.5.0/go.mod h1:FVC7BI/5Ym8R25iw5OLsgshdUBbT1h5jZTpA+mvAdZ4=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=

main.go

@@ -38,16 +38,16 @@ import (
 		- Create VAO struct independent from VBO to support multi-VBO use cases (e.g. instancing) ✅
 		- Normals maps ✅
 		- HDR ✅
-		- Fix bad point light acne
-		- UBO support
-		- Cascaded shadow mapping
+		- Fix bad point light acne ✅
+		- UBO support ✅
 		- Skeletal animations
+		- (?) Cascaded shadow mapping
 	- In some cases we DO want input even when captured by UI. We need two systems within input package, one filtered and one not✅
+	- (?) Support OpenGL 4.1 and 4.6, and default to 4.6
 	- Proper model loading (i.e. load model by reading all its meshes, textures, and so on together)
 	- Renderer batching
 	- Scene graph
-	- Separate engine loop from rendering loop? or leave it to the user?
-	- Abstract keys enum away from sdl?
+	- (?) Separate engine loop from rendering loop
 	- Frustum culling
 	- Proper Asset loading system
 	- Material system editor with fields automatically extracted from the shader
@@ -60,10 +60,16 @@ type DirLight struct {
 }
 
 var (
+	renderDirLightShadows   = true
+	renderPointLightShadows = true
+	renderSpotLightShadows  = true
+
 	dirLightSize float32 = 30
 	dirLightNear float32 = 0.1
 	dirLightFar  float32 = 30
 	dirLightPos          = gglm.NewVec3(0, 10, 0)
+
+	pointLightRadiusToFarPlaneRatio float32 = 1.25
 )
 
 func (d *DirLight) GetProjViewMat() gglm.Mat4 {
@@ -82,19 +88,34 @@ func (d *DirLight) GetProjViewMat() gglm.Mat4 {
 	return *projMat.Mul(&viewMat)
 }
 
-// Check https://wiki.ogre3d.org/tiki-index.php?page=-Point+Light+Attenuation for values
+// Based on: https://lisyarus.github.io/blog/posts/point-light-attenuation.html
 type PointLight struct {
 	Pos           gglm.Vec3
 	DiffuseColor  gglm.Vec3
 	SpecularColor gglm.Vec3
 
-	// @TODO
-	Radius float32
+	Radius  float32
+	Falloff float32
 
-	Constant  float32
-	Linear    float32
-	Quadratic float32
+	// MaxBias is the max shadow bias applied for this light.
+	// A usual value is 0.05
+	MaxBias float32
 
+	// NearPlane is the distance where if the pixel
+	// is closer to the light than this distance, no shadow will be casted.
+	//
+	// This helps not produce shadows from within objects.
+	// Same idea a camera near plane.
+	NearPlane float32
+
+	// Far plane is the max distance at which shadows from this
+	// light will show.
+	//
+	// This should be a bit bigger than the radius, as an object
+	// at the edge of the radius should still cast a shadow, and
+	// so this shadow will be further than the radius.
+	//
+	// Something like 'FarPlane=Radius*1.25' might work.
 	FarPlane float32
 }
 
@@ -186,22 +207,71 @@ func (s *SpotLight) OuterCutoffCos() float32 {
 	return gglm.Cos32(s.OuterCutoffRad)
 }
 
+type GlobalMatricesUboData struct {
+	CamPos      gglm.Vec3
+	ProjViewMat gglm.Mat4
+}
+
+type DirLightUboData struct {
+	Dir           gglm.Vec3
+	DiffuseColor  gglm.Vec3
+	SpecularColor gglm.Vec3
+}
+
+type PointLightUboData struct {
+	Pos           gglm.Vec3
+	DiffuseColor  gglm.Vec3
+	SpecularColor gglm.Vec3
+	Radius        float32
+	Falloff       float32
+	MaxBias       float32
+	NearPlane     float32
+	FarPlane      float32
+}
+
+type SpotLightUboData struct {
+	Pos           gglm.Vec3
+	Dir           gglm.Vec3
+	DiffuseColor  gglm.Vec3
+	SpecularColor gglm.Vec3
+	InnerCutoff   float32
+	OuterCutoff   float32
+}
+
+type LightsUboData struct {
+	DirLight     DirLightUboData
+	PointLights  [POINT_LIGHT_COUNT]PointLightUboData
+	SpotLights   [SPOT_LIGHT_COUNT]SpotLightUboData
+	AmbientColor gglm.Vec3
+}
+
 const (
+
+	// These must match the shader values
+	POINT_LIGHT_COUNT = 8
+	SPOT_LIGHT_COUNT  = 4
+
 	UNSCALED_WINDOW_WIDTH  = 1280
 	UNSCALED_WINDOW_HEIGHT = 720
 
-	PROFILE_CPU = true
-	PROFILE_MEM = true
+	PROFILE_CPU = false
+	PROFILE_MEM = false
 
 	FRAME_TIME_MS_SAMPLES = 10000
 )
 
 var (
+	globalMatricesUboData GlobalMatricesUboData
+	globalMatricesUbo     buffers.UniformBuffer
+
+	lightsUboData LightsUboData
+	lightsUbo     buffers.UniformBuffer
+
 	frameTimesMsIndex int       = 0
 	frameTimesMs      []float32 = make([]float32, 0, FRAME_TIME_MS_SAMPLES)
 
-	camSpeed         float32 = 15
-	mouseSensitivity float32 = 0.5
+	camMoveSpeed float32 = 15
+	camRotSpeed  float32 = 0.5
 
 	window engine.Window
 
@@ -264,58 +334,48 @@ var (
 	dpiScaling float32
 
 	// Light settings
-	ambientColor = gglm.NewVec3(0, 0, 0)
-
 	dirLightDir = gglm.NewVec3(0, -0.5, -0.8)
 	// Lights
 	dirLight = DirLight{
 		Dir:           *dirLightDir.Normalize(),
-		DiffuseColor:  gglm.NewVec3(1, 1, 1),
+		DiffuseColor:  gglm.NewVec3(63.0/255, 63.0/255, 63.0/255),
 		SpecularColor: gglm.NewVec3(1, 1, 1),
 	}
-	pointLights = [...]PointLight{
+	pointLights = [POINT_LIGHT_COUNT]PointLight{
 		{
-			Pos:           gglm.NewVec3(0, 2, -2),
+			Pos:           gglm.NewVec3(0, 4, -3),
 			DiffuseColor:  gglm.NewVec3(1, 0, 0),
 			SpecularColor: gglm.NewVec3(1, 1, 1),
-			// These values are for 50m range
-			Constant:  1.0,
-			Linear:    0.09,
-			Quadratic: 0.032,
-
-			FarPlane: 25,
-		},
-		{
-			Pos:           gglm.NewVec3(0, -5, 0),
-			DiffuseColor:  gglm.NewVec3(0, 1, 0),
-			SpecularColor: gglm.NewVec3(1, 1, 1),
-			Constant:      1.0,
-			Linear:        0.09,
-			Quadratic:     0.032,
-			FarPlane:      25,
+			Radius:        10,
+			Falloff:       1.0,
+			MaxBias:       0.05,
+			NearPlane:     0.2,
+			FarPlane:      20 * pointLightRadiusToFarPlaneRatio,
 		},
 		{
 			Pos:           gglm.NewVec3(5, 0, 0),
 			DiffuseColor:  gglm.NewVec3(1, 1, 1),
 			SpecularColor: gglm.NewVec3(1, 1, 1),
-			Constant:      1.0,
-			Linear:        0.09,
-			Quadratic:     0.032,
-			FarPlane:      25,
+			Radius:        10,
+			Falloff:       1.0,
+			MaxBias:       0.05,
+			NearPlane:     0.2,
+			FarPlane:      20 * pointLightRadiusToFarPlaneRatio,
 		},
 		{
 			Pos:           gglm.NewVec3(-3, 4, 3),
 			DiffuseColor:  gglm.NewVec3(1, 1, 1),
 			SpecularColor: gglm.NewVec3(1, 1, 1),
-			Constant:      1.0,
-			Linear:        0.09,
-			Quadratic:     0.032,
-			FarPlane:      25,
+			Radius:        10,
+			Falloff:       1.0,
+			MaxBias:       0.05,
+			NearPlane:     0.2,
+			FarPlane:      20 * pointLightRadiusToFarPlaneRatio,
 		},
 	}
 
 	spotLightDir0 = gglm.NewVec3(1.5, -0.9, 0)
-	spotLights    = [...]SpotLight{
+	spotLights    = [SPOT_LIGHT_COUNT]SpotLight{
 		{
 			Pos:           gglm.NewVec3(-4, 7, 5),
 			Dir:           *spotLightDir0.Normalize(),
@@ -412,9 +472,10 @@ func (g *Game) handleWindowEvents(e sdl.Event) {
 
 			g.WinWidth = e.Data1
 			g.WinHeight = e.Data2
-			cam.AspectRatio = float32(g.WinWidth) / float32(g.WinHeight)
 
+			cam.AspectRatio = float32(g.WinWidth) / float32(g.WinHeight)
 			cam.Update()
+
 			updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
 		}
 	}
@@ -461,7 +522,7 @@ func (g *Game) Init() {
 	// Camera
 	winWidth, winHeight := g.Win.SDLWin.GetSize()
 
-	camPos := gglm.NewVec3(0, 0, 10)
+	camPos := gglm.NewVec3(0, 10, 20)
 	camForward := gglm.NewVec3(0, 0, -1)
 	camWorldUp := gglm.NewVec3(0, 1, 0)
 	cam = camera.NewPerspective(
@@ -552,12 +613,8 @@ func (g *Game) Init() {
 	whiteMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
 	whiteMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
 	whiteMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
-	whiteMat.SetUnifVec3("ambientColor", &ambientColor)
 	whiteMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
-	whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-	whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	whiteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	whiteMat.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
 	whiteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	whiteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -570,12 +627,8 @@ func (g *Game) Init() {
 	containerMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
 	containerMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
 	containerMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
-	containerMat.SetUnifVec3("ambientColor", &ambientColor)
 	containerMat.SetUnifFloat32("material.shininess", containerMat.Shininess)
-	containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-	containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	containerMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	containerMat.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
 	containerMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	containerMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -588,12 +641,8 @@ func (g *Game) Init() {
 	groundMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
 	groundMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
 	groundMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
-	groundMat.SetUnifVec3("ambientColor", &ambientColor)
 	groundMat.SetUnifFloat32("material.shininess", groundMat.Shininess)
-	groundMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-	groundMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	groundMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	groundMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	groundMat.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
 	groundMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	groundMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -605,12 +654,8 @@ func (g *Game) Init() {
 	palleteMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
 	palleteMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
 	palleteMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
-	palleteMat.SetUnifVec3("ambientColor", &ambientColor)
 	palleteMat.SetUnifFloat32("material.shininess", palleteMat.Shininess)
-	palleteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-	palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	palleteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	palleteMat.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
 	palleteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	palleteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -643,17 +688,89 @@ func (g *Game) Init() {
 	// We don't actually care about the values here because the quad is hardcoded in the shader,
 	// but we just want to have a vao with 6 vertices and uv0 so opengl can be called properly
 	screenQuadVbo := buffers.NewVertexBuffer(buffers.Element{ElementType: buffers.DataTypeVec3}, buffers.Element{ElementType: buffers.DataTypeVec2})
-	screenQuadVbo.SetData(make([]float32, 6), buffers.BufUsage_Static)
+	screenQuadVbo.SetData(make([]float32, 6), buffers.BufUsage_Static_Draw)
 	screenQuadVao = buffers.NewVertexArray()
 	screenQuadVao.AddVertexBuffer(screenQuadVbo)
 
 	// Fbos and lights
 	g.initFbos()
-	g.updateLights()
+	// Ubos
+	g.initUbos()
 
 	// Initial camera update
 	cam.Update()
 	updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
+
+	lightsUboData.AmbientColor = gglm.NewVec3(20.0/255, 20.0/255, 20.0/255)
+	g.applyLightUpdates()
+}
+
+func (g *Game) initUbos() {
+
+	globalMatricesUbo = buffers.NewUniformBuffer(
+		[]buffers.UniformBufferFieldInput{
+			{Id: 0, Type: buffers.DataTypeVec3},
+			{Id: 1, Type: buffers.DataTypeMat4},
+		},
+		buffers.BufUsage_Dynamic_Draw,
+	)
+
+	globalMatricesUbo.SetBindPoint(0)
+	groundMat.SetUniformBlockBindingPoint("GlobalMatrices", 0)
+	whiteMat.SetUniformBlockBindingPoint("GlobalMatrices", 0)
+	containerMat.SetUniformBlockBindingPoint("GlobalMatrices", 0)
+	palleteMat.SetUniformBlockBindingPoint("GlobalMatrices", 0)
+
+	lightsUbo = buffers.NewUniformBuffer(
+		[]buffers.UniformBufferFieldInput{
+			// Dir light
+			{Id: 0, Type: buffers.DataTypeStruct,
+				Subfields: []buffers.UniformBufferFieldInput{
+					{Id: 1, Type: buffers.DataTypeVec3}, // 12 00
+					{Id: 2, Type: buffers.DataTypeVec3}, // 12 16
+					{Id: 3, Type: buffers.DataTypeVec3}, // 12 32
+				},
+			},
+			// Point lights
+			{Id: 5, Type: buffers.DataTypeStruct,
+				Count: POINT_LIGHT_COUNT,
+				Subfields: []buffers.UniformBufferFieldInput{
+					{Id: 6, Type: buffers.DataTypeVec3},     // 12 48
+					{Id: 7, Type: buffers.DataTypeVec3},     // 12 64
+					{Id: 8, Type: buffers.DataTypeVec3},     // 12 80
+					{Id: 9, Type: buffers.DataTypeFloat32},  // 04 92
+					{Id: 10, Type: buffers.DataTypeFloat32}, // 04 96
+					{Id: 11, Type: buffers.DataTypeFloat32}, // 04 100
+					{Id: 12, Type: buffers.DataTypeFloat32}, // 04 104
+					{Id: 13, Type: buffers.DataTypeFloat32}, // 04 108
+				},
+			},
+			// Spot lights
+			{Id: 14, Type: buffers.DataTypeStruct,
+				Count: SPOT_LIGHT_COUNT,
+				Subfields: []buffers.UniformBufferFieldInput{
+					{Id: 15, Type: buffers.DataTypeVec3},    // 12 112
+					{Id: 16, Type: buffers.DataTypeVec3},    // 12 128
+					{Id: 17, Type: buffers.DataTypeVec3},    // 12 144
+					{Id: 18, Type: buffers.DataTypeVec3},    // 12 160
+					{Id: 19, Type: buffers.DataTypeFloat32}, // 04 172
+					{Id: 20, Type: buffers.DataTypeFloat32}, // 04 176
+				},
+			},
+
+			// Ambient
+			{Id: 21, Type: buffers.DataTypeVec3}, // 12 192
+		},
+		buffers.BufUsage_Dynamic_Draw,
+	)
+
+	// fmt.Printf("\n==Lights UBO (id=%d)==\nSize=%d\nFields: %+v\n\n", lightsUbo.Id, lightsUbo.Size, lightsUbo.Fields)
+
+	lightsUbo.SetBindPoint(1)
+	groundMat.SetUniformBlockBindingPoint("Lights", 1)
+	whiteMat.SetUniformBlockBindingPoint("Lights", 1)
+	containerMat.SetUniformBlockBindingPoint("Lights", 1)
+	palleteMat.SetUniformBlockBindingPoint("Lights", 1)
 }
 
 func (g *Game) initFbos() {
@@ -676,7 +793,7 @@ func (g *Game) initFbos() {
 	assert.T(demoFbo.IsComplete(), "Demo fbo is not complete after init")
 
 	// Depth map fbo
-	dirLightDepthMapFbo = buffers.NewFramebuffer(2048, 2048)
+	dirLightDepthMapFbo = buffers.NewFramebuffer(4096, 4096)
 	dirLightDepthMapFbo.SetNoColorBuffer()
 	dirLightDepthMapFbo.NewDepthAttachment(
 		buffers.FramebufferAttachmentType_Texture,
@@ -686,7 +803,7 @@ func (g *Game) initFbos() {
 	assert.T(dirLightDepthMapFbo.IsComplete(), "Depth map fbo is not complete after init")
 
 	// Point light depth map fbo
-	pointLightDepthMapFbo = buffers.NewFramebuffer(512, 512)
+	pointLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024)
 	pointLightDepthMapFbo.SetNoColorBuffer()
 	pointLightDepthMapFbo.NewDepthCubemapArrayAttachment(
 		buffers.FramebufferAttachmentDataFormat_DepthF32,
@@ -696,7 +813,7 @@ func (g *Game) initFbos() {
 	assert.T(pointLightDepthMapFbo.IsComplete(), "Point light depth map fbo is not complete after init")
 
 	// Spot light depth map fbo
-	spotLightDepthMapFbo = buffers.NewFramebuffer(512, 512)
+	spotLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024)
 	spotLightDepthMapFbo.SetNoColorBuffer()
 	spotLightDepthMapFbo.NewDepthTextureArrayAttachment(
 		buffers.FramebufferAttachmentDataFormat_DepthF32,
@@ -720,9 +837,12 @@ func (g *Game) initFbos() {
 	assert.T(hdrFbo.IsComplete(), "Hdr fbo is not complete after init")
 }
 
-func (g *Game) updateLights() {
+// applyLightUpdates updates materials and light ubo using
+// data from the game's light structs
+func (g *Game) applyLightUpdates() {
 
 	// Directional light
+	lightsUboData.DirLight = DirLightUboData(dirLight)
 	whiteMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
 	containerMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
 	groundMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
@@ -732,42 +852,7 @@ func (g *Game) updateLights() {
 	for i := 0; i < len(pointLights); i++ {
 
 		p := &pointLights[i]
-		indexString := "pointLights[" + strconv.Itoa(i) + "]"
-
-		whiteMat.SetUnifVec3(indexString+".pos", &p.Pos)
-		containerMat.SetUnifVec3(indexString+".pos", &p.Pos)
-		groundMat.SetUnifVec3(indexString+".pos", &p.Pos)
-		palleteMat.SetUnifVec3(indexString+".pos", &p.Pos)
-
-		whiteMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
-		containerMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
-		groundMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
-		palleteMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
-
-		whiteMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
-		containerMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
-		groundMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
-		palleteMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
-
-		whiteMat.SetUnifFloat32(indexString+".constant", p.Constant)
-		containerMat.SetUnifFloat32(indexString+".constant", p.Constant)
-		groundMat.SetUnifFloat32(indexString+".constant", p.Constant)
-		palleteMat.SetUnifFloat32(indexString+".constant", p.Constant)
-
-		whiteMat.SetUnifFloat32(indexString+".linear", p.Linear)
-		containerMat.SetUnifFloat32(indexString+".linear", p.Linear)
-		groundMat.SetUnifFloat32(indexString+".linear", p.Linear)
-		palleteMat.SetUnifFloat32(indexString+".linear", p.Linear)
-
-		whiteMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
-		containerMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
-		groundMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
-		palleteMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
-
-		whiteMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
-		containerMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
-		groundMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
-		palleteMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
+		lightsUboData.PointLights[i] = PointLightUboData(*p)
 	}
 
 	whiteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
@@ -782,43 +867,24 @@ func (g *Game) updateLights() {
 		innerCutoffCos := l.InnerCutoffCos()
 		outerCutoffCos := l.OuterCutoffCos()
 
-		indexString := "spotLights[" + strconv.Itoa(i) + "]"
-
-		whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
-		containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
-		groundMat.SetUnifVec3(indexString+".pos", &l.Pos)
-		palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)
-
-		whiteMat.SetUnifVec3(indexString+".dir", &l.Dir)
-		containerMat.SetUnifVec3(indexString+".dir", &l.Dir)
-		groundMat.SetUnifVec3(indexString+".dir", &l.Dir)
-		palleteMat.SetUnifVec3(indexString+".dir", &l.Dir)
-
-		whiteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-		containerMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-		groundMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-		palleteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-
-		whiteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-		containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-		groundMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-		palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-
-		whiteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
-		containerMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
-		groundMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
-		palleteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
-
-		whiteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
-		containerMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
-		groundMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
-		palleteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
+		lightsUboData.SpotLights[i] = SpotLightUboData{
+			Pos:           l.Pos,
+			Dir:           l.Dir,
+			DiffuseColor:  l.DiffuseColor,
+			SpecularColor: l.SpecularColor,
+			InnerCutoff:   innerCutoffCos,
+			OuterCutoff:   outerCutoffCos,
+		}
 	}
 
 	whiteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
 	containerMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
 	groundMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
 	palleteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
+
+	// Apply changes
+	lightsUbo.Bind()
+	lightsUbo.SetStruct(lightsUboData)
 }
 
 func (g *Game) Update() {
@@ -830,11 +896,10 @@ func (g *Game) Update() {
 	g.updateCameraLookAround()
 	g.updateCameraPos()
 
-	g.showDebugWindow()
+	globalMatricesUboData.CamPos = cam.Pos
+	updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
 
-	if input.KeyClicked(sdl.K_F4) {
-		logging.InfoLog.Printf("Pos: %s; Forward: %s; |Forward|: %f\n", cam.Pos.String(), cam.Forward.String(), cam.Forward.Mag())
-	}
+	g.showDebugWindow()
 }
 
 func (g *Game) showDebugWindow() {
@@ -843,7 +908,7 @@ func (g *Game) showDebugWindow() {
 
 	imgui.Begin("Debug controls")
 
-	imgui.PushStyleColorVec4(imgui.ColText, imgui.NewColor(1, 1, 0, 1).Value)
+	imgui.PushStyleColorVec4(imgui.ColText, imgui.NewColor(1, 1, 0, 1).FieldValue)
 	imgui.LabelText("FPS", fmt.Sprint(timing.GetAvgFPS()))
 	imgui.PopStyleColor()
 
@@ -858,7 +923,7 @@ func (g *Game) showDebugWindow() {
 		}
 	}
 
-	imgui.PlotLinesFloatPtrV("Frame Times", frameTimesMs, int32(len(frameTimesMs)), 0, "", 0, 16, imgui.Vec2{Y: 200}, 4)
+	imgui.PlotLinesFloatPtrV("Frame Times", frameTimesMs, int32(len(frameTimesMs)), 0, "", 0, 16, imgui.Vec2{Y: 50}, 4)
 
 	imgui.Spacing()
 
@@ -877,20 +942,22 @@ func (g *Game) showDebugWindow() {
 
 	imgui.Text("HDR")
 	imgui.Checkbox("Enable HDR", &hdrRendering)
-	if imgui.DragFloat("Exposure", &hdrExposure) {
+	if imgui.DragFloatV("Exposure", &hdrExposure, 0.1, -10, 100, "%.3f", imgui.SliderFlagsNone) {
 		tonemappedScreenQuadMat.SetUnifFloat32("exposure", hdrExposure)
 	}
 
 	imgui.Spacing()
 
+	//
+	// Lights
+	//
+	updateLights := false
+
 	// Ambient light
 	imgui.Text("Ambient Light")
 
-	if imgui.DragFloat3("Ambient Color", &ambientColor.Data) {
-		whiteMat.SetUnifVec3("ambientColor", &ambientColor)
-		containerMat.SetUnifVec3("ambientColor", &ambientColor)
-		groundMat.SetUnifVec3("ambientColor", &ambientColor)
-		palleteMat.SetUnifVec3("ambientColor", &ambientColor)
+	if imgui.ColorEdit3("Ambient Color", &lightsUboData.AmbientColor.Data) {
+		updateLights = true
 	}
 
 	imgui.Spacing()
@@ -901,30 +968,29 @@ func (g *Game) showDebugWindow() {
 	imgui.Checkbox("Render Directional Light Shadows", &renderDirLightShadows)
 
 	if imgui.DragFloat3("Direction", &dirLight.Dir.Data) {
-		whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-		containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-		groundMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-		palleteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+		updateLights = true
 	}
 
-	if imgui.DragFloat3("Diffuse Color", &dirLight.DiffuseColor.Data) {
-		whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-		containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-		groundMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-		palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+	if imgui.ColorEdit3("Diffuse Color", &dirLight.DiffuseColor.Data) {
+		updateLights = true
 	}
 
-	if imgui.DragFloat3("Specular Color", &dirLight.SpecularColor.Data) {
-		whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-		containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-		groundMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-		palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+	if imgui.ColorEdit3("Specular Color", &dirLight.SpecularColor.Data) {
+		updateLights = true
 	}
 
-	imgui.DragFloat3("dPos", &dirLightPos.Data)
-	imgui.DragFloat("dSize", &dirLightSize)
-	imgui.DragFloat("dNear", &dirLightNear)
-	imgui.DragFloat("dFar", &dirLightFar)
+	if imgui.DragFloat3("dPos", &dirLightPos.Data) {
+		updateLights = true
+	}
+	if imgui.DragFloat("dSize", &dirLightSize) {
+		updateLights = true
+	}
+	if imgui.DragFloat("dNear", &dirLightNear) {
+		updateLights = true
+	}
+	if imgui.DragFloat("dFar", &dirLightFar) {
+		updateLights = true
+	}
 
 	imgui.Spacing()
 
@@ -953,27 +1019,29 @@ func (g *Game) showDebugWindow() {
 				continue
 			}
 
-			indexString := "pointLights[" + indexNumString + "]"
-
 			if imgui.DragFloat3("Pos", &pl.Pos.Data) {
-				whiteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
-				containerMat.SetUnifVec3(indexString+".pos", &pl.Pos)
-				groundMat.SetUnifVec3(indexString+".pos", &pl.Pos)
-				palleteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
+				updateLights = true
 			}
 
-			if imgui.DragFloat3("Diffuse Color", &pl.DiffuseColor.Data) {
-				whiteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
-				containerMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
-				groundMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
-				palleteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+			if imgui.ColorEdit3("Diffuse Color", &pl.DiffuseColor.Data) {
+				updateLights = true
 			}
 
-			if imgui.DragFloat3("Specular Color", &pl.SpecularColor.Data) {
-				whiteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
-				containerMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
-				groundMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
-				palleteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+			if imgui.ColorEdit3("Specular Color", &pl.SpecularColor.Data) {
+				updateLights = true
+			}
+
+			if imgui.DragFloatV("Falloff", &pl.Falloff, 0.1, 0, 100, "%.3f", imgui.SliderFlagsNone) {
+				updateLights = true
+			}
+
+			if imgui.DragFloatV("Radius", &pl.Radius, 0.2, 0, 500, "%.3f", imgui.SliderFlagsNone) {
+				updateLights = true
+				pl.FarPlane = pl.Radius * pointLightRadiusToFarPlaneRatio
+			}
+
+			if imgui.DragFloatV("Max Bias", &pl.MaxBias, 0.01, 0, 10, "%.3f", imgui.SliderFlagsNone) {
+				updateLights = true
 			}
 
 			imgui.TreePop()
@@ -996,54 +1064,34 @@ func (g *Game) showDebugWindow() {
 				continue
 			}
 
-			indexString := "spotLights[" + indexNumString + "]"
-
 			if imgui.DragFloat3("Pos", &l.Pos.Data) {
-				whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
-				containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
-				groundMat.SetUnifVec3(indexString+".pos", &l.Pos)
-				palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+				updateLights = true
 			}
 
 			if imgui.DragFloat3("Dir", &l.Dir.Data) {
-				whiteMat.SetUnifVec3(indexString+".dir", &l.Dir)
-				containerMat.SetUnifVec3(indexString+".dir", &l.Dir)
-				groundMat.SetUnifVec3(indexString+".dir", &l.Dir)
-				palleteMat.SetUnifVec3(indexString+".dir", &l.Dir)
+				updateLights = true
 			}
 
-			if imgui.DragFloat3("Diffuse Color", &l.DiffuseColor.Data) {
-				whiteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-				containerMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-				groundMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-				palleteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+			if imgui.ColorEdit3("Diffuse Color", &l.DiffuseColor.Data) {
+				updateLights = true
 			}
 
-			if imgui.DragFloat3("Specular Color", &l.SpecularColor.Data) {
-				whiteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-				containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-				groundMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-				palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
+			if imgui.ColorEdit3("Specular Color", &l.SpecularColor.Data) {
+				updateLights = true
 			}
 
-			if imgui.DragFloat("Inner Cutoff Radians", &l.InnerCutoffRad) {
-
-				cos := l.InnerCutoffCos()
-
-				whiteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-				containerMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-				groundMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-				palleteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-			}
-
-			if imgui.DragFloat("Outer Cutoff Radians", &l.OuterCutoffRad) {
-
-				cos := l.OuterCutoffCos()
-
-				whiteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
-				containerMat.SetUnifFloat32(indexString+".outerCutoff", cos)
-				groundMat.SetUnifFloat32(indexString+".outerCutoff", cos)
-				palleteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
+			if imgui.DragFloatRange2V(
+				"Cutoff Radians",
+				&l.InnerCutoffRad,
+				&l.OuterCutoffRad,
+				0.1,
+				0,
+				0,
+				"%.3f",
+				"%.3f",
+				imgui.SliderFlagsNone,
+			) {
+				updateLights = true
 			}
 
 			imgui.DragFloat("Spot Near Plane", &l.NearPlane)
@@ -1055,6 +1103,10 @@ func (g *Game) showDebugWindow() {
 		imgui.EndListBox()
 	}
 
+	if updateLights {
+		g.applyLightUpdates()
+	}
+
 	// Demo fbo
 	imgui.Text("Demo Framebuffer")
 	imgui.Checkbox("Show FBO##0", &renderToDemoFbo)
@@ -1084,11 +1136,15 @@ func (g *Game) updateCameraLookAround() {
 		return
 	}
 
+	const MAX_MOUSE_MOVE = 300
+	mouseX = gglm.Clamp(mouseX, -MAX_MOUSE_MOVE, MAX_MOUSE_MOVE)
+	mouseY = gglm.Clamp(mouseY, -MAX_MOUSE_MOVE, MAX_MOUSE_MOVE)
+
 	// Yaw
-	yaw += float32(mouseX) * mouseSensitivity * timing.DT()
+	yaw += float32(mouseX) * camRotSpeed * timing.DT()
 
 	// Pitch
-	pitch += float32(-mouseY) * mouseSensitivity * timing.DT()
+	pitch += float32(-mouseY) * camRotSpeed * timing.DT()
 	if pitch > 1.5 {
 		pitch = 1.5
 	}
@@ -1097,10 +1153,7 @@ func (g *Game) updateCameraLookAround() {
 		pitch = -1.5
 	}
 
-	// Update cam forward
 	cam.UpdateRotation(pitch, yaw)
-
-	updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
 }
 
 func (g *Game) updateCameraPos() {
@@ -1114,35 +1167,30 @@ func (g *Game) updateCameraPos() {
 
 	// Forward and backward
 	if input.KeyDown(sdl.K_w) {
-		cam.Pos.Add(cam.Forward.Clone().Scale(camSpeed * camSpeedScale * timing.DT()))
+		cam.Pos.Add(cam.Forward.Clone().Scale(camMoveSpeed * camSpeedScale * timing.DT()))
 		update = true
 	} else if input.KeyDown(sdl.K_s) {
-		cam.Pos.Add(cam.Forward.Clone().Scale(-camSpeed * camSpeedScale * timing.DT()))
+		cam.Pos.Add(cam.Forward.Clone().Scale(-camMoveSpeed * camSpeedScale * timing.DT()))
 		update = true
 	}
 
 	// Left and right
 	if input.KeyDown(sdl.K_d) {
 		cross := gglm.Cross(&cam.Forward, &cam.WorldUp)
-		cam.Pos.Add(cross.Normalize().Scale(camSpeed * camSpeedScale * timing.DT()))
+		cam.Pos.Add(cross.Normalize().Scale(camMoveSpeed * camSpeedScale * timing.DT()))
 		update = true
 	} else if input.KeyDown(sdl.K_a) {
 		cross := gglm.Cross(&cam.Forward, &cam.WorldUp)
-		cam.Pos.Add(cross.Normalize().Scale(-camSpeed * camSpeedScale * timing.DT()))
+		cam.Pos.Add(cross.Normalize().Scale(-camMoveSpeed * camSpeedScale * timing.DT()))
 		update = true
 	}
 
 	if update {
 		cam.Update()
-		updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
 	}
 }
 
 var (
-	renderDirLightShadows   = true
-	renderPointLightShadows = true
-	renderSpotLightShadows  = true
-
 	rotatingCubeSpeedDeg1 float32 = 45
 	rotatingCubeSpeedDeg2 float32 = 120
 	rotatingCubeSpeedDeg3 float32 = 120
@@ -1153,10 +1201,8 @@ var (
 
 func (g *Game) Render() {
 
-	whiteMat.SetUnifVec3("camPos", &cam.Pos)
-	containerMat.SetUnifVec3("camPos", &cam.Pos)
-	groundMat.SetUnifVec3("camPos", &cam.Pos)
-	palleteMat.SetUnifVec3("camPos", &cam.Pos)
+	globalMatricesUbo.Bind()
+	globalMatricesUbo.SetStruct(globalMatricesUboData)
 
 	rotatingCubeTrMat1.Rotate(rotatingCubeSpeedDeg1*gglm.Deg2Rad*timing.DT(), 0, 1, 0)
 	rotatingCubeTrMat2.Rotate(rotatingCubeSpeedDeg2*gglm.Deg2Rad*timing.DT(), 1, 1, 0)
@@ -1409,12 +1455,9 @@ func (g *Game) DeInit() {
 func updateAllProjViewMats(projMat, viewMat gglm.Mat4) {
 
 	projViewMat := *projMat.Clone().Mul(&viewMat)
+	globalMatricesUboData.ProjViewMat = projViewMat
 
 	unlitMat.SetUnifMat4("projViewMat", &projViewMat)
-	whiteMat.SetUnifMat4("projViewMat", &projViewMat)
-	containerMat.SetUnifMat4("projViewMat", &projViewMat)
-	groundMat.SetUnifMat4("projViewMat", &projViewMat)
-	palleteMat.SetUnifMat4("projViewMat", &projViewMat)
 	debugDepthMat.SetUnifMat4("projViewMat", &projViewMat)
 
 	// Update skybox projViewMat

materials/material.go

@@ -124,6 +124,21 @@ func (m *Material) UnBind() {
 	gl.UseProgram(0)
 }
 
+func (m *Material) SetUniformBlockBindingPoint(uniformBlockName string, bindPointIndex uint32) {
+
+	nullStr := gl.Str(uniformBlockName + "\x00")
+	index := gl.GetUniformBlockIndex(m.ShaderProg.Id, nullStr)
+	assert.T(
+		index != gl.INVALID_INDEX,
+		"SetUniformBlockBindingPoint for material=%s (matId=%d; shaderId=%d) failed because the uniform block=%s wasn't found",
+		m.Name,
+		m.Id,
+		m.ShaderProg.Id,
+		uniformBlockName,
+	)
+	gl.UniformBlockBinding(m.ShaderProg.Id, index, bindPointIndex)
+}
+
 func (m *Material) GetAttribLoc(attribName string) int32 {
 
 	loc, ok := m.AttribLocs[attribName]
@@ -131,7 +146,8 @@ func (m *Material) GetAttribLoc(attribName string) int32 {
 		return loc
 	}
 
-	loc = gl.GetAttribLocation(m.ShaderProg.Id, gl.Str(attribName+"\x00"))
+	name := gl.Str(attribName + "\x00")
+	loc = gl.GetAttribLocation(m.ShaderProg.Id, name)
 	assert.T(loc != -1, "Attribute '"+attribName+"' doesn't exist on material "+m.Name)
 	m.AttribLocs[attribName] = loc
 	return loc
@@ -144,7 +160,8 @@ func (m *Material) GetUnifLoc(uniformName string) int32 {
 		return loc
 	}
 
-	loc = gl.GetUniformLocation(m.ShaderProg.Id, gl.Str(uniformName+"\x00"))
+	name := gl.Str(uniformName + "\x00")
+	loc = gl.GetUniformLocation(m.ShaderProg.Id, name)
 	assert.T(loc != -1, "Uniform '"+uniformName+"' doesn't exist on material "+m.Name)
 	m.UnifLocs[uniformName] = loc
 	return loc

meshes/mesh.go

@@ -151,7 +151,7 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (Mesh, e
 		indexBufData = append(indexBufData, indices...)
 	}
 
-	vbo.SetData(vertexBufData, buffers.BufUsage_Static)
+	vbo.SetData(vertexBufData, buffers.BufUsage_Static_Draw)
 	ibo.SetData(indexBufData)
 
 	mesh.Vao.AddVertexBuffer(vbo)

res/shaders/simple.glsl

@@ -14,33 +14,25 @@ layout(location=3) in vec2 vertUV0In;
 layout(location=4) in vec3 vertColorIn;
 
 //
-// Uniforms
+// UBOs
 //
-uniform vec3 camPos;
-uniform mat4 modelMat;
-uniform mat3 normalMat;
-uniform mat4 projViewMat;
-uniform mat4 dirLightProjViewMat;
-uniform mat4 spotLightProjViewMats[NUM_SPOT_LIGHTS];
-
 struct DirLight {
     vec3 dir;
     vec3 diffuseColor;
     vec3 specularColor;
-    sampler2D shadowMap;
 };
-uniform DirLight dirLight;
+uniform sampler2D dirLightShadowMap;
 
 struct PointLight {
     vec3 pos;
     vec3 diffuseColor;
     vec3 specularColor;
-    float constant;
-    float linear;
-    float quadratic;
+    float radius;
+    float falloff;
+    float maxBias;
+    float nearPlane;
     float farPlane;
 };
-uniform PointLight pointLights[NUM_POINT_LIGHTS];
 
 struct SpotLight {
     vec3 pos;
@@ -50,7 +42,25 @@ struct SpotLight {
     float innerCutoff;
     float outerCutoff;
 };
-uniform SpotLight spotLights[NUM_SPOT_LIGHTS];
+
+layout (std140) uniform GlobalMatrices {
+    vec3 camPos;
+    mat4 projViewMat;
+};
+
+layout (std140) uniform Lights {
+    DirLight dirLight;
+    PointLight pointLights[NUM_POINT_LIGHTS];
+    SpotLight spotLights[NUM_SPOT_LIGHTS];
+    vec3 ambientColor;
+};
+
+//
+// Uniforms
+//
+uniform mat4 modelMat;
+uniform mat4 dirLightProjViewMat;
+uniform mat4 spotLightProjViewMats[NUM_SPOT_LIGHTS];
 
 //
 // Outputs
@@ -154,20 +164,19 @@ struct DirLight {
     vec3 dir;
     vec3 diffuseColor;
     vec3 specularColor;
-    sampler2D shadowMap;
 };
-uniform DirLight dirLight;
+uniform sampler2D dirLightShadowMap;
 
 struct PointLight {
     vec3 pos;
     vec3 diffuseColor;
     vec3 specularColor;
-    float constant;
-    float linear;
-    float quadratic;
+    float radius;
+    float falloff;
+    float maxBias;
+    float nearPlane;
     float farPlane;
 };
-uniform PointLight pointLights[NUM_POINT_LIGHTS];
 uniform samplerCubeArray pointLightCubeShadowMaps;
 
 struct SpotLight {
@@ -178,10 +187,19 @@ struct SpotLight {
     float innerCutoff;
     float outerCutoff;
 };
-uniform SpotLight spotLights[NUM_SPOT_LIGHTS];
 uniform sampler2DArray spotLightShadowMaps;
 
-uniform vec3 ambientColor = vec3(0.2, 0.2, 0.2);
+layout (std140) uniform GlobalMatrices {
+    vec3 camPos;
+    mat4 projViewMat;
+};
+
+layout (std140) uniform Lights {
+    DirLight dirLight;
+    PointLight pointLights[NUM_POINT_LIGHTS];
+    SpotLight spotLights[NUM_SPOT_LIGHTS];
+    vec3 ambientColor;
+};
 
 //
 // Outputs
@@ -248,34 +266,88 @@ vec3 CalcDirLight()
     vec3 finalSpecular = specularAmount * dirLight.specularColor * specularTexColor.rgb;
 
     // Shadow
-    float shadow = CalcDirShadow(dirLight.shadowMap, lightDir);
+    float shadow = CalcDirShadow(dirLightShadowMap, lightDir);
 
     return (finalDiffuse + finalSpecular) * (1 - shadow);
 }
 
-float CalcPointShadow(int lightIndex, vec3 worldLightPos, vec3 tangentLightDir, float farPlane) {
+float CalcPointShadow(int lightIndex, vec3 worldLightPos, vec3 tangentLightDir, float maxBias, float nearPlane, float farPlane) {
 
     vec3 lightToFrag = fragPos - worldLightPos;
 
+    // Get depth of current fragment
+    float currentDepth = length(lightToFrag);
+
+    if (currentDepth < nearPlane) {
+        return 0;
+    }
+
     float closestDepth = texture(pointLightCubeShadowMaps, vec4(lightToFrag, lightIndex)).r;
 
     // We stored depth in the cubemap in the range [0, 1], so now we move back to [0, farPlane]
     closestDepth *= farPlane;
 
-    // Get depth of current fragment
-    float currentDepth = length(lightToFrag);
+    float bias = max(maxBias * (1 - dot(normalizedVertNorm, tangentLightDir)), 0.005);
 
-    float bias = max(0.05 * (1 - dot(normalizedVertNorm, tangentLightDir)), 0.005);
-
-    float shadow = currentDepth -  bias > closestDepth ? 1.0 : 0.0;
+    float shadow = currentDepth - bias > closestDepth ? 1 : 0;
 
     return shadow;
 }
 
+//
+// The following point light attenuation formulas
+// are from https://lisyarus.github.io/blog/posts/point-light-attenuation.html
+//
+// I found them more intuitive than the standard implementation and it also ensures
+// we have zero light at the selected distance.
+//
+float sqr(float x)
+{
+    return x * x;
+}
+
+// This version doesn't have a harsh cutoff at radius
+float AttenuateNoCusp(float dist, float radius, float falloff)
+{
+    // Since we only use this as attenuation and max intensity defines
+    // the max output value, anything more than 1 would increase
+    // the output of the light, which I don't think makes sense for
+    // our attenuation purposes.
+    //
+    // Seems to me this can be done simply by increasing color values above 255. 
+    //
+    // Forcing to 1 for now.
+    #define MAX_INTENSITY 1
+
+    float s = dist / radius;
+
+    if (s >= 1.0)
+        return 0.0;
+
+    float s2 = sqr(s);
+
+    return MAX_INTENSITY * sqr(1 - s2) / (1 + falloff * s2);
+}
+
+// This version has a harsh/immediate cutoff at radius
+float AttenuateCusp(float dist, float radius, float falloff)
+{
+    #define MAX_INTENSITY 1
+
+    float s = dist / radius;
+
+    if (s >= 1.0)
+        return 0.0;
+
+    float s2 = sqr(s);
+
+    return MAX_INTENSITY * sqr(1 - s2) / (1 + falloff * s);
+}
+
 vec3 CalcPointLight(PointLight pointLight, int lightIndex)
 {
-    // Ignore unset lights
-    if (pointLight.constant == 0){
+    // Ignore inactive lights
+    if (pointLight.radius == 0){
         return vec3(0);
     }
 
@@ -293,10 +365,10 @@ vec3 CalcPointLight(PointLight pointLight, int lightIndex)
 
     // Attenuation
     float distToLight = length(tangentLightPos - tangentFragPos);
-    float attenuation = 1 / (pointLight.constant + pointLight.linear * distToLight + pointLight.quadratic * (distToLight * distToLight));  
+    float attenuation = AttenuateNoCusp(distToLight, pointLight.radius, pointLight.falloff);
 
     // Shadow
-    float shadow = CalcPointShadow(lightIndex, pointLight.pos, tangentLightDir, pointLight.farPlane);
+    float shadow = CalcPointShadow(lightIndex, pointLight.pos, tangentLightDir, pointLight.maxBias, pointLight.nearPlane, pointLight.farPlane);
 
     return (finalDiffuse + finalSpecular) * attenuation * (1 - shadow);
 }
@@ -343,7 +415,10 @@ float CalcSpotShadow(vec3 tangentLightDir, int lightIndex)
 
 vec3 CalcSpotLight(SpotLight light, int lightIndex)
 {
-    if (light.innerCutoff == 0)
+    // The inner/outer cutoffs are cosine values,
+    // which means a value of 1 is mainly produced when the input
+    // is 0 degrees or radians. cos(180) will also be 1, but that's too much :)
+    if (light.innerCutoff == 1)
         return vec3(0);
 
     vec3 tangentLightDir = tangentSpotLightDirections[lightIndex];

ui/imgui/imgui.go

@@ -1,6 +1,17 @@
 package nmageimgui
 
 import (
+	"unsafe"
+
+	// The following is included just so we can get
+	// the c imports and cgo configs defined here: https://github.com/AllenDang/cimgui-go/blob/main/sdlbackend/sdl_backend.go
+	//
+	// This is needed because AllenDang/cimgui-go links sdl2 statically, which requires us
+	// to explicitly define all the libs it needs, which isn't normally needed if we were dynamically linking.
+	//
+	// Without this, we get compilation errors as sdl2 can't find libs it relies on.
+	_ "github.com/AllenDang/cimgui-go/sdlbackend"
+
 	imgui "github.com/AllenDang/cimgui-go"
 	"github.com/bloeys/gglm/gglm"
 	"github.com/bloeys/nmage/materials"
@@ -129,7 +140,7 @@ func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *im
 
 	fontConfigToUse := imgui.NewFontConfig()
 	if fontConfig != nil {
-		fontConfigToUse = *fontConfig
+		fontConfigToUse = fontConfig
 	}
 
 	glyphRangesToUse := imgui.NewGlyphRange()
@@ -141,13 +152,13 @@ func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *im
 
 	a := imIO.Fonts()
 	f := a.AddFontFromFileTTFV(fontPath, fontSize, fontConfigToUse, glyphRangesToUse.Data())
-	pixels, width, height, _ := a.GetTextureDataAsAlpha8()
+	pixels, width, height, _ := a.TextureDataAsAlpha8()
 
 	gl.ActiveTexture(gl.TEXTURE0)
 	gl.BindTexture(gl.TEXTURE_2D, *i.TexID)
 	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(width), int32(height), 0, gl.RED, gl.UNSIGNED_BYTE, pixels)
 
-	return f
+	return *f
 }
 
 const DefaultImguiShader = `
@@ -212,7 +223,7 @@ func NewImGui(shaderPath string) ImguiInfo {
 	}
 
 	imguiInfo := ImguiInfo{
-		ImCtx: imgui.CreateContext(),
+		ImCtx: *imgui.CreateContext(),
 		Mat:   imguiMat,
 		TexID: new(uint32),
 	}
@@ -233,11 +244,12 @@ func NewImGui(shaderPath string) ImguiInfo {
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
 	gl.PixelStorei(gl.UNPACK_ROW_LENGTH, 0)
 
-	pixels, width, height, _ := io.Fonts().GetTextureDataAsAlpha8()
+	pixels, width, height, _ := io.Fonts().TextureDataAsAlpha8()
 	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(width), int32(height), 0, gl.RED, gl.UNSIGNED_BYTE, pixels)
 
 	// Store our identifier
-	io.Fonts().SetTexID(imgui.TextureID(imguiInfo.TexID))
+
+	io.Fonts().SetTexID(imgui.TextureID{Data: uintptr(unsafe.Pointer(imguiInfo.TexID))})
 
 	//Shader attributes
 	imguiInfo.Mat.Bind()