Project5: Xiaoxiao Zou

README.md

@@ -3,10 +3,59 @@ Vulkan Grass Rendering
 
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 5**
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+* Xiaoxiao Zou
+  * [LinkedIn](https://www.linkedin.com/in/xiaoxiao-zou-23482a1b9/)
+* Tested on: Windows 11, AMD Ryzen 9 7940HS @ 4.00 GHz, Nvidia RTX 4060 Laptop 
 
-### (TODO: Your README)
 
-*DO NOT* leave the README to the last minute! It is a crucial part of the
-project, and we will not be able to grade you without a good README.
+### Result & Features
+![](./img/result.gif)
+
+Features: 
+- culling test
+  - orientation culling test
+
+    ![](./img/result1.gif)
+    Orietation culling is based on if the view direction is not in the same direction as orientation, since the grass has no width, it will cause aliasing effect.
+
+  - view frustum culling test
+
+    ![](./img/result2.gif)
+
+    view frustum culling is based on if the grass is inside camera view, if it is not, the grass will not be rendered.
+
+  - distance culling test
+
+    ![](./img/result3.gif)
+
+    distance culling is based on if grass is too far away from the camera, if it is too far, it will not be rendered.
+
+- physics simulation (no force shown below)
+
+  ![](./img/result4.gif)
+  - gravity force
+
+    ![](./img/result5.gif)
+
+    gravity force will be applied to the grass. since there is no other force be applied to grass, all of grass is laid down. 
+
+  - recovery force (with gravity)
+
+    ![](./img/result6.gif)
+
+    with recovery force, the grass will be back to form a relatively steady position for the grass. 
+
+  - wind force (with gravity and wind)
+
+    ![](./img/result.gif)
+
+    with wind force, it will give grass a wind effect. I am using a wind force as sine function to get a effect to grass floating back and force. 
+
+### Performance & Analysis
+
+![](./img/analysis1.png)
+The FPS descreases as the blades counts become higher, especially when it reaches around 2^15. However, it roughly stays the same for low blades count (since threads count might be larger than blades count).
+
+
+![](./img/analysis2.png)
+The FPS get increased for all culling method individually. (culling test on same view with same blade count). Distance culling gives better performance improvement for this certain view compared to the other twos. All together, it gives best performance improvement.

src/Renderer.cpp

@@ -198,6 +198,38 @@ void Renderer::CreateComputeDescriptorSetLayout() {
     // TODO: Create the descriptor set layout for the compute pipeline
     // Remember this is like a class definition stating why types of information
     // will be stored at each binding
+    VkDescriptorSetLayoutBinding bladeLayoutBinding = {};
+    bladeLayoutBinding.binding = 0;
+    bladeLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+    bladeLayoutBinding.descriptorCount = 1;
+    bladeLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+    bladeLayoutBinding.pImmutableSamplers = nullptr;
+
+    VkDescriptorSetLayoutBinding culledLayoutBinding = {};
+    culledLayoutBinding.binding = 1;
+    culledLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+    culledLayoutBinding.descriptorCount = 1;
+    culledLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+    culledLayoutBinding.pImmutableSamplers = nullptr;
+
+    VkDescriptorSetLayoutBinding numLayoutBinding = {};
+    numLayoutBinding.binding = 2;
+    numLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+    numLayoutBinding.descriptorCount = 1;
+    numLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+    numLayoutBinding.pImmutableSamplers = nullptr;
+
+    std::vector<VkDescriptorSetLayoutBinding> bindings = {bladeLayoutBinding,culledLayoutBinding,numLayoutBinding};
+
+    // Create the descriptor set layout
+    VkDescriptorSetLayoutCreateInfo layoutInfo = {};
+    layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    layoutInfo.bindingCount = static_cast<uint32_t>(bindings.size());
+    layoutInfo.pBindings = bindings.data();
+
+    if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &computeDescriptorSetLayout) != VK_SUCCESS) {
+        throw std::runtime_error("Failed to create descriptor set layout");
+    }
 }
 
 void Renderer::CreateDescriptorPool() {
@@ -216,6 +248,7 @@ void Renderer::CreateDescriptorPool() {
         { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 1 },
 
         // TODO: Add any additional types and counts of descriptors you will need to allocate
+        { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, static_cast<uint32_t>(3*scene->GetBlades().size()) }
     };
 
     VkDescriptorPoolCreateInfo poolInfo = {};
@@ -320,6 +353,42 @@ void Renderer::CreateModelDescriptorSets() {
 void Renderer::CreateGrassDescriptorSets() {
     // TODO: Create Descriptor sets for the grass.
     // This should involve creating descriptor sets which point to the model matrix of each group of grass blades
+    grassDescriptorSets.resize(scene->GetBlades().size());
+
+    // Describe the desciptor set
+    VkDescriptorSetLayout layouts[] = { modelDescriptorSetLayout };
+    VkDescriptorSetAllocateInfo allocInfo = {};
+    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    allocInfo.descriptorPool = descriptorPool;
+    allocInfo.descriptorSetCount = static_cast<uint32_t>(grassDescriptorSets.size());
+    allocInfo.pSetLayouts = layouts;
+
+    // Allocate descriptor sets
+    if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, grassDescriptorSets.data()) != VK_SUCCESS) {
+        throw std::runtime_error("Failed to allocate descriptor set");
+    }
+
+    std::vector<VkWriteDescriptorSet> descriptorWrites(grassDescriptorSets.size());
+
+    for (uint32_t i = 0; i < scene->GetBlades().size(); ++i) {
+        VkDescriptorBufferInfo modelBufferInfo = {};
+        modelBufferInfo.buffer = scene->GetBlades()[i]->GetModelBuffer();
+        modelBufferInfo.offset = 0;
+        modelBufferInfo.range = sizeof(ModelBufferObject);
+
+        descriptorWrites[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        descriptorWrites[i].dstSet = grassDescriptorSets[i];
+        descriptorWrites[i].dstBinding = 0;
+        descriptorWrites[i].dstArrayElement = 0;
+        descriptorWrites[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+        descriptorWrites[i].descriptorCount = 1;
+        descriptorWrites[i].pBufferInfo = &modelBufferInfo;
+        descriptorWrites[i].pImageInfo = nullptr;
+        descriptorWrites[i].pTexelBufferView = nullptr;
+    }
+
+    // Update descriptor sets
+    vkUpdateDescriptorSets(logicalDevice, static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
 }
 
 void Renderer::CreateTimeDescriptorSet() {
@@ -360,6 +429,72 @@ void Renderer::CreateTimeDescriptorSet() {
 void Renderer::CreateComputeDescriptorSets() {
     // TODO: Create Descriptor sets for the compute pipeline
     // The descriptors should point to Storage buffers which will hold the grass blades, the culled grass blades, and the output number of grass blades 
+    computeDescriptorSets.resize(scene->GetBlades().size());
+
+    // Describe the desciptor set
+    VkDescriptorSetLayout layouts[] = { computeDescriptorSetLayout };
+    VkDescriptorSetAllocateInfo allocInfo = {};
+    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    allocInfo.descriptorPool = descriptorPool;
+    allocInfo.descriptorSetCount = static_cast<uint32_t>(computeDescriptorSets.size());
+    allocInfo.pSetLayouts = layouts;
+
+    // Allocate descriptor sets
+    if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, computeDescriptorSets.data()) != VK_SUCCESS) {
+        throw std::runtime_error("Failed to allocate descriptor set");
+    }
+
+    std::vector<VkWriteDescriptorSet> descriptorWrites(3*computeDescriptorSets.size());
+
+    for (uint32_t i = 0; i < scene->GetBlades().size(); ++i) {
+        VkDescriptorBufferInfo bladeBufferInfo = {};
+        bladeBufferInfo.buffer = scene->GetBlades()[i]->GetBladesBuffer();
+        bladeBufferInfo.offset = 0;
+        bladeBufferInfo.range =NUM_BLADES *sizeof(Blade);
+
+        VkDescriptorBufferInfo culledBufferInfo = {};
+        culledBufferInfo.buffer = scene->GetBlades()[i]->GetCulledBladesBuffer();
+        culledBufferInfo.offset = 0;
+        culledBufferInfo.range = NUM_BLADES *sizeof(Blade);
+
+        VkDescriptorBufferInfo numbladeBufferInfo = {};
+        numbladeBufferInfo.buffer = scene->GetBlades()[i]->GetNumBladesBuffer();
+        numbladeBufferInfo.offset = 0;
+        numbladeBufferInfo.range = sizeof(BladeDrawIndirect);
+
+        descriptorWrites[3*i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        descriptorWrites[3*i].dstSet = computeDescriptorSets[i];
+        descriptorWrites[3*i].dstBinding = 0;
+        descriptorWrites[3*i].dstArrayElement = 0;
+        descriptorWrites[3*i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+        descriptorWrites[3*i].descriptorCount = 1;
+        descriptorWrites[3*i].pBufferInfo = &bladeBufferInfo;
+        descriptorWrites[3*i].pImageInfo = nullptr;
+        descriptorWrites[3*i].pTexelBufferView = nullptr;
+
+        descriptorWrites[3*i+1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        descriptorWrites[3*i+1].dstSet = computeDescriptorSets[i];
+        descriptorWrites[3*i+1].dstBinding = 1;
+        descriptorWrites[3*i+1].dstArrayElement = 0;
+        descriptorWrites[3*i+1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+        descriptorWrites[3*i+1].descriptorCount = 1;
+        descriptorWrites[3*i+1].pBufferInfo = &culledBufferInfo;
+        descriptorWrites[3*i+1].pImageInfo = nullptr;
+        descriptorWrites[3*i+1].pTexelBufferView = nullptr;
+
+        descriptorWrites[3*i+2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        descriptorWrites[3*i+2].dstSet = computeDescriptorSets[i];
+        descriptorWrites[3*i+2].dstBinding = 2;
+        descriptorWrites[3*i+2].dstArrayElement = 0;
+        descriptorWrites[3*i+2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+        descriptorWrites[3*i+2].descriptorCount = 1;
+        descriptorWrites[3*i+2].pBufferInfo = &numbladeBufferInfo;
+        descriptorWrites[3*i+2].pImageInfo = nullptr;
+        descriptorWrites[3*i+2].pTexelBufferView = nullptr;
+    }
+
+    // Update descriptor sets
+    vkUpdateDescriptorSets(logicalDevice, static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
 }
 
 void Renderer::CreateGraphicsPipeline() {
@@ -717,7 +852,7 @@ void Renderer::CreateComputePipeline() {
     computeShaderStageInfo.pName = "main";
 
     // TODO: Add the compute dsecriptor set layout you create to this list
-    std::vector<VkDescriptorSetLayout> descriptorSetLayouts = { cameraDescriptorSetLayout, timeDescriptorSetLayout };
+    std::vector<VkDescriptorSetLayout> descriptorSetLayouts = { cameraDescriptorSetLayout, timeDescriptorSetLayout,computeDescriptorSetLayout };
 
     // Create pipeline layout
     VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
@@ -884,6 +1019,11 @@ void Renderer::RecordComputeCommandBuffer() {
     vkCmdBindDescriptorSets(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 1, 1, &timeDescriptorSet, 0, nullptr);
 
     // TODO: For each group of blades bind its descriptor set and dispatch
+    for (uint32_t i = 0; i < scene->GetBlades().size(); ++i)
+    {
+        vkCmdBindDescriptorSets(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 2, 1, &computeDescriptorSets[i], 0, nullptr);
+        vkCmdDispatch(computeCommandBuffer, NUM_BLADES/32, 1, 1);
+    }
 
     // ~ End recording ~
     if (vkEndCommandBuffer(computeCommandBuffer) != VK_SUCCESS) {
@@ -976,13 +1116,14 @@ void Renderer::RecordCommandBuffers() {
             VkBuffer vertexBuffers[] = { scene->GetBlades()[j]->GetCulledBladesBuffer() };
             VkDeviceSize offsets[] = { 0 };
             // TODO: Uncomment this when the buffers are populated
-            // vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, vertexBuffers, offsets);
+            vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, vertexBuffers, offsets);
 
             // TODO: Bind the descriptor set for each grass blades model
+            vkCmdBindDescriptorSets(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, grassPipelineLayout, 1, 1, &grassDescriptorSets[j], 0, nullptr);
 
             // Draw
             // TODO: Uncomment this when the buffers are populated
-            // vkCmdDrawIndirect(commandBuffers[i], scene->GetBlades()[j]->GetNumBladesBuffer(), 0, 1, sizeof(BladeDrawIndirect));
+            vkCmdDrawIndirect(commandBuffers[i], scene->GetBlades()[j]->GetNumBladesBuffer(), 0, 1, sizeof(BladeDrawIndirect));
         }
 
         // End render pass
@@ -1036,6 +1177,11 @@ void Renderer::Frame() {
     if (!swapChain->Present()) {
         RecreateFrameResources();
     }
+    framecount++;
+    if(framecount%1000==0){
+        printf("FPS: %f \n", 1.0f/scene->getDeltatime());
+    }
+
 }
 
 Renderer::~Renderer() {
@@ -1057,6 +1203,7 @@ Renderer::~Renderer() {
     vkDestroyDescriptorSetLayout(logicalDevice, cameraDescriptorSetLayout, nullptr);
     vkDestroyDescriptorSetLayout(logicalDevice, modelDescriptorSetLayout, nullptr);
     vkDestroyDescriptorSetLayout(logicalDevice, timeDescriptorSetLayout, nullptr);
+    vkDestroyDescriptorSetLayout(logicalDevice, computeDescriptorSetLayout, nullptr);
 
     vkDestroyDescriptorPool(logicalDevice, descriptorPool, nullptr);
 

src/Renderer.h

@@ -47,6 +47,7 @@ class Renderer {
     SwapChain* swapChain;
     Scene* scene;
     Camera* camera;
+    long int framecount;
 
     VkCommandPool graphicsCommandPool;
     VkCommandPool computeCommandPool;
@@ -55,12 +56,15 @@ class Renderer {
 
     VkDescriptorSetLayout cameraDescriptorSetLayout;
     VkDescriptorSetLayout modelDescriptorSetLayout;
+    VkDescriptorSetLayout computeDescriptorSetLayout;
     VkDescriptorSetLayout timeDescriptorSetLayout;
 
     VkDescriptorPool descriptorPool;
 
     VkDescriptorSet cameraDescriptorSet;
     std::vector<VkDescriptorSet> modelDescriptorSets;
+    std::vector<VkDescriptorSet> grassDescriptorSets;
+    std::vector<VkDescriptorSet> computeDescriptorSets;
     VkDescriptorSet timeDescriptorSet;
 
     VkPipelineLayout graphicsPipelineLayout;

src/Scene.h

@@ -33,6 +33,9 @@ high_resolution_clock::time_point startTime = high_resolution_clock::now();
     Scene(Device* device);
     ~Scene();
 
+    float gettime(){return time.totalTime;};
+    float getDeltatime(){return time.deltaTime;};
+
     const std::vector<Model*>& GetModels() const;
     const std::vector<Blades*>& GetBlades() const;