Build script + rename tag release->nmage_release+protect against invalid physx use

.github/workflows/build-nmage.yml

@@ -9,10 +9,10 @@ jobs:
     runs-on: macos-12
     steps:
     
-      - name: Install golang
+      - name: Install golang 1.18
         uses: actions/setup-go@v3
         with:
-          go-version: '>=1.22'
+          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

assets/textures.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"image"
+	"image/color"
 	"image/jpeg"
 	"image/png"
 	"io"
@@ -13,7 +14,6 @@ import (
 	"unsafe"
 
 	"github.com/go-gl/gl/v4.1-core/gl"
-	"github.com/mandykoh/prism"
 )
 
 type ColorFormat int
@@ -23,20 +23,11 @@ const (
 )
 
 type Texture struct {
-	// 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)
+	//Path only exists for textures loaded from disk
+	Path   string
+	TexID  uint32
+	Width  int32
 	Height int32
-
-	// Pixels usually stored in RGBA format
 	Pixels []byte
 }
 
@@ -45,7 +36,6 @@ type TextureLoadOptions struct {
 	WriteToCache     bool
 	GenMipMaps       bool
 	KeepPixelsInMem  bool
-	NoSrgba          bool
 }
 
 type Cubemap struct {
@@ -77,20 +67,16 @@ func LoadTexturePNG(file string, loadOptions *TextureLoadOptions) (Texture, erro
 		return Texture{}, err
 	}
 
-	bytesReader := bytes.NewReader(fileBytes)
-	img, err := png.Decode(bytesReader)
+	img, err := png.Decode(bytes.NewReader(fileBytes))
 	if err != nil {
 		return Texture{}, err
 	}
 
-	nrgbaImg := prism.ConvertImageToNRGBA(img, 2)
 	tex := Texture{
-		Path:   file,
-		Pixels: nrgbaImg.Pix,
-		Width:  int32(nrgbaImg.Bounds().Dx()),
-		Height: int32(nrgbaImg.Bounds().Dy()),
+		Path: file,
 	}
-	flipImgPixelsVertically(tex.Pixels, int(tex.Width), int(tex.Height), 4)
+
+	tex.Pixels, tex.Width, tex.Height = pixelsFromNrgbaPng(img)
 
 	//Prepare opengl stuff
 	gl.GenTextures(1, &tex.TexID)
@@ -103,12 +89,7 @@ func LoadTexturePNG(file string, loadOptions *TextureLoadOptions) (Texture, erro
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
 
 	// load and generate the texture
-	internalFormat := int32(gl.SRGB_ALPHA)
-	if loadOptions.NoSrgba {
-		internalFormat = gl.RGBA8
-	}
-
-	gl.TexImage2D(gl.TEXTURE_2D, 0, internalFormat, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
 
 	if loadOptions.GenMipMaps {
 		gl.GenerateMipmap(tex.TexID)
@@ -131,14 +112,8 @@ func LoadTextureInMemPngImg(img image.Image, loadOptions *TextureLoadOptions) (T
 		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)
+	tex := Texture{}
+	tex.Pixels, tex.Width, tex.Height = pixelsFromNrgbaPng(img)
 
 	//Prepare opengl stuff
 	gl.GenTextures(1, &tex.TexID)
@@ -151,12 +126,7 @@ func LoadTextureInMemPngImg(img image.Image, loadOptions *TextureLoadOptions) (T
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
 
 	// load and generate the texture
-	internalFormat := int32(gl.SRGB_ALPHA)
-	if loadOptions.NoSrgba {
-		internalFormat = gl.RGBA8
-	}
-
-	gl.TexImage2D(gl.TEXTURE_2D, 0, internalFormat, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
 
 	if loadOptions.GenMipMaps {
 		gl.GenerateMipmap(tex.TexID)
@@ -196,14 +166,11 @@ func LoadTextureJpeg(file string, loadOptions *TextureLoadOptions) (Texture, err
 		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()),
+		Path: file,
 	}
-	flipImgPixelsVertically(tex.Pixels, int(tex.Width), int(tex.Height), 4)
+
+	tex.Pixels, tex.Width, tex.Height = pixelsFromNrgbaPng(img)
 
 	//Prepare opengl stuff
 	gl.GenTextures(1, &tex.TexID)
@@ -216,12 +183,7 @@ func LoadTextureJpeg(file string, loadOptions *TextureLoadOptions) (Texture, err
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
 
 	// load and generate the texture
-	internalFormat := int32(gl.SRGB_ALPHA)
-	if loadOptions.NoSrgba {
-		internalFormat = gl.RGBA8
-	}
-
-	gl.TexImage2D(gl.TEXTURE_2D, 0, internalFormat, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, tex.Width, tex.Height, 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tex.Pixels[0]))
 
 	if loadOptions.GenMipMaps {
 		gl.GenerateMipmap(tex.TexID)
@@ -238,19 +200,65 @@ func LoadTextureJpeg(file string, loadOptions *TextureLoadOptions) (Texture, err
 	return tex, nil
 }
 
-// LoadCubemapTextures only supports the 'TextureIsSrgba' option
-func LoadCubemapTextures(rightTex, leftTex, topTex, botTex, frontTex, backTex string, loadOptions *TextureLoadOptions) (Cubemap, error) {
+func pixelsFromNrgbaPng(img image.Image) (pixels []byte, width, height int32) {
 
-	if loadOptions == nil {
-		loadOptions = &TextureLoadOptions{}
+	//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
+	width, height = int32(img.Bounds().Dx()), int32(img.Bounds().Dy())
+	pixels = make([]byte, img.Bounds().Dx()*img.Bounds().Dy()*4)
+	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)
+
+			pixels[i] = c.R
+			pixels[i+1] = c.G
+			pixels[i+2] = c.B
+			pixels[i+3] = c.A
+
+			i += 4
+		}
 	}
 
+	return pixels, width, height
+}
+
+func pixelsFromNrgbaJpg(img image.Image) (pixels []byte, width, height int32) {
+
+	//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
+	width, height = int32(img.Bounds().Dx()), int32(img.Bounds().Dy())
+	pixels = make([]byte, img.Bounds().Dx()*img.Bounds().Dy()*4)
+	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)
+
+			pixels[i] = c.R
+			pixels[i+1] = c.G
+			pixels[i+2] = c.B
+			pixels[i+3] = c.A
+
+			i += 4
+		}
+	}
+
+	return pixels, width, height
+}
+
+func LoadCubemapTextures(rightTex, leftTex, topTex, botTex, frontTex, backTex string) (Cubemap, error) {
+
 	var imgDecoder func(r io.Reader) (image.Image, error)
+	var pixelDecoder func(image.Image) ([]byte, int32, int32)
 	ext := strings.ToLower(path.Ext(rightTex))
 	if ext == ".jpg" || ext == ".jpeg" {
 		imgDecoder = jpeg.Decode
+		pixelDecoder = pixelsFromNrgbaJpg
 	} else if ext == ".png" {
 		imgDecoder = png.Decode
+		pixelDecoder = pixelsFromNrgbaPng
 	} else {
 		return Cubemap{}, fmt.Errorf("unknown image extension: %s. Expected one of: .jpg, .jpeg, .png", ext)
 	}
@@ -284,16 +292,9 @@ func LoadCubemapTextures(rightTex, leftTex, topTex, botTex, frontTex, backTex st
 			return Cubemap{}, err
 		}
 
-		nrgbaImg := prism.ConvertImageToNRGBA(img, 2)
-		height := int32(nrgbaImg.Bounds().Dy())
-		width := int32(nrgbaImg.Bounds().Dx())
+		pixels, width, height := pixelDecoder(img)
 
-		internalFormat := int32(gl.SRGB_ALPHA)
-		if loadOptions.NoSrgba {
-			internalFormat = gl.RGBA8
-		}
-
-		gl.TexImage2D(uint32(gl.TEXTURE_CUBE_MAP_POSITIVE_X)+i, 0, internalFormat, int32(width), int32(height), 0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&nrgbaImg.Pix[0]))
+		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(&pixels[0]))
 	}
 
 	// set the texture wrapping/filtering options (on the currently bound texture object)
@@ -305,21 +306,3 @@ func LoadCubemapTextures(rightTex, leftTex, topTex, botTex, frontTex, backTex st
 
 	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/buffers.go

@@ -0,0 +1,131 @@
+package buffers
+
+import (
+	"github.com/bloeys/nmage/logging"
+	"github.com/go-gl/gl/v4.1-core/gl"
+)
+
+type Buffer struct {
+	VAOID uint32
+	//BufID is the ID of the VBO
+	BufID uint32
+	//IndexBufID is the ID of the index/element buffer
+	IndexBufID uint32
+	// IndexBufCount int32
+	Stride int32
+
+	layout []Element
+}
+
+func (b *Buffer) Bind() {
+	gl.BindVertexArray(b.VAOID)
+}
+
+func (b *Buffer) UnBind() {
+	gl.BindVertexArray(0)
+}
+
+func (b *Buffer) SetData(values []float32) {
+
+	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), 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)
+}
+
+func (b *Buffer) SetIndexBufData(values []uint32) {
+
+	// b.IndexBufCount = int32(len(values))
+	gl.BindVertexArray(b.VAOID)
+	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, b.IndexBufID)
+
+	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)
+}
+
+func (b *Buffer) GetLayout() []Element {
+	e := make([]Element, len(b.layout))
+	copy(e, b.layout)
+	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
+
+	b.Stride = 0
+	for i := 0; i < len(b.layout); i++ {
+
+		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 {
+
+	b := Buffer{}
+	gl.GenVertexArrays(1, &b.VAOID)
+	if b.VAOID == 0 {
+		logging.ErrLog.Println("Failed to create openGL vertex array object")
+	}
+
+	gl.GenBuffers(1, &b.BufID)
+	if b.BufID == 0 {
+		logging.ErrLog.Println("Failed to create openGL buffer")
+	}
+
+	gl.GenBuffers(1, &b.IndexBufID)
+	if b.IndexBufID == 0 {
+		logging.ErrLog.Println("Failed to create openGL buffer")
+	}
+
+	b.SetLayout(layout...)
+	return b
+}

buffers/framebuffer.go

@@ -1,403 +0,0 @@
-package buffers
-
-import (
-	"github.com/bloeys/nmage/logging"
-	"github.com/go-gl/gl/v4.1-core/gl"
-)
-
-type FramebufferAttachmentType int32
-
-const (
-	FramebufferAttachmentType_Unknown FramebufferAttachmentType = iota
-	FramebufferAttachmentType_Texture
-	FramebufferAttachmentType_Renderbuffer
-)
-
-func (f FramebufferAttachmentType) IsValid() bool {
-
-	switch f {
-	case FramebufferAttachmentType_Texture:
-		fallthrough
-	case FramebufferAttachmentType_Renderbuffer:
-		return true
-
-	default:
-		return false
-	}
-}
-
-type FramebufferAttachmentDataFormat int32
-
-const (
-	FramebufferAttachmentDataFormat_Unknown FramebufferAttachmentDataFormat = iota
-	FramebufferAttachmentDataFormat_R32Int
-	FramebufferAttachmentDataFormat_RGBA8
-	FramebufferAttachmentDataFormat_SRGBA
-	FramebufferAttachmentDataFormat_DepthF32
-	FramebufferAttachmentDataFormat_Depth24Stencil8
-)
-
-func (f FramebufferAttachmentDataFormat) IsColorFormat() bool {
-	return f == FramebufferAttachmentDataFormat_R32Int ||
-		f == FramebufferAttachmentDataFormat_RGBA8 ||
-		f == FramebufferAttachmentDataFormat_SRGBA
-}
-
-func (f FramebufferAttachmentDataFormat) IsDepthFormat() bool {
-	return f == FramebufferAttachmentDataFormat_Depth24Stencil8 ||
-		f == FramebufferAttachmentDataFormat_DepthF32
-}
-
-func (f FramebufferAttachmentDataFormat) GlInternalFormat() int32 {
-
-	switch f {
-	case FramebufferAttachmentDataFormat_R32Int:
-		return gl.R32I
-	case FramebufferAttachmentDataFormat_RGBA8:
-		return gl.RGB8
-	case FramebufferAttachmentDataFormat_SRGBA:
-		return gl.SRGB_ALPHA
-	case FramebufferAttachmentDataFormat_DepthF32:
-		return gl.DEPTH_COMPONENT
-	case FramebufferAttachmentDataFormat_Depth24Stencil8:
-		return gl.DEPTH24_STENCIL8
-	default:
-		logging.ErrLog.Fatalf("unknown framebuffer attachment data format. Format=%d\n", f)
-		return 0
-	}
-}
-
-func (f FramebufferAttachmentDataFormat) GlFormat() uint32 {
-
-	switch f {
-	case FramebufferAttachmentDataFormat_R32Int:
-		return gl.RED_INTEGER
-
-	case FramebufferAttachmentDataFormat_RGBA8:
-		fallthrough
-	case FramebufferAttachmentDataFormat_SRGBA:
-		return gl.RGBA
-
-	case FramebufferAttachmentDataFormat_DepthF32:
-		return gl.DEPTH_COMPONENT
-
-	case FramebufferAttachmentDataFormat_Depth24Stencil8:
-		return gl.DEPTH_STENCIL
-
-	default:
-		logging.ErrLog.Fatalf("unknown framebuffer attachment data format. Format=%d\n", f)
-		return 0
-	}
-}
-
-type FramebufferAttachment struct {
-	Id     uint32
-	Type   FramebufferAttachmentType
-	Format FramebufferAttachmentDataFormat
-}
-
-type Framebuffer struct {
-	Id                    uint32
-	ClearFlags            uint32
-	Attachments           []FramebufferAttachment
-	ColorAttachmentsCount uint32
-	Width                 uint32
-	Height                uint32
-}
-
-func (fbo *Framebuffer) Bind() {
-	gl.BindFramebuffer(gl.FRAMEBUFFER, fbo.Id)
-}
-
-func (fbo *Framebuffer) BindWithViewport() {
-	gl.BindFramebuffer(gl.FRAMEBUFFER, fbo.Id)
-	gl.Viewport(0, 0, int32(fbo.Width), int32(fbo.Height))
-}
-
-// Clear calls gl.Clear with the fob's clear flags.
-// Note that the fbo must be complete and bound.
-// Calling this without a bound fbo will clear something else, like your screen.
-func (fbo *Framebuffer) Clear() {
-	gl.Clear(fbo.ClearFlags)
-}
-
-func (fbo *Framebuffer) UnBind() {
-	gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
-}
-
-func (fbo *Framebuffer) UnBindWithViewport(width, height uint32) {
-	gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
-	gl.Viewport(0, 0, int32(width), int32(height))
-}
-
-// IsComplete returns true if OpenGL reports that the fbo is complete/usable.
-// Note that this function binds and then unbinds the fbo
-func (fbo *Framebuffer) IsComplete() bool {
-	fbo.Bind()
-	isComplete := gl.CheckFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE
-	fbo.UnBind()
-	return isComplete
-}
-
-func (fbo *Framebuffer) HasColorAttachment() bool {
-	return fbo.ColorAttachmentsCount > 0
-}
-
-func (fbo *Framebuffer) HasDepthAttachment() bool {
-
-	for i := 0; i < len(fbo.Attachments); i++ {
-
-		a := &fbo.Attachments[i]
-		if a.Format.IsDepthFormat() {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (fbo *Framebuffer) NewColorAttachment(
-	attachType FramebufferAttachmentType,
-	attachFormat FramebufferAttachmentDataFormat,
-) {
-
-	if fbo.ColorAttachmentsCount == 8 {
-		logging.ErrLog.Fatalf("failed creating color attachment for framebuffer due it already having %d attached\n", fbo.ColorAttachmentsCount)
-	}
-
-	if !attachType.IsValid() {
-		logging.ErrLog.Fatalf("failed creating color attachment for framebuffer due to unknown attachment type. Type=%d\n", attachType)
-	}
-
-	if !attachFormat.IsColorFormat() {
-		logging.ErrLog.Fatalf("failed creating color attachment for framebuffer due to attachment data format not being a valid color type. Data format=%d\n", attachFormat)
-	}
-
-	a := FramebufferAttachment{
-		Type:   attachType,
-		Format: attachFormat,
-	}
-
-	fbo.Bind()
-
-	if attachType == FramebufferAttachmentType_Texture {
-
-		// Create texture
-		gl.GenTextures(1, &a.Id)
-		if a.Id == 0 {
-			logging.ErrLog.Fatalf("failed to generate texture for framebuffer. GlError=%d\n", gl.GetError())
-		}
-
-		gl.BindTexture(gl.TEXTURE_2D, a.Id)
-		gl.TexImage2D(gl.TEXTURE_2D, 0, attachFormat.GlInternalFormat(), int32(fbo.Width), int32(fbo.Height), 0, attachFormat.GlFormat(), gl.UNSIGNED_BYTE, nil)
-
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
-		gl.BindTexture(gl.TEXTURE_2D, 0)
-
-		// Attach to fbo
-		gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0+fbo.ColorAttachmentsCount, gl.TEXTURE_2D, a.Id, 0)
-
-	} else if attachType == FramebufferAttachmentType_Renderbuffer {
-
-		// Create rbo
-		gl.GenRenderbuffers(1, &a.Id)
-		if a.Id == 0 {
-			logging.ErrLog.Fatalf("failed to generate render buffer for framebuffer. GlError=%d\n", gl.GetError())
-		}
-
-		gl.BindRenderbuffer(gl.RENDERBUFFER, a.Id)
-		gl.RenderbufferStorage(gl.RENDERBUFFER, uint32(attachFormat.GlInternalFormat()), int32(fbo.Width), int32(fbo.Height))
-		gl.BindRenderbuffer(gl.RENDERBUFFER, 0)
-
-		// Attach to fbo
-		gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0+fbo.ColorAttachmentsCount, gl.RENDERBUFFER, a.Id)
-	}
-
-	fbo.UnBind()
-	fbo.ColorAttachmentsCount++
-	fbo.ClearFlags |= gl.COLOR_BUFFER_BIT
-	fbo.Attachments = append(fbo.Attachments, a)
-}
-
-// SetNoColorBuffer sets the read and draw buffers of this fbo to 'NONE',
-// which tells the graphics driver that we don't want a color buffer for this fbo.
-//
-// This is required because normally an fbo must have a color buffer to be considered complete, but by
-// doing this we get marked as complete even without one.
-//
-// Usually used when you only care about some other buffer, like a depth buffer.
-func (fbo *Framebuffer) SetNoColorBuffer() {
-
-	if fbo.HasColorAttachment() {
-		logging.ErrLog.Fatalf("failed SetNoColorBuffer because framebuffer already has a color attachment\n")
-	}
-
-	fbo.Bind()
-	gl.DrawBuffer(gl.NONE)
-	gl.ReadBuffer(gl.NONE)
-	fbo.UnBind()
-}
-
-func (fbo *Framebuffer) NewDepthAttachment(
-	attachType FramebufferAttachmentType,
-	attachFormat FramebufferAttachmentDataFormat,
-) {
-
-	if fbo.HasDepthAttachment() {
-		logging.ErrLog.Fatalf("failed creating depth attachment for framebuffer because a depth attachment already exists\n")
-	}
-
-	if !attachType.IsValid() {
-		logging.ErrLog.Fatalf("failed creating depth attachment for framebuffer due to unknown attachment type. Type=%d\n", attachType)
-	}
-
-	if !attachFormat.IsDepthFormat() {
-		logging.ErrLog.Fatalf("failed creating depth attachment for framebuffer due to attachment data format not being a valid depth-stencil type. Data format=%d\n", attachFormat)
-	}
-
-	a := FramebufferAttachment{
-		Type:   attachType,
-		Format: attachFormat,
-	}
-
-	fbo.Bind()
-
-	if attachType == FramebufferAttachmentType_Texture {
-
-		// Create texture
-		gl.GenTextures(1, &a.Id)
-		if a.Id == 0 {
-			logging.ErrLog.Fatalf("failed to generate texture for framebuffer. GlError=%d\n", gl.GetError())
-		}
-
-		gl.BindTexture(gl.TEXTURE_2D, a.Id)
-		gl.TexImage2D(gl.TEXTURE_2D, 0, attachFormat.GlInternalFormat(), int32(fbo.Width), int32(fbo.Height), 0, attachFormat.GlFormat(), gl.FLOAT, nil)
-
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
-
-		// This is so that any sampling outside the depth map gives a full depth value.
-		// Useful for example when doing shadow maps where we want things outside
-		// the range of the texture to not show shadow
-		borderColor := []float32{1, 1, 1, 1}
-		gl.TexParameterfv(gl.TEXTURE_2D, gl.TEXTURE_BORDER_COLOR, &borderColor[0])
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_BORDER)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_BORDER)
-
-		gl.BindTexture(gl.TEXTURE_2D, 0)
-
-		// Attach to fbo
-		gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, a.Id, 0)
-
-	} else if attachType == FramebufferAttachmentType_Renderbuffer {
-
-		// Create rbo
-		gl.GenRenderbuffers(1, &a.Id)
-		if a.Id == 0 {
-			logging.ErrLog.Fatalf("failed to generate render buffer for framebuffer. GlError=%d\n", gl.GetError())
-		}
-
-		gl.BindRenderbuffer(gl.RENDERBUFFER, a.Id)
-		gl.RenderbufferStorage(gl.RENDERBUFFER, uint32(attachFormat.GlInternalFormat()), int32(fbo.Width), int32(fbo.Height))
-		gl.BindRenderbuffer(gl.RENDERBUFFER, 0)
-
-		// Attach to fbo
-		gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, a.Id)
-	}
-
-	fbo.UnBind()
-	fbo.ClearFlags |= gl.DEPTH_BUFFER_BIT
-	fbo.Attachments = append(fbo.Attachments, a)
-}
-
-func (fbo *Framebuffer) NewDepthStencilAttachment(
-	attachType FramebufferAttachmentType,
-	attachFormat FramebufferAttachmentDataFormat,
-) {
-
-	if fbo.HasDepthAttachment() {
-		logging.ErrLog.Fatalf("failed creating depth-stencil attachment for framebuffer because a depth-stencil attachment already exists\n")
-	}
-
-	if !attachType.IsValid() {
-		logging.ErrLog.Fatalf("failed creating depth-stencil attachment for framebuffer due to unknown attachment type. Type=%d\n", attachType)
-	}
-
-	if !attachFormat.IsDepthFormat() {
-		logging.ErrLog.Fatalf("failed creating depth-stencil attachment for framebuffer due to attachment data format not being a valid depth-stencil type. Data format=%d\n", attachFormat)
-	}
-
-	a := FramebufferAttachment{
-		Type:   attachType,
-		Format: attachFormat,
-	}
-
-	fbo.Bind()
-
-	if attachType == FramebufferAttachmentType_Texture {
-
-		// Create texture
-		gl.GenTextures(1, &a.Id)
-		if a.Id == 0 {
-			logging.ErrLog.Fatalf("failed to generate texture for framebuffer. GlError=%d\n", gl.GetError())
-		}
-
-		gl.BindTexture(gl.TEXTURE_2D, a.Id)
-		gl.TexImage2D(gl.TEXTURE_2D, 0, attachFormat.GlInternalFormat(), int32(fbo.Width), int32(fbo.Height), 0, attachFormat.GlFormat(), gl.UNSIGNED_INT_24_8, nil)
-
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
-		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
-		gl.BindTexture(gl.TEXTURE_2D, 0)
-
-		// Attach to fbo
-		gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.TEXTURE_2D, a.Id, 0)
-
-	} else if attachType == FramebufferAttachmentType_Renderbuffer {
-
-		// Create rbo
-		gl.GenRenderbuffers(1, &a.Id)
-		if a.Id == 0 {
-			logging.ErrLog.Fatalf("failed to generate render buffer for framebuffer. GlError=%d\n", gl.GetError())
-		}
-
-		gl.BindRenderbuffer(gl.RENDERBUFFER, a.Id)
-		gl.RenderbufferStorage(gl.RENDERBUFFER, uint32(attachFormat.GlInternalFormat()), int32(fbo.Width), int32(fbo.Height))
-		gl.BindRenderbuffer(gl.RENDERBUFFER, 0)
-
-		// Attach to fbo
-		gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, a.Id)
-	}
-
-	fbo.UnBind()
-	fbo.ClearFlags |= gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
-	fbo.Attachments = append(fbo.Attachments, a)
-}
-
-func (fbo *Framebuffer) Delete() {
-
-	if fbo.Id == 0 {
-		return
-	}
-
-	gl.DeleteFramebuffers(1, &fbo.Id)
-	fbo.Id = 0
-}
-
-func NewFramebuffer(width, height uint32) Framebuffer {
-
-	// It is allowed to have attachments of differnt sizes in one FBO,
-	// but that complicates things (e.g. which size to use for gl.viewport) and I don't see much use
-	// for it now, so we will have all attachments share size
-	fbo := Framebuffer{
-		Width:  width,
-		Height: height,
-	}
-
-	gl.GenFramebuffers(1, &fbo.Id)
-	if fbo.Id == 0 {
-		logging.ErrLog.Fatalf("failed to generate framebuffer. GlError=%d\n", gl.GetError())
-	}
-
-	return fbo
-}

