Add: 2D texture creation and mipmap generation

Author: XanderBert

src/EOS.h

@@ -281,6 +281,80 @@ namespace EOS
         const char* DebugName = "";
     };
 
+    struct ComponentMapping final
+    {
+        Swizzle R = Swizzle::Identity;
+        Swizzle G = Swizzle::Identity;
+        Swizzle B = Swizzle::Identity;
+        Swizzle A = Swizzle::Identity;
+
+        bool Identity() const
+        {
+            return R == Swizzle::Identity && G == Swizzle::Identity && B == Swizzle::Identity && A == Swizzle::Identity;
+        }
+    };
+
+    struct Dimensions final
+    {
+        uint32_t Width = 1;
+        uint32_t Height = 1;
+        uint32_t Depth = 1;
+
+        inline Dimensions divide1D(uint32_t v) const
+        {
+            return {.Width = Width / v, .Height = Height, .Depth = Depth};
+        }
+
+        inline Dimensions divide2D(uint32_t v) const
+        {
+            return {.Width = Width / v, .Height = Height / v, .Depth = Depth};
+        }
+
+        inline Dimensions divide3D(uint32_t v) const
+        {
+            return {.Width = Width / v, .Height = Height / v, .Depth = Depth / v};
+        }
+
+        inline bool operator==(const Dimensions& other) const
+        {
+            return Width == other.Width && Height == other.Height && Depth == other.Depth;
+        }
+    };
+
+    struct TextureDescription final
+    {
+        EOS::ImageType Type = EOS::ImageType::Image_2D;
+        Format TextureFormat = Format::Invalid;
+        Dimensions TextureDimensions = {1, 1, 1};
+        uint32_t NumberOfLayers = 1;
+        uint32_t NumberOfMipLevels = 1;
+        uint32_t NumberOfSamples = 1;
+        uint8_t Usage = TextureUsageFlags::Sampled;
+        StorageType Storage = StorageType::Device;
+        ComponentMapping Swizzle{};
+        const void* Data = nullptr;
+        uint32_t DataNumberOfMipLevels = 1;     // how many mip-levels we want to upload
+        bool GenerateMipmaps = false;           // generate mip-levels immediately, valid only with non-null data
+        const char* DebugName = "";
+    };
+
+    struct Offset3D final
+    {
+        int32_t X = 0;
+        int32_t Y = 0;
+        int32_t Z = 0;
+    };
+
+    struct TextureRangeDescription final
+    {
+        Offset3D Offset = {};
+        Dimensions Dimension = {1, 1, 1};
+        uint32_t Layer = 0;
+        uint32_t NumberOfLayers = 1;
+        uint32_t MipLevel = 0;
+        uint32_t NumberOfMipLevels = 1;
+    };
+
 #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.
@@ -350,6 +424,8 @@ namespace EOS
         */
         virtual EOS::Holder<BufferHandle> CreateBuffer(const BufferDescription& description) = 0;
 
+        virtual EOS::Holder<TextureHandle> CreateTexture(const TextureDescription& description) = 0;
+
         /**
         * @brief Handles the destruction of a TextureHandle and what it holds.
         * @param handle The handle to the texture you want to destroy.
@@ -370,20 +446,28 @@ 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.
-         */
+        * @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;
 
         /**
-         * @brief
-         * @param handle The handle of the buffer we want to upload to.
-         * @param data The data we want to upload.
-         * @param size The size of the data we want to upload.
-         * @param offset The offset it needs to have inside of the buffer.
-         */
+        * @brief Handles the uploading of buffers to the GPU
+        * @param handle The handle of the buffer we want to upload to.
+        * @param data The data we want to upload.
+        * @param size The size of the data we want to upload.
+        * @param offset The offset it needs to have inside of the buffer.
+        */
         virtual void Upload(EOS::BufferHandle handle, const void* data, size_t size, size_t offset) = 0;
 
+        /**
+        * @brief Handles the uploading of textures to the GPU
+        * @param handle The handle of the texture we want to upload
+        * @param range The description of how many mips, layers ... we want to upload.
+        * @param data The actual data of the texture we want to upload.
+        */
+        virtual void Upload(EOS::TextureHandle handle, const TextureRangeDescription& range, const void* data) = 0;
+
     protected:
         IContext() = default;
     };
@@ -592,6 +676,13 @@ void cmdPushConstants(const EOS::ICommandBuffer& commandBuffer, const Struct& da
     cmdPushConstants(commandBuffer, &data, sizeof(Struct), offset);
 }
 
