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:
@@ -33,6 +43,7 @@ const (
 	FramebufferAttachmentDataFormat_R32Int
 	FramebufferAttachmentDataFormat_RGBA8
 	FramebufferAttachmentDataFormat_SRGBA
+	FramebufferAttachmentDataFormat_DepthF32
 	FramebufferAttachmentDataFormat_Depth24Stencil8
 )
 
@@ -43,7 +54,8 @@ func (f FramebufferAttachmentDataFormat) IsColorFormat() bool {
 }
 
 func (f FramebufferAttachmentDataFormat) IsDepthFormat() bool {
-	return f == FramebufferAttachmentDataFormat_Depth24Stencil8
+	return f == FramebufferAttachmentDataFormat_Depth24Stencil8 ||
+		f == FramebufferAttachmentDataFormat_DepthF32
 }
 
 func (f FramebufferAttachmentDataFormat) GlInternalFormat() int32 {
@@ -55,6 +67,8 @@ func (f FramebufferAttachmentDataFormat) GlInternalFormat() int32 {
 		return gl.RGB8
 	case FramebufferAttachmentDataFormat_SRGBA:
 		return gl.SRGB_ALPHA
+	case FramebufferAttachmentDataFormat_DepthF32:
+		return gl.DEPTH_COMPONENT
 	case FramebufferAttachmentDataFormat_Depth24Stencil8:
 		return gl.DEPTH24_STENCIL8
 	default:
@@ -74,6 +88,9 @@ func (f FramebufferAttachmentDataFormat) GlFormat() uint32 {
 	case FramebufferAttachmentDataFormat_SRGBA:
 		return gl.RGBA
 
+	case FramebufferAttachmentDataFormat_DepthF32:
+		return gl.DEPTH_COMPONENT
+
 	case FramebufferAttachmentDataFormat_Depth24Stencil8:
 		return gl.DEPTH_STENCIL
 
@@ -91,6 +108,7 @@ type FramebufferAttachment struct {
 
 type Framebuffer struct {
 	Id                    uint32
+	ClearFlags            uint32
 	Attachments           []FramebufferAttachment
 	ColorAttachmentsCount uint32
 	Width                 uint32
@@ -106,6 +124,13 @@ func (fbo *Framebuffer) BindWithViewport() {
 	gl.Viewport(0, 0, int32(fbo.Width), int32(fbo.Height))
 }
 
+// Clear calls gl.Clear with the fob's clear flags.
+// Note that the fbo must be complete and bound.
+// Calling this without a bound fbo will clear something else, like your screen.
+func (fbo *Framebuffer) Clear() {
+	gl.Clear(fbo.ClearFlags)
+}
+
 func (fbo *Framebuffer) UnBind() {
 	gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
 }
@@ -154,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)
 	}
@@ -201,6 +234,249 @@ func (fbo *Framebuffer) NewColorAttachment(
 
 	fbo.UnBind()
 	fbo.ColorAttachmentsCount++
+	fbo.ClearFlags |= gl.COLOR_BUFFER_BIT
+	fbo.Attachments = append(fbo.Attachments, a)
+}
+
+// SetNoColorBuffer sets the read and draw buffers of this fbo to 'NONE',
+// which tells the graphics driver that we don't want a color buffer for this fbo.
+//
+// This is required because normally an fbo must have a color buffer to be considered complete, but by
+// doing this we get marked as complete even without one.
+//
+// Usually used when you only care about some other buffer, like a depth buffer.
+func (fbo *Framebuffer) SetNoColorBuffer() {
+
+	if fbo.HasColorAttachment() {
+		logging.ErrLog.Fatalf("failed SetNoColorBuffer because framebuffer already has a color attachment\n")
+	}
+
+	fbo.Bind()
+	gl.DrawBuffer(gl.NONE)
+	gl.ReadBuffer(gl.NONE)
+	fbo.UnBind()
+}
+
+func (fbo *Framebuffer) NewDepthAttachment(
+	attachType FramebufferAttachmentType,
+	attachFormat FramebufferAttachmentDataFormat,
+) {
+
+	if fbo.HasDepthAttachment() {
+		logging.ErrLog.Fatalf("failed creating depth attachment for framebuffer because a depth attachment already exists\n")
+	}
+
+	if !attachType.IsValid() {
+		logging.ErrLog.Fatalf("failed creating depth attachment for framebuffer due to unknown attachment type. Type=%d\n", attachType)
+	}
+
+	if !attachFormat.IsDepthFormat() {
+		logging.ErrLog.Fatalf("failed creating depth attachment for framebuffer due to attachment data format not being a valid depth-stencil type. Data format=%d\n", attachFormat)
+	}
+
+	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,
+	}
+
+	fbo.Bind()
+
+	if attachType == FramebufferAttachmentType_Texture {
+
+		// Create texture
+		gl.GenTextures(1, &a.Id)
+		if a.Id == 0 {
+			logging.ErrLog.Fatalf("failed to generate texture for framebuffer. GlError=%d\n", gl.GetError())
+		}
+
+		gl.BindTexture(gl.TEXTURE_2D, a.Id)
+		gl.TexImage2D(gl.TEXTURE_2D, 0, attachFormat.GlInternalFormat(), int32(fbo.Width), int32(fbo.Height), 0, attachFormat.GlFormat(), gl.FLOAT, nil)
+
+		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+
+		// This is so that any sampling outside the depth map gives a full depth value.
+		// Useful for example when doing shadow maps where we want things outside
+		// the range of the texture to not show shadow
+		borderColor := []float32{1, 1, 1, 1}
+		gl.TexParameterfv(gl.TEXTURE_2D, gl.TEXTURE_BORDER_COLOR, &borderColor[0])
+		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_BORDER)
+		gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_BORDER)
+
+		gl.BindTexture(gl.TEXTURE_2D, 0)
+
+		// Attach to fbo
+		gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, a.Id, 0)
+
+	} else if attachType == FramebufferAttachmentType_Renderbuffer {
+
+		// Create rbo
+		gl.GenRenderbuffers(1, &a.Id)
+		if a.Id == 0 {
+			logging.ErrLog.Fatalf("failed to generate render buffer for framebuffer. GlError=%d\n", gl.GetError())
+		}
+
+		gl.BindRenderbuffer(gl.RENDERBUFFER, a.Id)
+		gl.RenderbufferStorage(gl.RENDERBUFFER, uint32(attachFormat.GlInternalFormat()), int32(fbo.Width), int32(fbo.Height))
+		gl.BindRenderbuffer(gl.RENDERBUFFER, 0)
+
+		// Attach to fbo
+		gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, a.Id)
+
+	} 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()
+	fbo.ClearFlags |= gl.DEPTH_BUFFER_BIT
+	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)
 }
 
