Ch29Multisampling.diff

diff --git "a/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch28Mipmapping.java" "b/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch29Multisampling.java"
index ba55d68..f53e108 100644
--- "a/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch28Mipmapping.java"
+++ "b/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch29Multisampling.java"
@@ -6,7 +6,6 @@ import org.joml.Vector2fc;
 import org.joml.Vector3f;
 import org.joml.Vector3fc;
 import org.lwjgl.PointerBuffer;
-import org.lwjgl.system.Configuration;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.system.Pointer;
 import org.lwjgl.vulkan.*;
@@ -44,9 +43,8 @@ import static org.lwjgl.vulkan.EXTDebugUtils.*;
 import static org.lwjgl.vulkan.KHRSurface.*;
 import static org.lwjgl.vulkan.KHRSwapchain.*;
 import static org.lwjgl.vulkan.VK10.*;
-import static org.lwjgl.vulkan.VK11.VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
 
-public class Ch28Mipmapping {
+public class Ch29Multisampling {
 
     private static class HelloTriangleApplication {
 
@@ -152,9 +150,9 @@ public class Ch28Mipmapping {
             private static final int OFFSETOF_COLOR = 3 * Float.BYTES;
             private static final int OFFSETOF_TEXTCOORDS = (3 + 3) * Float.BYTES;
 
-            private final Vector3fc pos;
-            private final Vector3fc color;
-            private final Vector2fc texCoords;
+            private Vector3fc pos;
+            private Vector3fc color;
+            private Vector2fc texCoords;
 
             public Vertex(Vector3fc pos, Vector3fc color, Vector2fc texCoords) {
                 this.pos = pos;
@@ -214,6 +212,7 @@ public class Ch28Mipmapping {
         private long surface;
 
         private VkPhysicalDevice physicalDevice;
+        private int msaaSamples = VK_SAMPLE_COUNT_1_BIT;
         private VkDevice device;
 
         private VkQueue graphicsQueue;
@@ -235,6 +234,10 @@ public class Ch28Mipmapping {
 
         private long commandPool;
 
+        private long colorImage;
+        private long colorImageMemory;
+        private long colorImageView;
+
         private long depthImage;
         private long depthImageMemory;
         private long depthImageView;
@@ -334,6 +337,10 @@ public class Ch28Mipmapping {
 
         private void cleanupSwapChain() {
 
+            vkDestroyImageView(device, colorImageView, null);
+            vkDestroyImage(device, colorImage, null);
+            vkFreeMemory(device, colorImageMemory, null);
+
             vkDestroyImageView(device, depthImageView, null);
             vkDestroyImage(device, depthImage, null);
             vkFreeMemory(device, depthImageMemory, null);
@@ -425,6 +432,7 @@ public class Ch28Mipmapping {
             createImageViews();
             createRenderPass();
             createGraphicsPipeline();
+            createColorResources();
             createDepthResources();
             createFramebuffers();
             createUniformBuffers();
@@ -544,6 +552,7 @@ public class Ch28Mipmapping {
 
                     if(isDeviceSuitable(device)) {
                         physicalDevice = device;
+                        msaaSamples = getMaxUsableSampleCount();
                         return;
                     }
                 }
@@ -571,6 +580,7 @@ public class Ch28Mipmapping {
 
                 VkPhysicalDeviceFeatures deviceFeatures = VkPhysicalDeviceFeatures.calloc(stack);
                 deviceFeatures.samplerAnisotropy(true);
+                deviceFeatures.sampleRateShading(true); // Enable sample shading feature for the device
 
                 VkDeviceCreateInfo createInfo = VkDeviceCreateInfo.calloc(stack);
 
@@ -687,30 +697,47 @@ public class Ch28Mipmapping {
 
             try(MemoryStack stack = stackPush()) {
 
-                VkAttachmentDescription.Buffer attachments = VkAttachmentDescription.calloc(2, stack);
-                VkAttachmentReference.Buffer attachmentRefs = VkAttachmentReference.calloc(2, stack);
+                VkAttachmentDescription.Buffer attachments = VkAttachmentDescription.calloc(3, stack);
+                VkAttachmentReference.Buffer attachmentRefs = VkAttachmentReference.calloc(3, stack);
 
                 // Color attachments
 
+                // MSAA Image
                 VkAttachmentDescription colorAttachment = attachments.get(0);
                 colorAttachment.format(swapChainImageFormat);
-                colorAttachment.samples(VK_SAMPLE_COUNT_1_BIT);
+                colorAttachment.samples(msaaSamples);
                 colorAttachment.loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR);
                 colorAttachment.storeOp(VK_ATTACHMENT_STORE_OP_STORE);
                 colorAttachment.stencilLoadOp(VK_ATTACHMENT_LOAD_OP_DONT_CARE);
                 colorAttachment.stencilStoreOp(VK_ATTACHMENT_STORE_OP_DONT_CARE);
                 colorAttachment.initialLayout(VK_IMAGE_LAYOUT_UNDEFINED);
-                colorAttachment.finalLayout(VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+                colorAttachment.finalLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
 
                 VkAttachmentReference colorAttachmentRef = attachmentRefs.get(0);
                 colorAttachmentRef.attachment(0);
                 colorAttachmentRef.layout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
 
+                // Present Image
+                VkAttachmentDescription colorAttachmentResolve = attachments.get(2);
+                colorAttachmentResolve.format(swapChainImageFormat);
+                colorAttachmentResolve.samples(VK_SAMPLE_COUNT_1_BIT);
+                colorAttachmentResolve.loadOp(VK_ATTACHMENT_LOAD_OP_DONT_CARE);
+                colorAttachmentResolve.storeOp(VK_ATTACHMENT_STORE_OP_STORE);
+                colorAttachmentResolve.stencilLoadOp(VK_ATTACHMENT_LOAD_OP_DONT_CARE);
+                colorAttachmentResolve.stencilStoreOp(VK_ATTACHMENT_STORE_OP_DONT_CARE);
+                colorAttachmentResolve.initialLayout(VK_IMAGE_LAYOUT_UNDEFINED);
+                colorAttachmentResolve.finalLayout(VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+
+                VkAttachmentReference colorAttachmentResolveRef = attachmentRefs.get(2);
+                colorAttachmentResolveRef.attachment(2);
+                colorAttachmentResolveRef.layout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+
+
                 // Depth-Stencil attachments
 
                 VkAttachmentDescription depthAttachment = attachments.get(1);
                 depthAttachment.format(findDepthFormat());
-                depthAttachment.samples(VK_SAMPLE_COUNT_1_BIT);
+                depthAttachment.samples(msaaSamples);
                 depthAttachment.loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR);
                 depthAttachment.storeOp(VK_ATTACHMENT_STORE_OP_DONT_CARE);
                 depthAttachment.stencilLoadOp(VK_ATTACHMENT_LOAD_OP_DONT_CARE);
@@ -727,6 +754,7 @@ public class Ch28Mipmapping {
                 subpass.colorAttachmentCount(1);
                 subpass.pColorAttachments(VkAttachmentReference.calloc(1, stack).put(0, colorAttachmentRef));
                 subpass.pDepthStencilAttachment(depthAttachmentRef);
+                subpass.pResolveAttachments(VkAttachmentReference.calloc(1, stack).put(0, colorAttachmentResolveRef));
 
                 VkSubpassDependency.Buffer dependency = VkSubpassDependency.calloc(1, stack);
                 dependency.srcSubpass(VK_SUBPASS_EXTERNAL);
@@ -864,8 +892,9 @@ public class Ch28Mipmapping {
 
                 VkPipelineMultisampleStateCreateInfo multisampling = VkPipelineMultisampleStateCreateInfo.calloc(stack);
                 multisampling.sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO);
-                multisampling.sampleShadingEnable(false);
-                multisampling.rasterizationSamples(VK_SAMPLE_COUNT_1_BIT);
+                multisampling.sampleShadingEnable(true);
+                multisampling.minSampleShading(0.2f); // Enable sample shading in the pipeline
+                multisampling.rasterizationSamples(msaaSamples); // Min fraction for sample shading; closer to one is smoother
 
                 VkPipelineDepthStencilStateCreateInfo depthStencil = VkPipelineDepthStencilStateCreateInfo.calloc(stack);
                 depthStencil.sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO);
@@ -944,7 +973,7 @@ public class Ch28Mipmapping {
 
             try(MemoryStack stack = stackPush()) {
 
-                LongBuffer attachments = stack.longs(VK_NULL_HANDLE, depthImageView);
+                LongBuffer attachments = stack.longs(colorImageView, depthImageView, VK_NULL_HANDLE);
                 LongBuffer pFramebuffer = stack.mallocLong(1);
 
                 // Lets allocate the create info struct once and just update the pAttachments field each iteration
@@ -957,7 +986,7 @@ public class Ch28Mipmapping {
 
                 for(long imageView : swapChainImageViews) {
 
-                    attachments.put(0, imageView);
+                    attachments.put(2, imageView);
 
                     framebufferInfo.pAttachments(attachments);
 
@@ -990,6 +1019,32 @@ public class Ch28Mipmapping {
             }
         }
 
+        private void createColorResources() {
+
+            try(MemoryStack stack = stackPush()) {
+
+                LongBuffer pColorImage = stack.mallocLong(1);
+                LongBuffer pColorImageMemory = stack.mallocLong(1);
+
+                createImage(swapChainExtent.width(), swapChainExtent.height(),
+                        1,
+                        msaaSamples,
+                        swapChainImageFormat,
+                        VK_IMAGE_TILING_OPTIMAL,
+                        VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+                        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+                        pColorImage,
+                        pColorImageMemory);
+
+                colorImage = pColorImage.get(0);
+                colorImageMemory = pColorImageMemory.get(0);
+
+                colorImageView = createImageView(colorImage, swapChainImageFormat, VK_IMAGE_ASPECT_COLOR_BIT, 1);
+
+                transitionImageLayout(colorImage, swapChainImageFormat, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 1);
+            }
+        }
+
         private void createDepthResources() {
 
             try(MemoryStack stack = stackPush()) {
@@ -1002,6 +1057,7 @@ public class Ch28Mipmapping {
                 createImage(
                         swapChainExtent.width(), swapChainExtent.height(),
                         1,
+                        msaaSamples,
                         depthFormat,
                         VK_IMAGE_TILING_OPTIMAL,
                         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
@@ -1104,7 +1160,7 @@ public class Ch28Mipmapping {
                 LongBuffer pTextureImageMemory = stack.mallocLong(1);
                 createImage(pWidth.get(0), pHeight.get(0),
                         mipLevels,
-                        VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TILING_OPTIMAL,
+                        VK_SAMPLE_COUNT_1_BIT, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TILING_OPTIMAL,
                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
                         VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
                         pTextureImage,
@@ -1230,6 +1286,39 @@ public class Ch28Mipmapping {
             }
         }
 
+        private int getMaxUsableSampleCount() {
+
+            try(MemoryStack stack = stackPush()) {
+
+                VkPhysicalDeviceProperties physicalDeviceProperties = VkPhysicalDeviceProperties.malloc(stack);
+                vkGetPhysicalDeviceProperties(physicalDevice, physicalDeviceProperties);
+
+                int sampleCountFlags = physicalDeviceProperties.limits().framebufferColorSampleCounts()
+                        & physicalDeviceProperties.limits().framebufferDepthSampleCounts();
+
+                if((sampleCountFlags & VK_SAMPLE_COUNT_64_BIT) != 0) {
+                    return VK_SAMPLE_COUNT_64_BIT;
+                }
+                if((sampleCountFlags & VK_SAMPLE_COUNT_32_BIT) != 0) {
+                    return VK_SAMPLE_COUNT_32_BIT;
+                }
+                if((sampleCountFlags & VK_SAMPLE_COUNT_16_BIT) != 0) {
+                    return VK_SAMPLE_COUNT_16_BIT;
+                }
+                if((sampleCountFlags & VK_SAMPLE_COUNT_8_BIT) != 0) {
+                    return VK_SAMPLE_COUNT_8_BIT;
+                }
+                if((sampleCountFlags & VK_SAMPLE_COUNT_4_BIT) != 0) {
+                    return VK_SAMPLE_COUNT_4_BIT;
+                }
+                if((sampleCountFlags & VK_SAMPLE_COUNT_2_BIT) != 0) {
+                    return VK_SAMPLE_COUNT_2_BIT;
+                }
+
+                return VK_SAMPLE_COUNT_1_BIT;
+            }
+        }
+
         private void createTextureImageView() {
             textureImageView = createImageView(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_ASPECT_COLOR_BIT, mipLevels);
         }
@@ -1291,12 +1380,12 @@ public class Ch28Mipmapping {
             }
         }
 
-        private void createImage(int width, int height, int mipLevels, int format, int tiling, int usage, int memProperties,
+        private void createImage(int width, int height, int mipLevels, int numSamples, int format, int tiling, int usage, int memProperties,
                                  LongBuffer pTextureImage, LongBuffer pTextureImageMemory) {
 
             try(MemoryStack stack = stackPush()) {
 
-                VkImageCreateInfo imageInfo = VkImageCreateInfo.calloc(stack);
+                VkImageCreateInfo imageInfo = VkImageCreateInfo.callocStack(stack);
                 imageInfo.sType(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
                 imageInfo.imageType(VK_IMAGE_TYPE_2D);
                 imageInfo.extent().width(width);
@@ -1308,7 +1397,7 @@ public class Ch28Mipmapping {
                 imageInfo.tiling(tiling);
                 imageInfo.initialLayout(VK_IMAGE_LAYOUT_UNDEFINED);
                 imageInfo.usage(usage);
-                imageInfo.samples(VK_SAMPLE_COUNT_1_BIT);
+                imageInfo.samples(numSamples);
                 imageInfo.sharingMode(VK_SHARING_MODE_EXCLUSIVE);
 
                 if(vkCreateImage(device, imageInfo, null, pTextureImage) != VK_SUCCESS) {
@@ -1318,7 +1407,7 @@ public class Ch28Mipmapping {
                 VkMemoryRequirements memRequirements = VkMemoryRequirements.malloc(stack);
                 vkGetImageMemoryRequirements(device, pTextureImage.get(0), memRequirements);
 
-                VkMemoryAllocateInfo allocInfo = VkMemoryAllocateInfo.calloc(stack);
+                VkMemoryAllocateInfo allocInfo = VkMemoryAllocateInfo.callocStack(stack);
                 allocInfo.sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
                 allocInfo.allocationSize(memRequirements.size());
                 allocInfo.memoryTypeIndex(findMemoryType(stack, memRequirements.memoryTypeBits(), memProperties));
@@ -1335,7 +1424,7 @@ public class Ch28Mipmapping {
 
             try(MemoryStack stack = stackPush()) {
 
-                VkImageMemoryBarrier.Buffer barrier = VkImageMemoryBarrier.calloc(1, stack);
+                VkImageMemoryBarrier.Buffer barrier = VkImageMemoryBarrier.callocStack(1, stack);
                 barrier.sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER);
                 barrier.oldLayout(oldLayout);
                 barrier.newLayout(newLayout);
@@ -1388,6 +1477,14 @@ public class Ch28Mipmapping {
                     sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
                     destinationStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
 
+                } else if(oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
+
+                    barrier.srcAccessMask(0);
+                    barrier.dstAccessMask(VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
+
+                    sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+                    destinationStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+
                 } else {
                     throw new IllegalArgumentException("Unsupported layout transition");
                 }
@@ -1411,7 +1508,7 @@ public class Ch28Mipmapping {
 
                 VkCommandBuffer commandBuffer = beginSingleTimeCommands();
 
-                VkBufferImageCopy.Buffer region = VkBufferImageCopy.calloc(1, stack);
+                VkBufferImageCopy.Buffer region = VkBufferImageCopy.callocStack(1, stack);
                 region.bufferOffset(0);
                 region.bufferRowLength(0);   // Tightly packed
                 region.bufferImageHeight(0);  // Tightly packed
@@ -2164,7 +2261,6 @@ public class Ch28Mipmapping {
         }
 
         private PointerBuffer asPointerBuffer(MemoryStack stack, Collection<String> collection) {
-            if(collection == null) return null;
 
             PointerBuffer buffer = stack.mallocPointer(collection.size());
 
@@ -2176,7 +2272,6 @@ public class Ch28Mipmapping {
         }
 
         private PointerBuffer asPointerBuffer(MemoryStack stack, List<? extends Pointer> list) {
-            if(list == null) return null;
 
             PointerBuffer buffer = stack.mallocPointer(list.size());