buffers/index_buffer.go

@@ -1,46 +0,0 @@
-package buffers
-
-import (
-	"github.com/bloeys/nmage/logging"
-	"github.com/go-gl/gl/v4.1-core/gl"
-)
-
-type IndexBuffer struct {
-	Id uint32
-	// IndexBufCount is the number of elements in the index buffer. Updated in IndexBuffer.SetData
-	IndexBufCount int32
-}
-
-func (ib *IndexBuffer) Bind() {
-	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ib.Id)
-}
-
-func (ib *IndexBuffer) UnBind() {
-	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
-}
-
-func (ib *IndexBuffer) SetData(values []uint32) {
-
-	ib.Bind()
-
-	sizeInBytes := len(values) * 4
-	ib.IndexBufCount = int32(len(values))
-
-	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())
-	}
-}
-
-func NewIndexBuffer() IndexBuffer {
-
-	ib := IndexBuffer{}
-
-	gl.GenBuffers(1, &ib.Id)
-	if ib.Id == 0 {
-		logging.ErrLog.Println("Failed to create OpenGL buffer")
-	}
-
-	return ib
-}

buffers/vertex_array.go

@@ -1,54 +0,0 @@
-package buffers
-
-import (
-	"github.com/bloeys/nmage/logging"
-	"github.com/go-gl/gl/v4.1-core/gl"
-)
-
-type VertexArray struct {
-	Id          uint32
-	Vbos        []VertexBuffer
-	IndexBuffer IndexBuffer
-}
-
-func (va *VertexArray) Bind() {
-	gl.BindVertexArray(va.Id)
-}
-
-func (va *VertexArray) UnBind() {
-	gl.BindVertexArray(0)
-}
-
-func (va *VertexArray) AddVertexBuffer(vbo VertexBuffer) {
-
-	// NOTE: VBOs are only bound at 'VertexAttribPointer' (and related) calls
-
-	va.Bind()
-	vbo.Bind()
-
-	for i := 0; i < len(vbo.layout); i++ {
-
-		l := &vbo.layout[i]
-
-		gl.EnableVertexAttribArray(uint32(i))
-		gl.VertexAttribPointerWithOffset(uint32(i), l.ElementType.CompCount(), l.ElementType.GLType(), false, vbo.Stride, uintptr(l.Offset))
-	}
-}
-
-func (va *VertexArray) SetIndexBuffer(ib IndexBuffer) {
-	va.Bind()
-	ib.Bind()
-	va.IndexBuffer = ib
-}
-
-func NewVertexArray() VertexArray {
-
-	vao := VertexArray{}
-
-	gl.GenVertexArrays(1, &vao.Id)
-	if vao.Id == 0 {
-		logging.ErrLog.Println("Failed to create OpenGL vertex array object")
-	}
-
-	return vao
-}

