JacobDomagala · JacobDomagala · Mar 20, 2026
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -43,7 +43,9 @@ add_subdirectory(editor)
 include(cmake/compile_shaders.cmake)
 compile_shader(SOURCE_FILE "${SHADERS_PATH}/default.vert"  OUTPUT_FILE_NAME "${SHADERS_PATH}/vert.spv")
 compile_shader(SOURCE_FILE "${SHADERS_PATH}/default.frag"  OUTPUT_FILE_NAME "${SHADERS_PATH}/frag.spv")
-compile_shader(SOURCE_FILE "${SHADERS_PATH}/ui.vert"  OUTPUT_FILE_NAME "${SHADERS_PATH}/ui.vert.spv")
-compile_shader(SOURCE_FILE "${SHADERS_PATH}/ui.frag"  OUTPUT_FILE_NAME "${SHADERS_PATH}/ui.frag.spv")
-compile_shader(SOURCE_FILE "${SHADERS_PATH}/line.vert"  OUTPUT_FILE_NAME "${SHADERS_PATH}/line.vert.spv")
-compile_shader(SOURCE_FILE "${SHADERS_PATH}/line.frag"  OUTPUT_FILE_NAME "${SHADERS_PATH}/line.frag.spv")
+compile_shader(SOURCE_FILE "${SHADERS_PATH}/ui.vert"  OUTPUT_FILE_NAME "${SHADERS_PATH}/ui.vert.spv")
+compile_shader(SOURCE_FILE "${SHADERS_PATH}/ui.frag"  OUTPUT_FILE_NAME "${SHADERS_PATH}/ui.frag.spv")
+compile_shader(SOURCE_FILE "${SHADERS_PATH}/line.vert"  OUTPUT_FILE_NAME "${SHADERS_PATH}/line.vert.spv")
+compile_shader(SOURCE_FILE "${SHADERS_PATH}/line.frag"  OUTPUT_FILE_NAME "${SHADERS_PATH}/line.frag.spv")
+compile_shader(SOURCE_FILE "${SHADERS_PATH}/shadow.vert"  OUTPUT_FILE_NAME "${SHADERS_PATH}/shadow.vert.spv")
+compile_shader(SOURCE_FILE "${SHADERS_PATH}/shadow.frag"  OUTPUT_FILE_NAME "${SHADERS_PATH}/shadow.frag.spv")
diff --git a/assets/shaders/default.frag b/assets/shaders/default.frag
@@ -5,11 +5,25 @@
 #extension GL_ARB_gpu_shader_int64 : enable
 
 layout(set = 0, binding = 2) uniform sampler2D textures[256];
