Update submodule URL

.gitea/workflows/make_png.yaml

@@ -20,7 +20,7 @@ jobs:
           fetch-depth: 0
           submodules: recursive
           lfs: true
-      - run: cd prev && git checkout 10a90a5f6a
+      - run: cd prev && git checkout 7c0c02b9af
       - name: Build current
         run: cmake -S curr -B curr/build -DGLERMINAL_TEST=ON && cmake --build curr/build
       - name: Build previous

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "glfw"]
 	path = glfw
-	url = https://git.shylie.info/shylie/glfw.git
+	url = https://github.com/glfw/glfw.git
 [submodule "Lua"]
 	path = Lua
-	url = https://git.shylie.info/shylie/Lua.git
+	url = https://github.com/walterschell/Lua.git

CMakeLists.txt

@@ -28,6 +28,9 @@ add_library(glerminallib STATIC
 	source/glad/glad.h
 	source/KHR/khrplatform.h
 	source/glad.c
+
+	source/miniaudio.h
+	source/miniaudio.c
 )
 
 set_target_properties(glerminallib

examples/atlas.cpp

@@ -30,8 +30,8 @@ namespace
 			{
 				for (int k = 0; k < LAYER_COUNT; k++)
 				{
-					glerminal_set(i, j, k, rand() % 4);
-					glerminal_offset(i, j, k, (rand() * rand()) % 64 - 32, (rand() * rand()) % 64 - 32);
+					glerminal_set(i + 1, j + 1, k, rand() % 4);
+					glerminal_offset(i + 1, j + 1, k, (rand() * rand()) % 64 - 32, (rand() * rand()) % 64 - 32);
 				}
 			}
 		}

examples/basic.cpp