buffers/vertex_buffer.go

@@ -1,63 +0,0 @@
-package buffers
-
-import (
-	"github.com/bloeys/nmage/logging"
-	"github.com/go-gl/gl/v4.1-core/gl"
-)
-
-type VertexBuffer struct {
-	Id     uint32
-	Stride int32
-	layout []Element
-}
-
-func (vb *VertexBuffer) Bind() {
-	gl.BindBuffer(gl.ARRAY_BUFFER, vb.Id)
-}
-
-func (vb *VertexBuffer) UnBind() {
-	gl.BindBuffer(gl.ARRAY_BUFFER, 0)
-}
-
-func (vb *VertexBuffer) SetData(values []float32, usage BufUsage) {
-
-	vb.Bind()
-
-	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())
-	}
-}
-
-func (vb *VertexBuffer) GetLayout() []Element {
-	e := make([]Element, len(vb.layout))
-	copy(e, vb.layout)
-	return e
-}
-
-func (vb *VertexBuffer) SetLayout(layout ...Element) {
-
-	vb.Stride = 0
-	vb.layout = layout
-
-	for i := 0; i < len(vb.layout); i++ {
-
-		vb.layout[i].Offset = int(vb.Stride)
-		vb.Stride += vb.layout[i].Size()
-	}
-}
-
-func NewVertexBuffer(layout ...Element) VertexBuffer {
-
-	vb := VertexBuffer{}
-
-	gl.GenBuffers(1, &vb.Id)
-	if vb.Id == 0 {
-		logging.ErrLog.Println("Failed to create OpenGL buffer")
-	}
-
-	vb.SetLayout(layout...)
-	return vb
-}

