Now using filenames instead of IDs when loading/retrieving textures.

Author: Unarelith

.gitignore

@@ -56,4 +56,5 @@ server/openminer_server
 
 # Misc
 *.zip
+test_atlas.png
 

client/include/graphics/TextureAtlas.hpp

@@ -17,36 +17,45 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 #include <gk/core/IntTypes.hpp>
 #include <gk/core/SDLHeaders.hpp>
+#include <gk/core/Rect.hpp>
+#include <gk/gl/Texture.hpp>
 
 class TextureAtlas {
 	public:
 		TextureAtlas() = default;
 
-		void addFile(const std::string &filename);
+		void addFile(const std::string &path, const std::string &filename);
 		void packTextures();
-		void saveToFile(const std::string &filename);
 
-		u16 getTextureID(const std::string &filename);
+		void loadFromRegistry();
 
-		const SDL_Surface *getSurface() const { return m_atlas.get(); }
+		u16 getTextureID(const std::string &filename) const;
+		gk::FloatRect getTexCoords(const std::string &filename, bool normalized = true) const;
+
+		const gk::Texture &texture() const { return m_texture; }
+
+		bool isReady() const { return m_isReady; }
 
 	private:
 		// Expected texture size
-		u16 m_width = 0;
-		u16 m_height = 0;
+		u16 m_tileSize = 0;
 
 		// Mapping between filename and internal texture ID
 		std::unordered_map<std::string, u16> m_textureMap;
 
 		// Textures to pack together
 		using SurfacePtr = std::unique_ptr<SDL_Surface, decltype(&SDL_FreeSurface)>;
-		std::unordered_map<std::string, SurfacePtr> m_textures;
+		std::vector<SurfacePtr> m_textures;
 
 		// Packed texture
-		SurfacePtr m_atlas{nullptr, &SDL_FreeSurface};
+		gk::Texture m_texture;
+
+		// Is the texture atlas ready to use?
+		bool m_isReady = false;
 };
 
 #endif // TEXTUREATLAS_HPP_

client/include/gui/Cube.hpp

@@ -19,6 +19,7 @@
 #include <gk/gl/VertexBuffer.hpp>
 
 class Block;