+layout(set = 0, binding = 3) uniform sampler2D shadowMap;
+
+layout(set = 0, binding = 0) uniform UniformBufferObject
+{
+   mat4 u_projectionMat;
+   mat4 u_viewMat;
+   vec4 u_cameraPos;
+   mat4 u_lightViewProj;
+   vec4 u_lightDirection;
+   vec4 u_lightColor;
+   vec4 u_shadowParams;
+}
+ubo;
 
 layout(location = 0) in VS_OUT
 {
    vec4 fColor;
    vec2 fTexCoord;
+   vec4 fLightSpacePos;
 
    flat int fDiffSampl;
    flat int fExtraSampl;
@@ -18,10 +32,57 @@ fs_in;
 
 layout(location = 0) out vec4 outColor;
 
+float
+ComputeShadow(vec4 lightSpacePos)
+{
+    vec3 projCoords = lightSpacePos.xyz / max(lightSpacePos.w, 0.0001);
+    projCoords = projCoords * 0.5 + 0.5;
+
+    if (projCoords.z <= 0.0 || projCoords.z >= 1.0)
+    {
+        return 0.0;
+    }
+
+    if (projCoords.x < 0.0 || projCoords.x > 1.0 || projCoords.y < 0.0 || projCoords.y > 1.0)
+    {
+        return 0.0;
+    }
+
+    float shadow = 0.0;
+    float bias = ubo.u_shadowParams.z;
+    vec2 texelSize = 1.0 / vec2(textureSize(shadowMap, 0));
+
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            float closestDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r;
+            shadow += (projCoords.z - bias) > closestDepth ? 1.0 : 0.0;
+        }
+    }
+
+    return shadow / 9.0;
+}
+
 void
 main(void)
 {
     vec4 base = texture(textures[fs_in.fDiffSampl], fs_in.fTexCoord);
     vec4 mask = texture(textures[fs_in.fExtraSampl], fs_in.fTexCoord);
-    outColor = fs_in.fColor * base * mask;
+    vec4 surface = fs_in.fColor * base * mask;
+
+    if (surface.a <= 0.01)
+    {
+        discard;
+    }
+
+    vec3 lightDir = normalize(ubo.u_lightDirection.xyz);
+    float diffuse = max(dot(vec3(0.0, 0.0, 1.0), lightDir), 0.0);
+    float shadow = ComputeShadow(fs_in.fLightSpacePos);
+    float ambient = ubo.u_shadowParams.x;
+    float shadowStrength = ubo.u_shadowParams.y;
+    float visibility = 1.0 - shadow * shadowStrength;
+
+    vec3 lighting = vec3(ambient) + visibility * diffuse * ubo.u_lightColor.rgb;
+    outColor = vec4(surface.rgb * lighting, surface.a);
 }
diff --git a/assets/shaders/default.vert b/assets/shaders/default.vert
@@ -8,6 +8,10 @@ layout(set = 0, binding = 0) uniform UniformBufferObject
    mat4 u_projectionMat;
    mat4 u_viewMat;
    vec4 u_cameraPos;
+   mat4 u_lightViewProj;
+   vec4 u_lightDirection;
+   vec4 u_lightColor;
+   vec4 u_shadowParams;
 }
 ubo;
 
@@ -30,6 +34,7 @@ layout(location = 0) out VS_OUT
 {
    vec4 fColor;
    vec2 fTexCoord;
+   vec4 fLightSpacePos;
 
    flat int fDiffSampl;
    flat int fExtraSampl;
@@ -54,6 +59,8 @@ main(void)
 
    mat4 modelMat = curInstanceData.modelMat;
    vec3 position = a_position;
+   vec4 worldPosition = modelMat * vec4(position.xyz, 1.0f);
 
-   gl_Position = ubo.u_projectionMat * ubo.u_viewMat * modelMat * vec4(position.xyz, 1.0f);
+   vs_out.fLightSpacePos = ubo.u_lightViewProj * worldPosition;
+   gl_Position = ubo.u_projectionMat * ubo.u_viewMat * worldPosition;
 }