@@ -263,9 +539,32 @@ func (fbo *Framebuffer) NewDepthStencilAttachment(
 	}
 
 	fbo.UnBind()
+	fbo.ClearFlags |= gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
 	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

materials/material.go

@@ -8,6 +8,19 @@ import (
 	"github.com/go-gl/gl/v4.1-core/gl"
 )
 
+type TextureSlot uint32
+
+const (
+	TextureSlot_Diffuse          TextureSlot = 0
+	TextureSlot_Specular         TextureSlot = 1
+	TextureSlot_Normal           TextureSlot = 2
+	TextureSlot_Emission         TextureSlot = 3
+	TextureSlot_Cubemap          TextureSlot = 10
+	TextureSlot_Cubemap_Array    TextureSlot = 11
+	TextureSlot_ShadowMap1       TextureSlot = 12
+	TextureSlot_ShadowMap_Array1 TextureSlot = 13
+)
+
 type Material struct {
 	Name       string
 	ShaderProg shaders.ShaderProgram
@@ -15,47 +28,72 @@ 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
 	NormalTex   uint32
 	EmissionTex uint32
 
+	// Shininess of specular highlights
 	Shininess float32
+
+	// Cubemaps
+	CubemapTex      uint32
+	CubemapArrayTex uint32
+
+	// Shadowmaps
+	ShadowMapTex1      uint32
+	ShadowMapTexArray1 uint32
 }
 
 func (m *Material) Bind() {
 
-	gl.UseProgram(m.ShaderProg.ID)
+	m.ShaderProg.Bind()
 
-	gl.ActiveTexture(gl.TEXTURE0)
-	gl.BindTexture(gl.TEXTURE_2D, m.DiffuseTex)
+	if m.DiffuseTex != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Diffuse))
+		gl.BindTexture(gl.TEXTURE_2D, m.DiffuseTex)
+	}
 
-	gl.ActiveTexture(gl.TEXTURE1)
-	gl.BindTexture(gl.TEXTURE_2D, m.SpecularTex)
+	if m.SpecularTex != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Specular))
+		gl.BindTexture(gl.TEXTURE_2D, m.SpecularTex)
+	}
 
-	gl.ActiveTexture(gl.TEXTURE2)
-	gl.BindTexture(gl.TEXTURE_2D, m.NormalTex)
+	if m.NormalTex != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Normal))
+		gl.BindTexture(gl.TEXTURE_2D, m.NormalTex)
+	}
 
