Project 6: Wenli Zhao

src/Renderer.cpp

@@ -198,6 +198,40 @@ 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 inputBladesBinding = {};
+	inputBladesBinding.binding = 0;
+	inputBladesBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	inputBladesBinding.descriptorCount = 1;
+	inputBladesBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+	inputBladesBinding.pImmutableSamplers = nullptr;
+
+	VkDescriptorSetLayoutBinding culledBladesBinding = {};
+	culledBladesBinding.binding = 1;
+	culledBladesBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	culledBladesBinding.descriptorCount = 1;
+	culledBladesBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+	culledBladesBinding.pImmutableSamplers = nullptr;
+
+	VkDescriptorSetLayoutBinding numBladesBinding = {};
+	numBladesBinding.binding = 2;
+	numBladesBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	numBladesBinding.descriptorCount = 1;
+	numBladesBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+	numBladesBinding.pImmutableSamplers = nullptr;
+
+	std::vector<VkDescriptorSetLayoutBinding> bindings = { inputBladesBinding, culledBladesBinding, numBladesBinding };
+
+	// 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 +250,9 @@ void Renderer::CreateDescriptorPool() {
         { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 1 },
 
         // TODO: Add any additional types and counts of descriptors you will need to allocate
+
+		// Compute
+		{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, static_cast<uint32_t>(3 * scene->GetBlades().size()) },
     };
 
     VkDescriptorPoolCreateInfo poolInfo = {};