diff --git a/assets/shaders/shadow.frag b/assets/shaders/shadow.frag
@@ -0,0 +1,24 @@
+#version 460
+
+layout(set = 0, binding = 2) uniform sampler2D textures[256];
+
+layout(location = 0) in VS_OUT
+{
+   vec2 fTexCoord;
+
+   flat int fDiffSampl;
+   flat int fExtraSampl;
+}
+fs_in;
+
+void
+main(void)
+{
+   vec4 base = texture(textures[fs_in.fDiffSampl], fs_in.fTexCoord);
+   vec4 mask = texture(textures[fs_in.fExtraSampl], fs_in.fTexCoord);
+
+   if ((base * mask).a <= 0.01)
+   {
+      discard;
+   }
+}
diff --git a/assets/shaders/shadow.vert b/assets/shaders/shadow.vert
@@ -0,0 +1,53 @@
+#version 460
+
+#extension GL_ARB_shader_storage_buffer_object : require
+#extension GL_ARB_gpu_shader_int64 : enable
+
+layout(set = 0, binding = 0) uniform UniformBufferObject
+{
+   mat4 u_projectionMat;
+   mat4 u_viewMat;
+   vec4 u_cameraPos;
+   mat4 u_lightViewProj;
+   vec4 u_lightDirection;
+   vec4 u_lightColor;
+   vec4 u_shadowParams;
+}
+ubo;
+
+struct BufferData
+{
+   mat4 modelMat;
+   vec4 color;
+   vec4 texSamples;
+};
+
+layout(std430, set = 0, binding = 1) readonly buffer Block
+{
+   BufferData Transforms[];
+};
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec3 a_texCoordDrawID;
+
+layout(location = 0) out VS_OUT
+{
+   vec2 fTexCoord;
+
+   flat int fDiffSampl;
+   flat int fExtraSampl;
+}
+vs_out;
+
+void
+main(void)
+{
+   float drawID = a_texCoordDrawID.z;
+   BufferData curInstanceData = Transforms[int(drawID)];
+
+   vs_out.fTexCoord = a_texCoordDrawID.xy;
+   vs_out.fDiffSampl = int(curInstanceData.texSamples.x);
+   vs_out.fExtraSampl = int(curInstanceData.texSamples.y);
+
+   gl_Position = ubo.u_lightViewProj * curInstanceData.modelMat * vec4(a_position.xyz, 1.0f);
+}
diff --git a/editor/editor.cpp b/editor/editor.cpp
@@ -989,15 +989,11 @@ Editor::Render(VkCommandBuffer cmdBuffer)
 
       gizmo_.Render();
 
-
-      vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, renderData.pipeline);
-
-      auto offsets = std::to_array< const VkDeviceSize >({0});
-      vkCmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, renderData.pipelineLayout,
-                              0, 1, &renderData.descriptorSets[renderer::Data::currentFrame_], 0,
-                              nullptr);
-      renderer::QuadShader::PushConstants pushConstants = {};
-      pushConstants.selectedIdx = -1.0f;
+
+      vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, renderData.pipeline);
+
+      renderer::QuadShader::PushConstants pushConstants = {};
+      pushConstants.selectedIdx = -1.0f;
 
       if (currentSelectedGameObject_ != Object::INVALID_ID)
       {
@@ -1006,38 +1002,19 @@ Editor::Render(VkCommandBuffer cmdBuffer)
          pushConstants.selectedIdx = static_cast< float >(tmpIdx);
       }
 
-      vkCmdPushConstants(cmdBuffer, renderData.pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0,
-                         sizeof(renderer::QuadShader::PushConstants), &pushConstants);
-
-      const auto renderAllLayers = renderLayerToDraw_ == -1;
-      for (int32_t layer = renderer::NUM_LAYERS - 1; layer >= 0; --layer)
-      {
-         const auto idx = static_cast< size_t >(layer);
-         const auto& numObjects = renderData.numMeshes.at(idx);
-
-         const auto renderThisLayer =
-            (renderAllLayers or layer == 0) ? true : renderLayerToDraw_ == layer;
-
-         if (numObjects == 0 or !renderThisLayer)
-         {
-            continue;
-         }
-
-         vkCmdBindVertexBuffers(cmdBuffer, 0, 1, &renderData.vertexBuffer.at(idx).buffer_,
-                                offsets.data());
-
-         vkCmdBindIndexBuffer(cmdBuffer, renderData.indexBuffer.at(idx).buffer_, 0,
-                              VK_INDEX_TYPE_UINT32);
-
-         vkCmdDrawIndexed(cmdBuffer, numObjects * renderer::INDICES_PER_SPRITE, 1, 0, 0, 0);
-      }
-
-      // DRAW LINES
-      vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                        renderer::EditorData::linePipeline_);
-
-      vkCmdBindVertexBuffers(cmdBuffer, 0, 1, &renderer::EditorData::lineVertexBuffer.buffer_,
-                             offsets.data());
+      renderer::DrawQuadMeshes(cmdBuffer, renderData.pipelineLayout,
+                               renderData.descriptorSets[renderer::Data::currentFrame_],
+                               renderLayerToDraw_, true, &pushConstants,
+                               sizeof(renderer::QuadShader::PushConstants),
+                               VK_SHADER_STAGE_VERTEX_BIT);
+
+      // DRAW LINES
+      vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                        renderer::EditorData::linePipeline_);
+
+      auto offsets = std::to_array< const VkDeviceSize >({0});
+      vkCmdBindVertexBuffers(cmdBuffer, 0, 1, &renderer::EditorData::lineVertexBuffer.buffer_,
+                             offsets.data());
 
       vkCmdBindIndexBuffer(cmdBuffer, renderer::EditorData::lineIndexBuffer.buffer_, 0,
                            VK_INDEX_TYPE_UINT32);

