Re-added docs for Index and Vertex buffer types and cleaned files

Author: Raelr

engine/render/renderer/platform/vulkan/IndexBuffer.h

@@ -23,28 +23,96 @@ class IndexBuffer
 
     // 'Structors
 
+    /**
+     * The default constructor for the IndexBuffer class
+     */
     IndexBuffer() = default;
+
+    /**
+     * The IndexBuffer base constructor. Accepts index data along with a size to construct the
+     * buffer with
+     * @param data the data to copy into the buffer
+     * @param dataSize the size of the data in bytes
+     */
     IndexBuffer(void* data, uint64_t dataSize);
+
+    /**
+     * A zero copy constructor. Initialises the IndexBuffer with a maximum size but no data
+     * @param bufferSize the total size of the buffer in bytes
+     */
     IndexBuffer(unsigned long bufferSize);
+
+    /**
+     * An IndexBuffer copy constructor. Creates a new IndexBuffer with the contents of another
+     * IndexBuffer
+     * @param other the index buffer to copy data from
+     */
     IndexBuffer(const IndexBuffer& other);
+
+    /**
+     * An IndexBuffer move constructor. Creates a new IndexBuffer with the moved memory from another
+     * IndexBuffer
+     * @param other the IndexBuffer to move data from
+     */
     IndexBuffer(IndexBuffer&& other);
+
+    /**
+     * The IndexBuffer destructor. Frees all memory and resets the IndexBuffer
+     */
     ~IndexBuffer();
 
     // Operator overload
 
+    /**
+     * The IndexBuffer copy assignment operator. Copies the value from one IndexBuffer into another
+     * @param other the IndexBuffer to copy data from
+     * @return a reference to the current IndexBuffer
+     */
     IndexBuffer& operator=(const IndexBuffer& other);
+
+    /**
+     * The IndexBuffer move assignment operator. Moves the value from one IndexBuffer into another
+     * @param other the IndexBuffer to move data from
+     * @return a reference to the current IndexBuffer
+     */
     IndexBuffer& operator=(IndexBuffer&& other);
 
     // Functions
 
+    /**
+     * Frees all memory from the IndexBuffer and resets all values
+     */
     void Free();
+
+    /**
+     * Copies the provided data into the IndexBuffer with an offset
+     * @param data the data to be copied into the buffer
+     * @param size the size in bytes of the data
+     * @param offset the byte offset to copy the data to
+     */
     void Copy(const void* data, unsigned long size, unsigned long offset = 0);
+
+    /**
+     * Binds the IndexBuffer for rendering
+     * @param commandBuffer the command buffer to bind to
+     * @param offset the byte offset to bind
+     */
     void Bind(const CommandBuffer& commandBuffer, uint64_t offset = 0);
 
 private:
 
+    /**
+     * Swaps the contents of two buffers
+     * @param other the buffer to swap values with
+     */
     void Swap(IndexBuffer& other);
+
+    /**
+     * Allocates memory for the buffer
+     * @param device the device to allocate memory from
+     */
     void Allocate(VkDevice device);
+
     void* rawBuffer {nullptr};
     VkBuffer buffer {nullptr};
     VkDeviceMemory memory {nullptr};

engine/render/renderer/platform/vulkan/VertexBuffer.h

@@ -23,24 +23,87 @@ class VertexBuffer
 
     // 'Structor
 
+    /**
+     * The default constructor for the VertexBuffer
+     */
     VertexBuffer() = default;
+
+    /**
+     * A constructor for the VertexBuffer which accepts vertex data during construction
+     * @param data the vertex data to be copied in
+     * @param bufferSize the size of the data in bytes
+     */
     VertexBuffer(void* data, unsigned long bufferSize);
+
+    /**
+     * A zero-data constructor for the VertxBuffer. Initialises a vertex buffer with no data but
+     * with the given size
+     * @param bufferSize the total size of the buffer in bytes
+     */
     VertexBuffer(unsigned long bufferSize);
+
+    /**
+     * The move constructor from another VertexBuffer
+     * @param other the other vertex buffer to move
+     */
     VertexBuffer(VertexBuffer&& other);
+
+    /**
+     * The copy constructor from another VertexBuffer
+     * @param other the other vertex buffer to copy from
+     */
     VertexBuffer(const VertexBuffer& other);
