glerminal/source/glerminal.cpp

#include "glerminal-private.h"

#define SCREEN_SIZE_UNIFORM_NAME "screen_size"
#define PALETTE_UNIFORM_NAME "palette"
#define SPRITES_UNIFORM_NAME "sprites"
#define LAYERS_UNIFORM_NAME "layers"

namespace
{
	glerminal::glerminal* GLERMINAL_G = nullptr;

	constexpr float VBO_VERTICES[] =
	{
		// first triangle
		 0,  0, // top right
		 0, -1, // bottom right
		-1,  0, // top left

		// second triangle
		 0, -1, // bottom right
		-1, -1, // bottom left
		-1,  0 // top left
	};

	constexpr char* VERTEX_SHADER_SOURCE =
		"#version 400 core\n"
		"layout (location = 0) in vec2 position;\n"
		"layout (location = 1) in vec2 offset[8];\n"
		"layout (location = 9) in ivec4 sprite[2];\n"
		"uniform vec4 " SCREEN_SIZE_UNIFORM_NAME ";\n"
		"out VS_OUT {\n"
		"   flat vec2 offset[8];\n"
		"	flat ivec4 sprite[2];\n"
		"	vec2 texcoord;\n"
		"} vs_out;\n"
		"void main()\n"
		"{\n"
		"	vs_out.sprite = sprite;\n"
		"	for (int i = 0; i < 8; i++)\n"
		"	{\n"
		"		vs_out.offset[i] = offset[i] * " SCREEN_SIZE_UNIFORM_NAME ".zw;\n"
		"	}\n"
		"	vs_out.texcoord = vec2(position.x + 1, -position.y);\n"
		"	vec2 cell_position = vec2(1 + gl_InstanceID - " SCREEN_SIZE_UNIFORM_NAME ".x * floor(gl_InstanceID * " SCREEN_SIZE_UNIFORM_NAME ".z), -floor((gl_InstanceID) * " SCREEN_SIZE_UNIFORM_NAME ".z));\n"
		"	vec2 temp = vec2((position + cell_position) * " SCREEN_SIZE_UNIFORM_NAME ".zw * 2 + vec2(-1, 1));\n"
		"	gl_Position = vec4(temp.x, -temp.y, 0, 1);\n"
		"}";

	constexpr char* GEOMETRY_SHADER_SOURCE =
		"#version 400 core\n"
		"layout (triangles) in;\n"
		"layout (triangle_strip, max_vertices = 24) out;\n"
		"layout (invocations = 8) in;\n"
		"in VS_OUT {\n"
		"   flat vec2 offset[8];\n"
		"	flat ivec4 sprite[2];\n"
		"	vec2 texcoord;\n"
		"} gs_in[];\n"
		"flat out int sprite;\n"
		"out vec2 texcoord;\n"
		"void main()\n"
		"{\n"
		"	gl_Layer = gl_InvocationID;\n"
		"	gl_Position = vec4(gl_in[0].gl_Position.xy + gs_in[0].offset[gl_InvocationID], 0, 1);\n"
		"	sprite = gs_in[0].sprite[gl_InvocationID / 8][gl_InvocationID % 8];\n"
		"	texcoord = gs_in[0].texcoord;\n"
		"	EmitVertex();\n"
		"	gl_Layer = gl_InvocationID;\n"
		"	gl_Position = vec4(gl_in[1].gl_Position.xy + gs_in[0].offset[gl_InvocationID], 0, 1);\n"
		"	sprite = gs_in[1].sprite[gl_InvocationID / 8][gl_InvocationID % 8];\n"
		"	texcoord = gs_in[1].texcoord;\n"
		"	EmitVertex();\n"
		"	gl_Layer = gl_InvocationID;\n"
		"	gl_Position = vec4(gl_in[2].gl_Position.xy + gs_in[0].offset[gl_InvocationID], 0, 1);\n"
		"	sprite = gs_in[2].sprite[gl_InvocationID / 8][gl_InvocationID % 8];\n"
		"	texcoord = gs_in[2].texcoord;\n"
		"	EmitVertex();\n"
		"	EndPrimitive();\n"
		"}";

