#include <Orange/Core/Array.h>
#include <Orange/Core/Vector.h>
#include "Orange/Core/Span.h"
#include <Orange/Core/Result.h>
#include <Orange/Core/FileSystem.h>
#include <Orange/Math/Vector.h>
#include <Orange/Math/Matrix.h>
#include <Orange/Math/Transformation.h>
#include <Orange/Core/Parse.h>
#include <Orange/Core/Variant.h>
#include <Orange/Core/Time.h>

#include <Orange/Render/Window.h>
#include <Orange/Render/RenderContext.h>
#include <Orange/Render/Swapchain.h>
#include <Orange/Render/VulkanHelpers.h>

#include <Orange/Graphics/Camera.h>

#include <vs_Mesh.h>
#include <fs_DebugVertColor.h>

using namespace orange;

struct AABB
{
    vec3 min;
    vec3 max;

    void Extend(vec3 pos)
    {
        min = Min(pos, min);
        max = Max(pos, max);
    }
};

enum class MeshVertexType
{
    Static,
    Skinned,
};

#ifndef offsetof2
#define offsetof2(type, member) size_t(uintptr_t(&((type*)0)->member))
#endif

struct StaticVertex
{
    vec3 pos;
    vec2 uv;
    vec3 normal;
    //vec3 tangent;

    static constexpr VkVertexInputAttributeDescription Attributes[] =
    {
        { .location = 0, .binding = 0, .format = VK_FORMAT_R32G32B32_SFLOAT, .offset = uint32_t(offsetof2(StaticVertex, pos)) },
        { .location = 1, .binding = 0, .format = VK_FORMAT_R32G32_SFLOAT,    .offset = uint32_t(offsetof2(StaticVertex, uv)) },
        { .location = 2, .binding = 0, .format = VK_FORMAT_R32G32B32_SFLOAT, .offset = uint32_t(offsetof2(StaticVertex, normal)) },
    };

    bool operator == (const StaticVertex& other) const
    {
        return pos     == other.pos &&
               uv      == other.uv &&
               normal  == other.normal;// &&
               //tangent == other.tangent;
    }
};

struct SkinnedVertex : public StaticVertex
{
    static constexpr uint32_t MaxVertexWeights = 4;

    bool operator == (const SkinnedVertex& other) const
    {
        return pos         == other.pos &&
               uv          == other.uv &&
               normal      == other.normal &&
               //tangent     == other.tangent &&
               boneIndices == other.boneIndices &&
               boneWeights == other.boneWeights;
    }

    Array<uint8_t, MaxVertexWeights> boneIndices;
    Array<uint8_t, MaxVertexWeights> boneWeights;
};

struct MeshVertexData
{
    MeshVertexData(MeshVertexType type)
        : vertexType(type)
    {
        switch(vertexType)
        {
            case MeshVertexType::Static:
                vertices.Construct<Vector<StaticVertex>>();
                break;
            case MeshVertexType::Skinned:
                vertices.Construct<Vector<SkinnedVertex>>();
                break;
        }
    }

    Vector<StaticVertex>&  GetStaticVertices()
    {
        Assert(vertexType == MeshVertexType::Static);
        return vertices.Get<Vector<StaticVertex>>();
    }

    Vector<SkinnedVertex>& GetSkinnedVertices()
    {
        Assert(vertexType == MeshVertexType::Skinned);
        return vertices.Get<Vector<SkinnedVertex>>();
    }

    BufferView View()
    {
        switch(vertexType)
        {
            case MeshVertexType::Static:
                return GetStaticVertices();
                break;
            case MeshVertexType::Skinned:
                return GetSkinnedVertices();
                break;
            default:
                return BufferView{ nullptr, 0 };
        }
    }

    uint32_t VertexCount() const
    {
        // Type doesn't matter here, just want to grab m_size.
        return uint32_t(vertices.Get<Vector<uint8_t>>().Size());
    }

    MeshVertexType vertexType;
    Variant<Vector<StaticVertex>, Vector<SkinnedVertex>> vertices;
};

struct MeshData
{
    MeshData(MeshVertexType type)
        : vertexData{ type } {}

