Add: GPU Buffer, Shader Copying

Author: XanderBert

cmake/CmakeMacros.cmake

@@ -53,4 +53,16 @@ macro(CREATE_APP name)
         add_definitions(-D_CONSOLE)
         set_property(TARGET ${PROJECT_NAME} PROPERTY VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
     endif()
+
+    # Copy shaders
+    foreach(SHADER ${SHADER_FILES})
+        get_filename_component(SHADER_NAME ${SHADER} NAME)
+        add_custom_command(
+                TARGET ${PROJECT_NAME} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "${SHADER}"
+                "$<TARGET_FILE_DIR:${PROJECT_NAME}>/${SHADER_NAME}"
+                COMMENT "Copying shader file: ${SHADER_NAME}"
+        )
+    endforeach()
 endmacro()

src/EOS.h

@@ -272,6 +272,15 @@ namespace EOS
         float MaxDepth = 1.0f;
     };
 
+    struct BufferDescription final
+    {
+        BufferUsageFlags Usage = BufferUsageFlags::None;
+        StorageType Storage = StorageType::HostVisible;
+        size_t Size = 0;
+        const void* Data = nullptr;
+        const char* DebugName = "";
+    };
+
 #pragma region INTERFACES
     //TODO: instead of interfaces use concept and a forward declare. And then every API implements 1 class of that name with the concept.
     //CMake should handle that only 1 type of API is being used at the time.
@@ -327,12 +336,20 @@ namespace EOS
         virtual EOS::Holder<EOS::ShaderModuleHandle> CreateShaderModule(const EOS::ShaderInfo& shaderInfo) = 0;
 
         /**
-         * @brief Creates a RenderPipeline and returns a handle to it.
-         * @param renderPipelineDescription The description about what type of pipeline we want to create and what it exists of.
-         * @return A Holder Handle to a Render Pipeline.
-         */
+        * @brief Creates a RenderPipeline and returns a handle to it.
+        * @param renderPipelineDescription The description about what type of pipeline we want to create and what it exists of.
+        * @return A Holder Handle to a Render Pipeline.
+        */
         virtual EOS::Holder<EOS::RenderPipelineHandle> CreateRenderPipeline(const RenderPipelineDescription& renderPipelineDescription) = 0;
 
+
+        /**
+        * @brief Creates a Buffer and returns a handle to it.
+        * @param description desecribes the what sort of buffer it is and its properties.
+        * @return A Holder Handle to the buffer.
+        */
+        virtual EOS::Holder<BufferHandle> CreateBuffer(const BufferDescription& description) = 0;
+
         /**
         * @brief Handles the destruction of a TextureHandle and what it holds.
         * @param handle The handle to the texture you want to destroy.
@@ -352,6 +369,12 @@ namespace EOS
         */
         virtual void Destroy(RenderPipelineHandle handle) = 0;
 
+        /**
+         * @brief Handles the destruction of a BufferHandle and what it holds.
+         * @param handle The handle to the Buffer you want to destroy.
+         */
+        virtual void Destroy(BufferHandle handle) = 0;
+
     protected:
         IContext() = default;
     };

src/enums.h

@@ -306,4 +306,24 @@ namespace EOS
         MsaaResolve,
         None,
     };
+
+    enum class StorageType : uint8_t
+    {
+        Device,
+        HostVisible,
+        Memoryless
+    };
+
+    enum BufferUsageFlags : uint8_t
+    {
+        None = 0x00,
+        Index = 0x01,
+        Vertex = 0x02,
+        Uniform = 0x04,
+        Storage = 0x08,
+        Indirect = 0x10,
+        ShaderBindingTable = 0x20,
+        AccelStructBuildInputReadOnly = 0x40,
+        AccelStructStorage = 0x80
+    };
 }

src/main.cpp

@@ -15,6 +15,7 @@ int main()
     std::unique_ptr<EOS::IContext> context = EOS::CreateContextWithSwapChain(contextDescr);
     std::unique_ptr<EOS::ShaderCompiler> shaderCompiler = EOS::CreateShaderCompiler("./");
 
+    //TODO First check if the shader is not already compiled
     EOS::Holder<EOS::ShaderModuleHandle> shaderHandleVert = EOS::LoadShader(context, shaderCompiler, "triangleVert");
     EOS::Holder<EOS::ShaderModuleHandle> shaderHandleFrag = EOS::LoadShader(context, shaderCompiler, "triangleFrag");
 
@@ -28,6 +29,27 @@ int main()
 
     EOS::Holder<EOS::RenderPipelineHandle> renderPipelineHandle = context->CreateRenderPipeline(triangleDescription);
 
