Working mac arm+mac x86+windows x86 builds

.github/workflows/build-nmage.yml

@@ -1,24 +1,69 @@
 name: build-nmage
 
 on:
+  push:
+    branches:
+      - dev
   create:
   workflow_dispatch:
 
 jobs:
-  build-nmage-macos:
+  build-nmage-windows:
-    runs-on: macos-12
+    runs-on: windows-latest
-    steps:
 
+    steps:
       - name: Install golang
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
-          go-version: '>=1.22'
+          go-version: ">=1.23"
+
+      - name: Install assimp-go dll
+        run: |
+          Invoke-WebRequest -Uri "https://github.com/bloeys/assimp-go/releases/download/v0.4.2/libassimp-5.dll" -OutFile "C:\Windows\System32\libassimp-5.dll"
+
+      - name: Download and setup SDL2
+        run: |
+          Invoke-WebRequest -Uri "https://github.com/libsdl-org/SDL/releases/download/release-2.30.7/SDL2-devel-2.30.7-mingw.zip" -OutFile "SDL2.zip"
+          Expand-Archive -Path "SDL2.zip" -DestinationPath "SDL2"
+          Copy-Item -Path "SDL2\SDL2-2.30.7\x86_64-w64-mingw32" -Destination "C:\mingw64" -Recurse -Force
+
+      - 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_amd64.dylib -O /usr/local/lib/libassimp.5.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,_mixer,_ttf,_gfx} pkg-config
+        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)
+// ElementType is the type of an element thats makes up a buffer (e.g. Vec3)
-type ElementType int
+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(int(imgui.MouseButtonLeft), isSdlButtonLeftDown)
-	imIo.SetMouseButtonDown(imgui.MouseButtonRight, isSdlButtonRightDown)
+	imIo.SetMouseButtonDown(int(imgui.MouseButtonRight), isSdlButtonRightDown)
-	imIo.SetMouseButtonDown(imgui.MouseButtonMiddle, isSdlButtonMiddleDown)
+	imIo.SetMouseButtonDown(int(imgui.MouseButtonMiddle), isSdlButtonMiddleDown)
 }
 
 func (w *Window) handleWindowResize() {

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
 
@@ -12,7 +12,7 @@ require (
 )
 
 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
 )
 

go.sum

@@ -1,5 +1,7 @@
 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.50.0 h1:DlGLp9z8KMNx+hNR6PjnPmC0HjDRC19QwAKL1iwhOxs=

main.go