@@ -320,6 +357,44 @@ 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() {
@@ -358,8 +433,75 @@ void Renderer::CreateTimeDescriptorSet() {
 }
 
 void Renderer::CreateComputeDescriptorSets() {
+
+	computeDescriptorSets.resize(scene->GetBlades().size());
     // 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 
+
+	// 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 computeBufferInfo = {};
+		computeBufferInfo.buffer = scene->GetBlades()[i]->GetBladesBuffer();
+		computeBufferInfo.offset = 0;
+		computeBufferInfo.range = sizeof(Blade) * NUM_BLADES;
+
+		VkDescriptorBufferInfo computeCulledBladesInfo = {};
+		computeCulledBladesInfo.buffer = scene->GetBlades()[i]->GetCulledBladesBuffer();
+		computeCulledBladesInfo.offset = 0;
+		computeCulledBladesInfo.range = sizeof(Blade) * NUM_BLADES;
+
+		VkDescriptorBufferInfo computeNumBladesInfo = {};
+		computeNumBladesInfo.buffer = scene->GetBlades()[i]->GetNumBladesBuffer();
+		computeNumBladesInfo.offset = 0;
+		computeNumBladesInfo.range = sizeof(BladeDrawIndirect);
+
+		descriptorWrites[3 * i + 0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		descriptorWrites[3 * i + 0].dstSet = computeDescriptorSets[0];
+		descriptorWrites[3 * i + 0].dstBinding = 0;
+		descriptorWrites[3 * i + 0].dstArrayElement = 0;
+		descriptorWrites[3 * i + 0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+		descriptorWrites[3 * i + 0].descriptorCount = 1;
+		descriptorWrites[3 * i + 0].pBufferInfo = &computeBufferInfo;
+		descriptorWrites[3 * i + 0].pImageInfo = nullptr;
+		descriptorWrites[3 * i + 0].pTexelBufferView = nullptr;
+
+		descriptorWrites[3 * i + 1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		descriptorWrites[3 * i + 1].dstSet = computeDescriptorSets[0];
+		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 = &computeCulledBladesInfo;
+		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[0];
+		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 = &computeNumBladesInfo;
+		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() {
@@ -716,8 +858,8 @@ void Renderer::CreateComputePipeline() {
     computeShaderStageInfo.module = computeShaderModule;
     computeShaderStageInfo.pName = "main";
 
-    // TODO: Add the compute dsecriptor set layout you create to this list
-    std::vector<VkDescriptorSetLayout> descriptorSetLayouts = { cameraDescriptorSetLayout, timeDescriptorSetLayout };
+    // TODO: Add the compute descriptor set layout you create to this list
+    std::vector<VkDescriptorSetLayout> descriptorSetLayouts = { cameraDescriptorSetLayout, timeDescriptorSetLayout, computeDescriptorSetLayout };
 
     // Create pipeline layout
     VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
@@ -884,6 +1026,12 @@ 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
+	// vkCmdDispatch(...)
+
+		// Bind descriptor set for compute
+		vkCmdBindDescriptorSets(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 2, 1, &computeDescriptorSets[0], 0, nullptr);
+		vkCmdDispatch(computeCommandBuffer, ceil((NUM_BLADES + WORKGROUP_SIZE - 1) / (WORKGROUP_SIZE)), 1, 1);
+
 
     // ~ End recording ~
     if (vkEndCommandBuffer(computeCommandBuffer) != VK_SUCCESS) {
@@ -976,13 +1124,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_COMPUTE, graphicsPipelineLayout, 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
@@ -1057,6 +1206,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

@@ -56,12 +56,15 @@ class Renderer {
     VkDescriptorSetLayout cameraDescriptorSetLayout;
     VkDescriptorSetLayout modelDescriptorSetLayout;
     VkDescriptorSetLayout timeDescriptorSetLayout;
+	VkDescriptorSetLayout computeDescriptorSetLayout;
 
     VkDescriptorPool descriptorPool;
 
     VkDescriptorSet cameraDescriptorSet;
     std::vector<VkDescriptorSet> modelDescriptorSets;
     VkDescriptorSet timeDescriptorSet;
+	std::vector<VkDescriptorSet> computeDescriptorSets;
+	std::vector<VkDescriptorSet> grassDescriptorSets;
 
     VkPipelineLayout graphicsPipelineLayout;
     VkPipelineLayout grassPipelineLayout;

src/shaders/compute.comp

@@ -2,6 +2,7 @@
 #extension GL_ARB_separate_shader_objects : enable
 
 #define WORKGROUP_SIZE 32
+
 layout(local_size_x = WORKGROUP_SIZE, local_size_y = 1, local_size_z = 1) in;
 
 layout(set = 0, binding = 0) uniform CameraBufferObject {
@@ -29,28 +30,141 @@ struct Blade {
 // The project is using vkCmdDrawIndirect to use a buffer as the arguments for a draw call
 // This is sort of an advanced feature so we've showed you what this buffer should look like
 //
-// layout(set = ???, binding = ???) buffer NumBlades {
-// 	  uint vertexCount;   // Write the number of blades remaining here
-// 	  uint instanceCount; // = 1
-// 	  uint firstVertex;   // = 0
-// 	  uint firstInstance; // = 0
-// } numBlades;
+
+layout(set = 2, binding = 0) buffer InputBlades {
+	Blade inputBlades[];
+};
+
+layout(set = 2, binding = 1) buffer CulledBlades {
+	Blade culledBlades[];
+};
+
+layout(set = 2, binding = 2) buffer NumBlades {
+	uint vertexCount;   // Write the number of blades remaining here
+	uint instanceCount; // = 1
+	uint firstVertex;   // = 0
+	uint firstInstance; // = 0
+} numBlades;
+
 
 bool inBounds(float value, float bounds) {
     return (value >= -bounds) && (value <= bounds);
 }
 
 void main() {
+	uint index = gl_GlobalInvocationID.x;
+
 	// Reset the number of blades to 0
 	if (gl_GlobalInvocationID.x == 0) {
-		// numBlades.vertexCount = 0;
+		numBlades.vertexCount = 0;
 	}
 	barrier(); // Wait till all threads reach this point
 
+
+
     // TODO: Apply forces on every blade and update the vertices in the buffer
+	Blade blade = inputBlades[index];
+
+	vec3 v0 = vec3(blade.v0);
+	vec3 v1 = vec3(blade.v1);
+	vec3 v2 = vec3(blade.v2);
+	vec3 up = vec3(blade.up);
+	float orientation = blade.v0.w;
+	float h = blade.v1.w;
+	float w = blade.v2.w;
+	float stiffness = blade.up.w;
+
+	// Forward vector
+	vec3 f = normalize(cross(up, vec3(sin(orientation), 0.0, cos(orientation))));
+
+	// Along the width vector
+	float dir= orientation - 1.57079632679;
+	vec3 atw = normalize(cross(up, vec3(sin(dir), 0.0, cos(dir))));
+
+	// Gravity
+	float acc = -9.8;
+	vec3 gravity = vec3(0.0, 1, 0.0);
+	vec3 gE = normalize(gravity) * acc;
+	vec3 gF = 0.25 * length(gE) * f;
+	vec3 g = gE + gF;
+
+	// Recovery
+	vec3 iv2 = h * up + v0;
+	vec3 recovery =  (iv2 - v2) * 1.3 * stiffness;
+
+	// Wind
+	vec3 wi = vec3(1, 0, 0);
+	float strength = cos(totalTime) * 0.5;
+	wi = wi * strength;
+	float fd = 1 -  dot ( wi * v0 / length(wi * v0) , (v2 - v0) / length(v2 - v0) ) ;
+	float fr = dot ((v2 - v0) , up) / h;	
+	vec3 wind = wi * v0 * fd * fr; 
+
+
+	// State Validation
+	vec3 tv2 = (g + recovery + wind) * deltaTime;
+	v2 = v2 + tv2;
+	v2 = v2 - up * min(dot(up, v2 - v0), 0);
+
+	float lproj = length( v2 - v0 - up * dot( v2 - v1, up) );
+	v1 = v0 + h * up * max( 1 - (lproj/h), 0.05 * max( lproj / h, 1) );
+
+
+	float n = 3; // degree of bezier
+	float L0 = distance(v0, v1);
+	float L1 = distance(v0, v1) + distance(v0, v2);
+	float L = (2 * L0 + (n-1) * L1) / (n + 1);
+	float r = h / L;
+	v1 = v0 + r * (v1 - v0);
+	v2 = v1 + r * (v2 - v1);
+
+	blade.v2 = vec4(v2, w);
+
+	inputBlades[index] = blade;
+
+
 
 	// TODO: Cull blades that are too far away or not in the camera frustum and write them
 	// to the culled blades buffer
 	// Note: to do this, you will need to use an atomic operation to read and update numBlades.vertexCount
 	// You want to write the visible blades to the buffer without write conflicts between threads
+	bool culled = false;
+
+	// Orientation Culling
+	mat4 inverseView = inverse(camera.view);
+	vec4 dirc = inverseView * vec4(0.0,0.0,1.0,0.0);
+	float oCull = abs(dot(dirc.xyz, atw.xyz));
+	if (oCull < 0.85) {
+		culled = true;
+	}
+
+	// View Frustrum Culling
+	vec3 m = .25 * v0.xyz + .5 * v1.xyz + .25 * v2.xyz;
+	vec4 v0NDC = (camera.proj * camera.view * vec4(v0, 1.0));
+	vec4 mNDC = (camera.proj * camera.view * vec4(m, 1.0) );
+	vec4 v2NDC = (camera.proj * camera.view * vec4(v2, 1.0));
+	v0NDC/= v0NDC.w;
+	mNDC/= mNDC.w;
+	v2NDC/= v2NDC.w;
+
+	if (!inBounds(v0NDC.x, 1) && !inBounds(v0NDC.y, 1) && !inBounds(v0NDC.z, 1) &&
+	 !inBounds(v2NDC.x, 1) && !inBounds(v2NDC.y, 1) && !inBounds(v2NDC.z, 1) &&
+	 !inBounds(mNDC.x, 1) && !inBounds(mNDC.y, 1) && !inBounds(mNDC.z, 1) ) {
+		culled = true;
+	}
+
+	// Distance test
+	float distance = 20;
+	float bucket = 5;
+	float dist = - (camera.view * vec4(v0, 1.0)).z;
+
+	if (dist > distance) {
+		culled = true;
+	}
+
+
+	if (!culled) {
+		culledBlades[atomicAdd(numBlades.vertexCount, 1)] = inputBlades[index];
+	}
+
 }