+/**
+ * @brief
+ * @param commandBuffer
+ * @param depthState
+ */
+void cmdSetDepthState(const EOS::ICommandBuffer& commandBuffer, const EOS::DepthState& depthState);
+
 /**
  * @brief Adds a debug marker that is visible in debug software.
  * @param commandBuffer The commandbuffer we want to record into.

src/enums.h

@@ -174,7 +174,7 @@ namespace EOS
         ClockWise
     };
 
-    enum class Format : uint8_t
+    enum Format : uint8_t
     {
         Invalid = 0,
 
@@ -320,7 +320,7 @@ namespace EOS
         Index = 0x01,
         Vertex = 0x02,
         Uniform = 0x04,
-        Storage = 0x08,
+        StorageFlag = 0x08,
         Indirect = 0x10,
         ShaderBindingTable = 0x20,
         AccelStructBuildInputReadOnly = 0x40,
@@ -333,4 +333,22 @@ namespace EOS
         UI16,
         UI32,
     };
+
+    enum TextureUsageFlags : uint8_t
+    {
+        Sampled = 0x00,
+        Storage = 0x01,
+        Attachment = 0x2,
+    };
+
+    enum Swizzle : uint8_t
+    {
+        Identity = 0,
+        Zero,
+        One,
+        R,
+        G,
+        B,
+        A,
+    };
 }

src/logger.h

@@ -5,7 +5,7 @@
 #include <spdlog/sinks/basic_file_sink.h>
 #include <spdlog/sinks/callback_sink.h>
 #include <spdlog/fmt/bundled/ranges.h>
-
+#include <assert.h>
 #include "defines.h"
 #include "spdlog/sinks/rotating_file_sink.h"
 

src/main.cpp

@@ -64,13 +64,19 @@ int main()
     EOS::Holder<EOS::ShaderModuleHandle> shaderHandleVert = EOS::LoadShader(context, shaderCompiler, "triangleVert");
     EOS::Holder<EOS::ShaderModuleHandle> shaderHandleFrag = EOS::LoadShader(context, shaderCompiler, "triangleFrag");
 
-
     constexpr EOS::VertexInputData vdesc
     {
         .Attributes    = { { .Location = 0, .Format = EOS::VertexFormat::Float3, .Offset = 0 } },
         .InputBindings = { { .Stride = sizeof(glm::vec3) } },
     };
 
+    EOS::Holder<EOS::TextureHandle> depthTexture = context->CreateTexture({
+    .Type       = EOS::ImageType::Image_2D,
+    .TextureFormat     = EOS::Format::Z_F32,
+    .TextureDimensions = {static_cast<uint32_t>(window->Width), static_cast<uint32_t>(window->Height)},
+    .Usage      = EOS::TextureUsageFlags::Attachment,
+    .DebugName  = "Depth Buffer",
+    });
 
     //It would be nice if these pipeline descriptions would be stored as JSON/XML into the material system
     EOS::RenderPipelineDescription renderPipelineDescription
@@ -79,19 +85,16 @@ int main()
         .VertexShader = shaderHandleVert,
         .FragmentShader = shaderHandleFrag,
         .ColorAttachments = {{ .ColorFormat = context->GetSwapchainFormat()}},
-
+        .DepthFormat = EOS::Format::Z_F32, //TODO depthTexture->Format
+        .PipelineCullMode = EOS::CullMode::Back,
+        .DebugName = "Basic Render Pipeline"
     };
-
     EOS::Holder<EOS::RenderPipelineHandle> renderPipelineHandle = context->CreateRenderPipeline(renderPipelineDescription);
 
     std::vector<glm::vec3> positions;
     std::vector<uint32_t> indices;
-
-    //TODO: Copy over data to bin
     LoadModel("../data/rubber_duck/scene.gltf", positions, indices);
 
-
-
     EOS::Holder<EOS::BufferHandle> vertexBuffer = context->CreateBuffer(
     {
       .Usage     = EOS::BufferUsageFlags::Vertex,
@@ -101,7 +104,6 @@ int main()
       .DebugName = "Buffer: vertex"
       });
 
-
     EOS::Holder<EOS::BufferHandle> indexBuffer = context->CreateBuffer(
     {
         .Usage     = EOS::BufferUsageFlags::Index,
@@ -118,31 +120,54 @@ int main()
         {
             continue; // Or sleep
         }
-
         const float aspectRatio = static_cast<float>(window->Width) / static_cast<float>(window->Height);
 
-        //TODO: There is no depth texture available in the vertex stage to handle Depth Comparrison
+        //glm::mat4 model = glm::rotate(glm::mat4(1.0f), glm::radians(  static_cast<float>(glfwGetTime() * 20.0f)  ), glm::vec3(1, 0, 0));
+        //constexpr glm::mat4 view = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, -0.5f, -1.5f));
+        //const glm::mat4 projection = glm::perspective(glm::radians(65.0f), aspectRatio, 0.1f, 1000.0f);
+
+        using glm::mat4;
+        using glm::vec3;
 
-        glm::mat4 model = glm::rotate(glm::mat4(1.0f), glm::radians(  static_cast<float>(glfwGetTime() * 10.0f)  ), glm::vec3(1, 0, 0));
-        constexpr glm::mat4 view = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, -0.5f, -1.5f));
-        const glm::mat4 projection = glm::perspective(glm::radians(65.0f), aspectRatio, 0.1f, 1000.0f);
-        const glm::mat4 mvp = projection * view * model;
+        const mat4 m = glm::rotate(mat4(1.0f), glm::radians(-90.0f), vec3(1, 0, 0));
+        const mat4 v = glm::rotate(glm::translate(mat4(1.0f), vec3(0.0f, -0.5f, -1.5f)), (float)glfwGetTime(), vec3(0.0f, 1.0f, 0.0f));
+        const mat4 p = glm::perspective(45.0f, aspectRatio, 0.1f, 1000.0f);
+        const glm::mat4 mvp = p * v * m;
 
         EOS::ICommandBuffer& cmdBuffer = context->AcquireCommandBuffer();
         cmdPipelineBarrier(cmdBuffer, {}, {{context->GetSwapChainTexture(), EOS::ResourceState::Undefined, EOS::ResourceState::Present}});
 
-        EOS::Framebuffer framebuffer = {.Color = {{.Texture = context->GetSwapChainTexture()}}};
-        EOS::RenderPass renderPass{ .Color = { { .LoadOpState = EOS::LoadOp::Clear, .ClearColor = { 0.36f, 0.4f, 1.0f, 0.28f } } }};
+        EOS::Framebuffer framebuffer
+        {
+            .Color = {{.Texture = context->GetSwapChainTexture()}},
+            .DepthStencil = { .Texture = depthTexture },
+            .DebugName = "Basic Color Depth Framebuffer"
+        };
+
+        EOS::RenderPass renderPass
+        {
+            .Color { { .LoadOpState = EOS::LoadOp::Clear, .ClearColor = { 0.36f, 0.4f, 1.0f, 0.28f } } },
+            .Depth{ .LoadOpState = EOS::LoadOp::Clear, .ClearDepth = 1.0f }
+        };
+
+        EOS::DepthState depthState
+        {
+            .CompareOpState = EOS::CompareOp::Less,
+            .IsDepthWriteEnabled = true,
+        };
+
         cmdBeginRendering(cmdBuffer, renderPass, framebuffer);
+        {
             cmdPushMarker(cmdBuffer, "Render Duck", 0xff0000ff);
-                cmdBindVertexBuffer(cmdBuffer, 0, vertexBuffer);
-                cmdBindIndexBuffer(cmdBuffer, indexBuffer, EOS::IndexFormat::UI32);
-                cmdBindRenderPipeline(cmdBuffer, renderPipelineHandle);
-                cmdPushConstants(cmdBuffer, mvp);
-                cmdDrawIndexed(cmdBuffer, indices.size());
+            cmdBindVertexBuffer(cmdBuffer, 0, vertexBuffer);
+            cmdBindIndexBuffer(cmdBuffer, indexBuffer, EOS::IndexFormat::UI32);
+            cmdBindRenderPipeline(cmdBuffer, renderPipelineHandle);
+            cmdPushConstants(cmdBuffer, mvp);
+            cmdSetDepthState(cmdBuffer, depthState);
+            cmdDrawIndexed(cmdBuffer, indices.size());
             cmdPopMarker(cmdBuffer);
+        }
         cmdEndRendering(cmdBuffer);
-
         context->Submit(cmdBuffer, context->GetSwapChainTexture());
     }
 

src/shaders/triangleVert.slang

@@ -9,6 +9,6 @@ public struct PerFrameData
 [shader("vertex")]
 void main( uint vertexID : SV_VertexID, float3 inPos : POSITION, out float4 outPosition : SV_Position, out float3 outColor : COLOR0)
 {
-    outPosition = mul(perFrameData.MVP, float4(inPos, 1.0));
+    outPosition = mul(float4(inPos, 1.0), perFrameData.MVP);
     outColor = inPos.xzy;
 }