+
+    /**
+     * The VertexBuffer destructor
+     */
     ~VertexBuffer();
 
     // Operators
 
+    /**
+     * The copy assignment operator. Copies the values of one Vertex Buffer to another
+     * @param other the Vertex Buffer to copy
+     * @return a reference to the current VertexBuffer
+     */
     VertexBuffer& operator=(const VertexBuffer& other);
+
+    /**
+     * The move assignment operator. Moves the values of one Vertex Buffer to another
+     * @param other the Vertex buffer being moved
+     * @return a reference to the current VertexBuffer
+     */
     VertexBuffer& operator=(VertexBuffer&& other);
 
     // Functions
 
+    /**
+     * Copies the provided data into the buffer
+     * @param data the data to be copied
+     * @param size the size of the data in bytes
+     * @param offset the offset to copy the data to within the buffer
+     */
     void Copy(const void* data, unsigned long size, unsigned long offset = 0);
+
+    /**
+     * Binds the VertexBuffer for rendering
+     * @param commandBuffer the command buffer the binding should apply to
+     * @param offset the offset of the buffer to bind in bytes
+     * @param binding the vertex binding ID to use
+     */
     void Bind(const CommandBuffer& commandBuffer, const uint64_t* offset, unsigned int binding = 0);
+
+    /**
+     * Frees the contents of the VertexBuffer
+     */
     void Free();
 
+    /**
+     * Casts the contents of the buffer to a specific type
+     * @tparam T the type to cast the contents to
+     * @param offset the offset to retrieve in bytes
+     * @return the entire buffer cast to the requested type
+     */
     template<typename T>
     const T* Cast(unsigned long offset = 0)
     {
@@ -49,8 +112,18 @@ class VertexBuffer
 
 private:
 
+    /**
+     * Swaps the contents of two VertexBuffers
+     * @param other the VertexBuffer to swap with
+     */
     void Swap(VertexBuffer& other);
+
+    /**
+     * Allocates the memory for the VertexBuffer
+     * @param device the device used for allocation
+     */
     void Allocate(VkDevice device);
+
     void* rawBuffer {nullptr};
     VkBuffer buffer {nullptr};
     VkDeviceMemory memory {nullptr};

engine/render/renderer/renderer/Renderer2D.cpp

@@ -239,7 +239,6 @@ void Renderer2D::RenderQuads(Vulkan::CommandBuffer& buffer, size_t index)
         uint64_t bindOffset = sizeof(QuadVertex) * vertexBufferOffset;
 
         quadVBuffer.Bind(buffer, &bindOffset);
-        // quadVertexBuffer.Bind(buffer, &vertexBufferOffset);
 
         Vulkan::Utils::DrawIndexed(buffer.Get(), 6, quadArr.Count(), 0, 0, 0);
     }

engine/utils/Logging.h

@@ -99,7 +99,7 @@ class VariantContainer
     DEFINE_VARIANT_TYPE(const Vec2& data, "Vector2(" + ToString(data) + ")");
     DEFINE_VARIANT_TYPE(const Vec3& data, "Vector3(" + ToString(data) + ")");
     DEFINE_VARIANT_TYPE(const Vec4& data, "Vector4(" + ToString(data) + ")");
-    //    DEFINE_VARIANT_TYPE(const Mat2& data, "Mat2(" + ToString(data) + ")");
+    DEFINE_VARIANT_TYPE(const Mat2& data, "Mat2(" + ToString(data) + ")");
     DEFINE_VARIANT_TYPE(const Mat3& data, "Mat3(" + ToString(data) + ")");
     DEFINE_VARIANT_TYPE(const Mat4& data, "Mat4(" + ToString(data) + ")");
 

engine/utils/math/Maths.h

