Fixed issues with vertex buffers not copying data

Author: Raelr

engine/render/assets/shaders/BillboardInstanced.frag

@@ -0,0 +1,22 @@
+//
+//  Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+//  This code is released under an unmodified zlib license.
+//  For conditions of distribution and use, please see:
+//      https://opensource.org/licenses/Zlib
+//
+
+#version 450
+
+layout (location = 0) in vec4 fragColour;
+layout (location = 1) in vec2 uv;
+layout (location = 2) in flat uint texId;
+
+layout (location = 0) out vec4 outColour;
+
+layout(binding = 1) uniform sampler2D tex[16];
+
+void main() {
+    vec4 sampled = texture(tex[texId], vec2(uv.x, -uv.y));
+    outColour = sampled * fragColour;
+}

engine/render/assets/shaders/BillboardInstanced.vert

@@ -0,0 +1,59 @@
+#version 450
+
+//
+//  Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+//  This code is released under an unmodified zlib license.
+//  For conditions of distribution and use, please see:
+//      https://opensource.org/licenses/Zlib
+//
+
+// Per instance data
+layout (location = 0) in vec3 inPosition;
+layout (location = 1) in vec3 inScale;
+layout (location = 2) in vec4 inColour;
+layout (location = 3) in vec4 inUv;
+
+layout (location = 0) out vec4 outColour;
+layout (location = 1) out vec2 outUv;
+layout (location = 2) out flat uint outTexId;
+
+layout (push_constant) uniform PushConstant {
+    uint textureIndex;
+} pushConstant;
+
+vec3 quadVertices[4] = {
+    vec3(1.0, 1.0, 0),
+    vec3(1.0, -1.0, 0),
+    vec3(-1.0, -1.0, 0),
+    vec3(-1.0, 1.0, 0)
+};
+
+struct CameraData
+{
+    mat4 projectionMatrix;
+    mat4 viewMatrix;
+};
+
+layout (binding = 0) uniform GlobalData {
+    CameraData cameraData;
+} globalData;
+
+CameraData camera = globalData.cameraData;
+
+void main() {
+    vec4 quadInCameraSpace = camera.viewMatrix * vec4(inPosition,  1.0);
+
+    vec4 positionInCameraSpace = quadInCameraSpace + vec4(quadVertices[gl_VertexIndex].xy * (inScale.xy * 0.5), 0.0, 0.0);
+
+    gl_Position = camera.projectionMatrix * positionInCameraSpace;
+
+    float uvx = (float(gl_VertexIndex == 0 || gl_VertexIndex == 1) * (inUv.x + inUv.z))
+    + (float(gl_VertexIndex == 2 || gl_VertexIndex == 3) * (inUv.x));
+    float uvy = (float(gl_VertexIndex == 0 || gl_VertexIndex == 3) * (inUv.y + inUv.w))
+    + (float(gl_VertexIndex == 1 || gl_VertexIndex == 2) * (inUv.y));
+
+    outColour = inColour;
+    outUv = vec2(uvx, uvy);
+    outTexId = pushConstant.textureIndex;
+}

engine/render/assets/shaders/billboard.frag

