Added comments and cleaned old code

Author: Raelr

engine/render/assets/shaders/Grid2D.frag

@@ -20,6 +20,16 @@ layout(location = 0) out vec4 outColour;
 
 float getAxisGridColour(float uv, float width, float factor, float derivative)
 {
+    /**
+    * There are a few things happening here:
+    * 1. The fract function returns the fraction of the given value (the parts after the decimal place). This returns to us
+    * another normalised coordinate which we can then use to repeat patterns.
+    * 2. We get the fraction of the uv (remember the has been divided by the spacing we provided earlier), and offset it
+    * by half the screen.
+    * 3. We then get the absolute value  of the new UV - half the screen (so that we don't get any negatives)
+    * 4. We divide this by the derivative to give us a smaller space (used for anti-aliasing)
+    * 5. We then use a step function to determine if the provided UV coordinate is within the cell borders
+    */
     return max(step(abs(fract(uv - 0.5) -0.5) / derivative, width), factor);
 }
 
@@ -29,20 +39,27 @@ vec4 grid(float spacing, float width, vec2 uv, vec3 lColour)
 
     vec4 colour = vec4(getAxisGridColour(uv.y, width, getAxisGridColour(uv.x, width, 0.0, derivative), derivative));
 
+    // Check if the uv sits within the range of the cell multiples
     vec2 modCoords = vec2(mod(uv.x, cellMultiple), mod(uv.y, cellMultiple));
 
+    // Fade the cell colours depending on whether they fall within the cell multiples range or not
     vec4 mixColour = mix(vec4(cellColour * fadeFactor, fadeFactor), vec4(cellColour, 1.0), float(modCoords.x < width || modCoords.y < width));
 