    MeshVertexData   vertexData;
    Vector<uint16_t> indices;
    AABB             bounds;
};

Result<MeshData> ParseOBJ(StringView buffer)
{
    MeshData data{ MeshVertexType::Static };

    Vector<vec3> positions;
    Vector<vec2> uvs;
    Vector<vec3> normals;

    const char* obj = buffer.data;
    const char* end = buffer.data + buffer.size;
    while (obj != end)
    {
        SmallVector<char, 8> element;
        stream::ReadString(obj, end, " #\n", element);

        if (element == "v" || element == "vt" || element == "vn")
        {
            float vtx[3]{};
            for (int i = 0; i < 3; i++)
            {
                stream::ConsumeSpace(obj, end);
                if (auto r_float = stream::Parse<float>(obj, end))
                    vtx[i] = *r_float;
            }

            if (element == "v")
                positions.EmplaceBack(vtx[0], vtx[1], vtx[2]);
            else if (element == "vt")
                uvs.EmplaceBack(vtx[0], vtx[1]);
            else if (element == "vn")
                normals.EmplaceBack(vtx[0], vtx[1], vtx[2]);
        }
        else if (element == "g" || element == "o")
        {
            stream::ConsumeSpace(obj, end);
            SmallVector<char, 32> name;
            stream::ReadString(obj, end, " #\n", name);

            name.PushBack('\0');
            if (element == "g")
                log::info("Group name: %s", name.Data());
            else
                log::info("Object name: %s", name.Data());
        }
        else if (element == "f")
        {
            int32_t indices[3][3]{};
            for (int i = 0; i < 3; i++)
            {
                stream::ConsumeSpace(obj, end);

                for (int j = 0; j < 3; j++)
                {
                    indices[i][j] = -1;

                    if (j == 0 || stream::Consume(obj, end, "/"))
                    {
                        if (auto r_int = stream::Parse<uint32_t>(obj, end))
                            indices[i][j] = *r_int - 1; // OBJ indexing starts at one.
                    }
                }
            }

            for (int i = 0; i < 3; i++)
            {
                StaticVertex vertex =
                {
                    .pos    = indices[i][0] != -1 ? positions[indices[i][0]] : vec3{},
                    .uv     = indices[i][1] != -1 ? uvs      [indices[i][1]] : vec2{},
                    .normal = indices[i][2] != -1 ? normals  [indices[i][2]] : vec3{},
                };

                auto& vertices = data.vertexData.GetStaticVertices();

                size_t vertexIdx = vertices.FindIdx(vertex);
                if (vertexIdx == vertices.InvalidIdx)
                {
                    data.bounds.Extend(vertex.pos);
                    vertexIdx = vertices.PushBack(vertex);
                }

                Assert(vertexIdx < UINT16_MAX);
                data.indices.PushBack(uint16_t(vertexIdx));
            }
        }
        else if (!element.Empty())
        {
            element.PushBack('\0');
            log::info("Unknown element: %s", element.Data());
        }

        stream::AdvancePast(obj, end, "\n");
    };

    return Result<MeshData>::Success(data);
}