@@ -0,0 +1,129 @@
+//
+// Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+// This code is released under an unmodified zlib license.
+// For conditions of distribution and use, please see:
+//     https://opensource.org/licenses/Zlib
+//
+
+#include "VBuffer.h"
+
+#include <utils/Logging.h>
+
+#include <cstdlib>
+#include <cstring>
+
+#include "Context.h"
+#include "utils/Buffer.h"
+
+namespace Siege::Vulkan
+{
+
+VBuffer::VBuffer(unsigned long bufferSize) : size {bufferSize}
+{
+    CC_ASSERT(bufferSize > 0,
+              "Cannot allocate vertex buffer of size 0. If you wanted to create an "
+              "empty vertex buffer then please use the default constructor")
+
+    rawBuffer = malloc(bufferSize);
+
+    auto device = Context::GetVkLogicalDevice();
+
+    auto physicalDevice = Context::GetPhysicalDevice()->GetDevice();
+
+    Utils::CreateBuffer(device,
+                        physicalDevice,
+                        size,
+                        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+                        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                        buffer,
+                        memory);
+
+    Utils::CopyData(device, memory, size, rawBuffer, 0);
+}
+
+VBuffer::VBuffer(void* data, unsigned long bufferSize) : VBuffer(bufferSize)
+{
+    memcpy(rawBuffer, data, bufferSize);
+}
+
+void VBuffer::Copy(void* data, unsigned long dSize, unsigned long offset)
+{
+    auto device = Context::GetVkLogicalDevice();
+
+    if (size < dSize)
+    {
+    }
+
+    void* dst = reinterpret_cast<char*>(rawBuffer) + offset;
+    memcpy(dst, data, dSize);
+    Utils::CopyData(device, memory, dSize, dst, offset);
+}
+
+VBuffer::VBuffer(VBuffer&& other)
+{
+    Swap(other);
+}
+
+VBuffer::VBuffer(const VBuffer& other) : VBuffer(other.rawBuffer, other.size) {}
+
+VBuffer::~VBuffer()
+{
+    Free();
+}
+
+void VBuffer::Bind(const CommandBuffer& commandBuffer,
+                   unsigned long long* offset,
+                   unsigned int binding)
+{
+    vkCmdBindVertexBuffers(commandBuffer.Get(), binding, 1, &buffer, offset);
+}
+
+void VBuffer::Free()
+{
+    VkDevice device = Vulkan::Context::GetVkLogicalDevice();
+
+    if (device == nullptr) return;
+
+    free(rawBuffer);
+    Utils::FreeBuffer(device, buffer, memory);
+    size = 0;
+    rawBuffer = nullptr;
+    buffer = nullptr;
+    memory = nullptr;
+}
+
+VBuffer& VBuffer::operator=(const VBuffer& other)
+{
+    size = other.size;
+    rawBuffer = malloc(size);
+    memcpy(rawBuffer, other.rawBuffer, size);
+    return *this;
+}
+
+VBuffer& VBuffer::operator=(VBuffer&& other)
+{
+    Swap(other);
+    return *this;
+}
+
+void VBuffer::Allocate(void* data, unsigned long long newSize) {}
+
+void VBuffer::Swap(VBuffer& other)
+{
+    auto tmpRawBuffer = rawBuffer;
+    auto tmpSize = size;
+    auto tmpBuffer = buffer;
+    auto tmpMemory = memory;
+
+    rawBuffer = other.rawBuffer;
+    size = other.size;
+    buffer = other.buffer;
+    memory = other.memory;
+
+    other.rawBuffer = tmpRawBuffer;
+    other.size = tmpSize;
+    other.buffer = tmpBuffer;
+    other.memory = tmpMemory;
+}
+} // namespace Siege::Vulkan

engine/render/assets/shaders/billboard.vert

@@ -0,0 +1,62 @@
+//
+// Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+// This code is released under an unmodified zlib license.
+// For conditions of distribution and use, please see:
+//     https://opensource.org/licenses/Zlib
+//
+
+#ifndef SIEGE_ENGINE_VBUFFER_H
+#define SIEGE_ENGINE_VBUFFER_H
+
+#include "CommandBuffer.h"
+#include "utils/Types.h"
+
+namespace Siege::Vulkan
+{
+
+class VBuffer
+{
+public:
+
+    // 'Structor
+
+    VBuffer() = default;
+    VBuffer(void* data, unsigned long bufferSize);
+    VBuffer(unsigned long bufferSize);
+    VBuffer(VBuffer&& other);
+    VBuffer(const VBuffer& other);
+    ~VBuffer();
+
+    // Operators
+
+    VBuffer& operator=(const VBuffer& other);
+    VBuffer& operator=(VBuffer&& other);
+
+    // Functions
+
+    void Copy(void* data, unsigned long size, unsigned long offset = 0);
+    void Bind(const CommandBuffer& commandBuffer,
+              unsigned long long* offset,
+              unsigned int binding = 0);
+    void Free();
+
+    template<typename T>
+    const T* Cast(unsigned long offset = 0)
+    {
+        return reinterpret_cast<T*>(rawBuffer) + offset;
+    }
+
+private:
+
+    void Allocate(void* data, unsigned long long newSize);
+    void Swap(VBuffer& other);
+    void* rawBuffer {nullptr};
+    VkBuffer buffer {nullptr};
+    VkDeviceMemory memory {nullptr};
+    unsigned long size {0};
+};
+
+} // namespace Siege::Vulkan
+
+#endif // SIEGE_ENGINE_VBUFFER_H