Refactor of changes due to chapter 10

Author: lwjglgamedev

bookcontents/README.md

@@ -12,4 +12,4 @@ The book is structured in the following chapters:
 - [Chapter 07](chapter-07/chapter-07.md): In this chapter we go 3D by implementing depth testing and add windows resizing support.
 - [Chapter 08](chapter-08/chapter-08.md): In this chapter we add support for loading complex 3D models using Assimp and textures.
 - [Chapter 09](chapter-09/chapter-09.md): We will automatically generate mipmaps, add support for transparent objects, add a camera to move around the scene and use dynamic uniform objects.
-- [Chapter 10](chapter-09/chapter-10.md): Deferred rendering (Draft code, synchronization needs to be reviewed).
+- [Chapter 10](chapter-09/chapter-10.md): Deferred rendering.

bookcontents/chapter-04/chapter-04.md

@@ -142,7 +142,15 @@ public class SwapChain {
 }
 ```
 
-The first thing we do is retrieve the number of formats our surface supports by calling the `vkGetPhysicalDeviceSurfaceFormatsKHR` Vulkan function. As with many other Vulkan samples, we first call that function to get the total number of formats supported and then we create a buffer of structures, `VkSurfaceFormatKHR` in this case, to retrieve the data by calling the same function again. Once we have all that data, we iterate over the formats trying to check if `VK_FORMAT_B8G8R8A8_UNORM`(8 bits for RGBA channels normalized) and SRGB non linear color space are supported. `SurfaceFormat` is just a `record` which stores the image format and the color space.
+The first thing we do is retrieve the number of formats our surface supports by calling the `vkGetPhysicalDeviceSurfaceFormatsKHR` Vulkan function. As with many other Vulkan samples, we first call that function to get the total number of formats supported and then we create a buffer of structures, `VkSurfaceFormatKHR` in this case, to retrieve the data by calling the same function again. Once we have all that data, we iterate over the formats trying to check if `VK_FORMAT_B8G8R8A8_UNORM`(8 bits for RGBA channels normalized) and SRGB non linear color space are supported. `SurfaceFormat` is just a `record` which stores the image format and the color space:
+```java
+public class SwapChain {
+    ...
+    public record SurfaceFormat(int imageFormat, int colorSpace) {
+    }
+    ...
+}
+```
 
 It is turn again to go back to the constructor. We need to calculate now the extent of the images of the swap chain:
 

bookcontents/chapter-05/chapter-05.md

@@ -541,17 +541,15 @@ public class SwapChain {
 ```
 
 We create to types of semaphores:
-
-- `imgAcquisitionSemaphores`: They will be used to signal image acquisition.
-
-- `renderCompleteSemaphores`: They will be used to signal that the command submitted have been completed. 
+- `imgAcquisitionSemaphore`: It will be used to signal image acquisition.
+- `renderCompleteSemaphore`: It will be used to signal that the command submitted have been completed. 
 
 These semaphores are stored together under a record:
 
 ```java
 public class SwapChain {
     ...
-    public record SyncSemaphores(Semaphore imgAcquisitionSemaphores, Semaphore renderCompleteSemaphores) {
+    public record SyncSemaphores(Semaphore imgAcquisitionSemaphore, Semaphore renderCompleteSemaphore) {
     }
     ...
 }
@@ -567,7 +565,7 @@ public class SwapChain {
         try (MemoryStack stack = MemoryStack.stackPush()) {
             IntBuffer ip = stack.mallocInt(1);
             int err = KHRSwapchain.vkAcquireNextImageKHR(device.getVkDevice(), vkSwapChain, ~0L,
-                    syncSemaphoresList[currentFrame].imgAcquisitionSemaphores().getVkSemaphore(), MemoryUtil.NULL, ip);
+                    syncSemaphoresList[currentFrame].imgAcquisitionSemaphore().getVkSemaphore(), MemoryUtil.NULL, ip);
             if (err == KHRSwapchain.VK_ERROR_OUT_OF_DATE_KHR) {
                 resize = true;
             } else if (err == KHRSwapchain.VK_SUBOPTIMAL_KHR) {
@@ -604,7 +602,7 @@ public class SwapChain {
             VkPresentInfoKHR present = VkPresentInfoKHR.callocStack(stack)
                     .sType(KHRSwapchain.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR)
                     .pWaitSemaphores(stack.longs(
-                            syncSemaphoresList[currentFrame].renderCompleteSemaphores().getVkSemaphore()))
+                            syncSemaphoresList[currentFrame].renderCompleteSemaphore().getVkSemaphore()))
                     .swapchainCount(1)
                     .pSwapchains(stack.longs(vkSwapChain))
                     .pImageIndices(stack.ints(currentFrame));
@@ -740,17 +738,17 @@ public class ForwardRenderActivity {
             currentFence.reset();
             SwapChain.SyncSemaphores syncSemaphores = swapChain.getSyncSemaphoresList()[idx];
             queue.submit(stack.pointers(commandBuffer.getVkCommandBuffer()),
-                    stack.longs(syncSemaphores.imgAcquisitionSemaphores().getVkSemaphore()),
+                    stack.longs(syncSemaphores.imgAcquisitionSemaphore().getVkSemaphore()),
                     stack.ints(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT),
-                    stack.longs(syncSemaphores.renderCompleteSemaphores().getVkSemaphore()), currentFence);
+                    stack.longs(syncSemaphores.renderCompleteSemaphore().getVkSemaphore()), currentFence);
 
         }
     }
     ...
 }
 ```
 