diff --git a/engine/game/game.cpp b/engine/game/game.cpp
@@ -379,46 +379,18 @@ Game::HandleReverseLogic()
    }
 }
 
-void
-Game::Render(VkCommandBuffer cmdBuffer)
-{
-   RenderFirstPass();
-   RenderSecondPass();
+void
+Game::Render(VkCommandBuffer cmdBuffer)
+{
+   RenderFirstPass();
+   RenderSecondPass();
 
    auto& renderData =
       renderer::Data::renderData_.at(renderer::GetCurrentlyBoundType());
-
-   vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, renderData.pipeline);
-
-
-   auto offsets = std::to_array< const VkDeviceSize >({0});
-
-   vkCmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, renderData.pipelineLayout, 0,
-                           1, &renderData.descriptorSets[renderer::Data::currentFrame_], 0,
-                           nullptr);
-
-   for (int32_t layer = renderer::NUM_LAYERS - 1; layer >= 0; --layer)
-   {
-      const auto idx = static_cast< size_t >(layer);
-
-      const auto& numObjects = renderData.numMeshes.at(idx);
-      if (numObjects == 0)
-      {
-         continue;
-      }
-
-      vkCmdBindVertexBuffers(cmdBuffer, 0, 1, &renderData.vertexBuffer.at(idx).buffer_,
-                             offsets.data());
-
-      vkCmdBindIndexBuffer(cmdBuffer, renderData.indexBuffer.at(idx).buffer_, 0,
-                           VK_INDEX_TYPE_UINT32);
-
-      // const auto numObjects =
-      // renderer::GetNumMeshes(renderer::ApplicationType::GAME); numObjects_ =
-      // numObjects.second - numObjects.first;
-      vkCmdDrawIndexed(cmdBuffer, renderData.numMeshes.at(idx) * renderer::INDICES_PER_SPRITE, 1, 0,
-                       0, 0);
-   }
-}
+
+   vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, renderData.pipeline);
+   renderer::DrawQuadMeshes(cmdBuffer, renderData.pipelineLayout,
+                            renderData.descriptorSets[renderer::Data::currentFrame_]);
+}
 
 } // namespace looper
diff --git a/engine/renderer/helpers.hpp b/engine/renderer/helpers.hpp
@@ -349,12 +349,21 @@ FindSupportedFormat(const std::vector< VkFormat >& candidates, VkImageTiling til
    return {};
 }
 
-VkFormat
-FindDepthFormat()
-{
-   return FindSupportedFormat({VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT},
-                              VK_IMAGE_TILING_OPTIMAL,
-                              VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
-}
-
-} // namespace looper::renderer
+VkFormat
+FindDepthFormat()
+{
+   return FindSupportedFormat({VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT},
+                              VK_IMAGE_TILING_OPTIMAL,
+                              VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
+}
+
+VkFormat
+FindShadowDepthFormat()
+{
+   return FindSupportedFormat(
+      {VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT},
+      VK_IMAGE_TILING_OPTIMAL,
+      VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT);
+}
+
+} // namespace looper::renderer