diff --git a/buffers/framebuffer.go b/buffers/framebuffer.go index bdbda3a..6491847 100755 --- a/buffers/framebuffer.go +++ b/buffers/framebuffer.go @@ -11,6 +11,7 @@ type FramebufferAttachmentType int32 const ( FramebufferAttachmentType_Unknown FramebufferAttachmentType = iota FramebufferAttachmentType_Texture + FramebufferAttachmentType_Texture_Array FramebufferAttachmentType_Renderbuffer FramebufferAttachmentType_Cubemap FramebufferAttachmentType_Cubemap_Array @@ -21,6 +22,8 @@ func (f FramebufferAttachmentType) IsValid() bool { switch f { case FramebufferAttachmentType_Texture: fallthrough + case FramebufferAttachmentType_Texture_Array: + fallthrough case FramebufferAttachmentType_Renderbuffer: fallthrough case FramebufferAttachmentType_Cubemap: @@ -180,6 +183,10 @@ func (fbo *Framebuffer) NewColorAttachment( 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) } @@ -271,6 +278,10 @@ func (fbo *Framebuffer) NewDepthAttachment( 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, @@ -407,6 +418,68 @@ func (fbo *Framebuffer) NewDepthCubemapArrayAttachment( fbo.Attachments = append(fbo.Attachments, a) } +func (fbo *Framebuffer) NewDepthTextureArrayAttachment( + attachFormat FramebufferAttachmentDataFormat, + numTextures int32, +) { + + if fbo.HasDepthAttachment() { + logging.ErrLog.Fatalf("failed creating texture array depth attachment for framebuffer because a depth attachment already exists\n") + } + + if !attachFormat.IsDepthFormat() { + logging.ErrLog.Fatalf("failed creating depth attachment for framebuffer due to attachment data format not being a valid depth-stencil type. Data format=%d\n", attachFormat) + } + + a := FramebufferAttachment{ + Type: FramebufferAttachmentType_Texture_Array, + Format: attachFormat, + } + + fbo.Bind() + + // Create cubemap array + gl.GenTextures(1, &a.Id) + if a.Id == 0 { + logging.ErrLog.Fatalf("failed to generate texture for framebuffer. GlError=%d\n", gl.GetError()) + } + + gl.BindTexture(gl.TEXTURE_2D_ARRAY, a.Id) + + gl.TexImage3D( + gl.TEXTURE_2D_ARRAY, + 0, + attachFormat.GlInternalFormat(), + int32(fbo.Width), + int32(fbo.Height), + numTextures, + 0, + attachFormat.GlFormat(), + gl.FLOAT, + nil, + ) + + gl.TexParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST) + gl.TexParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST) + + // This is so that any sampling outside the depth map gives a full depth value. + // Useful for example when doing shadow maps where we want things outside + // the range of the texture to not show shadow + borderColor := []float32{1, 1, 1, 1} + gl.TexParameterfv(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_BORDER_COLOR, &borderColor[0]) + gl.TexParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_BORDER) + gl.TexParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_BORDER) + + gl.BindTexture(gl.TEXTURE_2D_ARRAY, 0) + + // Attach to fbo + gl.FramebufferTexture(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, a.Id, 0) + + fbo.UnBind() + fbo.ClearFlags |= gl.DEPTH_BUFFER_BIT + fbo.Attachments = append(fbo.Attachments, a) +} + func (fbo *Framebuffer) NewDepthStencilAttachment( attachType FramebufferAttachmentType, attachFormat FramebufferAttachmentDataFormat, diff --git a/main.go b/main.go index bb8644c..e172298 100755 --- a/main.go +++ b/main.go @@ -32,7 +32,8 @@ import ( - Spotlights ✅ - Directional light shadows ✅ - Point light shadows ✅ - - Spotlight shadows + - Spotlight shadows ✅ + - UBO support - HDR - Cascaded shadow mapping - Skeletal animations @@ -70,7 +71,7 @@ func (d *DirLight) GetProjViewMat() gglm.Mat4 { farClip := dirLightFar projMat := gglm.Ortho(-size, size, -size, size, nearClip, farClip).Mat4 - viewMat := gglm.LookAtRH(pos, pos.Clone().Add(d.Dir.Clone().Scale(10)), gglm.NewVec3(0, 1, 0)).Mat4 + viewMat := gglm.LookAtRH(pos, pos.Clone().Add(&d.Dir), gglm.NewVec3(0, 1, 0)).Mat4 return *projMat.Mul(&viewMat) } @@ -93,6 +94,9 @@ type PointLight struct { const ( MaxPointLights = 8 + + // If this changes update the array depth map shader + MaxSpotLights = 4 ) var ( @@ -117,24 +121,42 @@ func (p *PointLight) GetProjViewMats(shadowMapWidth, shadowMapHeight float32) [6 } type SpotLight struct { - Pos gglm.Vec3 - Dir gglm.Vec3 - DiffuseColor gglm.Vec3 - SpecularColor gglm.Vec3 - InnerCutoff float32 - OuterCutoff float32 + Pos gglm.Vec3 + Dir gglm.Vec3 + DiffuseColor gglm.Vec3 + SpecularColor gglm.Vec3 + InnerCutoffRad float32 + OuterCutoffRad float32 + + // Near plane like 0.x (or anything too small) causes shadows to not work properly. + // Needs adjusting as the distance of light to object increases + NearPlane float32 + + FarPlane float32 } -// SetCutoffs properly sets the cosine values of the cutoffs using the passed -// degrees. -// -// The light has full intensity within the inner cutoff, falloff between -// inner-outer cutoff, and zero light beyond the outer cutoff. -// -// The inner cuttoff degree must be *smaller* than the outer cutoff -func (s *SpotLight) SetCutoffs(innerCutoffAngleDeg, outerCutoffAngleDeg float32) { - s.InnerCutoff = gglm.Cos32(innerCutoffAngleDeg * gglm.Deg2Rad) - s.OuterCutoff = gglm.Cos32(outerCutoffAngleDeg * gglm.Deg2Rad) +func (s *SpotLight) GetProjViewMat() gglm.Mat4 { + + projMat := gglm.Perspective(s.OuterCutoffRad*2, 1, s.NearPlane, s.FarPlane) + + // Adjust up vector if lightDir is parallel or nearly parallel to upVector + // as lookat view matrix breaks if up and look at are parallel + up := gglm.NewVec3(0, 1, 0) + if gglm.Abs32(gglm.DotVec3(&s.Dir, up)) > 0.99 { + up.SetXY(1, 0) + } + + viewMat := gglm.LookAtRH(&s.Pos, s.Pos.Clone().Add(&s.Dir), up).Mat4 + + return *projMat.Mul(&viewMat) +} + +func (s *SpotLight) InnerCutoffCos() float32 { + return gglm.Cos32(s.InnerCutoffRad) +} + +func (s *SpotLight) OuterCutoffCos() float32 { + return gglm.Cos32(s.OuterCutoffRad) } const ( @@ -153,32 +175,36 @@ var ( cam *camera.Camera // Demo fbo - renderToDemoFbo = true + renderToDemoFbo = false renderToBackBuffer = true demoFboScale = gglm.NewVec2(0.25, 0.25) demoFboOffset = gglm.NewVec2(0.75, -0.75) demoFbo buffers.Framebuffer // Dir light fbo - showDirLightDepthMapFbo = true + showDirLightDepthMapFbo = false dirLightDepthMapFboScale = gglm.NewVec2(0.25, 0.25) dirLightDepthMapFboOffset = gglm.NewVec2(0.75, -0.2) dirLightDepthMapFbo buffers.Framebuffer // Point light fbo - omnidirDepthMapFbo buffers.Framebuffer + pointLightDepthMapFbo buffers.Framebuffer + + // Spot light fbo + spotLightDepthMapFbo buffers.Framebuffer screenQuadVao buffers.VertexArray screenQuadMat *materials.Material - unlitMat *materials.Material - whiteMat *materials.Material - containerMat *materials.Material - palleteMat *materials.Material - skyboxMat *materials.Material - dirLightDepthMapMat *materials.Material - omnidirDepthMapMat *materials.Material - debugDepthMat *materials.Material + unlitMat *materials.Material + whiteMat *materials.Material + containerMat *materials.Material + palleteMat *materials.Material + skyboxMat *materials.Material + depthMapMat *materials.Material + arrayDepthMapMat *materials.Material + omnidirDepthMapMat *materials.Material + debugDepthMat *materials.Material cubeMesh *meshes.Mesh sphereMesh *meshes.Mesh @@ -245,13 +271,16 @@ var ( } spotLights = [...]SpotLight{ { - Pos: *gglm.NewVec3(2, 5, 5), - Dir: *gglm.NewVec3(0, -1, 0), - DiffuseColor: *gglm.NewVec3(0, 1, 1), + Pos: *gglm.NewVec3(-4, 7, 5), + Dir: *gglm.NewVec3(1.5, -0.9, 0).Normalize(), + DiffuseColor: *gglm.NewVec3(1, 0, 1), SpecularColor: *gglm.NewVec3(1, 1, 1), // These must be cosine values - InnerCutoff: gglm.Cos32(15 * gglm.Deg2Rad), - OuterCutoff: gglm.Cos32(20 * gglm.Deg2Rad), + InnerCutoffRad: 15 * gglm.Deg2Rad, + OuterCutoffRad: 20 * gglm.Deg2Rad, + + NearPlane: 1, + FarPlane: 30, }, } ) @@ -442,8 +471,9 @@ func (g *Game) Init() { whiteMat.SetUnifVec3("dirLight.dir", &dirLight.Dir) whiteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor) whiteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor) - whiteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap)) + whiteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1)) whiteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array)) + whiteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1)) containerMat = materials.NewMaterial("Container mat", "./res/shaders/simple.glsl") containerMat.Shininess = 64 @@ -460,8 +490,9 @@ func (g *Game) Init() { containerMat.SetUnifVec3("dirLight.dir", &dirLight.Dir) containerMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor) containerMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor) - containerMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap)) + containerMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1)) containerMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array)) + containerMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1)) palleteMat = materials.NewMaterial("Pallete mat", "./res/shaders/simple.glsl") palleteMat.Shininess = 64 @@ -477,12 +508,15 @@ func (g *Game) Init() { palleteMat.SetUnifFloat32("material.shininess", palleteMat.Shininess) palleteMat.SetUnifVec3("dirLight.diffuseColor", &dirLight.DiffuseColor) palleteMat.SetUnifVec3("dirLight.specularColor", &dirLight.SpecularColor) - palleteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap)) + palleteMat.SetUnifInt32("dirLight.shadowMap", int32(materials.TextureSlot_ShadowMap1)) palleteMat.SetUnifInt32("pointLightCubeShadowMaps", int32(materials.TextureSlot_Cubemap_Array)) + palleteMat.SetUnifInt32("spotLightShadowMaps", int32(materials.TextureSlot_ShadowMap_Array1)) debugDepthMat = materials.NewMaterial("Debug depth mat", "./res/shaders/debug-depth.glsl") - dirLightDepthMapMat = materials.NewMaterial("Directional Depth Map mat", "./res/shaders/directional-depth-map.glsl") + depthMapMat = materials.NewMaterial("Depth Map mat", "./res/shaders/depth-map.glsl") + + arrayDepthMapMat = materials.NewMaterial("Array Depth Map mat", "./res/shaders/array-depth-map.glsl") omnidirDepthMapMat = materials.NewMaterial("Omnidirectional Depth Map mat", "./res/shaders/omnidirectional-depth-map.glsl") @@ -540,15 +574,25 @@ func (g *Game) initFbos() { assert.T(dirLightDepthMapFbo.IsComplete(), "Depth map fbo is not complete after init") - // Cubemap fbo - omnidirDepthMapFbo = buffers.NewFramebuffer(1024, 1024) - omnidirDepthMapFbo.SetNoColorBuffer() - omnidirDepthMapFbo.NewDepthCubemapArrayAttachment( + // Point light depth map fbo + pointLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024) + pointLightDepthMapFbo.SetNoColorBuffer() + pointLightDepthMapFbo.NewDepthCubemapArrayAttachment( buffers.FramebufferAttachmentDataFormat_DepthF32, MaxPointLights, ) - assert.T(omnidirDepthMapFbo.IsComplete(), "Cubemap fbo is not complete after init") + assert.T(pointLightDepthMapFbo.IsComplete(), "Point light depth map fbo is not complete after init") + + // Spot light depth map fbo + spotLightDepthMapFbo = buffers.NewFramebuffer(1024, 1024) + spotLightDepthMapFbo.SetNoColorBuffer() + spotLightDepthMapFbo.NewDepthTextureArrayAttachment( + buffers.FramebufferAttachmentDataFormat_DepthF32, + MaxSpotLights, + ) + + assert.T(spotLightDepthMapFbo.IsComplete(), "Spot light depth map fbo is not complete after init") } func (g *Game) updateLights() { @@ -593,14 +637,17 @@ func (g *Game) updateLights() { palleteMat.SetUnifFloat32(indexString+".farPlane", p.FarPlane) } - whiteMat.CubemapArrayTex = omnidirDepthMapFbo.Attachments[0].Id - containerMat.CubemapArrayTex = omnidirDepthMapFbo.Attachments[0].Id - palleteMat.CubemapArrayTex = omnidirDepthMapFbo.Attachments[0].Id + whiteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id + containerMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id + palleteMat.CubemapArrayTex = pointLightDepthMapFbo.Attachments[0].Id // Spotlights for i := 0; i < len(spotLights); i++ { l := &spotLights[i] + innerCutoffCos := l.InnerCutoffCos() + outerCutoffCos := l.OuterCutoffCos() + indexString := "spotLights[" + strconv.Itoa(i) + "]" whiteMat.SetUnifVec3(indexString+".pos", &l.Pos) @@ -619,14 +666,18 @@ func (g *Game) updateLights() { containerMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor) palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor) - whiteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff) - containerMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff) - palleteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff) + whiteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos) + containerMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos) + palleteMat.SetUnifFloat32(indexString+".innerCutoff", innerCutoffCos) - whiteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff) - containerMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff) - palleteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff) + whiteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos) + containerMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos) + palleteMat.SetUnifFloat32(indexString+".outerCutoff", outerCutoffCos) } + + whiteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id + containerMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id + palleteMat.ShadowMapTexArray1 = spotLightDepthMapFbo.Attachments[0].Id } func (g *Game) Update() { @@ -638,11 +689,6 @@ func (g *Game) Update() { g.updateCameraLookAround() g.updateCameraPos() - //Rotating cubes - if input.KeyDown(sdl.K_SPACE) { - cubeModelMat.Rotate(10*timing.DT()*gglm.Deg2Rad, gglm.NewVec3(1, 1, 1).Normalize()) - } - g.showDebugWindow() if input.KeyClicked(sdl.K_F4) { @@ -763,6 +809,8 @@ func (g *Game) showDebugWindow() { } // Spot lights + imgui.Checkbox("Render Spot Light Shadows", &renderSpotLightShadows) + if imgui.BeginListBoxV("Spot Lights", imgui.Vec2{Y: 200}) { for i := 0; i < len(spotLights); i++ { @@ -800,18 +848,27 @@ func (g *Game) showDebugWindow() { palleteMat.SetUnifVec3(indexString+".specularColor", &l.SpecularColor) } - if imgui.DragFloat("Inner Cutoff", &l.InnerCutoff) { - whiteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff) - containerMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff) - palleteMat.SetUnifFloat32(indexString+".innerCutoff", l.InnerCutoff) + if imgui.DragFloat("Inner Cutoff Radians", &l.InnerCutoffRad) { + + cos := l.InnerCutoffCos() + + whiteMat.SetUnifFloat32(indexString+".innerCutoff", cos) + containerMat.SetUnifFloat32(indexString+".innerCutoff", cos) + palleteMat.SetUnifFloat32(indexString+".innerCutoff", cos) } - if imgui.DragFloat("Outer Cutoff", &l.OuterCutoff) { - whiteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff) - containerMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff) - palleteMat.SetUnifFloat32(indexString+".outerCutoff", l.OuterCutoff) + if imgui.DragFloat("Outer Cutoff Radians", &l.OuterCutoffRad) { + + cos := l.OuterCutoffCos() + + whiteMat.SetUnifFloat32(indexString+".outerCutoff", cos) + containerMat.SetUnifFloat32(indexString+".outerCutoff", cos) + palleteMat.SetUnifFloat32(indexString+".outerCutoff", cos) } + imgui.DragFloat("Spot Near Plane", &l.NearPlane) + imgui.DragFloat("Spot Far Plane", &l.FarPlane) + imgui.TreePop() } @@ -902,24 +959,36 @@ func (g *Game) updateCameraPos() { var ( renderDirLightShadows = true renderPointLightShadows = true + renderSpotLightShadows = true rotatingCubeSpeedDeg1 float32 = 45 rotatingCubeSpeedDeg2 float32 = 120 + rotatingCubeSpeedDeg3 float32 = 120 rotatingCubeTrMat1 = *gglm.NewTrMatId().Translate(gglm.NewVec3(-4, -1, 4)) rotatingCubeTrMat2 = *gglm.NewTrMatId().Translate(gglm.NewVec3(-1, 0.5, 4)) + rotatingCubeTrMat3 = *gglm.NewTrMatId().Translate(gglm.NewVec3(5, 0.5, 4)) ) func (g *Game) Render() { + whiteMat.SetUnifVec3("camPos", &cam.Pos) + containerMat.SetUnifVec3("camPos", &cam.Pos) + palleteMat.SetUnifVec3("camPos", &cam.Pos) + rotatingCubeTrMat1.Rotate(rotatingCubeSpeedDeg1*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(0, 1, 0)) rotatingCubeTrMat2.Rotate(rotatingCubeSpeedDeg2*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(1, 1, 0)) + rotatingCubeTrMat3.Rotate(rotatingCubeSpeedDeg3*gglm.Deg2Rad*timing.DT(), gglm.NewVec3(1, 1, 1)) if renderDirLightShadows { - g.renderDirectionalShadowmap() + g.renderDirectionalLightShadowmap() + } + + if renderSpotLightShadows { + g.renderSpotLightShadowmaps() } if renderPointLightShadows { - g.renderOmnidirectionalShadowmap() + g.renderPointLightShadowmaps() } if renderToBackBuffer { @@ -940,21 +1009,16 @@ func (g *Game) Render() { } } -func (g *Game) renderDirectionalShadowmap() { +func (g *Game) renderDirectionalLightShadowmap() { // Set some uniforms dirLightProjViewMat := dirLight.GetProjViewMat() - whiteMat.SetUnifVec3("camPos", &cam.Pos) whiteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat) - - containerMat.SetUnifVec3("camPos", &cam.Pos) containerMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat) - - palleteMat.SetUnifVec3("camPos", &cam.Pos) palleteMat.SetUnifMat4("dirLightProjViewMat", &dirLightProjViewMat) - dirLightDepthMapMat.SetUnifMat4("projViewMat", &dirLightProjViewMat) + depthMapMat.SetUnifMat4("projViewMat", &dirLightProjViewMat) // Start rendering dirLightDepthMapFbo.BindWithViewport() @@ -966,7 +1030,7 @@ func (g *Game) renderDirectionalShadowmap() { // // Some note that this is too troublesome and fails in many cases. Might be better to remove. gl.CullFace(gl.FRONT) - g.RenderScene(dirLightDepthMapMat) + g.RenderScene(depthMapMat) gl.CullFace(gl.BACK) dirLightDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight)) @@ -980,10 +1044,41 @@ func (g *Game) renderDirectionalShadowmap() { } } -func (g *Game) renderOmnidirectionalShadowmap() { +func (g *Game) renderSpotLightShadowmaps() { - omnidirDepthMapFbo.BindWithViewport() - omnidirDepthMapFbo.Clear() + for i := 0; i < len(spotLights); i++ { + + l := &spotLights[i] + indexStr := strconv.Itoa(i) + projViewMatIndexStr := "spotLightProjViewMats[" + indexStr + "]" + + // Set render uniforms + projViewMat := l.GetProjViewMat() + + whiteMat.SetUnifMat4(projViewMatIndexStr, &projViewMat) + containerMat.SetUnifMat4(projViewMatIndexStr, &projViewMat) + palleteMat.SetUnifMat4(projViewMatIndexStr, &projViewMat) + + // Set depth uniforms + arrayDepthMapMat.SetUnifMat4("projViewMats["+indexStr+"]", &projViewMat) + } + + // Render + spotLightDepthMapFbo.BindWithViewport() + spotLightDepthMapFbo.Clear() + + // Front culling created issues + // gl.CullFace(gl.FRONT) + g.RenderScene(arrayDepthMapMat) + // gl.CullFace(gl.BACK) + + spotLightDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight)) +} + +func (g *Game) renderPointLightShadowmaps() { + + pointLightDepthMapFbo.BindWithViewport() + pointLightDepthMapFbo.Clear() for i := 0; i < len(pointLights); i++ { @@ -995,7 +1090,7 @@ func (g *Game) renderOmnidirectionalShadowmap() { omnidirDepthMapMat.SetUnifFloat32("farPlane", p.FarPlane) // Set projView matrices - projViewMats := p.GetProjViewMats(float32(omnidirDepthMapFbo.Width), float32(omnidirDepthMapFbo.Height)) + projViewMats := p.GetProjViewMats(float32(pointLightDepthMapFbo.Width), float32(pointLightDepthMapFbo.Height)) for j := 0; j < len(projViewMats); j++ { omnidirDepthMapMat.SetUnifMat4("cubemapProjViewMats["+strconv.Itoa(j)+"]", &projViewMats[j]) } @@ -1003,7 +1098,7 @@ func (g *Game) renderOmnidirectionalShadowmap() { g.RenderScene(omnidirDepthMapMat) } - omnidirDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight)) + pointLightDepthMapFbo.UnBindWithViewport(uint32(g.WinWidth), uint32(g.WinHeight)) } func (g *Game) renderDemoFob() { @@ -1070,8 +1165,8 @@ func (g *Game) RenderScene(overrideMat *materials.Material) { // Rotating cubes window.Rend.DrawMesh(cubeMesh, &rotatingCubeTrMat1, cubeMat) - window.Rend.DrawMesh(cubeMesh, &rotatingCubeTrMat2, cubeMat) + window.Rend.DrawMesh(cubeMesh, &rotatingCubeTrMat3, cubeMat) // Cubes generator // rowSize := 1 diff --git a/materials/material.go b/materials/material.go index a430476..eaa1f23 100755 --- a/materials/material.go +++ b/materials/material.go @@ -11,13 +11,14 @@ import ( type TextureSlot uint32 const ( - TextureSlot_Diffuse TextureSlot = 0 - TextureSlot_Specular TextureSlot = 1 - TextureSlot_Normal TextureSlot = 2 - TextureSlot_Emission TextureSlot = 3 - TextureSlot_Cubemap TextureSlot = 10 - TextureSlot_ShadowMap TextureSlot = 11 - TextureSlot_Cubemap_Array TextureSlot = 12 + 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 { @@ -42,7 +43,8 @@ type Material struct { CubemapArrayTex uint32 // Shadowmaps - ShadowMapTex1 uint32 + ShadowMapTex1 uint32 + ShadowMapTexArray1 uint32 } func (m *Material) Bind() { @@ -80,9 +82,14 @@ func (m *Material) Bind() { } if m.ShadowMapTex1 != 0 { - gl.ActiveTexture(uint32(gl.TEXTURE0 + TextureSlot_ShadowMap)) + 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() { diff --git a/res/shaders/array-depth-map.glsl b/res/shaders/array-depth-map.glsl new file mode 100755 index 0000000..cc95ba3 --- /dev/null +++ b/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; +} diff --git a/res/shaders/directional-depth-map.glsl b/res/shaders/depth-map.glsl similarity index 100% rename from res/shaders/directional-depth-map.glsl rename to res/shaders/depth-map.glsl diff --git a/res/shaders/simple.glsl b/res/shaders/simple.glsl index cd935d7..2bad562 100755 --- a/res/shaders/simple.glsl +++ b/res/shaders/simple.glsl @@ -6,15 +6,19 @@ layout(location=1) in vec3 vertNormalIn; layout(location=2) in vec2 vertUV0In; layout(location=3) in vec3 vertColorIn; +uniform mat4 modelMat; +uniform mat4 projViewMat; +uniform mat4 dirLightProjViewMat; + +#define NUM_SPOT_LIGHTS 4 +uniform mat4 spotLightProjViewMats[NUM_SPOT_LIGHTS]; + out vec3 vertNormal; out vec2 vertUV0; out vec3 vertColor; out vec3 fragPos; out vec4 fragPosDirLight; - -uniform mat4 modelMat; -uniform mat4 projViewMat; -uniform mat4 dirLightProjViewMat; +out vec4 fragPosSpotLight[NUM_SPOT_LIGHTS]; void main() { @@ -31,6 +35,9 @@ void main() fragPos = modelVert.xyz; fragPosDirLight = dirLightProjViewMat * vec4(fragPos, 1); + for (int i = 0; i < NUM_SPOT_LIGHTS; i++) + fragPosSpotLight[i] = spotLightProjViewMats[i] * vec4(fragPos, 1); + gl_Position = projViewMat * modelVert; } @@ -81,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); @@ -90,6 +98,7 @@ in vec3 vertNormal; in vec2 vertUV0; in vec3 fragPos; in vec4 fragPosDirLight; +in vec4 fragPosSpotLight[NUM_SPOT_LIGHTS]; out vec4 fragColor; @@ -123,9 +132,9 @@ float CalcDirShadow(sampler2D shadowMap, vec3 lightDir) // Basically get soft shadows by averaging this texel and surrounding ones float shadow = 0; vec2 texelSize = 1 / textureSize(shadowMap, 0); - for(int x = -1; x <= 1; ++x) + for(int x = -1; x <= 1; x++) { - for(int y = -1; y <= 1; ++y) + for(int y = -1; y <= 1; y++) { float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r; @@ -205,7 +214,47 @@ vec3 CalcPointLight(PointLight pointLight, int lightIndex) 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); @@ -231,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() @@ -254,7 +306,7 @@ void main() for (int i = 0; i < NUM_SPOT_LIGHTS; i++) { - finalColor += CalcSpotLight(spotLights[i]); + finalColor += CalcSpotLight(spotLights[i], i); } vec3 finalEmission = emissionTexColor.rgb;