-This method, gets the `CommandBuffer` instance that should be used for the frame that we are in (for the image that we are rendering to). It also gets the `Fence`associated to that `CommandBuffer`. We invoke the `fenceAit` and the `reset`  one to prevent submitting a `CommandBuffer` which is still been used. Finally, we submit the command to the queue, retrieving also the semaphore that has been used to signal the acquisition of the current swap chain image. This is done by invoking a new method in the `Queue` class, named `submit`. The meaning of the arguments of this method will be explained when we analyzed its definition:
+This method, gets the `CommandBuffer` instance that should be used for the frame that we are in (for the image that we are rendering to). It also gets the `Fence`associated to that `CommandBuffer`. We invoke the `fenceWait` and the `reset` one to prevent submitting a `CommandBuffer` which is still been used. Finally, we submit the command to the queue, retrieving also the semaphore that has been used to signal the acquisition of the current swap chain image. This is done by invoking a new method in the `Queue` class, named `submit`. The meaning of the arguments of this method will be explained when we analyzed its definition:
 
 ```java
 public class Queue {

bookcontents/chapter-06/chapter-06.md

@@ -159,14 +159,33 @@ public class VulkanBuffer {
 
 ## Vertex description
 
-We have now created the buffers required to hold the data for vertices, the next step is to describe to Vulkan the format of that data. In order to do that, we will create a new class named `VertexBufferStructure` which will be used by Vulkan to know hot to extract that data from the underlying buffer. The class starts like this:
+We have now created the buffers required to hold the data for vertices, the next step is to describe to Vulkan the format of that data. As you can guess, depending on the specific case, the structure of that data may change, we may have just position coordinates, or position with texture coordinates and normals, etc. Some of the vulkan elements that we will define later on, will need a handle to that structure. In order to support this, we will create an abstract class named `VertexInputStateInfo`, which just stores the handle to a `VkPipelineVertexInputStateCreateInfo` structure:
+```java
+package org.vulkanb.eng.graph.vk;
+
+import org.lwjgl.vulkan.VkPipelineVertexInputStateCreateInfo;
+
+public abstract class VertexInputStateInfo {
+
+    protected VkPipelineVertexInputStateCreateInfo vi;
+
+    public void cleanup() {
+        vi.free();
+    }
+
+    public VkPipelineVertexInputStateCreateInfo getVi() {
+        return vi;
+    }
+}
+```
+
+Now we can extend from tha class to define specific vertex formats. We will create a new class named `VertexBufferStructure` which will be used by Vulkan to know hot to extract that data from the underlying buffer. The class starts like this:
 
 ```java