build.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -e
+
+if [[ $# -ne 1 ]]; then
+    echo -e "1) Build Debug mode\n2) Build Release mode"
+    exit 0
+fi
+
+mode=$1
+if [[ $mode -eq 1 ]]; then
+
+    ./switch-physx-mode.sh 1
+    go build .
+    echo "Debug build finished"
+
+elif [[ $mode -eq 2 ]]; then
+
+    ./switch-physx-mode.sh 2
+    go build -tags "nmage_release,physx_release" .
+    echo "Release build finished"
+
+else
+
+    echo "Unknown build option. Please select 1 for a Debug build or 2 for a Release build"
+    exit 1
+
+fi

consts/flags_debug.go

@@ -1,4 +1,4 @@
-//go:build !release
+//go:build !nmage_release
 
 package consts
 

consts/flags_release.go

@@ -1,4 +1,4 @@
-//go:build release
+//go:build nmage_release
 
 package consts
 

engine/engine.go

@@ -3,25 +3,17 @@ 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
-
-	isSdlButtonLeftDown   = false
-	isSdlButtonMiddleDown = false
-	isSdlButtonRightDown  = false
-
-	ImguiRelativeMouseModePosX float32
-	ImguiRelativeMouseModePosY float32
 )
 
 type Window struct {
@@ -34,24 +26,7 @@ type Window struct {
 func (w *Window) handleInputs() {
 
 	input.EventLoopStart()
-	imIo := imgui.CurrentIO()
-
-	imguiCaptureMouse := imIo.WantCaptureMouse()
-	imguiCaptureKeyboard := imIo.WantCaptureKeyboard()
-
-	// These two are to fix a bug where state isn't cleared
-	// even after imgui captures the keyboard/mouse.
-	//
-	// For example, if player is moving due to key held and then imgui captures the keyboard,
-	// the player keeps moving even when the key is no longer pressed because the input system never
-	// receives the key up event.
-	if imguiCaptureMouse {
-		input.ClearMouseState()
-	}
-
-	if imguiCaptureKeyboard {
-		input.ClearKeyboardState()
-	}
+	imIO := imgui.CurrentIO()
 
 	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
 
@@ -65,64 +40,30 @@ func (w *Window) handleInputs() {
 
 		case *sdl.MouseWheelEvent:
 
-			if !imguiCaptureMouse {
-				input.HandleMouseWheelEvent(e)
-			}
+			input.HandleMouseWheelEvent(e)
 
-			imIo.AddMouseWheelDelta(float32(e.X), float32(e.Y))
+			xDelta, yDelta := input.GetMouseWheelMotion()
+			imIO.AddMouseWheelDelta(float32(xDelta), float32(yDelta))
 
 		case *sdl.KeyboardEvent:
+			input.HandleKeyboardEvent(e)
 
-			if !imguiCaptureKeyboard {
-				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)
+			if e.Type == sdl.KEYDOWN {
+				imIO.KeyPress(int(e.Keysym.Scancode))
+			} else if e.Type == sdl.KEYUP {
+				imIO.KeyRelease(int(e.Keysym.Scancode))
 			}
 
 		case *sdl.TextInputEvent:
-			imIo.AddInputCharactersUTF8(e.GetText())
+			imIO.AddInputCharacters(string(e.Text[:]))
 
 		case *sdl.MouseButtonEvent:
-
-			if !imguiCaptureMouse {
-				input.HandleMouseBtnEvent(e)
-			}
-
-			isPressed := e.State == sdl.PRESSED
-
-			if e.Button == sdl.BUTTON_LEFT {
-				isSdlButtonLeftDown = isPressed
-			} else if e.Button == sdl.BUTTON_MIDDLE {
-				isSdlButtonMiddleDown = isPressed
-			} else if e.Button == sdl.BUTTON_RIGHT {
-				isSdlButtonRightDown = isPressed
-			}
+			input.HandleMouseBtnEvent(e)
 
 		case *sdl.MouseMotionEvent:
-
-			if !imguiCaptureMouse {
-				input.HandleMouseMotionEvent(e)
-			}
+			input.HandleMouseMotionEvent(e)
 
 		case *sdl.WindowEvent:
-
 			if e.Event == sdl.WINDOWEVENT_SIZE_CHANGED {
 				w.handleWindowResize()
 			}
@@ -132,17 +73,17 @@ func (w *Window) handleInputs() {
 		}
 	}
 
-	if sdl.GetRelativeMouseMode() {
-		imIo.SetMousePos(imgui.Vec2{X: ImguiRelativeMouseModePosX, Y: ImguiRelativeMouseModePosY})
-	} else {
-		x, y, _ := sdl.GetMouseState()
-		imIo.SetMousePos(imgui.Vec2{X: float32(x), Y: float32(y)})
-	}
-
 	// If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
-	imIo.SetMouseButtonDown(imgui.MouseButtonLeft, isSdlButtonLeftDown)
-	imIo.SetMouseButtonDown(imgui.MouseButtonRight, isSdlButtonRightDown)
-	imIo.SetMouseButtonDown(imgui.MouseButtonMiddle, isSdlButtonMiddleDown)
+	x, y, _ := sdl.GetMouseState()
+	imIO.SetMousePosition(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)
 }
 
 func (w *Window) handleWindowResize() {
@@ -171,7 +112,7 @@ func Init() error {
 
 func initSDL() error {
 
-	err := sdl.Init(sdl.INIT_TIMER | sdl.INIT_VIDEO)
+	err := sdl.Init(sdl.INIT_EVERYTHING)
 	if err != nil {
 		return err
 	}
@@ -181,21 +122,15 @@ func initSDL() error {
 	sdl.GLSetAttribute(sdl.MAJOR_VERSION, 4)
 	sdl.GLSetAttribute(sdl.MINOR_VERSION, 1)
 
+	// R(0-255) G(0-255) B(0-255)
 	sdl.GLSetAttribute(sdl.GL_RED_SIZE, 8)
 	sdl.GLSetAttribute(sdl.GL_GREEN_SIZE, 8)
 	sdl.GLSetAttribute(sdl.GL_BLUE_SIZE, 8)
-	sdl.GLSetAttribute(sdl.GL_ALPHA_SIZE, 8)
 
 	sdl.GLSetAttribute(sdl.GL_DOUBLEBUFFER, 1)
 	sdl.GLSetAttribute(sdl.GL_DEPTH_SIZE, 24)
 	sdl.GLSetAttribute(sdl.GL_STENCIL_SIZE, 8)
 
-	sdl.GLSetAttribute(sdl.GL_FRAMEBUFFER_SRGB_CAPABLE, 1)
-
-	// Allows us to do MSAA
-	sdl.GLSetAttribute(sdl.GL_MULTISAMPLEBUFFERS, 1)
-	sdl.GLSetAttribute(sdl.GL_MULTISAMPLESAMPLES, 4)
-
 	sdl.GLSetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_CORE)
 
 	return nil
@@ -206,12 +141,16 @@ func CreateOpenGLWindow(title string, x, y, width, height int32, flags WindowFla
 }
 
 func CreateOpenGLWindowCentered(title string, width, height int32, flags WindowFlags, rend renderer.Render) (*Window, error) {
-	return createWindow(title, sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, width, height, WindowFlags_OPENGL|flags, rend)
+	return createWindow(title, -1, -1, width, height, WindowFlags_OPENGL|flags, rend)
 }
 
 func createWindow(title string, x, y, width, height int32, flags WindowFlags, rend renderer.Render) (*Window, error) {
 
-	assert.T(isInited, "engine.Init() was not called!")
+	assert.T(isInited, "engine.Init was not called!")
+	if x == -1 && y == -1 {
+		x = sdl.WINDOWPOS_CENTERED
+		y = sdl.WINDOWPOS_CENTERED
+	}
 
 	sdlWin, err := sdl.CreateWindow(title, x, y, width, height, uint32(flags))
 	if err != nil {
@@ -233,6 +172,7 @@ func createWindow(title string, x, y, width, height int32, flags WindowFlags, re
 		return nil, err
 	}
 
+	win.SDLWin.GLSwap()
 	return win, err
 }
 
@@ -243,30 +183,19 @@ func initOpenGL() error {
 	}
 
 	gl.Enable(gl.DEPTH_TEST)
-	gl.Enable(gl.STENCIL_TEST)
 	gl.Enable(gl.CULL_FACE)
 	gl.CullFace(gl.BACK)
 	gl.FrontFace(gl.CCW)
 
 	gl.Enable(gl.BLEND)
-	gl.Enable(gl.MULTISAMPLE)
-	gl.Enable(gl.FRAMEBUFFER_SRGB)
 	gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
 
 	gl.ClearColor(0, 0, 0, 1)
 	return nil
 }
 
-func SetSrgbFramebuffer(isEnabled bool) {
-
-	if isEnabled {
-		gl.Enable(gl.FRAMEBUFFER_SRGB)
-	} else {
-		gl.Disable(gl.FRAMEBUFFER_SRGB)
-	}
-}
-
 func SetVSync(enabled bool) {
+	assert.T(isInited, "engine.Init was not called!")
 
 	if enabled {
 		sdl.GLSetSwapInterval(1)
@@ -274,12 +203,3 @@ func SetVSync(enabled bool) {
 		sdl.GLSetSwapInterval(0)
 	}
 }
-
-func SetMSAA(isEnabled bool) {
-
-	if isEnabled {
-		gl.Enable(gl.MULTISAMPLE)
-	} else {
-		gl.Disable(gl.MULTISAMPLE)
-	}
-}

engine/game.go

@@ -23,26 +23,19 @@ type Game interface {
 func Run(g Game, w *Window, ui nmageimgui.ImguiInfo) {
 
 	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()
 
-	fbWidth, fbHeight := w.SDLWin.GLGetDrawableSize()
-	ui.Render(float32(width), float32(height), fbWidth, fbHeight)
-
-	timing.FrameEnded()
+	//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))
+	ui.Render(float32(tempWidth), float32(tempHeight), tempFBWidth, tempFBHeight)
 
 	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()

entity/base_comp.go

@@ -1,26 +1,27 @@
 package entity
 
-import "github.com/bloeys/nmage/registry"
+import "github.com/bloeys/nmage/assert"
 
 var _ Comp = &BaseComp{}
 
 type BaseComp struct {
-	Handle registry.Handle
+	Entity *Entity
 }
 
-func (b BaseComp) baseComp() {
+func (b *BaseComp) base() {
 }
 
-func (b *BaseComp) Init(parentHandle registry.Handle) {
-	b.Handle = parentHandle
+func (b *BaseComp) Init(parent *Entity) {
+	assert.T(parent != nil, "Component was initialized with a nil parent. That is not allowed.")
+	b.Entity = parent
 }
 
-func (b BaseComp) Name() string {
+func (b *BaseComp) Name() string {
 	return "Base Component"
 }
 
-func (b BaseComp) Update() {
+func (b *BaseComp) Update() {
 }
 
-func (b BaseComp) Destroy() {
+func (b *BaseComp) Destroy() {
 }

entity/comp.go

@@ -1,38 +1,27 @@
 package entity
 
-import (
-	"github.com/bloeys/nmage/assert"
-	"github.com/bloeys/nmage/registry"
-)
+import "github.com/bloeys/nmage/assert"
 
 type Comp interface {
 	// This ensures that implementors of the Comp interface
 	// always embed BaseComp
-	baseComp()
+	base()
 
 	Name() string
-	Init(parentHandle registry.Handle)
+	Init(parent *Entity)
 	Update()
 	Destroy()
 }
 
-func NewCompContainer() CompContainer {
-	return CompContainer{Comps: []Comp{}}
+func AddComp[T Comp](e *Entity, c T) {
+
+	assert.T(!HasComp[T](e), "Entity with id '%v' already has component of type '%T'", e.ID, c)
+
+	e.Comps = append(e.Comps, c)
+	c.Init(e)
 }
 
-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 {
+func HasComp[T Comp](e *Entity) bool {
 
 	for i := 0; i < len(e.Comps); i++ {
 
@@ -45,7 +34,7 @@ func HasComp[T Comp](e *CompContainer) bool {
 	return false
 }
 
-func GetComp[T Comp](e *CompContainer) (out T) {
+func GetComp[T Comp](e *Entity) (out T) {
 
 	for i := 0; i < len(e.Comps); i++ {
 
@@ -59,7 +48,7 @@ func GetComp[T Comp](e *CompContainer) (out T) {
 }
 
 // DestroyComp calls Destroy on the component and then removes it from the entities component list
-func DestroyComp[T Comp](e *CompContainer) {
+func DestroyComp[T Comp](e *Entity) {
 
 	for i := 0; i < len(e.Comps); i++ {
 

entity/entity.go

@@ -1,7 +1,49 @@
 package entity
 
-import "github.com/bloeys/nmage/registry"
+type EntityFlag byte
 
-type Entity interface {
-	GetHandle() registry.Handle
+const (
+	EntityFlag_None  EntityFlag = 0
+	EntityFlag_Alive EntityFlag = 1 << (iota - 1)
+)
+
+const (
+	GenerationShiftBits = 64 - 8
+	FlagsShiftBits      = 64 - 16
+	IndexBitMask        = 0x00_00_FFFF_FFFF_FFFF
+)
+
+type EntityHandle uint64
+
+type Entity struct {
+
+	// Byte 1: Generation; Byte 2: Flags; Bytes 3-8: Index
+	ID    EntityHandle
+	Comps []Comp
+}
+
+func (e *Entity) HasFlag(ef EntityFlag) bool {
+	return GetFlags(e.ID)&ef > 0
+}
+
+func (e *Entity) UpdateAllComps() {
+	for i := 0; i < len(e.Comps); i++ {
+		e.Comps[i].Update()
+	}
+}
+
+func GetGeneration(id EntityHandle) byte {
+	return byte(id >> GenerationShiftBits)
+}
+
+func GetFlags(id EntityHandle) EntityFlag {
+	return EntityFlag(id >> FlagsShiftBits)
+}
+
+func GetIndex(id EntityHandle) uint64 {
+	return uint64(id & IndexBitMask)
+}
+
+func NewEntityId(generation byte, flags EntityFlag, index uint64) EntityHandle {
+	return EntityHandle(index | (uint64(generation) << GenerationShiftBits) | (uint64(flags) << FlagsShiftBits))
 }

entity/registry.go

@@ -0,0 +1,109 @@
+package entity
+
+import (
+	"github.com/bloeys/nmage/assert"
+)
+
+var (
+	// The number of slots required to be in the free list before the free list
+	// is used for creating new entries
+	FreeListUsageThreshold uint32 = 20
+)
+
+type freeListitem struct {
+	EntityIndex uint64
+	nextFree    *freeListitem
+}
+
+type Registry struct {
+	EntityCount uint64
+	Entities    []Entity
+
+	FreeList     *freeListitem
+	FreeListSize uint32
+}
+
+func (r *Registry) NewEntity() *Entity {
+
+	assert.T(r.EntityCount < uint64(len(r.Entities)), "Can not add more entities to registry because it is full")
+
+	entityToUseIndex := uint64(0)
+	var entityToUse *Entity = nil
+
+	if r.FreeList != nil && r.FreeListSize > FreeListUsageThreshold {
+
+		entityToUseIndex = r.FreeList.EntityIndex
+		entityToUse = &r.Entities[entityToUseIndex]
+		r.FreeList = r.FreeList.nextFree
+		r.FreeListSize--
+	} else {
+
+		for i := 0; i < len(r.Entities); i++ {
+
+			e := &r.Entities[i]
+			if e.HasFlag(EntityFlag_Alive) {
+				continue
+			}
+
+			entityToUse = e
+			entityToUseIndex = uint64(i)
+			break
+		}
+	}
+
+	if entityToUse == nil {
+		panic("failed to create new entity because we did not find a free spot in the registry. Why did the assert not go off?")
+	}
+
+	r.EntityCount++
+	entityToUse.ID = NewEntityId(GetGeneration(entityToUse.ID)+1, EntityFlag_Alive, entityToUseIndex)
+	assert.T(entityToUse.ID != 0, "Entity ID must not be zero")
+	return entityToUse
+}
+
+func (r *Registry) GetEntity(id EntityHandle) *Entity {
+
+	index := GetIndex(id)
+	gen := GetGeneration(id)
+
+	e := &r.Entities[index]
+	eGen := GetGeneration(e.ID)
+
+	if gen != eGen {
+		return nil
+	}
+
+	return e
+}
+
+// FreeEntity calls Destroy on all the entities components, resets the component list, resets the entity flags, then ads this entity to the free list
+func (r *Registry) FreeEntity(id EntityHandle) {
+
+	e := r.GetEntity(id)
+	if e == nil {
+		return
+	}
+
+	for i := 0; i < len(e.Comps); i++ {
+		e.Comps[i].Destroy()
+	}
+
+	r.EntityCount--
+	eIndex := GetIndex(e.ID)
+
+	e.Comps = []Comp{}
+	e.ID = NewEntityId(GetGeneration(e.ID), EntityFlag_None, eIndex)
+
+	r.FreeList = &freeListitem{
+		EntityIndex: eIndex,
+		nextFree:    r.FreeList,
+	}
+	r.FreeListSize++
+}
+
+func NewRegistry(size uint32) *Registry {
+	assert.T(size > 0, "Registry size must be more than zero")
+	return &Registry{
+		Entities: make([]Entity, size),
+	}
+}

go.mod

@@ -1,19 +1,16 @@
 module github.com/bloeys/nmage
 
-go 1.22
+go 1.18
 
-require github.com/veandco/go-sdl2 v0.4.35
+require github.com/veandco/go-sdl2 v0.4.25
 
 require github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6
 
 require (
 	github.com/bloeys/assimp-go v0.4.4
 	github.com/bloeys/gglm v0.43.0
+	github.com/bloeys/physx-go v0.2.0
+	github.com/inkyblackness/imgui-go/v4 v4.6.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
+// replace github.com/bloeys/physx-go => ../physx-go

go.sum

@@ -1,40 +1,19 @@
-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/bloeys/physx-go v0.2.0 h1:zsjskoPFlH7m8hKnlCsJ4hVKe8ys2s1fLEhcNDfofS4=
+github.com/bloeys/physx-go v0.2.0/go.mod h1:YNt5tX4T8d/4RdldvpWc77DeHM4jqlIunUQUi/rqSKA=
+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-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=
+github.com/inkyblackness/imgui-go/v4 v4.6.0 h1:ShcnXEYl80+xREGBY9OpGWePA6FfJChY9Varsm+3jjE=
+github.com/inkyblackness/imgui-go/v4 v4.6.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.25 h1:J5ac3KKOccp/0xGJA1PaNYKPUcZm19IxhDGs8lJofPI=
+github.com/veandco/go-sdl2 v0.4.25/go.mod h1:OROqMhHD43nT4/i9crJukyVecjPNYYuCofep6SNiAjY=

input/input.go

@@ -31,8 +31,8 @@ type mouseWheelState struct {
 }
 
 var (
-	keyMap        = make(map[sdl.Keycode]keyState)
-	mouseBtnMap   = make(map[int]mouseBtnState)
+	keyMap        = make(map[sdl.Keycode]*keyState)
+	mouseBtnMap   = make(map[int]*mouseBtnState)
 	mouseMotion   = mouseMotionState{}
 	mouseWheel    = mouseWheelState{}
 	quitRequested bool
@@ -40,17 +40,15 @@ var (
 
 func EventLoopStart() {
 
-	for k, v := range keyMap {
+	for _, v := range keyMap {
 		v.IsPressedThisFrame = false
 		v.IsReleasedThisFrame = false
-		keyMap[k] = v
 	}
 
-	for k, v := range mouseBtnMap {
+	for _, v := range mouseBtnMap {
 		v.IsPressedThisFrame = false
 		v.IsReleasedThisFrame = false
 		v.IsDoubleClicked = false
-		mouseBtnMap[k] = v
 	}
 
 	mouseMotion.XDelta = 0
@@ -62,16 +60,6 @@ func EventLoopStart() {
 	quitRequested = false
 }
 
-func ClearKeyboardState() {
-	clear(keyMap)
-}
-
-func ClearMouseState() {
-	clear(mouseBtnMap)
-	mouseMotion = mouseMotionState{}
-	mouseWheel = mouseWheelState{}
-}
-
 func HandleQuitEvent(e *sdl.QuitEvent) {
 	quitRequested = true
 }
@@ -82,31 +70,29 @@ func IsQuitClicked() bool {
 
 func HandleKeyboardEvent(e *sdl.KeyboardEvent) {
 
-	ks, ok := keyMap[e.Keysym.Sym]
-	if !ok {
-		ks = keyState{Key: e.Keysym.Sym}
+	ks := keyMap[e.Keysym.Sym]
+	if ks == nil {
+		ks = &keyState{Key: e.Keysym.Sym}
+		keyMap[ks.Key] = ks
 	}
 
 	ks.State = int(e.State)
 	ks.IsPressedThisFrame = e.State == sdl.PRESSED && e.Repeat == 0
 	ks.IsReleasedThisFrame = e.State == sdl.RELEASED && e.Repeat == 0
-
-	keyMap[ks.Key] = ks
 }
 
 func HandleMouseBtnEvent(e *sdl.MouseButtonEvent) {
 
-	mb, ok := mouseBtnMap[int(e.Button)]
-	if !ok {
-		mb = mouseBtnState{Btn: int(e.Button)}
+	mb := mouseBtnMap[int(e.Button)]
+	if mb == nil {
+		mb = &mouseBtnState{Btn: int(e.Button)}
+		mouseBtnMap[int(e.Button)] = mb
 	}
 
 	mb.State = int(e.State)
 	mb.IsDoubleClicked = e.Clicks == 2 && e.State == sdl.PRESSED
 	mb.IsPressedThisFrame = e.State == sdl.PRESSED
 	mb.IsReleasedThisFrame = e.State == sdl.RELEASED
-
-	mouseBtnMap[int(e.Button)] = mb
 }
 
 func HandleMouseMotionEvent(e *sdl.MouseMotionEvent) {
@@ -123,12 +109,12 @@ func HandleMouseWheelEvent(e *sdl.MouseWheelEvent) {
 	mouseWheel.YDelta = e.Y
 }
 
-// GetMousePos returns the window coordinates of the mouse
+//GetMousePos returns the window coordinates of the mouse
 func GetMousePos() (x, y int32) {
 	return mouseMotion.XPos, mouseMotion.YPos
 }
 
-// GetMouseMotion returns how many pixels were moved last frame
+//GetMouseMotion returns how many pixels were moved last frame
 func GetMouseMotion() (xDelta, yDelta int32) {
 	return mouseMotion.XDelta, mouseMotion.YDelta
 }
@@ -155,7 +141,7 @@ func GetMouseWheelMotion() (xDelta, yDelta int32) {
 	return mouseWheel.XDelta, mouseWheel.YDelta
 }
 
-// GetMouseWheelXNorm returns 1 if mouse wheel xDelta > 0, -1 if xDelta < 0, and 0 otherwise
+//GetMouseWheelXNorm returns 1 if mouse wheel xDelta > 0, -1 if xDelta < 0, and 0 otherwise
 func GetMouseWheelXNorm() int32 {
 
 	if mouseWheel.XDelta > 0 {
@@ -167,7 +153,7 @@ func GetMouseWheelXNorm() int32 {
 	return 0
 }
 
-// returns 1 if mouse wheel yDelta > 0, -1 if yDelta < 0, and 0 otherwise
+//returns 1 if mouse wheel yDelta > 0, -1 if yDelta < 0, and 0 otherwise
 func GetMouseWheelYNorm() int32 {
 
 	if mouseWheel.YDelta > 0 {
@@ -181,8 +167,8 @@ func GetMouseWheelYNorm() int32 {
 
 func KeyClicked(kc sdl.Keycode) bool {
 
-	ks, ok := keyMap[kc]
-	if !ok {
+	ks := keyMap[kc]
+	if ks == nil {
 		return false
 	}
 
@@ -191,8 +177,8 @@ func KeyClicked(kc sdl.Keycode) bool {
 
 func KeyReleased(kc sdl.Keycode) bool {
 
-	ks, ok := keyMap[kc]
-	if !ok {
+	ks := keyMap[kc]
+	if ks == nil {
 		return false
 	}
 
@@ -201,8 +187,8 @@ func KeyReleased(kc sdl.Keycode) bool {
 
 func KeyDown(kc sdl.Keycode) bool {
 
-	ks, ok := keyMap[kc]
-	if !ok {
+	ks := keyMap[kc]
+	if ks == nil {
 		return false
 	}
 
@@ -211,8 +197,8 @@ func KeyDown(kc sdl.Keycode) bool {
 
 func KeyUp(kc sdl.Keycode) bool {
 
-	ks, ok := keyMap[kc]
-	if !ok {
+	ks := keyMap[kc]
+	if ks == nil {
 		return true
 	}
 
@@ -221,8 +207,8 @@ func KeyUp(kc sdl.Keycode) bool {
 
 func MouseClicked(mb int) bool {
 
-	btn, ok := mouseBtnMap[mb]
-	if !ok {
+	btn := mouseBtnMap[mb]
+	if btn == nil {
 		return false
 	}
 
@@ -231,8 +217,8 @@ func MouseClicked(mb int) bool {
 
 func MouseDoubleClicked(mb int) bool {
 
-	btn, ok := mouseBtnMap[mb]
-	if !ok {
+	btn := mouseBtnMap[mb]
+	if btn == nil {
 		return false
 	}
 
@@ -240,8 +226,8 @@ func MouseDoubleClicked(mb int) bool {
 }
 
 func MouseReleased(mb int) bool {
-	btn, ok := mouseBtnMap[mb]
-	if !ok {
+	btn := mouseBtnMap[mb]
+	if btn == nil {
 		return false
 	}
 
@@ -250,8 +236,8 @@ func MouseReleased(mb int) bool {
 
 func MouseDown(mb int) bool {
 
-	btn, ok := mouseBtnMap[mb]
-	if !ok {
+	btn := mouseBtnMap[mb]
+	if btn == nil {
 		return false
 	}
 
@@ -260,8 +246,8 @@ func MouseDown(mb int) bool {
 
 func MouseUp(mb int) bool {
 
-	btn, ok := mouseBtnMap[mb]
-	if !ok {
+	btn := mouseBtnMap[mb]
+	if btn == nil {
 		return true
 	}
 

level/level.go

@@ -2,16 +2,19 @@ package level
 
 import (
 	"github.com/bloeys/nmage/assert"
+	"github.com/bloeys/nmage/entity"
 )
 
 type Level struct {
+	*entity.Registry
 	Name string
 }
 
-func NewLevel(name string) *Level {
+func NewLevel(name string, maxEntities uint32) *Level {
 
 	assert.T(name != "", "Level name can not be empty")
 	return &Level{
-		Name: name,
+		Name:     name,
+		Registry: entity.NewRegistry(maxEntities),
 	}
 }

materials/material.go

@@ -8,77 +8,30 @@ import (
 	"github.com/go-gl/gl/v4.1-core/gl"
 )
 
-type TextureSlot uint32
-
-const (
-	TextureSlot_Diffuse   TextureSlot = 0
-	TextureSlot_Specular  TextureSlot = 1
-	TextureSlot_Normal    TextureSlot = 2
-	TextureSlot_Emission  TextureSlot = 3
-	TextureSlot_Cubemap   TextureSlot = 10
-	TextureSlot_ShadowMap TextureSlot = 11
-)
-
 type Material struct {
 	Name       string
 	ShaderProg shaders.ShaderProgram
 
+	DiffuseTex uint32
+
 	UnifLocs   map[string]int32
 	AttribLocs map[string]int32
-
-	// Phong shading
-	DiffuseTex  uint32
-	SpecularTex uint32
-	NormalTex   uint32
-	EmissionTex uint32
-
-	// Shininess of specular highlights
-	Shininess float32
-
-	// Cubemap
-	CubemapTex uint32
-
-	// Shadowmaps
-	ShadowMap uint32
 }
 
 func (m *Material) Bind() {
 
 	gl.UseProgram(m.ShaderProg.ID)
 
-	if m.DiffuseTex != 0 {
-		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Diffuse))
-		gl.BindTexture(gl.TEXTURE_2D, m.DiffuseTex)
-	}
-
-	if m.SpecularTex != 0 {
-		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Specular))
-		gl.BindTexture(gl.TEXTURE_2D, m.SpecularTex)
-	}
-
-	if m.NormalTex != 0 {
-		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Normal))
-		gl.BindTexture(gl.TEXTURE_2D, m.NormalTex)
-	}
-
-	if m.EmissionTex != 0 {
-		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Emission))
-		gl.BindTexture(gl.TEXTURE_2D, m.EmissionTex)
-	}
-
-	if m.CubemapTex != 0 {
-		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Cubemap))
-		gl.BindTexture(gl.TEXTURE_CUBE_MAP, m.CubemapTex)
-	}
-
-	if m.ShadowMap != 0 {
-		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_ShadowMap))
-		gl.BindTexture(gl.TEXTURE_2D, m.ShadowMap)
-	}
+	gl.ActiveTexture(gl.TEXTURE0)
+	gl.BindTexture(gl.TEXTURE_2D, m.DiffuseTex)
 }
 
 func (m *Material) UnBind() {
 	gl.UseProgram(0)
+
+	//TODO: Should we unbind textures here? Are these two lines needed?
+	// gl.ActiveTexture(gl.TEXTURE0)
+	// gl.BindTexture(gl.TEXTURE_2D, 0)
 }
 
 func (m *Material) GetAttribLoc(attribName string) int32 {
@@ -155,7 +108,7 @@ func NewMaterial(matName, shaderPath string) *Material {
 
 	shdrProg, err := shaders.LoadAndCompileCombinedShader(shaderPath)
 	if err != nil {
-		logging.ErrLog.Fatalf("Failed to create new material '%s'. Err: %s\n", matName, err.Error())
+		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)}
@@ -165,7 +118,7 @@ func NewMaterialSrc(matName string, shaderSrc []byte) *Material {
 
 	shdrProg, err := shaders.LoadAndCompileCombinedShaderSrc(shaderSrc)
 	if err != nil {
-		logging.ErrLog.Fatalf("Failed to create new material '%s'. Err: %s\n", matName, err.Error())
+		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)}

meshes/mesh.go

@@ -2,6 +2,7 @@ package meshes
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/bloeys/assimp-go/asig"
 	"github.com/bloeys/gglm/gglm"
@@ -17,7 +18,7 @@ type SubMesh struct {
 
 type Mesh struct {
 	Name      string
-	Vao       buffers.VertexArray
+	Buf       buffers.Buffer
 	SubMeshes []SubMesh
 }
 
@@ -35,25 +36,21 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (*Mesh,
 
 	mesh := &Mesh{
 		Name:      name,
-		Vao:       buffers.NewVertexArray(),
+		Buf:       buffers.NewBuffer(),
 		SubMeshes: make([]SubMesh, 0, 1),
 	}
 
-	vbo := buffers.NewVertexBuffer()
-	ibo := buffers.NewIndexBuffer()
-
 	// 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)
 
-	// fmt.Printf("\nMesh %s has %d meshe(s) with first mesh having %d vertices\n", name, len(scene.Meshes), len(scene.Meshes[0].Vertices))
-
 	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}}
@@ -62,20 +59,17 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (*Mesh,
 		}
 
 		if i == 0 {
-			vbo.SetLayout(layoutToUse...)
+			mesh.Buf.SetLayout(layoutToUse...)
 		} else {
 
-			// @TODO @NOTE: This requirement is because we are using one VAO+VBO for all
-			// the meshes and so the buffer must have one format.
-			//
-			// If we want to allow different layouts then we can simply create one vbo per layout and put
-			// meshes of the same layout in the same vbo, and we store the index of the vbo the mesh
-			// uses in the submesh struct.
-			firstSubmeshLayout := vbo.GetLayout()
-			assert.T(len(firstSubmeshLayout) == len(layoutToUse), "Vertex layout of submesh '%d' of mesh '%s' at path '%s' does not equal vertex layout of the first submesh. Original layout: %v; This layout: %v", i, name, modelPath, firstSubmeshLayout, layoutToUse)
+			// @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++ {
-				assert.T(firstSubmeshLayout[i].ElementType == layoutToUse[i].ElementType, "Vertex layout of submesh '%d' of mesh '%s' at path '%s' does not equal vertex layout of the first submesh. Original layout: %v; This layout: %v", i, name, modelPath, firstSubmeshLayout, layoutToUse)
+				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))
+				}
 			}
 		}
 
@@ -88,7 +82,7 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (*Mesh,
 		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) / vbo.Stride,
+			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
@@ -99,16 +93,9 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (*Mesh,
 		indexBufData = append(indexBufData, indices...)
 	}
 
-	vbo.SetData(vertexBufData, buffers.BufUsage_Static)
-	ibo.SetData(indexBufData)
-
-	mesh.Vao.AddVertexBuffer(vbo)
-	mesh.Vao.SetIndexBuffer(ibo)
-
-	// This is needed so that if you load meshes one after the other the
-	// following mesh doesn't attach its vbo/ibo to this vao
-	mesh.Vao.UnBind()
-
+	// 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
 }
 
@@ -132,9 +119,9 @@ type arrToInterleave struct {
 
 func (a *arrToInterleave) get(i int) []float32 {
 
-	assert.T(len(a.V2s) == 0 || len(a.V3s) == 0, "One array should be set in arrToInterleave, but multiple arrays are set")
-	assert.T(len(a.V2s) == 0 || len(a.V4s) == 0, "One array should be set in arrToInterleave, but multiple arrays are set")
-	assert.T(len(a.V3s) == 0 || len(a.V4s) == 0, "One array should be set in arrToInterleave, but multiple 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[:]
@@ -186,7 +173,7 @@ func interleave(arrs ...arrToInterleave) []float32 {
 
 func flattenFaces(faces []asig.Face) []uint32 {
 
-	assert.T(len(faces[0].Indices) == 3, "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++ {

physics/physx/physx.go

@@ -0,0 +1,86 @@
+package physx
+
+import (
+	"errors"
+
+	"github.com/bloeys/gglm/gglm"
+	"github.com/bloeys/nmage/logging"
+	"github.com/bloeys/physx-go/pgo"
+)
+
+type PhysX struct {
+	Foundation *pgo.Foundation
+	Physics    *pgo.Physics
+	Scene      *pgo.Scene
+}
+
+type PhysXCreationOptions struct {
+
+	// Good defaults are length=1 (1m sizes), and speed=9.81 (speed of gravity)
+	TypicalObjectLength float32
+	// Good defaults are length=1 (1m sizes), and speed=9.81 (speed of gravity)
+	TypicalObjectSpeed float32
+
+	// If EnableVisualDebugger=true then all VisualDebuggerXYZ variables must be set
+	EnableVisualDebugger bool
+	VisualDebuggerHost   string
+	// Default port is 5425
+	VisualDebuggerPort                 int
+	VisualDebuggerTimeoutMillis        int
+	VisualDebuggerTransmitConstraints  bool
+	VisualDebuggerTransmitContacts     bool
+	VisualDebuggerTransmitSceneQueries bool
+
+	SceneGravity *gglm.Vec3
+	// Number of internal PhysX threads that do work.
+	// If this is zero then all work is done on the thread that calls simulate
+	SceneCPUDispatcherThreads uint32
+	// Gets called when two objects collide
+	SceneContactHandler func(cph pgo.ContactPairHeader)
+}
+
+func NewPhysx(options PhysXCreationOptions) (px *PhysX, err error) {
+
+	if options.EnableVisualDebugger && !pgo.PvdSupported {
+		return nil, errors.New("can not enable PhysX visual debugger (PVD) because physx-go is in release mode. Please build without the 'physx_release' tag")
+	}
+
+	logging.InfoLog.Printf("Initializing PhysX. Worker threads: %d. PVD supported: %v\n", options.SceneCPUDispatcherThreads, pgo.PvdSupported)
+
+	// Setup foundation, pvd, and physics
+	px = &PhysX{}
+	px.Foundation = pgo.CreateFoundation()
+
+	ts := pgo.NewTolerancesScale(options.TypicalObjectLength, options.TypicalObjectSpeed)
+	if options.EnableVisualDebugger {
+
+		pvdTr := pgo.DefaultPvdSocketTransportCreate(options.VisualDebuggerHost, options.VisualDebuggerPort, options.VisualDebuggerTimeoutMillis)
+		pvd := pgo.CreatePvd(px.Foundation)
+		if !pvd.Connect(pvdTr, pgo.PvdInstrumentationFlag_eALL) {
+			return nil, errors.New("failed to connect to PhysX Visual Debugger. Is it running? Did you pass correct visual debugger host/port (default port is 5425)?")
+		}
+
+		px.Physics = pgo.CreatePhysics(px.Foundation, ts, false, pvd)
+
+	} else {
+		px.Physics = pgo.CreatePhysics(px.Foundation, ts, false, nil)
+	}
+
+	// Setup scene
+	sd := pgo.NewSceneDesc(ts)
+	sd.SetGravity(pgo.NewVec3(options.SceneGravity.X(), options.SceneGravity.Y(), options.SceneGravity.Z()))
+	sd.SetCpuDispatcher(pgo.DefaultCpuDispatcherCreate(options.SceneCPUDispatcherThreads, nil).ToCpuDispatcher())
+	sd.SetOnContactCallback(options.SceneContactHandler)
+
+	px.Scene = px.Physics.CreateScene(sd)
+	if options.EnableVisualDebugger {
+
+		scenePvdClient := px.Scene.GetScenePvdClient()
+		scenePvdClient.SetScenePvdFlag(pgo.PvdSceneFlag_eTRANSMIT_CONSTRAINTS, options.VisualDebuggerTransmitConstraints)
+		scenePvdClient.SetScenePvdFlag(pgo.PvdSceneFlag_eTRANSMIT_CONTACTS, options.VisualDebuggerTransmitContacts)
+		scenePvdClient.SetScenePvdFlag(pgo.PvdSceneFlag_eTRANSMIT_SCENEQUERIES, options.VisualDebuggerTransmitSceneQueries)
+		scenePvdClient.Release()
+	}
+
+	return px, nil
+}

registry/iterator.go

@@ -1,73 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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 {
-
-	if id.IsZero() {
-		return nil
-	}
-
-	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

@@ -1,43 +0,0 @@
-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
-
-// IsZero reports whether the handle is in its default 'zero' state.
-// A zero handle is an invalid handle that does NOT point to any entity
-func (h Handle) IsZero() bool {
-	return h == 0
-}
-
-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

@@ -2,7 +2,6 @@ package rend3dgl
 
 import (
 	"github.com/bloeys/gglm/gglm"
-	"github.com/bloeys/nmage/buffers"
 	"github.com/bloeys/nmage/materials"
 	"github.com/bloeys/nmage/meshes"
 	"github.com/bloeys/nmage/renderer"
@@ -12,56 +11,23 @@ import (
 var _ renderer.Render = &Rend3DGL{}
 
 type Rend3DGL struct {
-	BoundVao  *buffers.VertexArray
 	BoundMesh *meshes.Mesh
 	BoundMat  *materials.Material
 }
 
-func (r *Rend3DGL) DrawMesh(mesh *meshes.Mesh, modelMat *gglm.TrMat, mat *materials.Material) {
+func (r3d *Rend3DGL) Draw(mesh *meshes.Mesh, trMat *gglm.TrMat, mat *materials.Material) {
 
-	if mesh != r.BoundMesh {
-		mesh.Vao.Bind()
-		r.BoundMesh = mesh
+	if mesh != r3d.BoundMesh {
+		mesh.Buf.Bind()
+		r3d.BoundMesh = mesh
 	}
 
-	if mat != r.BoundMat {
+	if mat != r3d.BoundMat {
 		mat.Bind()
-		r.BoundMat = mat
+		r3d.BoundMat = mat
 	}
 
-	mat.SetUnifMat4("modelMat", &modelMat.Mat4)
-
-	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 (r *Rend3DGL) DrawVertexArray(mat *materials.Material, vao *buffers.VertexArray, firstElement int32, elementCount int32) {
-
-	if vao != r.BoundVao {
-		vao.Bind()
-		r.BoundVao = vao
-	}
-
-	if mat != r.BoundMat {
-		mat.Bind()
-		r.BoundMat = mat
-	}
-
-	gl.DrawArrays(gl.TRIANGLES, firstElement, elementCount)
-}
-
-func (r *Rend3DGL) DrawCubemap(mesh *meshes.Mesh, mat *materials.Material) {
-
-	if mesh != r.BoundMesh {
-		mesh.Vao.Bind()
-		r.BoundMesh = mesh
-	}
-
-	if mat != r.BoundMat {
-		mat.Bind()
-		r.BoundMat = mat
-	}
+	mat.SetUnifMat4("modelMat", &trMat.Mat4)
 
 	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)

renderer/renderer.go

@@ -2,14 +2,11 @@ package renderer
 
 import (
 	"github.com/bloeys/gglm/gglm"
-	"github.com/bloeys/nmage/buffers"
 	"github.com/bloeys/nmage/materials"
 	"github.com/bloeys/nmage/meshes"
 )
 
 type Render interface {
-	DrawMesh(mesh *meshes.Mesh, trMat *gglm.TrMat, mat *materials.Material)
-	DrawVertexArray(mat *materials.Material, vao *buffers.VertexArray, firstElement int32, count int32)
-	DrawCubemap(mesh *meshes.Mesh, mat *materials.Material)
+	Draw(mesh *meshes.Mesh, trMat *gglm.TrMat, mat *materials.Material)
 	FrameEnd()
 }

res/shaders/debug-depth.glsl

@@ -13,18 +13,17 @@ out vec3 fragPos;
 
 //MVP = Model View Projection
 uniform mat4 modelMat;
-uniform mat4 projViewMat;
+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));
 
-    vec4 modelVert = modelMat * vec4(vertPosIn, 1);
-    fragPos = modelVert.xyz;
-
-    gl_Position = projViewMat * modelVert;
+    gl_Position = projMat * viewMat * modelMat * vec4(vertPosIn, 1.0);
 }
 
 //shader:fragment

res/shaders/depth-map.glsl

@@ -1,21 +0,0 @@
-//shader:vertex
-#version 410
-
-layout(location=0) in vec3 vertPosIn;
-
-uniform mat4 modelMat;
-uniform mat4 projViewMat;
-
-void main()
-{
-    gl_Position = projViewMat * modelMat * vec4(vertPosIn, 1);
-}
-
-//shader:fragment
-#version 410
-
-void main()
-{
-    // This implicitly writes to the depth buffer with no color operations
-    // Equivalent: gl_FragDepth = gl_FragCoord.z;
-}

res/shaders/imgui.glsl

@@ -1,47 +0,0 @@
-//shader:vertex
-#version 410
-
-uniform mat4 ProjMtx;
-
-in vec2 Position;
-in vec2 UV;
-in vec4 Color;
-
-out vec2 Frag_UV;
-out vec4 Frag_Color;
-
-// Imgui doesn't handle srgb correctly, and looks too bright and wrong in srgb buffers (see: https://github.com/ocornut/imgui/issues/578).
-// While not a complete fix (that would require changes in imgui itself), moving incoming srgba colors to linear in the vertex shader helps make things look better.
-vec4 srgba_to_linear(vec4 srgbaColor){
-
-    #define gamma_correction 2.2
-
-    return vec4(
-        pow(srgbaColor.r, gamma_correction),
-        pow(srgbaColor.g, gamma_correction),
-        pow(srgbaColor.b, gamma_correction),
-        srgbaColor.a
-    );
-}
-
-void main()
-{
-    Frag_UV = UV;
-    Frag_Color = srgba_to_linear(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);
-}

res/shaders/screen-quad.glsl

@@ -1,45 +0,0 @@
-//shader:vertex
-#version 410
-
-out vec2 vertUV0;
-
-// Hardcoded vertex positions for a fullscreen quad.
-// Format: vec4(pos.x, pos.y, uv0.x, uv0.y)
-vec4 quadData[6] = vec4[](
-    vec4(-1.0,  1.0, 0.0, 1.0),
-    vec4(-1.0, -1.0, 0.0, 0.0),
-    vec4(1.0, -1.0, 1.0, 0.0),
-    vec4(-1.0,  1.0, 0.0, 1.0),
-    vec4(1.0, -1.0, 1.0, 0.0),
-    vec4(1.0,  1.0, 1.0, 1.0)
-);
-
-uniform vec2 scale = vec2(1, 1);
-uniform vec2 offset = vec2(0, 0);
-
-void main()
-{
-    vec4 vertData = quadData[gl_VertexID];
-
-    vertUV0 = vertData.zw;
-    gl_Position = vec4((vertData.xy * scale) + offset, 0.0, 1.0);
-}
-
-//shader:fragment
-#version 410
-
-struct Material {
-    sampler2D diffuse;
-};
-
-uniform Material material;
-
-in vec2 vertUV0;
-
-out vec4 fragColor;
-
-void main()
-{
-    vec4 diffuseTexColor = texture(material.diffuse, vertUV0);
-    fragColor = vec4(diffuseTexColor.rgb, 1);
-}

res/shaders/simple-unlit.glsl

@@ -1,54 +0,0 @@
-//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 projViewMat;
-
-void main()
-{
-    // @TODO: Calculate this on the CPU and send it as a uniform
-    //
-    // This produces the normal matrix that multiplies with the model normal to produce the
-    // world space normal. Based on 'One last thing' section from: https://learnopengl.com/Lighting/Basic-Lighting
-    vertNormal = mat3(transpose(inverse(modelMat))) * vertNormalIn;
-    
-    vertUV0 = vertUV0In;
-    vertColor = vertColorIn;
-
-    vec4 modelVert = modelMat * vec4(vertPosIn, 1);
-    fragPos = modelVert.xyz;
-    gl_Position = projViewMat * modelVert;
-}
-
-//shader:fragment
-#version 410
-
-struct Material {
-    sampler2D diffuse;
-};
-
-uniform Material material;
-
-in vec3 vertColor;
-in vec3 vertNormal;
-in vec2 vertUV0;
-in vec3 fragPos;
-
-out vec4 fragColor;
-
-void main()
-{
-    vec4 diffuseTexColor = texture(material.diffuse, vertUV0);
-    fragColor = vec4(diffuseTexColor.rgb, 1);
-}

res/shaders/simple.glsl

@@ -10,232 +10,46 @@ out vec3 vertNormal;
 out vec2 vertUV0;
 out vec3 vertColor;
 out vec3 fragPos;
-out vec4 fragPosDirLight;
 
+//MVP = Model View Projection
 uniform mat4 modelMat;
-uniform mat4 projViewMat;
-uniform mat4 dirLightProjViewMat;
+uniform mat4 viewMat;
+uniform mat4 projMat;
 
 void main()
 {
-    // @TODO: Calculate this on the CPU and send it as a uniform
-    //
-    // This produces the normal matrix that multiplies with the model normal to produce the
-    // world space normal. Based on 'One last thing' section from: https://learnopengl.com/Lighting/Basic-Lighting
     vertNormal = mat3(transpose(inverse(modelMat))) * vertNormalIn;
-    
     vertUV0 = vertUV0In;
     vertColor = vertColorIn;
+    fragPos = vec3(modelMat * vec4(vertPosIn, 1.0));
 
-    vec4 modelVert = modelMat * vec4(vertPosIn, 1);
-    fragPos = modelVert.xyz;
-    fragPosDirLight = dirLightProjViewMat * vec4(fragPos, 1);
-
-    gl_Position = projViewMat * modelVert;
+    gl_Position = projMat * viewMat * modelMat * vec4(vertPosIn, 1.0);
 }
 
 //shader:fragment
 #version 410
 
-struct Material {
-    sampler2D diffuse;
-    sampler2D specular;
-    // sampler2D normal;
-    sampler2D emission;
-    float shininess;
-};
+uniform float ambientStrength = 0;
+uniform vec3 ambientLightColor = vec3(1, 1, 1);
 
-uniform Material material;
+uniform vec3 lightPos1;
+uniform vec3 lightColor1;
 
-struct DirLight {
-    vec3 dir;
-    vec3 diffuseColor;
-    vec3 specularColor;
-    sampler2D shadowMap;
-};
-
-uniform DirLight dirLight;
-
-struct PointLight {
-    vec3 pos;
-    vec3 diffuseColor;
-    vec3 specularColor;
-    float constant;
-    float linear;
-    float quadratic;
-};
-
-#define NUM_POINT_LIGHTS 16
-uniform PointLight pointLights[NUM_POINT_LIGHTS];
-
-struct SpotLight {
-    vec3 pos;
-    vec3 dir;
-    vec3 diffuseColor;
-    vec3 specularColor;
-    float innerCutoff;
-    float outerCutoff;
-};
-
-#define NUM_SPOT_LIGHTS 4
-uniform SpotLight spotLights[NUM_SPOT_LIGHTS];
-
-uniform vec3 camPos;
-uniform vec3 ambientColor = vec3(0.2, 0.2, 0.2);
+uniform sampler2D diffTex;
 
 in vec3 vertColor;
 in vec3 vertNormal;
 in vec2 vertUV0;
 in vec3 fragPos;
-in vec4 fragPosDirLight;
 
 out vec4 fragColor;
 
-// Global variables used as cache for lighting calculations
-vec4 diffuseTexColor;
-vec4 specularTexColor;
-vec4 emissionTexColor;
-vec3 normalizedVertNorm;
-vec3 viewDir;
-
-float CalcShadow(sampler2D shadowMap, vec3 lightDir)
-{
-    // Move from clip space to NDC
-    vec3 projCoords = fragPosDirLight.xyz / fragPosDirLight.w;
-
-    // Move from [-1,1] to [0, 1]
-    projCoords = projCoords * 0.5 + 0.5;
-
-    // If sampling outside the depth texture then force 'no shadow'
-    if(projCoords.z > 1)
-        return 0;
-
-    // currentDepth is the fragment depth from the light's perspective
-    float currentDepth = projCoords.z;
-
-    // Bias in the range [0.005, 0.05] depending on the angle, where a higher
-    // angle gives a higher bias, as shadow acne gets worse with angle
-    float bias = max(0.05 * (1 - dot(normalizedVertNorm, lightDir)), 0.005);
-
-    // 'Percentage Close Filtering'. B
-    // Basically get soft shadows by averaging this texel and surrounding ones
-    float shadow = 0;
-    vec2 texelSize = 1 / textureSize(shadowMap, 0);
-    for(int x = -1; x <= 1; ++x)
-    {
-        for(int y = -1; y <= 1; ++y)
-        {
-            float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r; 
-
-            // If our depth is larger than the lights closest depth at the texel we checked (projCoords),
-            // then there is something closer to the light than us, and so we are in shadow
-            shadow += currentDepth - bias > pcfDepth ? 1 : 0;
-        }
-    }
-
-    shadow /= 9;
-
-    return shadow;
-}
-
-vec3 CalcDirLight()
-{
-    vec3 lightDir = normalize(-dirLight.dir);
-
-    // Diffuse
-    float diffuseAmount = max(0.0, dot(normalizedVertNorm, lightDir));
-    vec3 finalDiffuse = diffuseAmount * dirLight.diffuseColor * diffuseTexColor.rgb;
-
-    // Specular
-    vec3 halfwayDir = normalize(lightDir + viewDir);
-    float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
-    vec3 finalSpecular = specularAmount * dirLight.specularColor * specularTexColor.rgb;
-
-    // Shadow
-    float shadow = CalcShadow(dirLight.shadowMap, lightDir);
-
-    return (finalDiffuse + finalSpecular) * (1 - shadow);
-}
-
-vec3 CalcPointLight(PointLight pointLight)
-{
-    // Ignore unset lights
-    if (pointLight.constant == 0){
-        return vec3(0);
-    }
-
-    vec3 lightDir = normalize(pointLight.pos - fragPos);
-
-    // Diffuse
-    float diffuseAmount = max(0.0, dot(normalizedVertNorm, lightDir));
-    vec3 finalDiffuse = diffuseAmount * pointLight.diffuseColor * diffuseTexColor.rgb;
-
-    // Specular
-    vec3 halfwayDir = normalize(lightDir + viewDir);
-    float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
-    vec3 finalSpecular = specularAmount * pointLight.specularColor * specularTexColor.rgb;
-
-    // attenuation
-    float distToLight = length(pointLight.pos - fragPos);
-    float attenuation = 1 / (pointLight.constant + pointLight.linear * distToLight + pointLight.quadratic * (distToLight * distToLight));  
-
-    return (finalDiffuse + finalSpecular) * attenuation;
-}
-
-vec3 CalcSpotLight(SpotLight light)
-{
-    if (light.innerCutoff == 0)
-        return vec3(0);
-
-    vec3 fragToLightDir = normalize(light.pos - fragPos);
-
-    // Spot light cone with full intensity within inner cutoff,
-    // and falloff between inner-outer cutoffs, and zero
-    // light after outer cutoff
-    float theta = dot(fragToLightDir, normalize(-light.dir));
-    float epsilon = (light.innerCutoff - light.outerCutoff);
-    float intensity = clamp((theta - light.outerCutoff) / epsilon, float(0), float(1));
-
-    if (intensity == 0)
-        return vec3(0);
-
-    // Diffuse
-    float diffuseAmount = max(0.0, dot(normalizedVertNorm, fragToLightDir));
-    vec3 finalDiffuse = diffuseAmount * light.diffuseColor * diffuseTexColor.rgb;
-
-    // Specular
-    vec3 halfwayDir = normalize(fragToLightDir + viewDir);
-    float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
-    vec3 finalSpecular = specularAmount * light.specularColor * specularTexColor.rgb;
-
-    return (finalDiffuse + finalSpecular) * intensity;
-}
-
 void main()
 {
-    // Shared values
-    diffuseTexColor = texture(material.diffuse, vertUV0);
-    specularTexColor = texture(material.specular, vertUV0);
-    emissionTexColor = texture(material.emission, vertUV0);
+    vec3 lightDir = normalize(lightPos1 - fragPos);  
+    float diffStrength = max(0.0, dot(normalize(vertNormal), lightDir));
 
-    normalizedVertNorm = normalize(vertNormal);
-    viewDir = normalize(camPos - fragPos);
-
-    // Light contributions
-    vec3 finalColor = CalcDirLight();
-
-    for (int i = 0; i < NUM_POINT_LIGHTS; i++)
-    {
-        finalColor += CalcPointLight(pointLights[i]);
-    }
-
-    for (int i = 0; i < NUM_SPOT_LIGHTS; i++)
-    {
-        finalColor += CalcSpotLight(spotLights[i]);
-    }
-
-    vec3 finalEmission = emissionTexColor.rgb;
-    vec3 finalAmbient = ambientColor * diffuseTexColor.rgb;
-
-    fragColor = vec4(finalColor + finalAmbient + finalEmission, 1);
-}
+    vec3 finalAmbientColor = ambientLightColor * ambientStrength;
+    vec4 texColor = texture(diffTex, vertUV0);
+    fragColor = vec4(texColor.rgb * vertColor * (finalAmbientColor + diffStrength*lightColor1) , texColor.a);
+} 

res/shaders/skybox.glsl

@@ -8,12 +8,13 @@ layout(location=3) in vec3 vertColorIn;
 
 out vec3 vertUV0;
 
-uniform mat4 projViewMat;
+uniform mat4 viewMat;
+uniform mat4 projMat;
 
 void main()
 {
     vertUV0 = vec3(vertPosIn.x, vertPosIn.y, -vertPosIn.z);
-    vec4 pos = projViewMat * vec4(vertPosIn, 1.0);
+    vec4 pos = projMat * viewMat * vec4(vertPosIn, 1.0);
     gl_Position = pos.xyww;
 }
 

switch-physx-mode.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+set -e
+
+if [[ $# -ne 1 ]]; then
+    echo -e "1) Checked mode\n2) Release mode"
+    exit 0
+fi
+
+mode=$1
+physxBinDir="../physx/physx/bin/win.x86_64.vc142.mt"
+physxCBinDir="../physx-c/x64"
+if [[ $mode -eq 1 ]]; then
+
+    physxCheckedBinDir="$physxBinDir/checked"
+    cp "$physxCheckedBinDir/PhysX_64.dll" "$physxCheckedBinDir/PhysXCommon_64.dll" "$physxCheckedBinDir/PhysXFoundation_64.dll" .
+
+    physxCCheckedBinDir="$physxCBinDir/Checked"
+    cp "$physxCCheckedBinDir/physx-c.dll" .
+
+    echo "Switched PhysX to Checked mode"
+
+elif [[ $mode -eq 2 ]]; then
+
+    physxReleaseBinDir="$physxBinDir/release"
+    cp "$physxReleaseBinDir/PhysX_64.dll" "$physxReleaseBinDir/PhysXCommon_64.dll" "$physxReleaseBinDir/PhysXFoundation_64.dll" .
+
+    physxCReleaseBinDir="$physxCBinDir/Release"
+    cp "$physxCReleaseBinDir/physx-c.dll" .
+
+    echo "Switched PhysX to Release mode"
+
+else
+
+    echo "Unknown mode. Please select 1 or 2"
+    exit 1
+
+fi

ui/imgui/imgui.go

@@ -1,30 +1,30 @@
 package nmageimgui
 
 import (
-	imgui "github.com/AllenDang/cimgui-go"
 	"github.com/bloeys/gglm/gglm"
+	"github.com/bloeys/nmage/assert"
 	"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
 	VboID      uint32
 	IndexBufID uint32
-	// This is a pointer so we can send a stable pointer to C code
-	TexID *uint32
+	TexID      uint32
 }
 
 func (i *ImguiInfo) FrameStart(winWidth, winHeight float32) {
 
-	// if err := i.ImCtx.SetCurrent(); err != nil {
-	// 	assert.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 +35,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 {
-	// 	assert.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 +46,7 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 		return
 	}
 
-	drawData := imgui.CurrentDrawData()
+	drawData := imgui.RenderedDrawData()
 	drawData.ScaleClipRects(imgui.Vec2{
 		X: float32(fbWidth) / float32(winWidth),
 		Y: float32(fbHeight) / float32(winHeight),
@@ -68,7 +68,7 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 	i.Mat.Bind()
 	i.Mat.SetUnifInt32("Texture", 0)
 
-	// @PERF: only update the ortho matrix on window resize
+	//PERF: only update the ortho matrix on window resize
 	orthoMat := gglm.Ortho(0, float32(winWidth), 0, float32(winHeight), 0, 20)
 	i.Mat.SetUnifMat4("ProjMtx", &orthoMat.Mat4)
 	gl.BindSampler(0, 0) // Rely on combined texture/sampler state.
@@ -96,11 +96,11 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 	// Draw
 	for _, list := range drawData.CommandLists() {
 
-		vertexBuffer, vertexBufferSize := list.GetVertexBuffer()
+		vertexBuffer, vertexBufferSize := list.VertexBuffer()
 		gl.BindBuffer(gl.ARRAY_BUFFER, i.VboID)
 		gl.BufferData(gl.ARRAY_BUFFER, vertexBufferSize, vertexBuffer, gl.STREAM_DRAW)
 
-		indexBuffer, indexBufferSize := list.GetIndexBuffer()
+		indexBuffer, indexBufferSize := list.IndexBuffer()
 		gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, i.IndexBufID)
 		gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, indexBufferSize, indexBuffer, gl.STREAM_DRAW)
 
@@ -109,12 +109,11 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 				cmd.CallUserCallback(list)
 			} else {
 
-				gl.ActiveTexture(gl.TEXTURE0)
-				gl.BindTexture(gl.TEXTURE_2D, *i.TexID)
+				gl.BindTexture(gl.TEXTURE_2D, i.TexID)
 				clipRect := cmd.ClipRect()
 				gl.Scissor(int32(clipRect.X), int32(fbHeight)-int32(clipRect.W), int32(clipRect.Z-clipRect.X), int32(clipRect.W-clipRect.Y))
 
-				gl.DrawElementsBaseVertexWithOffset(gl.TRIANGLES, int32(cmd.ElemCount()), uint32(drawType), uintptr(int(cmd.IdxOffset())*indexSize), int32(cmd.VtxOffset()))
+				gl.DrawElementsBaseVertex(gl.TRIANGLES, int32(cmd.ElementCount()), uint32(drawType), gl.PtrOffset(cmd.IndexOffset()*indexSize), int32(cmd.VertexOffset()))
 			}
 		}
 	}
@@ -125,14 +124,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.GlyphRange) imgui.Font {
+func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *imgui.FontConfig, glyphRanges *imgui.GlyphRanges) imgui.Font {
 
-	fontConfigToUse := imgui.NewFontConfig()
+	fontConfigToUse := imgui.DefaultFontConfig
 	if fontConfig != nil {
 		fontConfigToUse = *fontConfig
 	}
 
-	glyphRangesToUse := imgui.NewGlyphRange()
+	glyphRangesToUse := imgui.EmptyGlyphRanges
 	if glyphRanges != nil {
 		glyphRangesToUse = *glyphRanges
 	}
@@ -140,17 +139,16 @@ func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *im
 	imIO := imgui.CurrentIO()
 
 	a := imIO.Fonts()
-	f := a.AddFontFromFileTTFV(fontPath, fontSize, fontConfigToUse, glyphRangesToUse.Data())
-	pixels, width, height, _ := a.GetTextureDataAsAlpha8()
+	f := a.AddFontFromFileTTFV(fontPath, fontSize, fontConfigToUse, glyphRangesToUse)
+	image := a.TextureDataAlpha8()
 
-	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)
+	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)
 
 	return f
 }
 
-const DefaultImguiShader = `
+const imguiShdrSrc = `
 //shader:vertex
 #version 410
 
@@ -163,24 +161,10 @@ in vec4 Color;
 out vec2 Frag_UV;
 out vec4 Frag_Color;
 
-// Imgui doesn't handle srgb correctly, and looks too bright and wrong in srgb buffers (see: https://github.com/ocornut/imgui/issues/578).
-// While not a complete fix (that would require changes in imgui itself), moving incoming srgba colors to linear in the vertex shader helps make things look better.
-vec4 srgba_to_linear(vec4 srgbaColor){
-
-    #define gamma_correction 2.2
-
-    return vec4(
-        pow(srgbaColor.r, gamma_correction),
-        pow(srgbaColor.g, gamma_correction),
-        pow(srgbaColor.b, gamma_correction),
-        srgbaColor.a
-    );
-}
-
 void main()
 {
     Frag_UV = UV;
-    Frag_Color = srgba_to_linear(Color);
+    Frag_Color = Color;
     gl_Position = ProjMtx * vec4(Position.xy, 0, 1);
 }
 
@@ -200,44 +184,32 @@ void main()
 }
 `
 
-// NewImGui setups imgui using the passed shader.
-// If the path is empty a default nMage shader is used
-func NewImGui(shaderPath string) ImguiInfo {
-
-	var imguiMat *materials.Material
-	if shaderPath == "" {
-		imguiMat = materials.NewMaterialSrc("ImGUI Mat", []byte(DefaultImguiShader))
-	} else {
-		imguiMat = materials.NewMaterial("ImGUI Mat", shaderPath)
-	}
+func NewImGUI() ImguiInfo {
 
 	imguiInfo := ImguiInfo{
-		ImCtx: imgui.CreateContext(),
-		Mat:   imguiMat,
-		TexID: new(uint32),
+		ImCtx: imgui.CreateContext(nil),
+		Mat:   materials.NewMaterialSrc("ImGUI Mat", []byte(imguiShdrSrc)),
 	}
 
-	io := imgui.CurrentIO()
-	io.SetConfigFlags(io.ConfigFlags() | imgui.ConfigFlagsDockingEnable)
-	io.SetBackendFlags(io.BackendFlags() | imgui.BackendFlagsRendererHasVtxOffset)
+	imIO := imgui.CurrentIO()
+	imIO.SetBackendFlags(imIO.GetBackendFlags() | imgui.BackendFlagsRendererHasVtxOffset)
 
 	gl.GenVertexArrays(1, &imguiInfo.VaoID)
 	gl.GenBuffers(1, &imguiInfo.VboID)
 	gl.GenBuffers(1, &imguiInfo.IndexBufID)
-	gl.GenTextures(1, imguiInfo.TexID)
+	gl.GenTextures(1, &imguiInfo.TexID)
 
 	// Upload font to gpu
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, *imguiInfo.TexID)
+	gl.BindTexture(gl.TEXTURE_2D, imguiInfo.TexID)
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
 	gl.PixelStorei(gl.UNPACK_ROW_LENGTH, 0)
 
-	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)
+	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)
 
 	// Store our identifier
-	io.Fonts().SetTexID(imgui.TextureID(imguiInfo.TexID))
+	imIO.Fonts().SetTextureID(imgui.TextureID(imguiInfo.TexID))
 
 	//Shader attributes
 	imguiInfo.Mat.Bind()
@@ -246,223 +218,35 @@ func NewImGui(shaderPath string) 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
-	}
-}