Captured/uncaptured mode in input package+comments

assets/textures.go

@@ -19,7 +19,8 @@ import (
 type ColorFormat int
 
 const (
-	ColorFormat_RGBA8 ColorFormat = iota
+	ColorFormat_Unknown ColorFormat = iota
+	ColorFormat_RGBA8
 )
 
 type Texture struct {

buffers/buf_usage.go

@@ -10,8 +10,10 @@ import (
 type BufUsage int
 
 const (
+	BufUsage_Unknown BufUsage = iota
+
 	//Buffer is set only once and used many times
-	BufUsage_Static BufUsage = iota
+	BufUsage_Static
 	//Buffer is changed a lot and used many times
 	BufUsage_Dynamic
 	//Buffer is set only once and used by the GPU at most a few times

buffers/framebuffer.go

@@ -1,6 +1,7 @@
 package buffers
 
 import (
+	"github.com/bloeys/nmage/assert"
 	"github.com/bloeys/nmage/logging"
 	"github.com/go-gl/gl/v4.1-core/gl"
 )
@@ -10,7 +11,10 @@ type FramebufferAttachmentType int32
 const (
 	FramebufferAttachmentType_Unknown FramebufferAttachmentType = iota
 	FramebufferAttachmentType_Texture
+	FramebufferAttachmentType_Texture_Array
 	FramebufferAttachmentType_Renderbuffer
+	FramebufferAttachmentType_Cubemap
+	FramebufferAttachmentType_Cubemap_Array
 )
 
 func (f FramebufferAttachmentType) IsValid() bool {
@@ -18,7 +22,13 @@ func (f FramebufferAttachmentType) IsValid() bool {
 	switch f {
 	case FramebufferAttachmentType_Texture:
 		fallthrough
+	case FramebufferAttachmentType_Texture_Array:
+		fallthrough
 	case FramebufferAttachmentType_Renderbuffer:
+		fallthrough
+	case FramebufferAttachmentType_Cubemap:
+		fallthrough
+	case FramebufferAttachmentType_Cubemap_Array:
 		return true
 
 	default:
@@ -169,6 +179,14 @@ func (fbo *Framebuffer) NewColorAttachment(
 		logging.ErrLog.Fatalf("failed creating color attachment for framebuffer due to unknown attachment type. Type=%d\n", attachType)
 	}
 
+	if attachType == FramebufferAttachmentType_Cubemap || attachType == FramebufferAttachmentType_Cubemap_Array {
+		logging.ErrLog.Fatalf("failed creating color attachment because cubemaps can not be color attachments (at least in this implementation. You might be able to do it manually)\n")
+	}
+
+	if attachType == FramebufferAttachmentType_Texture_Array {
+		logging.ErrLog.Fatalf("failed creating color attachment because texture arrays can not be color attachments (implementation can be updated to support it or you can do it manually)\n")
+	}
+
 	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)
 	}
@@ -256,6 +274,14 @@ func (fbo *Framebuffer) NewDepthAttachment(
 		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)
 	}
 
+	if attachType == FramebufferAttachmentType_Cubemap_Array {
+		logging.ErrLog.Fatalf("failed creating cubemap array depth attachment because 'NewDepthCubemapArrayAttachment' must be used for that\n")
+	}
+
+	if attachType == FramebufferAttachmentType_Texture_Array {
+		logging.ErrLog.Fatalf("failed creating texture array depth attachment because 'NewDepthTextureArrayAttachment' must be used for that\n")
+	}
+
 	a := FramebufferAttachment{
 		Type:   attachType,
 		Format: attachFormat,
@@ -304,6 +330,30 @@ func (fbo *Framebuffer) NewDepthAttachment(
 
 		// Attach to fbo
 		gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, a.Id)
+
+	} else if attachType == FramebufferAttachmentType_Cubemap {
+
+		// Create cubemap
+		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_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.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+		gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+		gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
+		gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
+		gl.TexParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
+
+		gl.BindTexture(gl.TEXTURE_2D, 0)
+
+		// Attach to fbo
+		gl.FramebufferTexture(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, a.Id, 0)
 	}
 
 	fbo.UnBind()
@@ -311,6 +361,125 @@ func (fbo *Framebuffer) NewDepthAttachment(
 	fbo.Attachments = append(fbo.Attachments, a)
 }
 
+func (fbo *Framebuffer) NewDepthCubemapArrayAttachment(
+	attachFormat FramebufferAttachmentDataFormat,
+	numCubemaps int32,
+) {
+
+	if fbo.HasDepthAttachment() {
+		logging.ErrLog.Fatalf("failed creating cubemap array depth attachment for framebuffer because a depth attachment already exists\n")
+	}
+
+	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:   FramebufferAttachmentType_Cubemap_Array,
+		Format: attachFormat,
+	}
+
+	fbo.Bind()
+
+	// Create cubemap array
+	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_CUBE_MAP_ARRAY, a.Id)
+
+	gl.TexImage3D(
+		gl.TEXTURE_CUBE_MAP_ARRAY,
+		0,
+		attachFormat.GlInternalFormat(),
+		int32(fbo.Width),
+		int32(fbo.Height),
+		6*numCubemaps,
+		0,
+		attachFormat.GlFormat(),
+		gl.FLOAT,
+		nil,
+	)
+
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
+	gl.TexParameteri(gl.TEXTURE_CUBE_MAP_ARRAY, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
+
+	gl.BindTexture(gl.TEXTURE_2D, 0)
+
+	// Attach to fbo
+	gl.FramebufferTexture(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, a.Id, 0)
+
+	fbo.UnBind()
+	fbo.ClearFlags |= gl.DEPTH_BUFFER_BIT
+	fbo.Attachments = append(fbo.Attachments, a)
+}
+
+func (fbo *Framebuffer) NewDepthTextureArrayAttachment(
+	attachFormat FramebufferAttachmentDataFormat,
+	numTextures int32,
+) {
+
+	if fbo.HasDepthAttachment() {
+		logging.ErrLog.Fatalf("failed creating texture array depth attachment for framebuffer because a depth attachment already exists\n")
+	}
+
+	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:   FramebufferAttachmentType_Texture_Array,
+		Format: attachFormat,
+	}
+
+	fbo.Bind()
+
+	// Create cubemap array
+	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_ARRAY, a.Id)
+
+	gl.TexImage3D(
+		gl.TEXTURE_2D_ARRAY,
+		0,
+		attachFormat.GlInternalFormat(),
+		int32(fbo.Width),
+		int32(fbo.Height),
+		numTextures,
+		0,
+		attachFormat.GlFormat(),
+		gl.FLOAT,
+		nil,
+	)
+
+	gl.TexParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+	gl.TexParameteri(gl.TEXTURE_2D_ARRAY, 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_ARRAY, gl.TEXTURE_BORDER_COLOR, &borderColor[0])
+	gl.TexParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_BORDER)
+	gl.TexParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_BORDER)
+
+	gl.BindTexture(gl.TEXTURE_2D_ARRAY, 0)
+
+	// Attach to fbo
+	gl.FramebufferTexture(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, a.Id, 0)
+
+	fbo.UnBind()
+	fbo.ClearFlags |= gl.DEPTH_BUFFER_BIT
+	fbo.Attachments = append(fbo.Attachments, a)
+}
+
 func (fbo *Framebuffer) NewDepthStencilAttachment(
 	attachType FramebufferAttachmentType,
 	attachFormat FramebufferAttachmentDataFormat,
@@ -374,6 +543,28 @@ func (fbo *Framebuffer) NewDepthStencilAttachment(
 	fbo.Attachments = append(fbo.Attachments, a)
 }
 
+// SetCubemapArrayLayerFace 'binds' a single face of a cubemap from the cubemap
+// array to the fbo, such that rendering only affects that one face and the others inaccessible.
+//
+// If this is not called, the default is that the entire cubemap array and all the faces in it
+// are bound and available for use when binding the fbo.
+func (fbo *Framebuffer) SetCubemapArrayLayerFace(layerFace int32) {
+
+	for i := 0; i < len(fbo.Attachments); i++ {
+
+		a := &fbo.Attachments[i]
+		if a.Type != FramebufferAttachmentType_Cubemap_Array {
+			continue
+		}
+
+		assert.T(a.Format.IsDepthFormat(), "SetCubemapFromArray called but a cubemap array is set on a color attachment, which is not currently handled. Code must be updated!")
+		gl.FramebufferTextureLayer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, a.Id, 0, layerFace)
+		return
+	}
+
+	logging.ErrLog.Fatalf("SetCubemapFromArray failed because no cubemap array attachment was found on fbo. Fbo=%+v\n", *fbo)
+}
+
 func (fbo *Framebuffer) Delete() {
 
 	if fbo.Id == 0 {

engine/engine.go

@@ -33,25 +33,12 @@ 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()
-	}
+	input.EventLoopStart(imguiCaptureMouse, imguiCaptureKeyboard)
 
 	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
 
@@ -65,18 +52,12 @@ func (w *Window) handleInputs() {
 
 		case *sdl.MouseWheelEvent:
 
-			if !imguiCaptureMouse {
-				input.HandleMouseWheelEvent(e)
-			}
-
+			input.HandleMouseWheelEvent(e)
 			imIo.AddMouseWheelDelta(float32(e.X), float32(e.Y))
 
 		case *sdl.KeyboardEvent:
 
-			if !imguiCaptureKeyboard {
-				input.HandleKeyboardEvent(e)
-			}
-
+			input.HandleKeyboardEvent(e)
 			imIo.AddKeyEvent(nmageimgui.SdlScancodeToImGuiKey(e.Keysym.Scancode), e.Type == sdl.KEYDOWN)
 
 			// Send modifier key updates to imgui
@@ -101,10 +82,7 @@ func (w *Window) handleInputs() {
 
 		case *sdl.MouseButtonEvent:
 
-			if !imguiCaptureMouse {
-				input.HandleMouseBtnEvent(e)
-			}
-
+			input.HandleMouseBtnEvent(e)
 			isPressed := e.State == sdl.PRESSED
 
 			if e.Button == sdl.BUTTON_LEFT {
@@ -117,9 +95,7 @@ func (w *Window) handleInputs() {
 
 		case *sdl.MouseMotionEvent:
 
-			if !imguiCaptureMouse {
-				input.HandleMouseMotionEvent(e)
-			}
+			input.HandleMouseMotionEvent(e)
 
 		case *sdl.WindowEvent:
 
@@ -217,6 +193,7 @@ func createWindow(title string, x, y, width, height int32, flags WindowFlags, re
 	if err != nil {
 		return nil, err
 	}
+
 	win := &Window{
 		SDLWin:         sdlWin,
 		EventCallbacks: make([]func(sdl.Event), 0),
@@ -233,6 +210,10 @@ func createWindow(title string, x, y, width, height int32, flags WindowFlags, re
 		return nil, err
 	}
 
+	// 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)
+	sdlWin.GLSwap()
+
 	return win, err
 }
 
@@ -254,6 +235,7 @@ func initOpenGL() error {
 	gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
 
 	gl.ClearColor(0, 0, 0, 1)
+
 	return nil
 }
 

input/input.go

@@ -1,6 +1,23 @@
+// The input package provides an interface to mouse and keyboard inputs
+// like key clicks and releases, along with some higher level constructs like
+// pressed/released this frames, double clicks, and normalized inputs.
+//
+// The input package has two sets of functions for most cases, where one
+// is in the form 'xy' and the other 'xyCaptured'. The captured form
+// always returns normal events even if the mouse or keyboard are captured
+// by the UI system. The 'xy' form however will return zero/false if the
+// respective input device is currently captured (with the exception of mouse position, that is always correctly returned).
+//
+// For most cases, you want to use the 'xy' form. For example, you only want to receive
+// key down events for game character movement when the UI isn't capturing the keyboard,
+// because otherwise the character will move while typing in a UI textbox.
+//
+// The functions IsMouseCaptured and IsKeyboardCaptured are also available.
 package input
 
-import "github.com/veandco/go-sdl2/sdl"
+import (
+	"github.com/veandco/go-sdl2/sdl"
+)
 
 type keyState struct {
 	Key                 sdl.Keycode
@@ -31,15 +48,22 @@ type mouseWheelState struct {
 }
 
 var (
-	keyMap        = make(map[sdl.Keycode]keyState)
-	mouseBtnMap   = make(map[int]mouseBtnState)
-	mouseMotion   = mouseMotionState{}
-	mouseWheel    = mouseWheelState{}
-	quitRequested bool
+	mouseWheel  = mouseWheelState{}
+	mouseMotion = mouseMotionState{}
+	mouseBtnMap = make(map[int]mouseBtnState)
+	keyMap      = make(map[sdl.Keycode]keyState)
+
+	isQuitRequested    bool
+	isMouseCaptured    bool
+	isKeyboardCaptured bool
 )
 
-func EventLoopStart() {
+func EventLoopStart(mouseGotCaptured, keyboardGotCaptured bool) {
 
+	isMouseCaptured = mouseGotCaptured
+	isKeyboardCaptured = keyboardGotCaptured
+
+	// Update per-frame state
 	for k, v := range keyMap {
 		v.IsPressedThisFrame = false
 		v.IsReleasedThisFrame = false
@@ -59,7 +83,7 @@ func EventLoopStart() {
 	mouseWheel.XDelta = 0
 	mouseWheel.YDelta = 0
 
-	quitRequested = false
+	isQuitRequested = false
 }
 
 func ClearKeyboardState() {
@@ -73,11 +97,19 @@ func ClearMouseState() {
 }
 
 func HandleQuitEvent(e *sdl.QuitEvent) {
-	quitRequested = true
+	isQuitRequested = true
+}
+
+func IsMouseCaptured() bool {
+	return isMouseCaptured
+}
+
+func IsKeyboardCaptured() bool {
+	return isKeyboardCaptured
 }
 
 func IsQuitClicked() bool {
-	return quitRequested
+	return isQuitRequested
 }
 
 func HandleKeyboardEvent(e *sdl.KeyboardEvent) {
@@ -123,18 +155,36 @@ 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 regardless of whether the mouse is captured or not
 func GetMousePos() (x, y int32) {
 	return mouseMotion.XPos, mouseMotion.YPos
 }
 
 // GetMouseMotion returns how many pixels were moved last frame
 func GetMouseMotion() (xDelta, yDelta int32) {
+
+	if isMouseCaptured {
+		return 0, 0
+	}
+
+	return GetMouseMotionCaptured()
+}
+
+func GetMouseMotionCaptured() (xDelta, yDelta int32) {
 	return mouseMotion.XDelta, mouseMotion.YDelta
 }
 
 func GetMouseMotionNorm() (xDelta, yDelta int32) {
 
+	if isMouseCaptured {
+		return 0, 0
+	}
+
+	return GetMouseMotionNormCaptured()
+}
+
+func GetMouseMotionNormCaptured() (xDelta, yDelta int32) {
+
 	x, y := mouseMotion.XDelta, mouseMotion.YDelta
 	if x > 0 {
 		x = 1
@@ -152,12 +202,31 @@ func GetMouseMotionNorm() (xDelta, yDelta int32) {
 }
 
 func GetMouseWheelMotion() (xDelta, yDelta int32) {
+
+	if isMouseCaptured {
+		return 0, 0
+	}
+
+	return GetMouseWheelMotionCaptured()
+}
+
+func GetMouseWheelMotionCaptured() (xDelta, yDelta int32) {
 	return mouseWheel.XDelta, mouseWheel.YDelta
 }
 
 // GetMouseWheelXNorm returns 1 if mouse wheel xDelta > 0, -1 if xDelta < 0, and 0 otherwise
 func GetMouseWheelXNorm() int32 {
 
+	if isMouseCaptured {
+		return 0
+	}
+
+	return GetMouseWheelXNormCaptured()
+}
+
+// GetMouseWheelXNormCaptured returns 1 if mouse wheel xDelta > 0, -1 if xDelta < 0, and 0 otherwise
+func GetMouseWheelXNormCaptured() int32 {
+
 	if mouseWheel.XDelta > 0 {
 		return 1
 	} else if mouseWheel.XDelta < 0 {
@@ -167,9 +236,19 @@ func GetMouseWheelXNorm() int32 {
 	return 0
 }
 
-// returns 1 if mouse wheel yDelta > 0, -1 if yDelta < 0, and 0 otherwise
+// GetMouseWheelYNorm returns 1 if mouse wheel yDelta > 0, -1 if yDelta < 0, and 0 otherwise
 func GetMouseWheelYNorm() int32 {
 
+	if isMouseCaptured {
+		return 0
+	}
+
+	return GetMouseWheelYNormCaptured()
+}
+
+// GetMouseWheelYNormCaptured returns 1 if mouse wheel yDelta > 0, -1 if yDelta < 0, and 0 otherwise
+func GetMouseWheelYNormCaptured() int32 {
+
 	if mouseWheel.YDelta > 0 {
 		return 1
 	} else if mouseWheel.YDelta < 0 {
@@ -181,6 +260,15 @@ func GetMouseWheelYNorm() int32 {
 
 func KeyClicked(kc sdl.Keycode) bool {
 
+	if isKeyboardCaptured {
+		return false
+	}
+
+	return KeyClickedCaptured(kc)
+}
+
+func KeyClickedCaptured(kc sdl.Keycode) bool {
+
 	ks, ok := keyMap[kc]
 	if !ok {
 		return false
@@ -191,6 +279,15 @@ func KeyClicked(kc sdl.Keycode) bool {
 
 func KeyReleased(kc sdl.Keycode) bool {
 
+	if isKeyboardCaptured {
+		return false
+	}
+
+	return KeyReleasedCaptured(kc)
+}
+
+func KeyReleasedCaptured(kc sdl.Keycode) bool {
+
 	ks, ok := keyMap[kc]
 	if !ok {
 		return false
@@ -201,6 +298,15 @@ func KeyReleased(kc sdl.Keycode) bool {
 
 func KeyDown(kc sdl.Keycode) bool {
 
+	if isKeyboardCaptured {
+		return false
+	}
+
+	return KeyDownCaptured(kc)
+}
+
+func KeyDownCaptured(kc sdl.Keycode) bool {
+
 	ks, ok := keyMap[kc]
 	if !ok {
 		return false
@@ -211,6 +317,15 @@ func KeyDown(kc sdl.Keycode) bool {
 
 func KeyUp(kc sdl.Keycode) bool {
 
+	if isKeyboardCaptured {
+		return false
+	}
+
+	return KeyUpCaptured(kc)
+}
+
+func KeyUpCaptured(kc sdl.Keycode) bool {
+
 	ks, ok := keyMap[kc]
 	if !ok {
 		return true
@@ -221,6 +336,15 @@ func KeyUp(kc sdl.Keycode) bool {
 
 func MouseClicked(mb int) bool {
 
+	if isMouseCaptured {
+		return false
+	}
+
+	return MouseClickedCaptued(mb)
+}
+
+func MouseClickedCaptued(mb int) bool {
+
 	btn, ok := mouseBtnMap[mb]
 	if !ok {
 		return false
@@ -231,6 +355,15 @@ func MouseClicked(mb int) bool {
 
 func MouseDoubleClicked(mb int) bool {
 
+	if isMouseCaptured {
+		return false
+	}
+
+	return MouseDoubleClickedCaptured(mb)
+}
+
+func MouseDoubleClickedCaptured(mb int) bool {
+
 	btn, ok := mouseBtnMap[mb]
 	if !ok {
 		return false
@@ -240,6 +373,16 @@ func MouseDoubleClicked(mb int) bool {
 }
 
 func MouseReleased(mb int) bool {
+
+	if isMouseCaptured {
+		return false
+	}
+
+	return MouseReleasedCaptured(mb)
+}
+
+func MouseReleasedCaptured(mb int) bool {
+
 	btn, ok := mouseBtnMap[mb]
 	if !ok {
 		return false
@@ -250,6 +393,15 @@ func MouseReleased(mb int) bool {
 
 func MouseDown(mb int) bool {
 
+	if isMouseCaptured {
+		return false
+	}
+
+	return MouseDownCaptued(mb)
+}
+
+func MouseDownCaptued(mb int) bool {
+
 	btn, ok := mouseBtnMap[mb]
 	if !ok {
 		return false
@@ -260,6 +412,15 @@ func MouseDown(mb int) bool {
 
 func MouseUp(mb int) bool {
 
+	if isMouseCaptured {
+		return false
+	}
+
+	return MouseUpCaptured(mb)
+}
+
+func MouseUpCaptured(mb int) bool {
+
 	btn, ok := mouseBtnMap[mb]
 	if !ok {
 		return true

main.go

@@ -30,9 +30,14 @@ import (
 		- Directional lights ✅
 		- Point lights ✅
 		- Spotlights ✅
+		- Directional light shadows ✅
+		- Point light shadows ✅
+		- Spotlight shadows ✅
+		- 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
 	- Proper model loading (i.e. load model by reading all its meshes, textures, and so on together)
 	- Create VAO struct independent from VBO to support multi-VBO use cases (e.g. instancing) ✅
 	- Renderer batching
@@ -67,7 +72,7 @@ func (d *DirLight) GetProjViewMat() gglm.Mat4 {
 	farClip := dirLightFar
 
 	projMat := gglm.Ortho(-size, size, -size, size, nearClip, farClip).Mat4
-	viewMat := gglm.LookAtRH(pos, pos.Clone().Add(d.Dir.Clone().Scale(10)), gglm.NewVec3(0, 1, 0)).Mat4
+	viewMat := gglm.LookAtRH(pos, pos.Clone().Add(&d.Dir), gglm.NewVec3(0, 1, 0)).Mat4
 
 	return *projMat.Mul(&viewMat)
 }
@@ -78,32 +83,81 @@ type PointLight struct {
 	DiffuseColor  gglm.Vec3
 	SpecularColor gglm.Vec3
 
+	// @TODO
 	Radius float32
 
 	Constant  float32
 	Linear    float32
 	Quadratic float32
+
+	FarPlane float32
+}
+
+const (
+	MaxPointLights = 8
+
+	// If this changes update the array depth map shader
+	MaxSpotLights = 4
+)
+
+var (
+	pointLightNear float32 = 1
+)
+
+func (p *PointLight) GetProjViewMats(shadowMapWidth, shadowMapHeight float32) [6]gglm.Mat4 {
+
+	aspect := float32(shadowMapWidth) / float32(shadowMapHeight)
+	projMat := gglm.Perspective(90*gglm.Deg2Rad, aspect, pointLightNear, p.FarPlane)
+
+	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),
+	}
+
+	return projViewMats
 }
 
 type SpotLight struct {
-	Pos           gglm.Vec3
-	Dir           gglm.Vec3
-	DiffuseColor  gglm.Vec3
-	SpecularColor gglm.Vec3
-	InnerCutoff   float32
-	OuterCutoff   float32
+	Pos            gglm.Vec3
+	Dir            gglm.Vec3
+	DiffuseColor   gglm.Vec3
+	SpecularColor  gglm.Vec3
+	InnerCutoffRad float32
+	OuterCutoffRad float32
+
+	// Near plane like 0.x (or anything too small) causes shadows to not work properly.
+	// Needs adjusting as the distance of light to object increases
+	NearPlane float32
+
+	FarPlane float32
 }
 
-// SetCutoffs properly sets the cosine values of the cutoffs using the passed
-// degrees.
-//
-// The light has full intensity within the inner cutoff, falloff between
-// inner-outer cutoff, and zero light beyond the outer cutoff.
-//
-// The inner cuttoff degree must be *smaller* than the outer cutoff
-func (s *SpotLight) SetCutoffs(innerCutoffAngleDeg, outerCutoffAngleDeg float32) {
-	s.InnerCutoff = gglm.Cos32(innerCutoffAngleDeg * gglm.Deg2Rad)
-	s.OuterCutoff = gglm.Cos32(outerCutoffAngleDeg * gglm.Deg2Rad)
+func (s *SpotLight) GetProjViewMat() gglm.Mat4 {
+
+	projMat := gglm.Perspective(s.OuterCutoffRad*2, 1, s.NearPlane, s.FarPlane)
+
+	// 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 {
+		up.SetXY(1, 0)
+	}
+
+	viewMat := gglm.LookAtRH(&s.Pos, s.Pos.Clone().Add(&s.Dir), up).Mat4
+
+	return *projMat.Mul(&viewMat)
+}
+
+func (s *SpotLight) InnerCutoffCos() float32 {
+	return gglm.Cos32(s.InnerCutoffRad)
+}
+
+func (s *SpotLight) OuterCutoffCos() float32 {
+	return gglm.Cos32(s.OuterCutoffRad)
 }
 
 const (
@@ -121,27 +175,37 @@ var (
 	yaw   float32 = -1.5
 	cam   *camera.Camera
 
-	renderToDemoFbo    = true
+	// Demo fbo
+	renderToDemoFbo    = false
 	renderToBackBuffer = true
 	demoFboScale       = gglm.NewVec2(0.25, 0.25)
 	demoFboOffset      = gglm.NewVec2(0.75, -0.75)
 	demoFbo            buffers.Framebuffer
 
-	renderToDepthMapFbo = true
-	depthMapFboScale    = gglm.NewVec2(0.25, 0.25)
-	depthMapFboOffset   = gglm.NewVec2(0.75, -0.2)
-	depthMapFbo         buffers.Framebuffer
+	// Dir light fbo
+	showDirLightDepthMapFbo   = false
+	dirLightDepthMapFboScale  = gglm.NewVec2(0.25, 0.25)
+	dirLightDepthMapFboOffset = gglm.NewVec2(0.75, -0.2)
+	dirLightDepthMapFbo       buffers.Framebuffer
+
+	// Point light fbo
+	pointLightDepthMapFbo buffers.Framebuffer
+
+	// Spot light fbo
+	spotLightDepthMapFbo buffers.Framebuffer
 
 	screenQuadVao buffers.VertexArray
 	screenQuadMat *materials.Material
 
-	unlitMat      *materials.Material
-	whiteMat      *materials.Material
-	containerMat  *materials.Material
-	palleteMat    *materials.Material
-	skyboxMat     *materials.Material
-	depthMapMat   *materials.Material
-	debugDepthMat *materials.Material
+	unlitMat           *materials.Material
+	whiteMat           *materials.Material
+	containerMat       *materials.Material
+	palleteMat         *materials.Material
+	skyboxMat          *materials.Material
+	depthMapMat        *materials.Material
+	arrayDepthMapMat   *materials.Material
+	omnidirDepthMapMat *materials.Material
+	debugDepthMat      *materials.Material
 
 	cubeMesh   *meshes.Mesh
 	sphereMesh *meshes.Mesh
@@ -168,13 +232,15 @@ var (
 	}
 	pointLights = [...]PointLight{
 		{
-			Pos:           *gglm.NewVec3(0, 5, 0),
+			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,
 			Quadratic: 0.032,
+
+			FarPlane: 25,
 		},
 		{
 			Pos:           *gglm.NewVec3(0, -5, 0),
@@ -183,6 +249,7 @@ var (
 			Constant:      1.0,
 			Linear:        0.09,
 			Quadratic:     0.032,
+			FarPlane:      25,
 		},
 		{
 			Pos:           *gglm.NewVec3(5, 0, 0),
@@ -191,25 +258,30 @@ var (
 			Constant:      1.0,
 			Linear:        0.09,
 			Quadratic:     0.032,
+			FarPlane:      25,
 		},
 		{
-			Pos:           *gglm.NewVec3(-4, 0, 0),
-			DiffuseColor:  *gglm.NewVec3(0, 0, 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{
 		{
-			Pos:           *gglm.NewVec3(0, 5, 0),
-			Dir:           *gglm.NewVec3(0, -1, 0),
-			DiffuseColor:  *gglm.NewVec3(0, 1, 1),
+			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),
 			// These must be cosine values
-			InnerCutoff: gglm.Cos32(15 * gglm.Deg2Rad),
-			OuterCutoff: gglm.Cos32(20 * gglm.Deg2Rad),
+			InnerCutoffRad: 15 * gglm.Deg2Rad,
+			OuterCutoffRad: 20 * gglm.Deg2Rad,
+
+			NearPlane: 1,
+			FarPlane:  30,
 		},
 	}
 )
@@ -400,7 +472,9 @@ func (g *Game) Init() {
 	whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 	whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 	whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	whiteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap))
+	whiteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	whiteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
+	whiteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
 	containerMat = materials.NewMaterial("Container mat", "./res/shaders/simple.glsl")
 	containerMat.Shininess = 64
@@ -417,7 +491,9 @@ func (g *Game) Init() {
 	containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 	containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 	containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	containerMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap))
+	containerMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	containerMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
+	containerMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
 	palleteMat = materials.NewMaterial("Pallete mat", "./res/shaders/simple.glsl")
 	palleteMat.Shininess = 64
@@ -433,12 +509,18 @@ func (g *Game) Init() {
 	palleteMat.SetUnifFloat32("material.shininess", palleteMat.Shininess)
 	palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
 	palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
-	palleteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap))
+	palleteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1))
+	palleteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array))
+	palleteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1))
 
 	debugDepthMat = materials.NewMaterial("Debug depth mat", "./res/shaders/debug-depth.glsl")
 
 	depthMapMat = materials.NewMaterial("Depth Map mat", "./res/shaders/depth-map.glsl")
 
+	arrayDepthMapMat = materials.NewMaterial("Array Depth Map mat", "./res/shaders/array-depth-map.glsl")
+
+	omnidirDepthMapMat = materials.NewMaterial("Omnidirectional Depth Map mat", "./res/shaders/omnidirectional-depth-map.glsl")
+
 	skyboxMat = materials.NewMaterial("Skybox mat", "./res/shaders/skybox.glsl")
 	skyboxMat.CubemapTex = skyboxCmap.TexID
 	skyboxMat.SetUnifInt32("skybox", int32(materials.TextureSlot_Cubemap))
@@ -484,58 +566,89 @@ func (g *Game) initFbos() {
 	assert.T(demoFbo.IsComplete(), "Demo fbo is not complete after init")
 
 	// Depth map fbo
-	depthMapFbo = buffers.NewFramebuffer(1024, 1024)
-	depthMapFbo.SetNoColorBuffer()
-	depthMapFbo.NewDepthAttachment(
+	dirLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024)
+	dirLightDepthMapFbo.SetNoColorBuffer()
+	dirLightDepthMapFbo.NewDepthAttachment(
 		buffers.FramebufferAttachmentType_Texture,
 		buffers.FramebufferAttachmentDataFormat_DepthF32,
 	)
 
-	assert.T(depthMapFbo.IsComplete(), "Depth map fbo is not complete after init")
+	assert.T(dirLightDepthMapFbo.IsComplete(), "Depth map fbo is not complete after init")
+
+	// Point light depth map fbo
+	pointLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024)
+	pointLightDepthMapFbo.SetNoColorBuffer()
+	pointLightDepthMapFbo.NewDepthCubemapArrayAttachment(
+		buffers.FramebufferAttachmentDataFormat_DepthF32,
+		MaxPointLights,
+	)
+
+	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.SetNoColorBuffer()
+	spotLightDepthMapFbo.NewDepthTextureArrayAttachment(
+		buffers.FramebufferAttachmentDataFormat_DepthF32,
+		MaxSpotLights,
+	)
+
+	assert.T(spotLightDepthMapFbo.IsComplete(), "Spot light depth map fbo is not complete after init")
 }
 
 func (g *Game) updateLights() {
 
 	// Directional light
-	whiteMat.ShadowMap = depthMapFbo.Attachments[0].Id
-	containerMat.ShadowMap = depthMapFbo.Attachments[0].Id
-	palleteMat.ShadowMap = depthMapFbo.Attachments[0].Id
+	whiteMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
+	containerMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
+	palleteMat.ShadowMapTex1 = dirLightDepthMapFbo.Attachments[0].Id
 
 	// Point lights
 	for i := 0; i < len(pointLights); i++ {
 
-		pl := &pointLights[i]
+		p := &pointLights[i]
 		indexString := "pointLights[" + strconv.Itoa(i) + "]"
 
-		whiteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
-		containerMat.SetUnifVec3(indexString+".pos", &pl.Pos)
-		palleteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
+		whiteMat.SetUnifVec3(indexString+".pos", &p.Pos)
+		containerMat.SetUnifVec3(indexString+".pos", &p.Pos)
+		palleteMat.SetUnifVec3(indexString+".pos", &p.Pos)
 
-		whiteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
-		containerMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
-		palleteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+		whiteMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
+		containerMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
+		palleteMat.SetUnifVec3(indexString+".diffuseColor", &p.DiffuseColor)
 
-		whiteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
-		containerMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
-		palleteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+		whiteMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
+		containerMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
+		palleteMat.SetUnifVec3(indexString+".specularColor", &p.SpecularColor)
 
-		whiteMat.SetUnifFloat32(indexString+".constant", pl.Constant)
-		containerMat.SetUnifFloat32(indexString+".constant", pl.Constant)
-		palleteMat.SetUnifFloat32(indexString+".constant", pl.Constant)
+		whiteMat.SetUnifFloat32(indexString+".constant", p.Constant)
+		containerMat.SetUnifFloat32(indexString+".constant", p.Constant)
+		palleteMat.SetUnifFloat32(indexString+".constant", p.Constant)
 
-		whiteMat.SetUnifFloat32(indexString+".linear", pl.Linear)
-		containerMat.SetUnifFloat32(indexString+".linear", pl.Linear)
-		palleteMat.SetUnifFloat32(indexString+".linear", pl.Linear)
+		whiteMat.SetUnifFloat32(indexString+".linear", p.Linear)
+		containerMat.SetUnifFloat32(indexString+".linear", p.Linear)
+		palleteMat.SetUnifFloat32(indexString+".linear", p.Linear)
 
-		whiteMat.SetUnifFloat32(indexString+".quadratic", pl.Quadratic)
-		containerMat.SetUnifFloat32(indexString+".quadratic", pl.Quadratic)
-		palleteMat.SetUnifFloat32(indexString+".quadratic", pl.Quadratic)
+		whiteMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
+		containerMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
+		palleteMat.SetUnifFloat32(indexString+".quadratic", p.Quadratic)
+
+		whiteMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
+		containerMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
+		palleteMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane)
 	}
 
+	whiteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
+	containerMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
+	palleteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id
+
 	// Spotlights
 	for i := 0; i < len(spotLights); i++ {
 
 		l := &spotLights[i]
+		innerCutoffCos := l.InnerCutoffCos()
+		outerCutoffCos := l.OuterCutoffCos()
+
 		indexString := "spotLights[" + strconv.Itoa(i) + "]"
 
 		whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
@@ -554,14 +667,18 @@ func (g *Game) updateLights() {
 		containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 		palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 
-		whiteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff)
-		containerMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff)
-		palleteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff)
+		whiteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
+		containerMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
+		palleteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos)
 
-		whiteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
-		containerMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
-		palleteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
+		whiteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
+		containerMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
+		palleteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos)
 	}
+
+	whiteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
+	containerMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
+	palleteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id
 }
 
 func (g *Game) Update() {
@@ -573,11 +690,6 @@ func (g *Game) Update() {
 	g.updateCameraLookAround()
 	g.updateCameraPos()
 
-	//Rotating cubes
-	if input.KeyDown(sdl.K_SPACE) {
-		cubeModelMat.Rotate(10*timing.DT()*gglm.Deg2Rad, gglm.NewVec3(1, 1, 1).Normalize())
-	}
-
 	g.showDebugWindow()
 
 	if input.KeyClicked(sdl.K_F4) {
@@ -620,6 +732,8 @@ func (g *Game) showDebugWindow() {
 	// Directional light
 	imgui.Text("Directional Light")
 
+	imgui.Checkbox("Render Directional Light Shadows", &renderDirLightShadows)
+
 	if imgui.DragFloat3("Direction", &dirLight.Dir.Data) {
 		whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
 		containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
@@ -657,6 +771,7 @@ func (g *Game) showDebugWindow() {
 	imgui.Spacing()
 
 	// Point lights
+	imgui.Checkbox("Render Point Light Shadows", &renderPointLightShadows)
 	if imgui.BeginListBoxV("Point Lights", imgui.Vec2{Y: 200}) {
 
 		for i := 0; i < len(pointLights); i++ {
@@ -695,6 +810,8 @@ func (g *Game) showDebugWindow() {
 	}
 
 	// Spot lights
+	imgui.Checkbox("Render Spot Light Shadows", &renderSpotLightShadows)
+
 	if imgui.BeginListBoxV("Spot Lights", imgui.Vec2{Y: 200}) {
 
 		for i := 0; i < len(spotLights); i++ {
@@ -732,18 +849,27 @@ func (g *Game) showDebugWindow() {
 				palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
 			}
 
-			if imgui.DragFloat("Inner Cutoff", &l.InnerCutoff) {
-				whiteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff)
-				containerMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff)
-				palleteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff)
+			if imgui.DragFloat("Inner Cutoff Radians", &l.InnerCutoffRad) {
+
+				cos := l.InnerCutoffCos()
+
+				whiteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
+				containerMat.SetUnifFloat32(indexString+".innerCutoff", cos)
+				palleteMat.SetUnifFloat32(indexString+".innerCutoff", cos)
 			}
 
-			if imgui.DragFloat("Outer Cutoff", &l.OuterCutoff) {
-				whiteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
-				containerMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
-				palleteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
+			if imgui.DragFloat("Outer Cutoff Radians", &l.OuterCutoffRad) {
+
+				cos := l.OuterCutoffCos()
+
+				whiteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
+				containerMat.SetUnifFloat32(indexString+".outerCutoff", cos)
+				palleteMat.SetUnifFloat32(indexString+".outerCutoff", cos)
 			}
 
+			imgui.DragFloat("Spot Near Plane", &l.NearPlane)
+			imgui.DragFloat("Spot Far Plane", &l.FarPlane)
+
 			imgui.TreePop()
 		}
 
@@ -752,15 +878,15 @@ func (g *Game) showDebugWindow() {
 
 	// Demo fbo
 	imgui.Text("Demo Framebuffer")
-	imgui.Checkbox("Render to demo FBO", &renderToDemoFbo)
+	imgui.Checkbox("Show FBO##0", &renderToDemoFbo)
 	imgui.DragFloat2("Scale##0", &demoFboScale.Data)
 	imgui.DragFloat2("Offset##0", &demoFboOffset.Data)
 
 	// Depth map fbo
-	imgui.Text("Depth Map Framebuffer")
-	imgui.Checkbox("Render to depth map FBO", &renderToDepthMapFbo)
-	imgui.DragFloat2("Scale##1", &depthMapFboScale.Data)
-	imgui.DragFloat2("Offset##1", &depthMapFboOffset.Data)
+	imgui.Text("Directional Light Depth Map Framebuffer")
+	imgui.Checkbox("Show FBO##1", &showDirLightDepthMapFbo)
+	imgui.DragFloat2("Scale##1", &dirLightDepthMapFboScale.Data)
+	imgui.DragFloat2("Offset##1", &dirLightDepthMapFboOffset.Data)
 
 	// Other
 	imgui.Text("Other Settings")
@@ -831,45 +957,39 @@ func (g *Game) updateCameraPos() {
 	}
 }
 
+var (
+	renderDirLightShadows   = true
+	renderPointLightShadows = true
+	renderSpotLightShadows  = true
+
+	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))
+)
+
 func (g *Game) Render() {
 
-	dirLightProjViewMat := dirLight.GetProjViewMat()
-
-	// Set some uniforms
 	whiteMat.SetUnifVec3("camPos", &cam.Pos)
-	whiteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
-
 	containerMat.SetUnifVec3("camPos", &cam.Pos)
-	containerMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
-
 	palleteMat.SetUnifVec3("camPos", &cam.Pos)
-	palleteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
 
-	depthMapMat.SetUnifMat4("projViewMat", &dirLightProjViewMat)
+	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))
 
-	//
-	// Render depth map for shadows
-	//
-	depthMapFbo.BindWithViewport()
-	depthMapFbo.Clear()
+	if renderDirLightShadows {
+		g.renderDirectionalLightShadowmap()
+	}
 
-	// Culling front faces helps 'peter panning' when
-	// drawing shadow maps, but works only for solids with a back face (i.e. quads won't cast shadows).
-	// Check more here: https://learnopengl.com/Advanced-Lighting/Shadows/Shadow-Mapping
-	//
-	// Some note that this is too troublesome and fails in many cases. Might be better to remove.
-	gl.CullFace(gl.FRONT)
-	g.RenderScene(depthMapMat)
-	gl.CullFace(gl.BACK)
+	if renderSpotLightShadows {
+		g.renderSpotLightShadowmaps()
+	}
 
-	depthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight))
-
-	if renderToDepthMapFbo {
-		screenQuadMat.DiffuseTex = depthMapFbo.Attachments[0].Id
-		screenQuadMat.SetUnifVec2("offset", depthMapFboOffset)
-		screenQuadMat.SetUnifVec2("scale", depthMapFboScale)
-		screenQuadMat.Bind()
-		window.Rend.DrawVertexArray(screenQuadMat, &screenQuadVao, 0, 6)
+	if renderPointLightShadows {
+		g.renderPointLightShadowmaps()
 	}
 
 	if renderToBackBuffer {
@@ -886,36 +1006,125 @@ func (g *Game) Render() {
 	}
 
 	if renderToDemoFbo {
+		g.renderDemoFob()
+	}
+}
 
-		demoFbo.Bind()
-		demoFbo.Clear()
+func (g *Game) renderDirectionalLightShadowmap() {
 
-		if renderDepthBuffer {
-			g.RenderScene(debugDepthMat)
-		} else {
-			g.RenderScene(nil)
-		}
+	// Set some uniforms
+	dirLightProjViewMat := dirLight.GetProjViewMat()
 
-		if renderSkybox {
-			g.DrawSkybox()
-		}
+	whiteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
+	containerMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
+	palleteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat)
 
-		demoFbo.UnBind()
+	depthMapMat.SetUnifMat4("projViewMat", &dirLightProjViewMat)
 
-		screenQuadMat.DiffuseTex = demoFbo.Attachments[0].Id
-		screenQuadMat.SetUnifVec2("offset", demoFboOffset)
-		screenQuadMat.SetUnifVec2("scale", demoFboScale)
+	// Start rendering
+	dirLightDepthMapFbo.BindWithViewport()
+	dirLightDepthMapFbo.Clear()
 
+	// Culling front faces helps 'peter panning' when
+	// drawing shadow maps, but works only for solids with a back face (i.e. quads won't cast shadows).
+	// Check more here: https://learnopengl.com/Advanced-Lighting/Shadows/Shadow-Mapping
+	//
+	// Some note that this is too troublesome and fails in many cases. Might be better to remove.
+	gl.CullFace(gl.FRONT)
+	g.RenderScene(depthMapMat)
+	gl.CullFace(gl.BACK)
+
+	dirLightDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight))
+
+	if showDirLightDepthMapFbo {
+		screenQuadMat.DiffuseTex = dirLightDepthMapFbo.Attachments[0].Id
+		screenQuadMat.SetUnifVec2("offset", dirLightDepthMapFboOffset)
+		screenQuadMat.SetUnifVec2("scale", dirLightDepthMapFboScale)
+		screenQuadMat.Bind()
 		window.Rend.DrawVertexArray(screenQuadMat, &screenQuadVao, 0, 6)
 	}
 }
 
-var (
-	rotatingCubeSpeedDeg1 float32 = 45
-	rotatingCubeSpeedDeg2 float32 = 90
-	rotatingCubeTrMat1            = *gglm.NewTrMatId().Translate(gglm.NewVec3(-4, -1, 4))
-	rotatingCubeTrMat2            = *gglm.NewTrMatId().Translate(gglm.NewVec3(-1, 0.5, 4))
-)
+func (g *Game) renderSpotLightShadowmaps() {
+
+	for i := 0; i < len(spotLights); i++ {
+
+		l := &spotLights[i]
+		indexStr := strconv.Itoa(i)
+		projViewMatIndexStr := "spotLightProjViewMats[" + indexStr + "]"
+
+		// Set render uniforms
+		projViewMat := l.GetProjViewMat()
+
+		whiteMat.SetUnifMat4(projViewMatIndexStr, &projViewMat)
+		containerMat.SetUnifMat4(projViewMatIndexStr, &projViewMat)
+		palleteMat.SetUnifMat4(projViewMatIndexStr, &projViewMat)
+
+		// Set depth uniforms
+		arrayDepthMapMat.SetUnifMat4("projViewMats["+indexStr+"]", &projViewMat)
+	}
+
+	// Render
+	spotLightDepthMapFbo.BindWithViewport()
+	spotLightDepthMapFbo.Clear()
+
+	// Front culling created issues
+	// gl.CullFace(gl.FRONT)
+	g.RenderScene(arrayDepthMapMat)
+	// gl.CullFace(gl.BACK)
+
+	spotLightDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight))
+}
+
+func (g *Game) renderPointLightShadowmaps() {
+
+	pointLightDepthMapFbo.BindWithViewport()
+	pointLightDepthMapFbo.Clear()
+
+	for i := 0; i < len(pointLights); i++ {
+
+		p := &pointLights[i]
+
+		// Generic uniforms
+		omnidirDepthMapMat.SetUnifVec3("lightPos", &p.Pos)
+		omnidirDepthMapMat.SetUnifInt32("cubemapIndex", int32(i))
+		omnidirDepthMapMat.SetUnifFloat32("farPlane", p.FarPlane)
+
+		// Set projView matrices
+		projViewMats := p.GetProjViewMats(float32(pointLightDepthMapFbo.Width), float32(pointLightDepthMapFbo.Height))
+		for j := 0; j < len(projViewMats); j++ {
+			omnidirDepthMapMat.SetUnifMat4("cubemapProjViewMats["+strconv.Itoa(j)+"]", &projViewMats[j])
+		}
+
+		g.RenderScene(omnidirDepthMapMat)
+	}
+
+	pointLightDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight))
+}
+
+func (g *Game) renderDemoFob() {
+
+	demoFbo.Bind()
+	demoFbo.Clear()
+
+	if renderDepthBuffer {
+		g.RenderScene(debugDepthMat)
+	} else {
+		g.RenderScene(nil)
+	}
+
+	if renderSkybox {
+		g.DrawSkybox()
+	}
+
+	demoFbo.UnBind()
+
+	screenQuadMat.DiffuseTex = demoFbo.Attachments[0].Id
+	screenQuadMat.SetUnifVec2("offset", demoFboOffset)
+	screenQuadMat.SetUnifVec2("scale", demoFboScale)
+
+	window.Rend.DrawVertexArray(screenQuadMat, &screenQuadVao, 0, 6)
+}
 
 func (g *Game) RenderScene(overrideMat *materials.Material) {
 
@@ -956,11 +1165,9 @@ func (g *Game) RenderScene(overrideMat *materials.Material) {
 	window.Rend.DrawMesh(cubeMesh, tempModelMatrix, cubeMat)
 
 	// Rotating cubes
-	rotatingCubeTrMat1.Rotate(rotatingCubeSpeedDeg1*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(0, 1, 0))
 	window.Rend.DrawMesh(cubeMesh, &rotatingCubeTrMat1, cubeMat)
-
-	rotatingCubeTrMat2.Rotate(rotatingCubeSpeedDeg2*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(1, 1, 0))
 	window.Rend.DrawMesh(cubeMesh, &rotatingCubeTrMat2, cubeMat)
+	window.Rend.DrawMesh(cubeMesh, &rotatingCubeTrMat3, cubeMat)
 
 	// Cubes generator
 	// rowSize := 1

materials/material.go

@@ -11,12 +11,14 @@ import (
 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
+	TextureSlot_Diffuse          TextureSlot = 0
+	TextureSlot_Specular         TextureSlot = 1
+	TextureSlot_Normal           TextureSlot = 2
+	TextureSlot_Emission         TextureSlot = 3
+	TextureSlot_Cubemap          TextureSlot = 10
+	TextureSlot_Cubemap_Array    TextureSlot = 11
+	TextureSlot_ShadowMap1       TextureSlot = 12
+	TextureSlot_ShadowMap_Array1 TextureSlot = 13
 )
 
 type Material struct {
@@ -26,6 +28,7 @@ type Material struct {
 	UnifLocs   map[string]int32
 	AttribLocs map[string]int32
 
+	// @TODO do this in a better way. Perhaps something like how we do fbo attachments
 	// Phong shading
 	DiffuseTex  uint32
 	SpecularTex uint32
@@ -35,16 +38,18 @@ type Material struct {
 	// Shininess of specular highlights
 	Shininess float32
 
-	// Cubemap
-	CubemapTex uint32
+	// Cubemaps
+	CubemapTex      uint32
+	CubemapArrayTex uint32
 
 	// Shadowmaps
-	ShadowMap uint32
+	ShadowMapTex1      uint32
+	ShadowMapTexArray1 uint32
 }
 
 func (m *Material) Bind() {
 
-	gl.UseProgram(m.ShaderProg.ID)
+	m.ShaderProg.Bind()
 
 	if m.DiffuseTex != 0 {
 		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Diffuse))
@@ -71,9 +76,19 @@ func (m *Material) Bind() {
 		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)
+	if m.CubemapArrayTex != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Cubemap_Array))
+		gl.BindTexture(gl.TEXTURE_CUBE_MAP_ARRAY, m.CubemapArrayTex)
+	}
+
+	if m.ShadowMapTex1 != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_ShadowMap1))
+		gl.BindTexture(gl.TEXTURE_2D, m.ShadowMapTex1)
+	}
+
+	if m.ShadowMapTexArray1 != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_ShadowMap_Array1))
+		gl.BindTexture(gl.TEXTURE_2D_ARRAY, m.ShadowMapTexArray1)
 	}
 }
 
@@ -88,7 +103,7 @@ func (m *Material) GetAttribLoc(attribName string) int32 {
 		return loc
 	}
 
-	loc = gl.GetAttribLocation(m.ShaderProg.ID, gl.Str(attribName+"\x00"))
+	loc = gl.GetAttribLocation(m.ShaderProg.Id, gl.Str(attribName+"\x00"))
 	assert.T(loc != -1, "Attribute '"+attribName+"' doesn't exist on material "+m.Name)
 	m.AttribLocs[attribName] = loc
 	return loc
@@ -101,7 +116,7 @@ func (m *Material) GetUnifLoc(uniformName string) int32 {
 		return loc
 	}
 
-	loc = gl.GetUniformLocation(m.ShaderProg.ID, gl.Str(uniformName+"\x00"))
+	loc = gl.GetUniformLocation(m.ShaderProg.Id, gl.Str(uniformName+"\x00"))
 	assert.T(loc != -1, "Uniform '"+uniformName+"' doesn't exist on material "+m.Name)
 	m.UnifLocs[uniformName] = loc
 	return loc
@@ -116,39 +131,39 @@ func (m *Material) DisableAttribute(attribName string) {
 }
 
 func (m *Material) SetUnifInt32(uniformName string, val int32) {
-	gl.ProgramUniform1i(m.ShaderProg.ID, m.GetUnifLoc(uniformName), val)
+	gl.ProgramUniform1i(m.ShaderProg.Id, m.GetUnifLoc(uniformName), val)
 }
 
 func (m *Material) SetUnifFloat32(uniformName string, val float32) {
-	gl.ProgramUniform1f(m.ShaderProg.ID, m.GetUnifLoc(uniformName), val)
+	gl.ProgramUniform1f(m.ShaderProg.Id, m.GetUnifLoc(uniformName), val)
 }
 
 func (m *Material) SetUnifVec2(uniformName string, vec2 *gglm.Vec2) {
-	gl.ProgramUniform2fv(m.ShaderProg.ID, m.GetUnifLoc(uniformName), 1, &vec2.Data[0])
+	gl.ProgramUniform2fv(m.ShaderProg.Id, m.GetUnifLoc(uniformName), 1, &vec2.Data[0])
 }
 
 func (m *Material) SetUnifVec3(uniformName string, vec3 *gglm.Vec3) {
-	gl.ProgramUniform3fv(m.ShaderProg.ID, m.GetUnifLoc(uniformName), 1, &vec3.Data[0])
+	gl.ProgramUniform3fv(m.ShaderProg.Id, m.GetUnifLoc(uniformName), 1, &vec3.Data[0])
 }
 
 func (m *Material) SetUnifVec4(uniformName string, vec4 *gglm.Vec4) {
-	gl.ProgramUniform4fv(m.ShaderProg.ID, m.GetUnifLoc(uniformName), 1, &vec4.Data[0])
+	gl.ProgramUniform4fv(m.ShaderProg.Id, m.GetUnifLoc(uniformName), 1, &vec4.Data[0])
 }
 
 func (m *Material) SetUnifMat2(uniformName string, mat2 *gglm.Mat2) {
-	gl.ProgramUniformMatrix2fv(m.ShaderProg.ID, m.GetUnifLoc(uniformName), 1, false, &mat2.Data[0][0])
+	gl.ProgramUniformMatrix2fv(m.ShaderProg.Id, m.GetUnifLoc(uniformName), 1, false, &mat2.Data[0][0])
 }
 
 func (m *Material) SetUnifMat3(uniformName string, mat3 *gglm.Mat3) {
-	gl.ProgramUniformMatrix3fv(m.ShaderProg.ID, m.GetUnifLoc(uniformName), 1, false, &mat3.Data[0][0])
+	gl.ProgramUniformMatrix3fv(m.ShaderProg.Id, m.GetUnifLoc(uniformName), 1, false, &mat3.Data[0][0])
 }
 
 func (m *Material) SetUnifMat4(uniformName string, mat4 *gglm.Mat4) {
-	gl.ProgramUniformMatrix4fv(m.ShaderProg.ID, m.GetUnifLoc(uniformName), 1, false, &mat4.Data[0][0])
+	gl.ProgramUniformMatrix4fv(m.ShaderProg.Id, m.GetUnifLoc(uniformName), 1, false, &mat4.Data[0][0])
 }
 
 func (m *Material) Delete() {
-	gl.DeleteProgram(m.ShaderProg.ID)
+	gl.DeleteProgram(m.ShaderProg.Id)
 }
 
 func NewMaterial(matName, shaderPath string) *Material {

res/shaders/array-depth-map.glsl

@@ -0,0 +1,54 @@
+//shader:vertex
+#version 410
+
+layout(location=0) in vec3 vertPosIn;
+
+uniform mat4 modelMat;
+
+void main()
+{
+    gl_Position = modelMat * vec4(vertPosIn, 1);
+}
+
+//shader:geometry
+#version 410
+
+layout (triangles) in;
+
+#define NUM_PROJ_VIEW_MATS 4
+
+// 3 * NUM_PROJ_VIEW_MATS
+layout (triangle_strip, max_vertices=12) out;
+
+// This is the same number as max spot lights or whatever else is being rendered
+uniform mat4 projViewMats[NUM_PROJ_VIEW_MATS];
+
+out vec4 FragPos;
+
+void main()
+{
+    for(int projViewMatIndex = 0; projViewMatIndex < NUM_PROJ_VIEW_MATS; projViewMatIndex++){
+
+        gl_Layer = projViewMatIndex;
+        mat4 projViewMat = projViewMats[projViewMatIndex];
+
+        for(int i = 0; i < 3; i++)
+        {
+            FragPos = gl_in[i].gl_Position;
+            gl_Position = projViewMat * FragPos;
+            EmitVertex();
+        }
+        EndPrimitive();
+    }
+}
+
+//shader:fragment
+#version 410
+
+in vec4 FragPos;
+
+void main()
+{
+    // This implicitly writes to the depth buffer with no color operations
+    // Equivalent: gl_FragDepth = gl_FragCoord.z;
+}

res/shaders/omnidirectional-depth-map.glsl

@@ -0,0 +1,65 @@
+//shader:vertex
+#version 410
+
+layout(location=0) in vec3 vertPosIn;
+
+uniform mat4 modelMat;
+
+void main()
+{
+    gl_Position = modelMat * vec4(vertPosIn, 1);
+}
+
+//shader:geometry
+#version 410
+
+layout (triangles) in;
+
+// Cubemap means 6 faces, and the
+// input 3 triangle vertices are drawn once per face, so 6*3=18
+layout (triangle_strip, max_vertices=18) out;
+
+uniform int cubemapIndex;
+uniform mat4 cubemapProjViewMats[6];
+
+out vec4 FragPos;
+
+void main()
+{
+    for(int face = 0; face < 6; ++face)
+    {
+        // Built in variable that specifies which cubemap face we are rendering to
+        // and only works when a cubemap is attached to the active fbo.
+        //
+        // We use an additional index here because our fbo has a cubemap array
+        gl_Layer = (cubemapIndex * 6) + face;
+
+        // Transform each triangle vertex
+        for(int i = 0; i < 3; ++i)
+        {
+            FragPos = gl_in[i].gl_Position;
+            gl_Position = cubemapProjViewMats[face] * FragPos;
+            EmitVertex();
+        }
+        EndPrimitive();
+    }
+}
+
+//shader:fragment
+#version 410
+
+in vec4 FragPos;
+
+uniform vec3 lightPos;
+uniform float farPlane;
+
+void main()
+{
+    // Get distance between fragment and light source
+    float lightDistance = length(FragPos.xyz - lightPos);
+
+    // Map to [0, 1] by dividing by far plane and use it as our depth
+    lightDistance = lightDistance / farPlane;
+
+    gl_FragDepth = lightDistance;
+}

res/shaders/simple.glsl

@@ -6,15 +6,19 @@ layout(location=1) in vec3 vertNormalIn;
 layout(location=2) in vec2 vertUV0In;
 layout(location=3) in vec3 vertColorIn;
 
+uniform mat4 modelMat;
+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;
-
-uniform mat4 modelMat;
-uniform mat4 projViewMat;
-uniform mat4 dirLightProjViewMat;
+out vec4 fragPosSpotLight[NUM_SPOT_LIGHTS];
 
 void main()
 {
@@ -23,7 +27,6 @@ void main()
     // 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;
-    vertNormal = mat3(transpose(inverse(modelMat))) * vertNormalIn;
     
     vertUV0 = vertUV0In;
     vertColor = vertColorIn;
@@ -32,6 +35,9 @@ void main()
     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;
 }
 
@@ -64,10 +70,12 @@ struct PointLight {
     float constant;
     float linear;
     float quadratic;
+    float farPlane;
 };
 
-#define NUM_POINT_LIGHTS 16
+#define NUM_POINT_LIGHTS 8
 uniform PointLight pointLights[NUM_POINT_LIGHTS];
+uniform samplerCubeArray pointLightCubeShadowMaps;
 
 struct SpotLight {
     vec3 pos;
@@ -80,6 +88,7 @@ struct SpotLight {
 
 #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);
@@ -89,6 +98,7 @@ in vec3 vertNormal;
 in vec2 vertUV0;
 in vec3 fragPos;
 in vec4 fragPosDirLight;
+in vec4 fragPosSpotLight[NUM_SPOT_LIGHTS];
 
 out vec4 fragColor;
 
@@ -99,7 +109,7 @@ vec4 emissionTexColor;
 vec3 normalizedVertNorm;
 vec3 viewDir;
 
-float CalcShadow(sampler2D shadowMap, vec3 lightDir)
+float CalcDirShadow(sampler2D shadowMap, vec3 lightDir)
 {
     // Move from clip space to NDC
     vec3 projCoords = fragPosDirLight.xyz / fragPosDirLight.w;
@@ -118,13 +128,13 @@ float CalcShadow(sampler2D shadowMap, vec3 lightDir)
     // 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
+    // 'Percentage Close Filtering'.
     // 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 x = -1; x <= 1; x++)
     {
-        for(int y = -1; y <= 1; ++y)
+        for(int y = -1; y <= 1; y++)
         {
             float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r; 
 
@@ -153,12 +163,30 @@ vec3 CalcDirLight()
     vec3 finalSpecular = specularAmount * dirLight.specularColor * specularTexColor.rgb;
 
     // Shadow
-    float shadow = CalcShadow(dirLight.shadowMap, lightDir);
+    float shadow = CalcDirShadow(dirLight.shadowMap, lightDir);
 
     return (finalDiffuse + finalSpecular) * (1 - shadow);
 }
 
-vec3 CalcPointLight(PointLight pointLight)
+float CalcPointShadow(int lightIndex, vec3 lightPos, vec3 lightDir, float farPlane) {
+
+    vec3 lightToFrag = fragPos - lightPos;
+
+    float closestDepth = texture(pointLightCubeShadowMaps, vec4(lightToFrag, lightIndex)).r;
+
+    // We stored depth in the cubemap in the range [0, 1], so now we move back to [0, farPlane]
+    closestDepth *= farPlane;
+
+    // Get depth of current fragment
+    float currentDepth = length(lightToFrag);
+
+    float bias = max(0.05 * (1 - dot(normalizedVertNorm, lightDir)), 0.005);
+    float shadow = currentDepth -  bias > closestDepth ? 1.0 : 0.0;
+
+    return shadow;
+}
+
+vec3 CalcPointLight(PointLight pointLight, int lightIndex)
 {
     // Ignore unset lights
     if (pointLight.constant == 0){
@@ -176,14 +204,57 @@ vec3 CalcPointLight(PointLight pointLight)
     float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
     vec3 finalSpecular = specularAmount * pointLight.specularColor * specularTexColor.rgb;
 
-    // attenuation
+    // Attenuation
     float distToLight = length(pointLight.pos - fragPos);
     float attenuation = 1 / (pointLight.constant + pointLight.linear * distToLight + pointLight.quadratic * (distToLight * distToLight));  
 
-    return (finalDiffuse + finalSpecular) * attenuation;
+    // Shadow
+    float shadow = CalcPointShadow(lightIndex, pointLight.pos, lightDir, pointLight.farPlane);
+
+    return (finalDiffuse + finalSpecular) * attenuation * (1 - shadow);
 }
 
-vec3 CalcSpotLight(SpotLight light)
+float CalcSpotShadow(vec3 lightDir, int lightIndex)
+{
+    // Move from clip space to NDC
+    vec3 projCoords = fragPosSpotLight[lightIndex].xyz / fragPosSpotLight[lightIndex].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'.
+    // Basically get soft shadows by averaging this texel and surrounding ones
+    float shadow = 0;
+    vec2 texelSize = 1 / textureSize(spotLightShadowMaps, 0).xy;
+    for(int x = -1; x <= 1; x++)
+    {
+        for(int y = -1; y <= 1; y++)
+        {
+            float pcfDepth = texture(spotLightShadowMaps, vec3(projCoords.xy + vec2(x, y) * texelSize, lightIndex)).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 CalcSpotLight(SpotLight light, int lightIndex)
 {
     if (light.innerCutoff == 0)
         return vec3(0);
@@ -195,7 +266,7 @@ vec3 CalcSpotLight(SpotLight light)
     // light after outer cutoff
     float theta = dot(fragToLightDir, normalize(-light.dir));
     float epsilon = (light.innerCutoff - light.outerCutoff);
-    float intensity = clamp((theta - light.outerCutoff) / epsilon, 0.0, 1);
+    float intensity = clamp((theta - light.outerCutoff) / epsilon, float(0), float(1));
 
     if (intensity == 0)
         return vec3(0);
@@ -209,7 +280,10 @@ vec3 CalcSpotLight(SpotLight light)
     float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
     vec3 finalSpecular = specularAmount * light.specularColor * specularTexColor.rgb;
 
-    return (finalDiffuse + finalSpecular) * intensity;
+    // Shadow
+    float shadow = CalcSpotShadow(fragToLightDir, lightIndex);
+
+    return (finalDiffuse + finalSpecular) * intensity * (1 - shadow);
 }
 
 void main()
@@ -227,12 +301,12 @@ void main()
 
     for (int i = 0; i < NUM_POINT_LIGHTS; i++)
     {
-        finalColor += CalcPointLight(pointLights[i]);
+        finalColor += CalcPointLight(pointLights[i], i);
     }
 
     for (int i = 0; i < NUM_SPOT_LIGHTS; i++)
     {
-        finalColor += CalcSpotLight(spotLights[i]);
+        finalColor += CalcSpotLight(spotLights[i], i);
     }
 
     vec3 finalEmission = emissionTexColor.rgb;

shaders/shader_program.go

@@ -6,32 +6,48 @@ import (
 )
 
 type ShaderProgram struct {
-	ID           uint32
-	VertShaderID uint32
-	FragShaderID uint32
+	Id           uint32
+	VertShaderId uint32
+	FragShaderId uint32
+	GeomShaderId uint32
 }
 
 func (sp *ShaderProgram) AttachShader(shader Shader) {
 
-	gl.AttachShader(sp.ID, shader.ID)
-	switch shader.ShaderType {
-	case VertexShaderType:
-		sp.VertShaderID = shader.ID
-	case FragmentShaderType:
-		sp.FragShaderID = shader.ID
+	gl.AttachShader(sp.Id, shader.Id)
+	switch shader.Type {
+	case ShaderType_Vertex:
+		sp.VertShaderId = shader.Id
+	case ShaderType_Fragment:
+		sp.FragShaderId = shader.Id
+	case ShaderType_Geometry:
+		sp.GeomShaderId = shader.Id
 	default:
-		logging.ErrLog.Println("Unknown shader type ", shader.ShaderType, " for ID ", shader.ID)
+		logging.ErrLog.Fatalf("Unknown shader type '%d' for shader id '%d'\n", shader.Type, shader.Id)
 	}
 }
 
 func (sp *ShaderProgram) Link() {
 
-	gl.LinkProgram(sp.ID)
+	gl.LinkProgram(sp.Id)
 
-	if sp.VertShaderID != 0 {
-		gl.DeleteShader(sp.VertShaderID)
+	if sp.VertShaderId != 0 {
+		gl.DeleteShader(sp.VertShaderId)
 	}
-	if sp.FragShaderID != 0 {
-		gl.DeleteShader(sp.FragShaderID)
+
+	if sp.FragShaderId != 0 {
+		gl.DeleteShader(sp.FragShaderId)
+	}
+
+	if sp.GeomShaderId != 0 {
+		gl.DeleteShader(sp.GeomShaderId)
 	}
 }
+
+func (s *ShaderProgram) Bind() {
+	gl.UseProgram(s.Id)
+}
+
+func (s *ShaderProgram) UnBind() {
+	gl.UseProgram(0)
+}

shaders/shader_types.go

@@ -1,10 +1,31 @@
 package shaders
 
-import "github.com/go-gl/gl/v4.1-core/gl"
+import (
+	"github.com/bloeys/nmage/logging"
+	"github.com/go-gl/gl/v4.1-core/gl"
+)
 
-type ShaderType int
+type ShaderType int32
+
+func (s ShaderType) ToGl() uint32 {
+
+	switch s {
+	case ShaderType_Vertex:
+		return gl.VERTEX_SHADER
+	case ShaderType_Fragment:
+		return gl.FRAGMENT_SHADER
+	case ShaderType_Geometry:
+		return gl.GEOMETRY_SHADER
+
+	default:
+		logging.ErrLog.Fatalf("Unknown shader type '%d'\n", s)
+		return 0
+	}
+}
 
 const (
-	VertexShaderType   ShaderType = gl.VERTEX_SHADER
-	FragmentShaderType ShaderType = gl.FRAGMENT_SHADER
+	ShaderType_Unknown ShaderType = iota
+	ShaderType_Vertex
+	ShaderType_Fragment
+	ShaderType_Geometry
 )

shaders/shaders.go

@@ -3,6 +3,7 @@ package shaders
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"os"
 	"strings"
 
@@ -11,12 +12,13 @@ import (
 )
 
 type Shader struct {
-	ID         uint32
-	ShaderType ShaderType
+	Id   uint32
+	Type ShaderType
 }
 
-func (s Shader) Delete() {
-	gl.DeleteShader(s.ID)
+func (s *Shader) Delete() {
+	gl.DeleteShader(s.Id)
+	s.Id = 0
 }
 
 func NewShaderProgram() (ShaderProgram, error) {
@@ -26,7 +28,7 @@ func NewShaderProgram() (ShaderProgram, error) {
 		return ShaderProgram{}, errors.New("failed to create shader program")
 	}
 
-	return ShaderProgram{ID: id}, nil
+	return ShaderProgram{Id: id}, nil
 }
 
 func LoadAndCompileCombinedShader(shaderPath string) (ShaderProgram, error) {
@@ -43,8 +45,8 @@ func LoadAndCompileCombinedShader(shaderPath string) (ShaderProgram, error) {
 func LoadAndCompileCombinedShaderSrc(shaderSrc []byte) (ShaderProgram, error) {
 
 	shaderSources := bytes.Split(shaderSrc, []byte("//shader:"))
-	if len(shaderSources) == 1 {
-		return ShaderProgram{}, errors.New("failed to read combined shader. Did not find '//shader:vertex' or '//shader:fragment'")
+	if len(shaderSources) < 2 {
+		return ShaderProgram{}, errors.New("failed to read combined shader. The minimum shader types to have are '//shader:vertex' and '//shader:fragment'")
 	}
 
 	shdrProg, err := NewShaderProgram()
@@ -65,12 +67,15 @@ func LoadAndCompileCombinedShaderSrc(shaderSrc []byte) (ShaderProgram, error) {
 		var shdrType ShaderType
 		if bytes.HasPrefix(src, []byte("vertex")) {
 			src = src[6:]
-			shdrType = VertexShaderType
+			shdrType = ShaderType_Vertex
 		} else if bytes.HasPrefix(src, []byte("fragment")) {
 			src = src[8:]
-			shdrType = FragmentShaderType
+			shdrType = ShaderType_Fragment
+		} else if bytes.HasPrefix(src, []byte("geometry")) {
+			src = src[8:]
+			shdrType = ShaderType_Geometry
 		} else {
-			return ShaderProgram{}, errors.New("unknown shader type. Must be '//shader:vertex' or '//shader:fragment'")
+			return ShaderProgram{}, errors.New("unknown shader type. Must be '//shader:vertex' or '//shader:fragment' or '//shader:geometry'")
 		}
 
 		shdr, err := CompileShaderOfType(src, shdrType)
@@ -83,7 +88,15 @@ func LoadAndCompileCombinedShaderSrc(shaderSrc []byte) (ShaderProgram, error) {
 	}
 
 	if loadedShdrCount == 0 {
-		return ShaderProgram{}, errors.New("no valid shaders found. Please put '//shader:vertex' or '//shader:fragment' before your shaders")
+		return ShaderProgram{}, errors.New("no valid shaders found. Please put '//shader:vertex' or '//shader:fragment' or '//shader:geometry' before your shaders")
+	}
+
+	if shdrProg.VertShaderId == 0 {
+		return ShaderProgram{}, errors.New("no valid vertex shader found. Please put '//shader:vertex' before your vertex shader")
+	}
+
+	if shdrProg.FragShaderId == 0 {
+		return ShaderProgram{}, errors.New("no valid fragment shader found. Please put '//shader:fragment' before your vertex shader")
 	}
 
 	shdrProg.Link()
@@ -92,41 +105,40 @@ func LoadAndCompileCombinedShaderSrc(shaderSrc []byte) (ShaderProgram, error) {
 
 func CompileShaderOfType(shaderSource []byte, shaderType ShaderType) (Shader, error) {
 
-	shaderID := gl.CreateShader(uint32(shaderType))
-	if shaderID == 0 {
-		logging.ErrLog.Println("Failed to create shader.")
-		return Shader{}, errors.New("failed to create shader")
+	shaderId := gl.CreateShader(shaderType.ToGl())
+	if shaderId == 0 {
+		return Shader{}, fmt.Errorf("failed to create OpenGl shader. OpenGl Error=%d", gl.GetError())
 	}
 
 	//Load shader source and compile
 	shaderCStr, shaderFree := gl.Strs(string(shaderSource) + "\x00")
 	defer shaderFree()
-	gl.ShaderSource(shaderID, 1, shaderCStr, nil)
+	gl.ShaderSource(shaderId, 1, shaderCStr, nil)
 
-	gl.CompileShader(shaderID)
-	if err := getShaderCompileErrors(shaderID); err != nil {
-		gl.DeleteShader(shaderID)
+	gl.CompileShader(shaderId)
+	if err := getShaderCompileErrors(shaderId); err != nil {
+		gl.DeleteShader(shaderId)
 		return Shader{}, err
 	}
 
-	return Shader{ID: shaderID, ShaderType: shaderType}, nil
+	return Shader{Id: shaderId, Type: shaderType}, nil
 }
 
-func getShaderCompileErrors(shaderID uint32) error {
+func getShaderCompileErrors(shaderId uint32) error {
 
 	var compiledSuccessfully int32
-	gl.GetShaderiv(shaderID, gl.COMPILE_STATUS, &compiledSuccessfully)
+	gl.GetShaderiv(shaderId, gl.COMPILE_STATUS, &compiledSuccessfully)
 	if compiledSuccessfully == gl.TRUE {
 		return nil
 	}
 
 	var logLength int32
-	gl.GetShaderiv(shaderID, gl.INFO_LOG_LENGTH, &logLength)
+	gl.GetShaderiv(shaderId, gl.INFO_LOG_LENGTH, &logLength)
 
 	log := gl.Str(strings.Repeat("\x00", int(logLength)))
-	gl.GetShaderInfoLog(shaderID, logLength, nil, log)
+	gl.GetShaderInfoLog(shaderId, logLength, nil, log)
 
 	errMsg := gl.GoStr(log)
-	logging.ErrLog.Println("Compilation of shader with id ", shaderID, " failed. Err: ", errMsg)
+	logging.ErrLog.Println("Compilation of shader with id ", shaderId, " failed. Err: ", errMsg)
 	return errors.New(errMsg)
 }