-	gl.ActiveTexture(gl.TEXTURE3)
-	gl.BindTexture(gl.TEXTURE_2D, m.EmissionTex)
+	if m.EmissionTex != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Emission))
+		gl.BindTexture(gl.TEXTURE_2D, m.EmissionTex)
+	}
+
+	if m.CubemapTex != 0 {
+		gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_Cubemap))
+		gl.BindTexture(gl.TEXTURE_CUBE_MAP, m.CubemapTex)
+	}
+
+	if m.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)
+	}
 }
 
 func (m *Material) UnBind() {
 	gl.UseProgram(0)
-
-	//TODO: Should we unbind textures here? Are these two lines needed?
-	// gl.ActiveTexture(gl.TEXTURE0)
-	// gl.BindTexture(gl.TEXTURE_2D, 0)
-
-	// gl.ActiveTexture(gl.TEXTURE1)
-	// gl.BindTexture(gl.TEXTURE_2D, 0)
-
-	// gl.ActiveTexture(gl.TEXTURE2)
-	// gl.BindTexture(gl.TEXTURE_2D, 0)
-
-	// gl.ActiveTexture(gl.TEXTURE3)
-	// gl.BindTexture(gl.TEXTURE_2D, 0)
 }
 
 func (m *Material) GetAttribLoc(attribName string) int32 {
@@ -65,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
@@ -78,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
@@ -93,46 +131,46 @@ 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 {
 
 	shdrProg, err := shaders.LoadAndCompileCombinedShader(shaderPath)
 	if err != nil {
-		logging.ErrLog.Fatalln("Failed to create new material. Err: ", err)
+		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)}
@@ -142,7 +180,7 @@ func NewMaterialSrc(matName string, shaderSrc []byte) *Material {
 
 	shdrProg, err := shaders.LoadAndCompileCombinedShaderSrc(shaderSrc)
 	if err != nil {
-		logging.ErrLog.Fatalln("Failed to create new material. Err: ", err)
+		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)}

renderer/rend3dgl/rend3dgl.go

@@ -2,6 +2,7 @@ package rend3dgl
 
 import (
 	"github.com/bloeys/gglm/gglm"
+	"github.com/bloeys/nmage/buffers"
 	"github.com/bloeys/nmage/materials"
 	"github.com/bloeys/nmage/meshes"
 	"github.com/bloeys/nmage/renderer"
@@ -11,23 +12,56 @@ import (
 var _ renderer.Render = &Rend3DGL{}
 
 type Rend3DGL struct {
+	BoundVao  *buffers.VertexArray
 	BoundMesh *meshes.Mesh
 	BoundMat  *materials.Material
 }
 
-func (r3d *Rend3DGL) Draw(mesh *meshes.Mesh, trMat *gglm.TrMat, mat *materials.Material) {
+func (r *Rend3DGL) DrawMesh(mesh *meshes.Mesh, modelMat *gglm.TrMat, mat *materials.Material) {
 
-	if mesh != r3d.BoundMesh {
+	if mesh != r.BoundMesh {
 		mesh.Vao.Bind()
-		r3d.BoundMesh = mesh
+		r.BoundMesh = mesh
 	}
 
-	if mat != r3d.BoundMat {
+	if mat != r.BoundMat {
 		mat.Bind()
-		r3d.BoundMat = mat
+		r.BoundMat = mat
 	}
 
-	mat.SetUnifMat4("modelMat", &trMat.Mat4)
+	mat.SetUnifMat4("modelMat", &modelMat.Mat4)
+
+	for i := 0; i < len(mesh.SubMeshes); i++ {
+		gl.DrawElementsBaseVertexWithOffset(gl.TRIANGLES, mesh.SubMeshes[i].IndexCount, gl.UNSIGNED_INT, uintptr(mesh.SubMeshes[i].BaseIndex), mesh.SubMeshes[i].BaseVertex)
+	}
+}
+
+func (r *Rend3DGL) DrawVertexArray(mat *materials.Material, vao *buffers.VertexArray, firstElement int32, elementCount int32) {
+
+	if vao != r.BoundVao {
+		vao.Bind()
+		r.BoundVao = vao
+	}
+
+	if mat != r.BoundMat {
+		mat.Bind()
+		r.BoundMat = mat
+	}
+
+	gl.DrawArrays(gl.TRIANGLES, firstElement, elementCount)
+}
+
+func (r *Rend3DGL) DrawCubemap(mesh *meshes.Mesh, mat *materials.Material) {
+
+	if mesh != r.BoundMesh {
+		mesh.Vao.Bind()
+		r.BoundMesh = mesh
+	}
+
+	if mat != r.BoundMat {
+		mat.Bind()
+		r.BoundMat = mat
+	}
 
 	for i := 0; i < len(mesh.SubMeshes); i++ {
 		gl.DrawElementsBaseVertexWithOffset(gl.TRIANGLES, mesh.SubMeshes[i].IndexCount, gl.UNSIGNED_INT, uintptr(mesh.SubMeshes[i].BaseIndex), mesh.SubMeshes[i].BaseVertex)

renderer/renderer.go

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

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/debug-depth.glsl

@@ -13,17 +13,18 @@ out vec3 fragPos;
 
 //MVP = Model View Projection
 uniform mat4 modelMat;
-uniform mat4 viewMat;
-uniform mat4 projMat;
+uniform mat4 projViewMat;
 
 void main()
 {
     vertNormal = mat3(transpose(inverse(modelMat))) * vertNormalIn;
     vertUV0 = vertUV0In;
     vertColor = vertColorIn;
-    fragPos = vec3(modelMat * vec4(vertPosIn, 1.0));
 
-    gl_Position = projMat * viewMat * modelMat * vec4(vertPosIn, 1.0);
+    vec4 modelVert = modelMat * vec4(vertPosIn, 1);
+    fragPos = modelVert.xyz;
+
+    gl_Position = projViewMat * modelVert;
 }
 
 //shader:fragment

res/shaders/depth-map.glsl

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

res/shaders/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-unlit.glsl

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

res/shaders/simple.glsl

@@ -6,29 +6,39 @@ 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;
-
-//MVP = Model View Projection
-uniform mat4 modelMat;
-uniform mat4 viewMat;
-uniform mat4 projMat;
+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;
-    fragPos = vec3(modelMat * vec4(vertPosIn, 1.0));
 
-    gl_Position = projMat * viewMat * modelMat * vec4(vertPosIn, 1.0);
+    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
@@ -48,6 +58,7 @@ struct DirLight {
     vec3 dir;
     vec3 diffuseColor;
     vec3 specularColor;
+    sampler2D shadowMap;
 };
 
 uniform DirLight dirLight;
@@ -59,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;
@@ -75,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);
@@ -83,6 +97,8 @@ in vec3 vertColor;
 in vec3 vertNormal;
 in vec2 vertUV0;
 in vec3 fragPos;
+in vec4 fragPosDirLight;
+in vec4 fragPosSpotLight[NUM_SPOT_LIGHTS];
 
 out vec4 fragColor;
 
@@ -93,6 +109,46 @@ vec4 emissionTexColor;
 vec3 normalizedVertNorm;
 vec3 viewDir;
 
+float CalcDirShadow(sampler2D shadowMap, vec3 lightDir)
+{
+    // Move from clip space to NDC
+    vec3 projCoords = fragPosDirLight.xyz / fragPosDirLight.w;
+
+    // Move from [-1,1] to [0, 1]
+    projCoords = projCoords * 0.5 + 0.5;
+
+    // If sampling outside the depth texture then force 'no shadow'
+    if(projCoords.z > 1)
+        return 0;
+
+    // currentDepth is the fragment depth from the light's perspective
+    float currentDepth = projCoords.z;
+
+    // Bias in the range [0.005, 0.05] depending on the angle, where a higher
+    // angle gives a higher bias, as shadow acne gets worse with angle
+    float bias = max(0.05 * (1 - dot(normalizedVertNorm, lightDir)), 0.005);
+
+    // 'Percentage Close Filtering'.
+    // Basically get soft shadows by averaging this texel and surrounding ones
+    float shadow = 0;
+    vec2 texelSize = 1 / textureSize(shadowMap, 0);
+    for(int x = -1; x <= 1; x++)
+    {
+        for(int y = -1; y <= 1; y++)
+        {
+            float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r; 
+
+            // If our depth is larger than the lights closest depth at the texel we checked (projCoords),
+            // then there is something closer to the light than us, and so we are in shadow
+            shadow += currentDepth - bias > pcfDepth ? 1 : 0;
+        }
+    }
+
+    shadow /= 9;
+
+    return shadow;
+}
+
 vec3 CalcDirLight()
 {
     vec3 lightDir = normalize(-dirLight.dir);
@@ -106,10 +162,31 @@ vec3 CalcDirLight()
     float specularAmount = pow(max(dot(normalizedVertNorm, halfwayDir), 0.0), material.shininess);
     vec3 finalSpecular = specularAmount * dirLight.specularColor * specularTexColor.rgb;
 
-    return finalDiffuse + finalSpecular;
+    // Shadow
+    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){
@@ -127,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.0 / (pointLight.constant + pointLight.linear * distToLight + pointLight.quadratic * (distToLight * distToLight));  
+    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);
@@ -146,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.0);
+    float intensity = clamp((theta - light.outerCutoff) / epsilon, float(0), float(1));
 
     if (intensity == 0)
         return vec3(0);
@@ -160,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()
@@ -178,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;

res/shaders/skybox.glsl

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

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