Fixed now?

.github/workflows/build-nmage.yml

@@ -1,22 +1,28 @@
 name: build-nmage
+
 on:
   create:
   workflow_dispatch:
 
 jobs:
   build-nmage-macos:
-    runs-on: macos-10.15
+    runs-on: macos-12
     steps:
-      - name: Install golang 1.17
-        uses: actions/setup-go@v2
+    
+      - name: Install golang 1.18
+        uses: actions/setup-go@v3
         with:
-          go-version: '^1.17'
+          go-version: '^1.18'
+
       - 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
+
       - name: Install SDL2
         run: brew install sdl2{,_image,_mixer,_ttf,_gfx} pkg-config
+
       - name: Clone nmage
         run: git clone https://github.com/bloeys/nmage
+
       - name: build nmage
         working-directory: nmage
         run: go build .

README.md

@@ -1,6 +1,6 @@
 # nMage
 
-[![build](https://github.com/bloeys/nmage/actions/workflows/run-nmage.yml/badge.svg)](https://github.com/bloeys/nmage/actions/workflows/run-nmage.yml)
+[![build](https://github.com/bloeys/nmage/actions/workflows/build-nmage.yml/badge.svg)](https://github.com/bloeys/nmage/actions/workflows/build-nmage.yml)
 
 nMage is a (hopefully!) high performance 3D Game Engine written in Go being developed [live](https://twitch.tv/bloeys), with recordings posted on [YouTube](https://www.youtube.com/channel/UCCf4qyNGPVwpj1HYFGahs_A).
 

assert/assert.go

@@ -0,0 +1,13 @@
+package assert
+
+import (
+	"github.com/bloeys/nmage/consts"
+	"github.com/bloeys/nmage/logging"
+)
+
+func T(check bool, msg string, args ...any) {
+
+	if consts.Debug && !check {
+		logging.ErrLog.Panicf("Assert failed: "+msg, args...)
+	}
+}

asserts/asserts.go

@@ -1,12 +0,0 @@
-package asserts
-
-import (
-	"github.com/bloeys/nmage/consts"
-	"github.com/bloeys/nmage/logging"
-)
-
-func T(check bool, msg string) {
-	if consts.Debug && !check {
-		logging.ErrLog.Panicln("Assert failed:", msg)
-	}
-}

assets/assets.go

@@ -1,27 +1,32 @@
 package assets
 
 var (
-	Textures     map[uint32]Texture = make(map[uint32]Texture)
-	TexturePaths map[string]uint32  = make(map[string]uint32)
+	Textures     = make(map[uint32]Texture)
+	TexturePaths = make(map[string]uint32)
 )
 
-func SetTexture(t Texture) {
+func AddTextureToCache(t Texture) {
 
-	if _, ok := TexturePaths[t.Path]; ok {
+	if t.Path != "" {
+		if _, ok := TexturePaths[t.Path]; ok {
+			return
+		}
+		println("Loaded texture from path:", t.Path)
+		Textures[t.TexID] = t
+		TexturePaths[t.Path] = t.TexID
 		return
 	}
 
-	println("Loaded texture:", t.Path)
-	Textures[t.TexID] = t
+	println("Loaded in-mem texture with ID:", t.TexID)
 	TexturePaths[t.Path] = t.TexID
 }
 
-func GetTexture(texID uint32) (Texture, bool) {
+func GetTextureFromCacheID(texID uint32) (Texture, bool) {
 	tex, ok := Textures[texID]
 	return tex, ok
 }
 
-func GetTexturePath(path string) (Texture, bool) {
+func GetTextureFromCachePath(path string) (Texture, bool) {
 	tex, ok := Textures[TexturePaths[path]]
 	return tex, ok
 }

assets/textures.go

@@ -2,12 +2,18 @@ package assets
 
 import (
 	"bytes"
-	"image/color"
+	"fmt"
+	"image"
+	"image/jpeg"
 	"image/png"
+	"io"
 	"os"
+	"path"
+	"strings"
 	"unsafe"
 
 	"github.com/go-gl/gl/v4.1-core/gl"
+	"github.com/mandykoh/prism"
 )
 
 type ColorFormat int
@@ -17,17 +23,51 @@ const (
 )
 
 type Texture struct {
-	Path   string
-	TexID  uint32
-	Width  int32
+	// Path only exists for textures loaded from disk
+	Path string
+
+	TexID uint32
+
+	// Width is the width of the texture in pixels (pixels per row).
+	// Note that the number of bytes constituting a row is MORE than this (e.g. for RGBA8, bytesPerRow=width*4, since we have 4 bytes per pixel)
+	Width int32
+
+	// Height is the height of the texture in pixels (pixels per column).
+	// Note that the number of bytes constituting a column is MORE than this (e.g. for RGBA8, bytesPerColumn=height*4, since we have 4 bytes per pixel)
 	Height int32
+
+	// Pixels usually stored in RGBA format
 	Pixels []byte
 }
 
-func LoadPNGTexture(file string) (Texture, error) {
+type TextureLoadOptions struct {
+	TryLoadFromCache bool
+	WriteToCache     bool
+	GenMipMaps       bool
+	KeepPixelsInMem  bool
+}
 
-	if tex, ok := GetTexturePath(file); ok {
-		return tex, nil
+type Cubemap struct {
+	// These only exists for textures loaded from disk
+	RightPath string
+	LeftPath  string
+	TopPath   string
+	BotPath   string
+	FrontPath string
+	BackPath  string
+	TexID     uint32
+}
+
+func LoadTexturePNG(file string, loadOptions *TextureLoadOptions) (Texture, error) {
+
+	if loadOptions == nil {
+		loadOptions = &TextureLoadOptions{}
+	}
+
+	if loadOptions.TryLoadFromCache {
+		if tex, ok := GetTextureFromCachePath(file); ok {
+			return tex, nil
+		}
 	}
 
 	//Load from disk
@@ -36,34 +76,20 @@ func LoadPNGTexture(file string) (Texture, error) {
 		return Texture{}, err
 	}
 
-	img, err := png.Decode(bytes.NewReader(fileBytes))
+	bytesReader := bytes.NewReader(fileBytes)
+	img, err := png.Decode(bytesReader)
 	if err != nil {
 		return Texture{}, err
 	}
 
+	nrgbaImg := prism.ConvertImageToNRGBA(img, 2)
 	tex := Texture{
 		Path:   file,
-		Width:  int32(img.Bounds().Dx()),
-		Height: int32(img.Bounds().Dy()),
-		Pixels: make([]byte, img.Bounds().Dx()*img.Bounds().Dy()*4),
-	}
-
-	//NOTE: Load bottom left to top right because this is the texture coordinate system used by OpenGL
-	//NOTE: We only support 8-bit channels (32-bit colors) for now
-	i := 0
-	for y := img.Bounds().Dy() - 1; y >= 0; y-- {
-		for x := 0; x < img.Bounds().Dx(); x++ {
-
-			c := color.NRGBAModel.Convert(img.At(x, y)).(color.NRGBA)
-
-			tex.Pixels[i] = c.R
-			tex.Pixels[i+1] = c.G
-			tex.Pixels[i+2] = c.B
-			tex.Pixels[i+3] = c.A
-
-			i += 4
-		}
+		Pixels: nrgbaImg.Pix,
+		Width:  int32(nrgbaImg.Bounds().Dx()),
+		Height: int32(nrgbaImg.Bounds().Dy()),
 	}
+	flipImgPixelsVertically(tex.Pixels, int(tex.Width), int(tex.Height), 4)
 
 	//Prepare opengl stuff
 	gl.GenTextures(1, &tex.TexID)
@@ -72,14 +98,202 @@ func LoadPNGTexture(file string) (Texture, error) {
 	// set the texture wrapping/filtering options (on the currently bound texture object)
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
-	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
 
 	// load and generate the texture
-	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
-	gl.GenerateMipmap(gl.TEXTURE_2D)
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.SRGB_ALPHA, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
 
-	SetTexture(tex)
+	if loadOptions.GenMipMaps {
+		gl.GenerateMipmap(tex.TexID)
+	}
+
+	if loadOptions.WriteToCache {
+		AddTextureToCache(tex)
+	}
+
+	if !loadOptions.KeepPixelsInMem {
+		tex.Pixels = nil
+	}
 
 	return tex, nil
 }
+
+func LoadTextureInMemPngImg(img image.Image, loadOptions *TextureLoadOptions) (Texture, error) {
+
+	if loadOptions == nil {
+		loadOptions = &TextureLoadOptions{}
+	}
+
+	nrgbaImg := prism.ConvertImageToNRGBA(img, 2)
+	tex := Texture{
+		Path:   "",
+		Pixels: nrgbaImg.Pix,
+		Height: int32(nrgbaImg.Bounds().Dy()),
+		Width:  int32(nrgbaImg.Bounds().Dx()),
+	}
+	flipImgPixelsVertically(tex.Pixels, int(tex.Width), int(tex.Height), 4)
+
+	//Prepare opengl stuff
+	gl.GenTextures(1, &tex.TexID)
+	gl.BindTexture(gl.TEXTURE_2D, tex.TexID)
+
+	// set the texture wrapping/filtering options (on the currently bound texture object)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
+
+	// load and generate the texture
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.SRGB8_ALPHA8, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
+
+	if loadOptions.GenMipMaps {
+		gl.GenerateMipmap(tex.TexID)
+	}
+
+	if loadOptions.WriteToCache {
+		AddTextureToCache(tex)
+	}
+
+	if !loadOptions.KeepPixelsInMem {
+		tex.Pixels = nil
+	}
+
+	return tex, nil
+}
+
+func LoadTextureJpeg(file string, loadOptions *TextureLoadOptions) (Texture, error) {
+
+	if loadOptions == nil {
+		loadOptions = &TextureLoadOptions{}
+	}
+
+	if loadOptions.TryLoadFromCache {
+		if tex, ok := GetTextureFromCachePath(file); ok {
+			return tex, nil
+		}
+	}
+
+	//Load from disk
+	fileBytes, err := os.ReadFile(file)
+	if err != nil {
+		return Texture{}, err
+	}
+
+	img, err := jpeg.Decode(bytes.NewReader(fileBytes))
+	if err != nil {
+		return Texture{}, err
+	}
+
+	nrgbaImg := prism.ConvertImageToNRGBA(img, 2)
+	tex := Texture{
+		Path:   file,
+		Pixels: nrgbaImg.Pix,
+		Height: int32(nrgbaImg.Bounds().Dy()),
+		Width:  int32(nrgbaImg.Bounds().Dx()),
+	}
+	flipImgPixelsVertically(tex.Pixels, int(tex.Width), int(tex.Height), 4)
+
+	//Prepare opengl stuff
+	gl.GenTextures(1, &tex.TexID)
+	gl.BindTexture(gl.TEXTURE_2D, tex.TexID)
+
+	// set the texture wrapping/filtering options (on the currently bound texture object)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
+
+	// load and generate the texture
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.SRGB8_ALPHA8, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
+
+	if loadOptions.GenMipMaps {
+		gl.GenerateMipmap(tex.TexID)
+	}
+
+	if loadOptions.WriteToCache {
+		AddTextureToCache(tex)
+	}
+
+	if !loadOptions.KeepPixelsInMem {
+		tex.Pixels = nil
+	}
+
+	return tex, nil
+}
+
+func LoadCubemapTextures(rightTex, leftTex, topTex, botTex, frontTex, backTex string) (Cubemap, error) {
+
+	var imgDecoder func(r io.Reader) (image.Image, error)
+	ext := strings.ToLower(path.Ext(rightTex))
+	if ext == ".jpg" || ext == ".jpeg" {
+		imgDecoder = jpeg.Decode
+	} else if ext == ".png" {
+		imgDecoder = png.Decode
+	} else {
+		return Cubemap{}, fmt.Errorf("unknown image extension: %s. Expected one of: .jpg, .jpeg, .png", ext)
+	}
+
+	cmap := Cubemap{
+		RightPath: rightTex,
+		LeftPath:  leftTex,
+		TopPath:   topTex,
+		BotPath:   botTex,
+		FrontPath: frontTex,
+		BackPath:  backTex,
+	}
+
+	gl.GenTextures(1, &cmap.TexID)
+	gl.BindTexture(gl.TEXTURE_CUBE_MAP, cmap.TexID)
+
+	// The order here matters
+	texturePaths := []string{rightTex, leftTex, topTex, botTex, frontTex, backTex}
+	for i := uint32(0); i < uint32(len(texturePaths)); i++ {
+
+		fPath := texturePaths[i]
+
+		//Load from disk
+		fileBytes, err := os.ReadFile(fPath)
+		if err != nil {
+			return Cubemap{}, err
+		}
+
+		img, err := imgDecoder(bytes.NewReader(fileBytes))
+		if err != nil {
+			return Cubemap{}, err
+		}
+
+		nrgbaImg := prism.ConvertImageToNRGBA(img, 2)
+		height := int32(nrgbaImg.Bounds().Dy())
+		width := int32(nrgbaImg.Bounds().Dx())
+
+		gl.TexImage2D(uint32(gl.TEXTURE_CUBE_MAP_POSITIVE_X)+i, 0, gl.RGBA8, int32(width), int32(height), 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&nrgbaImg.Pix[0]))
+	}
+
+	// set the texture wrapping/filtering options (on the currently bound texture object)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
+
+	return cmap, nil
+}
+
+func flipImgPixelsVertically(bytes []byte, width, height, bytesPerPixel int) {
+
+	// Flip the image vertically such that (e.g. in an image of 10 rows) rows 0<->9, 1<->8, 2<->7 etc are swapped.
+	// We do this because images are usually stored top-left to bottom-right, while opengl stores textures bottom-left to top-right, so if we don't swap
+	// rows textures will appear inverted
+	widthInBytes := width * bytesPerPixel
+	rowData := make([]byte, width*bytesPerPixel)
+	for rowNum := 0; rowNum < height/2; rowNum++ {
+
+		upperRowStartIndex := rowNum * widthInBytes
+		lowerRowStartIndex := (height - rowNum - 1) * widthInBytes
+		copy(rowData, bytes[upperRowStartIndex:upperRowStartIndex+widthInBytes])
+		copy(bytes[upperRowStartIndex:upperRowStartIndex+widthInBytes], bytes[lowerRowStartIndex:lowerRowStartIndex+widthInBytes])
+		copy(bytes[lowerRowStartIndex:lowerRowStartIndex+widthInBytes], rowData)
+
+	}
+}

buffers/buf_usage.go

@@ -3,7 +3,7 @@ package buffers
 import (
 	"fmt"
 
-	"github.com/bloeys/nmage/asserts"
+	"github.com/bloeys/nmage/assert"
 	"github.com/go-gl/gl/v4.1-core/gl"
 )
 
@@ -28,6 +28,6 @@ func (b BufUsage) ToGL() uint32 {
 		return gl.STREAM_DRAW
 	}
 
-	asserts.T(false, fmt.Sprintf("Unexpected BufUsage value '%v'", b))
+	assert.T(false, fmt.Sprintf("Unexpected BufUsage value '%v'", b))
 	return 0
 }

buffers/buffers.go

@@ -7,12 +7,15 @@ import (
 
 type Buffer struct {
 	VAOID uint32
-	//BufID is the ID of the VBO
+	// BufID is the ID of the VBO
 	BufID uint32
-	//IndexBufID is the ID of the index/element buffer
-	IndexBufID    uint32
+	// IndexBufID is the ID of the index/element buffer
+	IndexBufID uint32
+	// IndexBufCount is the number of elements in the index buffer
+	// Updated on SetIndexBufData
 	IndexBufCount int32
-	Stride        int32
+	// IndexBufCount int32
+	Stride int32
 
 	layout []Element
 }
@@ -30,7 +33,28 @@ func (b *Buffer) SetData(values []float32) {
 	gl.BindVertexArray(b.VAOID)
 	gl.BindBuffer(gl.ARRAY_BUFFER, b.BufID)
 
-	gl.BufferData(gl.ARRAY_BUFFER, len(values)*4, gl.Ptr(values), BufUsage_Static.ToGL())
+	sizeInBytes := len(values) * 4
+	if sizeInBytes == 0 {
+		gl.BufferData(gl.ARRAY_BUFFER, 0, gl.Ptr(nil), BufUsage_Static.ToGL())
+	} else {
+		gl.BufferData(gl.ARRAY_BUFFER, sizeInBytes, gl.Ptr(&values[0]), BufUsage_Static.ToGL())
+	}
+
+	gl.BindVertexArray(0)
+	gl.BindBuffer(gl.ARRAY_BUFFER, 0)
+}
+
+func (b *Buffer) SetDataWithUsage(values []float32, usage BufUsage) {
+
+	gl.BindVertexArray(b.VAOID)
+	gl.BindBuffer(gl.ARRAY_BUFFER, b.BufID)
+
+	sizeInBytes := len(values) * 4
+	if sizeInBytes == 0 {
+		gl.BufferData(gl.ARRAY_BUFFER, 0, gl.Ptr(nil), usage.ToGL())
+	} else {
+		gl.BufferData(gl.ARRAY_BUFFER, sizeInBytes, gl.Ptr(&values[0]), usage.ToGL())
+	}
 
 	gl.BindVertexArray(0)
 	gl.BindBuffer(gl.ARRAY_BUFFER, 0)
@@ -42,7 +66,12 @@ func (b *Buffer) SetIndexBufData(values []uint32) {
 	gl.BindVertexArray(b.VAOID)
 	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, b.IndexBufID)
 
-	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(values)*4, gl.Ptr(values), BufUsage_Static.ToGL())
+	sizeInBytes := len(values) * 4
+	if sizeInBytes == 0 {
+		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, 0, gl.Ptr(nil), BufUsage_Static.ToGL())
+	} else {
+		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, sizeInBytes, gl.Ptr(&values[0]), BufUsage_Static.ToGL())
+	}
 
 	gl.BindVertexArray(0)
 	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
@@ -54,6 +83,8 @@ func (b *Buffer) GetLayout() []Element {
 	return e
 }
 
+// SetLayout updates the layout object and the corresponding vertex attributes.
+// Vertex attributes are also enabled.
 func (b *Buffer) SetLayout(layout ...Element) {
 
 	b.layout = layout
@@ -64,6 +95,20 @@ func (b *Buffer) SetLayout(layout ...Element) {
 		b.layout[i].Offset = int(b.Stride)
 		b.Stride += b.layout[i].Size()
 	}
+
+	//Set opengl stuff
+	b.Bind()
+
+	//NOTE: VBOs are only bound at 'VertexAttribPointer', not BindBUffer, so we need to bind the buffer and vao here
+	gl.BindBuffer(gl.ARRAY_BUFFER, b.BufID)
+
+	for i := 0; i < len(layout); i++ {
+		gl.EnableVertexAttribArray(uint32(i))
+		gl.VertexAttribPointerWithOffset(uint32(i), layout[i].ElementType.CompCount(), layout[i].ElementType.GLType(), false, b.Stride, uintptr(layout[i].Offset))
+	}
+
+	b.UnBind()
+	gl.BindBuffer(gl.ARRAY_BUFFER, 0)
 }
 
 func NewBuffer(layout ...Element) Buffer {

buffers/element.go

@@ -3,7 +3,7 @@ package buffers
 import (
 	"fmt"
 
-	"github.com/bloeys/nmage/asserts"
+	"github.com/bloeys/nmage/assert"
 	"github.com/go-gl/gl/v4.1-core/gl"
 )
 
@@ -45,7 +45,7 @@ func (dt ElementType) GLType() uint32 {
 		return gl.FLOAT
 
 	default:
-		asserts.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
 		return 0
 	}
 }
@@ -68,7 +68,7 @@ func (dt ElementType) CompSize() int32 {
 		return 4
 
 	default:
-		asserts.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
 		return 0
 	}
 }
@@ -92,7 +92,7 @@ func (dt ElementType) CompCount() int32 {
 		return 4
 
 	default:
-		asserts.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
 		return 0
 	}
 }
@@ -116,7 +116,7 @@ func (dt ElementType) Size() int32 {
 		return 4 * 4
 
 	default:
-		asserts.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
+		assert.T(false, fmt.Sprintf("Unknown data type passed. DataType '%v'", dt))
 		return 0
 	}
 }

camera/camera.go

@@ -0,0 +1,100 @@
+package camera
+
+import (
+	"github.com/bloeys/gglm/gglm"
+)
+
+type Type int32
+
+const (
+	Type_Unknown Type = iota
+	Type_Perspective
+	Type_Orthographic
+)
+
+type Camera struct {
+	Type Type
+
+	Pos     gglm.Vec3
+	Forward gglm.Vec3
+	WorldUp gglm.Vec3
+
+	NearClip float32
+	FarClip  float32
+
+	// Perspective data
+	Fov         float32
+	AspectRatio float32
+
+	// Ortho data
+	Left, Right, Top, Bottom float32
+
+	// Matrices
+	ViewMat gglm.Mat4
+	ProjMat gglm.Mat4
+}
+
+// Update recalculates view matrix and projection matrix.
+// Should be called whenever a camera parameter changes
+func (c *Camera) Update() {
+
+	c.ViewMat = gglm.LookAtRH(&c.Pos, c.Pos.Clone().Add(&c.Forward), &c.WorldUp).Mat4
+
+	if c.Type == Type_Perspective {
+		c.ProjMat = *gglm.Perspective(c.Fov, c.AspectRatio, c.NearClip, c.FarClip)
+	} else {
+		c.ProjMat = gglm.Ortho(c.Left, c.Right, c.Top, c.Bottom, c.NearClip, c.FarClip).Mat4
+	}
+}
+
+// UpdateRotation calculates a new forward vector and then calls camera.Update()
+func (c *Camera) UpdateRotation(pitch, yaw float32) {
+
+	dir := gglm.NewVec3(
+		gglm.Cos32(yaw)*gglm.Cos32(pitch),
+		gglm.Sin32(pitch),
+		gglm.Sin32(yaw)*gglm.Cos32(pitch),
+	)
+	c.Forward = *dir.Normalize()
+	c.Update()
+}
+
+func NewPerspective(pos, forward, worldUp *gglm.Vec3, nearClip, farClip, fovRadians, aspectRatio float32) *Camera {
+
+	cam := &Camera{
+		Type:    Type_Perspective,
+		Pos:     *pos,
+		Forward: *forward,
+		WorldUp: *worldUp,
+
+		NearClip: nearClip,
+		FarClip:  farClip,
+
+		Fov:         fovRadians,
+		AspectRatio: aspectRatio,
+	}
+	cam.Update()
+
+	return cam
+}
+
+func NewOrthographic(pos, forward, worldUp *gglm.Vec3, nearClip, farClip, left, right, top, bottom float32) *Camera {
+
+	cam := &Camera{
+		Type:    Type_Orthographic,
+		Pos:     *pos,
+		Forward: *forward,
+		WorldUp: *worldUp,
+
+		NearClip: nearClip,
+		FarClip:  farClip,
+
+		Left:   left,
+		Right:  right,
+		Top:    top,
+		Bottom: bottom,
+	}
+	cam.Update()
+
+	return cam
+}

engine/engine.go

@@ -3,14 +3,20 @@ package engine
 import (
 	"runtime"
 
+	imgui "github.com/AllenDang/cimgui-go"
+	"github.com/bloeys/nmage/assert"
 	"github.com/bloeys/nmage/input"
 	"github.com/bloeys/nmage/renderer"
 	"github.com/bloeys/nmage/timing"
+	nmageimgui "github.com/bloeys/nmage/ui/imgui"
 	"github.com/go-gl/gl/v4.1-core/gl"
-	"github.com/inkyblackness/imgui-go/v4"
 	"github.com/veandco/go-sdl2/sdl"
 )
 
+var (
+	isInited = false
+)
+
 type Window struct {
 	SDLWin         *sdl.Window
 	GlCtx          sdl.GLContext
@@ -21,8 +27,9 @@ type Window struct {
 func (w *Window) handleInputs() {
 
 	input.EventLoopStart()
-	imIO := imgui.CurrentIO()
+	imIo := imgui.CurrentIO()
 
+	// @TODO: Would be nice to have imgui package process its own events via a callback instead of it being part of engine code
 	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
 
 		//Fire callbacks
@@ -38,19 +45,32 @@ func (w *Window) handleInputs() {
 			input.HandleMouseWheelEvent(e)
 
 			xDelta, yDelta := input.GetMouseWheelMotion()
-			imIO.AddMouseWheelDelta(float32(xDelta), float32(yDelta))
+			imIo.AddMouseWheelDelta(float32(xDelta), float32(yDelta))
 
 		case *sdl.KeyboardEvent:
-			input.HandleKeyboardEvent(e)
 
-			if e.Type == sdl.KEYDOWN {
-				imIO.KeyPress(int(e.Keysym.Scancode))
-			} else if e.Type == sdl.KEYUP {
-				imIO.KeyRelease(int(e.Keysym.Scancode))
+			input.HandleKeyboardEvent(e)
+			imIo.AddKeyEvent(nmageimgui.SdlScancodeToImGuiKey(e.Keysym.Scancode), e.Type == sdl.KEYDOWN)
+
+			// Send modifier key updates to imgui
+			if e.Keysym.Sym == sdl.K_LCTRL || e.Keysym.Sym == sdl.K_RCTRL {
+				imIo.SetKeyCtrl(e.Type == sdl.KEYDOWN)
+			}
+
+			if e.Keysym.Sym == sdl.K_LSHIFT || e.Keysym.Sym == sdl.K_RSHIFT {
+				imIo.SetKeyShift(e.Type == sdl.KEYDOWN)
+			}
+
+			if e.Keysym.Sym == sdl.K_LALT || e.Keysym.Sym == sdl.K_RALT {
+				imIo.SetKeyAlt(e.Type == sdl.KEYDOWN)
+			}
+
+			if e.Keysym.Sym == sdl.K_LGUI || e.Keysym.Sym == sdl.K_RGUI {
+				imIo.SetKeySuper(e.Type == sdl.KEYDOWN)
 			}
 
 		case *sdl.TextInputEvent:
-			imIO.AddInputCharacters(string(e.Text[:]))
+			imIo.AddInputCharactersUTF8(e.GetText())
 
 		case *sdl.MouseButtonEvent:
 			input.HandleMouseBtnEvent(e)
@@ -70,15 +90,11 @@ 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.
 	x, y, _ := sdl.GetMouseState()
-	imIO.SetMousePosition(imgui.Vec2{X: float32(x), Y: float32(y)})
+	imIo.SetMousePos(imgui.Vec2{X: float32(x), Y: float32(y)})
 
-	imIO.SetMouseButtonDown(0, input.MouseDown(sdl.BUTTON_LEFT))
-	imIO.SetMouseButtonDown(1, input.MouseDown(sdl.BUTTON_RIGHT))
-	imIO.SetMouseButtonDown(2, input.MouseDown(sdl.BUTTON_MIDDLE))
-
-	imIO.KeyShift(sdl.SCANCODE_LSHIFT, sdl.SCANCODE_RSHIFT)
-	imIO.KeyCtrl(sdl.SCANCODE_LCTRL, sdl.SCANCODE_RCTRL)
-	imIO.KeyAlt(sdl.SCANCODE_LALT, sdl.SCANCODE_RALT)
+	imIo.SetMouseButtonDown(0, input.MouseDown(sdl.BUTTON_LEFT))
+	imIo.SetMouseButtonDown(1, input.MouseDown(sdl.BUTTON_RIGHT))
+	imIo.SetMouseButtonDown(2, input.MouseDown(sdl.BUTTON_MIDDLE))
 }
 
 func (w *Window) handleWindowResize() {
@@ -96,6 +112,8 @@ func (w *Window) Destroy() error {
 
 func Init() error {
 
+	isInited = true
+
 	runtime.LockOSThread()
 	timing.Init()
 	err := initSDL()
@@ -105,7 +123,7 @@ func Init() error {
 
 func initSDL() error {
 
-	err := sdl.Init(sdl.INIT_EVERYTHING)
+	err := sdl.Init(sdl.INIT_TIMER | sdl.INIT_VIDEO)
 	if err != nil {
 		return err
 	}
@@ -139,6 +157,7 @@ func CreateOpenGLWindowCentered(title string, width, height int32, flags WindowF
 
 func createWindow(title string, x, y, width, height int32, flags WindowFlags, rend renderer.Render) (*Window, error) {
 
+	assert.T(isInited, "engine.Init was not called!")
 	if x == -1 && y == -1 {
 		x = sdl.WINDOWPOS_CENTERED
 		y = sdl.WINDOWPOS_CENTERED
@@ -186,6 +205,8 @@ func initOpenGL() error {
 }
 
 func SetVSync(enabled bool) {
+	assert.T(isInited, "engine.Init was not called!")
+
 	if enabled {
 		sdl.GLSetSwapInterval(1)
 	} else {

engine/game.go

@@ -6,51 +6,51 @@ import (
 	"github.com/go-gl/gl/v4.1-core/gl"
 )
 
+var (
+	isRunning = false
+)
+
 type Game interface {
 	Init()
-	Start()
 
-	FrameStart()
 	Update()
 	Render()
 	FrameEnd()
-	ShouldRun() bool
 
-	GetWindow() *Window
-	GetImGUI() nmageimgui.ImguiInfo
-
-	Deinit()
+	DeInit()
 }
 
-func Run(g Game) {
+func Run(g Game, w *Window, ui nmageimgui.ImguiInfo) {
 
-	w := g.GetWindow()
-	ui := g.GetImGUI()
+	isRunning = true
+
+	// Run init with an active Imgui frame to allow init full imgui access
+	timing.FrameStarted()
+	w.handleInputs()
+
+	width, height := w.SDLWin.GetSize()
+	ui.FrameStart(float32(width), float32(height))
 
 	g.Init()
 
-	//Simulate an imgui frame during init so any imgui calls are allowed within init
-	tempWidth, tempHeight := w.SDLWin.GetSize()
-	tempFBWidth, tempFBHeight := w.SDLWin.GLGetDrawableSize()
-	ui.FrameStart(float32(tempWidth), float32(tempHeight))
-	g.Start()
-	ui.Render(float32(tempWidth), float32(tempHeight), tempFBWidth, tempFBHeight)
+	fbWidth, fbHeight := w.SDLWin.GLGetDrawableSize()
+	ui.Render(float32(width), float32(height), fbWidth, fbHeight)
 
-	for g.ShouldRun() {
+	timing.FrameEnded()
+
+	for isRunning {
 
 		//PERF: Cache these
-		width, height := w.SDLWin.GetSize()
-		fbWidth, fbHeight := w.SDLWin.GLGetDrawableSize()
+		width, height = w.SDLWin.GetSize()
+		fbWidth, fbHeight = w.SDLWin.GLGetDrawableSize()
 
 		timing.FrameStarted()
 		w.handleInputs()
 		ui.FrameStart(float32(width), float32(height))
 
-		g.FrameStart()
-
 		g.Update()
 
-		gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
+		gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
 		g.Render()
 		ui.Render(float32(width), float32(height), fbWidth, fbHeight)
 		w.SDLWin.GLSwap()
@@ -60,5 +60,9 @@ func Run(g Game) {
 		timing.FrameEnded()
 	}
 
-	g.Deinit()
+	g.DeInit()
+}
+
+func Quit() {
+	isRunning = false
 }

entity/base_comp.go

@@ -0,0 +1,26 @@
+package entity
+
+import "github.com/bloeys/nmage/registry"
+
+var _ Comp = &BaseComp{}
+
+type BaseComp struct {
+	Handle registry.Handle
+}
+
+func (b BaseComp) baseComp() {
+}
+
+func (b *BaseComp) Init(parentHandle registry.Handle) {
+	b.Handle = parentHandle
+}
+
+func (b BaseComp) Name() string {
+	return "Base Component"
+}
+
+func (b BaseComp) Update() {
+}
+
+func (b BaseComp) Destroy() {
+}

entity/comp.go

@@ -0,0 +1,73 @@
+package entity
+
+import (
+	"github.com/bloeys/nmage/assert"
+	"github.com/bloeys/nmage/registry"
+)
+
+type Comp interface {
+	// This ensures that implementors of the Comp interface
+	// always embed BaseComp
+	baseComp()
+
+	Name() string
+	Init(parentHandle registry.Handle)
+	Update()
+	Destroy()
+}
+
+func NewCompContainer() CompContainer {
+	return CompContainer{Comps: []Comp{}}
+}
+
+type CompContainer struct {
+	Comps []Comp
+}
+
+func AddComp[T Comp](entityHandle registry.Handle, cc *CompContainer, c T) {
+
+	assert.T(!HasComp[T](cc), "Entity with id '%v' already has component of type '%T'", entityHandle, c)
+
+	cc.Comps = append(cc.Comps, c)
+	c.Init(entityHandle)
+}
+
+func HasComp[T Comp](e *CompContainer) bool {
+
+	for i := 0; i < len(e.Comps); i++ {
+
+		_, ok := e.Comps[i].(T)
+		if ok {
+			return true
+		}
+	}
+
+	return false
+}
+
+func GetComp[T Comp](e *CompContainer) (out T) {
+
+	for i := 0; i < len(e.Comps); i++ {
+
+		comp, ok := e.Comps[i].(T)
+		if ok {
+			return comp
+		}
+	}
+
+	return out
+}
+
+// DestroyComp calls Destroy on the component and then removes it from the entities component list
+func DestroyComp[T Comp](e *CompContainer) {
+
+	for i := 0; i < len(e.Comps); i++ {
+
+		comp, ok := e.Comps[i].(T)
+		if ok {
+			comp.Destroy()
+			e.Comps = append(e.Comps[:i], e.Comps[i+1:]...)
+			return
+		}
+	}
+}

entity/entity.go

@@ -0,0 +1,7 @@
+package entity
+
+import "github.com/bloeys/nmage/registry"
+
+type Entity interface {
+	GetHandle() registry.Handle
+}

go.mod

@@ -1,13 +1,19 @@
 module github.com/bloeys/nmage
 
-go 1.17
+go 1.18
 
-require github.com/veandco/go-sdl2 v0.4.10
+require github.com/veandco/go-sdl2 v0.4.35
 
-require github.com/go-gl/gl v0.0.0-20211025173605-bda47ffaa784
+require github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6
 
 require (
-	github.com/bloeys/assimp-go v0.4.2
-	github.com/bloeys/gglm v0.3.1
-	github.com/inkyblackness/imgui-go/v4 v4.3.0
+	github.com/bloeys/assimp-go v0.4.4
+	github.com/bloeys/gglm v0.43.0
 )
+
+require (
+	github.com/AllenDang/cimgui-go v0.0.0-20230720025235-f2ff398a66b2
+	github.com/mandykoh/prism v0.35.1
+)
+
+require github.com/mandykoh/go-parallel v0.1.0 // indirect

go.sum

@@ -1,17 +1,40 @@
-github.com/bloeys/assimp-go v0.4.2 h1:ArVK74BCFcTO/rCGj2NgZG9xtbjnJdEn5npIeJx1Z04=
-github.com/bloeys/assimp-go v0.4.2/go.mod h1:my3yRxT7CfOztmvi+0svmwbaqw0KFrxaHxncoyaEIP0=
-github.com/bloeys/gglm v0.3.1 h1:Sy9upW7SBsBfDXrSmEhid3aQ+7J7itej+upwcxOnPMQ=
-github.com/bloeys/gglm v0.3.1/go.mod h1:qwJQ0WzV191wAMwlGicbfbChbKoSedMk7gFFX6GnyOk=
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/go-gl/gl v0.0.0-20211025173605-bda47ffaa784 h1:1Zi56D0LNfvkzM+BdoxKryvUEdyWO7LP8oRT+oSYJW0=
-github.com/go-gl/gl v0.0.0-20211025173605-bda47ffaa784/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw=
-github.com/inkyblackness/imgui-go/v4 v4.3.0 h1:iyAzqWXq/dG5+6ckDPhGivtrIo6AywGQMvENKzun04s=
-github.com/inkyblackness/imgui-go/v4 v4.3.0/go.mod h1:g8SAGtOYUP7rYaOB2AsVKCEHmPMDmJKgt4z6d+flhb0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/veandco/go-sdl2 v0.4.10 h1:8QoD2bhWl7SbQDflIAUYWfl9Vq+mT8/boJFAUzAScgY=
-github.com/veandco/go-sdl2 v0.4.10/go.mod h1:OROqMhHD43nT4/i9crJukyVecjPNYYuCofep6SNiAjY=
+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/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.43.0 h1:ZpOghR3PHfpkigTDh+FqxLsF0gN8CD6s/bWoei6LyxI=
+github.com/bloeys/gglm v0.43.0/go.mod h1:qwJQ0WzV191wAMwlGicbfbChbKoSedMk7gFFX6GnyOk=
+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=
+github.com/mandykoh/go-parallel v0.1.0/go.mod h1:lkYHqG1JNTaSS6lG+PgFCnyMd2VDy8pH9jN9pY899ig=
+github.com/mandykoh/prism v0.35.1 h1:JbQfQarANxSWlgJEpjv+E7DvtrqBaVP1YgJfZPvo6ME=
+github.com/mandykoh/prism v0.35.1/go.mod h1:3miB3EAJ0IggYl/4eBB5MmawRbyJI1gKDtbrVvk8Q9I=
+github.com/veandco/go-sdl2 v0.4.35 h1:NohzsfageDWGtCd9nf7Pc3sokMK/MOK+UA2QMJARWzQ=
+github.com/veandco/go-sdl2 v0.4.35/go.mod h1:OROqMhHD43nT4/i9crJukyVecjPNYYuCofep6SNiAjY=
+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/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=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

level/level.go

@@ -0,0 +1,17 @@
+package level
+
+import (
+	"github.com/bloeys/nmage/assert"
+)
+
+type Level struct {
+	Name string
+}
+
+func NewLevel(name string) *Level {
+
+	assert.T(name != "", "Level name can not be empty")
+	return &Level{
+		Name: name,
+	}
+}

main.go

@@ -2,195 +2,131 @@ package main
 
 import (
 	"fmt"
+	"runtime"
 
-	"github.com/bloeys/assimp-go/asig"
+	imgui "github.com/AllenDang/cimgui-go"
 	"github.com/bloeys/gglm/gglm"
 	"github.com/bloeys/nmage/assets"
+	"github.com/bloeys/nmage/camera"
 	"github.com/bloeys/nmage/engine"
+	"github.com/bloeys/nmage/entity"
 	"github.com/bloeys/nmage/input"
 	"github.com/bloeys/nmage/logging"
 	"github.com/bloeys/nmage/materials"
 	"github.com/bloeys/nmage/meshes"
+	"github.com/bloeys/nmage/registry"
 	"github.com/bloeys/nmage/renderer/rend3dgl"
 	"github.com/bloeys/nmage/timing"
 	nmageimgui "github.com/bloeys/nmage/ui/imgui"
-	"github.com/inkyblackness/imgui-go/v4"
+	"github.com/go-gl/gl/v4.1-core/gl"
 	"github.com/veandco/go-sdl2/sdl"
 )
 
-//BUGS:
-// need to rebind the texutre if the texture (or any material values) change between draw calls
-// DT handling for when it is zero is wrong! (Gives 1000 DT)
-
-//TODO: Tasks:
-// Build simple game
+// @Todo:
 // Integrate physx
-// Entities and components
-// Camera class
-
-//Low Priority:
+// Create VAO struct independent from VBO to support multi-VBO use cases (e.g. instancing)
 // Renderer batching
 // Scene graph
 // Separate engine loop from rendering loop? or leave it to the user?
 // Abstract keys enum away from sdl
 // Proper Asset loading
-// Audio
 // Frustum culling
 // Material system editor with fields automatically extracted from the shader
 
+const (
+	camSpeed         = 15
+	mouseSensitivity = 0.5
+
+	unscaledWindowWidth  = 1280
+	unscaledWindowHeight = 720
+)
+
 var (
-	isRunning bool = true
-	window    *engine.Window
+	window *engine.Window
+
+	pitch float32 = 0
+	yaw   float32 = -90
+	cam   *camera.Camera
 
 	simpleMat *materials.Material
-	cubeMesh  *meshes.Mesh
+	skyboxMat *materials.Material
 
-	modelMat   = gglm.NewTrMatId()
-	projMat    = &gglm.Mat4{}
-	camPos     = gglm.NewVec3(0, 0, -10)
-	camForward = gglm.NewVec3(0, 0, 1)
+	chairMesh  *meshes.Mesh
+	cubeMesh   *meshes.Mesh
+	skyboxMesh *meshes.Mesh
 
-	lightPos1   = gglm.NewVec3(2, 2, 0)
+	cubeModelMat = gglm.NewTrMatId()
+
+	lightPos1   = gglm.NewVec3(-2, 0, 2)
 	lightColor1 = gglm.NewVec3(1, 1, 1)
+
+	debugDepthMat        *materials.Material
+	debugDrawDepthBuffer bool
+
+	skyboxCmap assets.Cubemap
+
+	dpiScaling float32
 )
 
 type OurGame struct {
 	Win       *engine.Window
 	ImGUIInfo nmageimgui.ImguiInfo
-	Quitting  bool
 }
 
-func (g *OurGame) Init() {
+type TransformComp struct {
+	entity.BaseComp
 
-	//Create materials
-	simpleMat = materials.NewMaterial("Simple Mat", "./res/shaders/simple")
-
-	//Load meshes
-	var err error
-	cubeMesh, err = meshes.NewMesh("Cube", "./res/models/tex-cube.fbx", asig.PostProcess(0))
-	if err != nil {
-		logging.ErrLog.Fatalln("Failed to load cube mesh. Err: ", err)
-	}
-
-	//Load textures
-	tex, err := assets.LoadPNGTexture("./res/textures/Low poly planet.png")
-	if err != nil {
-		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
-	}
-
-	//Configure material
-	simpleMat.DiffuseTex = tex.TexID
-	simpleMat.SetAttribute(cubeMesh.Buf)
-
-	//Movement, scale and rotation
-	translationMat := gglm.NewTranslationMat(gglm.NewVec3(0, 0, 0))
-	scaleMat := gglm.NewScaleMat(gglm.NewVec3(0.25, 0.25, 0.25))
-	rotMat := gglm.NewRotMat(gglm.NewQuatEuler(gglm.NewVec3(0, 0, 0).AsRad()))
-
-	modelMat.Mul(translationMat.Mul(rotMat.Mul(scaleMat)))
-	simpleMat.SetUnifMat4("modelMat", &modelMat.Mat4)
-
-	//Moves objects into the cameras view
-	updateViewMat()
-
-	//Perspective/Depth
-	projMat := gglm.Perspective(45*gglm.Deg2Rad, float32(1280)/float32(720), 0.1, 500)
-	simpleMat.SetUnifMat4("projMat", projMat)
-
-	//Lights
-	simpleMat.SetUnifVec3("lightPos1", lightPos1)
-	simpleMat.SetUnifVec3("lightColor1", lightColor1)
+	Pos   *gglm.Vec3
+	Rot   *gglm.Quat
+	Scale *gglm.Vec3
 }
 
-func (g *OurGame) Start() {
+func (t *TransformComp) Name() string {
+	return "Transform Component"
 }
 
-func (g *OurGame) FrameStart() {
-}
+func Test() {
 
-func (g *OurGame) Update() {
+	// lvl := level.NewLevel("test level")
+	testRegistry := registry.NewRegistry[int](100)
 
-	if input.IsQuitClicked() {
-		g.Quitting = true
-	}
+	e1, e1Handle := testRegistry.New()
+	e1CompContainer := entity.NewCompContainer()
+	fmt.Printf("Entity 1: %+v; Handle: %+v; Index: %+v; Gen: %+v; Flags: %+v\n", e1, e1Handle, e1Handle.Index(), e1Handle.Generation(), e1Handle.Flags())
 
-	winWidth, winHeight := g.Win.SDLWin.GetSize()
-	projMat = gglm.Perspective(45*gglm.Deg2Rad, float32(winWidth)/float32(winHeight), 0.1, 20)
-	simpleMat.SetUnifMat4("projMat", projMat)
+	trComp := entity.GetComp[*TransformComp](&e1CompContainer)
+	fmt.Println("Get comp before adding any:", trComp)
 
-	//Camera movement
-	var camSpeed float32 = 15
-	if input.KeyDown(sdl.K_w) {
-		camPos.Data[1] += camSpeed * timing.DT()
-		updateViewMat()
-	}
-	if input.KeyDown(sdl.K_s) {
-		camPos.Data[1] -= camSpeed * timing.DT()
-		updateViewMat()
-	}
-	if input.KeyDown(sdl.K_d) {
-		camPos.Data[0] += camSpeed * timing.DT()
-		updateViewMat()
-	}
-	if input.KeyDown(sdl.K_a) {
-		camPos.Data[0] -= camSpeed * timing.DT()
-		updateViewMat()
-	}
+	entity.AddComp(e1Handle, &e1CompContainer, &TransformComp{
+		Pos:   gglm.NewVec3(0, 0, 0),
+		Rot:   gglm.NewQuatEulerXYZ(0, 0, 0),
+		Scale: gglm.NewVec3(0, 0, 0),
+	})
+	trComp = entity.GetComp[*TransformComp](&e1CompContainer)
+	fmt.Println("Get transform comp:", trComp)
 
-	if input.GetMouseWheelYNorm() > 0 {
-		camPos.Data[2] += 1
-		updateViewMat()
-	} else if input.GetMouseWheelYNorm() < 0 {
-		camPos.Data[2] -= 1
-		updateViewMat()
-	}
+	e2, e2Handle := testRegistry.New()
+	e3, e3Handle := testRegistry.New()
+	e4, e4Handle := testRegistry.New()
+	fmt.Printf("Entity 2: %+v; Handle: %+v; Index: %+v; Gen: %+v; Flags: %+v\n", e2, e2Handle, e2Handle.Index(), e2Handle.Generation(), e2Handle.Flags())
+	fmt.Printf("Entity 3: %+v; Handle: %+v; Index: %+v; Gen: %+v; Flags: %+v\n", e3, e3Handle, e3Handle.Index(), e3Handle.Generation(), e3Handle.Flags())
+	fmt.Printf("Entity 4: %+v; Handle: %+v; Index: %+v; Gen: %+v; Flags: %+v\n", e4, e4Handle, e4Handle.Index(), e4Handle.Generation(), e4Handle.Flags())
 
-	//Rotating cubes
-	if input.KeyDown(sdl.K_SPACE) {
-		modelMat.Rotate(10*timing.DT()*gglm.Deg2Rad, gglm.NewVec3(1, 1, 1).Normalize())
-		simpleMat.SetUnifMat4("modelMat", &modelMat.Mat4)
-	}
+	*e2 = 1000
+	fmt.Printf("Entity 2 value after registry get: %+v\n", *testRegistry.Get(e2Handle))
 
-	imgui.DragFloat3("Cam Pos", &camPos.Data)
-}
+	testRegistry.Free(e2Handle)
+	fmt.Printf("Entity 2 value after free: %+v\n", testRegistry.Get(e2Handle))
 
-func (g *OurGame) Render() {
-
-	tempModelMat := modelMat.Clone()
-
-	rowSize := 100
-	for y := 0; y < rowSize; y++ {
-		for x := 0; x < rowSize; x++ {
-			tempModelMat.Translate(gglm.NewVec3(-1, 0, 0))
-			window.Rend.Draw(cubeMesh, tempModelMat, simpleMat)
-		}
-		tempModelMat.Translate(gglm.NewVec3(float32(rowSize), -1, 0))
-	}
-
-	g.GetWindow().SDLWin.SetTitle(fmt.Sprint("nMage (", timing.GetAvgFPS(), " fps)"))
-}
-
-func (g *OurGame) FrameEnd() {
-}
-
-func (g *OurGame) ShouldRun() bool {
-	return !g.Quitting
-}
-
-func (g *OurGame) GetWindow() *engine.Window {
-	return g.Win
-}
-
-func (g *OurGame) GetImGUI() nmageimgui.ImguiInfo {
-	return g.ImGUIInfo
-}
-
-func (g *OurGame) Deinit() {
-	g.Win.Destroy()
+	e5, e5Handle := testRegistry.New()
+	fmt.Printf("Entity 5: %+v; Handle: %+v; Index: %+v; Gen: %+v; Flags: %+v\n", e5, e5Handle, e5Handle.Index(), e5Handle.Generation(), e5Handle.Flags())
 }
 
 func main() {
 
+	// Test()
+	// return
+
 	//Init engine
 	err := engine.Init()
 	if err != nil {
@@ -198,7 +134,8 @@ func main() {
 	}
 
 	//Create window
-	window, err = engine.CreateOpenGLWindowCentered("nMage", 1280, 720, engine.WindowFlags_RESIZABLE, rend3dgl.NewRend3DGL())
+	dpiScaling = getDpiScaling(unscaledWindowWidth, unscaledWindowHeight)
+	window, err = engine.CreateOpenGLWindowCentered("nMage", int32(unscaledWindowWidth*dpiScaling), int32(unscaledWindowHeight*dpiScaling), engine.WindowFlags_RESIZABLE, rend3dgl.NewRend3DGL())
 	if err != nil {
 		logging.ErrLog.Fatalln("Failed to create window. Err: ", err)
 	}
@@ -208,15 +145,294 @@ func main() {
 
 	game := &OurGame{
 		Win:       window,
-		ImGUIInfo: nmageimgui.NewImGUI(),
+		ImGUIInfo: nmageimgui.NewImGui(),
+	}
+	window.EventCallbacks = append(window.EventCallbacks, game.handleWindowEvents)
+
+	engine.Run(game, window, game.ImGUIInfo)
+}
+
+func (g *OurGame) handleWindowEvents(e sdl.Event) {
+
+	switch e := e.(type) {
+	case *sdl.WindowEvent:
+		if e.Event == sdl.WINDOWEVENT_SIZE_CHANGED {
+
+			width := e.Data1
+			height := e.Data2
+			cam.AspectRatio = float32(width) / float32(height)
+			cam.Update()
+
+			simpleMat.SetUnifMat4("projMat", &cam.ProjMat)
+			debugDepthMat.SetUnifMat4("projMat", &cam.ProjMat)
+		}
+	}
+}
+
+func getDpiScaling(unscaledWindowWidth, unscaledWindowHeight int32) float32 {
+
+	// Great read on DPI here: https://nlguillemot.wordpress.com/2016/12/11/high-dpi-rendering/
+
+	// The no-scaling DPI on different platforms (e.g. when scale=100% on windows)
+	var defaultDpi float32 = 96
+	if runtime.GOOS == "windows" {
+		defaultDpi = 96
+	} else if runtime.GOOS == "darwin" {
+		defaultDpi = 72
 	}
 
-	engine.Run(game)
-	return
+	// Current DPI of the monitor
+	_, dpiHorizontal, _, err := sdl.GetDisplayDPI(0)
+	if err != nil {
+		dpiHorizontal = defaultDpi
+		fmt.Printf("Failed to get DPI with error '%s'. Using default DPI of '%f'\n", err.Error(), defaultDpi)
+	}
+
+	// Scaling factor (e.g. will be 1.25 for 125% scaling on windows)
+	dpiScaling := dpiHorizontal / defaultDpi
+
+	fmt.Printf(
+		"Default DPI=%f\nHorizontal DPI=%f\nDPI scaling=%f\nUnscaled window size (width, height)=(%d, %d)\nScaled window size (width, height)=(%d, %d)\n\n",
+		defaultDpi,
+		dpiHorizontal,
+		dpiScaling,
+		unscaledWindowWidth, unscaledWindowHeight,
+		int32(float32(unscaledWindowWidth)*dpiScaling), int32(float32(unscaledWindowHeight)*dpiScaling),
+	)
+
+	return dpiScaling
+}
+
+func (g *OurGame) Init() {
+
+	var err error
+
+	//Create materials
+	simpleMat = materials.NewMaterial("Simple mat", "./res/shaders/simple.glsl")
+	debugDepthMat = materials.NewMaterial("Debug depth mat", "./res/shaders/debug-depth.glsl")
+	skyboxMat = materials.NewMaterial("Skybox mat", "./res/shaders/skybox.glsl")
+
+	//Load meshes
+	cubeMesh, err = meshes.NewMesh("Cube", "./res/models/tex-cube.fbx", 0)
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load mesh. Err: ", err)
+	}
+
+	chairMesh, err = meshes.NewMesh("Chair", "./res/models/chair.fbx", 0)
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load mesh. Err: ", err)
+	}
+
+	skyboxMesh, err = meshes.NewMesh("Skybox", "./res/models/skybox-cube.obj", 0)
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load mesh. Err: ", err)
+	}
+
+	//Load textures
+	tex, err := assets.LoadTexturePNG("./res/textures/pallete-endesga-64-1x.png", nil)
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
+	}
+
+	skyboxCmap, err = assets.LoadCubemapTextures(
+		"./res/textures/sb-right.jpg", "./res/textures/sb-left.jpg",
+		"./res/textures/sb-top.jpg", "./res/textures/sb-bottom.jpg",
+		"./res/textures/sb-front.jpg", "./res/textures/sb-back.jpg",
+	)
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load cubemap. Err: ", err)
+	}
+
+	// Configure materials
+	simpleMat.DiffuseTex = tex.TexID
+
+	//Movement, scale and rotation
+	translationMat := gglm.NewTranslationMat(gglm.NewVec3(0, 0, 0))
+	scaleMat := gglm.NewScaleMat(gglm.NewVec3(1, 1, 1))
+	rotMat := gglm.NewRotMat(gglm.NewQuatEuler(gglm.NewVec3(-90, -90, 0).AsRad()))
+
+	cubeModelMat.Mul(translationMat.Mul(rotMat.Mul(scaleMat)))
+
+	// Camera
+	winWidth, winHeight := g.Win.SDLWin.GetSize()
+	cam = camera.NewPerspective(
+		gglm.NewVec3(0, 0, 10),
+		gglm.NewVec3(0, 0, -1),
+		gglm.NewVec3(0, 1, 0),
+		0.1, 200,
+		45*gglm.Deg2Rad,
+		float32(winWidth)/float32(winHeight),
+	)
+	simpleMat.SetUnifMat4("projMat", &cam.ProjMat)
+	debugDepthMat.SetUnifMat4("projMat", &cam.ProjMat)
+
+	updateViewMat()
+
+	//Lights
+	simpleMat.SetUnifVec3("lightPos1", lightPos1)
+	simpleMat.SetUnifVec3("lightColor1", lightColor1)
+}
+
+func (g *OurGame) Update() {
+
+	if input.IsQuitClicked() || input.KeyClicked(sdl.K_ESCAPE) {
+		engine.Quit()
+	}
+
+	g.updateCameraLookAround()
+	g.updateCameraPos()
+
+	imgui.ShowDemoWindow()
+
+	//Rotating cubes
+	if input.KeyDown(sdl.K_SPACE) {
+		cubeModelMat.Rotate(10*timing.DT()*gglm.Deg2Rad, gglm.NewVec3(1, 1, 1).Normalize())
+	}
+
+	imgui.Begin("Debug controls")
+	if imgui.DragFloat3("Cam Pos", &cam.Pos.Data) {
+		updateViewMat()
+	}
+	if imgui.DragFloat3("Cam Forward", &cam.Forward.Data) {
+		updateViewMat()
+	}
+
+	if imgui.DragFloat3("Light Pos 1", &lightPos1.Data) {
+		simpleMat.SetUnifVec3("lightPos1", lightPos1)
+	}
+
+	if imgui.DragFloat3("Light Color 1", &lightColor1.Data) {
+		simpleMat.SetUnifVec3("lightColor1", lightColor1)
+	}
+
+	imgui.Checkbox("Debug depth buffer", &debugDrawDepthBuffer)
+	imgui.End()
+
+	if input.KeyClicked(sdl.K_F4) {
+		fmt.Printf("Pos: %s; Forward: %s; |Forward|: %f\n", cam.Pos.String(), cam.Forward.String(), cam.Forward.Mag())
+	}
+
+	g.Win.SDLWin.SetTitle(fmt.Sprint("nMage (", timing.GetAvgFPS(), " fps)"))
+}
+
+func (g *OurGame) updateCameraLookAround() {
+
+	mouseX, mouseY := input.GetMouseMotion()
+	if (mouseX == 0 && mouseY == 0) || !input.MouseDown(sdl.BUTTON_RIGHT) {
+		return
+	}
+
+	// Yaw
+	yaw += float32(mouseX) * mouseSensitivity * timing.DT()
+
+	// Pitch
+	pitch += float32(-mouseY) * mouseSensitivity * timing.DT()
+	if pitch > 89.0 {
+		pitch = 89.0
+	}
+
+	if pitch < -89.0 {
+		pitch = -89.0
+	}
+
+	// Update cam forward
+	cam.UpdateRotation(pitch, yaw)
+
+	updateViewMat()
+}
+
+func (g *OurGame) updateCameraPos() {
+
+	update := false
+
+	var camSpeedScale float32 = 1.0
+	if input.KeyDown(sdl.K_LSHIFT) {
+		camSpeedScale = 2
+	}
+
+	// Forward and backward
+	if input.KeyDown(sdl.K_w) {
+		cam.Pos.Add(cam.Forward.Clone().Scale(camSpeed * camSpeedScale * timing.DT()))
+		update = true
+	} else if input.KeyDown(sdl.K_s) {
+		cam.Pos.Add(cam.Forward.Clone().Scale(-camSpeed * camSpeedScale * timing.DT()))
+		update = true
+	}
+
+	// Left and right
+	if input.KeyDown(sdl.K_d) {
+		cam.Pos.Add(gglm.Cross(&cam.Forward, &cam.WorldUp).Normalize().Scale(camSpeed * camSpeedScale * timing.DT()))
+		update = true
+	} else if input.KeyDown(sdl.K_a) {
+		cam.Pos.Add(gglm.Cross(&cam.Forward, &cam.WorldUp).Normalize().Scale(-camSpeed * camSpeedScale * timing.DT()))
+		update = true
+	}
+
+	if update {
+		updateViewMat()
+	}
+}
+
+func (g *OurGame) Render() {
+
+	matToUse := simpleMat
+	if debugDrawDepthBuffer {
+		matToUse = debugDepthMat
+	}
+
+	tempModelMatrix := cubeModelMat.Clone()
+	window.Rend.Draw(chairMesh, tempModelMatrix, matToUse)
+
+	rowSize := 1
+	for y := 0; y < rowSize; y++ {
+		for x := 0; x < rowSize; x++ {
+			tempModelMatrix.Translate(gglm.NewVec3(-6, 0, 0))
+			window.Rend.Draw(cubeMesh, tempModelMatrix, matToUse)
+		}
+		tempModelMatrix.Translate(gglm.NewVec3(float32(rowSize), -1, 0))
+	}
+
+	g.DrawSkybox()
+}
+
+func (g *OurGame) DrawSkybox() {
+
+	gl.Disable(gl.CULL_FACE)
+	gl.DepthFunc(gl.LEQUAL)
+	skyboxMesh.Buf.Bind()
+	skyboxMat.Bind()
+	gl.ActiveTexture(gl.TEXTURE0)
+	gl.BindTexture(gl.TEXTURE_CUBE_MAP, skyboxCmap.TexID)
+
+	viewMat := cam.ViewMat.Clone()
+	viewMat.Set(0, 3, 0)
+	viewMat.Set(1, 3, 0)
+	viewMat.Set(2, 3, 0)
+	viewMat.Set(3, 0, 0)
+	viewMat.Set(3, 1, 0)
+	viewMat.Set(3, 2, 0)
+	viewMat.Set(3, 3, 0)
+
+	skyboxMat.SetUnifMat4("viewMat", viewMat)
+	skyboxMat.SetUnifMat4("projMat", &cam.ProjMat)
+	// window.Rend.Draw(cubeMesh, gglm.NewTrMatId(), skyboxMat)
+	for i := 0; i < len(skyboxMesh.SubMeshes); i++ {
+		gl.DrawElementsBaseVertexWithOffset(gl.TRIANGLES, skyboxMesh.SubMeshes[i].IndexCount, gl.UNSIGNED_INT, uintptr(skyboxMesh.SubMeshes[i].BaseIndex), skyboxMesh.SubMeshes[i].BaseVertex)
+	}
+
+	gl.DepthFunc(gl.LESS)
+	gl.Enable(gl.CULL_FACE)
+}
+
+func (g *OurGame) FrameEnd() {
+}
+
+func (g *OurGame) DeInit() {
+	g.Win.Destroy()
 }
 
 func updateViewMat() {
-	targetPos := camPos.Clone().Add(camForward)
-	viewMat := gglm.LookAt(camPos, targetPos, gglm.NewVec3(0, 1, 0))
-	simpleMat.SetUnifMat4("viewMat", &viewMat.Mat4)
+	cam.Update()
+	simpleMat.SetUnifMat4("viewMat", &cam.ViewMat)
+	debugDepthMat.SetUnifMat4("viewMat", &cam.ViewMat)
 }

materials/material.go

@@ -2,8 +2,7 @@ package materials
 
 import (
 	"github.com/bloeys/gglm/gglm"
-	"github.com/bloeys/nmage/asserts"
-	"github.com/bloeys/nmage/buffers"
+	"github.com/bloeys/nmage/assert"
 	"github.com/bloeys/nmage/logging"
 	"github.com/bloeys/nmage/shaders"
 	"github.com/go-gl/gl/v4.1-core/gl"
@@ -43,7 +42,7 @@ func (m *Material) GetAttribLoc(attribName string) int32 {
 	}
 
 	loc = gl.GetAttribLocation(m.ShaderProg.ID, gl.Str(attribName+"\x00"))
-	asserts.T(loc != -1, "Attribute '"+attribName+"' doesn't exist on material "+m.Name)
+	assert.T(loc != -1, "Attribute '"+attribName+"' doesn't exist on material "+m.Name)
 	m.AttribLocs[attribName] = loc
 	return loc
 }
@@ -56,28 +55,11 @@ func (m *Material) GetUnifLoc(uniformName string) int32 {
 	}
 
 	loc = gl.GetUniformLocation(m.ShaderProg.ID, gl.Str(uniformName+"\x00"))
-	asserts.T(loc != -1, "Uniform '"+uniformName+"' doesn't exist on material "+m.Name)
+	assert.T(loc != -1, "Uniform '"+uniformName+"' doesn't exist on material "+m.Name)
 	m.UnifLocs[uniformName] = loc
 	return loc
 }
 
-func (m *Material) SetAttribute(bufObj buffers.Buffer) {
-
-	bufObj.Bind()
-
-	//NOTE: VBOs are only bound at 'VertexAttribPointer', not BindBUffer, so we need to bind the buffer and vao here
-	gl.BindBuffer(gl.ARRAY_BUFFER, bufObj.BufID)
-
-	layout := bufObj.GetLayout()
-	for i := 0; i < len(layout); i++ {
-		gl.EnableVertexAttribArray(uint32(i))
-		gl.VertexAttribPointer(uint32(i), layout[i].ElementType.CompCount(), layout[i].ElementType.GLType(), false, bufObj.Stride, gl.PtrOffset(layout[i].Offset))
-	}
-
-	bufObj.UnBind()
-	gl.BindBuffer(gl.ARRAY_BUFFER, 0)
-}
-
 func (m *Material) EnableAttribute(attribName string) {
 	gl.EnableVertexAttribArray(uint32(m.GetAttribLoc(attribName)))
 }
@@ -124,24 +106,20 @@ func (m *Material) Delete() {
 
 func NewMaterial(matName, shaderPath string) *Material {
 
-	shdrProg, err := shaders.NewShaderProgram()
+	shdrProg, err := shaders.LoadAndCompileCombinedShader(shaderPath)
 	if err != nil {
-		logging.ErrLog.Fatalln("Failed to create new shader program. Err: ", err)
+		logging.ErrLog.Fatalln("Failed to create new material. Err: ", err)
+	}
+
+	return &Material{Name: matName, ShaderProg: shdrProg, UnifLocs: make(map[string]int32), AttribLocs: make(map[string]int32)}
+}
+
+func NewMaterialSrc(matName string, shaderSrc []byte) *Material {
+
+	shdrProg, err := shaders.LoadAndCompileCombinedShaderSrc(shaderSrc)
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to create new material. Err: ", err)
 	}
 
-	vertShader, err := shaders.LoadAndCompilerShader(shaderPath+".vert.glsl", shaders.VertexShaderType)
-	if err != nil {
-		logging.ErrLog.Fatalln("Failed to load and create vertex shader. Err: ", err)
-	}
-
-	fragShader, err := shaders.LoadAndCompilerShader(shaderPath+".frag.glsl", shaders.FragmentShaderType)
-	if err != nil {
-		logging.ErrLog.Fatalln("Failed to load and create fragment shader. Err: ", err)
-	}
-
-	shdrProg.AttachShader(vertShader)
-	shdrProg.AttachShader(fragShader)
-	shdrProg.Link()
-
 	return &Material{Name: matName, ShaderProg: shdrProg, UnifLocs: make(map[string]int32), AttribLocs: make(map[string]int32)}
 }

meshes/mesh.go

@@ -6,13 +6,20 @@ import (
 
 	"github.com/bloeys/assimp-go/asig"
 	"github.com/bloeys/gglm/gglm"
-	"github.com/bloeys/nmage/asserts"
+	"github.com/bloeys/nmage/assert"
 	"github.com/bloeys/nmage/buffers"
 )
 
+type SubMesh struct {
+	BaseVertex int32
+	BaseIndex  uint32
+	IndexCount int32
+}
+
 type Mesh struct {
-	Name string
-	Buf  buffers.Buffer
+	Name      string
+	Buf       buffers.Buffer
+	SubMeshes []SubMesh
 }
 
 func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (*Mesh, error) {
@@ -27,29 +34,68 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (*Mesh,
 		return nil, errors.New("No meshes found in file: " + modelPath)
 	}
 
-	mesh := &Mesh{Name: name}
-	sceneMesh := scene.Meshes[0]
-	mesh.Buf = buffers.NewBuffer()
-
-	asserts.T(len(sceneMesh.TexCoords[0]) > 0, "Mesh has no UV0")
-	layoutToUse := []buffers.Element{{ElementType: buffers.DataTypeVec3}, {ElementType: buffers.DataTypeVec3}, {ElementType: buffers.DataTypeVec2}}
-
-	if len(sceneMesh.ColorSets) > 0 && len(sceneMesh.ColorSets[0]) > 0 {
-		layoutToUse = append(layoutToUse, buffers.Element{ElementType: buffers.DataTypeVec4})
-	}
-	mesh.Buf.SetLayout(layoutToUse...)
-
-	var values []float32
-	arrs := []arrToInterleave{{V3s: sceneMesh.Vertices}, {V3s: sceneMesh.Normals}, {V2s: v3sToV2s(sceneMesh.TexCoords[0])}}
-
-	if len(sceneMesh.ColorSets) > 0 && len(sceneMesh.ColorSets[0]) > 0 {
-		arrs = append(arrs, arrToInterleave{V4s: sceneMesh.ColorSets[0]})
+	mesh := &Mesh{
+		Name:      name,
+		Buf:       buffers.NewBuffer(),
+		SubMeshes: make([]SubMesh, 0, 1),
 	}
 
-	values = interleave(arrs...)
+	// Initial sizes assuming one submesh that has vertex pos+normals+texCoords, and 3 indices per face
+	var vertexBufData []float32 = make([]float32, 0, len(scene.Meshes[0].Vertices)*3*3*2)
+	var indexBufData []uint32 = make([]uint32, 0, len(scene.Meshes[0].Faces)*3)
 
-	mesh.Buf.SetData(values)
-	mesh.Buf.SetIndexBufData(flattenFaces(sceneMesh.Faces))
+	for i := 0; i < len(scene.Meshes); i++ {
+
+		sceneMesh := scene.Meshes[i]
+
+		if len(sceneMesh.TexCoords[0]) == 0 {
+			sceneMesh.TexCoords[0] = make([]gglm.Vec3, len(sceneMesh.Vertices))
+			println("Zeroing tex coords for submesh", i)
+		}
+
+		layoutToUse := []buffers.Element{{ElementType: buffers.DataTypeVec3}, {ElementType: buffers.DataTypeVec3}, {ElementType: buffers.DataTypeVec2}}
+		if len(sceneMesh.ColorSets) > 0 && len(sceneMesh.ColorSets[0]) > 0 {
+			layoutToUse = append(layoutToUse, buffers.Element{ElementType: buffers.DataTypeVec4})
+		}
+
+		if i == 0 {
+			mesh.Buf.SetLayout(layoutToUse...)
+		} else {
+
+			// @NOTE: Require that all submeshes have the same vertex buffer layout
+			firstSubmeshLayout := mesh.Buf.GetLayout()
+			assert.T(len(firstSubmeshLayout) == len(layoutToUse), fmt.Sprintf("Vertex layout of submesh %d does not equal vertex layout of the first submesh. Original layout: %v; This layout: %v", i, firstSubmeshLayout, layoutToUse))
+
+			for i := 0; i < len(firstSubmeshLayout); i++ {
+				if firstSubmeshLayout[i].ElementType != layoutToUse[i].ElementType {
+					panic(fmt.Sprintf("Vertex layout of submesh %d does not equal vertex layout of the first submesh. Original layout: %v; This layout: %v", i, firstSubmeshLayout, layoutToUse))
+				}
+			}
+		}
+
+		arrs := []arrToInterleave{{V3s: sceneMesh.Vertices}, {V3s: sceneMesh.Normals}, {V2s: v3sToV2s(sceneMesh.TexCoords[0])}}
+		if len(sceneMesh.ColorSets) > 0 && len(sceneMesh.ColorSets[0]) > 0 {
+			arrs = append(arrs, arrToInterleave{V4s: sceneMesh.ColorSets[0]})
+		}
+
+		indices := flattenFaces(sceneMesh.Faces)
+		mesh.SubMeshes = append(mesh.SubMeshes, SubMesh{
+
+			// Index of the vertex to start from (e.g. if index buffer says use vertex 5, and BaseVertex=3, the vertex used will be vertex 8)
+			BaseVertex: int32(len(vertexBufData)*4) / mesh.Buf.Stride,
+			// Which index (in the index buffer) to start from
+			BaseIndex: uint32(len(indexBufData)),
+			// How many indices in this submesh
+			IndexCount: int32(len(indices)),
+		})
+
+		vertexBufData = append(vertexBufData, interleave(arrs...)...)
+		indexBufData = append(indexBufData, indices...)
+	}
+
+	// fmt.Printf("!!! Vertex count: %d; Submeshes: %+v\n", len(vertexBufData)*4/int(mesh.Buf.Stride), mesh.SubMeshes)
+	mesh.Buf.SetData(vertexBufData)
+	mesh.Buf.SetIndexBufData(indexBufData)
 	return mesh, nil
 }
 
@@ -73,9 +119,9 @@ type arrToInterleave struct {
 
 func (a *arrToInterleave) get(i int) []float32 {
 
-	asserts.T(len(a.V2s) == 0 || len(a.V3s) == 0, "One array should be set in arrToInterleave, but both arrays are set")
-	asserts.T(len(a.V2s) == 0 || len(a.V4s) == 0, "One array should be set in arrToInterleave, but both arrays are set")
-	asserts.T(len(a.V3s) == 0 || len(a.V4s) == 0, "One array should be set in arrToInterleave, but both arrays are set")
+	assert.T(len(a.V2s) == 0 || len(a.V3s) == 0, "One array should be set in arrToInterleave, but both arrays are set")
+	assert.T(len(a.V2s) == 0 || len(a.V4s) == 0, "One array should be set in arrToInterleave, but both arrays are set")
+	assert.T(len(a.V3s) == 0 || len(a.V4s) == 0, "One array should be set in arrToInterleave, but both arrays are set")
 
 	if len(a.V2s) > 0 {
 		return a.V2s[i].Data[:]
@@ -88,8 +134,8 @@ func (a *arrToInterleave) get(i int) []float32 {
 
 func interleave(arrs ...arrToInterleave) []float32 {
 
-	asserts.T(len(arrs) > 0, "No input sent to interleave")
-	asserts.T(len(arrs[0].V2s) > 0 || len(arrs[0].V3s) > 0 || len(arrs[0].V4s) > 0, "Interleave arrays are empty")
+	assert.T(len(arrs) > 0, "No input sent to interleave")
+	assert.T(len(arrs[0].V2s) > 0 || len(arrs[0].V3s) > 0 || len(arrs[0].V4s) > 0, "Interleave arrays are empty")
 
 	elementCount := 0
 	if len(arrs[0].V2s) > 0 {
@@ -104,7 +150,7 @@ func interleave(arrs ...arrToInterleave) []float32 {
 	totalSize := 0
 	for i := 0; i < len(arrs); i++ {
 
-		asserts.T(len(arrs[i].V2s) == elementCount || len(arrs[i].V3s) == elementCount || len(arrs[i].V4s) == elementCount, "Mesh vertex data given to interleave is not the same length")
+		assert.T(len(arrs[i].V2s) == elementCount || len(arrs[i].V3s) == elementCount || len(arrs[i].V4s) == elementCount, "Mesh vertex data given to interleave is not the same length")
 
 		if len(arrs[i].V2s) > 0 {
 			totalSize += len(arrs[i].V2s) * 2
@@ -125,34 +171,9 @@ func interleave(arrs ...arrToInterleave) []float32 {
 	return out
 }
 
-func flattenVec3(vec3s []gglm.Vec3) []float32 {
-
-	floats := make([]float32, len(vec3s)*3)
-	for i := 0; i < len(vec3s); i++ {
-		floats[i*3+0] = vec3s[i].X()
-		floats[i*3+1] = vec3s[i].Y()
-		floats[i*3+2] = vec3s[i].Z()
-	}
-
-	return floats
-}
-
-func flattenVec4(vec4s []gglm.Vec4) []float32 {
-
-	floats := make([]float32, len(vec4s)*4)
-	for i := 0; i < len(vec4s); i++ {
-		floats[i*4+0] = vec4s[i].X()
-		floats[i*4+1] = vec4s[i].Y()
-		floats[i*4+2] = vec4s[i].Z()
-		floats[i*4+3] = vec4s[i].W()
-	}
-
-	return floats
-}
-
 func flattenFaces(faces []asig.Face) []uint32 {
 
-	asserts.T(len(faces[0].Indices) == 3, fmt.Sprintf("Face doesn't have 3 indices. Index count: %v\n", len(faces[0].Indices)))
+	assert.T(len(faces[0].Indices) == 3, fmt.Sprintf("Face doesn't have 3 indices. Index count: %v\n", len(faces[0].Indices)))
 
 	uints := make([]uint32, len(faces)*3)
 	for i := 0; i < len(faces); i++ {

registry/iterator.go

@@ -0,0 +1,73 @@
+package registry
+
+// Iterator goes through the entire registry it was created from and
+// returns all alive items, and nil after its done.
+//
+// The iterator will still work if items are added/removed to the registry
+// after it was created, but the following conditions apply:
+//   - If items are removed, iterator will not show the removed items (assuming it didn't return them before their removal)
+//   - If items are added, the iterator will either only return older items (i.e. is not affected), or only return newer items (i.e. items that were going to be returned before will now not get returned in favor of newly inserted items), or a mix of old and new items.
+//     However, in all cases the iterator will *never* returns more items than were alive at the time of the iterator's creation.
+//   - If items were both added and removed, the iterator might follow either of the previous 2 cases or a combination of them
+//
+// To summarize: The iterator will *never* return more items than were alive at the time of its creation, and will *never* return freed items
+//
+// Example usage:
+//
+//	for item, handle := it.Next(); !it.IsDone(); item, handle = it.Next() {
+//		// Do stuff
+//	}
+type Iterator[T any] struct {
+	registry       *Registry[T]
+	remainingItems uint
+	currIndex      int
+}
+
+func (it *Iterator[T]) Next() (*T, Handle) {
+
+	if it.IsDone() {
+		return nil, 0
+	}
+
+	// If IsDone() only checked 'remainingItems', then when Next() returns the last item IsDone() will immediately be true which will cause loops to exit before processing the last item!
+	// However, with this check IsDone will remain false until Next() is called at least one more time after returning the last item which ensures the last item is processed in the loop.
+	//
+	// In cases where iterator is created on an empty registry, IsDone() will report true and the above check will return early
+	if it.remainingItems == 0 {
+		it.currIndex = -1
+		return nil, 0
+	}
+
+	for ; it.currIndex < len(it.registry.Handles); it.currIndex++ {
+
+		handle := it.registry.Handles[it.currIndex]
+		if !handle.HasFlag(HandleFlag_Alive) {
+			continue
+		}
+
+		item := &it.registry.Items[it.currIndex]
+		it.currIndex++
+		it.remainingItems--
+		return item, handle
+	}
+
+	// If we reached here means we iterated to the end and didn't find anything, which probably
+	// means that the registry changed since we were created, and that remainingItems is not accurate.
+	//
+	// As such, we zero remaining items so that this iterator is considered done
+	it.currIndex = -1
+	it.remainingItems = 0
+	return nil, 0
+}
+
+func (it *Iterator[T]) IsDone() bool {
+
+	if it.remainingItems != 0 {
+		return false
+	}
+
+	// We have two cases here:
+	// 1. Index of zero means Next() never returned an item. Remaining items of zero without returning anything means we have an empty registry and so its safe to report done
+	// 2. Negative index means Next() has detected we reached the end and that its safe to report being done
+	return it.currIndex <= 0
+}

registry/registry.go

@@ -0,0 +1,131 @@
+package registry
+
+import (
+	"math"
+
+	"github.com/bloeys/nmage/assert"
+)
+
+type freeListitem struct {
+	ItemIndex uint64
+	nextFree  *freeListitem
+}
+
+// Registry is a storage data structure that can efficiently create/get/free items using generational indices.
+// Each item stored in the registry is associated with a 'handle' object that is used to get and free objects
+//
+// The registry 'owns' all items it stores and returns pointers to items in its array. All items are allocated upfront.
+//
+// It is NOT safe to concurrently create or free items. However, it is SAFE to concurrently get items
+type Registry[T any] struct {
+	ItemCount uint
+	Handles   []Handle
+	Items     []T
+
+	FreeList     *freeListitem
+	FreeListSize uint32
+
+	// The number of slots required to be in the free list before the free list
+	// is used for creating new entries
+	FreeListUsageThreshold uint32
+}
+
+func (r *Registry[T]) New() (*T, Handle) {
+
+	assert.T(r.ItemCount < uint(len(r.Handles)), "Can not add more entities to registry because it is full")
+
+	var index uint64 = math.MaxUint64
+
+	// Find index to use for the new item
+	if r.FreeList != nil && r.FreeListSize > r.FreeListUsageThreshold {
+
+		index = r.FreeList.ItemIndex
+
+		r.FreeList = r.FreeList.nextFree
+		r.FreeListSize--
+	} else {
+
+		for i := 0; i < len(r.Handles); i++ {
+
+			handle := r.Handles[i]
+
+			if handle.HasFlag(HandleFlag_Alive) {
+				continue
+			}
+
+			index = uint64(i)
+			break
+		}
+	}
+
+	if index == math.MaxUint64 {
+		panic("failed to create new entity because we did not find a free spot in the registry. Why did the item count assert not go off?")
+	}
+
+	var newItem T
+	newHandle := NewHandle(r.Handles[index].Generation()+1, HandleFlag_Alive, index)
+	assert.T(newHandle != 0, "Entity handle must not be zero")
+
+	r.ItemCount++
+	r.Handles[index] = newHandle
+	r.Items[index] = newItem
+
+	// It is very important we return directly from the items array, because if we return
+	// a pointer to newItem, and T is a value not a pointer, then newItem and what's stored in items will be different
+	return &r.Items[index], newHandle
+}
+
+func (r *Registry[T]) Get(id Handle) *T {
+
+	index := id.Index()
+	assert.T(index < uint64(len(r.Handles)), "Failed to get entity because of invalid entity handle. Handle index is %d while registry only has %d slots. Handle: %+v", index, r.ItemCount, id)
+
+	handle := r.Handles[index]
+	if handle.Generation() != id.Generation() || !handle.HasFlag(HandleFlag_Alive) {
+		return nil
+	}
+
+	item := &r.Items[index]
+	return item
+}
+
+// Free resets the entity flags then adds this entity to the free list
+func (r *Registry[T]) Free(id Handle) {
+
+	index := id.Index()
+	assert.T(index < uint64(len(r.Handles)), "Failed to free entity because of invalid entity handle. Handle index is %d while registry only has %d slots. Handle: %+v", index, r.ItemCount, id)
+
+	// Nothing to do if already free
+	handle := r.Handles[index]
+	if handle.Generation() != id.Generation() || !handle.HasFlag(HandleFlag_Alive) {
+		return
+	}
+
+	// Generation is incremented on aquire, so here we just reset flags
+	r.ItemCount--
+	r.Handles[index] = NewHandle(id.Generation(), HandleFlag_None, index)
+
+	// Add to free list
+	r.FreeList = &freeListitem{
+		ItemIndex: index,
+		nextFree:  r.FreeList,
+	}
+	r.FreeListSize++
+}
+
+func (r *Registry[T]) NewIterator() Iterator[T] {
+	return Iterator[T]{
+		registry:       r,
+		remainingItems: r.ItemCount,
+		currIndex:      0,
+	}
+}
+
+func NewRegistry[T any](size uint32) *Registry[T] {
+	assert.T(size > 0, "Registry size must be more than zero")
+	return &Registry[T]{
+		Handles:                make([]Handle, size),
+		Items:                  make([]T, size),
+		FreeListUsageThreshold: 30,
+	}
+}

registry/registry_handle.go

@@ -0,0 +1,37 @@
+package registry
+
+type HandleFlag byte
+
+const (
+	HandleFlag_None  HandleFlag = 0
+	HandleFlag_Alive HandleFlag = 1 << (iota - 1)
+)
+
+const (
+	GenerationShiftBits = 64 - 8
+	FlagsShiftBits      = 64 - 16
+	IndexBitMask        = 0x00_00_FFFF_FFFF_FFFF
+)
+
+// Byte 1: Generation; Byte 2: Flags; Bytes 3-8: Index
+type Handle uint64
+
+func (h Handle) HasFlag(ef HandleFlag) bool {
+	return h.Flags()&ef > 0
+}
+
+func (h Handle) Generation() byte {
+	return byte(h >> GenerationShiftBits)
+}
+
+func (h Handle) Flags() HandleFlag {
+	return HandleFlag(h >> FlagsShiftBits)
+}
+
+func (h Handle) Index() uint64 {
+	return uint64(h & IndexBitMask)
+}
+
+func NewHandle(generation byte, flags HandleFlag, index uint64) Handle {
+	return Handle(index | (uint64(generation) << GenerationShiftBits) | (uint64(flags) << FlagsShiftBits))
+}

renderer/rend3dgl/rend3dgl.go

@@ -28,7 +28,10 @@ func (r3d *Rend3DGL) Draw(mesh *meshes.Mesh, trMat *gglm.TrMat, mat *materials.M
 	}
 
 	mat.SetUnifMat4("modelMat", &trMat.Mat4)
-	gl.DrawElements(gl.TRIANGLES, mesh.Buf.IndexBufCount, gl.UNSIGNED_INT, gl.PtrOffset(0))
+
+	for i := 0; i < len(mesh.SubMeshes); i++ {
+		gl.DrawElementsBaseVertexWithOffset(gl.TRIANGLES, mesh.SubMeshes[i].IndexCount, gl.UNSIGNED_INT, uintptr(mesh.SubMeshes[i].BaseIndex), mesh.SubMeshes[i].BaseVertex)
+	}
 }
 
 func (r3d *Rend3DGL) FrameEnd() {

res/models/obj.obj

@@ -1,46 +0,0 @@
-# Blender v2.92.0 OBJ File: ''
-# www.blender.org
-mtllib obj.mtl
-o Cube
-v 2.275618 1.000000 0.349413
-v 3.520138 -1.000000 0.102233
-v 2.275618 1.000000 0.752820
-v 3.520138 -1.000000 1.000000
-v 0.244520 1.000000 0.349413
-v -1.000000 -1.000000 0.102233
-v 0.244520 1.000000 0.752820
-v -1.000000 -1.000000 1.000000
-vt 0.806168 0.568832
-vt 0.693832 0.681168
-vt 0.693832 0.568832
-vt 0.375000 1.000000
-vt 0.375000 0.750000
-vt 0.375000 0.000000
-vt 0.625000 0.250000
-vt 0.375000 0.250000
-vt 0.375000 0.500000
-vt 0.125000 0.750000
-vt 0.125000 0.500000
-vt 0.806168 0.681168
-vt 0.625000 0.931168
-vt 0.625000 0.068832
-vn 0.0000 1.0000 0.0000
-vn 0.0000 0.1227 0.9924
-vn -0.8490 0.5283 0.0000
-vn 0.0000 -1.0000 0.0000
-vn 0.8490 0.5283 0.0000
-vn 0.0000 0.1227 -0.9924
-usemtl Material
-s off
-f 5/1/1 3/2/1 1/3/1
-f 3/2/2 8/4/2 4/5/2
-f 8/6/3 5/7/3 6/8/3
-f 2/9/4 8/10/4 6/11/4
-f 1/3/5 4/5/5 2/9/5
-f 5/7/6 2/9/6 6/8/6
-f 5/1/1 7/12/1 3/2/1
-f 3/2/2 7/13/2 8/4/2
-f 8/6/3 7/14/3 5/7/3
-f 2/9/4 4/5/4 8/10/4
-f 1/3/5 3/2/5 4/5/5
-f 5/7/6 1/3/6 2/9/6

res/models/skybox-cube.obj

@@ -0,0 +1,38 @@
+# Blender v2.92.0 OBJ File: 'chair.blend'
+# www.blender.org
+o Cube.002_Cube.005
+v -1.000000 -1.000000 1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+v -1.000000 1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v 1.000000 1.000000 1.000000
+v 1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 -1.000000
+vt 0.375000 0.000000
+vt 0.625000 0.000000
+vt 0.625000 0.250000
+vt 0.375000 0.250000
+vt 0.625000 0.500000
+vt 0.375000 0.500000
+vt 0.625000 0.750000
+vt 0.375000 0.750000
+vt 0.625000 1.000000
+vt 0.375000 1.000000
+vt 0.125000 0.500000
+vt 0.125000 0.750000
+vt 0.875000 0.500000
+vt 0.875000 0.750000
+vn -1.0000 0.0000 0.0000
+vn 0.0000 0.0000 -1.0000
+vn 1.0000 0.0000 0.0000
+vn 0.0000 0.0000 1.0000
+vn 0.0000 -1.0000 0.0000
+vn 0.0000 1.0000 0.0000
+s off
+f 1/1/1 2/2/1 4/3/1 3/4/1
+f 3/4/2 4/3/2 8/5/2 7/6/2
+f 7/6/3 8/5/3 6/7/3 5/8/3
+f 5/8/4 6/7/4 2/9/4 1/10/4
+f 3/11/5 7/6/5 5/8/5 1/12/5
+f 8/5/6 4/13/6 2/14/6 6/7/6

res/shaders/debug-depth.glsl

@@ -1,3 +1,4 @@
+//shader:vertex
 #version 410
 
 layout(location=0) in vec3 vertPosIn;
@@ -23,4 +24,29 @@ void main()
     fragPos = vec3(modelMat * vec4(vertPosIn, 1.0));
 
     gl_Position = projMat * viewMat * modelMat * vec4(vertPosIn, 1.0);
-}
+}
+
+//shader:fragment
+#version 410
+
+in vec3 vertColor;
+in vec3 vertNormal;
+in vec2 vertUV0;
+in vec3 fragPos;
+
+out vec4 fragColor;
+
+uniform float near = 0.1;
+uniform float far  = 200.0;
+  
+float LinearizeDepth(float depth) 
+{
+    float z = depth * 2.0 - 1.0; // back to NDC 
+    return (2.0 * near * far) / (far + near - z * (far - near));	
+}
+
+void main()
+{
+    float depth = LinearizeDepth(gl_FragCoord.z) / far;
+    fragColor = vec4(vec3(depth), 1.0);
+} 

res/shaders/imgui.frag.glsl

@@ -1,13 +0,0 @@
-#version 410
-
-uniform sampler2D Texture;
-
-in vec2 Frag_UV;
-in vec4 Frag_Color;
-
-out vec4 Out_Color;
-
-void main()
-{
-    Out_Color = vec4(Frag_Color.rgb, Frag_Color.a * texture(Texture, Frag_UV.st).r);
-}

res/shaders/imgui.vert.glsl

@@ -1,17 +0,0 @@
-#version 410
-
-uniform mat4 ProjMtx;
-
-in vec2 Position;
-in vec2 UV;
-in vec4 Color;
-
-out vec2 Frag_UV;
-out vec4 Frag_Color;
-
-void main()
-{
-    Frag_UV = UV;
-    Frag_Color = Color;
-    gl_Position = ProjMtx * vec4(Position.xy, 0, 1);
-}

res/shaders/simple.frag.glsl

@@ -1,26 +0,0 @@
-#version 410
-
-uniform float ambientStrength = 0.1;
-uniform vec3 ambientLightColor = vec3(1, 1, 1);
-
-uniform vec3 lightPos1;
-uniform vec3 lightColor1;
-
-uniform sampler2D diffTex;
-
-in vec3 vertColor;
-in vec3 vertNormal;
-in vec2 vertUV0;
-in vec3 fragPos;
-
-out vec4 fragColor;
-
-void main()
-{
-    vec3 lightDir = normalize(lightPos1 - fragPos);  
-    float diffStrength = max(0.0, dot(normalize(vertNormal), lightDir));
-
-    vec3 finalAmbientColor = ambientLightColor * ambientStrength;
-    vec4 texColor = texture(diffTex, vertUV0);
-    fragColor = vec4(texColor.rgb * vertColor * (finalAmbientColor + diffStrength*lightColor1) , texColor.a);
-} 

res/shaders/simple.glsl

@@ -0,0 +1,55 @@
+//shader:vertex
+#version 410
+
+layout(location=0) in vec3 vertPosIn;
+layout(location=1) in vec3 vertNormalIn;
+layout(location=2) in vec2 vertUV0In;
+layout(location=3) in vec3 vertColorIn;
+
+out vec3 vertNormal;
+out vec2 vertUV0;
+out vec3 vertColor;
+out vec3 fragPos;
+
+//MVP = Model View Projection
+uniform mat4 modelMat;
+uniform mat4 viewMat;
+uniform mat4 projMat;
+
+void main()
+{
+    vertNormal = mat3(transpose(inverse(modelMat))) * vertNormalIn;
+    vertUV0 = vertUV0In;
+    vertColor = vertColorIn;
+    fragPos = vec3(modelMat * vec4(vertPosIn, 1.0));
+
+    gl_Position = projMat * viewMat * modelMat * vec4(vertPosIn, 1.0);
+}
+
+//shader:fragment
+#version 410
+
+uniform float ambientStrength = 0;
+uniform vec3 ambientLightColor = vec3(1, 1, 1);
+
+uniform vec3 lightPos1;
+uniform vec3 lightColor1;
+
+uniform sampler2D diffTex;
+
+in vec3 vertColor;
+in vec3 vertNormal;
+in vec2 vertUV0;
+in vec3 fragPos;
+
+out vec4 fragColor;
+
+void main()
+{
+    vec3 lightDir = normalize(lightPos1 - fragPos);  
+    float diffStrength = max(0.0, dot(normalize(vertNormal), lightDir));
+
+    vec3 finalAmbientColor = ambientLightColor * ambientStrength;
+    vec4 texColor = texture(diffTex, vertUV0);
+    fragColor = vec4(texColor.rgb * vertColor * (finalAmbientColor + diffStrength*lightColor1) , texColor.a);
+} 

res/shaders/skybox.glsl

@@ -0,0 +1,33 @@
+//shader:vertex
+#version 410
+
+layout(location=0) in vec3 vertPosIn;
+layout(location=1) in vec3 vertNormalIn;
+layout(location=2) in vec2 vertUV0In;
+layout(location=3) in vec3 vertColorIn;
+
+out vec3 vertUV0;
+
+uniform mat4 viewMat;
+uniform mat4 projMat;
+
+void main()
+{
+    vertUV0 = vec3(vertPosIn.x, vertPosIn.y, -vertPosIn.z);
+    vec4 pos = projMat * viewMat * vec4(vertPosIn, 1.0);
+    gl_Position = pos.xyww;
+}
+
+//shader:fragment
+#version 410
+
+in vec3 vertUV0;
+
+out vec4 fragColor;
+
+uniform samplerCube skybox;
+
+void main()
+{
+    fragColor = texture(skybox, vertUV0);
+} 

shaders/shaders.go

@@ -1,6 +1,7 @@
 package shaders
 
 import (
+	"bytes"
 	"errors"
 	"os"
 	"strings"
@@ -28,14 +29,69 @@ func NewShaderProgram() (ShaderProgram, error) {
 	return ShaderProgram{ID: id}, nil
 }
 
-func LoadAndCompilerShader(shaderPath string, shaderType ShaderType) (Shader, error) {
+func LoadAndCompileCombinedShader(shaderPath string) (ShaderProgram, error) {
 
-	shaderSource, err := os.ReadFile(shaderPath)
+	combinedSource, err := os.ReadFile(shaderPath)
 	if err != nil {
 		logging.ErrLog.Println("Failed to read shader. Err: ", err)
-		return Shader{}, err
+		return ShaderProgram{}, err
 	}
 
+	return LoadAndCompileCombinedShaderSrc(combinedSource)
+
+}
+func LoadAndCompileCombinedShaderSrc(shaderSrc []byte) (ShaderProgram, error) {
+
+	shaderSources := bytes.Split(shaderSrc, []byte("//shader:"))
+	if len(shaderSources) == 1 {
+		return ShaderProgram{}, errors.New("failed to read combined shader. Did not find '//shader:vertex' or '//shader:fragment'")
+	}
+
+	shdrProg, err := NewShaderProgram()
+	if err != nil {
+		return ShaderProgram{}, errors.New("failed to create new shader program. Err: " + err.Error())
+	}
+
+	loadedShdrCount := 0
+	for i := 0; i < len(shaderSources); i++ {
+
+		src := shaderSources[i]
+
+		//This can happen when the shader type is at the start of the file
+		if len(bytes.TrimSpace(src)) == 0 {
+			continue
+		}
+
+		var shdrType ShaderType
+		if bytes.HasPrefix(src, []byte("vertex")) {
+			src = src[6:]
+			shdrType = VertexShaderType
+		} else if bytes.HasPrefix(src, []byte("fragment")) {
+			src = src[8:]
+			shdrType = FragmentShaderType
+		} else {
+			return ShaderProgram{}, errors.New("unknown shader type. Must be '//shader:vertex' or '//shader:fragment'")
+		}
+
+		shdr, err := CompileShaderOfType(src, shdrType)
+		if err != nil {
+			return ShaderProgram{}, err
+		}
+
+		loadedShdrCount++
+		shdrProg.AttachShader(shdr)
+	}
+
+	if loadedShdrCount == 0 {
+		return ShaderProgram{}, errors.New("no valid shaders found. Please put '//shader:vertex' or '//shader:fragment' before your shaders")
+	}
+
+	shdrProg.Link()
+	return shdrProg, nil
+}
+
+func CompileShaderOfType(shaderSource []byte, shaderType ShaderType) (Shader, error) {
+
 	shaderID := gl.CreateShader(uint32(shaderType))
 	if shaderID == 0 {
 		logging.ErrLog.Println("Failed to create shader.")

timing/timing.go

@@ -43,7 +43,7 @@ func FrameEnded() {
 	//Calculate new dt
 	dt = float32(time.Since(frameStart).Seconds())
 	if dt == 0 {
-		dt = float32(time.Microsecond)
+		dt = float32(time.Microsecond.Seconds())
 	}
 }
 

ui/imgui/imgui.go

@@ -1,17 +1,16 @@
 package nmageimgui
 
 import (
+	imgui "github.com/AllenDang/cimgui-go"
 	"github.com/bloeys/gglm/gglm"
-	"github.com/bloeys/nmage/asserts"
 	"github.com/bloeys/nmage/materials"
 	"github.com/bloeys/nmage/timing"
 	"github.com/go-gl/gl/v4.1-core/gl"
-	"github.com/inkyblackness/imgui-go/v4"
 	"github.com/veandco/go-sdl2/sdl"
 )
 
 type ImguiInfo struct {
-	ImCtx *imgui.Context
+	ImCtx imgui.Context
 
 	Mat        *materials.Material
 	VaoID      uint32
@@ -22,9 +21,9 @@ type ImguiInfo struct {
 
 func (i *ImguiInfo) FrameStart(winWidth, winHeight float32) {
 
-	if err := i.ImCtx.SetCurrent(); err != nil {
-		asserts.T(false, "Setting imgui ctx as current failed. Err: "+err.Error())
-	}
+	// if err := i.ImCtx.SetCurrent(); err != nil {
+	// 	assert.T(false, "Setting imgui ctx as current failed. Err: "+err.Error())
+	// }
 
 	imIO := imgui.CurrentIO()
 	imIO.SetDisplaySize(imgui.Vec2{X: float32(winWidth), Y: float32(winHeight)})
@@ -35,9 +34,9 @@ func (i *ImguiInfo) FrameStart(winWidth, winHeight float32) {
 
 func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32) {
 
-	if err := i.ImCtx.SetCurrent(); err != nil {
-		asserts.T(false, "Setting imgui ctx as current failed. Err: "+err.Error())
-	}
+	// if err := i.ImCtx.SetCurrent(); err != nil {
+	// 	assert.T(false, "Setting imgui ctx as current failed. Err: "+err.Error())
+	// }
 
 	imgui.Render()
 
@@ -46,7 +45,7 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 		return
 	}
 
-	drawData := imgui.RenderedDrawData()
+	drawData := imgui.CurrentDrawData()
 	drawData.ScaleClipRects(imgui.Vec2{
 		X: float32(fbWidth) / float32(winWidth),
 		Y: float32(fbHeight) / float32(winHeight),
@@ -66,8 +65,7 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 	// DisplayMin is typically (0,0) for single viewport apps.
 
 	i.Mat.Bind()
-
-	gl.Uniform1i(gl.GetUniformLocation(i.Mat.ShaderProg.ID, gl.Str("Texture\x00")), 0)
+	i.Mat.SetUnifInt32("Texture", 0)
 
 	//PERF: only update the ortho matrix on window resize
 	orthoMat := gglm.Ortho(0, float32(winWidth), 0, float32(winHeight), 0, 20)
@@ -97,11 +95,11 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 	// Draw
 	for _, list := range drawData.CommandLists() {
 
-		vertexBuffer, vertexBufferSize := list.VertexBuffer()
+		vertexBuffer, vertexBufferSize := list.GetVertexBuffer()
 		gl.BindBuffer(gl.ARRAY_BUFFER, i.VboID)
 		gl.BufferData(gl.ARRAY_BUFFER, vertexBufferSize, vertexBuffer, gl.STREAM_DRAW)
 
-		indexBuffer, indexBufferSize := list.IndexBuffer()
+		indexBuffer, indexBufferSize := list.GetIndexBuffer()
 		gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, i.IndexBufID)
 		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, indexBufferSize, indexBuffer, gl.STREAM_DRAW)
 
@@ -114,7 +112,7 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 				clipRect := cmd.ClipRect()
 				gl.Scissor(int32(clipRect.X), int32(fbHeight)-int32(clipRect.W), int32(clipRect.Z-clipRect.X), int32(clipRect.W-clipRect.Y))
 
-				gl.DrawElementsBaseVertex(gl.TRIANGLES, int32(cmd.ElementCount()), uint32(drawType), gl.PtrOffset(cmd.IndexOffset()*indexSize), int32(cmd.VertexOffset()))
+				gl.DrawElementsBaseVertex(gl.TRIANGLES, int32(cmd.ElemCount()), uint32(drawType), gl.PtrOffset(int(cmd.IdxOffset())*indexSize), int32(cmd.VtxOffset()))
 			}
 		}
 	}
@@ -125,14 +123,14 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 	gl.Enable(gl.DEPTH_TEST)
 }
 
-func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *imgui.FontConfig, glyphRanges *imgui.GlyphRanges) imgui.Font {
+func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *imgui.FontConfig, glyphRanges *imgui.GlyphRange) imgui.Font {
 
-	fontConfigToUse := imgui.DefaultFontConfig
+	fontConfigToUse := imgui.NewFontConfig()
 	if fontConfig != nil {
 		fontConfigToUse = *fontConfig
 	}
 
-	glyphRangesToUse := imgui.EmptyGlyphRanges
+	glyphRangesToUse := imgui.NewGlyphRange()
 	if glyphRanges != nil {
 		glyphRangesToUse = *glyphRanges
 	}
@@ -140,24 +138,61 @@ func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *im
 	imIO := imgui.CurrentIO()
 
 	a := imIO.Fonts()
-	f := a.AddFontFromFileTTFV(fontPath, fontSize, fontConfigToUse, glyphRangesToUse)
-	image := a.TextureDataAlpha8()
+	f := a.AddFontFromFileTTFV(fontPath, fontSize, fontConfigToUse, glyphRangesToUse.Data())
+	pixels, width, height, _ := a.GetTextureDataAsAlpha8()
 
 	gl.BindTexture(gl.TEXTURE_2D, i.TexID)
-	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(image.Width), int32(image.Height), 0, gl.RED, gl.UNSIGNED_BYTE, image.Pixels)
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(width), int32(height), 0, gl.RED, gl.UNSIGNED_BYTE, pixels)
 
 	return f
 }
 
-func NewImGUI() ImguiInfo {
+const imguiShdrSrc = `
+//shader:vertex
+#version 410
+
+uniform mat4 ProjMtx;
+
+in vec2 Position;
+in vec2 UV;
+in vec4 Color;
+
+out vec2 Frag_UV;
+out vec4 Frag_Color;
+
+void main()
+{
+    Frag_UV = UV;
+    Frag_Color = Color;
+    gl_Position = ProjMtx * vec4(Position.xy, 0, 1);
+}
+
+//shader:fragment
+#version 410
+
+uniform sampler2D Texture;
+
+in vec2 Frag_UV;
+in vec4 Frag_Color;
+
+out vec4 Out_Color;
+
+void main()
+{
+    Out_Color = vec4(Frag_Color.rgb, Frag_Color.a * texture(Texture, Frag_UV.st).r);
+}
+`
+
+func NewImGui() ImguiInfo {
 
 	imguiInfo := ImguiInfo{
-		ImCtx: imgui.CreateContext(nil),
-		Mat:   materials.NewMaterial("ImGUI Mat", "./res/shaders/imgui"),
+		ImCtx: imgui.CreateContext(),
+		Mat:   materials.NewMaterialSrc("ImGUI Mat", []byte(imguiShdrSrc)),
 	}
 
-	imIO := imgui.CurrentIO()
-	imIO.SetBackendFlags(imIO.GetBackendFlags() | imgui.BackendFlagsRendererHasVtxOffset)
+	io := imgui.CurrentIO()
+	io.SetConfigFlags(io.ConfigFlags() | imgui.ConfigFlagsDockingEnable)
+	io.SetBackendFlags(io.BackendFlags() | imgui.BackendFlagsRendererHasVtxOffset)
 
 	gl.GenVertexArrays(1, &imguiInfo.VaoID)
 	gl.GenBuffers(1, &imguiInfo.VboID)
@@ -170,11 +205,11 @@ func NewImGUI() ImguiInfo {
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
 	gl.PixelStorei(gl.UNPACK_ROW_LENGTH, 0)
 
-	image := imIO.Fonts().TextureDataAlpha8()
-	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(image.Width), int32(image.Height), 0, gl.RED, gl.UNSIGNED_BYTE, image.Pixels)
+	pixels, width, height, _ := io.Fonts().GetTextureDataAsAlpha8()
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(width), int32(height), 0, gl.RED, gl.UNSIGNED_BYTE, pixels)
 
 	// Store our identifier
-	imIO.Fonts().SetTextureID(imgui.TextureID(imguiInfo.TexID))
+	io.Fonts().SetTexID(imgui.TextureID(uintptr(imguiInfo.TexID)))
 
 	//Shader attributes
 	imguiInfo.Mat.Bind()
@@ -183,35 +218,223 @@ func NewImGUI() ImguiInfo {
 	imguiInfo.Mat.EnableAttribute("Color")
 	imguiInfo.Mat.UnBind()
 
-	//Init imgui input mapping
-	keys := map[int]int{
-		imgui.KeyTab:        sdl.SCANCODE_TAB,
-		imgui.KeyLeftArrow:  sdl.SCANCODE_LEFT,
-		imgui.KeyRightArrow: sdl.SCANCODE_RIGHT,
-		imgui.KeyUpArrow:    sdl.SCANCODE_UP,
-		imgui.KeyDownArrow:  sdl.SCANCODE_DOWN,
-		imgui.KeyPageUp:     sdl.SCANCODE_PAGEUP,
-		imgui.KeyPageDown:   sdl.SCANCODE_PAGEDOWN,
-		imgui.KeyHome:       sdl.SCANCODE_HOME,
-		imgui.KeyEnd:        sdl.SCANCODE_END,
-		imgui.KeyInsert:     sdl.SCANCODE_INSERT,
-		imgui.KeyDelete:     sdl.SCANCODE_DELETE,
-		imgui.KeyBackspace:  sdl.SCANCODE_BACKSPACE,
-		imgui.KeySpace:      sdl.SCANCODE_BACKSPACE,
-		imgui.KeyEnter:      sdl.SCANCODE_RETURN,
-		imgui.KeyEscape:     sdl.SCANCODE_ESCAPE,
-		imgui.KeyA:          sdl.SCANCODE_A,
-		imgui.KeyC:          sdl.SCANCODE_C,
-		imgui.KeyV:          sdl.SCANCODE_V,
-		imgui.KeyX:          sdl.SCANCODE_X,
-		imgui.KeyY:          sdl.SCANCODE_Y,
-		imgui.KeyZ:          sdl.SCANCODE_Z,
-	}
-
-	// Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
-	for imguiKey, nativeKey := range keys {
-		imIO.KeyMap(imguiKey, nativeKey)
-	}
-
 	return imguiInfo
 }
+
+func SdlScancodeToImGuiKey(scancode sdl.Scancode) imgui.Key {
+
+	switch scancode {
+	case sdl.SCANCODE_TAB:
+		return imgui.KeyTab
+	case sdl.SCANCODE_LEFT:
+		return imgui.KeyLeftArrow
+	case sdl.SCANCODE_RIGHT:
+		return imgui.KeyRightArrow
+	case sdl.SCANCODE_UP:
+		return imgui.KeyUpArrow
+	case sdl.SCANCODE_DOWN:
+		return imgui.KeyDownArrow
+	case sdl.SCANCODE_PAGEUP:
+		return imgui.KeyPageUp
+	case sdl.SCANCODE_PAGEDOWN:
+		return imgui.KeyPageDown
+	case sdl.SCANCODE_HOME:
+		return imgui.KeyHome
+	case sdl.SCANCODE_END:
+		return imgui.KeyEnd
+	case sdl.SCANCODE_INSERT:
+		return imgui.KeyInsert
+	case sdl.SCANCODE_DELETE:
+		return imgui.KeyDelete
+	case sdl.SCANCODE_BACKSPACE:
+		return imgui.KeyBackspace
+	case sdl.SCANCODE_SPACE:
+		return imgui.KeySpace
+	case sdl.SCANCODE_RETURN:
+		return imgui.KeyEnter
+	case sdl.SCANCODE_ESCAPE:
+		return imgui.KeyEscape
+	case sdl.SCANCODE_APOSTROPHE:
+		return imgui.KeyApostrophe
+	case sdl.SCANCODE_COMMA:
+		return imgui.KeyComma
+	case sdl.SCANCODE_MINUS:
+		return imgui.KeyMinus
+	case sdl.SCANCODE_PERIOD:
+		return imgui.KeyPeriod
+	case sdl.SCANCODE_SLASH:
+		return imgui.KeySlash
+	case sdl.SCANCODE_SEMICOLON:
+		return imgui.KeySemicolon
+	case sdl.SCANCODE_EQUALS:
+		return imgui.KeyEqual
+	case sdl.SCANCODE_LEFTBRACKET:
+		return imgui.KeyLeftBracket
+	case sdl.SCANCODE_BACKSLASH:
+		return imgui.KeyBackslash
+	case sdl.SCANCODE_RIGHTBRACKET:
+		return imgui.KeyRightBracket
+	case sdl.SCANCODE_GRAVE:
+		return imgui.KeyGraveAccent
+	case sdl.SCANCODE_CAPSLOCK:
+		return imgui.KeyCapsLock
+	case sdl.SCANCODE_SCROLLLOCK:
+		return imgui.KeyScrollLock
+	case sdl.SCANCODE_NUMLOCKCLEAR:
+		return imgui.KeyNumLock
+	case sdl.SCANCODE_PRINTSCREEN:
+		return imgui.KeyPrintScreen
+	case sdl.SCANCODE_PAUSE:
+		return imgui.KeyPause
+	case sdl.SCANCODE_KP_0:
+		return imgui.KeyKeypad0
+	case sdl.SCANCODE_KP_1:
+		return imgui.KeyKeypad1
+	case sdl.SCANCODE_KP_2:
+		return imgui.KeyKeypad2
+	case sdl.SCANCODE_KP_3:
+		return imgui.KeyKeypad3
+	case sdl.SCANCODE_KP_4:
+		return imgui.KeyKeypad4
+	case sdl.SCANCODE_KP_5:
+		return imgui.KeyKeypad5
+	case sdl.SCANCODE_KP_6:
+		return imgui.KeyKeypad6
+	case sdl.SCANCODE_KP_7:
+		return imgui.KeyKeypad7
+	case sdl.SCANCODE_KP_8:
+		return imgui.KeyKeypad8
+	case sdl.SCANCODE_KP_9:
+		return imgui.KeyKeypad9
+	case sdl.SCANCODE_KP_PERIOD:
+		return imgui.KeyKeypadDecimal
+	case sdl.SCANCODE_KP_DIVIDE:
+		return imgui.KeyKeypadDivide
+	case sdl.SCANCODE_KP_MULTIPLY:
+		return imgui.KeyKeypadMultiply
+	case sdl.SCANCODE_KP_MINUS:
+		return imgui.KeyKeypadSubtract
+	case sdl.SCANCODE_KP_PLUS:
+		return imgui.KeyKeypadAdd
+	case sdl.SCANCODE_KP_ENTER:
+		return imgui.KeyKeypadEnter
+	case sdl.SCANCODE_KP_EQUALS:
+		return imgui.KeyKeypadEqual
+	case sdl.SCANCODE_LSHIFT:
+		return imgui.KeyLeftShift
+	case sdl.SCANCODE_LCTRL:
+		return imgui.KeyLeftCtrl
+	case sdl.SCANCODE_LALT:
+		return imgui.KeyLeftAlt
+	case sdl.SCANCODE_LGUI:
+		return imgui.KeyLeftSuper
+	case sdl.SCANCODE_RSHIFT:
+		return imgui.KeyRightShift
+	case sdl.SCANCODE_RCTRL:
+		return imgui.KeyRightCtrl
+	case sdl.SCANCODE_RALT:
+		return imgui.KeyRightAlt
+	case sdl.SCANCODE_RGUI:
+		return imgui.KeyRightSuper
+	case sdl.SCANCODE_MENU:
+		return imgui.KeyMenu
+	case sdl.SCANCODE_0:
+		return imgui.Key0
+	case sdl.SCANCODE_1:
+		return imgui.Key1
+	case sdl.SCANCODE_2:
+		return imgui.Key2
+	case sdl.SCANCODE_3:
+		return imgui.Key3
+	case sdl.SCANCODE_4:
+		return imgui.Key4
+	case sdl.SCANCODE_5:
+		return imgui.Key5
+	case sdl.SCANCODE_6:
+		return imgui.Key6
+	case sdl.SCANCODE_7:
+		return imgui.Key7
+	case sdl.SCANCODE_8:
+		return imgui.Key8
+	case sdl.SCANCODE_9:
+		return imgui.Key9
+	case sdl.SCANCODE_A:
+		return imgui.KeyA
+	case sdl.SCANCODE_B:
+		return imgui.KeyB
+	case sdl.SCANCODE_C:
+		return imgui.KeyC
+	case sdl.SCANCODE_D:
+		return imgui.KeyD
+	case sdl.SCANCODE_E:
+		return imgui.KeyE
+	case sdl.SCANCODE_F:
+		return imgui.KeyF
+	case sdl.SCANCODE_G:
+		return imgui.KeyG
+	case sdl.SCANCODE_H:
+		return imgui.KeyH
+	case sdl.SCANCODE_I:
+		return imgui.KeyI
+	case sdl.SCANCODE_J:
+		return imgui.KeyJ
+	case sdl.SCANCODE_K:
+		return imgui.KeyK
+	case sdl.SCANCODE_L:
+		return imgui.KeyL
+	case sdl.SCANCODE_M:
+		return imgui.KeyM
+	case sdl.SCANCODE_N:
+		return imgui.KeyN
+	case sdl.SCANCODE_O:
+		return imgui.KeyO
+	case sdl.SCANCODE_P:
+		return imgui.KeyP
+	case sdl.SCANCODE_Q:
+		return imgui.KeyQ
+	case sdl.SCANCODE_R:
+		return imgui.KeyR
+	case sdl.SCANCODE_S:
+		return imgui.KeyS
+	case sdl.SCANCODE_T:
+		return imgui.KeyT
+	case sdl.SCANCODE_U:
+		return imgui.KeyU
+	case sdl.SCANCODE_V:
+		return imgui.KeyV
+	case sdl.SCANCODE_W:
+		return imgui.KeyW
+	case sdl.SCANCODE_X:
+		return imgui.KeyX
+	case sdl.SCANCODE_Y:
+		return imgui.KeyY
+	case sdl.SCANCODE_Z:
+		return imgui.KeyZ
+	case sdl.SCANCODE_F1:
+		return imgui.KeyF1
+	case sdl.SCANCODE_F2:
+		return imgui.KeyF2
+	case sdl.SCANCODE_F3:
+		return imgui.KeyF3
+	case sdl.SCANCODE_F4:
+		return imgui.KeyF4
+	case sdl.SCANCODE_F5:
+		return imgui.KeyF5
+	case sdl.SCANCODE_F6:
+		return imgui.KeyF6
+	case sdl.SCANCODE_F7:
+		return imgui.KeyF7
+	case sdl.SCANCODE_F8:
+		return imgui.KeyF8
+	case sdl.SCANCODE_F9:
+		return imgui.KeyF9
+	case sdl.SCANCODE_F10:
+		return imgui.KeyF10
+	case sdl.SCANCODE_F11:
+		return imgui.KeyF11
+	case sdl.SCANCODE_F12:
+		return imgui.KeyF12
+	default:
+		return imgui.KeyNone
+	}
+}