-public class VertexBufferStructure {
+public class VertexBufferStructure extends VertexInputStateInfo {
 
     private static final int NUMBER_OF_ATTRIBUTES = 1;
     private static final int POSITION_COMPONENTS = 3;
-    private VkPipelineVertexInputStateCreateInfo vi;
     private VkVertexInputAttributeDescription.Buffer viAttrs;
     private VkVertexInputBindingDescription.Buffer viBindings;
 
@@ -259,15 +278,10 @@ The rest of the methods are the usual suspects, the `cleanup` one  to free the r
 public class VertexBufferStructure {
     ...
     public void cleanup() {
-        vi.free();
+        super.cleanup();
         viBindings.free();
         viAttrs.free();
     }
-
-    public VkPipelineVertexInputStateCreateInfo getVi() {
-        return vi;
-    }
-    ...
 }
 ```
 
@@ -750,9 +764,9 @@ Now it is the turn to create the pipeline, which will be encapsulated in a new c
 ```java
 public class Pipeline {
     ...
-    public record PipeLineCreationInfo(long vkRenderPass, ShaderProgram shaderProgram, int numColorAttachments, VertexBufferStructure vertexBufferStructure) {
+    public record PipeLineCreationInfo(long vkRenderPass, ShaderProgram shaderProgram, int numColorAttachments, VertexInputStateInfo viInputStateInfo) {
         public void cleanup() {
-            vertexBufferStructure.cleanup();
+            viInputStateInfo.cleanup();
         }
     }
     ...
@@ -945,7 +959,7 @@ public class Pipeline {
             VkGraphicsPipelineCreateInfo.Buffer pipeline = VkGraphicsPipelineCreateInfo.callocStack(1, stack)
                     .sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
                     .pStages(shaderStages)
-                    .pVertexInputState(pipeLineCreationInfo.vertexBufferStructure().getVi())
+                    .pVertexInputState(pipeLineCreationInfo.viInputStateInfo().getVi())
                     .pInputAssemblyState(vkPipelineInputAssemblyStateCreateInfo)
                     .pViewportState(vkPipelineViewportStateCreateInfo)
                     .pRasterizationState(vkPipelineRasterizationStateCreateInfo)

bookcontents/chapter-07/chapter-07.md

@@ -178,6 +178,7 @@ import static org.lwjgl.vulkan.VK11.*;
 
 public class Attachment {
 
+    private boolean depthAttachment;
     private Image image;
     private ImageView imageView;
 
@@ -187,9 +188,11 @@ public class Attachment {
         int aspectMask = 0;
         if ((usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) > 0) {
             aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+            depthAttachment = false;
         }
         if ((usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) > 0) {
             aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+            depthAttachment = true;
         }
 
         imageView = new ImageView(device, image.getVkImage(), image.getFormat(), aspectMask, 1);
@@ -207,16 +210,20 @@ public class Attachment {
     public ImageView getImageView() {
         return imageView;
     }
+
+    public boolean isDepthAttachment() {
+        return depthAttachment;
+    }
 }
 ```
-We just create and image and the associated image view. Depending on the type of image (color or depth image), we setup the aspect mask accordingly.
+We just create and image and the associated image view. Depending on the type of image (color or depth image), we setup the aspect mask accordingly. We also have defined a `boolean` attribute, named `depthAttachment` to identify if it is a depth attachment or not.
 
 ## Changing vertices structure
 
 In the previous chapter, we defined the structure of our vertices, which basically stated that our vertices were composed by x, y and z positions. Therefore, we would not need anything more to display 3D models. However, displaying a 3D model just using a single color (without shadows or light effects), makes difficult to verify if the model is being loaded property. So, we will add extra components that we will reuse in next chapters, we will add texture coordinates. Although we will not be handling textures in this chapter, we can use those components to pass some color information (at lest for two color channels). We need to modify the `VertexBufferStructure`  in this way:
 
 ```java
-public class VertexBufferStructure {
+public class VertexBufferStructure extends VertexInputStateInfo {
 
     public static final int TEXT_COORD_COMPONENTS = 2;
     private static final int NUMBER_OF_ATTRIBUTES = 2;
@@ -568,9 +575,9 @@ public class Pipeline {
     ...
     public record PipeLineCreationInfo(long vkRenderPass, ShaderProgram shaderProgram, int numColorAttachments,
         boolean hasDepthAttachment, int pushConstantsSize,
-        VertexBufferStructure vertexBufferStructure) {
+        VertexInputStateInfo viInputStateInfo) {
         public void cleanup() {
-            vertexBufferStructure.cleanup();
+            viInputStateInfo.cleanup();
         }
     }
     ...

bookcontents/chapter-08/chapter-08.md

@@ -1028,7 +1028,7 @@ public class MatrixDescriptorSetLayout extends DescriptorSetLayout {
 
     private static final Logger LOGGER = LogManager.getLogger();
 
-    public MatrixDescriptorSetLayout(Device device, int binding) {
+    public MatrixDescriptorSetLayout(Device device, int binding, int stage) {
         super(device);
 
         LOGGER.debug("Creating matrix descriptor set layout");
@@ -1039,7 +1039,7 @@ public class MatrixDescriptorSetLayout extends DescriptorSetLayout {
                     .binding(binding)
                     .descriptorType(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
                     .descriptorCount(1)
-                    .stageFlags(VK_SHADER_STAGE_VERTEX_BIT);
+                    .stageFlags(stage);
 
             VkDescriptorSetLayoutCreateInfo layoutInfo = VkDescriptorSetLayoutCreateInfo.callocStack(stack)
                     .sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
@@ -1054,7 +1054,7 @@ public class MatrixDescriptorSetLayout extends DescriptorSetLayout {
 }
 ```
 
-The code is quite similar to the one used in textures, but in this case we are using a different descriptor type: `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` to state that this descriptor will be associated directly to a buffer. We are also stating that this will be used in a vertex shader by using the `VK_SHADER_STAGE_VERTEX_BIT` flag.
+The code is quite similar to the one used in textures, but in this case we are using a different descriptor type: `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` to state that this descriptor will be associated directly to a buffer. The class receives also a stage parameter which states which pipeline stage the descriptor sets will be used. In our case, as we will see later on, we will use it in a vertex shader, so we will be using the `VK_SHADER_STAGE_VERTEX_BIT` flag.
 
 We need also to create the descriptor set associated to the uniform that will hold the projection matrix, in a new class named `MatrixDescriptorSet`:
 
@@ -1125,10 +1125,10 @@ public class Pipeline {
     ...
     public record PipeLineCreationInfo(long vkRenderPass, ShaderProgram shaderProgram, int numColorAttachments,
                                        boolean hasDepthAttachment, int pushConstantsSize,
-                                       VertexBufferStructure vertexBufferStructure,
+                                       VertexInputStateInfo viInputStateInfo,
                                        DescriptorSetLayout[]descriptorSetLayouts) {
         public void cleanup() {
-            vertexBufferStructure.cleanup();
+            viInputStateInfo.cleanup();
         }
     }
 }
@@ -1185,7 +1185,7 @@ We create the descriptor layouts for the textures and the uniform that will hold
 public class ForwardRenderActivity {
     ...
     private void createDescriptorSets() {
-        matrixDescriptorSetLayout = new MatrixDescriptorSetLayout(device, 0);
+        matrixDescriptorSetLayout = new MatrixDescriptorSetLayout(device, 0, VK_SHADER_STAGE_VERTEX_BIT);
         textureDescriptorSetLayout = new TextureDescriptorSetLayout(device, 0);
         descriptorSetLayouts = new DescriptorSetLayout[]{
                 matrixDescriptorSetLayout,
@@ -1208,16 +1208,21 @@ public class ForwardRenderActivity {
 
 First we create the descriptor set layouts. Once we have those, we can create the descriptor pool. In this case we will create just one descriptor for a single texture and a single descriptor for the projection matrix. We also create a texture sampler. Warning note: If the uniform could be updated in each frame, we would need as many descriptors as swap chain images we have. If not, we could be updating the descriptor set contents while still being used in rendering another frame. We also create a map, that we will use for the textures. We will store the descriptors associated to each texture indexed by the file used to load it.
 
-Going back to the `ForwardRenderActivity` constructor, the projection matrix only will be updated when resizing and when that occurs we will not be drawing anything, so it is safe to have just one. We initialize the buffer associated to the projection uniform by calling the `copyMatrixToBuffer` which is defined like this:
-
+Going back to the `ForwardRenderActivity` constructor, the projection matrix only will be updated when resizing and when that occurs we will not be drawing anything, so it is safe to have just one. We initialize the buffer associated to the projection uniform by calling the `copyMatrixToBuffer` method from the `VulkanUtils` class:
 ```java
 public class ForwardRenderActivity {
     ...
     public ForwardRenderActivity(SwapChain swapChain, CommandPool commandPool, PipelineCache pipelineCache, Scene scene) {
         ...
-        copyMatrixToBuffer(projMatrixUniform, scene.getPerspective().getPerspectiveMatrix());
+        VulkanUtils.copyMatrixToBuffer(device, projMatrixUniform, scene.getPerspective().getPerspectiveMatrix());
     }
-
+    ...
+}
+```
+The `copyMatrixToBuffer` method  is defined like this:
+```java
+public class VulkanUtils {
+    ...
     private void copyMatrixToBuffer(VulkanBuffer vulkanBuffer, Matrix4f matrix) {
         try (MemoryStack stack = MemoryStack.stackPush()) {
             PointerBuffer pointerBuffer = stack.mallocPointer(1);
@@ -1321,13 +1326,13 @@ public class ForwardRenderActivity {
 }
 ```
 
-The `resize` method needs also to be modified ti update the buffer that will back the projection matrix uniform:
+The `resize` method needs also to be modified to update the buffer that will back the projection matrix uniform:
 
 ```java
 public class ForwardRenderActivity {
     ...
     public void resize(SwapChain swapChain, Scene scene) {
-        copyMatrixToBuffer(projMatrixUniform, scene.getPerspective().getPerspectiveMatrix());
+        VulkanUtils.copyMatrixToBuffer(device, projMatrixUniform, scene.getPerspective().getPerspectiveMatrix());
         ...
     }
     ...