Merge pull request #65 from CapsCollective/feat/texture-atlas

Created a TextureAtlas class for managing textures packed into a single space

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::SubTextureRef 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::SubTextureRef 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/Material.cpp

@@ -158,17 +158,17 @@ void Material::SetUniformData(Hash::StringId id, uint64_t dataSize, const void*
     }
 }
 
-uint32_t Material::SetTexture(Hash::StringId id, Texture2D* texture)
+uint32_t Material::SetTexture(Hash::StringId id, const Texture2D& texture)
 {
     using namespace Utils;
     using namespace Descriptor;
 
-    auto texIndex = FindTextureIndex(texture->GetId());
+    auto texIndex = FindTextureIndex(texture.GetId());
 
     if (texIndex > -1) return texIndex;
 
     texIndex = textureIds.Count();
-    textureIds.Append(texture->GetId());
+    textureIds.Append(texture.GetId());
 
     for (auto it = propertiesSlots.CreateIterator(); it; ++it)
     {
@@ -179,7 +179,7 @@ uint32_t Material::SetTexture(Hash::StringId id, Texture2D* texture)
 
         if (propIdx == -1) continue;
 
-        auto info = texture->GetInfo();
+        auto info = texture.GetInfo();
 
         textureInfos[texIndex] = {info.sampler, info.imageInfo.view, info.imageInfo.layout};
 

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

@@ -93,7 +93,7 @@ class Material
      * @param index
      * @param textureInfo
      */
-    uint32_t SetTexture(Hash::StringId id, Texture2D* texture);
+    uint32_t SetTexture(Hash::StringId id, const Texture2D& texture);
 
     /**
      * Binds the Material for rendering (also binds the stored Pipeline)

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

@@ -0,0 +1,114 @@
+//
+// 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::SubTextureRef::operator*()
+{
+    return parentAtlas->texture;
+}
+
+TextureAtlas* TextureAtlas::SubTextureRef::operator->()
+{
+    return parentAtlas;
+}
+
+TextureAtlas::SubTextureRef::operator bool() const
+{
+    return parentAtlas;
+}
+
+void TextureAtlas::SubTextureRef::Swap(SubTextureRef& other)
+{
+    auto tmpAtlas = parentAtlas;
+    auto tmpMinX = minX;
+    auto tmpMinY = minY;
+    auto tmpWidth = width;
+    auto tmpHeight = height;
+
+    parentAtlas = other.parentAtlas;
+    minX = other.minX;
+    minY = other.minY;
+    width = other.width;
+    height = other.height;
+
+    other.parentAtlas = tmpAtlas;
+    other.minX = tmpMinX;
+    other.minY = tmpMinY;
+    other.width = tmpWidth;
+    other.height = tmpHeight;
+}
+TextureAtlas::SubTextureRef& TextureAtlas::SubTextureRef::operator=(
+    TextureAtlas::SubTextureRef& other)
+{
+    parentAtlas = other.parentAtlas;
+    minX = other.minX;
+    minY = other.minY;
+    width = other.width;
+    height = other.height;
+
+    return *this;
+}
+
+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()
+{
+    fixedExtent = {};
+}
+
+TextureAtlas::SubTextureRef TextureAtlas::operator[](size_t index)
+{
+    // TODO(Aryeh): Add some level of error handling here (assert if index is higher than number of
+    //  textures)
+
+    // NOTE(Aryeh): only works for fixed size textures
+    size_t elementsInRow = 1 / fixedExtent.width;
+
+    return SubTextureRef(this,
+                         (index % elementsInRow) * fixedExtent.width, // potentially slow code
+                         (index / elementsInRow) * fixedExtent.height,
+                         fixedExtent.width,
+                         fixedExtent.height);
+}
+
+TextureAtlas& TextureAtlas::operator=(TextureAtlas&& other)
+{
+    Swap(other);
+    return *this;
+}
+
+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;
+}
+
+} // namespace Siege::Vulkan