Fixed a bug with asset loader

src/dawn/asset/AssetDataLoader.cpp

@@ -201,7 +201,7 @@ size_t AssetDataLoader::skip(const size_t &n) {
   size_t n2, n3, n4;
   n4 = n;
   while(n4 != 0) {
-    n2 = Math::min<size_t>(n, ASSET_LOADER_BUFFER_SIZE);
+    n2 = Math::min<size_t>(n4, ASSET_LOADER_BUFFER_SIZE);
     n3 = this->read(dumpBuffer, n2);
     assertTrue(n3 == n2, "Failed to skip bytes!");
     n4 -= n3;

src/dawn/display/CMakeLists.txt

@@ -14,4 +14,5 @@ target_sources(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(mesh)
 add_subdirectory(shader)
-add_subdirectory(font)
+add_subdirectory(font)
+add_subdirectory(tileset)

src/dawn/display/tileset/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    TilesetGrid.cpp
+)

src/dawn/display/tileset/Tileset.hpp

@@ -0,0 +1,14 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+
+namespace Dawn {
+  struct Tileset {
+    public:
+      std::vector<glm::vec4> tiles;
+  };
+}

src/dawn/display/tileset/TilesetGrid.cpp

@@ -0,0 +1,76 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TilesetGrid.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+TilesetGrid::TilesetGrid(
+  const int32_t columns,
+  const int32_t rows,
+  const int32_t width,
+  const int32_t height,
+  const int32_t gapX,
+  const int32_t gapY,
+  const int32_t borderX,
+  const int32_t borderY
+) {
+  assertTrue(columns >= 1, "Columns must be greater than or equal to 1.");
+  assertTrue(rows >= 1, "Rows must be greater than or equal to 1.");
+  // assertTrue(width >= 1, "Width must be greater than or equal to 1.");
+  // assertTrue(height >= 1, "Height must be greater than or equal to 1.");
+  assertTrue(gapX >= 0, "GapX must be greater than or equal to 0.");
+  assertTrue(gapY >= 0, "GapY must be greater than or equal to 0.");
+  assertTrue(borderX >= 0, "BorderX must be greater than or equal to 0.");
+  assertTrue(borderY >= 0, "BorderY must be greater than or equal to 0.");
+  assertTrue(
+    width >= (columns + (gapX * columns) + borderX + borderX),
+    "Width must allow for at least 1px per column."
+  );
+  assertTrue(
+    height >= (rows + (gapY * rows) + borderY + borderY),
+    "Height must allow for at least 1px per row."
+  );
+
+  this->rows = rows;
+  this->columns = columns;
+
+  // Calculate division sizes (pixels)
+  float_t divX = (
+    (float_t)width - ((float_t)borderX * 2.0f) -
+    ((float_t)gapX * ((float_t)columns - 1))
+  ) / columns;
+
+  float_t divY = (
+    (float_t)height - ((float_t)borderY * 2.0f) -
+    ((float_t)gapY * ((float_t)rows - 1))
+  ) / rows;
+
+  // Calculate the division sizes (units)
+  float_t tdivX = divX / (float_t)width;
+  float_t tdivY = divY / (float_t)height;
+
+  for(int32_t y = 0; y < rows; y++) {
+    for(int32_t x = 0; x < columns; x++) {
+      glm::vec4 tile;
+      tile[0] = (borderX + (divX * x) + (gapX * x)) / width;
+      tile[2] = tile[0] + tdivX;
+          
+      tile[1] = (borderY + (divY * y) + (gapY * y)) / height;
+      tile[3] = tile[1] + tdivY;
+      this->tiles.push_back(tile);
+    }
+  }
+}
+
+glm::vec4 TilesetGrid::getTile(
+  const int32_t column,
+  const int32_t row
+) {
+  assertTrue(row >= 0 && row < this->rows, "Row out of bounds.");
+  assertTrue(column >= 0 && column < this->columns, "Column out of bounds.");
+  return this->tiles[(row * this->columns) + column];
+}

src/dawn/display/tileset/TilesetGrid.hpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Tileset.hpp"
+
+namespace Dawn {
+  struct TilesetGrid : public Tileset{
+    public:
+      int32_t rows;
+      int32_t columns;
+      
+      /**
+       * Creates a new TilesetGrid. A precalculated set of tiles that can be
+       * precalculated to make getting the index and uvs of a tile easier. This
+       * tileset is aligned to a simple grid (unlike a more complex UV unwrap).
+       * 
+       * @param columns The number of columns in the grid.
+       * @param rows The number of rows in the grid.
+       * @param width The width of the grid.
+       * @param height The height of the grid.
+       * @param gapX The gap between each column.
+       * @param gapY The gap between each row.
+       * @param borderX The border on the left and right of the grid.
+       * @param borderY The border on the top and bottom of the grid.
+       */
+      TilesetGrid(
+        const int32_t columns,
+        const int32_t rows,
+        const int32_t width,
+        const int32_t height,
+        const int32_t gapX = 0,
+        const int32_t gapY = 0,
+        const int32_t borderX = 0,
+        const int32_t borderY = 0
+      );
+
+      /**
+       * Gets the tile at the specified row and column.
+       * 
+       * @param col The column of the tile.
+       * @param row The row of the tile.
+       * @return The tile.
+       */
+      glm::vec4 getTile(const int32_t col, const int32_t row);
+  };
+}

src/dawnglfw/display/RenderHost.cpp

@@ -54,6 +54,9 @@ void RenderHost::init(const std::shared_ptr<Game> game) {
   gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
   assertNoGLError();
 
+  // Setup GL state
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
   // Get the resolution and scale/dpi
   backBufferRenderTarget = std::make_shared<BackBufferRenderTarget>();
 
@@ -85,7 +88,6 @@ void RenderHost::init(const std::shared_ptr<Game> game) {
 
 void RenderHost::update(const std::shared_ptr<Game> game) {
   // Prepare the initial values
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   assertNoGLError();
   glBlendFuncSeparate(
     GL_SRC_ALPHA,

src/dawnrpg/component/RPGEntity.cpp

@@ -7,6 +7,7 @@
 #include "scene/Scene.hpp"
 #include "display/mesh/QuadMesh.hpp"
 #include "asset/loader/TextureLoader.hpp"
+#include "display/tileset/TilesetGrid.hpp"
 
 using namespace Dawn;
 
@@ -51,6 +52,12 @@ void RPGEntity::setFacingDirection(const enum RPGEntityDirection dir) {
 }
 
 void RPGEntity::updateSprite() {
+  struct TilesetGrid tileset(
+    3, 4,
+    material->getTexture()->getWidth(), material->getTexture()->getHeight(),
+    1, 1
+  );
+
   int32_t row, col;
   row = col = 0;
 
@@ -73,12 +80,7 @@ void RPGEntity::updateSprite() {
   }
 
   // Convert row/col to UV coordinates.
-  glm::vec4 uvs = {
-    (float_t)col,
-    (float_t)(row+1) / 4.0f,
-    (float_t)(col+1),
-    (float_t)row / 4.0f
-  };
-
-  QuadMesh::bufferCoordinates(mesh, uvs, 0);
+  glm::vec4 tile = tileset.getTile(col, row);
+  tile = glm::vec4(tile.x, tile.w, tile.z, tile.y);// swap Y axis.
+  QuadMesh::bufferCoordinates(mesh, tile, 0);
 }

tools/texturetool/texturetool.py

@@ -33,7 +33,6 @@ if not os.path.exists(args.input):
 img = Image.open(args.input)
 
 # Normalize the image
-# output img.info
 hasAlpha = 'transparency' in img.info
 
 # Convert the image to RGB or RGBA mode based on alpha channel