int main(int argc, char** argv)
{
    (void)argc; (void)argv;

    auto r_window = Window::Create();
    if (!r_window)
        return 1;

    auto r_renderContext = RenderContext::Create("Cube Test");
    if (!r_renderContext)
        return 1;

    auto r_surface = r_window->CreateSurface(r_renderContext->Instance());
    if (!r_surface)
        return 1;

    auto r_swapchain = Swapchain::Create(*r_renderContext, *r_surface);
    if (!r_swapchain)
        return 1;

    auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/chair.obj");
    //auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/cube.obj");
    if (!r_objData)
        return 1;

    auto r_mesh = ParseOBJ(*r_objData);

    auto r_vs = r_renderContext->CreateShader(vs_Mesh);
    if (!r_vs) return 1;
    auto r_fs = r_renderContext->CreateShader(fs_DebugVertColor);
    if (!r_fs) return 1;

    //

    VkSamplerCreateInfo samplerInfo =
    {
        .sType            = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
        .magFilter        = VK_FILTER_LINEAR,
        .minFilter        = VK_FILTER_LINEAR,
        .mipmapMode       = VK_SAMPLER_MIPMAP_MODE_LINEAR,
        .addressModeU     = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
        .addressModeV     = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
        .addressModeW     = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
        .mipLodBias       = 0.0f,
        .anisotropyEnable = VK_TRUE,
        .maxAnisotropy    = 16.0f,
        .minLod           = -FLT_MAX,
        .maxLod           = FLT_MAX,
    };
    VkSampler sampler = VK_NULL_HANDLE;
    vkCreateSampler(r_renderContext->Device(), &samplerInfo, nullptr, &sampler);

    constexpr uint32_t MaxBindlessResources = 32768;
    VkDescriptorPoolSize bindlessPoolSizes[] =
    {
        { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MaxBindlessResources }
    };

    VkDescriptorPoolCreateInfo poolInfo =
    {
        .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
        .flags         = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
        .maxSets       = MaxBindlessResources * Size(bindlessPoolSizes),
        .poolSizeCount = uint32_t(Size(bindlessPoolSizes)),
        .pPoolSizes    = bindlessPoolSizes,
    };
    
    VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
    vkCreateDescriptorPool(r_renderContext->Device(), &poolInfo, nullptr, &descriptorPool);

    VkDescriptorSetLayoutBinding layoutBindings[] =
    {
        {
            .binding            = 0,
            .descriptorType     = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            .descriptorCount    = MaxBindlessResources,
            .stageFlags         = VK_SHADER_STAGE_ALL,
        },
        {
            .binding            = 1,
            .descriptorType     = VK_DESCRIPTOR_TYPE_SAMPLER,
            .descriptorCount    = 1,
            .stageFlags         = VK_SHADER_STAGE_FRAGMENT_BIT,
            .pImmutableSamplers = &sampler,
        },
        {
            .binding            = 2,
            .descriptorType     = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
            .descriptorCount    = MaxBindlessResources,
            .stageFlags         = VK_SHADER_STAGE_FRAGMENT_BIT,
        },
    };

    constexpr VkDescriptorBindingFlags bindingFlags[] =
    {
        0,
        0,
        VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT,
    };

    Assert(Size(bindingFlags) == Size(layoutBindings));

    VkDescriptorSetLayoutBindingFlagsCreateInfo layoutBindingFlagsInfo =
    {
        .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,
        .bindingCount  = Size(bindingFlags),
        .pBindingFlags = bindingFlags,
    };

    VkDescriptorSetLayoutCreateInfo layoutInfo =
    {
        .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
        .pNext        = &layoutBindingFlagsInfo,
        .flags        = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT,
        .bindingCount = Size(layoutBindings),
        .pBindings    = layoutBindings,
    };

    VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
    vkCreateDescriptorSetLayout(r_renderContext->Device(), &layoutInfo, nullptr, &descriptorSetLayout);

    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT descriptorCountAllocInfo =
    {
        .sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT,
        .descriptorSetCount = 1,
        .pDescriptorCounts  = &MaxBindlessResources,
    };

    VkDescriptorSetAllocateInfo descriptorSetAllocInfo =
    {
        .sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
        .pNext              = &descriptorCountAllocInfo,
        .descriptorPool     = descriptorPool,
        .descriptorSetCount = 1,
        .pSetLayouts        = &descriptorSetLayout,
    };

    VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
    vkAllocateDescriptorSets(r_renderContext->Device(), &descriptorSetAllocInfo, &descriptorSet);

    //

    VkPipelineShaderStageCreateInfo stages[] =
    {
        {
            .sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage  = VK_SHADER_STAGE_VERTEX_BIT,
            .module = *r_vs,
            .pName  = "main",
        },
        {
            .sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage  = VK_SHADER_STAGE_FRAGMENT_BIT,
            .module = *r_fs,
            .pName  = "main",
        },
    };

    Array<VkDynamicState, 2> dynamicStates =
    {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR,
    };

    VkPipelineDynamicStateCreateInfo dynamicStateInfo =
    {
        .sType             = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
        .dynamicStateCount = uint32_t(dynamicStates.Size()),
        .pDynamicStates    = dynamicStates.Data(),
    };

    VkVertexInputBindingDescription inputBindingDescription =
    {
        .binding   = 0,
        .stride    = sizeof(StaticVertex),
        .inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
    };

    VkPipelineVertexInputStateCreateInfo vertexInputInfo =
    {
        .sType                           = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
        .vertexBindingDescriptionCount   = 1u,
        .pVertexBindingDescriptions      = &inputBindingDescription,
        .vertexAttributeDescriptionCount = Size(StaticVertex::Attributes),
        .pVertexAttributeDescriptions    = StaticVertex::Attributes,
    };

    VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo =
    {
        .sType                  = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
        .topology               = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
        .primitiveRestartEnable = VK_FALSE,
    };

    VkPipelineViewportStateCreateInfo viewportStateInfo =
    {
        .sType         = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
        .viewportCount = 1,
        .scissorCount  = 1,
    };

    VkPipelineRasterizationStateCreateInfo rasterizationInfo =
    {
        .sType     = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
        .cullMode  = VK_CULL_MODE_NONE, //VK_CULL_MODE_BACK_BIT,
        .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
        .lineWidth = 1.0f,
    };

    VkPipelineMultisampleStateCreateInfo multisampleInfo =
    {
        .sType                = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
    };

    VkPipelineDepthStencilStateCreateInfo depthStencilInfo =
    {
        .sType            = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
        .depthTestEnable  = VK_TRUE,
        .depthWriteEnable = VK_TRUE,
        .depthCompareOp   = VK_COMPARE_OP_LESS,
        .minDepthBounds   = 0.0f,
        .maxDepthBounds   = 1.0f,
    };

    VkPipelineColorBlendAttachmentState attachmentBlendState =
    {
        .colorWriteMask =  VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
                           VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
    };

    VkPipelineColorBlendStateCreateInfo colorBlendStateInfo =
    {
        .sType           = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
        .attachmentCount = 1,
        .pAttachments    = &attachmentBlendState,
    };

    VkPipelineLayoutCreateInfo pipelineLayoutInfo =
    {
        .sType          = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .setLayoutCount = 1,
        .pSetLayouts    = &descriptorSetLayout
    };
    VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
    vkCreatePipelineLayout(r_renderContext->Device(), &pipelineLayoutInfo, nullptr, &pipelineLayout);

    VkFormat colorFormat = FormatToSrgbFormat(r_swapchain->Format());
    VkFormat depthFormat = *FindDepthFormat(r_renderContext->PhysicalDevice());
    VkPipelineRenderingCreateInfo renderingInfo =
    {
        .sType                   = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
        .viewMask                = 0u,
        .colorAttachmentCount    = 1u,
        .pColorAttachmentFormats = &colorFormat,
        .depthAttachmentFormat   = depthFormat
    };

    VkGraphicsPipelineCreateInfo pipelineInfo =
    {
        .sType               = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
        .pNext               = &renderingInfo,
        .stageCount          = Size(stages),
        .pStages             = stages,
        .pVertexInputState   = &vertexInputInfo,
        .pInputAssemblyState = &inputAssemblyInfo,
        .pViewportState      = &viewportStateInfo,
        .pRasterizationState = &rasterizationInfo,
        .pMultisampleState   = &multisampleInfo,
        .pDepthStencilState  = &depthStencilInfo,
        .pColorBlendState    = &colorBlendStateInfo,
        .pDynamicState       = &dynamicStateInfo,
        .layout              = pipelineLayout,
    };

    VkPipeline pipeline = VK_NULL_HANDLE;
    if (vkCreateGraphicsPipelines(r_renderContext->Device(), VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline) != VK_SUCCESS)
    {
        log::err("Blah");
        return 1;
    }

    auto r_buffer = r_renderContext->CreateBuffer(256 * 1024 * 1024);
    if (!r_buffer)
        return 1;

    VkBufferViewCreateInfo bufferViewInfo =
    {
        .sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
        .buffer = r_buffer->buffer,
        .format = VK_FORMAT_R8G8B8A8_UNORM,
        .offset = 0,
        .range  = r_buffer->size,
    };
    VkBufferView bufferView = VK_NULL_HANDLE;
    vkCreateBufferView(r_renderContext->Device(), &bufferViewInfo, nullptr, &bufferView);

    struct UniformData
    {
        mat4 projection;
        mat4 view;
    };

    Camera camera;
    camera.transform.position = vec3{0.0f, 0.0f, 80.0f};
    camera.viewportAspectRatio = 16.0f / 9.0f;
    //camera.offsetOrientation(1_deg * Seconds(t2 - t1).count(), 0_deg);
    //camera.lookAt(vec3{40.0f, 40.0f, 0.0f});
    camera.transform.orientation = eulerAnglesToQuaternion(EulerAngles{ 0_deg, 0_deg, 0_deg });

    UniformData uniformData
    {
        .projection = camera.projection(),
        .view = camera.view(),
    };

    auto pooler = MemoryPool{ *r_buffer };
    auto meshData = r_mesh->vertexData.View();
    auto vertexSlice = *pooler.AllocSlice(meshData.size, 16);
    auto indexSlice = *pooler.AllocSlice(r_mesh->indices.Size() * sizeof(uint16_t), 16);
    auto uniformSlice = *pooler.AllocSlice(sizeof(UniformData), 16);
    auto r_depthImage = r_renderContext->CreateImage(pooler, 1280, 720, depthFormat);

    VkImageViewCreateInfo depthImageViewInfo =
    {
        .sType    = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .image    = *r_depthImage,
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
        .format   = depthFormat,
        .subresourceRange = FirstDepthMipSubresourceRange,
    };

    VkImageView depthImageView = VK_NULL_HANDLE;
    if (vkCreateImageView(r_renderContext->Device(), &depthImageViewInfo, nullptr, &depthImageView) != VK_SUCCESS)
        return 1;

    VkDescriptorBufferInfo bufferInfo =
    {
        .buffer = r_buffer->buffer,
        .offset = uniformSlice.offset,
        .range  = uniformSlice.size,
    };

    VkWriteDescriptorSet writeDescriptorSet[] =
    {
        {
            .sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet          = descriptorSet,
            .dstBinding      = 0,
            .descriptorCount = 1,
            .descriptorType  = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            .pBufferInfo     = &bufferInfo,
        },
    };
    vkUpdateDescriptorSets(r_renderContext->Device(), Size(writeDescriptorSet), writeDescriptorSet, 0, nullptr);

    meshData.Copy       ((uint8_t*)(r_buffer->ptr) + vertexSlice.offset);
    r_mesh->indices.Copy((uint8_t*)(r_buffer->ptr) + indexSlice.offset);

    memcpy((uint8_t*)(r_buffer->ptr) + uniformSlice.offset, &uniformData, sizeof(uniformData));

    r_window->EnableRelativeMouse(true);

    auto t1 = Time::now();
    while (r_window->Update())
    {
        const auto t2 = Time::now();
        const float dt = Seconds(t2 - t1).count();
        t1 = t2;

        {
            auto mouseDelta = r_window->GetMouseDelta();
            //if (mouseDelta.x || mouseDelta.y)
            //{
            //    log::info("mouse: %d %d", mouseDelta.x, mouseDelta.y);
            //}

            const float sensitivity = 6.0f;

            camera.offsetOrientation(
                -sensitivity * dt * Radian( mouseDelta.x ),
                 sensitivity * dt * Radian( mouseDelta.y ));
            UniformData uniformData
            {
                .projection = camera.projection(),
                .view = camera.view(),
            };
            // NEED TO SYNCHRONIZE THIS
            memcpy((uint8_t*)(r_buffer->ptr) + uniformSlice.offset, &uniformData, sizeof(uniformData));
        }

        VkCommandBuffer cmdBuf = r_swapchain->CommandBuffer();
        r_renderContext->BeginCommandBuffer(cmdBuf);
        {
            VkViewport viewport =
            {
                .x        = 0.0f,
                .y        = 0.0f,
                .width    = float(r_swapchain->Extent().width),
                .height   = float(r_swapchain->Extent().height),
                .minDepth = 0.0f,
                .maxDepth = 1.0f,
            };

            VkRect2D scissor =
            {
                .offset = {0u, 0u},
                .extent = r_swapchain->Extent(),
            };

            vkCmdSetViewport(cmdBuf, 0, 1, &viewport);  
            vkCmdSetScissor(cmdBuf, 0, 1, &scissor);

            vkCmdBindPipeline(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
            vkCmdBindDescriptorSets(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);

            vkCmdBindVertexBuffers2(cmdBuf, 0, 1, &vertexSlice.buffer, &vertexSlice.offset, &vertexSlice.size, nullptr);
            vkCmdBindIndexBuffer(cmdBuf, r_buffer->buffer, indexSlice.offset, VK_INDEX_TYPE_UINT16);

            const VkImageMemoryBarrier undefinedToColorBarrier =
            {
                .sType            = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
                .dstAccessMask    = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
                .oldLayout        = VK_IMAGE_LAYOUT_UNDEFINED,
                .newLayout        = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                .image            = r_swapchain->Image(),
                .subresourceRange = FirstColorMipSubresourceRange,
            };

            vkCmdPipelineBarrier(
                cmdBuf,
                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                0,
                0, nullptr,
                0, nullptr,
                1, &undefinedToColorBarrier);

            const VkImageMemoryBarrier undefinedToDepthBarrier =
            {
                .sType            = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
                .dstAccessMask    = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
                .oldLayout        = VK_IMAGE_LAYOUT_UNDEFINED,
                .newLayout        = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                .image            = *r_depthImage,
                .subresourceRange = FirstColorMipSubresourceRange,
            };

            vkCmdPipelineBarrier(
                cmdBuf,
                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
                0,
                0, nullptr,
                0, nullptr,
                1, &undefinedToDepthBarrier);

            const VkRenderingAttachmentInfoKHR colorAttachmentInfos[] =
            {
                {
                    .sType       = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
                    .imageView   = r_swapchain->ImageView(),
                    .imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
                    .loadOp      = VK_ATTACHMENT_LOAD_OP_CLEAR,
                    .storeOp     = VK_ATTACHMENT_STORE_OP_STORE,
                    .clearValue  = { .color = { .float32 = { 1.0f, 0.5f, 0.0f, 1.0f } } },
                },
            };

            const VkRenderingAttachmentInfoKHR depthAttachmentInfo =
            {
                .sType       = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
                .imageView   = depthImageView,
                .imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
                .loadOp      = VK_ATTACHMENT_LOAD_OP_CLEAR,
                .storeOp     = VK_ATTACHMENT_STORE_OP_STORE,
                .clearValue  = { .color = { .float32 = { 1.0f, 1.0f, 1.0f, 1.0f } } },
            };

            const VkRenderingInfo renderInfo =
            {
                .sType                = VK_STRUCTURE_TYPE_RENDERING_INFO,
                .renderArea           = { {}, r_swapchain->Extent() },
                .layerCount           = 1,
                .colorAttachmentCount = Size(colorAttachmentInfos),
                .pColorAttachments    = colorAttachmentInfos,
                .pDepthAttachment     = &depthAttachmentInfo,
            };
            vkCmdBeginRendering(cmdBuf, &renderInfo);
            vkCmdDrawIndexed(cmdBuf, r_mesh->indices.Size(), 1, 0, 0, 0);
            vkCmdEndRendering(cmdBuf);

            const VkImageMemoryBarrier colorToPresentBarrier =
            {
                .sType            = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
                .srcAccessMask    = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
                .oldLayout        = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                .newLayout        = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
                .image            = r_swapchain->Image(),
                .subresourceRange = FirstColorMipSubresourceRange,
            };

            vkCmdPipelineBarrier(
                cmdBuf,
                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                0,
                0, nullptr,
                0, nullptr,
                1, &colorToPresentBarrier);
        }
        r_renderContext->EndCommandBuffer(cmdBuf);
        r_swapchain->Present();
    }

    return 0;
}