	constexpr char* FRAGMENT_SHADER_SOURCE =
		"#version 400 core\n"
		"in vec2 texcoord;\n"
		"flat in int sprite;\n"
		"uniform usampler2DArray " SPRITES_UNIFORM_NAME ";\n"
		"uniform vec4 " PALETTE_UNIFORM_NAME "[16];\n"
		"out vec4 FragColor;\n"
		"void main()\n"
		"{\n"
		"	FragColor = " PALETTE_UNIFORM_NAME "[int(texture(" SPRITES_UNIFORM_NAME ", vec3(texcoord, sprite)))];\n"
		"}";

	constexpr char* SCREEN_VERTEX_SHADER_SOURCE =
		"#version 400 core\n"
		"layout (location = 0) in vec2 position;\n"
		"out vec2 texcoord;\n"
		"void main()\n"
		"{\n"
		"	gl_Position = vec4(position * 2 + 1, 0, 1);\n"
		"	texcoord = vec2(position.x + 1, -position.y);\n"
		"}";

	constexpr char* SCREEN_FRAGMENT_SHADER_SOURCE =
		"#version 400 core\n"
		"in vec2 texcoord;\n"
		"uniform sampler2DArray " LAYERS_UNIFORM_NAME ";\n"
		"out vec4 FragColor;\n"
		"void main()\n"
		"{\n"
		"	vec3 current_color = vec3(0);\n"
		"	for (int i = 0; i < 8; i++)\n"
		"	{\n"
		"		vec4 texsample = texture(" LAYERS_UNIFORM_NAME ", vec3(texcoord, i));\n"
		"		current_color = mix(current_color, texsample.rgb, texsample.a);\n"
		"	}\n"
		"	FragColor = vec4(current_color, 1);\n"
		"}";
}

namespace glerminal
{
	glerminal::glerminal(glerminal_init_cb init, glerminal_main_cb main) :
		m_main(main),
		m_cells{ },
		m_offsets{ },
		m_sprites{ },
		m_palette{ }
#ifdef _DEBUG
		, m_log("log.txt")
#endif
	{
		if (GLERMINAL_G)
		{
			throw std::runtime_error("glerminal is already running.");
		}

		// unsure if this should be an error
		if (!init)
		{
			throw std::runtime_error("No init callback provided.");
		}

		if (!m_main)
		{
			throw std::runtime_error("No main callback provided.");
		}

		init_glfw();
		init_gl();

		GLERMINAL_G = this;

		init();
	}

	glerminal::~glerminal()
	{
		deinit_gl();
		deinit_glfw();

		GLERMINAL_G = nullptr;
	}

	void glerminal::run()
	{
		float last = glfwGetTime();
		while (!glfwWindowShouldClose(m_window))
		{
			glfwPollEvents();

			const float current = glfwGetTime();

			m_main(current - last);

			last = current;
		}
	}

	void glerminal::flush()
	{
		// use dirty flag later
		glNamedBufferData(m_sprites_instance_vbo, sizeof(m_cells), m_cells, GL_STREAM_DRAW);
		glNamedBufferData(m_offsets_instance_vbo, sizeof(m_offsets), m_offsets, GL_STREAM_DRAW);
		update_sprites();
		update_palette();

		glUseProgram(m_program);
		glBindTexture(GL_TEXTURE_2D_ARRAY, m_sprites_texture);
		glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
		glBindVertexArray(m_vao);
		glClear(GL_COLOR_BUFFER_BIT);
		glDrawArraysInstanced(GL_TRIANGLES, 0, 6, GRID_AREA);

		glUseProgram(m_screen_program);
		glBindTexture(GL_TEXTURE_2D_ARRAY, m_framebuffer_backing_texture);
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
		glBindVertexArray(m_screen_vao);
		glClear(GL_COLOR_BUFFER_BIT);
		glDrawArrays(GL_TRIANGLES, 0, 6);

		glfwSwapBuffers(m_window);
	}

