Created TextureAtlas class and implemented basic texture atlas functions

Author: Raelr

engine/render/renderer/Renderer.cpp

@@ -122,6 +122,16 @@ void Renderer::DrawQuad(const Vec2 position,
     renderer2D.DrawQuad(position, scale, colour, rotation, zIndex, texture);
 }
 
+void Renderer::DrawQuad(const Vec2 position,
+                        Vulkan::TextureAtlas::TextureRef texture,
+                        const Vec2 scale,
+                        const IColour colour,
+                        float rotation,
+                        const uint8_t zIndex)
+{
+    renderer2D.DrawQuad(position, texture, scale, colour, rotation, zIndex);
+}
+
 void Renderer::DrawText2D(const char* text,
                           Vulkan::Font& font,
                           const Vec2 position,

engine/render/renderer/Renderer.h

@@ -53,6 +53,12 @@ class Renderer
                   float rotation = 0.f,
                   const uint8_t zIndex = 0,
                   Vulkan::Texture2D* texture = nullptr);
+    void DrawQuad(const Vec2 position,
+                  Vulkan::TextureAtlas::TextureRef texture,
+                  const Vec2 scale = {1.f, 1.f},
+                  const IColour colour = IColour::White,
+                  float rotation = 0.f,
+                  const uint8_t zIndex = 0);
     void DrawText2D(const char* text,
                     Vulkan::Font& font,
                     const Vec2 position,

engine/render/renderer/platform/vulkan/TextureAtlas.cpp

@@ -0,0 +1,58 @@
+//
+// Copyright (c) 2020-present Caps Collective & contributors
+// Originally authored by Jonathan Moallem (@jonjondev) & 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 "TextureAtlas.h"
+
+namespace Siege::Vulkan
+{
+Texture2D& TextureAtlas::TextureRef::operator*()
+{
+    return parentAtlas.texture;
+}
+
+TextureAtlas::TextureAtlas(const char* name,
+                           const char* filePath,
+                           Utils::Extent2DF imageExtents,
+                           Utils::TextureFilter filter) :
+    fixedExtent {imageExtents}
+{
+    texture = Texture2D(name, filePath, filter);
+}
+
+TextureAtlas::TextureAtlas(TextureAtlas&& other)
+{
+    Swap(other);
+}
+
+TextureAtlas::~TextureAtlas() {}
+
+void TextureAtlas::Swap(TextureAtlas& other)
+{
+    auto tmpTexture = std::move(texture);
+    auto tmpFixedExtent = fixedExtent;
+
+    texture = std::move(other.texture);
+    fixedExtent = other.fixedExtent;
+
+    other.texture = std::move(tmpTexture);
+    other.fixedExtent = tmpFixedExtent;
+}
+
+TextureAtlas::TextureRef TextureAtlas::operator[](size_t index)
+{
+    size_t elementsInRow = 1 / fixedExtent.width;
+
+    return TextureRef(*this,
+                      (index % elementsInRow) * fixedExtent.width, // potentially slow code
+                      (index / elementsInRow) * fixedExtent.height,
+                      fixedExtent.width,
+                      fixedExtent.height);
+}
+
+} // namespace Siege::Vulkan

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

@@ -0,0 +1,80 @@
+//
+// Copyright (c) 2020-present Caps Collective & contributors
+// Originally authored by Jonathan Moallem (@jonjondev) & 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_VULKAN_TEXTURE_ATLAS_H
+#define SIEGE_ENGINE_VULKAN_TEXTURE_ATLAS_H
+
+#include "Texture2D.h"
+#include "utils/Types.h"
+
+namespace Siege::Vulkan
+{
+
+class TextureAtlas
+{
+public:
+
+    class TextureRef
+    {
+    public:
+
+        TextureRef(TextureAtlas& parent, float minX, float minY, float width, float height) :
+            parentAtlas {parent},
+            minX {minX},
+            width {width},
+            minY {minY},
+            height {height}
+        {}
+        Texture2D& operator*();
+
+        inline float GetMinX() const
+        {
+            return minX;
+        }
+        inline float GetMinY() const
+        {
+            return minY;
+        }
+
+        inline float GetWidth() const
+        {
+            return width;
+        }
+        inline float GetHeight() const
+        {
+            return height;
+        }
+
+    private:
+
+        // NOTE(Aryeh): Can we always guarantee that the atlas will exist?
+        TextureAtlas& parentAtlas;
+        float minX, width, minY, height {0.f};
+    };
+
+    TextureAtlas() = default;
+    TextureAtlas(const char* name,
+                 const char* filePath,
+                 Utils::Extent2DF imageExtents,
+                 Utils::TextureFilter filter = Utils::TEXTURE_FILTER_LINEAR);
+    TextureAtlas(TextureAtlas&& other);
+    ~TextureAtlas();
+
+    TextureRef operator[](size_t index);
+
+private:
+
+    void Swap(TextureAtlas& other);
+    Texture2D texture;
+    Utils::Extent2DF fixedExtent {};
+};
+
+} // namespace Siege::Vulkan
+
+#endif // SIEGE_ENGINE_VULKAN_TEXTURE_ATLAS_H

engine/render/renderer/renderer/Renderer2D.cpp

@@ -108,6 +108,30 @@ void Renderer2D::DrawQuad(const Vec2 position,
                                  {0.f, 0.f, 1.f, 1.f}});
 }
 