@@ -39,15 +39,15 @@ import (
 		- Normals maps ✅
 		- HDR ✅
 		- Fix bad point light acne ✅
-		- UBO support
+		- UBO support ✅
-		- Cascaded shadow mapping
 		- 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?
+	- (?) Separate engine loop from rendering loop
-	- Abstract keys enum away from sdl?
 	- Frustum culling
 	- Proper Asset loading system
 	- Material system editor with fields automatically extracted from the shader
@@ -97,6 +97,10 @@ type PointLight struct {
 	Radius  float32
 	Falloff 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.
 	//
@@ -104,10 +108,6 @@ type PointLight struct {
 	// Same idea a camera near plane.
 	NearPlane float32
 
-	// MaxBias is the max shadow bias applied for this light.
-	// A usual value is 0.05
-	MaxBias float32
-
 	// Far plane is the max distance at which shadows from this
 	// light will show.
 	//
@@ -207,17 +207,66 @@ 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_CPU = false
-	PROFILE_MEM = true
+	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)
 
@@ -285,8 +334,6 @@ var (
 	dpiScaling float32
 
 	// Light settings
-	ambientColor = gglm.NewVec3(20.0/255, 20.0/255, 20.0/255)
-
 	dirLightDir = gglm.NewVec3(0, -0.5, -0.8)
 	// Lights
 	dirLight = DirLight{
@@ -294,13 +341,13 @@ var (
 		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, 4, -3),
 			DiffuseColor:  gglm.NewVec3(1, 0, 0),
 			SpecularColor: gglm.NewVec3(1, 1, 1),
-			Falloff:       1.0,
 			Radius:        10,
+			Falloff:       1.0,
 			MaxBias:       0.05,
 			NearPlane:     0.2,
 			FarPlane:      20 * pointLightRadiusToFarPlaneRatio,
@@ -309,8 +356,8 @@ var (
 			Pos:           gglm.NewVec3(5, 0, 0),
 			DiffuseColor:  gglm.NewVec3(1, 1, 1),
 			SpecularColor: gglm.NewVec3(1, 1, 1),
-			Falloff:       1.0,
 			Radius:        10,
+			Falloff:       1.0,
 			MaxBias:       0.05,
 			NearPlane:     0.2,
 			FarPlane:      20 * pointLightRadiusToFarPlaneRatio,
@@ -319,8 +366,8 @@ var (
 			Pos:           gglm.NewVec3(-3, 4, 3),
 			DiffuseColor:  gglm.NewVec3(1, 1, 1),
 			SpecularColor: gglm.NewVec3(1, 1, 1),
-			Falloff:       1.0,
 			Radius:        10,
+			Falloff:       1.0,
 			MaxBias:       0.05,
 			NearPlane:     0.2,
 			FarPlane:      20 * pointLightRadiusToFarPlaneRatio,
@@ -328,7 +375,7 @@ var (
 	}
 
 	spotLightDir0 = gglm.NewVec3(1.5, -0.9, 0)
-	spotLights    = [...]SpotLight{
+	spotLights    = [SPOT_LIGHT_COUNT]SpotLight{
 		{
 			Pos:           gglm.NewVec3(-4, 7, 5),
 			Dir:           *spotLightDir0.Normalize(),
@@ -566,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.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
-	whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	whiteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
 	whiteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	whiteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -584,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.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
-	containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	containerMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
 	containerMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	containerMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -602,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.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
-	groundMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	groundMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	groundMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
 	groundMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	groundMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -619,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.SetUnifInt32("dirLightShadowMap", int32(materials.TextureSlot_ShadowMap1))
-	palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-	palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	palleteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
 	palleteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	palleteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
@@ -657,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() {
@@ -734,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
@@ -746,55 +852,7 @@ func (g *Game) updateLights() {
 	for i := 0; i < len(pointLights); i++ {
 
 		p := &pointLights[i]
-		indexString := "pointLights[" + strconv.Itoa(i) + "]"
+		lightsUboData.PointLights[i] = PointLightUboData(*p)
-
-		posStr := indexString + ".pos"
-		whiteMat.SetUnifVec3(posStr, &p.Pos)
-		containerMat.SetUnifVec3(posStr, &p.Pos)
-		groundMat.SetUnifVec3(posStr, &p.Pos)
-		palleteMat.SetUnifVec3(posStr, &p.Pos)
-
-		diffuseStr := indexString + ".diffuseColor"
-		whiteMat.SetUnifVec3(diffuseStr, &p.DiffuseColor)
-		containerMat.SetUnifVec3(diffuseStr, &p.DiffuseColor)
-		groundMat.SetUnifVec3(diffuseStr, &p.DiffuseColor)
-		palleteMat.SetUnifVec3(diffuseStr, &p.DiffuseColor)
-
-		specularStr := indexString + ".specularColor"
-		whiteMat.SetUnifVec3(specularStr, &p.SpecularColor)
-		containerMat.SetUnifVec3(specularStr, &p.SpecularColor)
-		groundMat.SetUnifVec3(specularStr, &p.SpecularColor)
-		palleteMat.SetUnifVec3(specularStr, &p.SpecularColor)
-
-		falloffStr := indexString + ".falloff"
-		whiteMat.SetUnifFloat32(falloffStr, p.Falloff)
-		containerMat.SetUnifFloat32(falloffStr, p.Falloff)
-		groundMat.SetUnifFloat32(falloffStr, p.Falloff)
-		palleteMat.SetUnifFloat32(falloffStr, p.Falloff)
-
-		radiusStr := indexString + ".radius"
-		whiteMat.SetUnifFloat32(radiusStr, p.Radius)
-		containerMat.SetUnifFloat32(radiusStr, p.Radius)
-		groundMat.SetUnifFloat32(radiusStr, p.Radius)
-		palleteMat.SetUnifFloat32(radiusStr, p.Radius)
-
-		maxBiasStr := indexString + ".maxBias"
-		whiteMat.SetUnifFloat32(maxBiasStr, p.MaxBias)
-		containerMat.SetUnifFloat32(maxBiasStr, p.MaxBias)
-		groundMat.SetUnifFloat32(maxBiasStr, p.MaxBias)
-		palleteMat.SetUnifFloat32(maxBiasStr, p.MaxBias)
-
-		nearPlaneStr := indexString + ".nearPlane"
-		whiteMat.SetUnifFloat32(nearPlaneStr, p.NearPlane)
-		containerMat.SetUnifFloat32(nearPlaneStr, p.NearPlane)
-		groundMat.SetUnifFloat32(nearPlaneStr, p.NearPlane)
-		palleteMat.SetUnifFloat32(nearPlaneStr, p.NearPlane)
-
-		farPlaneStr := indexString + ".farPlane"
-		whiteMat.SetUnifFloat32(farPlaneStr, p.FarPlane)
-		containerMat.SetUnifFloat32(farPlaneStr, p.FarPlane)
-		groundMat.SetUnifFloat32(farPlaneStr, p.FarPlane)
-		palleteMat.SetUnifFloat32(farPlaneStr, p.FarPlane)
 	}
 
 	whiteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
@@ -809,43 +867,24 @@ func (g *Game) updateLights() {
 		innerCutoffCos := l.InnerCutoffCos()
 		outerCutoffCos := l.OuterCutoffCos()
 
-		indexString := "spotLights[" + strconv.Itoa(i) + "]"
+		lightsUboData.SpotLights[i] = SpotLightUboData{
-
+			Pos:           l.Pos,
-		whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+			Dir:           l.Dir,
-		containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
+			DiffuseColor:  l.DiffuseColor,
-		groundMat.SetUnifVec3(indexString+".pos", &l.Pos)
+			SpecularColor: l.SpecularColor,
-		palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+			InnerCutoff:   innerCutoffCos,
-
+			OuterCutoff:   outerCutoffCos,
-		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)
 	}
 
 	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() {
@@ -857,6 +896,9 @@ func (g *Game) Update() {
 	g.updateCameraLookAround()
 	g.updateCameraPos()
 
+	globalMatricesUboData.CamPos = cam.Pos
+	updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
+
 	g.showDebugWindow()
 }
 
@@ -866,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()
 
@@ -906,14 +948,16 @@ func (g *Game) showDebugWindow() {
 
 	imgui.Spacing()
 
+	//
+	// Lights
+	//
+	updateLights := false
+
 	// Ambient light
 	imgui.Text("Ambient Light")
 
-	if imgui.ColorEdit3("Ambient Color", &ambientColor.Data) {
+	if imgui.ColorEdit3("Ambient Color", &lightsUboData.AmbientColor.Data) {
-		whiteMat.SetUnifVec3("ambientColor", &ambientColor)
+		updateLights = true
-		containerMat.SetUnifVec3("ambientColor", &ambientColor)
-		groundMat.SetUnifVec3("ambientColor", &ambientColor)
-		palleteMat.SetUnifVec3("ambientColor", &ambientColor)
 	}
 
 	imgui.Spacing()
@@ -924,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)
+		updateLights = true
-		containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-		groundMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
-		palleteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 	}
 
 	if imgui.ColorEdit3("Diffuse Color", &dirLight.DiffuseColor.Data) {
-		whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+		updateLights = true
-		containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-		groundMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
-		palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 	}
 
 	if imgui.ColorEdit3("Specular Color", &dirLight.SpecularColor.Data) {
-		whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+		updateLights = true
-		containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-		groundMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-		palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
 	}
 
-	imgui.DragFloat3("dPos", &dirLightPos.Data)
+	if imgui.DragFloat3("dPos", &dirLightPos.Data) {
-	imgui.DragFloat("dSize", &dirLightSize)
+		updateLights = true
-	imgui.DragFloat("dNear", &dirLightNear)
+	}
-	imgui.DragFloat("dFar", &dirLightFar)
+	if imgui.DragFloat("dSize", &dirLightSize) {
+		updateLights = true
+	}
+	if imgui.DragFloat("dNear", &dirLightNear) {
+		updateLights = true
+	}
+	if imgui.DragFloat("dFar", &dirLightFar) {
+		updateLights = true
+	}
 
 	imgui.Spacing()
 
@@ -976,73 +1019,29 @@ func (g *Game) showDebugWindow() {
 				continue
 			}
 
-			indexString := "pointLights[" + indexNumString + "]"
-
 			if imgui.DragFloat3("Pos", &pl.Pos.Data) {
-
+				updateLights = true
-				posStr := indexString + ".pos"
-
-				whiteMat.SetUnifVec3(posStr, &pl.Pos)
-				containerMat.SetUnifVec3(posStr, &pl.Pos)
-				groundMat.SetUnifVec3(posStr, &pl.Pos)
-				palleteMat.SetUnifVec3(posStr, &pl.Pos)
 			}
 
 			if imgui.ColorEdit3("Diffuse Color", &pl.DiffuseColor.Data) {
-
+				updateLights = true
-				diffStr := indexString + ".diffuseColor"
-
-				whiteMat.SetUnifVec3(diffStr, &pl.DiffuseColor)
-				containerMat.SetUnifVec3(diffStr, &pl.DiffuseColor)
-				groundMat.SetUnifVec3(diffStr, &pl.DiffuseColor)
-				palleteMat.SetUnifVec3(diffStr, &pl.DiffuseColor)
 			}
 
 			if imgui.ColorEdit3("Specular Color", &pl.SpecularColor.Data) {
-
+				updateLights = true
-				specularStr := indexString + ".specularColor"
-
-				whiteMat.SetUnifVec3(specularStr, &pl.SpecularColor)
-				containerMat.SetUnifVec3(specularStr, &pl.SpecularColor)
-				groundMat.SetUnifVec3(specularStr, &pl.SpecularColor)
-				palleteMat.SetUnifVec3(specularStr, &pl.SpecularColor)
 			}
 
 			if imgui.DragFloatV("Falloff", &pl.Falloff, 0.1, 0, 100, "%.3f", imgui.SliderFlagsNone) {
-
+				updateLights = true
-				falloffStr := indexString + ".falloff"
-
-				whiteMat.SetUnifFloat32(falloffStr, pl.Falloff)
-				containerMat.SetUnifFloat32(falloffStr, pl.Falloff)
-				groundMat.SetUnifFloat32(falloffStr, pl.Falloff)
-				palleteMat.SetUnifFloat32(falloffStr, pl.Falloff)
 			}
 
 			if imgui.DragFloatV("Radius", &pl.Radius, 0.2, 0, 500, "%.3f", imgui.SliderFlagsNone) {
-
+				updateLights = true
-				radiusStr := indexString + ".radius"
-
-				whiteMat.SetUnifFloat32(radiusStr, pl.Radius)
-				containerMat.SetUnifFloat32(radiusStr, pl.Radius)
-				groundMat.SetUnifFloat32(radiusStr, pl.Radius)
-				palleteMat.SetUnifFloat32(radiusStr, pl.Radius)
-
-				farPlaneStr := indexString + ".farPlane"
 				pl.FarPlane = pl.Radius * pointLightRadiusToFarPlaneRatio
-
-				whiteMat.SetUnifFloat32(farPlaneStr, pl.FarPlane)
-				containerMat.SetUnifFloat32(farPlaneStr, pl.FarPlane)
-				groundMat.SetUnifFloat32(farPlaneStr, pl.FarPlane)
-				palleteMat.SetUnifFloat32(farPlaneStr, pl.FarPlane)
 			}
 
 			if imgui.DragFloatV("Max Bias", &pl.MaxBias, 0.01, 0, 10, "%.3f", imgui.SliderFlagsNone) {
-
+				updateLights = true
-				maxBiasStr := indexString + ".maxBias"
-				whiteMat.SetUnifFloat32(maxBiasStr, pl.MaxBias)
-				containerMat.SetUnifFloat32(maxBiasStr, pl.MaxBias)
-				groundMat.SetUnifFloat32(maxBiasStr, pl.MaxBias)
-				palleteMat.SetUnifFloat32(maxBiasStr, pl.MaxBias)
 			}
 
 			imgui.TreePop()
@@ -1065,34 +1064,20 @@ func (g *Game) showDebugWindow() {
 				continue
 			}
 
-			indexString := "spotLights[" + indexNumString + "]"
-
 			if imgui.DragFloat3("Pos", &l.Pos.Data) {
-				whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+				updateLights = true
-				containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
-				groundMat.SetUnifVec3(indexString+".pos", &l.Pos)
-				palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)
 			}
 
 			if imgui.DragFloat3("Dir", &l.Dir.Data) {
-				whiteMat.SetUnifVec3(indexString+".dir", &l.Dir)
+				updateLights = true
-				containerMat.SetUnifVec3(indexString+".dir", &l.Dir)
-				groundMat.SetUnifVec3(indexString+".dir", &l.Dir)
-				palleteMat.SetUnifVec3(indexString+".dir", &l.Dir)
 			}
 
 			if imgui.ColorEdit3("Diffuse Color", &l.DiffuseColor.Data) {
-				whiteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+				updateLights = true
-				containerMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-				groundMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
-				palleteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
 			}
 
 			if imgui.ColorEdit3("Specular Color", &l.SpecularColor.Data) {
-				whiteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
+				updateLights = true
-				containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-				groundMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
-				palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 			}
 
 			if imgui.DragFloatRange2V(
@@ -1106,18 +1091,7 @@ func (g *Game) showDebugWindow() {
 				"%.3f",
 				imgui.SliderFlagsNone,
 			) {
-
+				updateLights = true
-				cos := l.InnerCutoffCos()
-				whiteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-				containerMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-				groundMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-				palleteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
-
-				cos = l.OuterCutoffCos()
-				whiteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
-				containerMat.SetUnifFloat32(indexString+".outerCutoff", cos)
-				groundMat.SetUnifFloat32(indexString+".outerCutoff", cos)
-				palleteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
 			}
 
 			imgui.DragFloat("Spot Near Plane", &l.NearPlane)
@@ -1129,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)
@@ -1176,8 +1154,6 @@ func (g *Game) updateCameraLookAround() {
 	}
 
 	cam.UpdateRotation(pitch, yaw)
-
-	updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
 }
 
 func (g *Game) updateCameraPos() {
@@ -1211,7 +1187,6 @@ func (g *Game) updateCameraPos() {
 
 	if update {
 		cam.Update()
-		updateAllProjViewMats(cam.ProjMat, cam.ViewMat)
 	}
 }
 
@@ -1226,10 +1201,8 @@ var (
 
 func (g *Game) Render() {
 
-	whiteMat.SetUnifVec3("camPos", &cam.Pos)
+	globalMatricesUbo.Bind()
-	containerMat.SetUnifVec3("camPos", &cam.Pos)
+	globalMatricesUbo.SetStruct(globalMatricesUboData)
-	groundMat.SetUnifVec3("camPos", &cam.Pos)
-	palleteMat.SetUnifVec3("camPos", &cam.Pos)
 
 	rotatingCubeTrMat1.Rotate(rotatingCubeSpeedDeg1*gglm.Deg2Rad*timing.DT(), 0, 1, 0)
 	rotatingCubeTrMat2.Rotate(rotatingCubeSpeedDeg2*gglm.Deg2Rad*timing.DT(), 1, 1, 0)
@@ -1482,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,34 +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 falloff;
     float radius;
+    float falloff;
     float maxBias;
     float nearPlane;
     float farPlane;
 };
-uniform PointLight pointLights[NUM_POINT_LIGHTS];
 
 struct SpotLight {
     vec3 pos;
@@ -51,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
@@ -155,21 +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 falloff;
     float radius;
+    float falloff;
     float maxBias;
     float nearPlane;
     float farPlane;
 };
-uniform PointLight pointLights[NUM_POINT_LIGHTS];
 uniform samplerCubeArray pointLightCubeShadowMaps;
 
 struct SpotLight {
@@ -180,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
@@ -250,7 +266,7 @@ 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);
 }

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()