	void glerminal::set(unsigned char x, unsigned char y, unsigned char layer, unsigned char sprite)
	{
		if (x < GRID_WIDTH && y < GRID_HEIGHT && layer < LAYER_COUNT)
		{
			m_cells[layer + x * LAYER_COUNT + y * LAYER_COUNT * GRID_WIDTH] = sprite;
		}
	}

	unsigned char glerminal::get(unsigned char x, unsigned char y, unsigned char layer) const
	{
		if (x < GRID_WIDTH && y < GRID_HEIGHT && layer < LAYER_COUNT)
		{
			return m_cells[x + y * GRID_WIDTH + layer * GRID_AREA];
		}
		else
		{
			return 0;
		}
	}

	void glerminal::offset(unsigned char x, unsigned char y, unsigned char layer, char x_offset, char y_offset)
	{
		if (x < GRID_WIDTH && y < GRID_HEIGHT && layer < LAYER_COUNT)
		{
			m_offsets[2 * (layer + x * LAYER_COUNT + y * LAYER_COUNT * GRID_WIDTH) + 0] = x_offset;
			m_offsets[2 * (layer + x * LAYER_COUNT + y * LAYER_COUNT * GRID_WIDTH) + 1] = y_offset;
		}
	}

	void glerminal::update_sprite(unsigned char id, glerminal_sprite sprite)
	{
		// does this work?
		reinterpret_cast<glerminal_sprite*>(m_sprites)[id] = sprite;
	}

	void glerminal::update_palette_color(unsigned char id, unsigned int color)
	{
		if (id < 16)
		{
			m_palette[4 * id + 0] = ((color >> 24) & 0xFF) / 255.0f;
			m_palette[4 * id + 1] = ((color >> 16) & 0xFF) / 255.0f;
			m_palette[4 * id + 2] = ((color >>  8) & 0xFF) / 255.0f;
			m_palette[4 * id + 3] = ((color >>  0) & 0xFF) / 255.0f;
		}
	}

	void glerminal::init_glfw()
	{
		glfwInit();

		glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
		glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
		glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
		// not resizable for now.
		// 
		// need to think about how to handle resizing to ensure
		// that the window stays an integer number of "tiles" large
		glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
#ifdef _DEBUG
		glfwWindowHint(GLFW_CONTEXT_DEBUG, GLFW_TRUE);
#endif

		// non-adjustable size for the same reason as above
		m_window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "glerminal", nullptr, nullptr);

		if (!m_window)
		{
			throw std::runtime_error("Failed to create glerminal window.");
		}
	}
	
#ifdef _DEBUG
	void glerminal::log(GLenum type, GLuint id, GLenum severity, const char* message) const
	{
		glDebugMessageInsert(GL_DEBUG_SOURCE_THIRD_PARTY, type, id, severity, -1, message);
	}