+class TextureAtlas;
 
 class Cube : public gk::Drawable, public gk::Transformable {
 	public:
@@ -31,7 +32,7 @@ class Cube : public gk::Drawable, public gk::Transformable {
 
 		float m_size = 1.0f;
 
-		const gk::Texture &m_texture;
+		const TextureAtlas &m_textureAtlas;
 
 		gk::VertexBuffer m_vbo;
 		bool m_isVboInitialized = false;

client/include/gui/ItemWidget.hpp

@@ -39,6 +39,8 @@ class ItemWidget : public Widget {
 		unsigned int m_x = 0;
 		unsigned int m_y = 0;
 
+		TextureAtlas &m_textureAtlas;
+
 		gk::Image m_image;
 		Text m_text;
 

client/include/states/GameState.hpp

@@ -28,6 +28,8 @@
 #include "HUD.hpp"
 #include "PlayerBox.hpp"
 
+class TextureAtlas;
+
 class GameState : public gk::ApplicationState {
 	public:
 		GameState(const std::string &host, int port);
@@ -57,6 +59,8 @@ class GameState : public gk::ApplicationState {
 		ClientCommandHandler m_clientCommandHandler{m_client, m_world, m_player, m_camera, m_playerBoxes};
 
 		HUD m_hud{m_player, m_world, m_clientCommandHandler};
+
+		TextureAtlas *m_textureAtlas = nullptr;
 };
 
 #endif // GAMESTATE_HPP_

client/include/world/ChunkBuilder.hpp

@@ -25,9 +25,12 @@
 
 class Block;
 class ClientChunk;
+class TextureAtlas;
 
 class ChunkBuilder {
 	public:
+		ChunkBuilder(TextureAtlas &textureAtlas) : m_textureAtlas(textureAtlas) {}
+
 		static constexpr u8 layers = 3;
 
 		std::array<std::size_t, layers> buildChunk(const ClientChunk &chunk, const std::array<gk::VertexBuffer, layers> &vbo);
@@ -62,6 +65,8 @@ class ChunkBuilder {
 			Front,
 			Back
 		};
+
+		TextureAtlas &m_textureAtlas;
 };
 
 #endif // CHUNKBUILDER_HPP_

client/include/world/ClientChunk.hpp

@@ -21,10 +21,12 @@
 #include "ChunkBuilder.hpp"
 #include "Config.hpp"
 
+class TextureAtlas;
+
 class ClientChunk : public Chunk {
 	public:
-		ClientChunk(s32 x, s32 y, s32 z, gk::Texture &texture)
-			: Chunk(x, y, z), m_texture(texture) {}
+		ClientChunk(s32 x, s32 y, s32 z, TextureAtlas &textureAtlas)
+			: Chunk(x, y, z), m_textureAtlas(textureAtlas), m_builder{textureAtlas} {}
 
 		void update();
 
@@ -39,7 +41,7 @@ class ClientChunk : public Chunk {
 		bool areAllNeighboursTooFar() const;
 
 	private:
-		gk::Texture &m_texture;
+		TextureAtlas &m_textureAtlas;
 
 		ChunkBuilder m_builder;
 

client/include/world/ClientWorld.hpp

@@ -21,6 +21,7 @@
 #include "World.hpp"
 
 class ClientCommandHandler;
+class TextureAtlas;
 
 class ClientWorld : public World, public gk::Drawable {
 	using ChunkMap = std::unordered_map<gk::Vector3i, std::unique_ptr<ClientChunk>>;
@@ -48,7 +49,7 @@ class ClientWorld : public World, public gk::Drawable {
 
 		ChunkMap m_chunks;
 
-		gk::Texture &m_texture;
+		TextureAtlas &m_textureAtlas;
 
 		ClientCommandHandler *m_client = nullptr;
 

client/source/core/ClientApplication.cpp

@@ -18,6 +18,7 @@
 
 #include "ClientApplication.hpp"
 #include "Config.hpp"
+#include "TextureAtlas.hpp"
 #include "TextureLoader.hpp"
 
 #include "GameState.hpp"
@@ -51,6 +52,7 @@ void ClientApplication::init() {
 
 	m_resourceHandler.loadConfigFile<TextureLoader>("resources/config/textures.xml");
 	m_resourceHandler.add<gk::Font>("font-default", "resources/fonts/default.ttf");
+	m_resourceHandler.add<TextureAtlas>("atlas-blocks");
 
 	Registry::setInstance(m_registry);
 

client/source/graphics/TextureAtlas.cpp

@@ -13,40 +13,39 @@
  */
 #include <gk/core/Exception.hpp>
 
+#include "Registry.hpp"
 #include "TextureAtlas.hpp"
 
-void TextureAtlas::addFile(const std::string &filename) {
-	SurfacePtr surface{IMG_Load(filename.c_str()), &SDL_FreeSurface};
-	if(!surface) {
-		throw EXCEPTION("Failed to load texture:", filename);
-	}
+void TextureAtlas::addFile(const std::string &path, const std::string &filename) {
+	auto it = m_textureMap.find(filename);
+	if (it != m_textureMap.end())
+		return;
 
-	auto it = m_textures.find(filename);
-	if (it != m_textures.end()) {
-		throw EXCEPTION("Texture already exists in atlas:", filename);
-	}
+	SurfacePtr surface{IMG_Load((path + filename).c_str()), &SDL_FreeSurface};
+	if(!surface)
+		throw EXCEPTION("Failed to load texture:", path + filename);
 
-	if (!m_width && !m_height) {
-		m_width = surface->w;
-		m_height = surface->h;
-	}
-	else if (m_width != surface->w || m_height != surface->h) {
-		throw EXCEPTION("Texture size unexpected for", filename + ". Got", surface->w, surface->w, "instead of", m_width, m_height);
-	}
+	if (!m_tileSize)
+		m_tileSize = surface->w;
+
+	if (m_tileSize != surface->w || m_tileSize != surface->h)
+		throw EXCEPTION("Texture size unexpected for", path + filename + ". Got", surface->w, surface->w, "instead of", m_tileSize, m_tileSize);
 
-	m_textures.emplace(filename, std::move(surface));
+	m_textureMap.emplace(filename, m_textures.size());
+	m_textures.emplace_back(std::move(surface));
 }
 
 void TextureAtlas::packTextures() {
-	if (!m_width && !m_height) {
+	if (!m_tileSize)
 		throw EXCEPTION("Cannot pack zero-sized textures!");
-	}
+
+	SurfacePtr atlas{nullptr, &SDL_FreeSurface};
 
 	// Max amount of textures on one line
 	const u16 atlasWidth = 16;
 
 	// Max amount of textures on one column
-	const u16 atlasHeight = m_textures.size() / atlasWidth;
+	const u16 atlasHeight = std::ceil((float)m_textures.size() / atlasWidth);
 
 	Uint32 rmask, gmask, bmask, amask;
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
@@ -61,36 +60,49 @@ void TextureAtlas::packTextures() {
 	amask = 0xff000000;
 #endif
 
-	m_atlas.reset(SDL_CreateRGBSurface(0, atlasWidth * m_width, atlasHeight * m_height, 32, rmask, gmask, bmask, amask));
-	if (!m_atlas) {
+	atlas.reset(SDL_CreateRGBSurface(0, atlasWidth * m_tileSize, atlasHeight * m_tileSize, 32, rmask, gmask, bmask, amask));
+	if (!atlas) {
 		throw EXCEPTION("Failed to create surface:", SDL_GetError());
 	}
 
 	u16 i = 0;
 	for (auto &it : m_textures) {
 		SDL_Rect outRect;
-		outRect.x = (i % atlasWidth) * m_width;
-		outRect.y = (i / atlasWidth) * m_height;
-		outRect.w = m_width;
-		outRect.h = m_height;
-
-		SDL_BlitSurface(it.second.get(), nullptr, m_atlas.get(), &outRect);
+		outRect.x = (i % atlasWidth) * m_tileSize;
+		outRect.y = (i / atlasWidth) * m_tileSize;
+		outRect.w = m_tileSize;
+		outRect.h = m_tileSize;
 
-		m_textureMap.emplace(it.first, i);
+		SDL_BlitSurface(it.get(), nullptr, atlas.get(), &outRect);
 
 		++i;
 	}
 
 	m_textures.clear();
+
+	m_isReady = true;
+
+	if (IMG_SavePNG(atlas.get(), "test_atlas.png") < 0)
+		throw EXCEPTION("Failed to save texture to: test_altas.png. Reason:", SDL_GetError());
+
+	m_texture.loadFromSurface(atlas.get());
 }
 
-void TextureAtlas::saveToFile(const std::string &filename) {
-	if (IMG_SavePNG(m_atlas.get(), filename.c_str()) < 0) {
-		throw EXCEPTION("Failed to save texture to:", filename + ". Reason:", SDL_GetError());
+void TextureAtlas::loadFromRegistry() {
+	for (auto &block : Registry::getInstance().blocks()) {
+		if (!block->textureFilename().empty())
+			addFile("resources/textures/faithful32/blocks/", block->textureFilename());
+	}
+
+	for (auto &item : Registry::getInstance().items()) {
+		if (!item.textureFilename().empty() && !item.isBlock())
+			addFile("resources/textures/faithful32/items/", item.textureFilename());
 	}
+
+	packTextures();
 }
 
-u16 TextureAtlas::getTextureID(const std::string &filename) {
+u16 TextureAtlas::getTextureID(const std::string &filename) const {
 	auto it = m_textureMap.find(filename);
 	if (it == m_textureMap.end()) {
 		throw EXCEPTION("Unable to find texture in atlas:", filename);
@@ -99,3 +111,26 @@ u16 TextureAtlas::getTextureID(const std::string &filename) {
 	return it->second;
 }
 
+gk::FloatRect TextureAtlas::getTexCoords(const std::string &filename, bool normalized) const {
+	if (filename.empty()) return gk::FloatRect{0, 0, 0, 0};
+
+	if (!m_isReady)
+		throw EXCEPTION("Can't get texture coordinates from empty atlas");
+
+	u16 textureID = getTextureID(filename);
+
+	float textureX = (textureID % (m_texture.getSize().x / m_tileSize)) * m_tileSize;
+	float textureY = (textureID / (m_texture.getSize().x / m_tileSize)) * m_tileSize;
+
+	if (normalized)
+		return gk::FloatRect{textureX / m_texture.getSize().x,
+							 textureY / m_texture.getSize().y,
+							 (float)m_tileSize / m_texture.getSize().x,
+							 (float)m_tileSize / m_texture.getSize().y};
+	else
+		return gk::FloatRect{textureX,
+							 textureY,
+							 (float)m_tileSize,
+							 (float)m_tileSize};
+}
+

client/source/gui/Cube.cpp

@@ -21,8 +21,9 @@
 #include "Block.hpp"
 #include "Config.hpp"
 #include "Cube.hpp"
+#include "TextureAtlas.hpp"
 
-Cube::Cube(float size) : m_texture(gk::ResourceHandler::getInstance().get<gk::Texture>("texture-blocks")) {
+Cube::Cube(float size) : m_textureAtlas(gk::ResourceHandler::getInstance().get<TextureAtlas>("atlas-blocks")) {
 	m_size = size;
 
 	// FIXME: Using Transform may be better here
@@ -71,12 +72,12 @@ void Cube::updateVertexBuffer(const Block &block) {
 	};
 
 	for (u8 i = 0 ; i < 6 ; ++i) {
-		const glm::vec4 &blockTexCoords = block.getTexCoords(i, 0);
+		const gk::FloatRect &blockTexCoords = m_textureAtlas.getTexCoords(block.textureFilename()); // block.getTexCoords(i, 0);
 		float faceTexCoords[2 * 4] = {
-			blockTexCoords.x, blockTexCoords.w,
-			blockTexCoords.z, blockTexCoords.w,
-			blockTexCoords.z, blockTexCoords.y,
-			blockTexCoords.x, blockTexCoords.y
+			blockTexCoords.x,                        blockTexCoords.y + blockTexCoords.height,
+			blockTexCoords.x + blockTexCoords.width, blockTexCoords.y + blockTexCoords.height,
+			blockTexCoords.x + blockTexCoords.width, blockTexCoords.y,
+			blockTexCoords.x,                        blockTexCoords.y
 		};
 		for(u8 j = 0 ; j < 4 ; j++) {
 			vertices[j + i * 4].texCoord[0] = faceTexCoords[j * 2];
@@ -113,7 +114,7 @@ void Cube::draw(gk::RenderTarget &target, gk::RenderStates states) const {
 
 	states.projectionMatrix = glm::ortho(0.0f, (float)SCREEN_WIDTH, (float)SCREEN_HEIGHT, 0.0f, -40.0f, DIST_FAR);
 
-	states.texture = &m_texture;
+	states.texture = &m_textureAtlas.texture();
 	states.vertexAttributes = gk::VertexAttribute::Only2d;
 
 	glCheck(glDisable(GL_CULL_FACE));