+    // Change the alpha based on whether the fragment is a grid line or not
     colour = mix(colour, vec4(mixColour), colour.a);
 
     return colour;
 }
 
 void main()
 {
+    // Determine the spacing and width of our cells
     const float spacing = cellSpacing * scale;
     const float width = lineWidth / spacing;
 
+    // Determine the uv location of the fragment we're dealing with
+    // NOTE: in glsl, gl_FragCoord always provides the fragment location + 0.5. As such, fragment 0,0 is represented as
+    // (0.5,0.5)
     vec2 uv = (gl_FragCoord.xy - 0.5) / spacing;
 
     outColour = grid(spacing, width, uv, cellColour);

engine/render/assets/shaders/Grid2D.vert

@@ -15,16 +15,16 @@ vec2 quadVertices[4] = {
     vec2(-1.0, 1.0)
 };
 
-layout(location=0) out vec3 cellColour;
-layout(location=1) out flat float cellSpacing;
-layout(location=2) out flat float lineWidth;
-layout(location=3) out flat float cellMultiple;
-layout(location=4) out flat float fadeFactor;
-layout(location=5) out flat float scale;
+layout(location=0) out vec3 cellColour; // The colour of our grid lines
+layout(location=1) out flat float cellSpacing; // the spacing between lines in pixels
+layout(location=2) out flat float lineWidth; // the width of our lines
+layout(location=3) out flat float cellMultiple; // determines how many cells will be encompassed in a sub-grid
+layout(location=4) out flat float fadeFactor; // determines how much sub-cells are faded
+layout(location=5) out flat float scale; // the DPI scale of the screen
 
 layout (push_constant) uniform PushConstant {
-    vec4 cellColouring;
-    vec4 cellDimensions;
+    vec4 cellColouring; // Stores the cellColour in xyz and fadeFactor in w
+    vec4 cellDimensions; // Stores the cell spacing in x, multiple in y, dimensions in z, and width in w
 } pushConstant;
 
 void main()

engine/render/assets/shaders/grid.frag

@@ -56,6 +56,4 @@ void main() {
 
     outColor = (grid(fragPos3D, 1) + grid(fragPos3D, 1))* float(t > 0);
     outColor.a *= fading;
-
-    if (outColor.a == 0) discard;
 }

engine/render/renderer/Renderer.cpp

@@ -64,7 +64,8 @@ void Renderer::RecreateSwapChain()
 {
     ClearDeviceQueue();
     auto extent = window.GetExtent();
-    while (extent.width == 0 || extent.height == 0)
+
+    while (!window.IsVisible() || extent.width == 0.0 || extent.height == 0.0)
     {
         extent = window.GetExtent();
         window.WaitEvents();
@@ -82,6 +83,7 @@ void Renderer::RecreateSwapChain()
     if (!swapchain.IsSameSwapFormat(oldImageFormat, oldDepthFormat))
     {
         Renderer3D::RecreateMaterials();
+        renderer2D.RecreateMaterials();
     }
 }
 
@@ -93,7 +95,7 @@ bool Renderer::StartFrame()
 
     auto result = swapchain.AcquireNextImage(&currentImageIndex);
 
-    if (result == Vulkan::Utils::ERROR_OUT_OF_DATE)
+    if (result == Vulkan::Utils::ERROR_OUT_OF_DATE || !window.IsVisible())
     {
         RecreateSwapChain();
         return false;
@@ -161,7 +163,7 @@ void Renderer::EndFrame()
 
     auto result = swapchain.SubmitCommandBuffers(commandBuffers, currentImageIndex);
 
-    if (result == Vulkan::Utils::ERROR_RESIZED || window.WasResized())
+    if (result == Vulkan::Utils::ERROR_RESIZED || window.WasResized() || !window.IsVisible())
     {
         window.ResetWindowResized();
         RecreateSwapChain();

engine/render/renderer/platform/vulkan/Material.cpp

@@ -22,9 +22,10 @@
 
 namespace Siege::Vulkan
 {
-Material::Material(Shader vertShader, Shader fragShader) :
+Material::Material(Shader vertShader, Shader fragShader, bool isWritingDepth) :
     vertexShader {std::move(vertShader)},
-    fragmentShader {std::move(fragShader)}
+    fragmentShader {std::move(fragShader)},
+    isWritingDepth {isWritingDepth}
 {
     using Vulkan::Context;
     using namespace Vulkan::Utils::Descriptor;
@@ -277,7 +278,7 @@ void Material::Recreate()
                            .WithPushConstant(pushConstant.size, pushConstant.type)
                            .WithVertexShader(&vertexShader)
                            .WithFragmentShader(&fragmentShader)
-                           .WithDepthWriting(vertexShader.IsWritingDepth())
+                           .WithDepthWriting(isWritingDepth)
                            .WithProperties(layouts)
                            .Build();
 }
@@ -408,6 +409,7 @@ void Material::Swap(Material& other)
     auto tmpBufferInfos = std::move(bufferInfos);
     auto tmpTexture2DInfos = std::move(texture2DInfos);
     auto tmpPushConstant = pushConstant;
+    auto tmpIsWritingDepth = isWritingDepth;
 
     vertexShader = std::move(other.vertexShader);
     fragmentShader = std::move(other.fragmentShader);
@@ -420,6 +422,7 @@ void Material::Swap(Material& other)
     bufferInfos = std::move(other.bufferInfos);
     texture2DInfos = std::move(other.texture2DInfos);
     pushConstant = other.pushConstant;
+    isWritingDepth = other.isWritingDepth;
 
     other.vertexShader = std::move(tmpVertexShader);
     other.fragmentShader = std::move(tmpFragmentShader);
@@ -432,5 +435,6 @@ void Material::Swap(Material& other)
     other.bufferInfos = std::move(tmpBufferInfos);
     other.texture2DInfos = std::move(tmpTexture2DInfos);
     other.pushConstant = tmpPushConstant;
+    other.isWritingDepth = tmpIsWritingDepth;
 }
 } // namespace Siege::Vulkan

engine/render/renderer/platform/vulkan/Material.h

@@ -35,6 +35,8 @@ namespace Siege::Vulkan
  * remaking every them every frame
  * @param texture2DInfos a list of texture 2D rendering infos used in textures
  * @param textureIds a list of texture IDs (used for checking the existence of textures)
+ * @param isWritingDepth a boolean specifying if the material pipeline is writing to the depth
+ * buffer
  */
 class Material
 {
@@ -50,8 +52,9 @@ class Material
      * A constructor for the material which expects a vertex and fragment shader at minimum
      * @param vertShader the vertex shader to be used by the Material
      * @param fragShader the fragment shader to be used by the Material
+     * @param isWritingDepth specifies if the material pipeline is writing to the depth buffer
      */
-    Material(Shader vertShader, Shader fragShader);
+    Material(Shader vertShader, Shader fragShader, bool isWritingDepth = true);
     /**
      * A move constructor for the Material class
      * @param other the Material to be moved
@@ -63,6 +66,9 @@ class Material
      */
     ~Material();
 
+    /**
+     * Frees the memory held by the material
+     */
     void Free();
 
     /**
@@ -150,6 +156,9 @@ class Material
         MSArray<Property, 10> properties;
     };
 
+    /**
+     * A struct specifying a push constant type
+     */
     struct PushConstant
     {
         uint32_t size {0};
@@ -274,6 +283,8 @@ class Material
     // Texture data
     MSArray<VkDescriptorImageInfo, MAX_TEXTURES> texture2DInfos;
     MSArray<Hash::StringId, MAX_TEXTURES> textureIds;
+
+    bool isWritingDepth {true};
 };
 } // namespace Siege::Vulkan
 

engine/render/renderer/platform/vulkan/Pipeline.cpp

@@ -49,7 +49,7 @@ Pipeline::Builder& Pipeline::Builder::WithFragmentShader(const Shader* fragShade
 
 Pipeline::Builder& Pipeline::Builder::WithDepthWriting(bool state)
 {
-    isWritingDepth = state;
+    usingDepthWrite = state;
     return *this;
 }
 
@@ -90,6 +90,8 @@ Pipeline Pipeline::Builder::Build()
     auto dynamicStateCreateInfos =
         CreateDynamicStates(viewportCount + scissorCount, (VkDynamicState*) dynamicStates.Data());
 
+    auto depthState = Utils::Pipeline::CreateStencilState(usingDepthWrite);
+
     // Get shader number and their stages.
 
     MSArray<VkPipelineShaderStageCreateInfo, 5> shaderStages {
@@ -148,9 +150,7 @@ Pipeline Pipeline::Builder::Build()
     pipelineCreateInfo.pMultisampleState = &Utils::Pipeline::defaultMultiSampleState;
     pipelineCreateInfo.pColorBlendState = &Utils::Pipeline::defaultColourBlendStateCreate;
     pipelineCreateInfo.pDynamicState = &dynamicStateCreateInfos;
-    pipelineCreateInfo.pDepthStencilState =
-        isWritingDepth ? &Utils::Pipeline::defaultStencilCreateState :
-                         &Utils::Pipeline::defaultTransluscentStencilCreateState;
+    pipelineCreateInfo.pDepthStencilState = &depthState;
 
     pipelineCreateInfo.layout = newPipeline.layout;
     pipelineCreateInfo.renderPass = renderPass->GetRenderPass();

engine/render/renderer/platform/vulkan/Pipeline.h

@@ -105,6 +105,11 @@ class Pipeline
          */
         Builder& WithFragmentShader(const Shader* fragShader);
 
+        /**
+         * Specifies if the pipeline is writing to the depth buffer
+         * @param state the state of depth buffer writing
+         * @return a reference to the current builder instance
+         */
         Builder& WithDepthWriting(bool state);
 
         /**
@@ -114,6 +119,12 @@ class Pipeline
          */
         Builder& WithProperties(const MSArray<VkDescriptorSetLayout, 10>& layouts);
 
+        /**
+         * Specifies a push constant to be used by the pipeline
+         * @param size the size of the push constant
+         * @param type the shader that the push constant will be pushed to
+         * @return a reference to the current builder instance
+         */
         Builder& WithPushConstant(uint32_t size, Utils::ShaderType type);
 
         /**
@@ -136,7 +147,6 @@ class Pipeline
 
         bool usingDepthTest {true};
         bool usingDepthWrite {true};
-        bool isWritingDepth {true};
 
         RenderPass* renderPass {nullptr};
     };

engine/render/renderer/platform/vulkan/Shader.cpp

@@ -45,13 +45,6 @@ Shader::VertexBinding& Shader::VertexBinding::AddFloatVec2Attribute()
     return *this;
 }
 
-Shader::VertexBinding& Shader::VertexBinding::AddU32Attribute()
-{
-    attributes.Append({stride, Utils::VertexAttributeType::VERTEX_UINT_32, inputRate});
-    stride += sizeof(uint32_t);
-    return *this;
-}
-
 Shader::VertexBinding& Shader::VertexBinding::AddMat4Attribute()
 {
     return AddFloatVec4Attribute()
@@ -60,16 +53,6 @@ Shader::VertexBinding& Shader::VertexBinding::AddMat4Attribute()
         .AddFloatVec4Attribute();
 }
 
-Shader::VertexBinding& Shader::VertexBinding::AddMat2Attribute()
-{
-    return AddFloatVec4Attribute().AddFloatVec4Attribute();
-}
-
-Shader::VertexBinding& Shader::VertexBinding::AddMat3Attribute()
-{
-    return AddFloatVec4Attribute().AddFloatVec4Attribute().AddFloatVec4Attribute();
-}
-
 Shader::Builder& Shader::Builder::WithGlobalData3DUniform(uint32_t set)
 {
     return WithUniform<Siege::Renderer3D::GlobalData>("globalData", set);
@@ -138,12 +121,6 @@ Shader::Builder& Shader::Builder::WithVertexBinding(const Shader::VertexBinding&
     return *this;
 }
 
-Shader::Builder& Shader::Builder::WithDepthWrite(bool state)
-{
-    isWritingDepth = state;
-    return *this;
-}
-
 Shader Shader::Builder::Build() const
 {
     return Shader(filePath,
@@ -154,8 +131,7 @@ Shader Shader::Builder::Build() const
                   defaultTextureInfo,
                   pushConstant,
                   totalUniformSize,
-                  attributeCount,
-                  isWritingDepth);
+                  attributeCount);
 }
 
 Shader::Shader(const Shader& other) :
@@ -165,8 +141,7 @@ Shader::Shader(const Shader& other) :
     vertexBindings {other.vertexBindings},
     defaultTextureInfo {other.defaultTextureInfo},
     pushConstant {other.pushConstant},
-    totalUniformSize {other.totalUniformSize},
-    isWritingDepth {other.isWritingDepth}
+    totalUniformSize {other.totalUniformSize}
 {
     CreateShaderModule();
 }
@@ -179,8 +154,7 @@ Shader::Shader(const String& filePath,
                Texture2D::Info tex2DInfo,
                PushConstant pushConstant,
                size_t totalSize,
-               uint32_t totalVertexAttributes,
-               bool isWritingDepth) :
+               uint32_t totalVertexAttributes) :
     filePath {filePath},
     type {type},
     expectedTopology {expectedTopology},
@@ -189,8 +163,7 @@ Shader::Shader(const String& filePath,
     defaultTextureInfo {tex2DInfo},
     pushConstant {pushConstant},
     totalUniformSize {totalSize},
-    totalVertexAttributeCount {totalVertexAttributes},
-    isWritingDepth {isWritingDepth}
+    totalVertexAttributeCount {totalVertexAttributes}
 {
     CreateShaderModule();
 }
@@ -249,7 +222,6 @@ void Shader::Swap(Shader& other)
     auto tmpExpectedTopology = expectedTopology;
     auto tmpDefaultTexture2DInfo = defaultTextureInfo;
     auto tmpPushConstant = pushConstant;
-    auto tmpIsWritingDepth = isWritingDepth;
 
     filePath = other.filePath;
     type = other.type;
@@ -261,7 +233,6 @@ void Shader::Swap(Shader& other)
     expectedTopology = other.expectedTopology;
     defaultTextureInfo = other.defaultTextureInfo;
     pushConstant = other.pushConstant;
-    isWritingDepth = other.isWritingDepth;
 
     other.filePath = tmpFilePath;
     other.type = tmpShaderType;
@@ -273,6 +244,5 @@ void Shader::Swap(Shader& other)
     other.expectedTopology = tmpExpectedTopology;
     other.defaultTextureInfo = tmpDefaultTexture2DInfo;
     other.pushConstant = tmpPushConstant;
-    other.isWritingDepth = tmpIsWritingDepth;
 }
 } // namespace Siege::Vulkan