#endif

	void glerminal::init_gl()
	{
		glfwMakeContextCurrent(m_window);
		glfwSwapInterval(1);

		if (!gladLoadGLLoader(reinterpret_cast<GLADloadproc>(glfwGetProcAddress)))
		{
			throw std::runtime_error("Failed to initialize GLAD.");
		}

#ifdef _DEBUG
		glEnable(GL_DEBUG_OUTPUT);
		glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
		glDebugMessageCallback([](GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
			{
				const char* source_str = "[UNKNOWN]";
				switch (source)
				{
				case GL_DEBUG_SOURCE_API:
					source_str = "[API]";
					break;

				case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
					source_str = "[WINDOW]";
					break;

				case GL_DEBUG_SOURCE_SHADER_COMPILER:
					source_str = "[SHADER]";
					break;

				case GL_DEBUG_SOURCE_THIRD_PARTY:
					source_str = "[GLERMINAL]";
					break;

				case GL_DEBUG_SOURCE_APPLICATION:
					source_str = "[APPLICATION]";
					break;
				}

				const char* type_str = "[UNKNOWN]";
				switch (type)
				{
				case GL_DEBUG_TYPE_ERROR:
					type_str = "[ERROR]";
					break;

				case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
					type_str = "[DEPRECATED]";
					break;

				case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
					type_str = "[UNDEFINED]";
					break;

				case GL_DEBUG_TYPE_PORTABILITY:
					type_str = "[PORTABILITY]";
					break;

				case GL_DEBUG_TYPE_PERFORMANCE:
					type_str = "[PERFORMANCE]";
					break;
				}

				static_cast<const glerminal*>(userParam)->m_log << source_str << type_str << ' ' << std::string(message, length) << std::endl;

			}, this);
#endif

		glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
		glDisable(GL_DEPTH_TEST);
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

		// -- setup vertex data --
		// create vertex buffer object
		glGenBuffers(1, &m_vbo);
		glGenBuffers(1, &m_sprites_instance_vbo);
		glGenBuffers(1, &m_offsets_instance_vbo);

		// create vertex array object
		glGenVertexArrays(1, &m_vao);
		glBindVertexArray(m_vao);

		// set up static vertex attributes
		glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
		glBufferData(GL_ARRAY_BUFFER, sizeof(VBO_VERTICES), VBO_VERTICES, GL_STATIC_DRAW);
		glEnableVertexAttribArray(0);
		glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(*VBO_VERTICES), reinterpret_cast<void*>(0));

		// set up instanced vertex attributes
		glBindBuffer(GL_ARRAY_BUFFER, m_offsets_instance_vbo);
		glBufferData(GL_ARRAY_BUFFER, sizeof(m_offsets), m_offsets, GL_STREAM_DRAW);
		glEnableVertexAttribArray(1);
		glVertexAttribPointer(1, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(0 * sizeof(*m_offsets)));
		glVertexAttribDivisor(1, 1);
		glEnableVertexAttribArray(2);
		glVertexAttribPointer(2, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(2 * sizeof(*m_offsets)));
		glVertexAttribDivisor(2, 1);
		glEnableVertexAttribArray(3);
		glVertexAttribPointer(3, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(4 * sizeof(*m_offsets)));
		glVertexAttribDivisor(3, 1);
		glEnableVertexAttribArray(4);
		glVertexAttribPointer(4, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(6 * sizeof(*m_offsets)));
		glVertexAttribDivisor(4, 1);
		glEnableVertexAttribArray(5);
		glVertexAttribPointer(5, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(8 * sizeof(*m_offsets)));
		glVertexAttribDivisor(5, 1);
		glEnableVertexAttribArray(6);
		glVertexAttribPointer(6, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(10 * sizeof(*m_offsets)));
		glVertexAttribDivisor(6, 1);
		glEnableVertexAttribArray(7);
		glVertexAttribPointer(7, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(12 * sizeof(*m_offsets)));
		glVertexAttribDivisor(7, 1);
		glEnableVertexAttribArray(8);
		glVertexAttribPointer(8, 2, GL_BYTE, GL_TRUE, 16 * sizeof(*m_offsets), reinterpret_cast<void*>(14 * sizeof(*m_offsets)));
		glVertexAttribDivisor(8, 1);

		glBindBuffer(GL_ARRAY_BUFFER, m_sprites_instance_vbo);
		glBufferData(GL_ARRAY_BUFFER, sizeof(m_cells), m_cells, GL_STREAM_DRAW);
		glEnableVertexAttribArray(9);
		glVertexAttribIPointer(9, 4, GL_UNSIGNED_BYTE, 8 * sizeof(*m_cells), reinterpret_cast<void*>(0 * sizeof(*m_cells)));
		glVertexAttribDivisor(9, 1);
		glEnableVertexAttribArray(10);
		glVertexAttribIPointer(10, 4, GL_UNSIGNED_BYTE, 8 * sizeof(*m_cells), reinterpret_cast<void*>(4 * sizeof(*m_cells)));
		glVertexAttribDivisor(10, 1);
		

		// set up static vertex attributes
		glGenVertexArrays(1, &m_screen_vao);
		glBindVertexArray(m_screen_vao);

		glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
		glEnableVertexAttribArray(0);
		glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(*VBO_VERTICES), reinterpret_cast<void*>(0));

		// -- setup shader program --
		// compile
		const unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vertex_shader, 1, &VERTEX_SHADER_SOURCE, nullptr);
		glCompileShader(vertex_shader);

		const unsigned int geometry_shader = glCreateShader(GL_GEOMETRY_SHADER);
		glShaderSource(geometry_shader, 1, &GEOMETRY_SHADER_SOURCE, nullptr);
		glCompileShader(geometry_shader);

		const unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragment_shader, 1, &FRAGMENT_SHADER_SOURCE, nullptr);
		glCompileShader(fragment_shader);

		int success;

		// verify compile
		glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glDeleteShader(vertex_shader);
			glDeleteShader(geometry_shader);
			glDeleteShader(fragment_shader);

			throw std::runtime_error("Could not compile vertex shader.");
		}

		glGetShaderiv(geometry_shader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glDeleteShader(vertex_shader);
			glDeleteShader(geometry_shader);
			glDeleteShader(fragment_shader);

			throw std::runtime_error("Could not compile geometry shader.");
		}

		glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glDeleteShader(vertex_shader);
			glDeleteShader(geometry_shader);
			glDeleteShader(fragment_shader);

			throw std::runtime_error("Could not compile fragment shader.");
		}

		// link
		m_program = glCreateProgram();
		glAttachShader(m_program, vertex_shader);
		glAttachShader(m_program, geometry_shader);
		glAttachShader(m_program, fragment_shader);
		glLinkProgram(m_program);
		glDeleteShader(vertex_shader);
		glDeleteShader(geometry_shader);
		glDeleteShader(fragment_shader);

		// verify link
		glGetProgramiv(m_program, GL_LINK_STATUS, &success);
		if (!success)
		{
			glDeleteProgram(m_program);

			throw std::runtime_error("Could not link shader program.");
		}

		// setup uniforms
		m_screen_size_uniform_location = glGetUniformLocation(m_program, SCREEN_SIZE_UNIFORM_NAME);
		m_palette_uniform_location = glGetUniformLocation(m_program, PALETTE_UNIFORM_NAME);

		glUseProgram(m_program);
		glUniform4f(m_screen_size_uniform_location, GRID_WIDTH, GRID_HEIGHT, 1.0f / GRID_WIDTH, 1.0f / GRID_HEIGHT);

		glUniform1i(glGetUniformLocation(m_program, SPRITES_UNIFORM_NAME), 0);

		update_palette();

		// compile
		const unsigned int screen_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(screen_vertex_shader, 1, &SCREEN_VERTEX_SHADER_SOURCE, nullptr);
		glCompileShader(screen_vertex_shader);

		const unsigned int screen_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(screen_fragment_shader, 1, &SCREEN_FRAGMENT_SHADER_SOURCE, nullptr);
		glCompileShader(screen_fragment_shader);

		// verify compile
		glGetShaderiv(screen_vertex_shader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glDeleteShader(screen_vertex_shader);
			glDeleteShader(screen_fragment_shader);

			throw std::runtime_error("Could not compile screen vertex shader.");
		}

		glGetShaderiv(screen_fragment_shader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glDeleteShader(screen_vertex_shader);
			glDeleteShader(screen_fragment_shader);

			throw std::runtime_error("Could not compile screen fragment shader.");
		}

		// link
		m_screen_program = glCreateProgram();
		glAttachShader(m_screen_program, screen_vertex_shader);
		glAttachShader(m_screen_program, screen_fragment_shader);
		glLinkProgram(m_screen_program);
		glDeleteShader(screen_vertex_shader);
		glDeleteShader(screen_fragment_shader);

		// verify link
		glGetProgramiv(m_screen_program, GL_LINK_STATUS, &success);
		if (!success)
		{
			glDeleteProgram(m_screen_program);

			throw std::runtime_error("Could not link screen shader program.");
		}

		// setup uniforms later

		// -- setup textures --
		glGenTextures(1, &m_sprites_texture);
		glBindTexture(GL_TEXTURE_2D_ARRAY, m_sprites_texture);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);

		update_sprites();

		// -- setup framebuffer --
		glGenFramebuffers(1, &m_framebuffer);
		glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);

		glGenTextures(1, &m_framebuffer_backing_texture);
		glBindTexture(GL_TEXTURE_2D_ARRAY, m_framebuffer_backing_texture);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);

		glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, SCREEN_WIDTH, SCREEN_HEIGHT, LAYER_COUNT, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
		glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_framebuffer_backing_texture, 0);

		// setup uniforms for screen shader
		glUseProgram(m_screen_program);
	}

	void glerminal::deinit_glfw()
	{
		glfwDestroyWindow(m_window);

		glfwTerminate();
	}

	void glerminal::deinit_gl()
	{
		glDeleteFramebuffers(1, &m_framebuffer);
		glDeleteTextures(1, &m_framebuffer_backing_texture);
		glDeleteTextures(1, &m_sprites_texture);
		glDeleteVertexArrays(1, &m_vao);
		glDeleteVertexArrays(1, &m_screen_vao);
		glDeleteBuffers(1, &m_vbo);
		glDeleteBuffers(1, &m_sprites_instance_vbo);
		glDeleteBuffers(1, &m_offsets_instance_vbo);
		glDeleteProgram(m_program);
	}

	void glerminal::update_sprites()
	{
		glBindTexture(GL_TEXTURE_2D_ARRAY, m_sprites_texture);
		glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_R8UI, CELL_SIZE, CELL_SIZE, 256, 0, GL_RED_INTEGER, GL_UNSIGNED_BYTE, m_sprites);
	}

	void glerminal::update_palette()
	{
		glUseProgram(m_program);
		glUniform4fv(m_palette_uniform_location, 16, m_palette);
	}
}