+void Renderer2D::DrawQuad(const Vec2 position,
+                          Vulkan::TextureAtlas::TextureRef& texture,
+                          const Vec2 scale,
+                          IColour colour,
+                          float rotation,
+                          uint8_t zIndex)
+{
+    CC_ASSERT(zIndex < MAX_LAYERS, "zIndex provided is larger than the maximum number of layers")
+
+    auto texIndex = quadMaterial.SetTexture(textureId, &(*texture));
+
+    auto& layerQuads = quads[zIndex];
+
+    if (texIndex >= layerQuads.Count())
+        layerQuads[texIndex] = MHArray<QuadVertex>(MAX_QUADS_PER_LAYER);
+
+    layerQuads[texIndex].Append(
+        {Transform3D({position.x + scale.x, position.y + scale.y, 1.f},
+                     {0.f, 0.f, rotation},
+                     scale),
+         ToFColour(colour),
+         {texture.GetMinX(), texture.GetMinY(), texture.GetWidth(), texture.GetHeight()}});
+}
+
 void Renderer2D::DrawText2D(const char* const text,
                             const Vec2 position,
                             const Vec2 scale,

engine/render/renderer/renderer/Renderer2D.h

@@ -17,6 +17,7 @@
 #include "render/renderer/platform/vulkan/Font.h"
 #include "render/renderer/platform/vulkan/IndexBuffer.h"
 #include "render/renderer/platform/vulkan/Material.h"
+#include "render/renderer/platform/vulkan/TextureAtlas.h"
 #include "render/renderer/platform/vulkan/VertexBuffer.h"
 
 namespace Siege
@@ -33,6 +34,12 @@ class Renderer2D
                   float rotation = 0.f,
                   const uint8_t zIndex = 0,
                   Vulkan::Texture2D* texture = nullptr);
+    void DrawQuad(const Vec2 position,
+                  Vulkan::TextureAtlas::TextureRef& texture,
+                  const Vec2 scale = Vec2::One(),
+                  const IColour colour = IColour::White,
+                  float rotation = 0.f,
+                  const uint8_t zIndex = 0);
     void DrawText2D(const char* const text,
                     const Vec2 position,
                     const Vec2 scale,

examples/tilemap/src/main.cpp

@@ -9,6 +9,7 @@
 
 #include <render/renderer/Renderer.h>
 #include <render/renderer/camera/Camera.h>
+#include <render/renderer/platform/vulkan/TextureAtlas.h>
 #include <utils/math/Projection.h>
 #include <utils/math/Transform.h>
 #include <utils/math/vec/Vec3.h>
@@ -24,9 +25,11 @@ int main()
     Siege::Renderer renderer(window);
 
     auto pixel = Siege::Vulkan::Font("assets/fonts/PublicPixel.ttf");
-    auto tilemap = Siege::Vulkan::Texture2D("tilemap",
-                                            "assets/textures/tilemap.png",
-                                            Siege::Vulkan::Utils::TEXTURE_FILTER_NEAREST);
+    auto tilemap = Siege::Vulkan::TextureAtlas("tilemap",
+                                               "assets/textures/tilemap.png",
+                                               {.5f, .5f},
+                                               Siege::Vulkan::Utils::TEXTURE_FILTER_NEAREST);
+    auto fullTile = Siege::Vulkan::Texture2D("full tilemap", "assets/textures/tilemap.png", Siege::Vulkan::Utils::TEXTURE_FILTER_NEAREST);
 
     Siege::Camera camera;
 
@@ -44,14 +47,47 @@ int main()
 
         renderer.DrawGrid2D(100.f, {.2f, .2f, .2f}, window.GetDPI());
 
-        renderer.DrawText2D("Hello World!",
+        renderer.DrawText2D("Full Texture",
                             pixel,
-                            {10.f, 10.f},
-                            {64.f, 64.f},
+                            {window.GetWidth() / 4.f, 20.f},
+                            {32.f, 32.f},
                             0.f,
                             Siege::IColour::Black);
 
-        renderer.DrawQuad({400.f, 300.f}, {64.f, 64.f}, Siege::IColour::White, 0.f, 0, &tilemap);
+        renderer.DrawQuad({(window.GetWidth() / 2.f) - 64.f, 100.f}, {64.f, 64.f}, Siege::IColour::White, 0.f, 0, &fullTile);
+
+        renderer.DrawText2D("Texture 0",
+                            pixel,
+                            {(window.GetWidth() / 2.f) * 0.1f, 275.f},
+                            {16.f, 16.f},
+                            0.f,
+                            Siege::IColour::Black);
+
+        renderer.DrawText2D("Texture 1",
+                            pixel,
+                            {(window.GetWidth() / 2.f) * 0.6f, 275.f},
+                            {16.f, 16.f},
+                            0.f,
+                            Siege::IColour::Black);
+
+        renderer.DrawText2D("Texture 2",
+                            pixel,
+                            {(window.GetWidth() / 2.f) * 1.1f, 275.f},
+                            {16.f, 16.f},
+                            0.f,
+                            Siege::IColour::Black);
+
+        renderer.DrawText2D("Texture 3",
+                            pixel,
+                            {(window.GetWidth() / 2.f) * 1.6f, 275.f},
+                            {16.f, 16.f},
+                            0.f,
+                            Siege::IColour::Black);
+
+        renderer.DrawQuad({(window.GetWidth() / 2.f) * 0.1f, 325.f}, tilemap[0], {64.f, 64.f}, Siege::IColour::White, 0.f, 0);
+        renderer.DrawQuad({(window.GetWidth() / 2.f) * 0.6f, 325.f}, tilemap[1], {64.f, 64.f}, Siege::IColour::White, 0.f, 0);
+        renderer.DrawQuad({(window.GetWidth() / 2.f) * 1.1f, 325.f}, tilemap[2], {64.f, 64.f}, Siege::IColour::White, 0.f, 0);
+        renderer.DrawQuad({(window.GetWidth() / 2.f) * 1.6f, 325.f}, tilemap[3], {64.f, 64.f}, Siege::IColour::White, 0.f, 0);
 
         renderer.EndFrame();
     }