diff --git a/README.md b/README.md
index 20ee451..5b3a291 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,75 @@
+https://github.com/user-attachments/assets/830acb53-29e5-4a4c-8e53-ab2417369332
+
+
Vulkan Grass Rendering
==================================
**University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 5**
+* Eli Asimow
+* [LinkedIn](https://www.linkedin.com/in/eli-asimow/), [personal website](https://easimow.com)
+* Tested on: Windows 11, AMD Ryzen 7 7435HS @ 2.08GHz 16GB, Nvidia GeForce RTX 4060 GPU
+
+## Overview
+
+Hello! Welcome to my Vulkan tesselated grass implementation. This application can easily render a million grass blades in a real time context, with each blade tesslating for further vertex detail. To acheive this result, I implemented several culling filters in a compute shader, which minimize the stress on the fragment stage.
+
+## Process
+
+### Initial Blades
+
+
+
+The first stage of the implementation was getting anything to show up at all! We render a simple plane, and then instance grass blades, scattered randomly across it. They are each a simple triangle of vertices. There was no use for compute or tescelation shaders at this stage, but I built them into the pipeline as empty shader steps in anticipation of the work to come.
+
+### Tesselation
+
+
+
+For the next step, we add a division of our simple triangle mesh through our tesselation shaders. In our tesc shader, we set a level of 10, which divides our blade into ten individual tesselated levels for the tese shader, where we determine these levels placement using a bezier curve with three degrees.
+
+### Compute Shader Forces
+
+Next, we add the physical forces that will animate our grass. The first is gravity -- although it's not too interesting on its own, as it just pushes the grass into the plane!
+
+
+
+We need to add a recovery force, which will pull our grass towards its initial position. Here's how the field looks after that:
+
+
+
+Lastly, we should add a wind effect, so our blades flow back and forth. I used simplex noise for my wind, sourced from Ashima Arts / Stefan Gustavson. We choose an arbitrary wind direction in the xz plane, and push our blades in that direction to a degree corresponding to the blade's default direction and a noise value sampled over time. Finally, we have a windy grass field!
+
+
+
+## Performance
+
+### Culling Methods
+
+
+
+
+We add three culls for performance. The first is a distance cull, such that no blade over a certain threshold should be drawn. The second is a frustrum cull, such that no blade outside the camera view should be drawn. The final is an orientation cull, such that no blade facing away from the camera should have its back side rendered.
+
+
+### Results
+
+For performance testing, we worked with a large plane of size 105.f, with a default blade count of 1 << 23 unless otherwise specified.
+
+First, let's look at the cumulative strain of blade count.
+
+
+
+Now, this is mostly as expected. When accounting for the logorithmic x scale, this is a largely linear relationship between number of drawn blades and the application performance. It's worth noting though that the number here is not actually the number of drawn blades to screen! Indeed, I made all these measurements with the three culling methods active. That means that the vast majority of blades were not being drawn. However, as the relationship between cull amount and blade amount is strictly linear, I felt no need to distinguish the two in my measurements here.
+
+
+
+Next up is the comparison of our different culling methods. I made these with my scene size set to 105.f, and with 1 << 23 blades. The most apparent result is that the sum total of the performance gains when combining all three culling methods seems to be greater than each on their own. That's surprising to me, especially when considering the linear relationship between blades drawn and performance, as seen in the prior graph. My best theory is that, together, they push the 1 << 23 scene past some thread threshold on my GPU. I'd like to repeat this test on another laptop when possible to compare and contrast! Other than that, the results are mostly straightforward. The top performer is my orientation culling, which makes sense. Because I have it set to only draw blades underneath a .2 threshold, the majority of blades should be eliminated here. I'd still think that this should be a better improvement with that magnitude of that cull considered, but at least it does come in first. Distance performed worse than I expected, especially considering the large scene. But in further tests with a reduced max distance from its default 100 meters, we can see it starting to show its value:
+
+
+
+These values were surveyed with only distance culling active. Lower max distance have an exponential performance boost! This makes sense; increasing the radius of our distance circle around the camera adds increasingly more blades to the circle of rendering. But while these performance increases are notable, so too is their cost: At low values, distance culling becomes the most visibly jarring of our three culling methods. So, in future applications of these methods, I'll have to be cogniziant of the artifacts distance cullings requires in order to be greatly effective.
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
-### (TODO: Your README)
+## Closing Thoughts
-*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.
+I really enjoyed this lab! I hope to use the grass I've made here as a basis for the environment of my next project: procedural voxel based clouds!
diff --git a/src/Blades.h b/src/Blades.h
index 9bd1eed..3f081bd 100644
--- a/src/Blades.h
+++ b/src/Blades.h
@@ -4,7 +4,7 @@
#include
#include "Model.h"
-constexpr static unsigned int NUM_BLADES = 1 << 13;
+constexpr static unsigned int NUM_BLADES = 1 << 23;
constexpr static float MIN_HEIGHT = 1.3f;
constexpr static float MAX_HEIGHT = 2.5f;
constexpr static float MIN_WIDTH = 0.1f;
@@ -13,76 +13,76 @@ constexpr static float MIN_BEND = 7.0f;
constexpr static float MAX_BEND = 13.0f;
struct Blade {
- // Position and direction
- glm::vec4 v0;
- // Bezier point and height
- glm::vec4 v1;
- // Physical model guide and width
- glm::vec4 v2;
- // Up vector and stiffness coefficient
- glm::vec4 up;
+ // Position and direction
+ glm::vec4 v0;
+ // Bezier point and height
+ glm::vec4 v1;
+ // Physical model guide and width
+ glm::vec4 v2;
+ // Up vector and stiffness coefficient
+ glm::vec4 up;
- static VkVertexInputBindingDescription getBindingDescription() {
- VkVertexInputBindingDescription bindingDescription = {};
- bindingDescription.binding = 0;
- bindingDescription.stride = sizeof(Blade);
- bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+ static VkVertexInputBindingDescription getBindingDescription() {
+ VkVertexInputBindingDescription bindingDescription = {};
+ bindingDescription.binding = 0;
+ bindingDescription.stride = sizeof(Blade);
+ bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
- return bindingDescription;
- }
+ return bindingDescription;
+ }
- static std::array getAttributeDescriptions() {
- std::array attributeDescriptions = {};
+ static std::array getAttributeDescriptions() {
+ std::array attributeDescriptions = {};
- // v0
- attributeDescriptions[0].binding = 0;
- attributeDescriptions[0].location = 0;
- attributeDescriptions[0].format = VK_FORMAT_R32G32B32A32_SFLOAT;
- attributeDescriptions[0].offset = offsetof(Blade, v0);
+ // v0
+ attributeDescriptions[0].binding = 0;
+ attributeDescriptions[0].location = 0;
+ attributeDescriptions[0].format = VK_FORMAT_R32G32B32A32_SFLOAT;
+ attributeDescriptions[0].offset = offsetof(Blade, v0);
- // v1
- attributeDescriptions[1].binding = 0;
- attributeDescriptions[1].location = 1;
- attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
- attributeDescriptions[1].offset = offsetof(Blade, v1);
+ // v1
+ attributeDescriptions[1].binding = 0;
+ attributeDescriptions[1].location = 1;
+ attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
+ attributeDescriptions[1].offset = offsetof(Blade, v1);
- // v2
- attributeDescriptions[2].binding = 0;
- attributeDescriptions[2].location = 2;
- attributeDescriptions[2].format = VK_FORMAT_R32G32B32A32_SFLOAT;
- attributeDescriptions[2].offset = offsetof(Blade, v2);
+ // v2
+ attributeDescriptions[2].binding = 0;
+ attributeDescriptions[2].location = 2;
+ attributeDescriptions[2].format = VK_FORMAT_R32G32B32A32_SFLOAT;
+ attributeDescriptions[2].offset = offsetof(Blade, v2);
- // up
- attributeDescriptions[3].binding = 0;
- attributeDescriptions[3].location = 3;
- attributeDescriptions[3].format = VK_FORMAT_R32G32B32A32_SFLOAT;
- attributeDescriptions[3].offset = offsetof(Blade, up);
+ // up
+ attributeDescriptions[3].binding = 0;
+ attributeDescriptions[3].location = 3;
+ attributeDescriptions[3].format = VK_FORMAT_R32G32B32A32_SFLOAT;
+ attributeDescriptions[3].offset = offsetof(Blade, up);
- return attributeDescriptions;
- }
+ return attributeDescriptions;
+ }
};
struct BladeDrawIndirect {
- uint32_t vertexCount;
- uint32_t instanceCount;
- uint32_t firstVertex;
- uint32_t firstInstance;
+ uint32_t vertexCount;
+ uint32_t instanceCount;
+ uint32_t firstVertex;
+ uint32_t firstInstance;
};
class Blades : public Model {
private:
- VkBuffer bladesBuffer;
- VkBuffer culledBladesBuffer;
- VkBuffer numBladesBuffer;
+ VkBuffer bladesBuffer;
+ VkBuffer culledBladesBuffer;
+ VkBuffer numBladesBuffer;
- VkDeviceMemory bladesBufferMemory;
- VkDeviceMemory culledBladesBufferMemory;
- VkDeviceMemory numBladesBufferMemory;
+ VkDeviceMemory bladesBufferMemory;
+ VkDeviceMemory culledBladesBufferMemory;
+ VkDeviceMemory numBladesBufferMemory;
public:
- Blades(Device* device, VkCommandPool commandPool, float planeDim);
- VkBuffer GetBladesBuffer() const;
- VkBuffer GetCulledBladesBuffer() const;
- VkBuffer GetNumBladesBuffer() const;
- ~Blades();
+ Blades(Device* device, VkCommandPool commandPool, float planeDim);
+ VkBuffer GetBladesBuffer() const;
+ VkBuffer GetCulledBladesBuffer() const;
+ VkBuffer GetNumBladesBuffer() const;
+ ~Blades();
};
diff --git a/src/Camera.cpp b/src/Camera.cpp
index 3afb5b8..e6dc4ba 100644
--- a/src/Camera.cpp
+++ b/src/Camera.cpp
@@ -9,40 +9,42 @@
#include "BufferUtils.h"
Camera::Camera(Device* device, float aspectRatio) : device(device) {
- r = 10.0f;
- theta = 0.0f;
- phi = 0.0f;
- cameraBufferObject.viewMatrix = glm::lookAt(glm::vec3(0.0f, 1.0f, 10.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
- cameraBufferObject.projectionMatrix = glm::perspective(glm::radians(45.0f), aspectRatio, 0.1f, 100.0f);
- cameraBufferObject.projectionMatrix[1][1] *= -1; // y-coordinate is flipped
-
- BufferUtils::CreateBuffer(device, sizeof(CameraBufferObject), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, buffer, bufferMemory);
- vkMapMemory(device->GetVkDevice(), bufferMemory, 0, sizeof(CameraBufferObject), 0, &mappedData);
- memcpy(mappedData, &cameraBufferObject, sizeof(CameraBufferObject));
+ r = 10.0f;
+ theta = 0.0f;
+ phi = 0.0f;
+ cameraBufferObject.viewMatrix = glm::lookAt(glm::vec3(0.0f, 1.0f, 10.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+ cameraBufferObject.projectionMatrix = glm::perspective(glm::radians(45.0f), aspectRatio, 0.1f, 100.0f);
+ cameraBufferObject.projectionMatrix[1][1] *= -1; // y-coordinate is flipped
+ cameraBufferObject.position = glm::vec4(0.0f, 1.0f, 10.0f, 1.0f);
+
+ BufferUtils::CreateBuffer(device, sizeof(CameraBufferObject), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, buffer, bufferMemory);
+ vkMapMemory(device->GetVkDevice(), bufferMemory, 0, sizeof(CameraBufferObject), 0, &mappedData);
+ memcpy(mappedData, &cameraBufferObject, sizeof(CameraBufferObject));
}
VkBuffer Camera::GetBuffer() const {
- return buffer;
+ return buffer;
}
void Camera::UpdateOrbit(float deltaX, float deltaY, float deltaZ) {
- theta += deltaX;
- phi += deltaY;
- r = glm::clamp(r - deltaZ, 1.0f, 50.0f);
+ theta += deltaX;
+ phi += deltaY;
+ r = glm::clamp(r - deltaZ, 1.0f, 50.0f);
- float radTheta = glm::radians(theta);
- float radPhi = glm::radians(phi);
+ float radTheta = glm::radians(theta);
+ float radPhi = glm::radians(phi);
- glm::mat4 rotation = glm::rotate(glm::mat4(1.0f), radTheta, glm::vec3(0.0f, 1.0f, 0.0f)) * glm::rotate(glm::mat4(1.0f), radPhi, glm::vec3(1.0f, 0.0f, 0.0f));
- glm::mat4 finalTransform = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f)) * rotation * glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 1.0f, r));
+ glm::mat4 rotation = glm::rotate(glm::mat4(1.0f), radTheta, glm::vec3(0.0f, 1.0f, 0.0f)) * glm::rotate(glm::mat4(1.0f), radPhi, glm::vec3(1.0f, 0.0f, 0.0f));
+ glm::mat4 finalTransform = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f)) * rotation * glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 1.0f, r));
- cameraBufferObject.viewMatrix = glm::inverse(finalTransform);
+ cameraBufferObject.viewMatrix = glm::inverse(finalTransform);
+ cameraBufferObject.position = finalTransform[3];
- memcpy(mappedData, &cameraBufferObject, sizeof(CameraBufferObject));
+ memcpy(mappedData, &cameraBufferObject, sizeof(CameraBufferObject));
}
Camera::~Camera() {
- vkUnmapMemory(device->GetVkDevice(), bufferMemory);
- vkDestroyBuffer(device->GetVkDevice(), buffer, nullptr);
- vkFreeMemory(device->GetVkDevice(), bufferMemory, nullptr);
+ vkUnmapMemory(device->GetVkDevice(), bufferMemory);
+ vkDestroyBuffer(device->GetVkDevice(), buffer, nullptr);
+ vkFreeMemory(device->GetVkDevice(), bufferMemory, nullptr);
}
diff --git a/src/Camera.h b/src/Camera.h
index 6b10747..26ae46c 100644
--- a/src/Camera.h
+++ b/src/Camera.h
@@ -5,28 +5,29 @@
#include "Device.h"
struct CameraBufferObject {
- glm::mat4 viewMatrix;
- glm::mat4 projectionMatrix;
+ glm::mat4 viewMatrix;
+ glm::mat4 projectionMatrix;
+ glm::vec4 position;
};
class Camera {
private:
- Device* device;
-
- CameraBufferObject cameraBufferObject;
-
- VkBuffer buffer;
- VkDeviceMemory bufferMemory;
+ Device* device;
- void* mappedData;
+ CameraBufferObject cameraBufferObject;
- float r, theta, phi;
+ VkBuffer buffer;
+ VkDeviceMemory bufferMemory;
+
+ void* mappedData;
+
+ float r, theta, phi;
public:
- Camera(Device* device, float aspectRatio);
- ~Camera();
+ Camera(Device* device, float aspectRatio);
+ ~Camera();
+
+ VkBuffer GetBuffer() const;
- VkBuffer GetBuffer() const;
-
- void UpdateOrbit(float deltaX, float deltaY, float deltaZ);
+ void UpdateOrbit(float deltaX, float deltaY, float deltaZ);
};
diff --git a/src/Renderer.cpp b/src/Renderer.cpp
index b445d04..9fb1364 100644
--- a/src/Renderer.cpp
+++ b/src/Renderer.cpp
@@ -9,1059 +9,1209 @@
static constexpr unsigned int WORKGROUP_SIZE = 32;
Renderer::Renderer(Device* device, SwapChain* swapChain, Scene* scene, Camera* camera)
- : device(device),
- logicalDevice(device->GetVkDevice()),
- swapChain(swapChain),
- scene(scene),
- camera(camera) {
-
- CreateCommandPools();
- CreateRenderPass();
- CreateCameraDescriptorSetLayout();
- CreateModelDescriptorSetLayout();
- CreateTimeDescriptorSetLayout();
- CreateComputeDescriptorSetLayout();
- CreateDescriptorPool();
- CreateCameraDescriptorSet();
- CreateModelDescriptorSets();
- CreateGrassDescriptorSets();
- CreateTimeDescriptorSet();
- CreateComputeDescriptorSets();
- CreateFrameResources();
- CreateGraphicsPipeline();
- CreateGrassPipeline();
- CreateComputePipeline();
- RecordCommandBuffers();
- RecordComputeCommandBuffer();
+ : device(device),
+ logicalDevice(device->GetVkDevice()),
+ swapChain(swapChain),
+ scene(scene),
+ camera(camera) {
+
+ CreateCommandPools();
+ CreateRenderPass();
+ CreateCameraDescriptorSetLayout();
+ CreateModelDescriptorSetLayout();
+ CreateTimeDescriptorSetLayout();
+ CreateComputeDescriptorSetLayout();
+ CreateDescriptorPool();
+ CreateCameraDescriptorSet();
+ CreateModelDescriptorSets();
+ CreateGrassDescriptorSets();
+ CreateTimeDescriptorSet();
+ CreateComputeDescriptorSets();
+ CreateFrameResources();
+ CreateGraphicsPipeline();
+ CreateGrassPipeline();
+ CreateComputePipeline();
+ RecordCommandBuffers();
+ RecordComputeCommandBuffer();
}
void Renderer::CreateCommandPools() {
- VkCommandPoolCreateInfo graphicsPoolInfo = {};
- graphicsPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
- graphicsPoolInfo.queueFamilyIndex = device->GetInstance()->GetQueueFamilyIndices()[QueueFlags::Graphics];
- graphicsPoolInfo.flags = 0;
-
- if (vkCreateCommandPool(logicalDevice, &graphicsPoolInfo, nullptr, &graphicsCommandPool) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create command pool");
- }
-
- VkCommandPoolCreateInfo computePoolInfo = {};
- computePoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
- computePoolInfo.queueFamilyIndex = device->GetInstance()->GetQueueFamilyIndices()[QueueFlags::Compute];
- computePoolInfo.flags = 0;
-
- if (vkCreateCommandPool(logicalDevice, &computePoolInfo, nullptr, &computeCommandPool) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create command pool");
- }
+ VkCommandPoolCreateInfo graphicsPoolInfo = {};
+ graphicsPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+ graphicsPoolInfo.queueFamilyIndex = device->GetInstance()->GetQueueFamilyIndices()[QueueFlags::Graphics];
+ graphicsPoolInfo.flags = 0;
+
+ if (vkCreateCommandPool(logicalDevice, &graphicsPoolInfo, nullptr, &graphicsCommandPool) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create command pool");
+ }
+
+ VkCommandPoolCreateInfo computePoolInfo = {};
+ computePoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+ computePoolInfo.queueFamilyIndex = device->GetInstance()->GetQueueFamilyIndices()[QueueFlags::Compute];
+ computePoolInfo.flags = 0;
+
+ if (vkCreateCommandPool(logicalDevice, &computePoolInfo, nullptr, &computeCommandPool) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create command pool");
+ }
}
void Renderer::CreateRenderPass() {
- // Color buffer attachment represented by one of the images from the swap chain
- VkAttachmentDescription colorAttachment = {};
- colorAttachment.format = swapChain->GetVkImageFormat();
- colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
- 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;
-
- // Create a color attachment reference to be used with subpass
- VkAttachmentReference colorAttachmentRef = {};
- colorAttachmentRef.attachment = 0;
- colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
- // Depth buffer attachment
- VkFormat depthFormat = device->GetInstance()->GetSupportedFormat({ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT }, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
- VkAttachmentDescription depthAttachment = {};
- depthAttachment.format = depthFormat;
- depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
- depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
- depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
- depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-
- // Create a depth attachment reference
- VkAttachmentReference depthAttachmentRef = {};
- depthAttachmentRef.attachment = 1;
- depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-
- // Create subpass description
- VkSubpassDescription subpass = {};
- subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- subpass.colorAttachmentCount = 1;
- subpass.pColorAttachments = &colorAttachmentRef;
- subpass.pDepthStencilAttachment = &depthAttachmentRef;
-
- std::array attachments = { colorAttachment, depthAttachment };
-
- // Specify subpass dependency
- VkSubpassDependency dependency = {};
- dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
- dependency.dstSubpass = 0;
- dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
- dependency.srcAccessMask = 0;
- dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
- dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-
- // Create render pass
- VkRenderPassCreateInfo renderPassInfo = {};
- renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
- renderPassInfo.attachmentCount = static_cast(attachments.size());
- renderPassInfo.pAttachments = attachments.data();
- renderPassInfo.subpassCount = 1;
- renderPassInfo.pSubpasses = &subpass;
- renderPassInfo.dependencyCount = 1;
- renderPassInfo.pDependencies = &dependency;
-
- if (vkCreateRenderPass(logicalDevice, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create render pass");
- }
+ // Color buffer attachment represented by one of the images from the swap chain
+ VkAttachmentDescription colorAttachment = {};
+ colorAttachment.format = swapChain->GetVkImageFormat();
+ colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
+ 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;
+
+ // Create a color attachment reference to be used with subpass
+ VkAttachmentReference colorAttachmentRef = {};
+ colorAttachmentRef.attachment = 0;
+ colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+ // Depth buffer attachment
+ VkFormat depthFormat = device->GetInstance()->GetSupportedFormat({ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT }, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
+ VkAttachmentDescription depthAttachment = {};
+ depthAttachment.format = depthFormat;
+ depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
+ depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+ depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+ depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+ // Create a depth attachment reference
+ VkAttachmentReference depthAttachmentRef = {};
+ depthAttachmentRef.attachment = 1;
+ depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+ // Create subpass description
+ VkSubpassDescription subpass = {};
+ subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+ subpass.colorAttachmentCount = 1;
+ subpass.pColorAttachments = &colorAttachmentRef;
+ subpass.pDepthStencilAttachment = &depthAttachmentRef;
+
+ std::array attachments = { colorAttachment, depthAttachment };
+
+ // Specify subpass dependency
+ VkSubpassDependency dependency = {};
+ dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
+ dependency.dstSubpass = 0;
+ dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+ dependency.srcAccessMask = 0;
+ dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+ dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+
+ // Create render pass
+ VkRenderPassCreateInfo renderPassInfo = {};
+ renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+ renderPassInfo.attachmentCount = static_cast(attachments.size());
+ renderPassInfo.pAttachments = attachments.data();
+ renderPassInfo.subpassCount = 1;
+ renderPassInfo.pSubpasses = &subpass;
+ renderPassInfo.dependencyCount = 1;
+ renderPassInfo.pDependencies = &dependency;
+
+ if (vkCreateRenderPass(logicalDevice, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create render pass");
+ }
}
void Renderer::CreateCameraDescriptorSetLayout() {
- // Describe the binding of the descriptor set layout
- VkDescriptorSetLayoutBinding uboLayoutBinding = {};
- uboLayoutBinding.binding = 0;
- uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- uboLayoutBinding.descriptorCount = 1;
- uboLayoutBinding.stageFlags = VK_SHADER_STAGE_ALL;
- uboLayoutBinding.pImmutableSamplers = nullptr;
-
- std::vector bindings = { uboLayoutBinding };
-
- // Create the descriptor set layout
- VkDescriptorSetLayoutCreateInfo layoutInfo = {};
- layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
- layoutInfo.bindingCount = static_cast(bindings.size());
- layoutInfo.pBindings = bindings.data();
-
- if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &cameraDescriptorSetLayout) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create descriptor set layout");
- }
+ // Describe the binding of the descriptor set layout
+ VkDescriptorSetLayoutBinding uboLayoutBinding = {};
+ uboLayoutBinding.binding = 0;
+ uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ uboLayoutBinding.descriptorCount = 1;
+ uboLayoutBinding.stageFlags = VK_SHADER_STAGE_ALL;
+ uboLayoutBinding.pImmutableSamplers = nullptr;
+
+ std::vector bindings = { uboLayoutBinding };
+
+ // Create the descriptor set layout
+ VkDescriptorSetLayoutCreateInfo layoutInfo = {};
+ layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ layoutInfo.bindingCount = static_cast(bindings.size());
+ layoutInfo.pBindings = bindings.data();
+
+ if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &cameraDescriptorSetLayout) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create descriptor set layout");
+ }
}
void Renderer::CreateModelDescriptorSetLayout() {
- VkDescriptorSetLayoutBinding uboLayoutBinding = {};
- uboLayoutBinding.binding = 0;
- uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- uboLayoutBinding.descriptorCount = 1;
- uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
- uboLayoutBinding.pImmutableSamplers = nullptr;
-
- VkDescriptorSetLayoutBinding samplerLayoutBinding = {};
- samplerLayoutBinding.binding = 1;
- samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
- samplerLayoutBinding.descriptorCount = 1;
- samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
- samplerLayoutBinding.pImmutableSamplers = nullptr;
-
- std::vector bindings = { uboLayoutBinding, samplerLayoutBinding };
-
- // Create the descriptor set layout
- VkDescriptorSetLayoutCreateInfo layoutInfo = {};
- layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
- layoutInfo.bindingCount = static_cast(bindings.size());
- layoutInfo.pBindings = bindings.data();
-
- if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &modelDescriptorSetLayout) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create descriptor set layout");
- }
+ VkDescriptorSetLayoutBinding uboLayoutBinding = {};
+ uboLayoutBinding.binding = 0;
+ uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ uboLayoutBinding.descriptorCount = 1;
+ uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+ uboLayoutBinding.pImmutableSamplers = nullptr;
+
+ VkDescriptorSetLayoutBinding samplerLayoutBinding = {};
+ samplerLayoutBinding.binding = 1;
+ samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+ samplerLayoutBinding.descriptorCount = 1;
+ samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+ samplerLayoutBinding.pImmutableSamplers = nullptr;
+
+ std::vector bindings = { uboLayoutBinding, samplerLayoutBinding };
+
+ // Create the descriptor set layout
+ VkDescriptorSetLayoutCreateInfo layoutInfo = {};
+ layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ layoutInfo.bindingCount = static_cast(bindings.size());
+ layoutInfo.pBindings = bindings.data();
+
+ if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &modelDescriptorSetLayout) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create descriptor set layout");
+ }
}
void Renderer::CreateTimeDescriptorSetLayout() {
- // Describe the binding of the descriptor set layout
- VkDescriptorSetLayoutBinding uboLayoutBinding = {};
- uboLayoutBinding.binding = 0;
- uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- uboLayoutBinding.descriptorCount = 1;
- uboLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
- uboLayoutBinding.pImmutableSamplers = nullptr;
-
- std::vector bindings = { uboLayoutBinding };
-
- // Create the descriptor set layout
- VkDescriptorSetLayoutCreateInfo layoutInfo = {};
- layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
- layoutInfo.bindingCount = static_cast(bindings.size());
- layoutInfo.pBindings = bindings.data();
-
- if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &timeDescriptorSetLayout) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create descriptor set layout");
- }
+ // Describe the binding of the descriptor set layout
+ VkDescriptorSetLayoutBinding uboLayoutBinding = {};
+ uboLayoutBinding.binding = 0;
+ uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ uboLayoutBinding.descriptorCount = 1;
+ uboLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+ uboLayoutBinding.pImmutableSamplers = nullptr;
+
+ std::vector bindings = { uboLayoutBinding };
+
+ // Create the descriptor set layout
+ VkDescriptorSetLayoutCreateInfo layoutInfo = {};
+ layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ layoutInfo.bindingCount = static_cast(bindings.size());
+ layoutInfo.pBindings = bindings.data();
+
+ if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &timeDescriptorSetLayout) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create descriptor set layout");
+ }
}
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
+ //in blades:
+ VkDescriptorSetLayoutBinding bladesInBinding = {};
+ bladesInBinding.binding = 0;
+ bladesInBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ bladesInBinding.descriptorCount = 1;
+ bladesInBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+ bladesInBinding.pImmutableSamplers = nullptr;
+
+ //out culled blades:
+ VkDescriptorSetLayoutBinding bladesOutBinding = {};
+ bladesOutBinding.binding = 1;
+ bladesOutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ bladesOutBinding.descriptorCount = 1;
+ bladesOutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+ bladesOutBinding.pImmutableSamplers = nullptr;
+
+
+ //out num blades:
+ VkDescriptorSetLayoutBinding OutNumBladesBinding = {};
+ OutNumBladesBinding.binding = 2;
+ OutNumBladesBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ OutNumBladesBinding.descriptorCount = 1;
+ OutNumBladesBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+ OutNumBladesBinding.pImmutableSamplers = nullptr;
+
+ std::vector bindings = { bladesInBinding, bladesOutBinding, OutNumBladesBinding };
+
+ VkDescriptorSetLayoutCreateInfo layoutInfo = {};
+ layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ layoutInfo.bindingCount = static_cast(bindings.size());
+ layoutInfo.pBindings = bindings.data();
+
+ if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &computeDescriptorSetLayout) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create compute descriptor set layout");
+ }
}
void Renderer::CreateDescriptorPool() {
- // Describe which descriptor types that the descriptor sets will contain
- std::vector poolSizes = {
- // Camera
- { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 1},
-
- // Models + Blades
- { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER , static_cast(scene->GetModels().size() + scene->GetBlades().size()) },
-
- // Models + Blades
- { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , static_cast(scene->GetModels().size() + scene->GetBlades().size()) },
-
- // Time (compute)
- { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 1 },
-
- // TODO: Add any additional types and counts of descriptors you will need to allocate
- };
-
- VkDescriptorPoolCreateInfo poolInfo = {};
- poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
- poolInfo.poolSizeCount = static_cast(poolSizes.size());
- poolInfo.pPoolSizes = poolSizes.data();
- poolInfo.maxSets = 5;
-
- if (vkCreateDescriptorPool(logicalDevice, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create descriptor pool");
- }
+ // Describe which descriptor types that the descriptor sets will contain
+ std::vector poolSizes = {
+ // Camera
+ { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 1},
+
+ // Models + Blades
+ { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER , static_cast(scene->GetModels().size() + scene->GetBlades().size()) },
+
+ // Models + Blades
+ { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , static_cast(scene->GetModels().size() + scene->GetBlades().size()) },
+
+ // Time (compute)
+ { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 1 },
+
+ // TODO: Add any additional types and counts of descriptors you will need to allocate
+ //3 buffers for compute grass
+ {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, static_cast(scene->GetBlades().size()) * 3},
+ };
+
+ VkDescriptorPoolCreateInfo poolInfo = {};
+ poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+ poolInfo.poolSizeCount = static_cast(poolSizes.size());
+ poolInfo.pPoolSizes = poolSizes.data();
+ poolInfo.maxSets = 5;
+
+ if (vkCreateDescriptorPool(logicalDevice, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create descriptor pool");
+ }
}
void Renderer::CreateCameraDescriptorSet() {
- // Describe the desciptor set
- VkDescriptorSetLayout layouts[] = { cameraDescriptorSetLayout };
- VkDescriptorSetAllocateInfo allocInfo = {};
- allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
- allocInfo.descriptorPool = descriptorPool;
- allocInfo.descriptorSetCount = 1;
- allocInfo.pSetLayouts = layouts;
-
- // Allocate descriptor sets
- if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, &cameraDescriptorSet) != VK_SUCCESS) {
- throw std::runtime_error("Failed to allocate descriptor set");
- }
-
- // Configure the descriptors to refer to buffers
- VkDescriptorBufferInfo cameraBufferInfo = {};
- cameraBufferInfo.buffer = camera->GetBuffer();
- cameraBufferInfo.offset = 0;
- cameraBufferInfo.range = sizeof(CameraBufferObject);
-
- std::array descriptorWrites = {};
- descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
- descriptorWrites[0].dstSet = cameraDescriptorSet;
- descriptorWrites[0].dstBinding = 0;
- descriptorWrites[0].dstArrayElement = 0;
- descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- descriptorWrites[0].descriptorCount = 1;
- descriptorWrites[0].pBufferInfo = &cameraBufferInfo;
- descriptorWrites[0].pImageInfo = nullptr;
- descriptorWrites[0].pTexelBufferView = nullptr;
-
- // Update descriptor sets
- vkUpdateDescriptorSets(logicalDevice, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
+ // Describe the desciptor set
+ VkDescriptorSetLayout layouts[] = { cameraDescriptorSetLayout };
+ VkDescriptorSetAllocateInfo allocInfo = {};
+ allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+ allocInfo.descriptorPool = descriptorPool;
+ allocInfo.descriptorSetCount = 1;
+ allocInfo.pSetLayouts = layouts;
+
+ // Allocate descriptor sets
+ if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, &cameraDescriptorSet) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to allocate descriptor set");
+ }
+
+ // Configure the descriptors to refer to buffers
+ VkDescriptorBufferInfo cameraBufferInfo = {};
+ cameraBufferInfo.buffer = camera->GetBuffer();
+ cameraBufferInfo.offset = 0;
+ cameraBufferInfo.range = sizeof(CameraBufferObject);
+
+ std::array descriptorWrites = {};
+ descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ descriptorWrites[0].dstSet = cameraDescriptorSet;
+ descriptorWrites[0].dstBinding = 0;
+ descriptorWrites[0].dstArrayElement = 0;
+ descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ descriptorWrites[0].descriptorCount = 1;
+ descriptorWrites[0].pBufferInfo = &cameraBufferInfo;
+ descriptorWrites[0].pImageInfo = nullptr;
+ descriptorWrites[0].pTexelBufferView = nullptr;
+
+ // Update descriptor sets
+ vkUpdateDescriptorSets(logicalDevice, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
}
void Renderer::CreateModelDescriptorSets() {
- modelDescriptorSets.resize(scene->GetModels().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(modelDescriptorSets.size());
- allocInfo.pSetLayouts = layouts;
-
- // Allocate descriptor sets
- if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, modelDescriptorSets.data()) != VK_SUCCESS) {
- throw std::runtime_error("Failed to allocate descriptor set");
- }
-
- std::vector descriptorWrites(2 * modelDescriptorSets.size());
-
- for (uint32_t i = 0; i < scene->GetModels().size(); ++i) {
- VkDescriptorBufferInfo modelBufferInfo = {};
- modelBufferInfo.buffer = scene->GetModels()[i]->GetModelBuffer();
- modelBufferInfo.offset = 0;
- modelBufferInfo.range = sizeof(ModelBufferObject);
-
- // Bind image and sampler resources to the descriptor
- VkDescriptorImageInfo imageInfo = {};
- imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- imageInfo.imageView = scene->GetModels()[i]->GetTextureView();
- imageInfo.sampler = scene->GetModels()[i]->GetTextureSampler();
-
- descriptorWrites[2 * i + 0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
- descriptorWrites[2 * i + 0].dstSet = modelDescriptorSets[i];
- descriptorWrites[2 * i + 0].dstBinding = 0;
- descriptorWrites[2 * i + 0].dstArrayElement = 0;
- descriptorWrites[2 * i + 0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- descriptorWrites[2 * i + 0].descriptorCount = 1;
- descriptorWrites[2 * i + 0].pBufferInfo = &modelBufferInfo;
- descriptorWrites[2 * i + 0].pImageInfo = nullptr;
- descriptorWrites[2 * i + 0].pTexelBufferView = nullptr;
-
- descriptorWrites[2 * i + 1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
- descriptorWrites[2 * i + 1].dstSet = modelDescriptorSets[i];
- descriptorWrites[2 * i + 1].dstBinding = 1;
- descriptorWrites[2 * i + 1].dstArrayElement = 0;
- descriptorWrites[2 * i + 1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
- descriptorWrites[2 * i + 1].descriptorCount = 1;
- descriptorWrites[2 * i + 1].pImageInfo = &imageInfo;
- }
-
- // Update descriptor sets
- vkUpdateDescriptorSets(logicalDevice, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
+ modelDescriptorSets.resize(scene->GetModels().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(modelDescriptorSets.size());
+ allocInfo.pSetLayouts = layouts;
+
+ // Allocate descriptor sets
+ if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, modelDescriptorSets.data()) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to allocate descriptor set");
+ }
+
+ std::vector descriptorWrites(2 * modelDescriptorSets.size());
+
+ for (uint32_t i = 0; i < scene->GetModels().size(); ++i) {
+ VkDescriptorBufferInfo modelBufferInfo = {};
+ modelBufferInfo.buffer = scene->GetModels()[i]->GetModelBuffer();
+ modelBufferInfo.offset = 0;
+ modelBufferInfo.range = sizeof(ModelBufferObject);
+
+ // Bind image and sampler resources to the descriptor
+ VkDescriptorImageInfo imageInfo = {};
+ imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ imageInfo.imageView = scene->GetModels()[i]->GetTextureView();
+ imageInfo.sampler = scene->GetModels()[i]->GetTextureSampler();
+
+ descriptorWrites[2 * i + 0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ descriptorWrites[2 * i + 0].dstSet = modelDescriptorSets[i];
+ descriptorWrites[2 * i + 0].dstBinding = 0;
+ descriptorWrites[2 * i + 0].dstArrayElement = 0;
+ descriptorWrites[2 * i + 0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ descriptorWrites[2 * i + 0].descriptorCount = 1;
+ descriptorWrites[2 * i + 0].pBufferInfo = &modelBufferInfo;
+ descriptorWrites[2 * i + 0].pImageInfo = nullptr;
+ descriptorWrites[2 * i + 0].pTexelBufferView = nullptr;
+
+ descriptorWrites[2 * i + 1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ descriptorWrites[2 * i + 1].dstSet = modelDescriptorSets[i];
+ descriptorWrites[2 * i + 1].dstBinding = 1;
+ descriptorWrites[2 * i + 1].dstArrayElement = 0;
+ descriptorWrites[2 * i + 1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+ descriptorWrites[2 * i + 1].descriptorCount = 1;
+ descriptorWrites[2 * i + 1].pImageInfo = &imageInfo;
+ }
+
+ // Update descriptor sets
+ vkUpdateDescriptorSets(logicalDevice, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
}
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
+ // 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(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 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);
+
+ // Bind image and sampler resources to the descriptor
+ //VkDescriptorImageInfo imageInfo = {};
+ //imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ //imageInfo.imageView = scene->GetModels()[i]->GetTextureView();
+ //imageInfo.sampler = scene->GetModels()[i]->GetTextureSampler();
+
+ 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(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
}
void Renderer::CreateTimeDescriptorSet() {
- // Describe the desciptor set
- VkDescriptorSetLayout layouts[] = { timeDescriptorSetLayout };
- VkDescriptorSetAllocateInfo allocInfo = {};
- allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
- allocInfo.descriptorPool = descriptorPool;
- allocInfo.descriptorSetCount = 1;
- allocInfo.pSetLayouts = layouts;
-
- // Allocate descriptor sets
- if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, &timeDescriptorSet) != VK_SUCCESS) {
- throw std::runtime_error("Failed to allocate descriptor set");
- }
-
- // Configure the descriptors to refer to buffers
- VkDescriptorBufferInfo timeBufferInfo = {};
- timeBufferInfo.buffer = scene->GetTimeBuffer();
- timeBufferInfo.offset = 0;
- timeBufferInfo.range = sizeof(Time);
-
- std::array descriptorWrites = {};
- descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
- descriptorWrites[0].dstSet = timeDescriptorSet;
- descriptorWrites[0].dstBinding = 0;
- descriptorWrites[0].dstArrayElement = 0;
- descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- descriptorWrites[0].descriptorCount = 1;
- descriptorWrites[0].pBufferInfo = &timeBufferInfo;
- descriptorWrites[0].pImageInfo = nullptr;
- descriptorWrites[0].pTexelBufferView = nullptr;
-
- // Update descriptor sets
- vkUpdateDescriptorSets(logicalDevice, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
+ // Describe the desciptor set
+ VkDescriptorSetLayout layouts[] = { timeDescriptorSetLayout };
+ VkDescriptorSetAllocateInfo allocInfo = {};
+ allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+ allocInfo.descriptorPool = descriptorPool;
+ allocInfo.descriptorSetCount = 1;
+ allocInfo.pSetLayouts = layouts;
+
+ // Allocate descriptor sets
+ if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, &timeDescriptorSet) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to allocate descriptor set");
+ }
+
+ // Configure the descriptors to refer to buffers
+ VkDescriptorBufferInfo timeBufferInfo = {};
+ timeBufferInfo.buffer = scene->GetTimeBuffer();
+ timeBufferInfo.offset = 0;
+ timeBufferInfo.range = sizeof(Time);
+
+ std::array descriptorWrites = {};
+ descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ descriptorWrites[0].dstSet = timeDescriptorSet;
+ descriptorWrites[0].dstBinding = 0;
+ descriptorWrites[0].dstArrayElement = 0;
+ descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ descriptorWrites[0].descriptorCount = 1;
+ descriptorWrites[0].pBufferInfo = &timeBufferInfo;
+ descriptorWrites[0].pImageInfo = nullptr;
+ descriptorWrites[0].pTexelBufferView = nullptr;
+
+ // Update descriptor sets
+ vkUpdateDescriptorSets(logicalDevice, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
}
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
+ // 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
+ computeDescriptorSet.resize(scene->GetBlades().size());
+
+ VkDescriptorSetLayout layouts[] = { computeDescriptorSetLayout };
+ VkDescriptorSetAllocateInfo allocInfo = {};
+ allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+ allocInfo.descriptorPool = descriptorPool;
+ allocInfo.descriptorSetCount = static_cast(computeDescriptorSet.size());
+ allocInfo.pSetLayouts = layouts;
+
+ // Allocate descriptor sets
+ if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, computeDescriptorSet.data()) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to allocate descriptor set");
+ }
+
+ std::vector descriptorWrites(scene->GetBlades().size() * 3);
+ for (int i = 0; i < scene->GetBlades().size() * 3; i += 3) {
+ VkDescriptorBufferInfo inBladesBufferInfo = {};
+ inBladesBufferInfo.buffer = scene->GetBlades()[i]->GetBladesBuffer();
+ inBladesBufferInfo.offset = 0;
+ inBladesBufferInfo.range = NUM_BLADES * sizeof(Blade);
+
+ VkDescriptorBufferInfo outBladesBufferInfo = {};
+ outBladesBufferInfo.buffer = scene->GetBlades()[i]->GetCulledBladesBuffer();
+ outBladesBufferInfo.offset = 0;
+ outBladesBufferInfo.range = NUM_BLADES * sizeof(Blade);
+
+ VkDescriptorBufferInfo numBladesBufferInfo = {};
+ numBladesBufferInfo.buffer = scene->GetBlades()[i]->GetNumBladesBuffer();
+ numBladesBufferInfo.offset = 0;
+ numBladesBufferInfo.range = sizeof(BladeDrawIndirect);
+
+ descriptorWrites[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ descriptorWrites[i].dstSet = computeDescriptorSet[i];
+ descriptorWrites[i].dstBinding = 0;
+ descriptorWrites[i].dstArrayElement = 0;
+ descriptorWrites[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ descriptorWrites[i].descriptorCount = 1;
+ descriptorWrites[i].pBufferInfo = &inBladesBufferInfo;
+ descriptorWrites[i].pImageInfo = nullptr;
+ descriptorWrites[i].pTexelBufferView = nullptr;
+
+ descriptorWrites[i + 1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ descriptorWrites[i + 1].dstSet = computeDescriptorSet[i];
+ descriptorWrites[i + 1].dstBinding = 1;
+ descriptorWrites[i + 1].dstArrayElement = 0;
+ descriptorWrites[i + 1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ descriptorWrites[i + 1].descriptorCount = 1;
+ descriptorWrites[i + 1].pBufferInfo = &outBladesBufferInfo;
+ descriptorWrites[i + 1].pImageInfo = nullptr;
+ descriptorWrites[i + 1].pTexelBufferView = nullptr;
+
+ descriptorWrites[i + 2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ descriptorWrites[i + 2].dstSet = computeDescriptorSet[i];
+ descriptorWrites[i + 2].dstBinding = 2;
+ descriptorWrites[i + 2].dstArrayElement = 0;
+ descriptorWrites[i + 2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ descriptorWrites[i + 2].descriptorCount = 1;
+ descriptorWrites[i + 2].pBufferInfo = &numBladesBufferInfo;
+ descriptorWrites[i + 2].pImageInfo = nullptr;
+ descriptorWrites[i + 2].pTexelBufferView = nullptr;
+ }
+
+ // Update descriptor sets
+ vkUpdateDescriptorSets(logicalDevice, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
}
+
+
void Renderer::CreateGraphicsPipeline() {
- VkShaderModule vertShaderModule = ShaderModule::Create("shaders/graphics.vert.spv", logicalDevice);
- VkShaderModule fragShaderModule = ShaderModule::Create("shaders/graphics.frag.spv", logicalDevice);
-
- // Assign each shader module to the appropriate stage in the pipeline
- VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
- vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
- vertShaderStageInfo.module = vertShaderModule;
- vertShaderStageInfo.pName = "main";
-
- VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
- fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
- fragShaderStageInfo.module = fragShaderModule;
- fragShaderStageInfo.pName = "main";
-
- VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, fragShaderStageInfo };
-
- // --- Set up fixed-function stages ---
-
- // Vertex input
- VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
- vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
-
- auto bindingDescription = Vertex::getBindingDescription();
- auto attributeDescriptions = Vertex::getAttributeDescriptions();
-
- vertexInputInfo.vertexBindingDescriptionCount = 1;
- vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
- vertexInputInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size());
- vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
-
- // Input assembly
- VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
- inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
- inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- inputAssembly.primitiveRestartEnable = VK_FALSE;
-
- // Viewports and Scissors (rectangles that define in which regions pixels are stored)
- VkViewport viewport = {};
- viewport.x = 0.0f;
- viewport.y = 0.0f;
- viewport.width = static_cast(swapChain->GetVkExtent().width);
- viewport.height = static_cast(swapChain->GetVkExtent().height);
- viewport.minDepth = 0.0f;
- viewport.maxDepth = 1.0f;
-
- VkRect2D scissor = {};
- scissor.offset = { 0, 0 };
- scissor.extent = swapChain->GetVkExtent();
-
- VkPipelineViewportStateCreateInfo viewportState = {};
- viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
- viewportState.viewportCount = 1;
- viewportState.pViewports = &viewport;
- viewportState.scissorCount = 1;
- viewportState.pScissors = &scissor;
-
- // Rasterizer
- VkPipelineRasterizationStateCreateInfo rasterizer = {};
- rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
- rasterizer.depthClampEnable = VK_FALSE;
- rasterizer.rasterizerDiscardEnable = VK_FALSE;
- rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
- rasterizer.lineWidth = 1.0f;
- rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
- rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
- rasterizer.depthBiasEnable = VK_FALSE;
- rasterizer.depthBiasConstantFactor = 0.0f;
- rasterizer.depthBiasClamp = 0.0f;
- rasterizer.depthBiasSlopeFactor = 0.0f;
-
- // Multisampling (turned off here)
- VkPipelineMultisampleStateCreateInfo multisampling = {};
- multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
- multisampling.sampleShadingEnable = VK_FALSE;
- multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- multisampling.minSampleShading = 1.0f;
- multisampling.pSampleMask = nullptr;
- multisampling.alphaToCoverageEnable = VK_FALSE;
- multisampling.alphaToOneEnable = VK_FALSE;
-
- // Depth testing
- VkPipelineDepthStencilStateCreateInfo depthStencil = {};
- depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depthStencil.depthTestEnable = VK_TRUE;
- depthStencil.depthWriteEnable = VK_TRUE;
- depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
- depthStencil.depthBoundsTestEnable = VK_FALSE;
- depthStencil.minDepthBounds = 0.0f;
- depthStencil.maxDepthBounds = 1.0f;
- depthStencil.stencilTestEnable = VK_FALSE;
-
- // Color blending (turned off here, but showing options for learning)
- // --> Configuration per attached framebuffer
- VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
- colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- colorBlendAttachment.blendEnable = VK_FALSE;
- colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
- colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
- colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
- colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
- colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
- colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
-
- // --> Global color blending settings
- VkPipelineColorBlendStateCreateInfo colorBlending = {};
- colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
- colorBlending.logicOpEnable = VK_FALSE;
- colorBlending.logicOp = VK_LOGIC_OP_COPY;
- colorBlending.attachmentCount = 1;
- colorBlending.pAttachments = &colorBlendAttachment;
- colorBlending.blendConstants[0] = 0.0f;
- colorBlending.blendConstants[1] = 0.0f;
- colorBlending.blendConstants[2] = 0.0f;
- colorBlending.blendConstants[3] = 0.0f;
-
- std::vector descriptorSetLayouts = { cameraDescriptorSetLayout, modelDescriptorSetLayout };
-
- // Pipeline layout: used to specify uniform values
- VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
- pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
- pipelineLayoutInfo.setLayoutCount = static_cast(descriptorSetLayouts.size());
- pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts.data();
- pipelineLayoutInfo.pushConstantRangeCount = 0;
- pipelineLayoutInfo.pPushConstantRanges = 0;
-
- if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &graphicsPipelineLayout) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create pipeline layout");
- }
-
- // --- Create graphics pipeline ---
- VkGraphicsPipelineCreateInfo pipelineInfo = {};
- pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
- pipelineInfo.stageCount = 2;
- pipelineInfo.pStages = shaderStages;
- pipelineInfo.pVertexInputState = &vertexInputInfo;
- pipelineInfo.pInputAssemblyState = &inputAssembly;
- pipelineInfo.pViewportState = &viewportState;
- pipelineInfo.pRasterizationState = &rasterizer;
- pipelineInfo.pMultisampleState = &multisampling;
- pipelineInfo.pDepthStencilState = &depthStencil;
- pipelineInfo.pColorBlendState = &colorBlending;
- pipelineInfo.pDynamicState = nullptr;
- pipelineInfo.layout = graphicsPipelineLayout;
- pipelineInfo.renderPass = renderPass;
- pipelineInfo.subpass = 0;
- pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
- pipelineInfo.basePipelineIndex = -1;
-
- if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create graphics pipeline");
- }
-
- vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
- vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
+ VkShaderModule vertShaderModule = ShaderModule::Create("shaders/graphics.vert.spv", logicalDevice);
+ VkShaderModule fragShaderModule = ShaderModule::Create("shaders/graphics.frag.spv", logicalDevice);
+
+ // Assign each shader module to the appropriate stage in the pipeline
+ VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
+ vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+ vertShaderStageInfo.module = vertShaderModule;
+ vertShaderStageInfo.pName = "main";
+
+ VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
+ fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+ fragShaderStageInfo.module = fragShaderModule;
+ fragShaderStageInfo.pName = "main";
+
+ VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, fragShaderStageInfo };
+
+ // --- Set up fixed-function stages ---
+
+ // Vertex input
+ VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
+ vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+
+ auto bindingDescription = Vertex::getBindingDescription();
+ auto attributeDescriptions = Vertex::getAttributeDescriptions();
+
+ vertexInputInfo.vertexBindingDescriptionCount = 1;
+ vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
+ vertexInputInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size());
+ vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
+
+ // Input assembly
+ VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
+ inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+ inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+ inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+ // Viewports and Scissors (rectangles that define in which regions pixels are stored)
+ VkViewport viewport = {};
+ viewport.x = 0.0f;
+ viewport.y = 0.0f;
+ viewport.width = static_cast(swapChain->GetVkExtent().width);
+ viewport.height = static_cast(swapChain->GetVkExtent().height);
+ viewport.minDepth = 0.0f;
+ viewport.maxDepth = 1.0f;
+
+ VkRect2D scissor = {};
+ scissor.offset = { 0, 0 };
+ scissor.extent = swapChain->GetVkExtent();
+
+ VkPipelineViewportStateCreateInfo viewportState = {};
+ viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+ viewportState.viewportCount = 1;
+ viewportState.pViewports = &viewport;
+ viewportState.scissorCount = 1;
+ viewportState.pScissors = &scissor;
+
+ // Rasterizer
+ VkPipelineRasterizationStateCreateInfo rasterizer = {};
+ rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+ rasterizer.depthClampEnable = VK_FALSE;
+ rasterizer.rasterizerDiscardEnable = VK_FALSE;
+ rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
+ rasterizer.lineWidth = 1.0f;
+ rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
+ rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+ rasterizer.depthBiasEnable = VK_FALSE;
+ rasterizer.depthBiasConstantFactor = 0.0f;
+ rasterizer.depthBiasClamp = 0.0f;
+ rasterizer.depthBiasSlopeFactor = 0.0f;
+
+ // Multisampling (turned off here)
+ VkPipelineMultisampleStateCreateInfo multisampling = {};
+ multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+ multisampling.sampleShadingEnable = VK_FALSE;
+ multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+ multisampling.minSampleShading = 1.0f;
+ multisampling.pSampleMask = nullptr;
+ multisampling.alphaToCoverageEnable = VK_FALSE;
+ multisampling.alphaToOneEnable = VK_FALSE;
+
+ // Depth testing
+ VkPipelineDepthStencilStateCreateInfo depthStencil = {};
+ depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+ depthStencil.depthTestEnable = VK_TRUE;
+ depthStencil.depthWriteEnable = VK_TRUE;
+ depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
+ depthStencil.depthBoundsTestEnable = VK_FALSE;
+ depthStencil.minDepthBounds = 0.0f;
+ depthStencil.maxDepthBounds = 1.0f;
+ depthStencil.stencilTestEnable = VK_FALSE;
+
+ // Color blending (turned off here, but showing options for learning)
+ // --> Configuration per attached framebuffer
+ VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
+ colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+ colorBlendAttachment.blendEnable = VK_FALSE;
+ colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
+ colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
+ colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
+ colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+ colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+ colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
+
+ // --> Global color blending settings
+ VkPipelineColorBlendStateCreateInfo colorBlending = {};
+ colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+ colorBlending.logicOpEnable = VK_FALSE;
+ colorBlending.logicOp = VK_LOGIC_OP_COPY;
+ colorBlending.attachmentCount = 1;
+ colorBlending.pAttachments = &colorBlendAttachment;
+ colorBlending.blendConstants[0] = 0.0f;
+ colorBlending.blendConstants[1] = 0.0f;
+ colorBlending.blendConstants[2] = 0.0f;
+ colorBlending.blendConstants[3] = 0.0f;
+
+ std::vector descriptorSetLayouts = { cameraDescriptorSetLayout, modelDescriptorSetLayout };
+
+ // Pipeline layout: used to specify uniform values
+ VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
+ pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+ pipelineLayoutInfo.setLayoutCount = static_cast(descriptorSetLayouts.size());
+ pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts.data();
+ pipelineLayoutInfo.pushConstantRangeCount = 0;
+ pipelineLayoutInfo.pPushConstantRanges = 0;
+
+ if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &graphicsPipelineLayout) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create pipeline layout");
+ }
+
+ // --- Create graphics pipeline ---
+ VkGraphicsPipelineCreateInfo pipelineInfo = {};
+ pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+ pipelineInfo.stageCount = 2;
+ pipelineInfo.pStages = shaderStages;
+ pipelineInfo.pVertexInputState = &vertexInputInfo;
+ pipelineInfo.pInputAssemblyState = &inputAssembly;
+ pipelineInfo.pViewportState = &viewportState;
+ pipelineInfo.pRasterizationState = &rasterizer;
+ pipelineInfo.pMultisampleState = &multisampling;
+ pipelineInfo.pDepthStencilState = &depthStencil;
+ pipelineInfo.pColorBlendState = &colorBlending;
+ pipelineInfo.pDynamicState = nullptr;
+ pipelineInfo.layout = graphicsPipelineLayout;
+ pipelineInfo.renderPass = renderPass;
+ pipelineInfo.subpass = 0;
+ pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
+ pipelineInfo.basePipelineIndex = -1;
+
+ if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create graphics pipeline");
+ }
+
+ vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
+ vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
}
void Renderer::CreateGrassPipeline() {
- // --- Set up programmable shaders ---
- VkShaderModule vertShaderModule = ShaderModule::Create("shaders/grass.vert.spv", logicalDevice);
- VkShaderModule tescShaderModule = ShaderModule::Create("shaders/grass.tesc.spv", logicalDevice);
- VkShaderModule teseShaderModule = ShaderModule::Create("shaders/grass.tese.spv", logicalDevice);
- VkShaderModule fragShaderModule = ShaderModule::Create("shaders/grass.frag.spv", logicalDevice);
-
- // Assign each shader module to the appropriate stage in the pipeline
- VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
- vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
- vertShaderStageInfo.module = vertShaderModule;
- vertShaderStageInfo.pName = "main";
-
- VkPipelineShaderStageCreateInfo tescShaderStageInfo = {};
- tescShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- tescShaderStageInfo.stage = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
- tescShaderStageInfo.module = tescShaderModule;
- tescShaderStageInfo.pName = "main";
-
- VkPipelineShaderStageCreateInfo teseShaderStageInfo = {};
- teseShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- teseShaderStageInfo.stage = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
- teseShaderStageInfo.module = teseShaderModule;
- teseShaderStageInfo.pName = "main";
-
- VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
- fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
- fragShaderStageInfo.module = fragShaderModule;
- fragShaderStageInfo.pName = "main";
-
- VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, tescShaderStageInfo, teseShaderStageInfo, fragShaderStageInfo };
-
- // --- Set up fixed-function stages ---
-
- // Vertex input
- VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
- vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
-
- auto bindingDescription = Blade::getBindingDescription();
- auto attributeDescriptions = Blade::getAttributeDescriptions();
-
- vertexInputInfo.vertexBindingDescriptionCount = 1;
- vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
- vertexInputInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size());
- vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
-
- // Input Assembly
- VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
- inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
- inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
- inputAssembly.primitiveRestartEnable = VK_FALSE;
-
- // Viewports and Scissors (rectangles that define in which regions pixels are stored)
- VkViewport viewport = {};
- viewport.x = 0.0f;
- viewport.y = 0.0f;
- viewport.width = static_cast(swapChain->GetVkExtent().width);
- viewport.height = static_cast(swapChain->GetVkExtent().height);
- viewport.minDepth = 0.0f;
- viewport.maxDepth = 1.0f;
-
- VkRect2D scissor = {};
- scissor.offset = { 0, 0 };
- scissor.extent = swapChain->GetVkExtent();
-
- VkPipelineViewportStateCreateInfo viewportState = {};
- viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
- viewportState.viewportCount = 1;
- viewportState.pViewports = &viewport;
- viewportState.scissorCount = 1;
- viewportState.pScissors = &scissor;
-
- // Rasterizer
- VkPipelineRasterizationStateCreateInfo rasterizer = {};
- rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
- rasterizer.depthClampEnable = VK_FALSE;
- rasterizer.rasterizerDiscardEnable = VK_FALSE;
- rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
- rasterizer.lineWidth = 1.0f;
- rasterizer.cullMode = VK_CULL_MODE_NONE;
- rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
- rasterizer.depthBiasEnable = VK_FALSE;
- rasterizer.depthBiasConstantFactor = 0.0f;
- rasterizer.depthBiasClamp = 0.0f;
- rasterizer.depthBiasSlopeFactor = 0.0f;
-
- // Multisampling (turned off here)
- VkPipelineMultisampleStateCreateInfo multisampling = {};
- multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
- multisampling.sampleShadingEnable = VK_FALSE;
- multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- multisampling.minSampleShading = 1.0f;
- multisampling.pSampleMask = nullptr;
- multisampling.alphaToCoverageEnable = VK_FALSE;
- multisampling.alphaToOneEnable = VK_FALSE;
-
- // Depth testing
- VkPipelineDepthStencilStateCreateInfo depthStencil = {};
- depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depthStencil.depthTestEnable = VK_TRUE;
- depthStencil.depthWriteEnable = VK_TRUE;
- depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
- depthStencil.depthBoundsTestEnable = VK_FALSE;
- depthStencil.minDepthBounds = 0.0f;
- depthStencil.maxDepthBounds = 1.0f;
- depthStencil.stencilTestEnable = VK_FALSE;
-
- // Color blending (turned off here, but showing options for learning)
- // --> Configuration per attached framebuffer
- VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
- colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- colorBlendAttachment.blendEnable = VK_FALSE;
- colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
- colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
- colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
- colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
- colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
- colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
-
- // --> Global color blending settings
- VkPipelineColorBlendStateCreateInfo colorBlending = {};
- colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
- colorBlending.logicOpEnable = VK_FALSE;
- colorBlending.logicOp = VK_LOGIC_OP_COPY;
- colorBlending.attachmentCount = 1;
- colorBlending.pAttachments = &colorBlendAttachment;
- colorBlending.blendConstants[0] = 0.0f;
- colorBlending.blendConstants[1] = 0.0f;
- colorBlending.blendConstants[2] = 0.0f;
- colorBlending.blendConstants[3] = 0.0f;
-
- std::vector descriptorSetLayouts = { cameraDescriptorSetLayout, modelDescriptorSetLayout };
-
- // Pipeline layout: used to specify uniform values
- VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
- pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
- pipelineLayoutInfo.setLayoutCount = static_cast(descriptorSetLayouts.size());
- pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts.data();
- pipelineLayoutInfo.pushConstantRangeCount = 0;
- pipelineLayoutInfo.pPushConstantRanges = 0;
-
- if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &grassPipelineLayout) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create pipeline layout");
- }
-
- // Tessellation state
- VkPipelineTessellationStateCreateInfo tessellationInfo = {};
- tessellationInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
- tessellationInfo.pNext = NULL;
- tessellationInfo.flags = 0;
- tessellationInfo.patchControlPoints = 1;
-
- // --- Create graphics pipeline ---
- VkGraphicsPipelineCreateInfo pipelineInfo = {};
- pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
- pipelineInfo.stageCount = 4;
- pipelineInfo.pStages = shaderStages;
- pipelineInfo.pVertexInputState = &vertexInputInfo;
- pipelineInfo.pInputAssemblyState = &inputAssembly;
- pipelineInfo.pViewportState = &viewportState;
- pipelineInfo.pRasterizationState = &rasterizer;
- pipelineInfo.pMultisampleState = &multisampling;
- pipelineInfo.pDepthStencilState = &depthStencil;
- pipelineInfo.pColorBlendState = &colorBlending;
- pipelineInfo.pTessellationState = &tessellationInfo;
- pipelineInfo.pDynamicState = nullptr;
- pipelineInfo.layout = grassPipelineLayout;
- pipelineInfo.renderPass = renderPass;
- pipelineInfo.subpass = 0;
- pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
- pipelineInfo.basePipelineIndex = -1;
-
- if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &grassPipeline) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create graphics pipeline");
- }
-
- // No need for the shader modules anymore
- vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
- vkDestroyShaderModule(logicalDevice, tescShaderModule, nullptr);
- vkDestroyShaderModule(logicalDevice, teseShaderModule, nullptr);
- vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
+ // --- Set up programmable shaders ---
+ VkShaderModule vertShaderModule = ShaderModule::Create("shaders/grass.vert.spv", logicalDevice);
+ VkShaderModule tescShaderModule = ShaderModule::Create("shaders/grass.tesc.spv", logicalDevice);
+ VkShaderModule teseShaderModule = ShaderModule::Create("shaders/grass.tese.spv", logicalDevice);
+ VkShaderModule fragShaderModule = ShaderModule::Create("shaders/grass.frag.spv", logicalDevice);
+
+ // Assign each shader module to the appropriate stage in the pipeline
+ VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
+ vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+ vertShaderStageInfo.module = vertShaderModule;
+ vertShaderStageInfo.pName = "main";
+
+ VkPipelineShaderStageCreateInfo tescShaderStageInfo = {};
+ tescShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ tescShaderStageInfo.stage = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
+ tescShaderStageInfo.module = tescShaderModule;
+ tescShaderStageInfo.pName = "main";
+
+ VkPipelineShaderStageCreateInfo teseShaderStageInfo = {};
+ teseShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ teseShaderStageInfo.stage = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+ teseShaderStageInfo.module = teseShaderModule;
+ teseShaderStageInfo.pName = "main";
+
+ VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
+ fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+ fragShaderStageInfo.module = fragShaderModule;
+ fragShaderStageInfo.pName = "main";
+
+ VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, tescShaderStageInfo, teseShaderStageInfo, fragShaderStageInfo };
+
+ // --- Set up fixed-function stages ---
+
+ // Vertex input
+ VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
+ vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+
+ auto bindingDescription = Blade::getBindingDescription();
+ auto attributeDescriptions = Blade::getAttributeDescriptions();
+
+ vertexInputInfo.vertexBindingDescriptionCount = 1;
+ vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
+ vertexInputInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size());
+ vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
+
+ // Input Assembly
+ VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
+ inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+ inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
+ inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+ // Viewports and Scissors (rectangles that define in which regions pixels are stored)
+ VkViewport viewport = {};
+ viewport.x = 0.0f;
+ viewport.y = 0.0f;
+ viewport.width = static_cast(swapChain->GetVkExtent().width);
+ viewport.height = static_cast(swapChain->GetVkExtent().height);
+ viewport.minDepth = 0.0f;
+ viewport.maxDepth = 1.0f;
+
+ VkRect2D scissor = {};
+ scissor.offset = { 0, 0 };
+ scissor.extent = swapChain->GetVkExtent();
+
+ VkPipelineViewportStateCreateInfo viewportState = {};
+ viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+ viewportState.viewportCount = 1;
+ viewportState.pViewports = &viewport;
+ viewportState.scissorCount = 1;
+ viewportState.pScissors = &scissor;
+
+ // Rasterizer
+ VkPipelineRasterizationStateCreateInfo rasterizer = {};
+ rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+ rasterizer.depthClampEnable = VK_FALSE;
+ rasterizer.rasterizerDiscardEnable = VK_FALSE;
+ rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
+ rasterizer.lineWidth = 1.0f;
+ rasterizer.cullMode = VK_CULL_MODE_NONE;
+ rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+ rasterizer.depthBiasEnable = VK_FALSE;
+ rasterizer.depthBiasConstantFactor = 0.0f;
+ rasterizer.depthBiasClamp = 0.0f;
+ rasterizer.depthBiasSlopeFactor = 0.0f;
+
+ // Multisampling (turned off here)
+ VkPipelineMultisampleStateCreateInfo multisampling = {};
+ multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+ multisampling.sampleShadingEnable = VK_FALSE;
+ multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+ multisampling.minSampleShading = 1.0f;
+ multisampling.pSampleMask = nullptr;
+ multisampling.alphaToCoverageEnable = VK_FALSE;
+ multisampling.alphaToOneEnable = VK_FALSE;
+
+ // Depth testing
+ VkPipelineDepthStencilStateCreateInfo depthStencil = {};
+ depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+ depthStencil.depthTestEnable = VK_TRUE;
+ depthStencil.depthWriteEnable = VK_TRUE;
+ depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
+ depthStencil.depthBoundsTestEnable = VK_FALSE;
+ depthStencil.minDepthBounds = 0.0f;
+ depthStencil.maxDepthBounds = 1.0f;
+ depthStencil.stencilTestEnable = VK_FALSE;
+
+ // Color blending (turned off here, but showing options for learning)
+ // --> Configuration per attached framebuffer
+ VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
+ colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+ colorBlendAttachment.blendEnable = VK_FALSE;
+ colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
+ colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
+ colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
+ colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+ colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+ colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
+
+ // --> Global color blending settings
+ VkPipelineColorBlendStateCreateInfo colorBlending = {};
+ colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+ colorBlending.logicOpEnable = VK_FALSE;
+ colorBlending.logicOp = VK_LOGIC_OP_COPY;
+ colorBlending.attachmentCount = 1;
+ colorBlending.pAttachments = &colorBlendAttachment;
+ colorBlending.blendConstants[0] = 0.0f;
+ colorBlending.blendConstants[1] = 0.0f;
+ colorBlending.blendConstants[2] = 0.0f;
+ colorBlending.blendConstants[3] = 0.0f;
+
+ std::vector descriptorSetLayouts = { cameraDescriptorSetLayout, modelDescriptorSetLayout };
+
+ // Pipeline layout: used to specify uniform values
+ VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
+ pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+ pipelineLayoutInfo.setLayoutCount = static_cast(descriptorSetLayouts.size());
+ pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts.data();
+ pipelineLayoutInfo.pushConstantRangeCount = 0;
+ pipelineLayoutInfo.pPushConstantRanges = 0;
+
+ if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &grassPipelineLayout) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create pipeline layout");
+ }
+
+ // Tessellation state
+ VkPipelineTessellationStateCreateInfo tessellationInfo = {};
+ tessellationInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
+ tessellationInfo.pNext = NULL;
+ tessellationInfo.flags = 0;
+ tessellationInfo.patchControlPoints = 1;
+
+ // --- Create graphics pipeline ---
+ VkGraphicsPipelineCreateInfo pipelineInfo = {};
+ pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+ pipelineInfo.stageCount = 4;
+ pipelineInfo.pStages = shaderStages;
+ pipelineInfo.pVertexInputState = &vertexInputInfo;
+ pipelineInfo.pInputAssemblyState = &inputAssembly;
+ pipelineInfo.pViewportState = &viewportState;
+ pipelineInfo.pRasterizationState = &rasterizer;
+ pipelineInfo.pMultisampleState = &multisampling;
+ pipelineInfo.pDepthStencilState = &depthStencil;
+ pipelineInfo.pColorBlendState = &colorBlending;
+ pipelineInfo.pTessellationState = &tessellationInfo;
+ pipelineInfo.pDynamicState = nullptr;
+ pipelineInfo.layout = grassPipelineLayout;
+ pipelineInfo.renderPass = renderPass;
+ pipelineInfo.subpass = 0;
+ pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
+ pipelineInfo.basePipelineIndex = -1;
+
+ if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &grassPipeline) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create graphics pipeline");
+ }
+
+ // No need for the shader modules anymore
+ vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
+ vkDestroyShaderModule(logicalDevice, tescShaderModule, nullptr);
+ vkDestroyShaderModule(logicalDevice, teseShaderModule, nullptr);
+ vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
}
void Renderer::CreateComputePipeline() {
- // Set up programmable shaders
- VkShaderModule computeShaderModule = ShaderModule::Create("shaders/compute.comp.spv", logicalDevice);
-
- VkPipelineShaderStageCreateInfo computeShaderStageInfo = {};
- computeShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- computeShaderStageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
- computeShaderStageInfo.module = computeShaderModule;
- computeShaderStageInfo.pName = "main";
-
- // TODO: Add the compute dsecriptor set layout you create to this list
- std::vector descriptorSetLayouts = { cameraDescriptorSetLayout, timeDescriptorSetLayout };
-
- // Create pipeline layout
- VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
- pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
- pipelineLayoutInfo.setLayoutCount = static_cast(descriptorSetLayouts.size());
- pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts.data();
- pipelineLayoutInfo.pushConstantRangeCount = 0;
- pipelineLayoutInfo.pPushConstantRanges = 0;
-
- if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &computePipelineLayout) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create pipeline layout");
- }
-
- // Create compute pipeline
- VkComputePipelineCreateInfo pipelineInfo = {};
- pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
- pipelineInfo.stage = computeShaderStageInfo;
- pipelineInfo.layout = computePipelineLayout;
- pipelineInfo.pNext = nullptr;
- pipelineInfo.flags = 0;
- pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
- pipelineInfo.basePipelineIndex = -1;
-
- if (vkCreateComputePipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &computePipeline) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create compute pipeline");
- }
-
- // No need for shader modules anymore
- vkDestroyShaderModule(logicalDevice, computeShaderModule, nullptr);
+ // Set up programmable shaders
+ VkShaderModule computeShaderModule = ShaderModule::Create("shaders/compute.comp.spv", logicalDevice);
+
+ VkPipelineShaderStageCreateInfo computeShaderStageInfo = {};
+ computeShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ computeShaderStageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
+ computeShaderStageInfo.module = computeShaderModule;
+ computeShaderStageInfo.pName = "main";
+
+ // TODO: Add the compute dsecriptor set layout you create to this list
+ std::vector descriptorSetLayouts = { cameraDescriptorSetLayout, timeDescriptorSetLayout, computeDescriptorSetLayout };
+
+ // Create pipeline layout
+ VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
+ pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+ pipelineLayoutInfo.setLayoutCount = static_cast(descriptorSetLayouts.size());
+ pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts.data();
+ pipelineLayoutInfo.pushConstantRangeCount = 0;
+ pipelineLayoutInfo.pPushConstantRanges = 0;
+
+ if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &computePipelineLayout) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create pipeline layout");
+ }
+
+ // Create compute pipeline
+ VkComputePipelineCreateInfo pipelineInfo = {};
+ pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+ pipelineInfo.stage = computeShaderStageInfo;
+ pipelineInfo.layout = computePipelineLayout;
+ pipelineInfo.pNext = nullptr;
+ pipelineInfo.flags = 0;
+ pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
+ pipelineInfo.basePipelineIndex = -1;
+
+ if (vkCreateComputePipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &computePipeline) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create compute pipeline");
+ }
+
+ // No need for shader modules anymore
+ vkDestroyShaderModule(logicalDevice, computeShaderModule, nullptr);
}
void Renderer::CreateFrameResources() {
- imageViews.resize(swapChain->GetCount());
-
- for (uint32_t i = 0; i < swapChain->GetCount(); i++) {
- // --- Create an image view for each swap chain image ---
- VkImageViewCreateInfo createInfo = {};
- createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
- createInfo.image = swapChain->GetVkImage(i);
-
- // Specify how the image data should be interpreted
- createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
- createInfo.format = swapChain->GetVkImageFormat();
-
- // Specify color channel mappings (can be used for swizzling)
- createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
- createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
- createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
- createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
-
- // Describe the image's purpose and which part of the image should be accessed
- createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
- createInfo.subresourceRange.baseMipLevel = 0;
- createInfo.subresourceRange.levelCount = 1;
- createInfo.subresourceRange.baseArrayLayer = 0;
- createInfo.subresourceRange.layerCount = 1;
-
- // Create the image view
- if (vkCreateImageView(logicalDevice, &createInfo, nullptr, &imageViews[i]) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create image views");
- }
- }
-
- VkFormat depthFormat = device->GetInstance()->GetSupportedFormat({ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT }, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
- // CREATE DEPTH IMAGE
- Image::Create(device,
- swapChain->GetVkExtent().width,
- swapChain->GetVkExtent().height,
- depthFormat,
- VK_IMAGE_TILING_OPTIMAL,
- VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
- VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
- depthImage,
- depthImageMemory
- );
-
- depthImageView = Image::CreateView(device, depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT);
-
- // Transition the image for use as depth-stencil
- Image::TransitionLayout(device, graphicsCommandPool, depthImage, depthFormat, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
-
-
- // CREATE FRAMEBUFFERS
- framebuffers.resize(swapChain->GetCount());
- for (size_t i = 0; i < swapChain->GetCount(); i++) {
- std::vector attachments = {
- imageViews[i],
- depthImageView
- };
-
- VkFramebufferCreateInfo framebufferInfo = {};
- framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
- framebufferInfo.renderPass = renderPass;
- framebufferInfo.attachmentCount = static_cast(attachments.size());
- framebufferInfo.pAttachments = attachments.data();
- framebufferInfo.width = swapChain->GetVkExtent().width;
- framebufferInfo.height = swapChain->GetVkExtent().height;
- framebufferInfo.layers = 1;
-
- if (vkCreateFramebuffer(logicalDevice, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create framebuffer");
- }
-
- }
+ imageViews.resize(swapChain->GetCount());
+
+ for (uint32_t i = 0; i < swapChain->GetCount(); i++) {
+ // --- Create an image view for each swap chain image ---
+ VkImageViewCreateInfo createInfo = {};
+ createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+ createInfo.image = swapChain->GetVkImage(i);
+
+ // Specify how the image data should be interpreted
+ createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+ createInfo.format = swapChain->GetVkImageFormat();
+
+ // Specify color channel mappings (can be used for swizzling)
+ createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+ createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+ createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+ createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+
+ // Describe the image's purpose and which part of the image should be accessed
+ createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ createInfo.subresourceRange.baseMipLevel = 0;
+ createInfo.subresourceRange.levelCount = 1;
+ createInfo.subresourceRange.baseArrayLayer = 0;
+ createInfo.subresourceRange.layerCount = 1;
+
+ // Create the image view
+ if (vkCreateImageView(logicalDevice, &createInfo, nullptr, &imageViews[i]) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create image views");
+ }
+ }
+
+ VkFormat depthFormat = device->GetInstance()->GetSupportedFormat({ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT }, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
+ // CREATE DEPTH IMAGE
+ Image::Create(device,
+ swapChain->GetVkExtent().width,
+ swapChain->GetVkExtent().height,
+ depthFormat,
+ VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+ depthImage,
+ depthImageMemory
+ );
+
+ depthImageView = Image::CreateView(device, depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT);
+
+ // Transition the image for use as depth-stencil
+ Image::TransitionLayout(device, graphicsCommandPool, depthImage, depthFormat, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+
+
+ // CREATE FRAMEBUFFERS
+ framebuffers.resize(swapChain->GetCount());
+ for (size_t i = 0; i < swapChain->GetCount(); i++) {
+ std::vector attachments = {
+ imageViews[i],
+ depthImageView
+ };
+
+ VkFramebufferCreateInfo framebufferInfo = {};
+ framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+ framebufferInfo.renderPass = renderPass;
+ framebufferInfo.attachmentCount = static_cast(attachments.size());
+ framebufferInfo.pAttachments = attachments.data();
+ framebufferInfo.width = swapChain->GetVkExtent().width;
+ framebufferInfo.height = swapChain->GetVkExtent().height;
+ framebufferInfo.layers = 1;
+
+ if (vkCreateFramebuffer(logicalDevice, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create framebuffer");
+ }
+
+ }
}
void Renderer::DestroyFrameResources() {
- for (size_t i = 0; i < imageViews.size(); i++) {
- vkDestroyImageView(logicalDevice, imageViews[i], nullptr);
- }
+ for (size_t i = 0; i < imageViews.size(); i++) {
+ vkDestroyImageView(logicalDevice, imageViews[i], nullptr);
+ }
- vkDestroyImageView(logicalDevice, depthImageView, nullptr);
- vkFreeMemory(logicalDevice, depthImageMemory, nullptr);
- vkDestroyImage(logicalDevice, depthImage, nullptr);
+ vkDestroyImageView(logicalDevice, depthImageView, nullptr);
+ vkFreeMemory(logicalDevice, depthImageMemory, nullptr);
+ vkDestroyImage(logicalDevice, depthImage, nullptr);
- for (size_t i = 0; i < framebuffers.size(); i++) {
- vkDestroyFramebuffer(logicalDevice, framebuffers[i], nullptr);
- }
+ for (size_t i = 0; i < framebuffers.size(); i++) {
+ vkDestroyFramebuffer(logicalDevice, framebuffers[i], nullptr);
+ }
}
void Renderer::RecreateFrameResources() {
- vkDestroyPipeline(logicalDevice, graphicsPipeline, nullptr);
- vkDestroyPipeline(logicalDevice, grassPipeline, nullptr);
- vkDestroyPipelineLayout(logicalDevice, graphicsPipelineLayout, nullptr);
- vkDestroyPipelineLayout(logicalDevice, grassPipelineLayout, nullptr);
- vkFreeCommandBuffers(logicalDevice, graphicsCommandPool, static_cast(commandBuffers.size()), commandBuffers.data());
-
- DestroyFrameResources();
- CreateFrameResources();
- CreateGraphicsPipeline();
- CreateGrassPipeline();
- RecordCommandBuffers();
+ vkDestroyPipeline(logicalDevice, graphicsPipeline, nullptr);
+ vkDestroyPipeline(logicalDevice, grassPipeline, nullptr);
+ vkDestroyPipelineLayout(logicalDevice, graphicsPipelineLayout, nullptr);
+ vkDestroyPipelineLayout(logicalDevice, grassPipelineLayout, nullptr);
+ vkFreeCommandBuffers(logicalDevice, graphicsCommandPool, static_cast(commandBuffers.size()), commandBuffers.data());
+
+ DestroyFrameResources();
+ CreateFrameResources();
+ CreateGraphicsPipeline();
+ CreateGrassPipeline();
+ RecordCommandBuffers();
}
void Renderer::RecordComputeCommandBuffer() {
- // Specify the command pool and number of buffers to allocate
- VkCommandBufferAllocateInfo allocInfo = {};
- allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
- allocInfo.commandPool = computeCommandPool;
- allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
- allocInfo.commandBufferCount = 1;
-
- if (vkAllocateCommandBuffers(logicalDevice, &allocInfo, &computeCommandBuffer) != VK_SUCCESS) {
- throw std::runtime_error("Failed to allocate command buffers");
- }
-
- VkCommandBufferBeginInfo beginInfo = {};
- beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
- beginInfo.pInheritanceInfo = nullptr;
-
- // ~ Start recording ~
- if (vkBeginCommandBuffer(computeCommandBuffer, &beginInfo) != VK_SUCCESS) {
- throw std::runtime_error("Failed to begin recording compute command buffer");
- }
-
- // Bind to the compute pipeline
- vkCmdBindPipeline(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipeline);
-
- // Bind camera descriptor set
- vkCmdBindDescriptorSets(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 0, 1, &cameraDescriptorSet, 0, nullptr);
-
- // Bind descriptor set for time uniforms
- 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
-
- // ~ End recording ~
- if (vkEndCommandBuffer(computeCommandBuffer) != VK_SUCCESS) {
- throw std::runtime_error("Failed to record compute command buffer");
- }
+ // Specify the command pool and number of buffers to allocate
+ VkCommandBufferAllocateInfo allocInfo = {};
+ allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+ allocInfo.commandPool = computeCommandPool;
+ allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+ allocInfo.commandBufferCount = 1;
+
+ if (vkAllocateCommandBuffers(logicalDevice, &allocInfo, &computeCommandBuffer) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to allocate command buffers");
+ }
+
+ VkCommandBufferBeginInfo beginInfo = {};
+ beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+ beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+ beginInfo.pInheritanceInfo = nullptr;
+
+ // ~ Start recording ~
+ if (vkBeginCommandBuffer(computeCommandBuffer, &beginInfo) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to begin recording compute command buffer");
+ }
+
+ // Bind to the compute pipeline
+ vkCmdBindPipeline(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipeline);
+
+ // Bind camera descriptor set
+ vkCmdBindDescriptorSets(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 0, 1, &cameraDescriptorSet, 0, nullptr);
+
+ // Bind descriptor set for time uniforms
+ 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 (int i = 0; i < scene->GetBlades().size(); ++i) {
+ vkCmdBindDescriptorSets(computeCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 2, 1, &computeDescriptorSet[i], 0, nullptr);
+ vkCmdDispatch(computeCommandBuffer, (NUM_BLADES + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE, 1, 1);
+ }
+
+
+ // ~ End recording ~
+ if (vkEndCommandBuffer(computeCommandBuffer) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to record compute command buffer");
+ }
}
void Renderer::RecordCommandBuffers() {
- commandBuffers.resize(swapChain->GetCount());
-
- // Specify the command pool and number of buffers to allocate
- VkCommandBufferAllocateInfo allocInfo = {};
- allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
- allocInfo.commandPool = graphicsCommandPool;
- allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
- allocInfo.commandBufferCount = static_cast(commandBuffers.size());
-
- if (vkAllocateCommandBuffers(logicalDevice, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {
- throw std::runtime_error("Failed to allocate command buffers");
- }
-
- // Start command buffer recording
- for (size_t i = 0; i < commandBuffers.size(); i++) {
- VkCommandBufferBeginInfo beginInfo = {};
- beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
- beginInfo.pInheritanceInfo = nullptr;
-
- // ~ Start recording ~
- if (vkBeginCommandBuffer(commandBuffers[i], &beginInfo) != VK_SUCCESS) {
- throw std::runtime_error("Failed to begin recording command buffer");
- }
-
- // Begin the render pass
- VkRenderPassBeginInfo renderPassInfo = {};
- renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
- renderPassInfo.renderPass = renderPass;
- renderPassInfo.framebuffer = framebuffers[i];
- renderPassInfo.renderArea.offset = { 0, 0 };
- renderPassInfo.renderArea.extent = swapChain->GetVkExtent();
-
- std::array clearValues = {};
- clearValues[0].color = { 0.0f, 0.0f, 0.0f, 1.0f };
- clearValues[1].depthStencil = { 1.0f, 0 };
- renderPassInfo.clearValueCount = static_cast(clearValues.size());
- renderPassInfo.pClearValues = clearValues.data();
-
- std::vector barriers(scene->GetBlades().size());
- for (uint32_t j = 0; j < barriers.size(); ++j) {
- barriers[j].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
- barriers[j].srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
- barriers[j].dstAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
- barriers[j].srcQueueFamilyIndex = device->GetQueueIndex(QueueFlags::Compute);
- barriers[j].dstQueueFamilyIndex = device->GetQueueIndex(QueueFlags::Graphics);
- barriers[j].buffer = scene->GetBlades()[j]->GetNumBladesBuffer();
- barriers[j].offset = 0;
- barriers[j].size = sizeof(BladeDrawIndirect);
- }
-
- vkCmdPipelineBarrier(commandBuffers[i], VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, 0, 0, nullptr, barriers.size(), barriers.data(), 0, nullptr);
-
- // Bind the camera descriptor set. This is set 0 in all pipelines so it will be inherited
- vkCmdBindDescriptorSets(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipelineLayout, 0, 1, &cameraDescriptorSet, 0, nullptr);
-
- vkCmdBeginRenderPass(commandBuffers[i], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
-
- // Bind the graphics pipeline
- vkCmdBindPipeline(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
-
- for (uint32_t j = 0; j < scene->GetModels().size(); ++j) {
- // Bind the vertex and index buffers
- VkBuffer vertexBuffers[] = { scene->GetModels()[j]->getVertexBuffer() };
- VkDeviceSize offsets[] = { 0 };
- vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, vertexBuffers, offsets);
-
- vkCmdBindIndexBuffer(commandBuffers[i], scene->GetModels()[j]->getIndexBuffer(), 0, VK_INDEX_TYPE_UINT32);
-
- // Bind the descriptor set for each model
- vkCmdBindDescriptorSets(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipelineLayout, 1, 1, &modelDescriptorSets[j], 0, nullptr);
-
- // Draw
- std::vector indices = scene->GetModels()[j]->getIndices();
- vkCmdDrawIndexed(commandBuffers[i], static_cast(indices.size()), 1, 0, 0, 0);
- }
-
- // Bind the grass pipeline
- vkCmdBindPipeline(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, grassPipeline);
-
- for (uint32_t j = 0; j < scene->GetBlades().size(); ++j) {
- VkBuffer vertexBuffers[] = { scene->GetBlades()[j]->GetCulledBladesBuffer() };
- VkDeviceSize offsets[] = { 0 };
- // TODO: Uncomment this when the buffers are populated
- // vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, vertexBuffers, offsets);
-
- // TODO: Bind the descriptor set for each grass blades model
-
- // Draw
- // TODO: Uncomment this when the buffers are populated
- // vkCmdDrawIndirect(commandBuffers[i], scene->GetBlades()[j]->GetNumBladesBuffer(), 0, 1, sizeof(BladeDrawIndirect));
- }
-
- // End render pass
- vkCmdEndRenderPass(commandBuffers[i]);
-
- // ~ End recording ~
- if (vkEndCommandBuffer(commandBuffers[i]) != VK_SUCCESS) {
- throw std::runtime_error("Failed to record command buffer");
- }
- }
+ commandBuffers.resize(swapChain->GetCount());
+
+ // Specify the command pool and number of buffers to allocate
+ VkCommandBufferAllocateInfo allocInfo = {};
+ allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+ allocInfo.commandPool = graphicsCommandPool;
+ allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+ allocInfo.commandBufferCount = static_cast(commandBuffers.size());
+
+ if (vkAllocateCommandBuffers(logicalDevice, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to allocate command buffers");
+ }
+
+ // Start command buffer recording
+ for (size_t i = 0; i < commandBuffers.size(); i++) {
+ VkCommandBufferBeginInfo beginInfo = {};
+ beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+ beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+ beginInfo.pInheritanceInfo = nullptr;
+
+ // ~ Start recording ~
+ if (vkBeginCommandBuffer(commandBuffers[i], &beginInfo) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to begin recording command buffer");
+ }
+
+ // Begin the render pass
+ VkRenderPassBeginInfo renderPassInfo = {};
+ renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+ renderPassInfo.renderPass = renderPass;
+ renderPassInfo.framebuffer = framebuffers[i];
+ renderPassInfo.renderArea.offset = { 0, 0 };
+ renderPassInfo.renderArea.extent = swapChain->GetVkExtent();
+
+ std::array clearValues = {};
+ clearValues[0].color = { 0.0f, 0.0f, 0.0f, 1.0f };
+ clearValues[1].depthStencil = { 1.0f, 0 };
+ renderPassInfo.clearValueCount = static_cast(clearValues.size());
+ renderPassInfo.pClearValues = clearValues.data();
+
+ std::vector barriers(scene->GetBlades().size());
+ for (uint32_t j = 0; j < barriers.size(); ++j) {
+ barriers[j].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+ barriers[j].srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
+ barriers[j].dstAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
+ barriers[j].srcQueueFamilyIndex = device->GetQueueIndex(QueueFlags::Compute);
+ barriers[j].dstQueueFamilyIndex = device->GetQueueIndex(QueueFlags::Graphics);
+ barriers[j].buffer = scene->GetBlades()[j]->GetNumBladesBuffer();
+ barriers[j].offset = 0;
+ barriers[j].size = sizeof(BladeDrawIndirect);
+ }
+
+ vkCmdPipelineBarrier(commandBuffers[i], VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, 0, 0, nullptr, barriers.size(), barriers.data(), 0, nullptr);
+
+ // Bind the camera descriptor set. This is set 0 in all pipelines so it will be inherited
+ vkCmdBindDescriptorSets(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipelineLayout, 0, 1, &cameraDescriptorSet, 0, nullptr);
+
+ vkCmdBeginRenderPass(commandBuffers[i], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+ // Bind the graphics pipeline
+ vkCmdBindPipeline(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
+
+ for (uint32_t j = 0; j < scene->GetModels().size(); ++j) {
+ // Bind the vertex and index buffers
+ VkBuffer vertexBuffers[] = { scene->GetModels()[j]->getVertexBuffer() };
+ VkDeviceSize offsets[] = { 0 };
+ vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, vertexBuffers, offsets);
+
+ vkCmdBindIndexBuffer(commandBuffers[i], scene->GetModels()[j]->getIndexBuffer(), 0, VK_INDEX_TYPE_UINT32);
+
+ // Bind the descriptor set for each model
+ vkCmdBindDescriptorSets(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipelineLayout, 1, 1, &modelDescriptorSets[j], 0, nullptr);
+
+ // Draw
+ std::vector indices = scene->GetModels()[j]->getIndices();
+ vkCmdDrawIndexed(commandBuffers[i], static_cast(indices.size()), 1, 0, 0, 0);
+ }
+
+ // Bind the grass pipeline
+ vkCmdBindPipeline(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, grassPipeline);
+
+ for (uint32_t j = 0; j < scene->GetBlades().size(); ++j) {
+ VkBuffer vertexBuffers[] = { scene->GetBlades()[j]->GetCulledBladesBuffer() };
+ VkDeviceSize offsets[] = { 0 };
+ // TODO: Uncomment this when the buffers are populated
+ 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, 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));
+ }
+
+ // End render pass
+ vkCmdEndRenderPass(commandBuffers[i]);
+
+ // ~ End recording ~
+ if (vkEndCommandBuffer(commandBuffers[i]) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to record command buffer");
+ }
+ }
}
void Renderer::Frame() {
- VkSubmitInfo computeSubmitInfo = {};
- computeSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+ VkSubmitInfo computeSubmitInfo = {};
+ computeSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
- computeSubmitInfo.commandBufferCount = 1;
- computeSubmitInfo.pCommandBuffers = &computeCommandBuffer;
+ computeSubmitInfo.commandBufferCount = 1;
+ computeSubmitInfo.pCommandBuffers = &computeCommandBuffer;
- if (vkQueueSubmit(device->GetQueue(QueueFlags::Compute), 1, &computeSubmitInfo, VK_NULL_HANDLE) != VK_SUCCESS) {
- throw std::runtime_error("Failed to submit draw command buffer");
- }
+ if (vkQueueSubmit(device->GetQueue(QueueFlags::Compute), 1, &computeSubmitInfo, VK_NULL_HANDLE) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to submit draw command buffer");
+ }
- if (!swapChain->Acquire()) {
- RecreateFrameResources();
- return;
- }
+ if (!swapChain->Acquire()) {
+ RecreateFrameResources();
+ return;
+ }
- // Submit the command buffer
- VkSubmitInfo submitInfo = {};
- submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+ // Submit the command buffer
+ VkSubmitInfo submitInfo = {};
+ submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
- VkSemaphore waitSemaphores[] = { swapChain->GetImageAvailableVkSemaphore() };
- VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
- submitInfo.waitSemaphoreCount = 1;
- submitInfo.pWaitSemaphores = waitSemaphores;
- submitInfo.pWaitDstStageMask = waitStages;
+ VkSemaphore waitSemaphores[] = { swapChain->GetImageAvailableVkSemaphore() };
+ VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
+ submitInfo.waitSemaphoreCount = 1;
+ submitInfo.pWaitSemaphores = waitSemaphores;
+ submitInfo.pWaitDstStageMask = waitStages;
- submitInfo.commandBufferCount = 1;
- submitInfo.pCommandBuffers = &commandBuffers[swapChain->GetIndex()];
+ submitInfo.commandBufferCount = 1;
+ submitInfo.pCommandBuffers = &commandBuffers[swapChain->GetIndex()];
- VkSemaphore signalSemaphores[] = { swapChain->GetRenderFinishedVkSemaphore() };
- submitInfo.signalSemaphoreCount = 1;
- submitInfo.pSignalSemaphores = signalSemaphores;
+ VkSemaphore signalSemaphores[] = { swapChain->GetRenderFinishedVkSemaphore() };
+ submitInfo.signalSemaphoreCount = 1;
+ submitInfo.pSignalSemaphores = signalSemaphores;
- if (vkQueueSubmit(device->GetQueue(QueueFlags::Graphics), 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) {
- throw std::runtime_error("Failed to submit draw command buffer");
- }
+ if (vkQueueSubmit(device->GetQueue(QueueFlags::Graphics), 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to submit draw command buffer");
+ }
- if (!swapChain->Present()) {
- RecreateFrameResources();
- }
+ if (!swapChain->Present()) {
+ RecreateFrameResources();
+ }
}
Renderer::~Renderer() {
- vkDeviceWaitIdle(logicalDevice);
+ vkDeviceWaitIdle(logicalDevice);
+
+ // TODO: destroy any resources you created
+
+ vkFreeCommandBuffers(logicalDevice, graphicsCommandPool, static_cast(commandBuffers.size()), commandBuffers.data());
+ vkFreeCommandBuffers(logicalDevice, computeCommandPool, 1, &computeCommandBuffer);
- // TODO: destroy any resources you created
+ vkDestroyPipeline(logicalDevice, graphicsPipeline, nullptr);
+ vkDestroyPipeline(logicalDevice, grassPipeline, nullptr);
+ vkDestroyPipeline(logicalDevice, computePipeline, nullptr);
- vkFreeCommandBuffers(logicalDevice, graphicsCommandPool, static_cast(commandBuffers.size()), commandBuffers.data());
- vkFreeCommandBuffers(logicalDevice, computeCommandPool, 1, &computeCommandBuffer);
-
- vkDestroyPipeline(logicalDevice, graphicsPipeline, nullptr);
- vkDestroyPipeline(logicalDevice, grassPipeline, nullptr);
- vkDestroyPipeline(logicalDevice, computePipeline, nullptr);
+ vkDestroyPipelineLayout(logicalDevice, graphicsPipelineLayout, nullptr);
+ vkDestroyPipelineLayout(logicalDevice, grassPipelineLayout, nullptr);
+ vkDestroyPipelineLayout(logicalDevice, computePipelineLayout, nullptr);
- vkDestroyPipelineLayout(logicalDevice, graphicsPipelineLayout, nullptr);
- vkDestroyPipelineLayout(logicalDevice, grassPipelineLayout, nullptr);
- vkDestroyPipelineLayout(logicalDevice, computePipelineLayout, nullptr);
+ vkDestroyDescriptorSetLayout(logicalDevice, cameraDescriptorSetLayout, nullptr);
+ vkDestroyDescriptorSetLayout(logicalDevice, modelDescriptorSetLayout, nullptr);
+ vkDestroyDescriptorSetLayout(logicalDevice, timeDescriptorSetLayout, nullptr);
- vkDestroyDescriptorSetLayout(logicalDevice, cameraDescriptorSetLayout, nullptr);
- vkDestroyDescriptorSetLayout(logicalDevice, modelDescriptorSetLayout, nullptr);
- vkDestroyDescriptorSetLayout(logicalDevice, timeDescriptorSetLayout, nullptr);
+ vkDestroyDescriptorSetLayout(logicalDevice, computeDescriptorSetLayout, nullptr);
- vkDestroyDescriptorPool(logicalDevice, descriptorPool, nullptr);
+ vkDestroyDescriptorPool(logicalDevice, descriptorPool, nullptr);
- vkDestroyRenderPass(logicalDevice, renderPass, nullptr);
- DestroyFrameResources();
- vkDestroyCommandPool(logicalDevice, computeCommandPool, nullptr);
- vkDestroyCommandPool(logicalDevice, graphicsCommandPool, nullptr);
+ vkDestroyRenderPass(logicalDevice, renderPass, nullptr);
+ DestroyFrameResources();
+ vkDestroyCommandPool(logicalDevice, computeCommandPool, nullptr);
+ vkDestroyCommandPool(logicalDevice, graphicsCommandPool, nullptr);
}
diff --git a/src/Renderer.h b/src/Renderer.h
index 95e025f..0b08467 100644
--- a/src/Renderer.h
+++ b/src/Renderer.h
@@ -7,76 +7,80 @@
class Renderer {
public:
- Renderer() = delete;
- Renderer(Device* device, SwapChain* swapChain, Scene* scene, Camera* camera);
- ~Renderer();
+ Renderer() = delete;
+ Renderer(Device* device, SwapChain* swapChain, Scene* scene, Camera* camera);
+ ~Renderer();
- void CreateCommandPools();
+ void CreateCommandPools();
- void CreateRenderPass();
+ void CreateRenderPass();
- void CreateCameraDescriptorSetLayout();
- void CreateModelDescriptorSetLayout();
- void CreateTimeDescriptorSetLayout();
- void CreateComputeDescriptorSetLayout();
+ void CreateCameraDescriptorSetLayout();
+ void CreateModelDescriptorSetLayout();
+ void CreateTimeDescriptorSetLayout();
+ void CreateComputeDescriptorSetLayout();
- void CreateDescriptorPool();
+ void CreateDescriptorPool();
- void CreateCameraDescriptorSet();
- void CreateModelDescriptorSets();
- void CreateGrassDescriptorSets();
- void CreateTimeDescriptorSet();
- void CreateComputeDescriptorSets();
+ void CreateCameraDescriptorSet();
+ void CreateModelDescriptorSets();
+ void CreateGrassDescriptorSets();
+ void CreateTimeDescriptorSet();
+ void CreateComputeDescriptorSets();
- void CreateGraphicsPipeline();
- void CreateGrassPipeline();
- void CreateComputePipeline();
+ void CreateGraphicsPipeline();
+ void CreateGrassPipeline();
+ void CreateComputePipeline();
- void CreateFrameResources();
- void DestroyFrameResources();
- void RecreateFrameResources();
+ void CreateFrameResources();
+ void DestroyFrameResources();
+ void RecreateFrameResources();
- void RecordCommandBuffers();
- void RecordComputeCommandBuffer();
+ void RecordCommandBuffers();
+ void RecordComputeCommandBuffer();
- void Frame();
+ void Frame();
private:
- Device* device;
- VkDevice logicalDevice;
- SwapChain* swapChain;
- Scene* scene;
- Camera* camera;
-
- VkCommandPool graphicsCommandPool;
- VkCommandPool computeCommandPool;
-
- VkRenderPass renderPass;
-
- VkDescriptorSetLayout cameraDescriptorSetLayout;
- VkDescriptorSetLayout modelDescriptorSetLayout;
- VkDescriptorSetLayout timeDescriptorSetLayout;
-
- VkDescriptorPool descriptorPool;
-
- VkDescriptorSet cameraDescriptorSet;
- std::vector modelDescriptorSets;
- VkDescriptorSet timeDescriptorSet;
-
- VkPipelineLayout graphicsPipelineLayout;
- VkPipelineLayout grassPipelineLayout;
- VkPipelineLayout computePipelineLayout;
-
- VkPipeline graphicsPipeline;
- VkPipeline grassPipeline;
- VkPipeline computePipeline;
-
- std::vector imageViews;
- VkImage depthImage;
- VkDeviceMemory depthImageMemory;
- VkImageView depthImageView;
- std::vector framebuffers;
-
- std::vector commandBuffers;
- VkCommandBuffer computeCommandBuffer;
+ Device* device;
+ VkDevice logicalDevice;
+ SwapChain* swapChain;
+ Scene* scene;
+ Camera* camera;
+
+ VkCommandPool graphicsCommandPool;
+ VkCommandPool computeCommandPool;
+
+ VkRenderPass renderPass;
+
+ VkDescriptorSetLayout cameraDescriptorSetLayout;
+ VkDescriptorSetLayout modelDescriptorSetLayout;
+ VkDescriptorSetLayout timeDescriptorSetLayout;
+ VkDescriptorSetLayout computeDescriptorSetLayout;
+
+ VkDescriptorPool descriptorPool;
+
+ VkDescriptorSet cameraDescriptorSet;
+ std::vector modelDescriptorSets;
+ std::vector grassDescriptorSets;
+ std::vector computeDescriptorSet;
+
+ VkDescriptorSet timeDescriptorSet;
+
+ VkPipelineLayout graphicsPipelineLayout;
+ VkPipelineLayout grassPipelineLayout;
+ VkPipelineLayout computePipelineLayout;
+
+ VkPipeline graphicsPipeline;
+ VkPipeline grassPipeline;
+ VkPipeline computePipeline;
+
+ std::vector imageViews;
+ VkImage depthImage;
+ VkDeviceMemory depthImageMemory;
+ VkImageView depthImageView;
+ std::vector framebuffers;
+
+ std::vector commandBuffers;
+ VkCommandBuffer computeCommandBuffer;
};
diff --git a/src/main.cpp b/src/main.cpp
index 8bf822b..f95ef84 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -12,156 +12,158 @@ Renderer* renderer;
Camera* camera;
namespace {
- void resizeCallback(GLFWwindow* window, int width, int height) {
- if (width == 0 || height == 0) return;
-
- vkDeviceWaitIdle(device->GetVkDevice());
- swapChain->Recreate();
- renderer->RecreateFrameResources();
- }
-
- bool leftMouseDown = false;
- bool rightMouseDown = false;
- double previousX = 0.0;
- double previousY = 0.0;
-
- void mouseDownCallback(GLFWwindow* window, int button, int action, int mods) {
- if (button == GLFW_MOUSE_BUTTON_LEFT) {
- if (action == GLFW_PRESS) {
- leftMouseDown = true;
- glfwGetCursorPos(window, &previousX, &previousY);
- }
- else if (action == GLFW_RELEASE) {
- leftMouseDown = false;
- }
- } else if (button == GLFW_MOUSE_BUTTON_RIGHT) {
- if (action == GLFW_PRESS) {
- rightMouseDown = true;
- glfwGetCursorPos(window, &previousX, &previousY);
- }
- else if (action == GLFW_RELEASE) {
- rightMouseDown = false;
- }
- }
- }
-
- void mouseMoveCallback(GLFWwindow* window, double xPosition, double yPosition) {
- if (leftMouseDown) {
- double sensitivity = 0.5;
- float deltaX = static_cast((previousX - xPosition) * sensitivity);
- float deltaY = static_cast((previousY - yPosition) * sensitivity);
-
- camera->UpdateOrbit(deltaX, deltaY, 0.0f);
-
- previousX = xPosition;
- previousY = yPosition;
- } else if (rightMouseDown) {
- double deltaZ = static_cast((previousY - yPosition) * 0.05);
-
- camera->UpdateOrbit(0.0f, 0.0f, deltaZ);
-
- previousY = yPosition;
- }
- }
+ void resizeCallback(GLFWwindow* window, int width, int height) {
+ if (width == 0 || height == 0) return;
+
+ vkDeviceWaitIdle(device->GetVkDevice());
+ swapChain->Recreate();
+ renderer->RecreateFrameResources();
+ }
+
+ bool leftMouseDown = false;
+ bool rightMouseDown = false;
+ double previousX = 0.0;
+ double previousY = 0.0;
+
+ void mouseDownCallback(GLFWwindow* window, int button, int action, int mods) {
+ if (button == GLFW_MOUSE_BUTTON_LEFT) {
+ if (action == GLFW_PRESS) {
+ leftMouseDown = true;
+ glfwGetCursorPos(window, &previousX, &previousY);
+ }
+ else if (action == GLFW_RELEASE) {
+ leftMouseDown = false;
+ }
+ }
+ else if (button == GLFW_MOUSE_BUTTON_RIGHT) {
+ if (action == GLFW_PRESS) {
+ rightMouseDown = true;
+ glfwGetCursorPos(window, &previousX, &previousY);
+ }
+ else if (action == GLFW_RELEASE) {
+ rightMouseDown = false;
+ }
+ }
+ }
+
+ void mouseMoveCallback(GLFWwindow* window, double xPosition, double yPosition) {
+ if (leftMouseDown) {
+ double sensitivity = 0.5;
+ float deltaX = static_cast((previousX - xPosition) * sensitivity);
+ float deltaY = static_cast((previousY - yPosition) * sensitivity);
+
+ camera->UpdateOrbit(deltaX, deltaY, 0.0f);
+
+ previousX = xPosition;
+ previousY = yPosition;
+ }
+ else if (rightMouseDown) {
+ double deltaZ = static_cast((previousY - yPosition) * 0.05);
+
+ camera->UpdateOrbit(0.0f, 0.0f, deltaZ);
+
+ previousY = yPosition;
+ }
+ }
}
int main() {
- static constexpr char* applicationName = "Vulkan Grass Rendering";
- InitializeWindow(640, 480, applicationName);
-
- unsigned int glfwExtensionCount = 0;
- const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
-
- Instance* instance = new Instance(applicationName, glfwExtensionCount, glfwExtensions);
-
- VkSurfaceKHR surface;
- if (glfwCreateWindowSurface(instance->GetVkInstance(), GetGLFWWindow(), nullptr, &surface) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create window surface");
- }
-
- instance->PickPhysicalDevice({ VK_KHR_SWAPCHAIN_EXTENSION_NAME }, QueueFlagBit::GraphicsBit | QueueFlagBit::TransferBit | QueueFlagBit::ComputeBit | QueueFlagBit::PresentBit, surface);
-
- VkPhysicalDeviceFeatures deviceFeatures = {};
- deviceFeatures.tessellationShader = VK_TRUE;
- deviceFeatures.fillModeNonSolid = VK_TRUE;
- deviceFeatures.samplerAnisotropy = VK_TRUE;
-
- device = instance->CreateDevice(QueueFlagBit::GraphicsBit | QueueFlagBit::TransferBit | QueueFlagBit::ComputeBit | QueueFlagBit::PresentBit, deviceFeatures);
-
- swapChain = device->CreateSwapChain(surface, 5);
-
- camera = new Camera(device, 640.f / 480.f);
-
- VkCommandPoolCreateInfo transferPoolInfo = {};
- transferPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
- transferPoolInfo.queueFamilyIndex = device->GetInstance()->GetQueueFamilyIndices()[QueueFlags::Transfer];
- transferPoolInfo.flags = 0;
-
- VkCommandPool transferCommandPool;
- if (vkCreateCommandPool(device->GetVkDevice(), &transferPoolInfo, nullptr, &transferCommandPool) != VK_SUCCESS) {
- throw std::runtime_error("Failed to create command pool");
- }
-
- VkImage grassImage;
- VkDeviceMemory grassImageMemory;
- Image::FromFile(device,
- transferCommandPool,
- "images/grass.jpg",
- VK_FORMAT_R8G8B8A8_UNORM,
- VK_IMAGE_TILING_OPTIMAL,
- VK_IMAGE_USAGE_SAMPLED_BIT,
- VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
- VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
- grassImage,
- grassImageMemory
- );
-
- float planeDim = 15.f;
- float halfWidth = planeDim * 0.5f;
- Model* plane = new Model(device, transferCommandPool,
- {
- { { -halfWidth, 0.0f, halfWidth }, { 1.0f, 0.0f, 0.0f },{ 1.0f, 0.0f } },
- { { halfWidth, 0.0f, halfWidth }, { 0.0f, 1.0f, 0.0f },{ 0.0f, 0.0f } },
- { { halfWidth, 0.0f, -halfWidth }, { 0.0f, 0.0f, 1.0f },{ 0.0f, 1.0f } },
- { { -halfWidth, 0.0f, -halfWidth }, { 1.0f, 1.0f, 1.0f },{ 1.0f, 1.0f } }
- },
- { 0, 1, 2, 2, 3, 0 }
- );
- plane->SetTexture(grassImage);
-
- Blades* blades = new Blades(device, transferCommandPool, planeDim);
-
- vkDestroyCommandPool(device->GetVkDevice(), transferCommandPool, nullptr);
-
- Scene* scene = new Scene(device);
- scene->AddModel(plane);
- scene->AddBlades(blades);
-
- renderer = new Renderer(device, swapChain, scene, camera);
-
- glfwSetWindowSizeCallback(GetGLFWWindow(), resizeCallback);
- glfwSetMouseButtonCallback(GetGLFWWindow(), mouseDownCallback);
- glfwSetCursorPosCallback(GetGLFWWindow(), mouseMoveCallback);
-
- while (!ShouldQuit()) {
- glfwPollEvents();
- scene->UpdateTime();
- renderer->Frame();
- }
-
- vkDeviceWaitIdle(device->GetVkDevice());
-
- vkDestroyImage(device->GetVkDevice(), grassImage, nullptr);
- vkFreeMemory(device->GetVkDevice(), grassImageMemory, nullptr);
-
- delete scene;
- delete plane;
- delete blades;
- delete camera;
- delete renderer;
- delete swapChain;
- delete device;
- delete instance;
- DestroyWindow();
- return 0;
+ static constexpr char* applicationName = "Vulkan Grass Rendering";
+ InitializeWindow(1920, 1080, applicationName);
+
+ unsigned int glfwExtensionCount = 0;
+ const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+
+ Instance* instance = new Instance(applicationName, glfwExtensionCount, glfwExtensions);
+
+ VkSurfaceKHR surface;
+ if (glfwCreateWindowSurface(instance->GetVkInstance(), GetGLFWWindow(), nullptr, &surface) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create window surface");
+ }
+
+ instance->PickPhysicalDevice({ VK_KHR_SWAPCHAIN_EXTENSION_NAME }, QueueFlagBit::GraphicsBit | QueueFlagBit::TransferBit | QueueFlagBit::ComputeBit | QueueFlagBit::PresentBit, surface);
+
+ VkPhysicalDeviceFeatures deviceFeatures = {};
+ deviceFeatures.tessellationShader = VK_TRUE;
+ deviceFeatures.fillModeNonSolid = VK_TRUE;
+ deviceFeatures.samplerAnisotropy = VK_TRUE;
+
+ device = instance->CreateDevice(QueueFlagBit::GraphicsBit | QueueFlagBit::TransferBit | QueueFlagBit::ComputeBit | QueueFlagBit::PresentBit, deviceFeatures);
+
+ swapChain = device->CreateSwapChain(surface, 5);
+
+ camera = new Camera(device, 1920.f / 1080.f);
+
+ VkCommandPoolCreateInfo transferPoolInfo = {};
+ transferPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+ transferPoolInfo.queueFamilyIndex = device->GetInstance()->GetQueueFamilyIndices()[QueueFlags::Transfer];
+ transferPoolInfo.flags = 0;
+
+ VkCommandPool transferCommandPool;
+ if (vkCreateCommandPool(device->GetVkDevice(), &transferPoolInfo, nullptr, &transferCommandPool) != VK_SUCCESS) {
+ throw std::runtime_error("Failed to create command pool");
+ }
+
+ VkImage grassImage;
+ VkDeviceMemory grassImageMemory;
+ Image::FromFile(device,
+ transferCommandPool,
+ "images/grass.jpg",
+ VK_FORMAT_R8G8B8A8_UNORM,
+ VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_USAGE_SAMPLED_BIT,
+ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+ grassImage,
+ grassImageMemory
+ );
+
+ float planeDim = 15.f;
+ float halfWidth = planeDim * 0.5f;
+ Model* plane = new Model(device, transferCommandPool,
+ {
+ { { -halfWidth, 0.0f, halfWidth }, { 1.0f, 0.0f, 0.0f },{ 1.0f, 0.0f } },
+ { { halfWidth, 0.0f, halfWidth }, { 0.0f, 1.0f, 0.0f },{ 0.0f, 0.0f } },
+ { { halfWidth, 0.0f, -halfWidth }, { 0.0f, 0.0f, 1.0f },{ 0.0f, 1.0f } },
+ { { -halfWidth, 0.0f, -halfWidth }, { 1.0f, 1.0f, 1.0f },{ 1.0f, 1.0f } }
+ },
+ { 0, 1, 2, 2, 3, 0 }
+ );
+ plane->SetTexture(grassImage);
+
+ Blades* blades = new Blades(device, transferCommandPool, planeDim);
+
+ vkDestroyCommandPool(device->GetVkDevice(), transferCommandPool, nullptr);
+
+ Scene* scene = new Scene(device);
+ scene->AddModel(plane);
+ scene->AddBlades(blades);
+
+ renderer = new Renderer(device, swapChain, scene, camera);
+
+ glfwSetWindowSizeCallback(GetGLFWWindow(), resizeCallback);
+ glfwSetMouseButtonCallback(GetGLFWWindow(), mouseDownCallback);
+ glfwSetCursorPosCallback(GetGLFWWindow(), mouseMoveCallback);
+
+ while (!ShouldQuit()) {
+ glfwPollEvents();
+ scene->UpdateTime();
+ renderer->Frame();
+ }
+
+ vkDeviceWaitIdle(device->GetVkDevice());
+
+ vkDestroyImage(device->GetVkDevice(), grassImage, nullptr);
+ vkFreeMemory(device->GetVkDevice(), grassImageMemory, nullptr);
+
+ delete scene;
+ delete plane;
+ delete blades;
+ delete camera;
+ delete renderer;
+ delete swapChain;
+ delete device;
+ delete instance;
+ DestroyWindow();
+ return 0;
}
diff --git a/src/shaders/compute.comp b/src/shaders/compute.comp
index 0fd0224..531d742 100644
--- a/src/shaders/compute.comp
+++ b/src/shaders/compute.comp
@@ -2,11 +2,118 @@
#extension GL_ARB_separate_shader_objects : enable
#define WORKGROUP_SIZE 32
+
+
+// ------------------------------------------------------------
+// 3D Simplex Noise (GLSL 450) - compatible with Vulkan
+// Adapted from Ashima Arts / Stefan Gustavson
+// ------------------------------------------------------------
+
+vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+
+vec4 permute(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }
+
+vec4 taylorInvSqrt(vec4 r) {
+ return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+// ------------------------------------------------------------
+// 3D Simplex Noise
+// ------------------------------------------------------------
+float snoise(vec3 v)
+{
+ const vec2 C = vec2(1.0 / 6.0, 1.0 / 3.0);
+
+ // First corner
+ vec3 i = floor(v + dot(v, C.yyy));
+ vec3 x0 = v - i + dot(i, C.xxx);
+
+ // Other corners
+ vec3 g = step(x0.yzx, x0.xyz);
+ vec3 l = 1.0 - g;
+ vec3 i1 = min(g.xyz, l.zxy);
+ vec3 i2 = max(g.xyz, l.zxy);
+
+ // Offsets for remaining corners
+ vec3 x1 = x0 - i1 + C.xxx;
+ vec3 x2 = x0 - i2 + C.yyy;
+ vec3 x3 = x0 - 0.5;
+
+ // Permutations
+ i = mod289(i);
+ vec4 p = permute(
+ permute(
+ permute(i.z + vec4(0.0, i1.z, i2.z, 1.0))
+ + i.y + vec4(0.0, i1.y, i2.y, 1.0))
+ + i.x + vec4(0.0, i1.x, i2.x, 1.0)
+ );
+
+ // Gradients: mapped onto an octahedron
+ vec4 j = p - 49.0 * floor(p / 49.0);
+
+ vec4 x_ = floor(j / 7.0);
+ vec4 y_ = floor(j - 7.0 * x_); // mod(j,7)
+
+ vec4 x = (x_ * 2.0 + 0.5) / 7.0 - 1.0;
+ vec4 y = (y_ * 2.0 + 0.5) / 7.0 - 1.0;
+ vec4 h = 1.0 - abs(x) - abs(y);
+
+ vec4 b0 = vec4(x.xy, y.xy);
+ vec4 b1 = vec4(x.zw, y.zw);
+
+ vec4 s0 = floor(b0) * 2.0 + 1.0;
+ vec4 s1 = floor(b1) * 2.0 + 1.0;
+ vec4 sh = -step(h, vec4(0.0));
+
+ vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+ vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+
+ vec3 g0 = vec3(a0.xy, h.x);
+ vec3 g1 = vec3(a0.zw, h.y);
+ vec3 g2 = vec3(a1.xy, h.z);
+ vec3 g3 = vec3(a1.zw, h.w);
+
+ // Normalize gradients
+ vec4 norm = taylorInvSqrt(vec4(
+ dot(g0, g0),
+ dot(g1, g1),
+ dot(g2, g2),
+ dot(g3, g3)
+ ));
+ g0 *= norm.x;
+ g1 *= norm.y;
+ g2 *= norm.z;
+ g3 *= norm.w;
+
+ // Mix final noise value
+ vec4 m = max(0.6 - vec4(
+ dot(x0, x0),
+ dot(x1, x1),
+ dot(x2, x2),
+ dot(x3, x3)
+ ), 0.0);
+ m = m * m;
+ m = m * m;
+
+ vec4 px = vec4(
+ dot(x0, g0),
+ dot(x1, g1),
+ dot(x2, g2),
+ dot(x3, g3)
+ );
+
+ return 42.0 * dot(m, px);
+}
+
+
+
layout(local_size_x = WORKGROUP_SIZE, local_size_y = 1, local_size_z = 1) in;
layout(set = 0, binding = 0) uniform CameraBufferObject {
mat4 view;
mat4 proj;
+ vec4 pos;
} camera;
layout(set = 1, binding = 0) uniform Time {
@@ -21,36 +128,122 @@ struct Blade {
vec4 up;
};
-// TODO: Add bindings to:
-// 1. Store the input blades
-// 2. Write out the culled blades
-// 3. Write the total number of blades remaining
-
-// 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 InBlades {
+ Blade[] inBlades;
+};
+
+layout (set = 2, binding = 1) buffer OutBlades {
+ Blade[] outBlades;
+};
+
+layout(set = 2, binding = 2) buffer NumBlades {
+ uint vertexCount;
+ uint instanceCount;
+ uint firstVertex;
+ uint firstInstance;
+} numBlades;
bool inBounds(float value, float bounds) {
return (value >= -bounds) && (value <= bounds);
}
+float MASS = 1.0;
+
void main() {
- // Reset the number of blades to 0
- if (gl_GlobalInvocationID.x == 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
-
- // 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
+ // Reset the number of blades to 0
+ if (gl_GlobalInvocationID.x == 0) {
+ numBlades.vertexCount = 0u;
+ }
+ barrier(); // Wait till all threads reach this point
+
+ // Read the blade for this invocation
+ uint idx = gl_GlobalInvocationID.x;
+ Blade blade = inBlades[idx];
+
+ // Forces
+ vec3 gravityDirection = vec3(0.0, -1.0, 0.0);
+ float gravityStrength = 9.81;
+ vec3 environmentGravity = normalize(gravityDirection) * gravityStrength;
+
+ vec3 front = cross(blade.up.xyz, vec3(cos(blade.v0.w), 0.0, sin(blade.v0.w)));
+ vec3 frontGravity = 0.25 * gravityStrength * front;
+ vec3 totalGravity = frontGravity + environmentGravity;
+
+
+ vec3 initialPosition = (blade.v0.xyz + blade.v1.w * blade.up.xyz);
+
+ vec3 recovery = (initialPosition - blade.v2.xyz) * blade.up.w;
+
+ //wind:
+
+ vec3 windDirection = normalize(vec3(1.0, 0.0, 1.0));
+ float windMagnitude = 2.0;
+ vec3 windForce = windDirection * snoise(blade.v2.xyz * 0.1 + windDirection * totalTime) * windMagnitude;
+ windForce *= 1.0 - dot(normalize(windForce), (blade.v2.xyz - blade.v0.xyz) / (blade.v2.xyz - blade.v0.xyz).length());
+ windForce *= 5.0;
+ vec3 totalForce = totalGravity + recovery + windForce;
+ vec3 acceleration = totalForce / MASS;
+
+ // Top vertex update (vec3)
+ vec3 newTop = blade.v2.xyz + acceleration * deltaTime;
+
+ // constraint 1: stay above ground
+ // use dot for projection (was previously using component-wise *)
+ float proj = dot(blade.up.xyz, (newTop - blade.v0.xyz));
+ float clampProj = min(proj, 0.0); // clamp to <= 0.0
+ newTop = newTop - blade.up.xyz * clampProj;
+
+ float lProj = length(newTop - blade.v0.xyz - blade.up.xyz * dot(newTop - blade.v0.xyz, blade.up.xyz));
+
+ // compute newControl using vec3 components (was mixing vec4 and vec3)
+ float v1w = blade.v1.w;
+ float factor = max(1.0 - lProj / v1w, 0.05 * max(lProj / v1w, 1.0));
+ vec3 newControl = blade.v0.xyz + v1w * blade.up.xyz * factor;
+
+ float l0 = length(newTop - blade.v0.xyz);
+ float l1 = length(newControl - blade.v0.xyz) + length(newTop - newControl);
+
+ // degree 2
+ float len = (2.0 * l0 + l1) / 3.0;
+ float r = v1w / len;
+
+ vec3 v1Correction = blade.v0.xyz + (newControl - blade.v0.xyz) * r;
+ vec3 v2Correction = v1Correction + (newTop - v1Correction) * r;
+
+ blade.v1 = vec4(v1Correction, blade.v1.w);
+ blade.v2 = vec4(v2Correction, blade.v2.w);
+
+ // blade.v1 = vec4(newControl, blade.v1.w);
+ // blade.v2 = vec4(newTop, blade.v2.w);
+
+
+
+
+
+ // Write updated blade back to input buffer (if intended)
+ inBlades[idx] = blade;
+
+
+ vec3 cameraDirection = vec3(camera.view[0][2], camera.view[1][2], camera.view[2][2]);
+ vec3 bladeDirection = vec3(cos(blade.v0.w), 0.0, sin(blade.v0.w));
+
+ if (abs(dot(cameraDirection, bladeDirection)) > 0.2 ) {
+ return;
+ }
+
+ vec3 m = 0.25 * blade.v0.xyz + 0.5 * blade.v1.xyz + 0.25 * blade.v2.xyz;
+ vec4 clip = camera.proj * camera.view * vec4(m, 1.f);
+ float limit = clip.w - .04;
+ if (clip.x < -limit || clip.x > limit || clip.y < -limit || clip.y > limit || clip.z < -limit || clip.z > limit) {
+ return;
+ }
+
+ float dProj = length(blade.v0.xyz - camera.pos.xyz - blade.up.xyz * dot(blade.v0.xyz - camera.pos.xyz, blade.up.xyz));
+ if (gl_GlobalInvocationID.x % 10 > floor(10 * (1 - dProj / 100.0))) {
+ return;
+ }
+
+ // Cull/write visible blades with atomic increment
+ uint outBladeId = atomicAdd(numBlades.vertexCount, 1u);
+ outBlades[outBladeId] = blade;
}
diff --git a/src/shaders/grass.frag b/src/shaders/grass.frag
index c7df157..60b248e 100644
--- a/src/shaders/grass.frag
+++ b/src/shaders/grass.frag
@@ -7,11 +7,29 @@ layout(set = 0, binding = 0) uniform CameraBufferObject {
} camera;
// TODO: Declare fragment shader inputs
+layout(location = 0) in vec3 fs_position;
+layout(location = 1) in vec3 fs_normal;
+layout(location = 2) in vec3 fs_up;
+layout(location = 3) in vec2 fs_uv;
+
+
layout(location = 0) out vec4 outColor;
void main() {
- // TODO: Compute fragment color
+ vec3 lightDir = normalize(vec3(0.3, 1.0, 0.2));
+
+ vec3 N = normalize(fs_normal);
+
+ float NdotL = max(dot(N, lightDir), 0.0);
+
+ vec3 grassColor = vec3(0.1, 0.8, 0.2);
+
+ // Ambient + diffuse term
+ vec3 ambient = 0.2 * grassColor;
+ vec3 diffuse = NdotL * grassColor;
+
+ vec3 color = ambient + diffuse;
- outColor = vec4(1.0);
+ outColor = vec4(color, 1.0);
}
diff --git a/src/shaders/grass.tesc b/src/shaders/grass.tesc
index f9ffd07..cce891d 100644
--- a/src/shaders/grass.tesc
+++ b/src/shaders/grass.tesc
@@ -8,19 +8,45 @@ layout(set = 0, binding = 0) uniform CameraBufferObject {
mat4 proj;
} camera;
+in gl_PerVertex {
+ vec4 gl_Position;
+} gl_in[];
+
// TODO: Declare tessellation control shader inputs and outputs
+layout(location = 0) in vec4 v0[];
+
+layout(location = 1) in vec4 v1[];
+
+layout(location = 2) in vec4 v2[];
+
+layout(location = 3) in vec4 model_up[];
+
+layout(location = 0) out vec4 out_v0[];
+
+layout(location = 1) out vec4 out_v1[];
+
+layout(location = 2) out vec4 out_v2[];
+
+layout(location = 3) out vec4 out_up[];
+
+
+
void main() {
// Don't move the origin location of the patch
gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
// TODO: Write any shader outputs
+ out_v0[gl_InvocationID] = v0[gl_InvocationID];
+ out_v1[gl_InvocationID] = v1[gl_InvocationID];
+ out_v2[gl_InvocationID] = v2[gl_InvocationID];
+ out_up[gl_InvocationID] = model_up[gl_InvocationID];
- // TODO: Set level of tesselation
- // gl_TessLevelInner[0] = ???
- // gl_TessLevelInner[1] = ???
- // gl_TessLevelOuter[0] = ???
- // gl_TessLevelOuter[1] = ???
- // gl_TessLevelOuter[2] = ???
- // gl_TessLevelOuter[3] = ???
+ float level = 10;
+ gl_TessLevelInner[0] = level;
+ gl_TessLevelInner[1] = level;
+ gl_TessLevelOuter[0] = level;
+ gl_TessLevelOuter[1] = level;
+ gl_TessLevelOuter[2] = level;
+ gl_TessLevelOuter[3] = level;
}
diff --git a/src/shaders/grass.tese b/src/shaders/grass.tese
index 751fff6..443f071 100644
--- a/src/shaders/grass.tese
+++ b/src/shaders/grass.tese
@@ -9,10 +9,41 @@ layout(set = 0, binding = 0) uniform CameraBufferObject {
} camera;
// TODO: Declare tessellation evaluation shader inputs and outputs
+layout(location = 0) in vec4 v0[];
+layout(location = 1) in vec4 v1[];
+layout(location = 2) in vec4 v2[];
+layout(location = 3) in vec4 up[];
+
+layout(location = 0) out vec3 fs_position;
+layout(location = 1) out vec3 fs_normal;
+layout(location = 2) out vec3 fs_up;
+layout(location = 3) out vec2 fs_uv;
+
void main() {
float u = gl_TessCoord.x;
float v = gl_TessCoord.y;
- // TODO: Use u and v to parameterize along the grass blade and output positions for each vertex of the grass blade
+ vec3 a = v0[0].xyz + v * (v1[0].xyz - v0[0].xyz);
+ vec3 b = v1[0].xyz + v * (v2[0].xyz - v1[0].xyz);
+ vec3 c = a + v * (b - a);
+
+ float width = v2[0].w;
+ float height = v1[0].w;
+ float angle = v0[0].w;
+
+ vec3 tangentXZ = vec3(cos(angle), 0, sin(angle));
+
+ vec3 c0 = c - width * tangentXZ;
+ vec3 c1 = c + width * tangentXZ;
+
+ vec3 tangentY = normalize(b-a);
+ vec3 normalVec = normalize(cross(tangentXZ, tangentY));
+
+ float t = 0.5 + (u - 0.5) * ((1 - max(v - 0.01, 0)) / (1 - 0.01));
+ fs_position = mix(c0, c1, t);
+
+ gl_Position = camera.proj * camera.view * vec4(fs_position, 1.0);
+ fs_normal = normalVec;
+ fs_uv = vec2(t, v);
}
diff --git a/src/shaders/grass.vert b/src/shaders/grass.vert
index db9dfe9..987aa6f 100644
--- a/src/shaders/grass.vert
+++ b/src/shaders/grass.vert
@@ -12,6 +12,28 @@ out gl_PerVertex {
vec4 gl_Position;
};
+layout(location = 0) in vec4 in_v0;
+layout(location = 1) in vec4 in_v1;
+layout(location = 2) in vec4 in_v2;
+layout(location = 3) in vec4 in_up;
+
+layout(location = 0) out vec4 v0;
+layout(location = 1) out vec4 v1;
+layout(location = 2) out vec4 v2;
+layout(location = 3) out vec4 model_up;
+
void main() {
// TODO: Write gl_Position and any other shader outputs
+ vec4 v0Temp = model * vec4(in_v0.xyz, 1.0);
+ v0 = vec4((v0Temp / v0Temp.w).xyz, in_v0.w);
+
+ vec4 v1Temp = model * vec4(in_v1.xyz, 1.0);
+ v1 = vec4((v1Temp / v1Temp.w).xyz, in_v1.w);
+
+ vec4 v2Temp = model * vec4(in_v2.xyz, 1.0);
+ v2 = vec4((v2Temp / v2Temp.w).xyz, in_v2.w);
+
+ vec4 upTemp = model * vec4(in_up.xyz, 0.0);
+ model_up = vec4((upTemp / upTemp.w).xyz, in_up.w);
+
}