void glerminal_run(glerminal_init_cb init, glerminal_main_cb main)
{
	try
	{
		glerminal::glerminal(init, main).run();
	}
	catch (const std::runtime_error& e)
	{
	}
}

void glerminal_flush()
{
	if (!GLERMINAL_G) { return; }

	GLERMINAL_G->flush();
}

void glerminal_set(unsigned char x, unsigned char y, unsigned char layer, unsigned char sprite)
{
	if (!GLERMINAL_G) { return; }

	GLERMINAL_G->set(x, y, layer, sprite);
}

unsigned char glerminal_get(unsigned char x, unsigned char y, unsigned char layer)
{
	if (!GLERMINAL_G) { return 0; }

	return GLERMINAL_G->get(x, y, layer);
}

void glerminal_offset(unsigned char x, unsigned char y, unsigned char layer, char x_offset, char y_offset)
{
	if (!GLERMINAL_G) { return; }

	GLERMINAL_G->offset(x, y, layer, x_offset, y_offset);
}

void glerminal_update_sprite(unsigned char id, glerminal_sprite sprite)
{
	if (!GLERMINAL_G) { return; }

	GLERMINAL_G->update_sprite(id, sprite);
}

void glerminal_update_palette(unsigned char id, unsigned int color)
{
	if (!GLERMINAL_G) { return; }

	GLERMINAL_G->update_palette_color(id, color);
}