Spot lights

.github/workflows/build-nmage.yml

@@ -9,10 +9,10 @@ jobs:
     runs-on: macos-12
     steps:
     
-      - name: Install golang 1.18
+      - name: Install golang
         uses: actions/setup-go@v3
         with:
-          go-version: '^1.18'
+          go-version: '>=1.18'
 
       - name: Install assimp-go dylib
         run: sudo mkdir -p /usr/local/lib && sudo wget https://github.com/bloeys/assimp-go/releases/download/v0.4.2/libassimp_darwin_amd64.dylib -O /usr/local/lib/libassimp.5.dylib

engine/engine.go

@@ -15,6 +15,13 @@ import (
 
 var (
 	isInited = false
+
+	isSdlButtonLeftDown   = false
+	isSdlButtonMiddleDown = false
+	isSdlButtonRightDown  = false
+
+	ImguiRelativeMouseModePosX float32
+	ImguiRelativeMouseModePosY float32
 )
 
 type Window struct {
@@ -29,7 +36,9 @@ func (w *Window) handleInputs() {
 	input.EventLoopStart()
 	imIo := imgui.CurrentIO()
 
-	// @TODO: Would be nice to have imgui package process its own events via a callback instead of it being part of engine code
+	imguiCaptureMouse := imIo.WantCaptureMouse()
+	imguiCaptureKeyboard := imIo.WantCaptureKeyboard()
+
 	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
 
 		//Fire callbacks
@@ -42,14 +51,18 @@ func (w *Window) handleInputs() {
 
 		case *sdl.MouseWheelEvent:
 
-			input.HandleMouseWheelEvent(e)
+			if !imguiCaptureMouse {
+				input.HandleMouseWheelEvent(e)
+			}
 
-			xDelta, yDelta := input.GetMouseWheelMotion()
-			imIo.AddMouseWheelDelta(float32(xDelta), float32(yDelta))
+			imIo.AddMouseWheelDelta(float32(e.X), float32(e.Y))
 
 		case *sdl.KeyboardEvent:
 
-			input.HandleKeyboardEvent(e)
+			if !imguiCaptureKeyboard {
+				input.HandleKeyboardEvent(e)
+			}
+
 			imIo.AddKeyEvent(nmageimgui.SdlScancodeToImGuiKey(e.Keysym.Scancode), e.Type == sdl.KEYDOWN)
 
 			// Send modifier key updates to imgui
@@ -73,12 +86,29 @@ func (w *Window) handleInputs() {
 			imIo.AddInputCharactersUTF8(e.GetText())
 
 		case *sdl.MouseButtonEvent:
-			input.HandleMouseBtnEvent(e)
+
+			if !imguiCaptureMouse {
+				input.HandleMouseBtnEvent(e)
+			}
+
+			isPressed := e.State == sdl.PRESSED
+
+			if e.Button == sdl.BUTTON_LEFT {
+				isSdlButtonLeftDown = isPressed
+			} else if e.Button == sdl.BUTTON_MIDDLE {
+				isSdlButtonMiddleDown = isPressed
+			} else if e.Button == sdl.BUTTON_RIGHT {
+				isSdlButtonRightDown = isPressed
+			}
 
 		case *sdl.MouseMotionEvent:
-			input.HandleMouseMotionEvent(e)
+
+			if !imguiCaptureMouse {
+				input.HandleMouseMotionEvent(e)
+			}
 
 		case *sdl.WindowEvent:
+
 			if e.Event == sdl.WINDOWEVENT_SIZE_CHANGED {
 				w.handleWindowResize()
 			}
@@ -88,13 +118,17 @@ func (w *Window) handleInputs() {
 		}
 	}
 
-	// If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
-	x, y, _ := sdl.GetMouseState()
-	imIo.SetMousePos(imgui.Vec2{X: float32(x), Y: float32(y)})
+	if sdl.GetRelativeMouseMode() {
+		imIo.SetMousePos(imgui.Vec2{X: ImguiRelativeMouseModePosX, Y: ImguiRelativeMouseModePosY})
+	} else {
+		x, y, _ := sdl.GetMouseState()
+		imIo.SetMousePos(imgui.Vec2{X: float32(x), Y: float32(y)})
+	}
 
-	imIo.SetMouseButtonDown(0, input.MouseDown(sdl.BUTTON_LEFT))
-	imIo.SetMouseButtonDown(1, input.MouseDown(sdl.BUTTON_RIGHT))
-	imIo.SetMouseButtonDown(2, input.MouseDown(sdl.BUTTON_MIDDLE))
+	// If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
+	imIo.SetMouseButtonDown(imgui.MouseButtonLeft, isSdlButtonLeftDown)
+	imIo.SetMouseButtonDown(imgui.MouseButtonRight, isSdlButtonRightDown)
+	imIo.SetMouseButtonDown(imgui.MouseButtonMiddle, isSdlButtonMiddleDown)
 }
 
 func (w *Window) handleWindowResize() {

input/input.go

@@ -31,8 +31,8 @@ type mouseWheelState struct {
 }
 
 var (
-	keyMap        = make(map[sdl.Keycode]*keyState)
-	mouseBtnMap   = make(map[int]*mouseBtnState)
+	keyMap        = make(map[sdl.Keycode]keyState)
+	mouseBtnMap   = make(map[int]mouseBtnState)
 	mouseMotion   = mouseMotionState{}
 	mouseWheel    = mouseWheelState{}
 	quitRequested bool
@@ -70,29 +70,31 @@ func IsQuitClicked() bool {
 
 func HandleKeyboardEvent(e *sdl.KeyboardEvent) {
 
-	ks := keyMap[e.Keysym.Sym]
-	if ks == nil {
-		ks = &keyState{Key: e.Keysym.Sym}
-		keyMap[ks.Key] = ks
+	ks, ok := keyMap[e.Keysym.Sym]
+	if !ok {
+		ks = keyState{Key: e.Keysym.Sym}
 	}
 
 	ks.State = int(e.State)
 	ks.IsPressedThisFrame = e.State == sdl.PRESSED && e.Repeat == 0
 	ks.IsReleasedThisFrame = e.State == sdl.RELEASED && e.Repeat == 0
+
+	keyMap[ks.Key] = ks
 }
 
 func HandleMouseBtnEvent(e *sdl.MouseButtonEvent) {
 
-	mb := mouseBtnMap[int(e.Button)]
-	if mb == nil {
-		mb = &mouseBtnState{Btn: int(e.Button)}
-		mouseBtnMap[int(e.Button)] = mb
+	mb, ok := mouseBtnMap[int(e.Button)]
+	if !ok {
+		mb = mouseBtnState{Btn: int(e.Button)}
 	}
 
 	mb.State = int(e.State)
 	mb.IsDoubleClicked = e.Clicks == 2 && e.State == sdl.PRESSED
 	mb.IsPressedThisFrame = e.State == sdl.PRESSED
 	mb.IsReleasedThisFrame = e.State == sdl.RELEASED
+
+	mouseBtnMap[int(e.Button)] = mb
 }
 
 func HandleMouseMotionEvent(e *sdl.MouseMotionEvent) {
@@ -109,12 +111,12 @@ func HandleMouseWheelEvent(e *sdl.MouseWheelEvent) {
 	mouseWheel.YDelta = e.Y
 }
 
-//GetMousePos returns the window coordinates of the mouse
+// GetMousePos returns the window coordinates of the mouse
 func GetMousePos() (x, y int32) {
 	return mouseMotion.XPos, mouseMotion.YPos
 }
 
-//GetMouseMotion returns how many pixels were moved last frame
+// GetMouseMotion returns how many pixels were moved last frame
 func GetMouseMotion() (xDelta, yDelta int32) {
 	return mouseMotion.XDelta, mouseMotion.YDelta
 }
@@ -141,7 +143,7 @@ func GetMouseWheelMotion() (xDelta, yDelta int32) {
 	return mouseWheel.XDelta, mouseWheel.YDelta
 }
 
-//GetMouseWheelXNorm returns 1 if mouse wheel xDelta > 0, -1 if xDelta < 0, and 0 otherwise
+// GetMouseWheelXNorm returns 1 if mouse wheel xDelta > 0, -1 if xDelta < 0, and 0 otherwise
 func GetMouseWheelXNorm() int32 {
 
 	if mouseWheel.XDelta > 0 {
@@ -153,7 +155,7 @@ func GetMouseWheelXNorm() int32 {
 	return 0
 }
 
-//returns 1 if mouse wheel yDelta > 0, -1 if yDelta < 0, and 0 otherwise
+// returns 1 if mouse wheel yDelta > 0, -1 if yDelta < 0, and 0 otherwise
 func GetMouseWheelYNorm() int32 {
 
 	if mouseWheel.YDelta > 0 {
@@ -167,8 +169,8 @@ func GetMouseWheelYNorm() int32 {
 
 func KeyClicked(kc sdl.Keycode) bool {
 
-	ks := keyMap[kc]
-	if ks == nil {
+	ks, ok := keyMap[kc]
+	if !ok {
 		return false
 	}
 
@@ -177,8 +179,8 @@ func KeyClicked(kc sdl.Keycode) bool {
 
 func KeyReleased(kc sdl.Keycode) bool {
 
-	ks := keyMap[kc]
-	if ks == nil {
+	ks, ok := keyMap[kc]
+	if !ok {
 		return false
 	}
 
@@ -187,8 +189,8 @@ func KeyReleased(kc sdl.Keycode) bool {
 
 func KeyDown(kc sdl.Keycode) bool {
 
-	ks := keyMap[kc]
-	if ks == nil {
+	ks, ok := keyMap[kc]
+	if !ok {
 		return false
 	}
 
@@ -197,8 +199,8 @@ func KeyDown(kc sdl.Keycode) bool {
 
 func KeyUp(kc sdl.Keycode) bool {
 
-	ks := keyMap[kc]
-	if ks == nil {
+	ks, ok := keyMap[kc]
+	if !ok {
 		return true
 	}
 
@@ -207,8 +209,8 @@ func KeyUp(kc sdl.Keycode) bool {
 
 func MouseClicked(mb int) bool {
 
-	btn := mouseBtnMap[mb]
-	if btn == nil {
+	btn, ok := mouseBtnMap[mb]
+	if !ok {
 		return false
 	}
 
@@ -217,8 +219,8 @@ func MouseClicked(mb int) bool {
 
 func MouseDoubleClicked(mb int) bool {
 
-	btn := mouseBtnMap[mb]
-	if btn == nil {
+	btn, ok := mouseBtnMap[mb]
+	if !ok {
 		return false
 	}
 
@@ -226,8 +228,8 @@ func MouseDoubleClicked(mb int) bool {
 }
 
 func MouseReleased(mb int) bool {
-	btn := mouseBtnMap[mb]
-	if btn == nil {
+	btn, ok := mouseBtnMap[mb]
+	if !ok {
 		return false
 	}
 
@@ -236,8 +238,8 @@ func MouseReleased(mb int) bool {
 
 func MouseDown(mb int) bool {
 
-	btn := mouseBtnMap[mb]
-	if btn == nil {
+	btn, ok := mouseBtnMap[mb]
+	if !ok {
 		return false
 	}
 
@@ -246,8 +248,8 @@ func MouseDown(mb int) bool {
 
 func MouseUp(mb int) bool {
 
-	btn := mouseBtnMap[mb]
-	if btn == nil {
+	btn, ok := mouseBtnMap[mb]
+	if !ok {
 		return true
 	}
 

main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"runtime"
+	"strconv"
 
 	imgui "github.com/AllenDang/cimgui-go"
 	"github.com/bloeys/gglm/gglm"
@@ -22,16 +23,65 @@ import (
 	"github.com/veandco/go-sdl2/sdl"
 )
 
-// @Todo:
-// Integrate physx
-// Create VAO struct independent from VBO to support multi-VBO use cases (e.g. instancing)
-// Renderer batching
-// Scene graph
-// Separate engine loop from rendering loop? or leave it to the user?
-// Abstract keys enum away from sdl
-// Proper Asset loading
-// Frustum culling
-// Material system editor with fields automatically extracted from the shader
+/*
+@TODO:
+	- Rendering:
+		- Phong lighting model ✅
+		- Directional lights ✅
+		- Point lights ✅
+		- Spotlights ✅
+		- HDR
+		- Cascaded shadow mapping
+		- Skeletal animations
+	- Create VAO struct independent from VBO to support multi-VBO use cases (e.g. instancing)
+	- Renderer batching
+	- Scene graph
+	- Separate engine loop from rendering loop? or leave it to the user?
+	- Abstract keys enum away from sdl
+	- Proper Asset loading
+	- Frustum culling
+	- Material system editor with fields automatically extracted from the shader
+*/
+
+type DirLight struct {
+	Dir           gglm.Vec3
+	DiffuseColor  gglm.Vec3
+	SpecularColor gglm.Vec3
+}
+
+// Check https://wiki.ogre3d.org/tiki-index.php?page=-Point+Light+Attenuation for values
+type PointLight struct {
+	Pos           gglm.Vec3
+	DiffuseColor  gglm.Vec3
+	SpecularColor gglm.Vec3
+
+	Radius float32
+
+	Constant  float32
+	Linear    float32
+	Quadratic float32
+}
+
+type SpotLight struct {
+	Pos           gglm.Vec3
+	Dir           gglm.Vec3
+	DiffuseColor  gglm.Vec3
+	SpecularColor gglm.Vec3
+	InnerCutoff   float32
+	OuterCutoff   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)
+}
 
 const (
 	camSpeed         = 15
@@ -45,30 +95,87 @@ var (
 	window *engine.Window
 
 	pitch float32 = 0
-	yaw   float32 = -90
+	yaw   float32 = -1.5
 	cam   *camera.Camera
 
-	simpleMat *materials.Material
-	skyboxMat *materials.Material
+	whiteMat      *materials.Material
+	containerMat  *materials.Material
+	palleteMat    *materials.Material
+	skyboxMat     *materials.Material
+	debugDepthMat *materials.Material
 
-	chairMesh  *meshes.Mesh
 	cubeMesh   *meshes.Mesh
+	sphereMesh *meshes.Mesh
+	chairMesh  *meshes.Mesh
 	skyboxMesh *meshes.Mesh
 
 	cubeModelMat = gglm.NewTrMatId()
 
-	lightPos1   = gglm.NewVec3(-2, 0, 2)
-	lightColor1 = gglm.NewVec3(1, 1, 1)
-
-	debugDepthMat        *materials.Material
+	drawSkybox           = true
 	debugDrawDepthBuffer bool
 
 	skyboxCmap assets.Cubemap
 
 	dpiScaling float32
+
+	// Light settings
+	ambientColor = gglm.NewVec3(0, 0, 0)
+
+	// Lights
+	dirLight = DirLight{
+		Dir:           *gglm.NewVec3(0, -0.8, 0.2).Normalize(),
+		DiffuseColor:  *gglm.NewVec3(0, 0, 0),
+		SpecularColor: *gglm.NewVec3(0, 0, 0),
+	}
+	pointLights = [...]PointLight{
+		{
+			Pos:           *gglm.NewVec3(0, 5, 0),
+			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,
+		},
+		{
+			Pos:           *gglm.NewVec3(0, -5, 0),
+			DiffuseColor:  *gglm.NewVec3(0, 1, 0),
+			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Constant:      1.0,
+			Linear:        0.09,
+			Quadratic:     0.032,
+		},
+		{
+			Pos:           *gglm.NewVec3(5, 0, 0),
+			DiffuseColor:  *gglm.NewVec3(1, 1, 1),
+			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Constant:      1.0,
+			Linear:        0.09,
+			Quadratic:     0.032,
+		},
+		{
+			Pos:           *gglm.NewVec3(-4, 0, 0),
+			DiffuseColor:  *gglm.NewVec3(0, 0, 1),
+			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			Constant:      1.0,
+			Linear:        0.09,
+			Quadratic:     0.032,
+		},
+	}
+	spotLights = [...]SpotLight{
+		{
+			Pos:           *gglm.NewVec3(0, 5, 0),
+			Dir:           *gglm.NewVec3(0, -1, 0),
+			DiffuseColor:  *gglm.NewVec3(0, 1, 1),
+			SpecularColor: *gglm.NewVec3(1, 1, 1),
+			// These must be cosine values
+			InnerCutoff: gglm.Cos32(15 * gglm.Deg2Rad),
+			OuterCutoff: gglm.Cos32(20 * gglm.Deg2Rad),
+		},
+	}
 )
 
-type OurGame struct {
+type Game struct {
 	Win       *engine.Window
 	ImGUIInfo nmageimgui.ImguiInfo
 }
@@ -145,7 +252,7 @@ func main() {
 	engine.SetVSync(false)
 	engine.SetSrgbFramebuffer(true)
 
-	game := &OurGame{
+	game := &Game{
 		Win:       window,
 		ImGUIInfo: nmageimgui.NewImGui("./res/shaders/imgui.glsl"),
 	}
@@ -154,7 +261,7 @@ func main() {
 	engine.Run(game, window, game.ImGUIInfo)
 }
 
-func (g *OurGame) handleWindowEvents(e sdl.Event) {
+func (g *Game) handleWindowEvents(e sdl.Event) {
 
 	switch e := e.(type) {
 	case *sdl.WindowEvent:
@@ -165,7 +272,7 @@ func (g *OurGame) handleWindowEvents(e sdl.Event) {
 			cam.AspectRatio = float32(width) / float32(height)
 			cam.Update()
 
-			simpleMat.SetUnifMat4("projMat", &cam.ProjMat)
+			palleteMat.SetUnifMat4("projMat", &cam.ProjMat)
 			debugDepthMat.SetUnifMat4("projMat", &cam.ProjMat)
 		}
 	}
@@ -205,17 +312,28 @@ func getDpiScaling(unscaledWindowWidth, unscaledWindowHeight int32) float32 {
 	return dpiScaling
 }
 
-func (g *OurGame) Init() {
+func (g *Game) Init() {
 
 	var err error
 
-	//Create materials
-	simpleMat = materials.NewMaterial("Simple mat", "./res/shaders/simple.glsl")
-	debugDepthMat = materials.NewMaterial("Debug depth mat", "./res/shaders/debug-depth.glsl")
-	skyboxMat = materials.NewMaterial("Skybox mat", "./res/shaders/skybox.glsl")
+	// Camera
+	winWidth, winHeight := g.Win.SDLWin.GetSize()
+	cam = camera.NewPerspective(
+		gglm.NewVec3(0, 0, 10),
+		gglm.NewVec3(0, 0, -1),
+		gglm.NewVec3(0, 1, 0),
+		0.1, 200,
+		45*gglm.Deg2Rad,
+		float32(winWidth)/float32(winHeight),
+	)
 
 	//Load meshes
-	cubeMesh, err = meshes.NewMesh("Cube", "./res/models/tex-cube.fbx", 0)
+	cubeMesh, err = meshes.NewMesh("Cube", "./res/models/cube.fbx", 0)
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load mesh. Err: ", err)
+	}
+
+	sphereMesh, err = meshes.NewMesh("Sphere", "./res/models/sphere.fbx", 0)
 	if err != nil {
 		logging.ErrLog.Fatalln("Failed to load mesh. Err: ", err)
 	}
@@ -231,7 +349,27 @@ func (g *OurGame) Init() {
 	}
 
 	//Load textures
-	tex, err := assets.LoadTexturePNG("./res/textures/pallete-endesga-64-1x.png", &assets.TextureLoadOptions{TextureIsSrgba: true})
+	whiteTex, err := assets.LoadTexturePNG("./res/textures/white.png", &assets.TextureLoadOptions{TextureIsSrgba: true})
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
+	}
+
+	blackTex, err := assets.LoadTexturePNG("./res/textures/black.png", &assets.TextureLoadOptions{TextureIsSrgba: true})
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
+	}
+
+	containerDiffuseTex, err := assets.LoadTexturePNG("./res/textures/container-diffuse.png", &assets.TextureLoadOptions{TextureIsSrgba: true})
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
+	}
+
+	containerSpecularTex, err := assets.LoadTexturePNG("./res/textures/container-specular.png", &assets.TextureLoadOptions{TextureIsSrgba: true})
+	if err != nil {
+		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
+	}
+
+	palleteTex, err := assets.LoadTexturePNG("./res/textures/pallete-endesga-64-1x.png", &assets.TextureLoadOptions{TextureIsSrgba: true})
 	if err != nil {
 		logging.ErrLog.Fatalln("Failed to load texture. Err: ", err)
 	}
@@ -246,37 +384,136 @@ func (g *OurGame) Init() {
 		logging.ErrLog.Fatalln("Failed to load cubemap. Err: ", err)
 	}
 
-	// Configure materials
-	simpleMat.DiffuseTex = tex.TexID
+	// Create materials and assign any unused texture slots to black
+	whiteMat = materials.NewMaterial("White mat", "./res/shaders/simple.glsl")
+	whiteMat.Shininess = 64
+	whiteMat.DiffuseTex = whiteTex.TexID
+	whiteMat.SpecularTex = blackTex.TexID
+	whiteMat.NormalTex = blackTex.TexID
+	whiteMat.EmissionTex = blackTex.TexID
+	whiteMat.SetUnifInt32("material.diffuse", 0)
+	whiteMat.SetUnifInt32("material.specular", 1)
+	// whiteMat.SetUnifInt32("material.normal", 2)
+	whiteMat.SetUnifInt32("material.emission", 3)
+	whiteMat.SetUnifMat4("projMat", &cam.ProjMat)
+	whiteMat.SetUnifVec3("ambientColor", ambientColor)
+	whiteMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
+	whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+	whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+	whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
 
-	//Movement, scale and rotation
+	containerMat = materials.NewMaterial("Container mat", "./res/shaders/simple.glsl")
+	containerMat.Shininess = 64
+	containerMat.DiffuseTex = containerDiffuseTex.TexID
+	containerMat.SpecularTex = containerSpecularTex.TexID
+	containerMat.NormalTex = blackTex.TexID
+	containerMat.EmissionTex = blackTex.TexID
+	containerMat.SetUnifInt32("material.diffuse", 0)
+	containerMat.SetUnifInt32("material.specular", 1)
+	// containerMat.SetUnifInt32("material.normal", 2)
+	containerMat.SetUnifInt32("material.emission", 3)
+	containerMat.SetUnifMat4("projMat", &cam.ProjMat)
+	containerMat.SetUnifVec3("ambientColor", ambientColor)
+	containerMat.SetUnifFloat32("material.shininess", containerMat.Shininess)
+	containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+	containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+	containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+
+	palleteMat = materials.NewMaterial("Pallete mat", "./res/shaders/simple.glsl")
+	palleteMat.Shininess = 64
+	palleteMat.DiffuseTex = palleteTex.TexID
+	palleteMat.SpecularTex = blackTex.TexID
+	palleteMat.NormalTex = blackTex.TexID
+	palleteMat.EmissionTex = blackTex.TexID
+	palleteMat.SetUnifInt32("material.diffuse", 0)
+	palleteMat.SetUnifInt32("material.specular", 1)
+	// palleteMat.SetUnifInt32("material.normal", 2)
+	palleteMat.SetUnifInt32("material.emission", 3)
+	palleteMat.SetUnifMat4("projMat", &cam.ProjMat)
+	palleteMat.SetUnifVec3("ambientColor", ambientColor)
+	palleteMat.SetUnifFloat32("material.shininess", palleteMat.Shininess)
+	palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+	palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+
+	debugDepthMat = materials.NewMaterial("Debug depth mat", "./res/shaders/debug-depth.glsl")
+	debugDepthMat.SetUnifMat4("projMat", &cam.ProjMat)
+
+	skyboxMat = materials.NewMaterial("Skybox mat", "./res/shaders/skybox.glsl")
+
+	// Movement, scale and rotation
 	translationMat := gglm.NewTranslationMat(gglm.NewVec3(0, 0, 0))
 	scaleMat := gglm.NewScaleMat(gglm.NewVec3(1, 1, 1))
 	rotMat := gglm.NewRotMat(gglm.NewQuatEuler(gglm.NewVec3(-90, -90, 0).AsRad()))
-
 	cubeModelMat.Mul(translationMat.Mul(rotMat.Mul(scaleMat)))
 
-	// Camera
-	winWidth, winHeight := g.Win.SDLWin.GetSize()
-	cam = camera.NewPerspective(
-		gglm.NewVec3(0, 0, 10),
-		gglm.NewVec3(0, 0, -1),
-		gglm.NewVec3(0, 1, 0),
-		0.1, 200,
-		45*gglm.Deg2Rad,
-		float32(winWidth)/float32(winHeight),
-	)
-	simpleMat.SetUnifMat4("projMat", &cam.ProjMat)
-	debugDepthMat.SetUnifMat4("projMat", &cam.ProjMat)
-
+	g.updateLights()
 	updateViewMat()
-
-	//Lights
-	simpleMat.SetUnifVec3("lightPos1", lightPos1)
-	simpleMat.SetUnifVec3("lightColor1", lightColor1)
 }
 
-func (g *OurGame) Update() {
+func (g *Game) updateLights() {
+
+	for i := 0; i < len(pointLights); i++ {
+
+		pl := &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+".diffuseColor", &pl.DiffuseColor)
+		containerMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+		palleteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+
+		whiteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+		containerMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+		palleteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+
+		whiteMat.SetUnifFloat32(indexString+".constant", pl.Constant)
+		containerMat.SetUnifFloat32(indexString+".constant", pl.Constant)
+		palleteMat.SetUnifFloat32(indexString+".constant", pl.Constant)
+
+		whiteMat.SetUnifFloat32(indexString+".linear", pl.Linear)
+		containerMat.SetUnifFloat32(indexString+".linear", pl.Linear)
+		palleteMat.SetUnifFloat32(indexString+".linear", pl.Linear)
+
+		whiteMat.SetUnifFloat32(indexString+".quadratic", pl.Quadratic)
+		containerMat.SetUnifFloat32(indexString+".quadratic", pl.Quadratic)
+		palleteMat.SetUnifFloat32(indexString+".quadratic", pl.Quadratic)
+	}
+
+	for i := 0; i < len(spotLights); i++ {
+
+		l := &spotLights[i]
+		indexString := "spotLights[" + strconv.Itoa(i) + "]"
+
+		whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+		containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
+		palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+
+		whiteMat.SetUnifVec3(indexString+".dir", &l.Dir)
+		containerMat.SetUnifVec3(indexString+".dir", &l.Dir)
+		palleteMat.SetUnifVec3(indexString+".dir", &l.Dir)
+
+		whiteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+		containerMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+		palleteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+
+		whiteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
+		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+".outerCutoff", l.OuterCutoff)
+		containerMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
+		palleteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
+	}
+}
+
+func (g *Game) Update() {
 
 	if input.IsQuitClicked() || input.KeyClicked(sdl.K_ESCAPE) {
 		engine.Quit()
@@ -285,31 +522,12 @@ func (g *OurGame) Update() {
 	g.updateCameraLookAround()
 	g.updateCameraPos()
 
-	imgui.ShowDemoWindow()
-
 	//Rotating cubes
 	if input.KeyDown(sdl.K_SPACE) {
 		cubeModelMat.Rotate(10*timing.DT()*gglm.Deg2Rad, gglm.NewVec3(1, 1, 1).Normalize())
 	}
 
-	imgui.Begin("Debug controls")
-	if imgui.DragFloat3("Cam Pos", &cam.Pos.Data) {
-		updateViewMat()
-	}
-	if imgui.DragFloat3("Cam Forward", &cam.Forward.Data) {
-		updateViewMat()
-	}
-
-	if imgui.DragFloat3("Light Pos 1", &lightPos1.Data) {
-		simpleMat.SetUnifVec3("lightPos1", lightPos1)
-	}
-
-	if imgui.DragFloat3("Light Color 1", &lightColor1.Data) {
-		simpleMat.SetUnifVec3("lightColor1", lightColor1)
-	}
-
-	imgui.Checkbox("Debug depth buffer", &debugDrawDepthBuffer)
-	imgui.End()
+	g.showDebugWindow()
 
 	if input.KeyClicked(sdl.K_F4) {
 		fmt.Printf("Pos: %s; Forward: %s; |Forward|: %f\n", cam.Pos.String(), cam.Forward.String(), cam.Forward.Mag())
@@ -318,7 +536,172 @@ func (g *OurGame) Update() {
 	g.Win.SDLWin.SetTitle(fmt.Sprint("nMage (", timing.GetAvgFPS(), " fps)"))
 }
 
-func (g *OurGame) updateCameraLookAround() {
+func (g *Game) showDebugWindow() {
+
+	imgui.ShowDemoWindow()
+
+	imgui.Begin("Debug controls")
+
+	// Camera
+	imgui.Text("Camera")
+	if imgui.DragFloat3("Cam Pos", &cam.Pos.Data) {
+		updateViewMat()
+	}
+	if imgui.DragFloat3("Cam Forward", &cam.Forward.Data) {
+		updateViewMat()
+	}
+
+	imgui.Spacing()
+
+	// Ambient light
+	imgui.Text("Ambient Light")
+
+	if imgui.DragFloat3("Ambient Color", &ambientColor.Data) {
+		whiteMat.SetUnifVec3("ambientColor", ambientColor)
+		containerMat.SetUnifVec3("ambientColor", ambientColor)
+		palleteMat.SetUnifVec3("ambientColor", ambientColor)
+	}
+
+	imgui.Spacing()
+
+	// Specular
+	imgui.Text("Specular Settings")
+
+	if imgui.DragFloat("Specular Shininess", &whiteMat.Shininess) {
+		whiteMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
+		containerMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
+		palleteMat.SetUnifFloat32("material.shininess", whiteMat.Shininess)
+	}
+
+	imgui.Spacing()
+
+	// Directional light
+	imgui.Text("Directional Light")
+
+	if imgui.DragFloat3("Direction", &dirLight.Dir.Data) {
+		whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+		containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+		palleteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir)
+	}
+
+	if imgui.DragFloat3("Diffuse Color", &dirLight.DiffuseColor.Data) {
+		whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+		containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+		palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor)
+	}
+
+	if imgui.DragFloat3("Specular Color", &dirLight.SpecularColor.Data) {
+		whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+		containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+		palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor)
+	}
+
+	imgui.Spacing()
+
+	// Point lights
+	if imgui.BeginListBoxV("Point Lights", imgui.Vec2{Y: 200}) {
+
+		for i := 0; i < len(pointLights); i++ {
+
+			pl := &pointLights[i]
+			indexNumString := strconv.Itoa(i)
+
+			if !imgui.TreeNodeExStrV("Point Light "+indexNumString, imgui.TreeNodeFlagsSpanAvailWidth) {
+				continue
+			}
+
+			indexString := "pointLights[" + indexNumString + "]"
+
+			if imgui.DragFloat3("Pos", &pl.Pos.Data) {
+				whiteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
+				containerMat.SetUnifVec3(indexString+".pos", &pl.Pos)
+				palleteMat.SetUnifVec3(indexString+".pos", &pl.Pos)
+			}
+
+			if imgui.DragFloat3("Diffuse Color", &pl.DiffuseColor.Data) {
+				whiteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+				containerMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+				palleteMat.SetUnifVec3(indexString+".diffuseColor", &pl.DiffuseColor)
+			}
+
+			if imgui.DragFloat3("Specular Color", &pl.SpecularColor.Data) {
+				whiteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+				containerMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+				palleteMat.SetUnifVec3(indexString+".specularColor", &pl.SpecularColor)
+			}
+
+			imgui.TreePop()
+		}
+
+		imgui.EndListBox()
+	}
+
+	// Spot lights
+	if imgui.BeginListBoxV("Spot Lights", imgui.Vec2{Y: 200}) {
+
+		for i := 0; i < len(spotLights); i++ {
+
+			l := &spotLights[i]
+			indexNumString := strconv.Itoa(i)
+
+			if !imgui.TreeNodeExStrV("Spot Light "+indexNumString, imgui.TreeNodeFlagsSpanAvailWidth) {
+				continue
+			}
+
+			indexString := "spotLights[" + indexNumString + "]"
+
+			if imgui.DragFloat3("Pos", &l.Pos.Data) {
+				whiteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+				containerMat.SetUnifVec3(indexString+".pos", &l.Pos)
+				palleteMat.SetUnifVec3(indexString+".pos", &l.Pos)
+			}
+
+			if imgui.DragFloat3("Dir", &l.Dir.Data) {
+				whiteMat.SetUnifVec3(indexString+".dir", &l.Dir)
+				containerMat.SetUnifVec3(indexString+".dir", &l.Dir)
+				palleteMat.SetUnifVec3(indexString+".dir", &l.Dir)
+			}
+
+			if imgui.DragFloat3("Diffuse Color", &l.DiffuseColor.Data) {
+				whiteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+				containerMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+				palleteMat.SetUnifVec3(indexString+".diffuseColor", &l.DiffuseColor)
+			}
+
+			if imgui.DragFloat3("Specular Color", &l.SpecularColor.Data) {
+				whiteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
+				containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor)
+				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("Outer Cutoff", &l.OuterCutoff) {
+				whiteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
+				containerMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
+				palleteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff)
+			}
+
+			imgui.TreePop()
+		}
+
+		imgui.EndListBox()
+	}
+
+	// Other
+	imgui.Text("Other Settings")
+
+	imgui.Checkbox("Draw Skybox", &drawSkybox)
+	imgui.Checkbox("Debug depth buffer", &debugDrawDepthBuffer)
+
+	imgui.End()
+}
+
+func (g *Game) updateCameraLookAround() {
 
 	mouseX, mouseY := input.GetMouseMotion()
 	if (mouseX == 0 && mouseY == 0) || !input.MouseDown(sdl.BUTTON_RIGHT) {
@@ -330,12 +713,12 @@ func (g *OurGame) updateCameraLookAround() {
 
 	// Pitch
 	pitch += float32(-mouseY) * mouseSensitivity * timing.DT()
-	if pitch > 89.0 {
-		pitch = 89.0
+	if pitch > 1.5 {
+		pitch = 1.5
 	}
 
-	if pitch < -89.0 {
-		pitch = -89.0
+	if pitch < -1.5 {
+		pitch = -1.5
 	}
 
 	// Update cam forward
@@ -344,7 +727,7 @@ func (g *OurGame) updateCameraLookAround() {
 	updateViewMat()
 }
 
-func (g *OurGame) updateCameraPos() {
+func (g *Game) updateCameraPos() {
 
 	update := false
 
@@ -376,29 +759,55 @@ func (g *OurGame) updateCameraPos() {
 	}
 }
 
-func (g *OurGame) Render() {
-
-	matToUse := simpleMat
-	if debugDrawDepthBuffer {
-		matToUse = debugDepthMat
-	}
+func (g *Game) Render() {
 
 	tempModelMatrix := cubeModelMat.Clone()
-	window.Rend.Draw(chairMesh, tempModelMatrix, matToUse)
 
+	whiteMat.SetUnifVec3("camPos", &cam.Pos)
+	containerMat.SetUnifVec3("camPos", &cam.Pos)
+	palleteMat.SetUnifVec3("camPos", &cam.Pos)
+
+	sunMat := palleteMat
+	chairMat := palleteMat
+	cubeMat := containerMat
+	if debugDrawDepthBuffer {
+		sunMat = debugDepthMat
+		chairMat = debugDepthMat
+		cubeMat = debugDepthMat
+	}
+
+	// Draw dir light
+	window.Rend.Draw(sphereMesh, gglm.NewTrMatId().Translate(gglm.NewVec3(0, 10, 0)).Scale(gglm.NewVec3(0.1, 0.1, 0.1)), sunMat)
+
+	// Draw point lights
+	for i := 0; i < len(pointLights); i++ {
+
+		pl := &pointLights[i]
+		window.Rend.Draw(cubeMesh, gglm.NewTrMatId().Translate(&pl.Pos).Scale(gglm.NewVec3(0.1, 0.1, 0.1)), sunMat)
+	}
+
+	// Chair
+	window.Rend.Draw(chairMesh, tempModelMatrix, chairMat)
+
+	// Ground
+	window.Rend.Draw(cubeMesh, gglm.NewTrMatId().Translate(gglm.NewVec3(0, -3, 0)).Scale(gglm.NewVec3(20, 1, 20)), cubeMat)
+
+	// Cubes
 	rowSize := 1
 	for y := 0; y < rowSize; y++ {
 		for x := 0; x < rowSize; x++ {
 			tempModelMatrix.Translate(gglm.NewVec3(-6, 0, 0))
-			window.Rend.Draw(cubeMesh, tempModelMatrix, matToUse)
+			window.Rend.Draw(cubeMesh, tempModelMatrix, cubeMat)
 		}
 		tempModelMatrix.Translate(gglm.NewVec3(float32(rowSize), -1, 0))
 	}
 
-	g.DrawSkybox()
+	if drawSkybox {
+		g.DrawSkybox()
+	}
 }
 
-func (g *OurGame) DrawSkybox() {
+func (g *Game) DrawSkybox() {
 
 	gl.Disable(gl.CULL_FACE)
 	gl.DepthFunc(gl.LEQUAL)
@@ -418,7 +827,6 @@ func (g *OurGame) DrawSkybox() {
 
 	skyboxMat.SetUnifMat4("viewMat", viewMat)
 	skyboxMat.SetUnifMat4("projMat", &cam.ProjMat)
-	// window.Rend.Draw(cubeMesh, gglm.NewTrMatId(), skyboxMat)
 	for i := 0; i < len(skyboxMesh.SubMeshes); i++ {
 		gl.DrawElementsBaseVertexWithOffset(gl.TRIANGLES, skyboxMesh.SubMeshes[i].IndexCount, gl.UNSIGNED_INT, uintptr(skyboxMesh.SubMeshes[i].BaseIndex), skyboxMesh.SubMeshes[i].BaseVertex)
 	}
@@ -427,15 +835,17 @@ func (g *OurGame) DrawSkybox() {
 	gl.Enable(gl.CULL_FACE)
 }
 
-func (g *OurGame) FrameEnd() {
+func (g *Game) FrameEnd() {
 }
 
-func (g *OurGame) DeInit() {
+func (g *Game) DeInit() {
 	g.Win.Destroy()
 }
 
 func updateViewMat() {
 	cam.Update()
-	simpleMat.SetUnifMat4("viewMat", &cam.ViewMat)
+	whiteMat.SetUnifMat4("viewMat", &cam.ViewMat)
+	containerMat.SetUnifMat4("viewMat", &cam.ViewMat)
+	palleteMat.SetUnifMat4("viewMat", &cam.ViewMat)
 	debugDepthMat.SetUnifMat4("viewMat", &cam.ViewMat)
 }

materials/material.go

@@ -12,10 +12,16 @@ type Material struct {
 	Name       string
 	ShaderProg shaders.ShaderProgram
 
-	DiffuseTex uint32
-
 	UnifLocs   map[string]int32
 	AttribLocs map[string]int32
+
+	// Phong shading
+	DiffuseTex  uint32
+	SpecularTex uint32
+	NormalTex   uint32
+	EmissionTex uint32
+
+	Shininess float32
 }
 
 func (m *Material) Bind() {
@@ -24,6 +30,15 @@ func (m *Material) Bind() {
 
 	gl.ActiveTexture(gl.TEXTURE0)
 	gl.BindTexture(gl.TEXTURE_2D, m.DiffuseTex)
+
+	gl.ActiveTexture(gl.TEXTURE1)
+	gl.BindTexture(gl.TEXTURE_2D, m.SpecularTex)
+
+	gl.ActiveTexture(gl.TEXTURE2)
+	gl.BindTexture(gl.TEXTURE_2D, m.NormalTex)
+
+	gl.ActiveTexture(gl.TEXTURE3)
+	gl.BindTexture(gl.TEXTURE_2D, m.EmissionTex)
 }
 
 func (m *Material) UnBind() {
@@ -32,6 +47,15 @@ func (m *Material) UnBind() {
 	//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 {

res/shaders/simple.glsl

@@ -18,7 +18,12 @@ uniform mat4 projMat;
 
 void main()
 {
+    // @TODO: Calculate this on the CPU and send it as a uniform
+
+    // This produces the normal matrix that multiplies with the model normal to produce the
+    // world space normal. Based on 'One last thing' section from: https://learnopengl.com/Lighting/Basic-Lighting
     vertNormal = mat3(transpose(inverse(modelMat))) * vertNormalIn;
+    
     vertUV0 = vertUV0In;
     vertColor = vertColorIn;
     fragPos = vec3(modelMat * vec4(vertPosIn, 1.0));
@@ -29,13 +34,50 @@ void main()
 //shader:fragment
 #version 410
 
-uniform float ambientStrength = 0;
-uniform vec3 ambientLightColor = vec3(1, 1, 1);
+struct Material {
+    sampler2D diffuse;
+    sampler2D specular;
+    // sampler2D normal;
+    sampler2D emission;
+    float shininess;
+};
 
-uniform vec3 lightPos1;
-uniform vec3 lightColor1;
+uniform Material material;
 
-uniform sampler2D diffTex;
+struct DirLight {
+    vec3 dir;
+    vec3 diffuseColor;
+    vec3 specularColor;
+};
+
+uniform DirLight dirLight;
+
+struct PointLight {
+    vec3 pos;
+    vec3 diffuseColor;
+    vec3 specularColor;
+    float constant;
+    float linear;
+    float quadratic;
+};
+
+#define NUM_POINT_LIGHTS 16
+uniform PointLight pointLights[NUM_POINT_LIGHTS];
+
+struct SpotLight {
+    vec3 pos;
+    vec3 dir;
+    vec3 diffuseColor;
+    vec3 specularColor;
+    float innerCutoff;
+    float outerCutoff;
+};
+
+#define NUM_SPOT_LIGHTS 4
+uniform SpotLight spotLights[NUM_SPOT_LIGHTS];
+
+uniform vec3 camPos;
+uniform vec3 ambientColor = vec3(0.2, 0.2, 0.2);
 
 in vec3 vertColor;
 in vec3 vertNormal;
@@ -44,12 +86,108 @@ in vec3 fragPos;
 
 out vec4 fragColor;
 
+// Global variables used as cache for lighting calculations
+vec4 diffuseTexColor;
+vec4 specularTexColor;
+vec4 emissionTexColor;
+vec3 normalizedVertNorm;
+vec3 viewDir;
+
+vec3 CalcDirLight()
+{
+    vec3 lightDir = normalize(-dirLight.dir);
+
+    // Diffuse
+    float diffuseAmount = max(0.0, dot(normalizedVertNorm, lightDir));
+    vec3 finalDiffuse = diffuseAmount * dirLight.diffuseColor * diffuseTexColor.rgb;
+
+    // Specular
+    vec3 reflectDir = reflect(-lightDir, normalizedVertNorm);
+    float specularAmount = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
+    vec3 finalSpecular = specularAmount * dirLight.specularColor * specularTexColor.rgb;
+
+    return finalDiffuse + finalSpecular;
+}
+
+vec3 CalcPointLight(PointLight pointLight)
+{
+    // Ignore unset lights
+    if (pointLight.constant == 0){
+        return vec3(0);
+    }
+
+    vec3 lightDir = normalize(pointLight.pos - fragPos);
+
+    // Diffuse
+    float diffuseAmount = max(0.0, dot(normalizedVertNorm, lightDir));
+    vec3 finalDiffuse = diffuseAmount * pointLight.diffuseColor * diffuseTexColor.rgb;
+
+    // Specular
+    vec3 reflectDir = reflect(-lightDir, normalizedVertNorm);
+    float specularAmount = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
+    vec3 finalSpecular = specularAmount * pointLight.specularColor * specularTexColor.rgb;
+
+    // attenuation
+    float distToLight = length(pointLight.pos - fragPos);
+    float attenuation = 1.0 / (pointLight.constant + pointLight.linear * distToLight + pointLight.quadratic * (distToLight * distToLight));  
+
+    return (finalDiffuse + finalSpecular) * attenuation;
+}
+
+vec3 CalcSpotLight(SpotLight light)
+{
+    if (light.innerCutoff == 0)
+        return vec3(0);
+
+    vec3 fragToLightDir = normalize(light.pos - fragPos);
+
+    // Spot light cone with full intensity within inner cutoff,
+    // and falloff between inner-outer cutoffs, and zero
+    // light after outer cutoff
+    float theta = dot(fragToLightDir, normalize(-light.dir));
+    float epsilon = (light.innerCutoff - light.outerCutoff);
+    float intensity = clamp((theta - light.outerCutoff) / epsilon, 0.0, 1.0);
+
+    if (intensity == 0)
+        return vec3(0);
+
+    // Diffuse
+    float diffuseAmount = max(0.0, dot(normalizedVertNorm, fragToLightDir));
+    vec3 finalDiffuse = diffuseAmount * light.diffuseColor * diffuseTexColor.rgb;
+
+    // Specular
+    vec3 reflectDir = reflect(-fragToLightDir, normalizedVertNorm);
+    float specularAmount = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
+    vec3 finalSpecular = specularAmount * light.specularColor * specularTexColor.rgb;
+
+    return (finalDiffuse + finalSpecular) * intensity;
+}
+
 void main()
 {
-    vec3 lightDir = normalize(lightPos1 - fragPos);  
-    float diffStrength = max(0.0, dot(normalize(vertNormal), lightDir));
+    // Shared values
+    diffuseTexColor = texture(material.diffuse, vertUV0);
+    specularTexColor = texture(material.specular, vertUV0);
+    emissionTexColor = texture(material.emission, vertUV0);
 
-    vec3 finalAmbientColor = ambientLightColor * ambientStrength;
-    vec4 texColor = texture(diffTex, vertUV0);
-    fragColor = vec4(texColor.rgb * vertColor * (finalAmbientColor + diffStrength*lightColor1) , texColor.a);
-} 
+    normalizedVertNorm = normalize(vertNormal);
+    viewDir = normalize(camPos - fragPos);
+
+    // Light contributions
+    vec3 finalColor = CalcDirLight();
+
+    for (int i = 0; i < NUM_POINT_LIGHTS; i++)
+    {
+        finalColor += CalcPointLight(pointLights[i]);
+    }
+
+    for (int i = 0; i < NUM_SPOT_LIGHTS; i++)
+    {
+        finalColor += CalcSpotLight(spotLights[i]);
+    }
+
+    vec3 finalEmission = emissionTexColor.rgb;
+    vec3 finalAmbient = ambientColor * diffuseTexColor.rgb;
+
+    fragColor = vec4(finalColor + finalAmbient + finalEmission, 1);
+}

ui/imgui/imgui.go

@@ -109,6 +109,7 @@ func (i *ImguiInfo) Render(winWidth, winHeight float32, fbWidth, fbHeight int32)
 				cmd.CallUserCallback(list)
 			} else {
 
+				gl.ActiveTexture(gl.TEXTURE0)
 				gl.BindTexture(gl.TEXTURE_2D, *i.TexID)
 				clipRect := cmd.ClipRect()
 				gl.Scissor(int32(clipRect.X), int32(fbHeight)-int32(clipRect.W), int32(clipRect.Z-clipRect.X), int32(clipRect.W-clipRect.Y))
@@ -142,6 +143,7 @@ func (i *ImguiInfo) AddFontTTF(fontPath string, fontSize float32, fontConfig *im
 	f := a.AddFontFromFileTTFV(fontPath, fontSize, fontConfigToUse, glyphRangesToUse.Data())
 	pixels, width, height, _ := a.GetTextureDataAsAlpha8()
 
+	gl.ActiveTexture(gl.TEXTURE0)
 	gl.BindTexture(gl.TEXTURE_2D, *i.TexID)
 	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(width), int32(height), 0, gl.RED, gl.UNSIGNED_BYTE, pixels)
 
@@ -225,6 +227,7 @@ func NewImGui(shaderPath string) ImguiInfo {
 	gl.GenTextures(1, imguiInfo.TexID)
 
 	// Upload font to gpu
+	gl.ActiveTexture(gl.TEXTURE0)
 	gl.BindTexture(gl.TEXTURE_2D, *imguiInfo.TexID)
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
 	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)