@@ -9,9 +9,9 @@ namespace
 	{
 		glerminal_load_sprites_file("resources/basic.png");
 
-		for (int i = 0; i < GRID_WIDTH; i++)
+		for (int i = 0; i < GRID_WIDTH + 2; i++)
 		{
-			for (int j = 0; j < GRID_HEIGHT; j++)
+			for (int j = 0; j < GRID_HEIGHT + 2; j++)
 			{
 				glerminal_set(i, j, 0, 1);
 			}
@@ -25,9 +25,9 @@ namespace
 		time += dt;
 		time = fmodf(time, 3.1415926f * 2);
 
-		for (int i = 0; i < GRID_WIDTH; i++)
+		for (int i = 0; i < GRID_WIDTH + 2; i++)
 		{
-			for (int j = 0; j < GRID_HEIGHT; j++)
+			for (int j = 0; j < GRID_HEIGHT + 2; j++)
 			{
 				glerminal_offset(i, j, 0, cosf(time - i / 3.1415f), sinf(time - j / 3.1415f));
 			}

examples/rogue.cpp

@@ -18,16 +18,16 @@ namespace
 	{
 		glerminal_load_sprites_file("resources/rogue.png");
 
-		for (int i = 0; i < GRID_WIDTH; i++)
+		for (int i = 0; i < GRID_WIDTH + 2; i++)
 		{
-			for (int j = 0; j < GRID_HEIGHT; j++)
+			for (int j = 0; j < GRID_HEIGHT + 2; j++)
 			{
 				for (int k = 0; k < WALL_LAYERS; k++)
 				{
 					const unsigned char v = (k + 1) * (256 / WALL_LAYERS) - 1;
 					const unsigned int c = (0xFF << 24) | (v << 16) | (v << 8) | v;
 
-					if (i == 0 || j == 0 || i == GRID_WIDTH - 1 || j == GRID_HEIGHT - 1)
+					if (i == 1 || j == 1 || i == GRID_WIDTH || j == GRID_HEIGHT)
 					{
 						glerminal_set(i, j, k, floor);
 					}
@@ -48,12 +48,12 @@ namespace
 		static double time = 0;
 		time += dt;
 
-		const float cx = GRID_WIDTH / 2.0f * cosf(time / 2) + GRID_WIDTH / 2.0f;
-		const float cy = GRID_HEIGHT / 2.0f * sinf(time / 2) + GRID_HEIGHT / 2.0f;
+		const float cx = GRID_WIDTH / 2.0f * cosf(time / 2) + GRID_WIDTH / 2.0f + 0.5f;
+		const float cy = GRID_HEIGHT / 2.0f * sinf(time / 2) + GRID_HEIGHT / 2.0f + 0.5f;
 
-		for (int i = 0; i < GRID_WIDTH; i++)
+		for (int i = 0; i < GRID_WIDTH + 2; i++)
 		{
-			for (int j = 0; j < GRID_HEIGHT; j++)
+			for (int j = 0; j < GRID_HEIGHT + 2; j++)
 			{
 				for (int k = 0; k < WALL_LAYERS; k++)
 				{

examples/towers.cpp

@@ -12,9 +12,9 @@ namespace
 		glerminal_load_sprites_file("resources/towers.png");
 
 
-		for (int i = 0; i < GRID_WIDTH; i++)
+		for (int i = 0; i < GRID_WIDTH + 2; i++)
 		{
-			for (int j = 0; j < GRID_HEIGHT; j++)
+			for (int j = 0; j < GRID_HEIGHT + 2; j++)
 			{
 				const int c = rand() % (LAYER_COUNT * 3 / 4) + LAYER_COUNT / 4;
 				for (int k = 0; k < c; k++)
@@ -40,12 +40,12 @@ namespace
 
 		time += dt;
 
-		const float cx = (GRID_WIDTH / 2.0f) * cosf(time / 3.1415f) + (GRID_WIDTH / 2.0f);
-		const float cy = (GRID_HEIGHT / 2.0f) * sinf(time / 3.1415f) + (GRID_HEIGHT / 2.0f);
+		const float cx = (GRID_WIDTH / 2.0f) * cosf(time / 3.1415f) + (GRID_WIDTH / 2.0f) + 0.5f;
+		const float cy = (GRID_HEIGHT / 2.0f) * sinf(time / 3.1415f) + (GRID_HEIGHT / 2.0f) + 0.5f;
 
-		for (int i = 0; i < GRID_WIDTH; i++)
+		for (int i = 0; i < GRID_WIDTH + 2; i++)
 		{
-			for (int j = 0; j < GRID_WIDTH; j++)
+			for (int j = 0; j < GRID_WIDTH + 2; j++)
 			{
 				for (int k = 0; k < LAYER_COUNT; k++)
 				{

include/glerminal.h

@@ -42,7 +42,7 @@ void glerminal_flush();
  * @param layer layer of the cell in the range [0, LAYER_COUNT)
  * @param sprite sprite's index in the range [0, 4096)
  */
-void glerminal_set(unsigned char x, unsigned char y, unsigned char layer, unsigned short sprite);
+void glerminal_set(int x, int y, int layer, unsigned short sprite);
 /**
  * @brief Get a cell's sprite
  * @param x position of the cell in the range [0, GRID_WIDTH)
@@ -50,7 +50,7 @@ void glerminal_set(unsigned char x, unsigned char y, unsigned char layer, unsign
  * @param layer layer of the cell in the range [0, LAYER_COUNT)
  * @return sprite index currently assigned to the cell
  */
-unsigned char glerminal_get(unsigned char x, unsigned char y, unsigned short layer);
+unsigned short glerminal_get(int x, int y, int layer);
 /**
  * @brief Set a cell's offset
  * @param x position of the cell in the range [0, GRID_WIDTH)
@@ -59,7 +59,7 @@ unsigned char glerminal_get(unsigned char x, unsigned char y, unsigned short lay
  * @param x_offset offset of the cell on the x axis in cells
  * @param y_offset offset of the cell on the y axis in cells
  */
-void glerminal_offset(unsigned char x, unsigned char y, unsigned char layer, float x_offset, float y_offset);
+void glerminal_offset(int x, int y, int layer, float x_offset, float y_offset);
 
 /**
  * @brief Set a cell's color
@@ -68,7 +68,7 @@ void glerminal_offset(unsigned char x, unsigned char y, unsigned char layer, flo
  * @param layer layer of the cell in the range [0, LAYER_COUNT)
  * @param color The new color
  */
-void glerminal_color(unsigned char x, unsigned char y, unsigned char layer, unsigned int color);
+void glerminal_color(int x, int y, int layer, unsigned int color);
 /**
  * @brief Set a cell's scale
  * @param x position of the cell in the range [0, GRID_WIDTH)
@@ -76,7 +76,7 @@ void glerminal_color(unsigned char x, unsigned char y, unsigned char layer, unsi
  * @param layer layer of the cell in the range [0, LAYER_COUNT)
  * @param scale The new scale
  */
-void glerminal_scale(unsigned char x, unsigned char y, unsigned char layer, float scale);
+void glerminal_scale(int x, int y, int layer, float scale);
 
 /**
  * @brief Load sprites from a png file
@@ -92,6 +92,8 @@ int glerminal_load_sprites_file(const char* filename);
  */
 int glerminal_load_sprites_buffer(unsigned char width, unsigned char height, const unsigned int* buffer);
 
+void glerminal_sound(const char* name);
+
 #ifdef __cplusplus
 }
 #endif

source/glerminal-main.cpp

@@ -38,9 +38,9 @@ namespace
 
 	int lglerminal_set(lua_State* L)
 	{
-		const unsigned char x = luaL_checkinteger(L, 1) - 1;
-		const unsigned char y = luaL_checkinteger(L, 2) - 1;
-		const unsigned char layer = luaL_checkinteger(L, 3) - 1;
+		const int x = luaL_checkinteger(L, 1);
+		const int y = luaL_checkinteger(L, 2);
+		const int layer = luaL_checkinteger(L, 3) - 1;
 		const unsigned short sprite = luaL_checkinteger(L, 4) - 1;
 		glerminal_set(x, y, layer, sprite);
 
@@ -49,9 +49,9 @@ namespace
 
 	int lglerminal_get(lua_State* L)
 	{
-		const unsigned char x = luaL_checkinteger(L, 1) - 1;
-		const unsigned char y = luaL_checkinteger(L, 2) - 1;
-		const unsigned char layer = luaL_checkinteger(L, 3) - 1;
+		const int x = luaL_checkinteger(L, 1);
+		const int y = luaL_checkinteger(L, 2);
+		const int layer = luaL_checkinteger(L, 3) - 1;
 		lua_pushnumber(L, glerminal_get(x, y, layer) + 1);
 
 		return 1;
@@ -59,9 +59,9 @@ namespace
 
 	int lglerminal_offset(lua_State* L)
 	{
-		const unsigned char x = luaL_checkinteger(L, 1) - 1;
-		const unsigned char y = luaL_checkinteger(L, 2) - 1;
-		const unsigned char layer = luaL_checkinteger(L, 3) - 1;
+		const int x = luaL_checkinteger(L, 1);
+		const int y = luaL_checkinteger(L, 2);
+		const int layer = luaL_checkinteger(L, 3) - 1;
 		const float ox = luaL_checknumber(L, 4);
 		const float oy = luaL_checknumber(L, 5);
 		glerminal_offset(x, y, layer, ox, oy);
@@ -71,10 +71,33 @@ namespace
 
 	int lglerminal_layer_color(lua_State* L)
 	{
-		const unsigned char x = luaL_checkinteger(L, 1) - 1;
-		const unsigned char y = luaL_checkinteger(L, 2) - 1;
-		const unsigned char layer = luaL_checkinteger(L, 3) - 1;
-		const unsigned int color = luaL_checkinteger(L, 4);
+		const int x = luaL_checkinteger(L, 1);
+		const int y = luaL_checkinteger(L, 2);
+		const int layer = luaL_checkinteger(L, 3) - 1;
+		const float r = luaL_checknumber(L, 4);
+		const float g = luaL_checknumber(L, 5);
+		const float b = luaL_checknumber(L, 6);
+		const float a =	luaL_optnumber(L, 7, 1.0f);
+
+		int ri = 255 * r;
+		int gi = 255 * g;
+		int bi = 255 * b;
+		int ai = 255 * a;
+
+		if (ri > 255) { ri = 255; }
+		if (ri < 0)   { ri = 0;   }
+
+		if (gi > 255) { gi = 255; }
+		if (gi < 0)   { gi = 0;   }
+
+		if (bi > 255) { bi = 255; }
+		if (bi < 0)   { bi = 0;   }
+
+		if (ai > 255) { ai = 255; }
+		if (ai < 0)   { ai = 0;   }
+
+		const unsigned int color = ri | (gi << 8) | (bi << 16) | (ai << 24);
+
 		glerminal_color(x, y, layer, color);
 
 		return 0;
@@ -82,9 +105,9 @@ namespace
 
 	int lglerminal_layer_scale(lua_State* L)
 	{
-		const unsigned char x = luaL_checkinteger(L, 1) - 1;
-		const unsigned char y = luaL_checkinteger(L, 2) - 1;
-		const unsigned char layer = luaL_checkinteger(L, 3) - 1;
+		const int x = luaL_checkinteger(L, 1);
+		const int y = luaL_checkinteger(L, 2);
+		const int layer = luaL_checkinteger(L, 3) - 1;
 		const float scale = luaL_checknumber(L, 4);
 		glerminal_scale(x, y, layer, scale);
 
@@ -99,6 +122,14 @@ namespace
 		return 1;
 	}
 
+	int lglerminal_play_sound(lua_State* L)
+	{
+		const char* name = luaL_checkstring(L, 1);
+		glerminal_sound(name);
+
+		return 0;
+	}
+
 	const luaL_Reg lglerminal_methods[] =
 	{
 		{ "quit",    lglerminal_quit },
@@ -109,6 +140,7 @@ namespace
 		{ "tint",    lglerminal_layer_color },
 		{ "scale",   lglerminal_layer_scale },
 		{ "sprites", lglerminal_load_sprites_file },
+		{ "sound",   lglerminal_play_sound },
 		{ nullptr,   nullptr }
 	};
 

source/glerminal-private.h

@@ -2,6 +2,7 @@
 #define GLERMINAL_PRIVATE_H
 
 #include "glerminal.h"
+#include "miniaudio.h"
 
 #include <stb_image.h>
 #include <glad/glad.h>
@@ -10,6 +11,8 @@
 #include <iostream>
 #include <fstream>
 #include <stdexcept>
+#include <map>
+#include <string>
 
 namespace glerminal
 {
@@ -23,6 +26,9 @@ namespace glerminal
 	constexpr unsigned int GRID_AREA = GRID_WIDTH * GRID_HEIGHT;
 	constexpr unsigned int SCREEN_WIDTH = GRID_WIDTH * CELL_SIZE * CELL_SCALE;
 	constexpr unsigned int SCREEN_HEIGHT = GRID_HEIGHT * CELL_SIZE * CELL_SCALE;
+	constexpr unsigned int SOUND_CHANNELS = 8;
+
+	constexpr unsigned int GRID_AREA_2 = (GRID_WIDTH + 2) * (GRID_HEIGHT + 2);
 
 	class glerminal
 	{
@@ -41,12 +47,14 @@ namespace glerminal
 
 		void flush();
 
-		void set(unsigned char x, unsigned char y, unsigned char layer, unsigned short sprite);
-		unsigned short get(unsigned char x, unsigned char y, unsigned char layer) const;
-		void offset(unsigned char x, unsigned char y, unsigned char layer, float x_offset, float y_offset);
-		void color(unsigned char x, unsigned char y, unsigned char layer, unsigned int color);
-		void scale(unsigned char x, unsigned char y, unsigned char layer, float scale);
+		void set(int x, int y, int layer, unsigned short sprite);
+		unsigned short get(int x, int y, int layer) const;
+		void offset(int x, int y, int layer, float x_offset, float y_offset);
+		void color(int x, int y, int layer, unsigned int color);
+		void scale(int x,int y, int layer, float scale);
 		void load_atlas(unsigned char w, unsigned char h, const unsigned int* data);
+		bool load_sound(const char* name);
+		void play_sound(const char* name);
 
 	private:
 		// glfw data
@@ -69,15 +77,13 @@ namespace glerminal
 		unsigned int m_screen_framebuffer_backing_texture;
 		unsigned int m_colors_instance_vbo;
 		unsigned int m_scales_instance_vbo;
-		unsigned int m_screen_size_uniform_location;
-		unsigned int m_palette_uniform_location;
 
 		// per-cell data
 
-		unsigned short m_cells[GRID_AREA * LAYER_COUNT];
-		float m_offsets[GRID_AREA * LAYER_COUNT * 2];
-		unsigned char m_colors[GRID_AREA * LAYER_COUNT * 4];
-		float m_scales[GRID_AREA * LAYER_COUNT];
+		unsigned short m_cells[GRID_AREA_2 * LAYER_COUNT];
+		float m_offsets[GRID_AREA_2 * LAYER_COUNT * 2];
+		unsigned char m_colors[GRID_AREA_2 * LAYER_COUNT * 4];
+		float m_scales[GRID_AREA_2 * LAYER_COUNT];
 
 		// library state
 
@@ -87,6 +93,9 @@ namespace glerminal
 		glerminal_mousemoved_cb m_mousemoved;
 		glerminal_mousepress_cb m_mousepressed, m_mousereleased;
 
+		ma_engine m_audio_engine;
+		std::map<std::string, ma_sound> m_sounds;
+
 #ifdef GLERMINAL_OPENGL_DEBUG_CONTEXT
 		mutable std::ofstream m_log;
 #endif
@@ -95,9 +104,13 @@ namespace glerminal
 		void init_glfw();
 		void init_gl();
 
+		void init_audio();
+
 		void deinit_glfw();
 		void deinit_gl();
 
+		void deinit_audio();
+
 		void update_sprites();
 		void update_colors();
 		void update_scales();

source/glerminal.cpp

@@ -1,6 +1,6 @@
 #define STB_IMAGE_IMPLEMENTATION
 #define STBI_ONLY_PNG
-#define STBI_MAX_DIMENSIONS 512
+#define STBI_MAX_DIMENSIONS 2048
 #include "glerminal-private.h"
 
 #define GRID_SIZE_UNIFORM_NAME "grid_size"
@@ -49,8 +49,8 @@ namespace
 		"	vs_out.layer = layer;\n"
 		"	vs_out.layer_color = color;\n"
 		"	vs_out.texcoord = vec2(sprite % " ATLAS_WIDTH_UNIFORM_NAME " + position.x + 1, (sprite / " ATLAS_WIDTH_UNIFORM_NAME ") - position.y) / vec2(" ATLAS_WIDTH_UNIFORM_NAME ") + vec2(-(2 * position.x + 1) * " GRID_SIZE_UNIFORM_NAME ".z / 16, (2 * position.y + 1) * " GRID_SIZE_UNIFORM_NAME ".z / 16);\n"
-		"	vec2 cell_position = vec2(scale + (gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) - " GRID_SIZE_UNIFORM_NAME ".x * floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) * " GRID_SIZE_UNIFORM_NAME ".z), -floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) * " GRID_SIZE_UNIFORM_NAME ".z));\n"
-		"	vec2 temp = ((position + vec2(-0.5, 0.5)) * scale + cell_position + vec2(0.5, -0.5)) * " GRID_SIZE_UNIFORM_NAME ".zw * 2 + vec2(-1, 1);\n"
+		"	vec2 cell_position = vec2(scale + (gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) - " GRID_SIZE_UNIFORM_NAME ".x * floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) / " GRID_SIZE_UNIFORM_NAME ".x), -floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) / " GRID_SIZE_UNIFORM_NAME ".x));\n"
+		"	vec2 temp = ((position + vec2(-0.5, 0.5)) * scale + cell_position + vec2(-0.5, 0.5)) * " GRID_SIZE_UNIFORM_NAME ".zw * 2 + vec2(-1, 1);\n"
 		"	gl_Position = vec4(scaled_offset.x + temp.x, scaled_offset.y - temp.y, 0, 1);\n"
 		"}";
 
@@ -79,8 +79,8 @@ namespace
 		"	vs_out.sprite = sprite;\n"
 		"	vs_out.texcoord = vec2(sprite % " ATLAS_WIDTH_UNIFORM_NAME " + position.x + 1, (sprite / " ATLAS_WIDTH_UNIFORM_NAME ") - position.y) / vec2(" ATLAS_WIDTH_UNIFORM_NAME ") + vec2(-(2 * position.x + 1) * " GRID_SIZE_UNIFORM_NAME ".z / 16, (2 * position.y + 1) * " GRID_SIZE_UNIFORM_NAME ".z / 16);\n"
 		"	vs_out.layer_color = color;\n"
-		"	vec2 cell_position = vec2(scale + (gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) - " GRID_SIZE_UNIFORM_NAME ".x * floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) * " GRID_SIZE_UNIFORM_NAME ".z), -floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) * " GRID_SIZE_UNIFORM_NAME ".z));\n"
-		"	vec2 temp = ((position + vec2(-0.5, 0.5)) * scale + cell_position + vec2(0.5, -0.5)) * " GRID_SIZE_UNIFORM_NAME ".zw * 2 + vec2(-1, 1);\n"
+		"	vec2 cell_position = vec2(scale + (gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) - " GRID_SIZE_UNIFORM_NAME ".x * floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) / " GRID_SIZE_UNIFORM_NAME ".x), -floor((gl_InstanceID % int(" GRID_SIZE_UNIFORM_NAME ".y)) / " GRID_SIZE_UNIFORM_NAME ".x));\n"
+		"	vec2 temp = ((position + vec2(-0.5, 0.5)) * scale + cell_position + vec2(-0.5, 0.5)) * " GRID_SIZE_UNIFORM_NAME ".zw * 2 + vec2(-1, 1);\n"
 		"	gl_Position = vec4(scaled_offset.x + temp.x, scaled_offset.y - temp.y, 0, 1);\n"
 		"}";
 
@@ -221,7 +221,7 @@ namespace glerminal
 			throw std::runtime_error("No main callback provided.");
 		}
 
-		for (int i = 0; i < GRID_AREA * LAYER_COUNT; i++)
+		for (int i = 0; i < GRID_AREA_2 * LAYER_COUNT; i++)
 		{
 			m_colors[i * 4 + 0] = m_colors[i * 4 + 1] = m_colors[i * 4 + 2] = m_colors[i * 4 + 3] = 255;
 			m_scales[i] = 1;
@@ -229,6 +229,7 @@ namespace glerminal
 
 		init_glfw();
 		init_gl();
+		init_audio();
 
 		GLERMINAL_G = this;
 
@@ -237,6 +238,7 @@ namespace glerminal
 
 	glerminal::~glerminal()
 	{
+		deinit_audio();
 		deinit_gl();
 		deinit_glfw();
 
@@ -275,7 +277,7 @@ namespace glerminal
 		glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 		glBindVertexArray(m_vao);
 		glClear(GL_COLOR_BUFFER_BIT);
-		glDrawArraysInstanced(GL_TRIANGLES, 0, 6, GRID_AREA * LAYER_COUNT);
+		glDrawArraysInstanced(GL_TRIANGLES, 0, 6, GRID_AREA_2 * LAYER_COUNT);
 
 		glUseProgram(m_screen_program);
 		glBindFramebuffer(GL_FRAMEBUFFER, m_screen_framebuffer);
@@ -283,28 +285,23 @@ namespace glerminal
 		glClear(GL_COLOR_BUFFER_BIT);
 		glDrawArrays(GL_TRIANGLES, 0, 6);
 
-		glBlitNamedFramebuffer(m_screen_framebuffer, 0, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL_COLOR_BUFFER_BIT, GL_NEAREST);
-
-		glfwSwapInterval(0);
-		glfwSwapBuffers(m_window);
-		glBlitNamedFramebuffer(m_screen_framebuffer, 0, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL_COLOR_BUFFER_BIT, GL_NEAREST);
-		glfwSwapInterval(1);
+		glBlitNamedFramebuffer(m_screen_framebuffer, 0, 0, 0, GRID_WIDTH * CELL_SIZE, GRID_HEIGHT * CELL_SIZE, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 		glfwSwapBuffers(m_window);
 	}
 
-	void glerminal::set(unsigned char x, unsigned char y, unsigned char layer, unsigned short sprite)
+	void glerminal::set(int x, int y, int layer, unsigned short sprite)
 	{
-		if (x < GRID_WIDTH && y < GRID_HEIGHT && layer < LAYER_COUNT)
+		if (x >= 0 && x < GRID_WIDTH + 2 && y >= 0 && y < GRID_HEIGHT + 2 && layer >= 0 && layer < LAYER_COUNT)
 		{
-			m_cells[x + y * GRID_WIDTH + layer * GRID_AREA] = sprite;
+			m_cells[x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2] = sprite;
 		}
 	}
 
-	unsigned short glerminal::get(unsigned char x, unsigned char y, unsigned char layer) const
+	unsigned short glerminal::get(int x, int y, int layer) const
 	{
-		if (x < GRID_WIDTH && y < GRID_HEIGHT && layer < LAYER_COUNT)
+		if (x >= 0 && x < GRID_WIDTH + 2 && y >= 0 && y < GRID_HEIGHT + 2 && layer >= 0 && layer < LAYER_COUNT)
 		{
-			return m_cells[x + y * GRID_WIDTH + layer * GRID_AREA];
+			return m_cells[x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2];
 		}
 		else
 		{
@@ -312,26 +309,32 @@ namespace glerminal
 		}
 	}
 
-	void glerminal::offset(unsigned char x, unsigned char y, unsigned char layer, float x_offset, float y_offset)
+	void glerminal::offset(int x, int y, int layer, float x_offset, float y_offset)
 	{
-		if (x < GRID_WIDTH && y < GRID_HEIGHT && layer < LAYER_COUNT)
+		if (x >= 0 && x < GRID_WIDTH + 2 && y >= 0 && y < GRID_HEIGHT + 2 && layer >= 0 && layer < LAYER_COUNT)
 		{
-			m_offsets[2 * (x + y * GRID_WIDTH + layer * GRID_AREA) + 0] = x_offset;
-			m_offsets[2 * (x + y * GRID_WIDTH + layer * GRID_AREA) + 1] = y_offset;
+			m_offsets[2 * (x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2) + 0] = x_offset;
+			m_offsets[2 * (x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2) + 1] = y_offset;
 		}
 	}
 
-	void glerminal::color(unsigned char x, unsigned char y, unsigned char layer, unsigned int color)
+	void glerminal::color(int x, int y, int layer, unsigned int color)
 	{
-		m_colors[4 * (x + y * GRID_WIDTH + layer * GRID_AREA) + 0] = ((color >>  0) & 0xFF);
-		m_colors[4 * (x + y * GRID_WIDTH + layer * GRID_AREA) + 1] = ((color >>  8) & 0xFF);
-		m_colors[4 * (x + y * GRID_WIDTH + layer * GRID_AREA) + 2] = ((color >> 16) & 0xFF);
-		m_colors[4 * (x + y * GRID_WIDTH + layer * GRID_AREA) + 3] = ((color >> 24) & 0xFF);
+		if (x >= 0 && x < GRID_WIDTH + 2 && y >= 0 && y < GRID_HEIGHT + 2 && layer >= 0 && layer < LAYER_COUNT)
+		{
+			m_colors[4 * (x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2) + 0] = (color >>  0) & 0xFF;
+			m_colors[4 * (x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2) + 1] = (color >>  8) & 0xFF;
+			m_colors[4 * (x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2) + 2] = (color >> 16) & 0xFF;
+			m_colors[4 * (x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2) + 3] = (color >> 24) & 0xFF;
+		}
 	}
 
-	void glerminal::scale(unsigned char x, unsigned char y, unsigned char layer, float scale)
+	void glerminal::scale(int x, int y, int layer, float scale)
 	{
-		m_scales[x + y * GRID_WIDTH + layer * GRID_AREA] = scale;
+		if (x >= 0 && x < GRID_WIDTH + 2 && y >= 0 && y < GRID_HEIGHT + 2 && layer >= 0 && layer < LAYER_COUNT)
+		{
+			m_scales[x + y * (GRID_WIDTH + 2) + layer * GRID_AREA_2] = scale;
+		}
 	}
 
 	void glerminal::load_atlas(unsigned char w, unsigned char h, const unsigned int* data)
@@ -360,6 +363,39 @@ namespace glerminal
 		}
 	}
 
+	bool glerminal::load_sound(const char* name)
+	{
+		if (m_sounds.find(name) == m_sounds.end())
+		{
+			ma_sound& ref = m_sounds[name];
+			const ma_result result = ma_sound_init_from_file(
+				&m_audio_engine,
+				name,
+				MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_NO_SPATIALIZATION,
+				nullptr,
+				nullptr,
+				&ref
+			);
+
+			if (result != MA_SUCCESS)
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	void glerminal::play_sound(const char* name)
+	{
+		load_sound(name);
+		const ma_result result = ma_engine_play_sound(&m_audio_engine, name, nullptr);
+		if (result != MA_SUCCESS)
+		{
+
+		}
+	}
+
 	void glerminal::init_glfw()
 	{
 		glfwInit();
@@ -467,7 +503,7 @@ namespace glerminal
 		glDisable(GL_DEPTH_TEST);
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+		glViewport(0, 0, GRID_WIDTH * CELL_SIZE, GRID_HEIGHT * CELL_SIZE);
 
 		// -- setup vertex data --
 		// create vertex buffer object
@@ -615,10 +651,8 @@ namespace glerminal
 		}
 
 		// setup uniforms
-		m_screen_size_uniform_location = glGetUniformLocation(m_program, GRID_SIZE_UNIFORM_NAME);
-
 		glUseProgram(m_program);
-		glUniform4f(m_screen_size_uniform_location, GRID_WIDTH, GRID_AREA, 1.0f / GRID_WIDTH, 1.0f / GRID_HEIGHT);
+		glUniform4f(glGetUniformLocation(m_program, GRID_SIZE_UNIFORM_NAME), GRID_WIDTH + 2, GRID_AREA_2, 1.0f / GRID_WIDTH, 1.0f / GRID_HEIGHT);
 		glUniform1i(glGetUniformLocation(m_program, ATLAS_WIDTH_UNIFORM_NAME), MAX_SPRITES_ROW);
 
 		// compile
@@ -699,7 +733,6 @@ namespace glerminal
 		update_sprites();
 
 		glBindTextureUnit(2, m_sprites_texture);
-		const auto err = glGetError();
 
 		// -- setup framebuffer --
 		glGenFramebuffers(1, &m_framebuffer);
@@ -717,7 +750,7 @@ namespace glerminal
 		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
 		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
 
-		glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, SCREEN_WIDTH, SCREEN_HEIGHT, LAYER_COUNT);
+		glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, GRID_WIDTH * CELL_SIZE, GRID_HEIGHT * CELL_SIZE, LAYER_COUNT);
 		glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_framebuffer_backing_texture, 0);
 
 		glBindTextureUnit(1, m_framebuffer_backing_texture);
@@ -738,10 +771,22 @@ namespace glerminal
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 
-		glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGB8, SCREEN_WIDTH, SCREEN_HEIGHT);
+		glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGB8, GRID_WIDTH * CELL_SIZE, GRID_HEIGHT * CELL_SIZE);
 		glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_screen_framebuffer_backing_texture, 0);
 	}
 
+	void glerminal::init_audio()
+	{
+		const ma_result result = ma_engine_init(nullptr, &m_audio_engine);
+
+		if (result != MA_SUCCESS)
+		{
+			throw std::runtime_error("Failed to initialize audio engine");
+		}
+
+		ma_engine_set_volume(&m_audio_engine, 1);
+	}
+
 	void glerminal::deinit_glfw()
 	{
 		glfwDestroyWindow(m_window);
@@ -766,6 +811,15 @@ namespace glerminal
 		glDeleteProgram(m_program);
 	}
 
+	void glerminal::deinit_audio()
+	{
+		for (auto& elem : m_sounds)
+		{
+			ma_sound_uninit(&elem.second);
+		}
+		ma_engine_uninit(&m_audio_engine);
+	}
+
 	void glerminal::update_sprites()
 	{
 		glTextureSubImage2D(m_sprites_texture, 0, 0, 0, (CELL_SIZE + 2) * MAX_SPRITES_ROW, (CELL_SIZE + 2) * MAX_SPRITES_ROW, GL_RGBA, GL_UNSIGNED_BYTE, m_sprites);
@@ -783,7 +837,7 @@ namespace glerminal
 
 	void glerminal::glfw_key_handler(GLFWwindow* window, int key, int scancode, int action, int mods)
 	{
-		glerminal* const self = static_cast<glerminal*>(glfwGetWindowUserPointer(window));
+		const glerminal* const self = static_cast<glerminal*>(glfwGetWindowUserPointer(window));
 
 		if (self->m_keypressed && action == GLFW_PRESS)
 		{
@@ -798,26 +852,26 @@ namespace glerminal
 
 	void glerminal::glfw_mousemoved_handler(GLFWwindow *window, double x, double y)
 	{
-		glerminal* const self = static_cast<glerminal*>(glfwGetWindowUserPointer(window));
+		const glerminal* const self = static_cast<glerminal*>(glfwGetWindowUserPointer(window));
 
-		if (self->m_mousemoved) { self->m_mousemoved(x / CELL_SIZE, y / CELL_SIZE); }
+		if (self->m_mousemoved) { self->m_mousemoved(x / (CELL_SIZE * CELL_SCALE), y / (CELL_SIZE * CELL_SCALE)); }
 	}
 
 	void glerminal::glfw_mousepress_handler(GLFWwindow *window, int button, int action, int mods)
 	{
-		glerminal* const self = static_cast<glerminal*>(glfwGetWindowUserPointer(window));
+		const glerminal* const self = static_cast<glerminal*>(glfwGetWindowUserPointer(window));
 
 		double x, y;
 		glfwGetCursorPos(window, &x, &y);
 
 		if (self->m_mousepressed && action == GLFW_PRESS)
 		{
-			self->m_mousepressed(button, x / CELL_SIZE, y / CELL_SIZE);
+			self->m_mousepressed(button, x / (CELL_SIZE * CELL_SCALE), y / (CELL_SIZE * CELL_SCALE));
 		}
 
 		if (self->m_mousereleased && action == GLFW_RELEASE)
 		{
-			self->m_mousereleased(button, x / CELL_SIZE, y / CELL_SIZE);
+			self->m_mousereleased(button, x / (CELL_SIZE * CELL_SCALE), y / (CELL_SIZE * CELL_SCALE));
 		}
 	}
 
@@ -851,39 +905,39 @@ void glerminal_flush()
 	GLERMINAL_G->flush();
 }
 
-void glerminal_set(unsigned char x, unsigned char y, unsigned char layer, unsigned short sprite)
+void glerminal_set(int x, int y, int layer, unsigned short sprite)
 {
 	if (!GLERMINAL_G) { return; }
 
-	GLERMINAL_G->set(x, y, layer, sprite);
+	GLERMINAL_G->set(x + 1, y + 1, layer, sprite);
 }
 
-unsigned char glerminal_get(unsigned char x, unsigned char y, unsigned short layer)
+unsigned short glerminal_get(int x, int y, int layer)
 {
 	if (!GLERMINAL_G) { return 0; }
 
-	return GLERMINAL_G->get(x, y, layer);
+	return GLERMINAL_G->get(x + 1, y + 1, layer);
 }
 
-void glerminal_offset(unsigned char x, unsigned char y, unsigned char layer, float x_offset, float y_offset)
+void glerminal_offset(int x, int y, int layer, float x_offset, float y_offset)
 {
 	if (!GLERMINAL_G) { return; }
 
-	GLERMINAL_G->offset(x, y, layer, x_offset, y_offset);
+	GLERMINAL_G->offset(x + 1, y + 1, layer, x_offset, y_offset);
 }
 
-void glerminal_color(unsigned char x, unsigned char y, unsigned char layer, unsigned int color)
+void glerminal_color(int x, int y, int layer, unsigned int color)
 {
 	if (!GLERMINAL_G) { return; }
 
-	GLERMINAL_G->color(x, y, layer, color);
+	GLERMINAL_G->color(x + 1, y + 1, layer, color);
 }
 
-void glerminal_scale(unsigned char x, unsigned char y, unsigned char layer, float scale)
+void glerminal_scale(int x, int y, int layer, float scale)
 {
 	if (!GLERMINAL_G) { return; }
 
-	GLERMINAL_G->scale(x, y, layer, scale);
+	GLERMINAL_G->scale(x + 1, y + 1, layer, scale);
 }
 
 int glerminal_load_sprites_file(const char* filename)
@@ -896,7 +950,7 @@ int glerminal_load_sprites_file(const char* filename)
 	stbi_uc* const buffer = stbi_load(filename, &w, &h, nullptr, 4);
 
 	// verify atlas size is a multiple of CELL_SIZE in each dimension
-	if (w % glerminal::CELL_SIZE == 0 && h % glerminal::CELL_SIZE == 0)
+	if (buffer && w % glerminal::CELL_SIZE == 0 && h % glerminal::CELL_SIZE == 0)
 	{
 		GLERMINAL_G->load_atlas(w / glerminal::CELL_SIZE, h / glerminal::CELL_SIZE, reinterpret_cast<unsigned int*>(buffer));
 
@@ -924,3 +978,10 @@ int glerminal_load_sprites_buffer(unsigned char width, unsigned char height, con
 		return false;
 	}
 }
+
+void glerminal_sound(const char* name)
+{
+	if (!GLERMINAL_G) { return; }
+
+	GLERMINAL_G->play_sound(name);
+}

source/miniaudio.c

@@ -0,0 +1,7 @@
+#ifndef GLERMINAL_MINIAUDIO_H
+#define GLERMINAL_MINIAUDIO_H
+
+#define MINIAUDIO_IMPLEMENTATION
+#include "miniaudio.h"
+
+#endif//GLERMINAL_MINIAUDIO_H

tests/basic.cpp

@@ -25,12 +25,12 @@ namespace
 		glerminal_quit();
 	}
 
-	void mainloop(float) {}
+	void mainloop(double) {}
 }
 
 int main()
 {
-	glerminal_run(init, mainloop, nullptr, nullptr);
+	glerminal_run({init, mainloop});
 
 	return 0;
 }

tests/test-common/test-common.cpp

@@ -8,7 +8,7 @@
 
 namespace
 {
-	unsigned char pixels[(GRID_WIDTH * CELL_SCALE * 8) * (GRID_HEIGHT * CELL_SCALE * 8) * 3];
+	unsigned char pixels[(GRID_WIDTH * 8) * (GRID_HEIGHT * 8) * 3];
 }
 
 void glerminal_test_save_image()
@@ -21,5 +21,5 @@ void glerminal_test_save_image()
 	glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
 
 	stbi_flip_vertically_on_write(true);
-	stbi_write_png("image.png", GRID_WIDTH * CELL_SCALE * 8, GRID_HEIGHT * CELL_SCALE * 8, 3, pixels, GRID_WIDTH * CELL_SCALE * 8 * 3);
+	stbi_write_png("image.png", GRID_WIDTH * 8, GRID_HEIGHT * 8, 3, pixels, GRID_WIDTH * 8 * 3);
 }