+
+    //EOS::Holder<EOS::BufferHandle> vertexBuffer = context->CreateBuffer(
+    //{
+    //    .usage     = EOS::BufferUsageFlags::Vertex,
+    //    .storage   = EOS::StorageType::Device,
+    //    .size      = sizeof(float[3]) * positions.size(),
+    //    .data      = positions.data(),
+    //    .debugName = "Buffer: vertex"
+    //});
+//
+//
+    //EOS::Holder<EOS::BufferHandle> indexBuffer = context->CreateBuffer(
+//{
+    //    .usage     = EOS::BufferUsageFlags::Vertex,
+    //    .storage   = EOS::StorageType::Device,
+    //    .size      = sizeof(uint32_t) * indices.size(),
+    //    .data      = indices.data(),`
+    //    .debugName = "Buffer: vertex"
+    //});
+
+
     while (!glfwWindowShouldClose(window))
     {
         glfwPollEvents();

src/shaders/triangleFrag.slang

@@ -1,13 +1,8 @@
-// Fragment Shader
-
-struct FragmentInput
+[shader("fragment")]
+void main(
+    float3 inColor : COLOR0,
+    out float4 outFragColor : SV_Target
+)
 {
-    float4 position : SV_Position; // Not typically used directly in basic fragment shaders
-    float3 color    : COLOR;       // Input color from vertex shader
-};
-
-float4 main(FragmentInput input) : SV_Target
-{
-    // Output the interpolated color from the vertex shader
-    return float4(input.color, 1.0); // r, g, b, alpha
-}
+    outFragColor = float4(inColor, 1.0);
+}

src/shaders/triangleVert.slang

@@ -1,23 +1,24 @@
-// Vertex Shader
+// Slang version
 
-struct VertexInput
+[shader("vertex")]
+void main(
+    uint vertexID : SV_VertexID,
+    out float4 outPosition : SV_Position,
+    out float3 outColor : COLOR0
+)
 {
-    float2 position : POSITION; // Input vertex position
-    float3 color    : COLOR;    // Input vertex color
-};
+    static const float2 pos[3] = {
+        float2(-0.6, -0.4),
+        float2( 0.6, -0.4),
+        float2( 0.0,  0.6)
+    };
 
-struct VertexOutput
-{
-    float4 position : SV_Position; // Output clip-space position
-    float3 color    : COLOR;       // Output color to fragment shader
-};
+    static const float3 col[3] = {
+        float3(1.0, 0.0, 0.0),
+        float3(0.0, 1.0, 0.0),
+        float3(0.0, 0.0, 1.0)
+    };
 
-VertexOutput main(VertexInput input)
-{
-    VertexOutput output;
-    // Pass the 2D position directly, assuming it's already in clip space for simplicity.
-    // z = 0.5 for visibility, w = 1.0 for a proper perspective divide.
-    output.position = float4(input.position, 0.5, 1.0);
-    output.color = input.color;
-    return output;
-}
+    outPosition = float4(pos[vertexID], 0.0, 1.0);
+    outColor = col[vertexID];
+}

src/vulkan/vkTools.cpp

@@ -1273,6 +1273,72 @@ namespace VkContext
         CHECK(false, "Could not resolve StoreOp");
         return VK_ATTACHMENT_STORE_OP_DONT_CARE;
     }
+
+    VkBufferUsageFlags BufferUsageFlagsToVkBufferUsageFlags(EOS::BufferUsageFlags bufferUsageFlags)
+    {
+        VkBufferUsageFlags usageFlags{};
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::Index)
+        {
+            usageFlags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
+        }
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::Vertex)
+        {
+            usageFlags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+        }
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::Uniform)
+        {
+            usageFlags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+        }
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::Storage)
+        {
+            usageFlags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+        }
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::Indirect)
+        {
+            usageFlags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+        }
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::ShaderBindingTable)
+        {
+            usageFlags |= VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+        }
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::AccelStructBuildInputReadOnly)
+        {
+            usageFlags |= VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+        }
+
+        if (bufferUsageFlags & EOS::BufferUsageFlags::AccelStructStorage)
+        {
+            usageFlags |= VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+        }
+
+        return usageFlags;
+    }
+
+    VkMemoryPropertyFlags StorageTypeToVkMemoryPropertyFlags(EOS::StorageType storage)
+    {
+        VkMemoryPropertyFlags memFlags{0};
+
+        switch (storage)
+        {
+            case EOS::StorageType::Device:
+                memFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                break;
+            case EOS::StorageType::HostVisible:
+                memFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+                break;
+            case EOS::StorageType::Memoryless:
+                memFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
+                break;
+        }
+        return memFlags;
+    }
 };
 
 namespace VkSynchronization

src/vulkan/vkTools.h

@@ -143,6 +143,8 @@ namespace VkContext
 
     [[nodiscard]] VkAttachmentLoadOp LoadOpToVkAttachmentLoadOp(EOS::LoadOp loadOp);
     [[nodiscard]] VkAttachmentStoreOp StoreOpToVkAttachmentStoreOp(EOS::StoreOp storeOp);
+    [[nodiscard]] VkBufferUsageFlags BufferUsageFlagsToVkBufferUsageFlags(EOS::BufferUsageFlags bufferUsageFlags);
+    [[nodiscard]] VkMemoryPropertyFlags StorageTypeToVkMemoryPropertyFlags(EOS::StorageType storage);
 }
 
 namespace VkSynchronization