After all why not, why shouldn't we have HDR

Default textures for diffuse/specular/normal/emission mat slots
Normal mapping
2025-12-29 05:18:21 +00:00 · 2024-05-12 06:46:46 +04:00 · 2024-05-11 05:11:54 +04:00 · 2024-05-07 05:23:36 +04:00 · 2024-05-06 23:23:52 +04:00 · 2024-05-06 22:55:57 +04:00
20 changed files with 795 additions and 242 deletions
--- a/.gitignore
+++ b/.gitignore
@ -15,4 +15,7 @@
 vendor/
 .vscode/
 imgui.ini
-*~
+*~
+
+# Custom
+*.pprof
--- a/assets/textures.go
+++ b/assets/textures.go
@ -23,6 +23,15 @@ const (
 	ColorFormat_RGBA8
 )

+var (
+	DefaultBlackTexId    Texture
+	DefaultWhiteTexId    Texture
+	DefaultDiffuseTexId  Texture
+	DefaultSpecularTexId Texture
+	DefaultNormalTexId   Texture
+	DefaultEmissionTexId Texture
+)
+
 type Texture struct {
 	// Path only exists for textures loaded from disk
 	Path string
--- a/buffers/framebuffer.go
+++ b/buffers/framebuffer.go
@ -42,6 +42,7 @@ const (
 	FramebufferAttachmentDataFormat_Unknown FramebufferAttachmentDataFormat = iota
 	FramebufferAttachmentDataFormat_R32Int
 	FramebufferAttachmentDataFormat_RGBA8
+	FramebufferAttachmentDataFormat_RGBAF16
 	FramebufferAttachmentDataFormat_SRGBA
 	FramebufferAttachmentDataFormat_DepthF32
 	FramebufferAttachmentDataFormat_Depth24Stencil8
@ -50,7 +51,8 @@ const (
 func (f FramebufferAttachmentDataFormat) IsColorFormat() bool {
 	return f == FramebufferAttachmentDataFormat_R32Int ||
 		f == FramebufferAttachmentDataFormat_RGBA8 ||
-		f == FramebufferAttachmentDataFormat_SRGBA
+		f == FramebufferAttachmentDataFormat_SRGBA ||
+		f == FramebufferAttachmentDataFormat_RGBAF16
 }

 func (f FramebufferAttachmentDataFormat) IsDepthFormat() bool {
@ -65,6 +67,8 @@ func (f FramebufferAttachmentDataFormat) GlInternalFormat() int32 {
 		return gl.R32I
 	case FramebufferAttachmentDataFormat_RGBA8:
 		return gl.RGB8
+	case FramebufferAttachmentDataFormat_RGBAF16:
+		return gl.RGBA16F
 	case FramebufferAttachmentDataFormat_SRGBA:
 		return gl.SRGB_ALPHA
 	case FramebufferAttachmentDataFormat_DepthF32:
@ -85,6 +89,8 @@ func (f FramebufferAttachmentDataFormat) GlFormat() uint32 {

 	case FramebufferAttachmentDataFormat_RGBA8:
 		fallthrough
+	case FramebufferAttachmentDataFormat_RGBAF16:
+		fallthrough
 	case FramebufferAttachmentDataFormat_SRGBA:
 		return gl.RGBA

@ -100,6 +106,33 @@ func (f FramebufferAttachmentDataFormat) GlFormat() uint32 {
 	}
 }

+func (f FramebufferAttachmentDataFormat) GlComponentType() uint32 {
+
+	switch f {
+
+	case FramebufferAttachmentDataFormat_R32Int:
+		return gl.INT
+
+	case FramebufferAttachmentDataFormat_RGBA8:
+		fallthrough
+	case FramebufferAttachmentDataFormat_SRGBA:
+		return gl.UNSIGNED_BYTE
+
+	case FramebufferAttachmentDataFormat_RGBAF16:
+		// Seems this is fine to be float instead of half float
+		fallthrough
+	case FramebufferAttachmentDataFormat_DepthF32:
+		return gl.FLOAT
+
+	case FramebufferAttachmentDataFormat_Depth24Stencil8:
+		return gl.UNSIGNED_INT_24_8
+
+	default:
+		logging.ErrLog.Fatalf("unknown framebuffer attachment data format. Format=%d\n", f)
+		return 0
+	}
+}
+
 type FramebufferAttachment struct {
 	Id     uint32
 	Type   FramebufferAttachmentType
@ -124,7 +157,7 @@ func (fbo *Framebuffer) BindWithViewport() {
 	gl.Viewport(0, 0, int32(fbo.Width), int32(fbo.Height))
 }

-// Clear calls gl.Clear with the fob's clear flags.
+// Clear calls gl.Clear with the fbo'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() {
@ -207,7 +240,17 @@ func (fbo *Framebuffer) NewColorAttachment(
 		}

 		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.TexImage2D(
+			gl.TEXTURE_2D,
+			0,
+			attachFormat.GlInternalFormat(),
+			int32(fbo.Width),
+			int32(fbo.Height),
+			0,
+			attachFormat.GlFormat(),
+			attachFormat.GlComponentType(),
+			nil,
+		)

 		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
 		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
@ -298,7 +341,17 @@ func (fbo *Framebuffer) NewDepthAttachment(
 		}

 		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.TexImage2D(
+			gl.TEXTURE_2D,
+			0,
+			attachFormat.GlInternalFormat(),
+			int32(fbo.Width),
+			int32(fbo.Height),
+			0,
+			attachFormat.GlFormat(),
+			attachFormat.GlComponentType(),
+			nil,
+		)

 		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
 		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
@ -341,7 +394,17 @@ func (fbo *Framebuffer) NewDepthAttachment(

 		gl.BindTexture(gl.TEXTURE_CUBE_MAP, a.Id)
 		for i := 0; i < 6; i++ {
-			gl.TexImage2D(uint32(gl.TEXTURE_CUBE_MAP_POSITIVE_X+i), 0, attachFormat.GlInternalFormat(), int32(fbo.Width), int32(fbo.Height), 0, attachFormat.GlFormat(), gl.FLOAT, nil)
+			gl.TexImage2D(
+				uint32(gl.TEXTURE_CUBE_MAP_POSITIVE_X+i),
+				0,
+				attachFormat.GlInternalFormat(),
+				int32(fbo.Width),
+				int32(fbo.Height),
+				0,
+				attachFormat.GlFormat(),
+				attachFormat.GlComponentType(),
+				nil,
+			)
 		}

 		gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
@ -398,7 +461,7 @@ func (fbo *Framebuffer) NewDepthCubemapArrayAttachment(
 		6*numCubemaps,
 		0,
 		attachFormat.GlFormat(),
-		gl.FLOAT,
+		attachFormat.GlComponentType(),
 		nil,
 	)

@ -455,7 +518,7 @@ func (fbo *Framebuffer) NewDepthTextureArrayAttachment(
 		numTextures,
 		0,
 		attachFormat.GlFormat(),
-		gl.FLOAT,
+		attachFormat.GlComponentType(),
 		nil,
 	)

@ -513,7 +576,17 @@ func (fbo *Framebuffer) NewDepthStencilAttachment(
 		}

 		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.TexImage2D(
+			gl.TEXTURE_2D,
+			0,
+			attachFormat.GlInternalFormat(),
+			int32(fbo.Width),
+			int32(fbo.Height),
+			0,
+			attachFormat.GlFormat(),
+			attachFormat.GlComponentType(),
+			nil,
+		)

 		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
 		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
--- a/camera/camera.go
+++ b/camera/camera.go
@ -41,7 +41,7 @@ func (c *Camera) Update() {
 	c.ViewMat = gglm.LookAtRH(&c.Pos, c.Pos.Clone().Add(&c.Forward), &c.WorldUp).Mat4

 	if c.Type == Type_Perspective {
-		c.ProjMat = *gglm.Perspective(c.Fov, c.AspectRatio, c.NearClip, c.FarClip)
+		c.ProjMat = gglm.Perspective(c.Fov, c.AspectRatio, c.NearClip, c.FarClip)
 	} else {
 		c.ProjMat = gglm.Ortho(c.Left, c.Right, c.Top, c.Bottom, c.NearClip, c.FarClip).Mat4
 	}
--- a/engine/engine.go
+++ b/engine/engine.go
@ -1,10 +1,13 @@
 package engine

 import (
+	"image"
+	"image/color"
 	"runtime"

 	imgui "github.com/AllenDang/cimgui-go"
 	"github.com/bloeys/nmage/assert"
+	"github.com/bloeys/nmage/assets"
 	"github.com/bloeys/nmage/input"
 	"github.com/bloeys/nmage/renderer"
 	"github.com/bloeys/nmage/timing"
@ -202,6 +205,8 @@ func createWindow(title string, x, y, width, height int32, flags WindowFlags, re
 		return win, err
 	}

+	setupDefaultTextures()
+
 	// Get rid of the blinding white startup screen (unfortunately there is still one frame of white)
 	gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
 	win.SDLWin.GLSwap()
@ -231,6 +236,57 @@ func initOpenGL() error {
 	return nil
 }

+func setupDefaultTextures() error {
+
+	// 1x1 black texture
+	defaultBlackImg := image.NewNRGBA(image.Rect(0, 0, 1, 1))
+	defaultBlackImg.Set(0, 0, color.NRGBA{R: 0, G: 0, B: 0, A: 1})
+	defaultBlackImgTex, err := assets.LoadTextureInMemPngImg(defaultBlackImg, &assets.TextureLoadOptions{NoSrgba: true})
+	if err != nil {
+		return err
+	}
+	assets.DefaultBlackTexId = defaultBlackImgTex
+
+	// 1x1 white texture
+	defaultWhiteImg := image.NewNRGBA(image.Rect(0, 0, 1, 1))
+	defaultWhiteImg.Set(0, 0, color.NRGBA{R: 255, G: 255, B: 255, A: 1})
+	defaultWhiteImgTex, err := assets.LoadTextureInMemPngImg(defaultWhiteImg, &assets.TextureLoadOptions{NoSrgba: true})
+	if err != nil {
+		return err
+	}
+	assets.DefaultWhiteTexId = defaultWhiteImgTex
+
+	// Default diffuse
+	assets.DefaultDiffuseTexId = defaultWhiteImgTex
+
+	// Default specular
+	assets.DefaultSpecularTexId = defaultBlackImgTex
+
+	// Default Normal map which is created to be RGB(0.5,0.5,1), which when multiplied by TBN matrix gives the vertex normal.
+	// 128 is better than 127 for normal maps. See 'Flat Color' section here: http://wiki.polycount.com/wiki/Normal_map
+	// Basically, 127 can create seams while 128 looks correct
+	defaultNormalMapImg := image.NewNRGBA(image.Rect(0, 0, 1, 1))
+	defaultNormalMapImg.Set(0, 0, color.NRGBA{R: 128, G: 128, B: 255, A: 1})
+	defaultNormalMapTex, err := assets.LoadTextureInMemPngImg(defaultNormalMapImg, &assets.TextureLoadOptions{NoSrgba: true})
+	if err != nil {
+		return err
+	}
+
+	assets.DefaultNormalTexId = defaultNormalMapTex
+
+	// Default emission
+	assets.DefaultEmissionTexId = defaultBlackImgTex
+
+	assert.T(assets.DefaultBlackTexId.TexID != 0, "The default black texture handle is zero. Either texture wasn't created or handle wasn't updated")
+	assert.T(assets.DefaultWhiteTexId.TexID != 0, "The default white texture handle is zero. Either texture wasn't created or handle wasn't updated")
+	assert.T(assets.DefaultDiffuseTexId.TexID != 0, "The default diffuse texture handle is zero. Either texture wasn't created or handle wasn't updated")
+	assert.T(assets.DefaultSpecularTexId.TexID != 0, "The default specular texture handle is zero. Either texture wasn't created or handle wasn't updated")
+	assert.T(assets.DefaultNormalTexId.TexID != 0, "The default normal texture handle is zero. Either texture wasn't created or handle wasn't updated")
+	assert.T(assets.DefaultEmissionTexId.TexID != 0, "The default emission texture handle is zero. Either texture wasn't created or handle wasn't updated")
+
+	return nil
+}
+
 func SetSrgbFramebuffer(isEnabled bool) {

 	if isEnabled {
--- a/go.mod
+++ b/go.mod
@ -8,7 +8,7 @@ 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/gglm v0.49.0
 )

 require (
--- a/go.sum
+++ b/go.sum
@ -2,8 +2,8 @@ github.com/AllenDang/cimgui-go v0.0.0-20230720025235-f2ff398a66b2 h1:3HA/5qD8Rim
 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/gglm v0.49.0 h1:YtbyHpszYhjnxw7KVV0LaCdBktRMqfGx/i37EMomxsE=
+github.com/bloeys/gglm v0.49.0/go.mod h1:qwJQ0WzV191wAMwlGicbfbChbKoSedMk7gFFX6GnyOk=
 github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6 h1:zDw5v7qm4yH7N8C8uWd+8Ii9rROdgWxQuGoJ9WDXxfk=
 github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw=
 github.com/mandykoh/go-parallel v0.1.0 h1:7vJMNMC4dsbgZdkAb2A8tV5ENY1v7VxIO1wzQWZoT8k=
--- a/main.go
+++ b/main.go
@ -2,7 +2,9 @@ package main

 import (
 	"fmt"
+	"os"
 	"runtime"
+	"runtime/pprof"
 	"strconv"

 	imgui "github.com/AllenDang/cimgui-go"
@ -34,8 +36,10 @@ import (
 		- Point light shadows ✅
 		- Spotlight shadows ✅
 		- Create VAO struct independent from VBO to support multi-VBO use cases (e.g. instancing) ✅
+		- Normals maps ✅
+		- HDR ✅
+		- Fix bad point light acne
 		- UBO support
-		- HDR
 		- Cascaded shadow mapping
 		- Skeletal animations
 	- In some cases we DO want input even when captured by UI. We need two systems within input package, one filtered and one not✅
@ -71,8 +75,9 @@ func (d *DirLight) GetProjViewMat() gglm.Mat4 {
 	nearClip := dirLightNear
 	farClip := dirLightFar

+	up := gglm.NewVec3(0, 1, 0)
 	projMat := gglm.Ortho(-size, size, -size, size, nearClip, farClip).Mat4
-	viewMat := gglm.LookAtRH(pos, pos.Clone().Add(&d.Dir), gglm.NewVec3(0, 1, 0)).Mat4
+	viewMat := gglm.LookAtRH(&pos, pos.Clone().Add(&d.Dir), &up).Mat4

 	return *projMat.Mul(&viewMat)
 }
@ -109,13 +114,34 @@ func (p *PointLight) GetProjViewMats(shadowMapWidth, shadowMapHeight float32) [6
 	aspect := float32(shadowMapWidth) / float32(shadowMapHeight)
 	projMat := gglm.Perspective(90*gglm.Deg2Rad, aspect, pointLightNear, p.FarPlane)

+	targetPos0 := gglm.NewVec3(1+p.Pos.X(), p.Pos.Y(), p.Pos.Z())
+	targetPos1 := gglm.NewVec3(-1+p.Pos.X(), p.Pos.Y(), p.Pos.Z())
+	targetPos2 := gglm.NewVec3(p.Pos.X(), 1+p.Pos.Y(), p.Pos.Z())
+	targetPos3 := gglm.NewVec3(p.Pos.X(), -1+p.Pos.Y(), p.Pos.Z())
+	targetPos4 := gglm.NewVec3(p.Pos.X(), p.Pos.Y(), 1+p.Pos.Z())
+	targetPos5 := gglm.NewVec3(p.Pos.X(), p.Pos.Y(), -1+p.Pos.Z())
+
+	worldUp0 := gglm.NewVec3(0, -1, 0)
+	worldUp1 := gglm.NewVec3(0, -1, 0)
+	worldUp2 := gglm.NewVec3(0, 0, 1)
+	worldUp3 := gglm.NewVec3(0, 0, -1)
+	worldUp4 := gglm.NewVec3(0, -1, 0)
+	worldUp5 := gglm.NewVec3(0, -1, 0)
+
+	lookAt0 := gglm.LookAtRH(&p.Pos, &targetPos0, &worldUp0)
+	lookAt1 := gglm.LookAtRH(&p.Pos, &targetPos1, &worldUp1)
+	lookAt2 := gglm.LookAtRH(&p.Pos, &targetPos2, &worldUp2)
+	lookAt3 := gglm.LookAtRH(&p.Pos, &targetPos3, &worldUp3)
+	lookAt4 := gglm.LookAtRH(&p.Pos, &targetPos4, &worldUp4)
+	lookAt5 := gglm.LookAtRH(&p.Pos, &targetPos5, &worldUp5)
+
 	projViewMats := [6]gglm.Mat4{
-		*projMat.Clone().Mul(&gglm.LookAtRH(&p.Pos, gglm.NewVec3(1, 0, 0).Add(&p.Pos), gglm.NewVec3(0, -1, 0)).Mat4),
-		*projMat.Clone().Mul(&gglm.LookAtRH(&p.Pos, gglm.NewVec3(-1, 0, 0).Add(&p.Pos), gglm.NewVec3(0, -1, 0)).Mat4),
-		*projMat.Clone().Mul(&gglm.LookAtRH(&p.Pos, gglm.NewVec3(0, 1, 0).Add(&p.Pos), gglm.NewVec3(0, 0, 1)).Mat4),
-		*projMat.Clone().Mul(&gglm.LookAtRH(&p.Pos, gglm.NewVec3(0, -1, 0).Add(&p.Pos), gglm.NewVec3(0, 0, -1)).Mat4),
-		*projMat.Clone().Mul(&gglm.LookAtRH(&p.Pos, gglm.NewVec3(0, 0, 1).Add(&p.Pos), gglm.NewVec3(0, -1, 0)).Mat4),
-		*projMat.Clone().Mul(&gglm.LookAtRH(&p.Pos, gglm.NewVec3(0, 0, -1).Add(&p.Pos), gglm.NewVec3(0, -1, 0)).Mat4),
+		*projMat.Clone().Mul(&lookAt0.Mat4),
+		*projMat.Clone().Mul(&lookAt1.Mat4),
+		*projMat.Clone().Mul(&lookAt2.Mat4),
+		*projMat.Clone().Mul(&lookAt3.Mat4),
+		*projMat.Clone().Mul(&lookAt4.Mat4),
+		*projMat.Clone().Mul(&lookAt5.Mat4),
 	}

 	return projViewMats
@ -143,11 +169,11 @@ func (s *SpotLight) GetProjViewMat() gglm.Mat4 {
 	// Adjust up vector if lightDir is parallel or nearly parallel to upVector
 	// as lookat view matrix breaks if up and look at are parallel
 	up := gglm.NewVec3(0, 1, 0)
-	if gglm.Abs32(gglm.DotVec3(&s.Dir, up)) > 0.99 {
+	if gglm.Abs32(gglm.DotVec3(&s.Dir, &up)) > 0.99 {
 		up.SetXY(1, 0)
 	}

-	viewMat := gglm.LookAtRH(&s.Pos, s.Pos.Clone().Add(&s.Dir), up).Mat4
+	viewMat := gglm.LookAtRH(&s.Pos, s.Pos.Clone().Add(&s.Dir), &up).Mat4

 	return *projMat.Mul(&viewMat)
 }
@ -166,6 +192,8 @@ const (

 	unscaledWindowWidth  = 1280
 	unscaledWindowHeight = 720
+
+	PROFILE_CPU = true
 )

 var (
@ -175,12 +203,13 @@ var (
 	yaw   float32 = -1.5
 	cam   camera.Camera

-	// Demo fbo
-	renderToDemoFbo    = false
 	renderToBackBuffer = true
-	demoFboScale       = gglm.NewVec2(0.25, 0.25)
-	demoFboOffset      = gglm.NewVec2(0.75, -0.75)
-	demoFbo            buffers.Framebuffer
+
+	// Demo fbo
+	renderToDemoFbo = false
+	demoFboScale    = gglm.NewVec2(0.25, 0.25)
+	demoFboOffset   = gglm.NewVec2(0.75, -0.75)
+	demoFbo         buffers.Framebuffer

 	// Dir light fbo
 	showDirLightDepthMapFbo   = false
@ -194,12 +223,19 @@ var (
 	// Spot light fbo
 	spotLightDepthMapFbo buffers.Framebuffer

+	// Hdr Fbo
+	hdrRendering                    = true
+	hdrExposure             float32 = 1
+	tonemappedScreenQuadMat materials.Material
+	hdrFbo                  buffers.Framebuffer
+
 	screenQuadVao buffers.VertexArray
 	screenQuadMat materials.Material

 	unlitMat           materials.Material
 	whiteMat           materials.Material
 	containerMat       materials.Material
+	groundMat          materials.Material
 	palleteMat         materials.Material
 	skyboxMat          materials.Material
 	depthMapMat        materials.Material
@ -215,7 +251,7 @@ var (
 	cubeModelMat = gglm.NewTrMatId()

 	renderSkybox      = true
-	renderDepthBuffer bool
+	renderDepthBuffer = false

 	skyboxCmap assets.Cubemap

@ -224,17 +260,18 @@ var (
 	// Light settings
 	ambientColor = gglm.NewVec3(0, 0, 0)

+	dirLightDir = gglm.NewVec3(0, -0.5, -0.8)
 	// Lights
 	dirLight = DirLight{
-		Dir:           *gglm.NewVec3(0, -0.5, -0.8).Normalize(),
-		DiffuseColor:  *gglm.NewVec3(1, 1, 1),
-		SpecularColor: *gglm.NewVec3(1, 1, 1),
+		Dir:           *dirLightDir.Normalize(),
+		DiffuseColor:  gglm.NewVec3(1, 1, 1),
+		SpecularColor: gglm.NewVec3(1, 1, 1),
 	}
 	pointLights = [...]PointLight{
 		{
-			Pos:           *gglm.NewVec3(0, 2, -2),
-			DiffuseColor:  *gglm.NewVec3(1, 0, 0),
-			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Pos:           gglm.NewVec3(0, 2, -2),
+			DiffuseColor:  gglm.NewVec3(1, 0, 0),
+			SpecularColor: gglm.NewVec3(1, 1, 1),
 			// These values are for 50m range
 			Constant:  1.0,
 			Linear:    0.09,
@ -243,45 +280,47 @@ var (
 			FarPlane: 25,
 		},
 		{
-			Pos:           *gglm.NewVec3(0, -5, 0),
-			DiffuseColor:  *gglm.NewVec3(0, 1, 0),
-			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Pos:           gglm.NewVec3(0, -5, 0),
+			DiffuseColor:  gglm.NewVec3(0, 1, 0),
+			SpecularColor: gglm.NewVec3(1, 1, 1),
 			Constant:      1.0,
 			Linear:        0.09,
 			Quadratic:     0.032,
 			FarPlane:      25,
 		},
 		{
-			Pos:           *gglm.NewVec3(5, 0, 0),
-			DiffuseColor:  *gglm.NewVec3(1, 1, 1),
-			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Pos:           gglm.NewVec3(5, 0, 0),
+			DiffuseColor:  gglm.NewVec3(1, 1, 1),
+			SpecularColor: gglm.NewVec3(1, 1, 1),
 			Constant:      1.0,
 			Linear:        0.09,
 			Quadratic:     0.032,
 			FarPlane:      25,
 		},
 		{
-			Pos:           *gglm.NewVec3(-3, 4, 3),
-			DiffuseColor:  *gglm.NewVec3(1, 1, 1),
-			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Pos:           gglm.NewVec3(-3, 4, 3),
+			DiffuseColor:  gglm.NewVec3(1, 1, 1),
+			SpecularColor: gglm.NewVec3(1, 1, 1),
 			Constant:      1.0,
 			Linear:        0.09,
 			Quadratic:     0.032,
 			FarPlane:      25,
 		},
 	}
-	spotLights = [...]SpotLight{
+
+	spotLightDir0 = gglm.NewVec3(1.5, -0.9, 0)
+	spotLights    = [...]SpotLight{
 		{
-			Pos:           *gglm.NewVec3(-4, 7, 5),
-			Dir:           *gglm.NewVec3(1.5, -0.9, 0).Normalize(),
-			DiffuseColor:  *gglm.NewVec3(1, 0, 1),
-			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Pos:           gglm.NewVec3(-4, 7, 5),
+			Dir:           *spotLightDir0.Normalize(),
+			DiffuseColor:  gglm.NewVec3(1, 0, 1),
+			SpecularColor: gglm.NewVec3(1, 1, 1),
 			// These must be cosine values
 			InnerCutoffRad: 15 * gglm.Deg2Rad,
 			OuterCutoffRad: 20 * gglm.Deg2Rad,

-			NearPlane: 1,
-			FarPlane:  30,
+			NearPlane: 2,
+			FarPlane:  50,
 		},
 	}
 )
@ -321,7 +360,36 @@ func main() {
 	}
 	window.EventCallbacks = append(window.EventCallbacks, game.handleWindowEvents)

+	if PROFILE_CPU {
+
+		pf, err := os.Create("cpu.pprof")
+		if err == nil {
+			defer pf.Close()
+			pprof.StartCPUProfile(pf)
+		} else {
+			logging.ErrLog.Printf("Creating cpu.pprof file failed. CPU profiling will not run. Err=%v\n", err)
+		}
+	}
+
 	engine.Run(game, &window, game.ImGUIInfo)
+
+	if PROFILE_CPU {
+		pprof.StopCPUProfile()
+
+		heapProfile, err := os.Create("heap.pprof")
+		if err == nil {
+
+			err = pprof.WriteHeapProfile(heapProfile)
+			if err != nil {
+				logging.ErrLog.Printf("Writing heap profile to heap.pprof failed. Err=%v\n", err)
+			}
+
+			heapProfile.Close()
+
+		} else {
+			logging.ErrLog.Printf("Creating heap.pprof file failed. Err=%v\n", err)
+		}
+	}
 }

 func (g *Game) handleWindowEvents(e sdl.Event) {
@ -380,10 +448,14 @@ func (g *Game) Init() {

 	// Camera
 	winWidth, winHeight := g.Win.SDLWin.GetSize()
+
+	camPos := gglm.NewVec3(0, 0, 10)
+	camForward := gglm.NewVec3(0, 0, -1)
+	camWorldUp := gglm.NewVec3(0, 1, 0)
 	cam = camera.NewPerspective(
-		gglm.NewVec3(0, 0, 10),
-		gglm.NewVec3(0, 0, -1),
-		gglm.NewVec3(0, 1, 0),
+		&camPos,
+		&camForward,
+		&camWorldUp,
 		0.1, 200,
 		45*gglm.Deg2Rad,
 		float32(winWidth)/float32(winHeight),
@ -411,16 +483,6 @@ func (g *Game) Init() {
 	}

 	//Load textures
-	whiteTex, err := assets.LoadTexturePNG("./res/textures/white.png", &assets.TextureLoadOptions{})
-	if err != nil {
-		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
-	}
-
-	blackTex, err := assets.LoadTexturePNG("./res/textures/black.png", &assets.TextureLoadOptions{})
-	if err != nil {
-		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
-	}
-
 	containerDiffuseTex, err := assets.LoadTexturePNG("./res/textures/container-diffuse.png", &assets.TextureLoadOptions{})
 	if err != nil {
 		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
@ -436,6 +498,16 @@ func (g *Game) Init() {
 		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
 	}

+	brickwallDiffuseTex, err := assets.LoadTexturePNG("./res/textures/brickwall.png", &assets.TextureLoadOptions{})
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
+	}
+
+	brickwallNormalTex, err := assets.LoadTexturePNG("./res/textures/brickwall-normal.png", &assets.TextureLoadOptions{NoSrgba: true})
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
+	}
+
 	skyboxCmap, err = assets.LoadCubemapTextures(
 		"./res/textures/sb-right.jpg", "./res/textures/sb-left.jpg",
 		"./res/textures/sb-top.jpg", "./res/textures/sb-bottom.jpg",
@ -450,24 +522,25 @@ func (g *Game) Init() {
 	// Create materials and assign any unused texture slots to black
 	//
 	screenQuadMat = materials.NewMaterial("Screen Quad Mat", "./res/shaders/screen-quad.glsl")
-	screenQuadMat.SetUnifVec2("scale", demoFboScale)
-	screenQuadMat.SetUnifVec2("offset", demoFboOffset)
+	screenQuadMat.SetUnifVec2("scale", &demoFboScale)
+	screenQuadMat.SetUnifVec2("offset", &demoFboOffset)
 	screenQuadMat.SetUnifInt32("material.diffuse", int32(materials.TextureSlot_Diffuse))

+	tonemappedScreenQuadMat = materials.NewMaterial("Tonemapped Screen Quad Mat", "./res/shaders/tonemapped-screen-quad.glsl")
+	tonemappedScreenQuadMat.SetUnifInt32("material.diffuse", int32(materials.TextureSlot_Diffuse))
+
 	unlitMat = materials.NewMaterial("Unlit mat", "./res/shaders/simple-unlit.glsl")
+	unlitMat.Settings.Set(materials.MaterialSettings_HasModelMtx)
 	unlitMat.SetUnifInt32("material.diffuse", int32(materials.TextureSlot_Diffuse))

 	whiteMat = materials.NewMaterial("White mat", "./res/shaders/simple.glsl")
+	whiteMat.Settings.Set(materials.MaterialSettings_HasModelMtx)
 	whiteMat.Shininess = 64
-	whiteMat.DiffuseTex = whiteTex.TexID
-	whiteMat.SpecularTex = blackTex.TexID
-	whiteMat.NormalTex = blackTex.TexID
-	whiteMat.EmissionTex = blackTex.TexID
 	whiteMat.SetUnifInt32("material.diffuse", int32(materials.TextureSlot_Diffuse))
 	whiteMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
-	// whiteMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
+	whiteMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
 	whiteMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
-	whiteMat.SetUnifVec3("ambientColor", ambientColor)
+	whiteMat.SetUnifVec3("ambientColor", &ambientColor)
 	whiteMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
 	whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 	whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
@ -477,16 +550,15 @@ func (g *Game) Init() {
 	whiteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))

 	containerMat = materials.NewMaterial("Container mat", "./res/shaders/simple.glsl")
+	containerMat.Settings.Set(materials.MaterialSettings_HasModelMtx)
 	containerMat.Shininess = 64
 	containerMat.DiffuseTex = containerDiffuseTex.TexID
 	containerMat.SpecularTex = containerSpecularTex.TexID
-	containerMat.NormalTex = blackTex.TexID
-	containerMat.EmissionTex = blackTex.TexID
 	containerMat.SetUnifInt32("material.diffuse", int32(materials.TextureSlot_Diffuse))
 	containerMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
-	// containerMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
+	containerMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
 	containerMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
-	containerMat.SetUnifVec3("ambientColor", ambientColor)
+	containerMat.SetUnifVec3("ambientColor", &ambientColor)
 	containerMat.SetUnifFloat32("material.shininess", containerMat.Shininess)
 	containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 	containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
@ -495,18 +567,35 @@ func (g *Game) Init() {
 	containerMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
 	containerMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))

+	groundMat = materials.NewMaterial("Ground mat", "./res/shaders/simple.glsl")
+	groundMat.Settings.Set(materials.MaterialSettings_HasModelMtx)
+	groundMat.Shininess = 64
+	groundMat.DiffuseTex = brickwallDiffuseTex.TexID
+	groundMat.NormalTex = brickwallNormalTex.TexID
+	groundMat.SetUnifInt32("material.diffuse", int32(materials.TextureSlot_Diffuse))
+	groundMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
+	groundMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
+	groundMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
+	groundMat.SetUnifVec3("ambientColor", &ambientColor)
+	groundMat.SetUnifFloat32("material.shininess", groundMat.Shininess)
+	groundMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+	groundMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+	groundMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+	groundMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	groundMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
+	groundMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
+
 	palleteMat = materials.NewMaterial("Pallete mat", "./res/shaders/simple.glsl")
+	palleteMat.Settings.Set(materials.MaterialSettings_HasModelMtx)
 	palleteMat.Shininess = 64
 	palleteMat.DiffuseTex = palleteTex.TexID
-	palleteMat.SpecularTex = blackTex.TexID
-	palleteMat.NormalTex = blackTex.TexID
-	palleteMat.EmissionTex = blackTex.TexID
 	palleteMat.SetUnifInt32("material.diffuse", int32(materials.TextureSlot_Diffuse))
 	palleteMat.SetUnifInt32("material.specular", int32(materials.TextureSlot_Specular))
-	// palleteMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
+	palleteMat.SetUnifInt32("material.normal", int32(materials.TextureSlot_Normal))
 	palleteMat.SetUnifInt32("material.emission", int32(materials.TextureSlot_Emission))
-	palleteMat.SetUnifVec3("ambientColor", ambientColor)
+	palleteMat.SetUnifVec3("ambientColor", &ambientColor)
 	palleteMat.SetUnifFloat32("material.shininess", palleteMat.Shininess)
+	palleteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 	palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 	palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
 	palleteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
@ -514,22 +603,29 @@ func (g *Game) Init() {
 	palleteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))

 	debugDepthMat = materials.NewMaterial("Debug depth mat", "./res/shaders/debug-depth.glsl")
+	debugDepthMat.Settings.Set(materials.MaterialSettings_HasModelMtx)

 	depthMapMat = materials.NewMaterial("Depth Map mat", "./res/shaders/depth-map.glsl")
+	depthMapMat.Settings.Set(materials.MaterialSettings_HasModelMtx)

 	arrayDepthMapMat = materials.NewMaterial("Array Depth Map mat", "./res/shaders/array-depth-map.glsl")
+	arrayDepthMapMat.Settings.Set(materials.MaterialSettings_HasModelMtx)

 	omnidirDepthMapMat = materials.NewMaterial("Omnidirectional Depth Map mat", "./res/shaders/omnidirectional-depth-map.glsl")
+	omnidirDepthMapMat.Settings.Set(materials.MaterialSettings_HasModelMtx)

 	skyboxMat = materials.NewMaterial("Skybox mat", "./res/shaders/skybox.glsl")
 	skyboxMat.CubemapTex = skyboxCmap.TexID
 	skyboxMat.SetUnifInt32("skybox", int32(materials.TextureSlot_Cubemap))

 	// Cube model mat
-	translationMat := gglm.NewTranslationMat(gglm.NewVec3(0, 0, 0))
-	scaleMat := gglm.NewScaleMat(gglm.NewVec3(1, 1, 1))
-	rotMat := gglm.NewRotMat(gglm.NewQuatEuler(gglm.NewVec3(-90, -90, 0).AsRad()))
-	cubeModelMat.Mul(translationMat.Mul(rotMat.Mul(scaleMat)))
+	translationMat := gglm.NewTranslationMat(0, 0, 0)
+
+	scaleMat := gglm.NewScaleMat(1, 1, 1)
+
+	rotMatRot := gglm.NewQuatEuler(-90*gglm.Deg2Rad, -90*gglm.Deg2Rad, 0)
+	rotMat := gglm.NewRotMatQuat(&rotMatRot)
+	cubeModelMat.Mul(translationMat.Mul(rotMat.Mul(&scaleMat)))

 	// Screen quad vao setup.
 	// We don't actually care about the values here because the quad is hardcoded in the shader,
@ -550,6 +646,8 @@ func (g *Game) Init() {

 func (g *Game) initFbos() {

+	// @TODO: Resize window sized fbos on window resize
+
 	// Demo fbo
 	demoFbo = buffers.NewFramebuffer(uint32(g.WinWidth), uint32(g.WinHeight))

@ -566,7 +664,7 @@ func (g *Game) initFbos() {
 	assert.T(demoFbo.IsComplete(), "Demo fbo is not complete after init")

 	// Depth map fbo
-	dirLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024)
+	dirLightDepthMapFbo = buffers.NewFramebuffer(2048, 2048)
 	dirLightDepthMapFbo.SetNoColorBuffer()
 	dirLightDepthMapFbo.NewDepthAttachment(
 		buffers.FramebufferAttachmentType_Texture,
@ -576,7 +674,7 @@ func (g *Game) initFbos() {
 	assert.T(dirLightDepthMapFbo.IsComplete(), "Depth map fbo is not complete after init")

 	// Point light depth map fbo
-	pointLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024)
+	pointLightDepthMapFbo = buffers.NewFramebuffer(512, 512)
 	pointLightDepthMapFbo.SetNoColorBuffer()
 	pointLightDepthMapFbo.NewDepthCubemapArrayAttachment(
 		buffers.FramebufferAttachmentDataFormat_DepthF32,
@ -586,7 +684,7 @@ func (g *Game) initFbos() {
 	assert.T(pointLightDepthMapFbo.IsComplete(), "Point light depth map fbo is not complete after init")

 	// Spot light depth map fbo
-	spotLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024)
+	spotLightDepthMapFbo = buffers.NewFramebuffer(512, 512)
 	spotLightDepthMapFbo.SetNoColorBuffer()
 	spotLightDepthMapFbo.NewDepthTextureArrayAttachment(
 		buffers.FramebufferAttachmentDataFormat_DepthF32,
@ -594,6 +692,20 @@ func (g *Game) initFbos() {
 	)

 	assert.T(spotLightDepthMapFbo.IsComplete(), "Spot light depth map fbo is not complete after init")
+
+	// Hdr fbo
+	hdrFbo = buffers.NewFramebuffer(uint32(g.WinWidth), uint32(g.WinHeight))
+	hdrFbo.NewColorAttachment(
+		buffers.FramebufferAttachmentType_Texture,
+		buffers.FramebufferAttachmentDataFormat_RGBAF16,
+	)
+
+	hdrFbo.NewDepthStencilAttachment(
+		buffers.FramebufferAttachmentType_Renderbuffer,
+		buffers.FramebufferAttachmentDataFormat_Depth24Stencil8,
+	)
+
+	assert.T(hdrFbo.IsComplete(), "Hdr fbo is not complete after init")
 }

 func (g *Game) updateLights() {
@ -601,6 +713,7 @@ func (g *Game) updateLights() {
 	// Directional light
 	whiteMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
 	containerMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
+	groundMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
 	palleteMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id

 	// Point lights
@ -611,35 +724,43 @@ func (g *Game) updateLights() {

 		whiteMat.SetUnifVec3(indexString+".pos", &p.Pos)
 		containerMat.SetUnifVec3(indexString+".pos", &p.Pos)
+		groundMat.SetUnifVec3(indexString+".pos", &p.Pos)
 		palleteMat.SetUnifVec3(indexString+".pos", &p.Pos)

 		whiteMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
 		containerMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
+		groundMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
 		palleteMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)

 		whiteMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
 		containerMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
+		groundMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
 		palleteMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)

 		whiteMat.SetUnifFloat32(indexString+".constant", p.Constant)
 		containerMat.SetUnifFloat32(indexString+".constant", p.Constant)
+		groundMat.SetUnifFloat32(indexString+".constant", p.Constant)
 		palleteMat.SetUnifFloat32(indexString+".constant", p.Constant)

 		whiteMat.SetUnifFloat32(indexString+".linear", p.Linear)
 		containerMat.SetUnifFloat32(indexString+".linear", p.Linear)
+		groundMat.SetUnifFloat32(indexString+".linear", p.Linear)
 		palleteMat.SetUnifFloat32(indexString+".linear", p.Linear)

 		whiteMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
 		containerMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
+		groundMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
 		palleteMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)

 		whiteMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
 		containerMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
+		groundMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
 		palleteMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
 	}

 	whiteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
 	containerMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
+	groundMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
 	palleteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id

 	// Spotlights
@ -653,31 +774,38 @@ func (g *Game) updateLights() {

 		whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
 		containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
+		groundMat.SetUnifVec3(indexString+".pos", &l.Pos)
 		palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)

 		whiteMat.SetUnifVec3(indexString+".dir", &l.Dir)
 		containerMat.SetUnifVec3(indexString+".dir", &l.Dir)
+		groundMat.SetUnifVec3(indexString+".dir", &l.Dir)
 		palleteMat.SetUnifVec3(indexString+".dir", &l.Dir)

 		whiteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
 		containerMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+		groundMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
 		palleteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)

 		whiteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 		containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
+		groundMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 		palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)

 		whiteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
 		containerMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
+		groundMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
 		palleteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)

 		whiteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
 		containerMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
+		groundMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
 		palleteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
 	}

 	whiteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
 	containerMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
+	groundMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
 	palleteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
 }

@ -718,13 +846,22 @@ func (g *Game) showDebugWindow() {

 	imgui.Spacing()

+	imgui.Text("HDR")
+	imgui.Checkbox("Enable HDR", &hdrRendering)
+	if imgui.DragFloat("Exposure", &hdrExposure) {
+		tonemappedScreenQuadMat.SetUnifFloat32("exposure", hdrExposure)
+	}
+
+	imgui.Spacing()
+
 	// Ambient light
 	imgui.Text("Ambient Light")

 	if imgui.DragFloat3("Ambient Color", &ambientColor.Data) {
-		whiteMat.SetUnifVec3("ambientColor", ambientColor)
-		containerMat.SetUnifVec3("ambientColor", ambientColor)
-		palleteMat.SetUnifVec3("ambientColor", ambientColor)
+		whiteMat.SetUnifVec3("ambientColor", &ambientColor)
+		containerMat.SetUnifVec3("ambientColor", &ambientColor)
+		groundMat.SetUnifVec3("ambientColor", &ambientColor)
+		palleteMat.SetUnifVec3("ambientColor", &ambientColor)
 	}

 	imgui.Spacing()
@ -737,18 +874,21 @@ func (g *Game) showDebugWindow() {
 	if imgui.DragFloat3("Direction", &dirLight.Dir.Data) {
 		whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 		containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+		groundMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 		palleteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 	}

 	if imgui.DragFloat3("Diffuse Color", &dirLight.DiffuseColor.Data) {
 		whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 		containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+		groundMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 		palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 	}

 	if imgui.DragFloat3("Specular Color", &dirLight.SpecularColor.Data) {
 		whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
 		containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+		groundMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
 		palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
 	}

@ -765,6 +905,7 @@ func (g *Game) showDebugWindow() {
 	if imgui.DragFloat("Specular Shininess", &whiteMat.Shininess) {
 		whiteMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
 		containerMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
+		groundMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
 		palleteMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
 	}

@ -788,18 +929,21 @@ func (g *Game) showDebugWindow() {
 			if imgui.DragFloat3("Pos", &pl.Pos.Data) {
 				whiteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
 				containerMat.SetUnifVec3(indexString+".pos", &pl.Pos)
+				groundMat.SetUnifVec3(indexString+".pos", &pl.Pos)
 				palleteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
 			}

 			if imgui.DragFloat3("Diffuse Color", &pl.DiffuseColor.Data) {
 				whiteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
 				containerMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+				groundMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
 				palleteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
 			}

 			if imgui.DragFloat3("Specular Color", &pl.SpecularColor.Data) {
 				whiteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
 				containerMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+				groundMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
 				palleteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
 			}

@ -828,24 +972,28 @@ func (g *Game) showDebugWindow() {
 			if imgui.DragFloat3("Pos", &l.Pos.Data) {
 				whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
 				containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
+				groundMat.SetUnifVec3(indexString+".pos", &l.Pos)
 				palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)
 			}

 			if imgui.DragFloat3("Dir", &l.Dir.Data) {
 				whiteMat.SetUnifVec3(indexString+".dir", &l.Dir)
 				containerMat.SetUnifVec3(indexString+".dir", &l.Dir)
+				groundMat.SetUnifVec3(indexString+".dir", &l.Dir)
 				palleteMat.SetUnifVec3(indexString+".dir", &l.Dir)
 			}

 			if imgui.DragFloat3("Diffuse Color", &l.DiffuseColor.Data) {
 				whiteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
 				containerMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+				groundMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
 				palleteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
 			}

 			if imgui.DragFloat3("Specular Color", &l.SpecularColor.Data) {
 				whiteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 				containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
+				groundMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 				palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 			}

@ -855,6 +1003,7 @@ func (g *Game) showDebugWindow() {

 				whiteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
 				containerMat.SetUnifFloat32(indexString+".innerCutoff", cos)
+				groundMat.SetUnifFloat32(indexString+".innerCutoff", cos)
 				palleteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
 			}

@ -864,6 +1013,7 @@ func (g *Game) showDebugWindow() {

 				whiteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
 				containerMat.SetUnifFloat32(indexString+".outerCutoff", cos)
+				groundMat.SetUnifFloat32(indexString+".outerCutoff", cos)
 				palleteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
 			}

@ -944,10 +1094,12 @@ func (g *Game) updateCameraPos() {

 	// Left and right
 	if input.KeyDown(sdl.K_d) {
-		cam.Pos.Add(gglm.Cross(&cam.Forward, &cam.WorldUp).Normalize().Scale(camSpeed * camSpeedScale * timing.DT()))
+		cross := gglm.Cross(&cam.Forward, &cam.WorldUp)
+		cam.Pos.Add(cross.Normalize().Scale(camSpeed * camSpeedScale * timing.DT()))
 		update = true
 	} else if input.KeyDown(sdl.K_a) {
-		cam.Pos.Add(gglm.Cross(&cam.Forward, &cam.WorldUp).Normalize().Scale(-camSpeed * camSpeedScale * timing.DT()))
+		cross := gglm.Cross(&cam.Forward, &cam.WorldUp)
+		cam.Pos.Add(cross.Normalize().Scale(-camSpeed * camSpeedScale * timing.DT()))
 		update = true
 	}

@ -965,20 +1117,21 @@ var (
 	rotatingCubeSpeedDeg1 float32 = 45
 	rotatingCubeSpeedDeg2 float32 = 120
 	rotatingCubeSpeedDeg3 float32 = 120
-	rotatingCubeTrMat1            = *gglm.NewTrMatId().Translate(gglm.NewVec3(-4, -1, 4))
-	rotatingCubeTrMat2            = *gglm.NewTrMatId().Translate(gglm.NewVec3(-1, 0.5, 4))
-	rotatingCubeTrMat3            = *gglm.NewTrMatId().Translate(gglm.NewVec3(5, 0.5, 4))
+	rotatingCubeTrMat1            = gglm.NewTrMatWithPos(-4, -1, 4)
+	rotatingCubeTrMat2            = gglm.NewTrMatWithPos(-1, 0.5, 4)
+	rotatingCubeTrMat3            = gglm.NewTrMatWithPos(5, 0.5, 4)
 )

 func (g *Game) Render() {

 	whiteMat.SetUnifVec3("camPos", &cam.Pos)
 	containerMat.SetUnifVec3("camPos", &cam.Pos)
+	groundMat.SetUnifVec3("camPos", &cam.Pos)
 	palleteMat.SetUnifVec3("camPos", &cam.Pos)

-	rotatingCubeTrMat1.Rotate(rotatingCubeSpeedDeg1*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(0, 1, 0))
-	rotatingCubeTrMat2.Rotate(rotatingCubeSpeedDeg2*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(1, 1, 0))
-	rotatingCubeTrMat3.Rotate(rotatingCubeSpeedDeg3*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(1, 1, 1))
+	rotatingCubeTrMat1.Rotate(rotatingCubeSpeedDeg1*gglm.Deg2Rad*timing.DT(), 0, 1, 0)
+	rotatingCubeTrMat2.Rotate(rotatingCubeSpeedDeg2*gglm.Deg2Rad*timing.DT(), 1, 1, 0)
+	rotatingCubeTrMat3.Rotate(rotatingCubeSpeedDeg3*gglm.Deg2Rad*timing.DT(), 1, 1, 1)

 	if renderDirLightShadows {
 		g.renderDirectionalLightShadowmap()
@ -996,17 +1149,19 @@ func (g *Game) Render() {

 		if renderDepthBuffer {
 			g.RenderScene(&debugDepthMat)
+		} else if hdrRendering {
+			g.renderHdrFbo()
 		} else {
+
 			g.RenderScene(nil)
+			if renderSkybox {
+				g.DrawSkybox()
+			}
 		}
 	}

-	if renderSkybox {
-		g.DrawSkybox()
-	}
-
 	if renderToDemoFbo {
-		g.renderDemoFob()
+		g.renderDemoFbo()
 	}
 }

@ -1017,6 +1172,7 @@ func (g *Game) renderDirectionalLightShadowmap() {

 	whiteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
 	containerMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
+	groundMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
 	palleteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)

 	depthMapMat.SetUnifMat4("projViewMat", &dirLightProjViewMat)
@ -1038,8 +1194,8 @@ func (g *Game) renderDirectionalLightShadowmap() {

 	if showDirLightDepthMapFbo {
 		screenQuadMat.DiffuseTex = dirLightDepthMapFbo.Attachments[0].Id
-		screenQuadMat.SetUnifVec2("offset", dirLightDepthMapFboOffset)
-		screenQuadMat.SetUnifVec2("scale", dirLightDepthMapFboScale)
+		screenQuadMat.SetUnifVec2("offset", &dirLightDepthMapFboOffset)
+		screenQuadMat.SetUnifVec2("scale", &dirLightDepthMapFboScale)
 		screenQuadMat.Bind()
 		window.Rend.DrawVertexArray(&screenQuadMat, &screenQuadVao, 0, 6)
 	}
@ -1058,6 +1214,7 @@ func (g *Game) renderSpotLightShadowmaps() {

 		whiteMat.SetUnifMat4(projViewMatIndexStr, &projViewMat)
 		containerMat.SetUnifMat4(projViewMatIndexStr, &projViewMat)
+		groundMat.SetUnifMat4(projViewMatIndexStr, &projViewMat)
 		palleteMat.SetUnifMat4(projViewMatIndexStr, &projViewMat)

 		// Set depth uniforms
@ -1102,7 +1259,7 @@ func (g *Game) renderPointLightShadowmaps() {
 	pointLightDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight))
 }

-func (g *Game) renderDemoFob() {
+func (g *Game) renderDemoFbo() {

 	demoFbo.Bind()
 	demoFbo.Clear()
@ -1120,12 +1277,29 @@ func (g *Game) renderDemoFob() {
 	demoFbo.UnBind()

 	screenQuadMat.DiffuseTex = demoFbo.Attachments[0].Id
-	screenQuadMat.SetUnifVec2("offset", demoFboOffset)
-	screenQuadMat.SetUnifVec2("scale", demoFboScale)
+	screenQuadMat.SetUnifVec2("offset", &demoFboOffset)
+	screenQuadMat.SetUnifVec2("scale", &demoFboScale)

 	window.Rend.DrawVertexArray(&screenQuadMat, &screenQuadVao, 0, 6)
 }

+func (g *Game) renderHdrFbo() {
+
+	hdrFbo.Bind()
+	hdrFbo.Clear()
+
+	g.RenderScene(nil)
+
+	if renderSkybox {
+		g.DrawSkybox()
+	}
+
+	hdrFbo.UnBind()
+
+	tonemappedScreenQuadMat.DiffuseTex = hdrFbo.Attachments[0].Id
+	window.Rend.DrawVertexArray(&tonemappedScreenQuadMat, &screenQuadVao, 0, 6)
+}
+
 func (g *Game) RenderScene(overrideMat *materials.Material) {

 	tempModelMatrix := cubeModelMat.Clone()
@ -1134,34 +1308,39 @@ func (g *Game) RenderScene(overrideMat *materials.Material) {
 	sunMat := &palleteMat
 	chairMat := &palleteMat
 	cubeMat := &containerMat
+	groundMat := &groundMat

 	if overrideMat != nil {
 		sunMat = overrideMat
 		chairMat = overrideMat
 		cubeMat = overrideMat
+		groundMat = overrideMat
 	}

 	// Draw dir light
-	window.Rend.DrawMesh(&sphereMesh, gglm.NewTrMatId().Translate(gglm.NewVec3(0, 10, 0)).Scale(gglm.NewVec3(0.1, 0.1, 0.1)), sunMat)
+	dirLightTrMat := gglm.NewTrMatId()
+	window.Rend.DrawMesh(&sphereMesh, dirLightTrMat.Translate(0, 10, 0).Scale(0.1, 0.1, 0.1), sunMat)

 	// Draw point lights
 	for i := 0; i < len(pointLights); i++ {

 		pl := &pointLights[i]
-		window.Rend.DrawMesh(&cubeMesh, gglm.NewTrMatId().Translate(&pl.Pos).Scale(gglm.NewVec3(0.1, 0.1, 0.1)), sunMat)
+		plTrMat := gglm.NewTrMatId()
+		window.Rend.DrawMesh(&cubeMesh, plTrMat.TranslateVec(&pl.Pos).Scale(0.1, 0.1, 0.1), sunMat)
 	}

 	// Chair
 	window.Rend.DrawMesh(&chairMesh, tempModelMatrix, chairMat)

 	// Ground
-	window.Rend.DrawMesh(&cubeMesh, gglm.NewTrMatId().Translate(gglm.NewVec3(0, -3, 0)).Scale(gglm.NewVec3(20, 1, 20)), cubeMat)
+	groundTrMat := gglm.NewTrMatId()
+	window.Rend.DrawMesh(&cubeMesh, groundTrMat.Translate(0, -3, 0).Scale(20, 1, 20), groundMat)

 	// Cubes
-	tempModelMatrix.Translate(gglm.NewVec3(-6, 0, 0))
+	tempModelMatrix.Translate(-6, 0, 0)
 	window.Rend.DrawMesh(&cubeMesh, tempModelMatrix, cubeMat)

-	tempModelMatrix.Translate(gglm.NewVec3(0, -1, -4))
+	tempModelMatrix.Translate(0, -1, -4)
 	window.Rend.DrawMesh(&cubeMesh, tempModelMatrix, cubeMat)

 	// Rotating cubes
@ -1205,6 +1384,7 @@ func updateAllProjViewMats(projMat, viewMat gglm.Mat4) {
 	unlitMat.SetUnifMat4("projViewMat", projViewMat)
 	whiteMat.SetUnifMat4("projViewMat", projViewMat)
 	containerMat.SetUnifMat4("projViewMat", projViewMat)
+	groundMat.SetUnifMat4("projViewMat", projViewMat)
 	palleteMat.SetUnifMat4("projViewMat", projViewMat)
 	debugDepthMat.SetUnifMat4("projViewMat", projViewMat)

--- a/materials/material.go
+++ b/materials/material.go
@ -3,6 +3,7 @@ package materials
 import (
 	"github.com/bloeys/gglm/gglm"
 	"github.com/bloeys/nmage/assert"
+	"github.com/bloeys/nmage/assets"
 	"github.com/bloeys/nmage/logging"
 	"github.com/bloeys/nmage/shaders"
 	"github.com/go-gl/gl/v4.1-core/gl"
@ -21,14 +22,35 @@ const (
 	TextureSlot_ShadowMap_Array1 TextureSlot = 13
 )

+type MaterialSettings uint64
+
+const (
+	MaterialSettings_None        MaterialSettings = iota
+	MaterialSettings_HasModelMtx MaterialSettings = 1 << (iota - 1)
+	MaterialSettings_HasNormalMtx
+)
+
+func (ms *MaterialSettings) Set(flags MaterialSettings) {
+	*ms |= flags
+}
+
+func (ms *MaterialSettings) Remove(flags MaterialSettings) {
+	*ms &= ^flags
+}
+
+func (ms *MaterialSettings) Has(flags MaterialSettings) bool {
+	return *ms&flags == flags
+}
+
 type Material struct {
 	Name       string
 	ShaderProg shaders.ShaderProgram
+	Settings   MaterialSettings

 	UnifLocs   map[string]int32
 	AttribLocs map[string]int32

-	// @TODO do this in a better way. Perhaps something like how we do fbo attachments
+	// @TODO: Do this in a better way?. Perhaps something like how we do fbo attachments? Or keep it?
 	// Phong shading
 	DiffuseTex  uint32
 	SpecularTex uint32
@ -51,26 +73,19 @@ func (m *Material) Bind() {

 	m.ShaderProg.Bind()

-	if m.DiffuseTex != 0 {
-		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Diffuse))
-		gl.BindTexture(gl.TEXTURE_2D, m.DiffuseTex)
-	}
+	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)
-	}
+	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)
-	}
+	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)
-	}
+	gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Emission))
+	gl.BindTexture(gl.TEXTURE_2D, m.EmissionTex)

+	// @TODO: Have defaults for these
 	if m.CubemapTex != 0 {
 		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Cubemap))
 		gl.BindTexture(gl.TEXTURE_CUBE_MAP, m.CubemapTex)
@ -173,7 +188,17 @@ func NewMaterial(matName, shaderPath string) Material {
 		logging.ErrLog.Fatalf("Failed to create new material '%s'. Err: %s\n", matName, err.Error())
 	}

-	return Material{Name: matName, ShaderProg: shdrProg, UnifLocs: make(map[string]int32), AttribLocs: make(map[string]int32)}
+	return Material{
+		Name:       matName,
+		ShaderProg: shdrProg,
+		UnifLocs:   make(map[string]int32),
+		AttribLocs: make(map[string]int32),
+
+		DiffuseTex:  assets.DefaultDiffuseTexId.TexID,
+		SpecularTex: assets.DefaultSpecularTexId.TexID,
+		NormalTex:   assets.DefaultNormalTexId.TexID,
+		EmissionTex: assets.DefaultEmissionTexId.TexID,
+	}
 }

 func NewMaterialSrc(matName string, shaderSrc []byte) Material {
@ -183,5 +208,15 @@ func NewMaterialSrc(matName string, shaderSrc []byte) Material {
 		logging.ErrLog.Fatalf("Failed to create new material '%s'. Err: %s\n", matName, err.Error())
 	}

-	return Material{Name: matName, ShaderProg: shdrProg, UnifLocs: make(map[string]int32), AttribLocs: make(map[string]int32)}
+	return Material{
+		Name:       matName,
+		ShaderProg: shdrProg,
+		UnifLocs:   make(map[string]int32),
+		AttribLocs: make(map[string]int32),
+
+		DiffuseTex:  assets.DefaultDiffuseTexId.TexID,
+		SpecularTex: assets.DefaultSpecularTexId.TexID,
+		NormalTex:   assets.DefaultNormalTexId.TexID,
+		EmissionTex: assets.DefaultEmissionTexId.TexID,
+	}
 }
--- a/meshes/mesh.go
+++ b/meshes/mesh.go
@ -16,14 +16,38 @@ type SubMesh struct {
 }

 type Mesh struct {
-	Name      string
+	Name string
+	/*
+		Vao has the following shader attribute layout:
+			- Loc0: Pos
+			- Loc1: Normal
+			- Loc2: UV0
+			- Loc3: Tangent
+			- (Optional) Color
+
+		Optional stuff appear in the order in this list, depending on what other optional stuff exists.
+
+		For example:
+			- If color exists it will be in Loc3, otherwise it is unset
+	*/
 	Vao       buffers.VertexArray
 	SubMeshes []SubMesh
 }

+var (
+	// DefaultMeshLoadFlags are the flags always applied when loading a new mesh regardless
+	// of what post process flags are used when loading a mesh.
+	//
+	// Defaults to: asig.PostProcessTriangulate | asig.PostProcessCalcTangentSpace;
+	// Note: changing this will break the normal lit shaders, which expect tangents to be there
+	DefaultMeshLoadFlags asig.PostProcess = asig.PostProcessTriangulate | asig.PostProcessCalcTangentSpace
+)
+
 func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (Mesh, error) {

-	scene, release, err := asig.ImportFile(modelPath, asig.PostProcessTriangulate|postProcessFlags)
+	finalPostProcessFlags := DefaultMeshLoadFlags | postProcessFlags
+
+	scene, release, err := asig.ImportFile(modelPath, finalPostProcessFlags)
 	if err != nil {
 		return Mesh{}, errors.New("Failed to load model. Err: " + err.Error())
 	}
@ -42,8 +66,17 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (Mesh, e
 	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)
+	// Estimate a useful prealloc capacity based on the first submesh that has vertex pos+normals+tangents+texCoords
+	vertexBufDataCapacity := len(scene.Meshes[0].Vertices) * 3 * 3 * 3 * 2
+
+	// Increase capacity depending on what the mesh has
+	if len(scene.Meshes[0].ColorSets) > 0 && len(scene.Meshes[0].ColorSets[0]) > 0 {
+		vertexBufDataCapacity *= 4
+	}
+
+	var vertexBufData []float32 = make([]float32, 0, vertexBufDataCapacity)
+
+	// Initial size assumes 3 indices per face
 	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))
@ -52,12 +85,25 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (Mesh, e

 		sceneMesh := scene.Meshes[i]

+		// We always want tangents and UV0
+		if len(sceneMesh.Tangents) == 0 {
+			sceneMesh.Tangents = make([]gglm.Vec3, len(sceneMesh.Vertices))
+		}
+
 		if len(sceneMesh.TexCoords[0]) == 0 {
 			sceneMesh.TexCoords[0] = make([]gglm.Vec3, len(sceneMesh.Vertices))
 		}

-		layoutToUse := []buffers.Element{{ElementType: buffers.DataTypeVec3}, {ElementType: buffers.DataTypeVec3}, {ElementType: buffers.DataTypeVec2}}
-		if len(sceneMesh.ColorSets) > 0 && len(sceneMesh.ColorSets[0]) > 0 {
+		hasColorSet0 := len(sceneMesh.ColorSets) > 0 && len(sceneMesh.ColorSets[0]) > 0
+
+		layoutToUse := []buffers.Element{
+			{ElementType: buffers.DataTypeVec3}, // Position
+			{ElementType: buffers.DataTypeVec3}, // Normals
+			{ElementType: buffers.DataTypeVec3}, // Tangents
+			{ElementType: buffers.DataTypeVec2}, // UV0
+		}
+
+		if hasColorSet0 {
 			layoutToUse = append(layoutToUse, buffers.Element{ElementType: buffers.DataTypeVec4})
 		}

@ -79,8 +125,14 @@ func NewMesh(name, modelPath string, postProcessFlags asig.PostProcess) (Mesh, e
 			}
 		}

-		arrs := []arrToInterleave{{V3s: sceneMesh.Vertices}, {V3s: sceneMesh.Normals}, {V2s: v3sToV2s(sceneMesh.TexCoords[0])}}
-		if len(sceneMesh.ColorSets) > 0 && len(sceneMesh.ColorSets[0]) > 0 {
+		arrs := []arrToInterleave{
+			{V3s: sceneMesh.Vertices},
+			{V3s: sceneMesh.Normals},
+			{V3s: sceneMesh.Tangents},
+			{V2s: v3sToV2s(sceneMesh.TexCoords[0])},
+		}
+
+		if hasColorSet0 {
 			arrs = append(arrs, arrToInterleave{V4s: sceneMesh.ColorSets[0]})
 		}

--- a/renderer/rend3dgl/rend3dgl.go
+++ b/renderer/rend3dgl/rend3dgl.go
@ -29,7 +29,14 @@ func (r *Rend3DGL) DrawMesh(mesh *meshes.Mesh, modelMat *gglm.TrMat, mat *materi
 		r.BoundMat = mat
 	}

-	mat.SetUnifMat4("modelMat", &modelMat.Mat4)
+	if mat.Settings.Has(materials.MaterialSettings_HasModelMtx) {
+		mat.SetUnifMat4("modelMat", &modelMat.Mat4)
+	}
+
+	if mat.Settings.Has(materials.MaterialSettings_HasNormalMtx) {
+		normalMat := modelMat.Clone().InvertAndTranspose().ToMat3()
+		mat.SetUnifMat3("normalMat", &normalMat)
+	}

 	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)
--- a/res/shaders/debug-depth.glsl
+++ b/res/shaders/debug-depth.glsl
@ -2,22 +2,19 @@
 #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;
+layout(location=2) in vec3 vertTangentIn;
+layout(location=3) in vec2 vertUV0In;
+layout(location=4) 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()
 {
-    vertNormal = mat3(transpose(inverse(modelMat))) * vertNormalIn;
    vertUV0 = vertUV0In;
    vertColor = vertColorIn;

@ -31,7 +28,6 @@ void main()
 #version 410

 in vec3 vertColor;
-in vec3 vertNormal;
 in vec2 vertUV0;
 in vec3 fragPos;

--- a/res/shaders/simple-unlit.glsl
+++ b/res/shaders/simple-unlit.glsl
@ -3,26 +3,19 @@

 layout(location=0) in vec3 vertPosIn;
 layout(location=1) in vec3 vertNormalIn;
-layout(location=2) in vec2 vertUV0In;
-layout(location=3) in vec3 vertColorIn;
+layout(location=2) in vec3 vertTangentIn;
+layout(location=3) in vec2 vertUV0In;
+layout(location=4) 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;

@ -41,7 +34,6 @@ struct Material {
 uniform Material material;

 in vec3 vertColor;
-in vec3 vertNormal;
 in vec2 vertUV0;
 in vec3 fragPos;

--- a/res/shaders/simple.glsl
+++ b/res/shaders/simple.glsl
@ -1,66 +1,34 @@
 //shader:vertex
 #version 410

+#define NUM_SPOT_LIGHTS 4
+#define NUM_POINT_LIGHTS 8
+
+//
+// Inputs
+//
 layout(location=0) in vec3 vertPosIn;
 layout(location=1) in vec3 vertNormalIn;
-layout(location=2) in vec2 vertUV0In;
-layout(location=3) in vec3 vertColorIn;
+layout(location=2) in vec3 vertTangentIn;
+layout(location=3) in vec2 vertUV0In;
+layout(location=4) in vec3 vertColorIn;

+//
+// Uniforms
+//
+uniform vec3 camPos;
 uniform mat4 modelMat;
+uniform mat3 normalMat;
 uniform mat4 projViewMat;
 uniform mat4 dirLightProjViewMat;
-
-#define NUM_SPOT_LIGHTS 4
 uniform mat4 spotLightProjViewMats[NUM_SPOT_LIGHTS];

-out vec3 vertNormal;
-out vec2 vertUV0;
-out vec3 vertColor;
-out vec3 fragPos;
-out vec4 fragPosDirLight;
-out vec4 fragPosSpotLight[NUM_SPOT_LIGHTS];
-
-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;
-    fragPosDirLight = dirLightProjViewMat * vec4(fragPos, 1);
-
-    for (int i = 0; i < NUM_SPOT_LIGHTS; i++)
-        fragPosSpotLight[i] = spotLightProjViewMats[i] * vec4(fragPos, 1);
-
-    gl_Position = projViewMat * modelVert;
-}
-
-//shader:fragment
-#version 410
-
-struct Material {
-    sampler2D diffuse;
-    sampler2D specular;
-    // sampler2D normal;
-    sampler2D emission;
-    float shininess;
-};
-
-uniform Material material;
-
 struct DirLight {
    vec3 dir;
    vec3 diffuseColor;
    vec3 specularColor;
    sampler2D shadowMap;
 };
-
 uniform DirLight dirLight;

 struct PointLight {
@ -72,8 +40,133 @@ struct PointLight {
    float quadratic;
    float farPlane;
 };
+uniform PointLight pointLights[NUM_POINT_LIGHTS];

+struct SpotLight {
+    vec3 pos;
+    vec3 dir;
+    vec3 diffuseColor;
+    vec3 specularColor;
+    float innerCutoff;
+    float outerCutoff;
+};
+uniform SpotLight spotLights[NUM_SPOT_LIGHTS];
+
+//
+// Outputs
+//
+out vec2 vertUV0;
+out vec3 vertColor;
+
+out vec3 fragPos;
+out vec3 fragPosDirLight;
+out vec4 fragPosSpotLight[NUM_SPOT_LIGHTS];
+
+out vec3 tangentCamPos;
+out vec3 tangentFragPos;
+out vec3 tangentDirLightDir;
+out vec3 tangentSpotLightPositions[NUM_SPOT_LIGHTS];
+out vec3 tangentSpotLightDirections[NUM_SPOT_LIGHTS];
+out vec3 tangentPointLightPositions[NUM_POINT_LIGHTS];
+
+void main()
+{
+    vertUV0 = vertUV0In;
+    vertColor = vertColorIn;
+    vec4 modelVert = modelMat * vec4(vertPosIn, 1);
+
+    // Tangent-BiTangent-Normal matrix for normal mapping
+    vec3 T = normalize(vec3(modelMat * vec4(vertTangentIn,   0.0)));
+    vec3 N = normalize(vec3(modelMat * vec4(vertNormalIn,    0.0)));
+
+    // Ensure T is orthogonal with respect to N
+    T = normalize(T - dot(T, N) * N);
+
+    vec3 B = cross(N, T);
+    mat3 tbnMtx = transpose(mat3(T, B, N));
+
+    // Lighting related
+    fragPos = modelVert.xyz;
+    fragPosDirLight = vec3(dirLightProjViewMat * vec4(fragPos, 1));
+
+    tangentCamPos = tbnMtx * camPos;
+    tangentFragPos = tbnMtx * fragPos;
+    tangentDirLightDir = tbnMtx * dirLight.dir;
+
+    for (int i = 0; i < NUM_POINT_LIGHTS; i++)
+        tangentPointLightPositions[i] = tbnMtx * pointLights[i].pos;
+
+    for (int i = 0; i < NUM_SPOT_LIGHTS; i++)
+    {
+        fragPosSpotLight[i] = spotLightProjViewMats[i] * vec4(fragPos, 1);
+
+        tangentSpotLightPositions[i] = tbnMtx * spotLights[i].pos;
+        tangentSpotLightDirections[i] = tbnMtx * spotLights[i].dir;
+    }
+
+    gl_Position = projViewMat * modelVert;
+}
+
+//shader:fragment
+#version 410
+
+/*
+    Note that while all lighting calculations are done in tangent space,
+    shadow mapping is done in world space.
+
+    The exception is the bias calculation. Since the bias relies on the normal
+    and the normal is in tangent space, we use a tangent space fragment position
+    with it, but the rest of shadow processing is in world space.
+*/
+
+#define NUM_SPOT_LIGHTS 4
 #define NUM_POINT_LIGHTS 8
+
+//
+// Inputs
+//
+in vec3 fragPos;
+in vec2 vertUV0;
+in vec3 vertColor;
+in vec3 fragPosDirLight;
+in vec4 fragPosSpotLight[NUM_SPOT_LIGHTS];
+
+in vec3 tangentCamPos;
+in vec3 tangentFragPos;
+in vec3 tangentDirLightDir;
+in vec3 tangentSpotLightPositions[NUM_SPOT_LIGHTS];
+in vec3 tangentSpotLightDirections[NUM_SPOT_LIGHTS];
+in vec3 tangentPointLightPositions[NUM_POINT_LIGHTS];
+
+//
+// Uniforms
+//
+struct Material {
+    sampler2D diffuse;
+    sampler2D specular;
+    sampler2D normal;
+    sampler2D emission;
+    float shininess;
+};
+uniform Material material;
+
+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;
+    float farPlane;
+};
 uniform PointLight pointLights[NUM_POINT_LIGHTS];
 uniform samplerCubeArray pointLightCubeShadowMaps;

@ -85,37 +178,29 @@ struct SpotLight {
    float innerCutoff;
    float outerCutoff;
 };
-
-#define NUM_SPOT_LIGHTS 4
 uniform SpotLight spotLights[NUM_SPOT_LIGHTS];
 uniform sampler2DArray spotLightShadowMaps;

-uniform vec3 camPos;
 uniform vec3 ambientColor = vec3(0.2, 0.2, 0.2);

-in vec3 vertColor;
-in vec3 vertNormal;
-in vec2 vertUV0;
-in vec3 fragPos;
-in vec4 fragPosDirLight;
-in vec4 fragPosSpotLight[NUM_SPOT_LIGHTS];
-
+//
+// Outputs
+//
 out vec4 fragColor;

+//
 // Global variables used as cache for lighting calculations
+//
+vec3 tangentViewDir;
 vec4 diffuseTexColor;
 vec4 specularTexColor;
 vec4 emissionTexColor;
 vec3 normalizedVertNorm;
-vec3 viewDir;

-float CalcDirShadow(sampler2D shadowMap, vec3 lightDir)
+float CalcDirShadow(sampler2D shadowMap, vec3 tangentLightDir)
 {
-    // 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;
+    vec3 projCoords = fragPosDirLight * 0.5 + 0.5;

    // If sampling outside the depth texture then force 'no shadow'
    if(projCoords.z > 1)
@ -126,7 +211,7 @@ float CalcDirShadow(sampler2D shadowMap, vec3 lightDir)

    // 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);
+    float bias = max(0.05 * (1 - dot(normalizedVertNorm, tangentLightDir)), 0.005);

    // 'Percentage Close Filtering'.
    // Basically get soft shadows by averaging this texel and surrounding ones
@ -151,14 +236,14 @@ float CalcDirShadow(sampler2D shadowMap, vec3 lightDir)

 vec3 CalcDirLight()
 {
-    vec3 lightDir = normalize(-dirLight.dir);
+    vec3 lightDir = normalize(-tangentDirLightDir);

    // Diffuse
    float diffuseAmount = max(0.0, dot(normalizedVertNorm, lightDir));
    vec3 finalDiffuse = diffuseAmount * dirLight.diffuseColor * diffuseTexColor.rgb;

    // Specular
-    vec3 halfwayDir = normalize(lightDir + viewDir);
+    vec3 halfwayDir = normalize(lightDir + tangentViewDir);
    float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
    vec3 finalSpecular = specularAmount * dirLight.specularColor * specularTexColor.rgb;

@ -168,9 +253,9 @@ vec3 CalcDirLight()
    return (finalDiffuse + finalSpecular) * (1 - shadow);
 }

-float CalcPointShadow(int lightIndex, vec3 lightPos, vec3 lightDir, float farPlane) {
+float CalcPointShadow(int lightIndex, vec3 worldLightPos, vec3 tangentLightDir, float farPlane) {

-    vec3 lightToFrag = fragPos - lightPos;
+    vec3 lightToFrag = fragPos - worldLightPos;

    float closestDepth = texture(pointLightCubeShadowMaps, vec4(lightToFrag, lightIndex)).r;

@ -180,7 +265,8 @@ float CalcPointShadow(int lightIndex, vec3 lightPos, vec3 lightDir, float farPla
    // Get depth of current fragment
    float currentDepth = length(lightToFrag);

-    float bias = max(0.05 * (1 - dot(normalizedVertNorm, lightDir)), 0.005);
+    float bias = max(0.05 * (1 - dot(normalizedVertNorm, tangentLightDir)), 0.005);
+
    float shadow = currentDepth -  bias > closestDepth ? 1.0 : 0.0;

    return shadow;
@ -193,28 +279,29 @@ vec3 CalcPointLight(PointLight pointLight, int lightIndex)
        return vec3(0);
    }

-    vec3 lightDir = normalize(pointLight.pos - fragPos);
+    vec3 tangentLightPos = tangentPointLightPositions[lightIndex];
+    vec3 tangentLightDir = normalize(tangentLightPos - tangentFragPos);

    // Diffuse
-    float diffuseAmount = max(0.0, dot(normalizedVertNorm, lightDir));
+    float diffuseAmount = max(0.0, dot(normalizedVertNorm, tangentLightDir));
    vec3 finalDiffuse = diffuseAmount * pointLight.diffuseColor * diffuseTexColor.rgb;

    // Specular
-    vec3 halfwayDir = normalize(lightDir + viewDir);
+    vec3 halfwayDir = normalize(tangentLightDir + tangentViewDir);
    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 distToLight = length(tangentLightPos - tangentFragPos);
    float attenuation = 1 / (pointLight.constant + pointLight.linear * distToLight + pointLight.quadratic * (distToLight * distToLight));  

    // Shadow
-    float shadow = CalcPointShadow(lightIndex, pointLight.pos, lightDir, pointLight.farPlane);
+    float shadow = CalcPointShadow(lightIndex, pointLight.pos, tangentLightDir, pointLight.farPlane);

    return (finalDiffuse + finalSpecular) * attenuation * (1 - shadow);
 }

-float CalcSpotShadow(vec3 lightDir, int lightIndex)
+float CalcSpotShadow(vec3 tangentLightDir, int lightIndex)
 {
    // Move from clip space to NDC
    vec3 projCoords = fragPosSpotLight[lightIndex].xyz / fragPosSpotLight[lightIndex].w;
@ -231,7 +318,7 @@ float CalcSpotShadow(vec3 lightDir, int lightIndex)

    // 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);
+    float bias = max(0.05 * (1 - dot(normalizedVertNorm, tangentLightDir)), 0.005);

    // 'Percentage Close Filtering'.
    // Basically get soft shadows by averaging this texel and surrounding ones
@ -259,12 +346,13 @@ vec3 CalcSpotLight(SpotLight light, int lightIndex)
    if (light.innerCutoff == 0)
        return vec3(0);

-    vec3 fragToLightDir = normalize(light.pos - fragPos);
+    vec3 tangentLightDir = tangentSpotLightDirections[lightIndex];
+    vec3 fragToLightDir = normalize(tangentSpotLightPositions[lightIndex] - tangentFragPos);

    // 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 theta = dot(fragToLightDir, normalize(-tangentLightDir));
    float epsilon = (light.innerCutoff - light.outerCutoff);
    float intensity = clamp((theta - light.outerCutoff) / epsilon, float(0), float(1));

@ -276,7 +364,7 @@ vec3 CalcSpotLight(SpotLight light, int lightIndex)
    vec3 finalDiffuse = diffuseAmount * light.diffuseColor * diffuseTexColor.rgb;

    // Specular
-    vec3 halfwayDir = normalize(fragToLightDir + viewDir);
+    vec3 halfwayDir = normalize(fragToLightDir + tangentViewDir);
    float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
    vec3 finalSpecular = specularAmount * light.specularColor * specularTexColor.rgb;

@ -286,15 +374,21 @@ vec3 CalcSpotLight(SpotLight light, int lightIndex)
    return (finalDiffuse + finalSpecular) * intensity * (1 - shadow);
 }

+#define DRAW_NORMALS false
+
 void main()
 {
    // Shared values
+    tangentViewDir = normalize(tangentCamPos - tangentFragPos);
    diffuseTexColor = texture(material.diffuse, vertUV0);
    specularTexColor = texture(material.specular, vertUV0);
    emissionTexColor = texture(material.emission, vertUV0);

-    normalizedVertNorm = normalize(vertNormal);
-    viewDir = normalize(camPos - fragPos);
+    // Read normal data encoded [0,1]
+    normalizedVertNorm = texture(material.normal, vertUV0).rgb;
+
+    // Remap normal to [-1,1]
+    normalizedVertNorm = normalize(normalizedVertNorm * 2.0 - 1.0);

    // Light contributions
    vec3 finalColor = CalcDirLight();
@ -313,4 +407,9 @@ void main()
    vec3 finalAmbient = ambientColor * diffuseTexColor.rgb;

    fragColor = vec4(finalColor + finalAmbient + finalEmission, 1);
+
+    if (DRAW_NORMALS)
+    {
+        fragColor = vec4(texture(material.normal, vertUV0).rgb, 1);
+    }
 }
--- a/res/shaders/skybox.glsl
+++ b/res/shaders/skybox.glsl
@ -3,8 +3,9 @@

 layout(location=0) in vec3 vertPosIn;
 layout(location=1) in vec3 vertNormalIn;
-layout(location=2) in vec2 vertUV0In;
-layout(location=3) in vec3 vertColorIn;
+layout(location=2) in vec3 vertTangentIn;
+layout(location=3) in vec2 vertUV0In;
+layout(location=4) in vec3 vertColorIn;

 out vec3 vertUV0;

--- a/res/shaders/tonemapped-screen-quad.glsl
+++ b/res/shaders/tonemapped-screen-quad.glsl
@ -0,0 +1,50 @@
+//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)
+);
+
+void main()
+{
+    vec4 vertData = quadData[gl_VertexID];
+
+    vertUV0 = vertData.zw;
+    gl_Position = vec4(vertData.xy, 0.0, 1.0);
+}
+
+//shader:fragment
+#version 410
+
+struct Material {
+    sampler2D diffuse;
+};
+
+uniform float exposure = 1;
+uniform Material material;
+
+in vec2 vertUV0;
+
+out vec4 fragColor;
+
+void main()
+{
+    vec4 diffuseTexColor = texture(material.diffuse, vertUV0);
+
+    // Reinhard tone mapping
+    // vec3 mappedColor = diffuseTexColor.rgb / (diffuseTexColor.rgb + vec3(1.0));
+
+    // Exposure tone mapping
+    vec3 mappedColor = vec3(1.0) - exp(-diffuseTexColor.rgb * exposure);
+
+    fragColor = vec4(mappedColor, 1);
+}
--- a/res/textures/black.png
+++ b/res/textures/black.png
--- a/res/textures/brickwall-normal.png
+++ b/res/textures/brickwall-normal.png
--- a/res/textures/brickwall.png
+++ b/res/textures/brickwall.png
--- a/res/textures/white.png
+++ b/res/textures/white.png
Author	SHA1	Message	Date
bloeys	cf6b2655e7	After all why not, why shouldn't we have HDR	2024-05-12 06:46:46 +04:00
bloeys	7b1e3ea7b4	Default textures for diffuse/specular/normal/emission mat slots	2024-05-11 05:11:54 +04:00
bloeys	c884d2624d	Normal mapping	2024-05-07 05:23:36 +04:00
bloeys	8c6b1d5821	Adjust shadow map texture sizes	2024-05-06 23:23:52 +04:00
bloeys	dfd1fe9c5e	Material settings+normal matrices on CPU	2024-05-06 22:55:57 +04:00
bloeys	24613823a7	Fix gitignore	2024-05-06 22:18:15 +04:00
bloeys	0386f441d6	Profiling	2024-05-06 22:16:20 +04:00
bloeys	57ab851534	Update gglm	2024-05-05 00:34:38 +04:00