@@ -18,6 +18,13 @@
 
 namespace Siege
 {
+
+template<typename T>
+inline constexpr T Epsilon()
+{
+    return static_cast<T>(1e-6);
+}
+
 struct BoundedBox
 {
     // 'Structors

engine/utils/math/mat/Equality.h

@@ -21,21 +21,28 @@ namespace Siege
  * @tparam T the type of numerical value stored by the matrix
  * @param lhs the matrix on the left hand side of the operation
  * @param rhs the matrix on the right hand side of the operation
+ * @param epsilon the tolerance level for the comparison
  * @return a boolean specifying if they are equal within the given tolerance
  */
 template<typename T>
-inline constexpr bool FEquals(const Mat<T, 4, 4>& lhs, const Mat<T, 4, 4>& rhs)
+inline constexpr bool Equals(const Mat<T, 4, 4>& lhs, const Mat<T, 4, 4>& rhs, T epsilon = 0)
 {
-    T epsilon = std::numeric_limits<T>::epsilon();
-
-    return (lhs[0][0] - rhs[0][0] <= epsilon) && (lhs[0][1] - rhs[0][1] <= epsilon) &&
-           (lhs[0][2] - rhs[0][2] <= epsilon) && (lhs[0][3] - rhs[0][3] <= epsilon) &&
-           (lhs[1][0] - rhs[1][0] <= epsilon) && (lhs[1][1] - rhs[1][1] <= epsilon) &&
-           (lhs[1][2] - rhs[1][2] <= epsilon) && (lhs[1][3] - rhs[1][3] <= epsilon) &&
-           (lhs[2][0] - rhs[2][0] <= epsilon) && (lhs[2][1] - rhs[2][1] <= epsilon) &&
-           (lhs[2][2] - rhs[2][2] <= epsilon) && (lhs[2][3] - rhs[2][3] <= epsilon) &&
-           (lhs[3][0] - rhs[3][0] <= epsilon) && (lhs[3][1] - rhs[3][1] <= epsilon) &&
-           (lhs[3][2] - rhs[3][2] <= epsilon) && (lhs[3][3] - rhs[3][3] <= epsilon);
+    return (std::fabs(lhs[0][0] - rhs[0][0]) <= epsilon) &&
+           (std::fabs(lhs[0][1] - rhs[0][1]) <= epsilon) &&
+           (std::fabs(lhs[0][2] - rhs[0][2]) <= epsilon) &&
+           (std::fabs(lhs[0][3] - rhs[0][3]) <= epsilon) &&
+           (std::fabs(lhs[1][0] - rhs[1][0]) <= epsilon) &&
+           (std::fabs(lhs[1][1] - rhs[1][1]) <= epsilon) &&
+           (std::fabs(lhs[1][2] - rhs[1][2]) <= epsilon) &&
+           (std::fabs(lhs[1][3] - rhs[1][3]) <= epsilon) &&
+           (std::fabs(lhs[2][0] - rhs[2][0]) <= epsilon) &&
+           (std::fabs(lhs[2][1] - rhs[2][1]) <= epsilon) &&
+           (std::fabs(lhs[2][2] - rhs[2][2]) <= epsilon) &&
+           (std::fabs(lhs[2][3] - rhs[2][3]) <= epsilon) &&
+           (std::fabs(lhs[3][0] - rhs[3][0]) <= epsilon) &&
+           (std::fabs(lhs[3][1] - rhs[3][1]) <= epsilon) &&
+           (std::fabs(lhs[3][2] - rhs[3][2]) <= epsilon) &&
+           (std::fabs(lhs[3][3] - rhs[3][3]) <= epsilon);
 }
 
 /**
@@ -44,18 +51,21 @@ inline constexpr bool FEquals(const Mat<T, 4, 4>& lhs, const Mat<T, 4, 4>& rhs)
  * @tparam T the type of numerical value stored by the matrix
  * @param lhs the matrix on the left hand side of the operation
  * @param rhs the matrix on the right hand side of the operation
+ * @param epsilon the tolerance level for the comparison
  * @return a boolean specifying if they are equal within the given tolerance
  */
 template<typename T>
-inline constexpr bool FEquals(const Mat<T, 3, 3>& lhs, const Mat<T, 3, 3>& rhs)
+inline constexpr bool Equals(const Mat<T, 3, 3>& lhs, const Mat<T, 3, 3>& rhs, T epsilon = 0)
 {
-    T epsilon = std::numeric_limits<T>::epsilon();
-
-    return (lhs[0][0] - rhs[0][0] <= epsilon) && (lhs[0][1] - rhs[0][1] <= epsilon) &&
-           (lhs[0][2] - rhs[0][2] <= epsilon) && (lhs[1][0] - rhs[1][0] <= epsilon) &&
-           (lhs[1][1] - rhs[1][1] <= epsilon) && (lhs[1][2] - rhs[1][2] <= epsilon) &&
-           (lhs[2][0] - rhs[2][0] <= epsilon) && (lhs[2][1] - rhs[2][1] <= epsilon) &&
-           (lhs[2][2] - rhs[2][2] <= epsilon);
+    return (std::fabs(lhs[0][0] - rhs[0][0]) <= epsilon) &&
+           (std::fabs(lhs[0][1] - rhs[0][1]) <= epsilon) &&
+           (std::fabs(lhs[0][2] - rhs[0][2]) <= epsilon) &&
+           (std::fabs(lhs[1][0] - rhs[1][0]) <= epsilon) &&
+           (std::fabs(lhs[1][1] - rhs[1][1]) <= epsilon) &&
+           (std::fabs(lhs[1][2] - rhs[1][2]) <= epsilon) &&
+           (std::fabs(lhs[2][0] - rhs[2][0]) <= epsilon) &&
+           (std::fabs(lhs[2][1] - rhs[2][1]) <= epsilon) &&
+           (std::fabs(lhs[2][2] - rhs[2][2]) <= epsilon);
 }
 
 /**
@@ -64,14 +74,16 @@ inline constexpr bool FEquals(const Mat<T, 3, 3>& lhs, const Mat<T, 3, 3>& rhs)
  * @tparam T the type of numerical value stored by the matrix
  * @param lhs the matrix on the left hand side of the operation
  * @param rhs the matrix on the right hand side of the operation
+ * @param epsilon the tolerance level for the comparison
  * @return a boolean specifying if they are equal within the given tolerance
  */
 template<typename T>
-inline constexpr bool FEquals(const Mat<T, 2, 2>& lhs, const Mat<T, 2, 2>& rhs)
+inline constexpr bool Equals(const Mat<T, 2, 2>& lhs, const Mat<T, 2, 2>& rhs, T epsilon = 0)
 {
-    T epsilon = std::numeric_limits<T>::epsilon();
-    return (lhs[0][0] - rhs[0][0] <= epsilon) && (lhs[0][1] - rhs[0][1] <= epsilon) &&
-           (lhs[1][0] - rhs[1][0] <= epsilon) && (lhs[1][1] - rhs[1][1] <= epsilon);
+    return (std::fabs(lhs[0][0] - rhs[0][0]) <= epsilon) &&
+           (std::fabs(lhs[0][1] - rhs[0][1]) <= epsilon) &&
+           (std::fabs(lhs[1][0] - rhs[1][0]) <= epsilon) &&
+           (std::fabs(lhs[1][1] - rhs[1][1]) <= epsilon);
 }
 } // namespace Siege
 

engine/utils/math/vec/Equality.h

@@ -16,6 +16,14 @@
 namespace Siege
 {
 
+/**
+ * Calculates the epsilon scaled to the larger of the values to compare. Creates a more generous
+ * tolerance level than a standard epsilon
+ * @tparam T The type of the values to compare
+ * @param lhs the value on the left hand side
+ * @param rhs the value on the right hand side
+ * @return the scaled epsilon of the two values
+ */
 template<typename T>
 inline constexpr T ScaledEpsilon(T lhs, T rhs)
 {

engine/utils/math/vec/Vec2.h

@@ -258,11 +258,11 @@ struct Vec<T, 2>
     {
         switch (index)
         {
-            default:
-            case (0):
-                return x;
             case (1):
                 return y;
+            case (0):
+            default:
+                return x;
         }
     }
 

engine/utils/math/vec/Vec3.h

@@ -293,13 +293,13 @@ struct Vec<T, 3>
     {
         switch (index)
         {
-            default:
-            case (0):
-                return x;
             case (1):
                 return y;
             case (2):
                 return z;
+            case (0):
+            default:
+                return x;
         }
     }
 

engine/utils/math/vec/Vec4.h

@@ -303,15 +303,15 @@ struct Vec<T, 4>
     {
         switch (index)
         {
-            default:
-            case (0):
-                return x;
             case (1):
                 return y;
             case (2):
                 return z;
             case (3):
                 return w;
+            case (0):
+            default:
+                return x;
         }
     }