gunslinger/examples/serialization/source/main.c

/*================================================================
	* Copyright: 2020 John Jackson
	* serialization

	Custom Byte Buffer / Binary Serialization example

	Shown in video: https://www.youtube.com/watch?v=GXdT8twQxxI

	The purpose of this example is to demonstrate how to serialize arbitrary data to disk using a custom byte buffer implementation.
	A simple pixel art editor is thrown in to demonstrate some of these ideas in practice.

	Libraries used : 
	{
		* Nuklear UI: https://github.com/Immediate-Mode-UI/Nuklear
		* TinyFileDialog: https://github.com/native-toolkit/tinyfiledialogs
	}

	Press `esc` to exit the application.
=================================================================*/

#include <gs.h>

#include "font.h"
#include "tinyfiledialogs.h"
#include "font/font_data.c"

#define NK_INCLUDE_FIXED_TYPES
#define NK_INCLUDE_STANDARD_IO
#define NK_INCLUDE_STANDARD_VARARGS
#define NK_INCLUDE_DEFAULT_ALLOCATOR
#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
#define NK_INCLUDE_FONT_BAKING
#define NK_INCLUDE_DEFAULT_FONT
#define NK_IMPLEMENTATION
#define NK_GLFW_GL3_IMPLEMENTATION
#define NK_KEYSTATE_BASED_INPUT
#include "nuklear.h"
#include "nuklear_glfw_gl3.h"

#define MAX_VERTEX_BUFFER 512 * 1024
#define MAX_ELEMENT_BUFFER 128 * 1024


//================================================================

void print_bin(uint8_t byte)
{
    int i = CHAR_BIT; /* however many bits are in a byte on your platform */
    while(i--) {
        putchar('0' + ((byte >> i) & 1)); /* loop through and print the bits */
    }
}

// Forward Decls
void pan_camera();

/*==============
// Byte Buffer
==============*/

typedef struct byte_buffer_t
{
	uint8_t* data;
	uint32_t position;
	uint32_t capacity;
	uint32_t size;
} byte_buffer_t;

#define byte_buffer_default_capacity 	1024

byte_buffer_t byte_buffer_new()
{
	byte_buffer_t buffer = {0};
	buffer.data = malloc(byte_buffer_default_capacity);
	memset(buffer.data, 0, byte_buffer_default_capacity);
	buffer.capacity = byte_buffer_default_capacity;
	buffer.size = 0;
	buffer.position = 0;
	return buffer; 
}

void byte_buffer_resize(byte_buffer_t* buffer, size_t sz);

void __byte_buffer_write_impl(byte_buffer_t* buffer, void* data, size_t sz)
{ 
	size_t total_write_size = buffer->position + sz;
	if (total_write_size >= buffer->capacity)
	{
		size_t capacity = buffer->capacity ? buffer->capacity * 2 : byte_buffer_default_capacity;
		while (capacity < total_write_size)
		{
			capacity *= 2;
		}
		byte_buffer_resize(buffer, capacity);
	}
	memcpy(buffer->data + buffer->position, data, sz);
	buffer->position += sz;
	buffer->size += sz; 
}

// Generic write function
#define byte_buffer_write(_buffer, T, _val)\
do {\
	byte_buffer_t* _bb = (_buffer);\
	size_t _sz = sizeof(T);\
	T _v = _val;\
	__byte_buffer_write_impl(_bb, (void*)&(_v), _sz);\
} while (0)

// Generic read function
#define byte_buffer_read(_buffer, T, _val_p)\
do {\
	T* _v = (T*)(_val_p);\
	byte_buffer_t* _bb = (_buffer);\
	*(_v) = *(T*)(_bb->data + _bb->position);\
	_bb->position += sizeof(T);\
} while (0)

// Utiltiy functions
void byte_buffer_clear(byte_buffer_t* buffer)
{
	buffer->size = 0;
	buffer->position = 0;
}

void byte_buffer_free(byte_buffer_t* buffer)
{
	byte_buffer_clear(buffer);
	free(buffer->data);
	buffer->data = NULL;
	buffer->capacity = 0;
}

void byte_buffer_resize(byte_buffer_t* buffer, size_t sz)
{
	uint8_t* data = realloc(buffer->data, sz);
	if (data == NULL) {
		return;
	}

	buffer->data = data;
	buffer->capacity = sz;
}

void byte_buffer_seek_to_beg(byte_buffer_t* buffer)
{
	buffer->position = 0;
}

void byte_buffer_seek_to_end(byte_buffer_t* buffer)
{
	buffer->position = buffer->size;
}

// Writing
gs_result 
byte_buffer_write_to_file(byte_buffer_t* buffer, const char* path)
{
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	gs_result res = platform->write_file_contents(path, "wb", buffer->data, sizeof(uint8_t), buffer->size);
	return res;
}

// Reading
gs_result
byte_buffer_read_from_file(byte_buffer_t* buffer, const char* path)
{
	// Clear previous data if any
	if (buffer->data) 
	{
		byte_buffer_free(buffer);
	}

	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	buffer->size = platform->file_size_in_bytes(path);
	buffer->data = platform->read_file_contents(path, "rb", NULL);

	if (!buffer->data) 
	{
		gs_assert(false);
		return gs_result_failure;
	}

	buffer->position = 0;
	buffer->capacity = buffer->size;
	return gs_result_success;
}

//================================================================

/*=========
// NK - UI
=========*/

struct pixel_frame_t;

gs_global struct nk_glfw g_nk_glfw = {0};
gs_global struct nk_context* g_nk_ctx;
gs_global struct nk_colorf g_nk_color;

void nk_init_ui();
void nk_do_ui(struct pixel_frame_t* pf);

//================================================================

/*=======================================
// Texture Buffer For Simple Pixel Editor
=======================================*/

b32 color_equal(gs_color_t c0, gs_color_t c1)
{
	return  (c0.r == c1.r) &&
			(c0.g == c1.g) &&
			(c0.b == c1.b) &&
			(c0.a == c1.a);
}

#define default_pixel_frame_width 		128
#define default_pixel_frame_height		128
#define ui_frame_width 					128
#define ui_frame_height 				128

const char* pixel_frame_v_src = "\n"
"#version 330 core\n"
"layout(location = 0) in vec2 a_pos;\n"
"layout(location = 1) in vec2 a_uv;\n"
"uniform mat4 u_proj;\n"
"uniform mat4 u_view;\n"
"out vec2 uv;\n"
"void main()\n"
"{\n"
"	gl_Position = u_proj * u_view * vec4(a_pos, 0.0, 1.0);\n"
"	uv = a_uv;\n"
"}";

const char* pixel_frame_f_src = "\n"
"#version 330 core\n"
"uniform sampler2D u_tex;"
"in vec2 uv;\n"
"out vec4 frag_color;\n"
"void main()\n"
"{\n"
"	frag_color = texture(u_tex, uv);\n"
"}";

/*
	These will be all the required op codes for undo/redo in our pixel editor
	We'll treat our undo/redo buffer as a simple VM
*/

typedef enum pixel_frame_action_op_code_type
{
	pixel_frame_action_op_write_pixels = 0x00,
	pixel_frame_action_op_clear_pixels = 0x01
} pixel_frame_action_op_code_type;

typedef struct pixel_frame_delta_color_t
{
	u8 r, g, b, a;
	u8 sign_bits;
} pixel_frame_delta_color_t;

typedef struct pixel_frame_action_write_t
{
	uint16_t idx;
	u8 r, g, b, a;
	u8 sign_bits;
} pixel_frame_action_write_t;

typedef struct pixel_frame_t
{
	gs_color_t* pixel_data;
	gs_color_t* ui_data;
	uint32_t pixel_frame_width;
	uint32_t pixel_frame_height;
	gs_texture_t bg_texture;
	gs_texture_t texture;
	gs_texture_t ui_texture;
	gs_shader_t shader;
	gs_uniform_t u_tex;
	gs_uniform_t u_proj;
	gs_uniform_t u_view;
	gs_vertex_buffer_t vbo;
	gs_index_buffer_t ibo;
	uint32_t paint_radius;
	b32 mouse_down;
	byte_buffer_t undo_buffer;
	byte_buffer_t redo_buffer;
	uint32_t current_write_size;
} pixel_frame_t;

typedef void (*put_pixel_func)(void*, gs_color_t, int32_t, int32_t);

// Bresenham Line -> from https://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm
void drawLine(void* data, gs_color_t color, int32_t x0, int32_t x1, int32_t y0, int32_t y1, put_pixel_func func)
{
	int32_t dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
	int32_t dy = abs(y1-y0), sy = y0<y1 ? 1 : -1; 
	int32_t err = (dx>dy ? dx : -dy)/2, e2;
 
	for(;;)
	{
		func(data, color, x0, y0);
		if (x0==x1 && y0==y1) break;
		e2 = err;
		if (e2 >-dx) { err -= dy; x0 += sx; }
		if (e2 < dy) { err += dx; y0 += sy; }
	}
}

// Function to put pixels 
// at subsequence points 
void drawCircle(void* data, gs_color_t color, b32 filled, int32_t xc, int32_t yc, int32_t x, int32_t y, put_pixel_func func) 
{
    if (filled)
    {
    	drawLine(data, color, xc - x, xc + x, yc + y, yc + y, func);
    	drawLine(data, color, xc - x, xc + x, yc - y, yc - y, func);
    	drawLine(data, color, xc - y, xc + y, yc + x, yc + x, func);
    	drawLine(data, color, xc - y, xc + y, yc - x, yc - x, func);
    }
    else 
    {
	    func(data, color, xc+x, yc+y); 
	    func(data, color, xc-x, yc+y); 

	    func(data, color, xc+x, yc-y); 
	    func(data, color, xc-x, yc-y); 

	    func(data, color, xc+y, yc+x); 
	    func(data, color, xc-y, yc+x); 

	    func(data, color, xc+y, yc-x); 
	    func(data, color, xc-y, yc-x);
    }
}

// Function for circle-generation 
// using Bresenham's algorithm 
void circleBres(void* data, gs_color_t color, b32 filled, int32_t xc, int32_t yc, int32_t r, put_pixel_func func) 
{ 
    int x = 0, y = r; 
    int d = 3 - 2 * r; 
    drawCircle(data, color, filled, xc, yc, x, y, func); 
    while (y >= x) 
    { 
        // For each pixel we will 
        // draw all eight pixels
        x++; 
  
        // Check for decision parameter 
        // and correspondingly  
        // update d, x, y 
        if (d > 0) 
        { 
            y--;  
            d = d + 4 * (x - y) + 10; 
        } 
        else
            d = d + 4 * x + 6; 
        drawCircle(data, color, filled, xc, yc, x, y, func); 
    } 
} 

gs_texture_parameter_desc pixel_frame_texture_parameter_desc()
{
	gs_texture_parameter_desc desc = gs_texture_parameter_desc_default();
	desc.mag_filter = gs_nearest;
	desc.min_filter = gs_nearest;
	desc.generate_mips = false;
	desc.width = default_pixel_frame_width;
	desc.height = default_pixel_frame_height;
	desc.num_comps = 4;
	return desc;
}

pixel_frame_t pixel_frame_new()
{
	gs_graphics_i* gfx = gs_engine_instance()->ctx.graphics;

	pixel_frame_t pf = {0};

	gs_texture_parameter_desc desc = pixel_frame_texture_parameter_desc();

	const gs_color_t checker_blue = (gs_color_t){ 50, 80, 180, 100 };
	const gs_color_t checker_white = (gs_color_t){ 255, 255, 255, 100 };

	const uint32_t bg_width = 5;
	const uint32_t bg_height = 5;
	gs_color_t* bg_data = gs_malloc(bg_width * bg_height * sizeof(gs_color_t));

	// Background image
	for (uint32_t h = 0; h < bg_width; ++h)
	{
		for (uint32_t w = 0; w < bg_height; ++w)
		{
			const uint32_t idx = h * bg_width + w;

			if (h % 2 == 0) {
				bg_data[ idx ] = w % 2 == 0 ? checker_white : checker_blue;
			}
			else {
				bg_data[ idx ] = w % 2 == 0 ? checker_blue : checker_white;
			}
		}
	}

	desc.width = bg_width;
	desc.height = bg_height;
	desc.data = bg_data;
	pf.bg_texture = gfx->construct_texture(desc);

	gs_free(bg_data);

	pf.pixel_frame_width = default_pixel_frame_width;
	pf.pixel_frame_height = default_pixel_frame_height;
	pf.pixel_data = gs_malloc(default_pixel_frame_width * default_pixel_frame_height * sizeof(gs_color_t));
	memset(pf.pixel_data, 0, default_pixel_frame_width * default_pixel_frame_height * sizeof(gs_color_t));

	desc = pixel_frame_texture_parameter_desc();
	desc.data = pf.pixel_data;
	pf.texture = gfx->construct_texture(desc);

	// UI data
	desc.width = ui_frame_width;
	desc.height = ui_frame_height;
	pf.ui_data = gs_malloc(desc.width * desc.height * sizeof(gs_color_t));
	desc.data = pf.ui_data;
	memset(pf.ui_data, 0, desc.width * desc.height * sizeof(gs_color_t));
	pf.ui_texture = gfx->construct_texture(desc);
	pf.paint_radius = 1;

	pf.shader = gfx->construct_shader(pixel_frame_v_src, pixel_frame_f_src);
	pf.u_tex = gfx->construct_uniform(pf.shader, "u_tex", gs_uniform_type_sampler2d);
	pf.u_proj = gfx->construct_uniform(pf.shader, "u_proj", gs_uniform_type_mat4);
	pf.u_view = gfx->construct_uniform(pf.shader, "u_view", gs_uniform_type_mat4);

	// Vertex data layout for our mesh
	gs_vertex_attribute_type layout[] = {

		gs_vertex_attribute_float2,		// Position
		gs_vertex_attribute_float2		// UV
	};

	// Vertex data for editor screen quad
	f32 v_data[] = 
	{
		// Positions  UVs
		-1.0f, -1.0f,  0.0f, 0.0f,	// Top Left
		 1.0f, -1.0f,  1.0f, 0.0f,	// Top Right 
		-1.0f,  1.0f,  0.0f, 1.0f,  // Bottom Left
		 1.0f,  1.0f,  1.0f, 1.0f   // Bottom Right
	};

	u32 i_data[] = {

		0, 3, 2,	// First Triangle
		0, 1, 3		// Second Triangle
	};

	// Construct vertex and index buffers
	pf.vbo = gfx->construct_vertex_buffer(layout, sizeof(layout), v_data, sizeof(v_data));
	pf.ibo = gfx->construct_index_buffer(i_data, sizeof(i_data));
	pf.mouse_down = false;
	pf.undo_buffer = byte_buffer_new();
	pf.redo_buffer = byte_buffer_new();
	pf.current_write_size = 0;

	return pf;
}

b32 pixel_frame_action_is_recording(pixel_frame_t* pf)
{
	return (pf->current_write_size != 0);
}

// Undo and Redo ops
void pixel_frame_action_start_record(pixel_frame_t* pf, pixel_frame_action_op_code_type op)
{
	// Cannot start another operation until the previous is done recording
	if (pixel_frame_action_is_recording(pf)) {
		return;
	}

	gs_println("Starting action...");
	// Write op code into buffer
	byte_buffer_write(&pf->undo_buffer, uint32_t, (uint32_t)op);
	pf->current_write_size += sizeof(pixel_frame_action_op_code_type);

	// Clear out redo buffer from previous actions
	byte_buffer_clear(&pf->redo_buffer);
}

void pixel_frame_action_end_record(pixel_frame_t* pf)
{
	if (!pixel_frame_action_is_recording(pf)) {
		return;
	}

	if (pf->current_write_size > sizeof(pixel_frame_action_op_code_type)) {
		// Write current write size into buffer then reset write size
		byte_buffer_write(&pf->undo_buffer, uint32_t, pf->current_write_size);
	}
	else {
		pf->undo_buffer.position -= sizeof(pixel_frame_action_op_code_type);	
		pf->undo_buffer.size -= sizeof(pixel_frame_action_op_code_type);	
	}

	gs_println("Ending action: sz: %zu, undo_size: %zu, undo_cap: %zu, redo_cap: %zu", pf->current_write_size, 
					pf->undo_buffer.size, pf->undo_buffer.capacity, pf->redo_buffer.capacity);



	pf->current_write_size = 0;
}

// Writing actions pushing ops into undo buffer
void pixel_frame_write_action_op(pixel_frame_t* pf, pixel_frame_action_write_t data)
{
	if (!pixel_frame_action_is_recording(pf)) {
		
		return;
	}

	// Write pixels...okie dokie, what does that data look like?
	// Do I need to keep track of previous pixel data? Not really, right? Because we know the starting state for all pixel data. It's memset to nothing.
	// Push data into byte buffer
	byte_buffer_write(&pf->undo_buffer, pixel_frame_action_write_t, data);
	pf->current_write_size += sizeof(data);
}

void pixel_frame_undo_action(pixel_frame_t* pf)
{
	if (pixel_frame_action_is_recording(pf)) {

		return;
	}

	if (pf->undo_buffer.position == 0)
	{
		return;
	}

	// To undo, we'll transfer an action from the undo buffer into the redo buffer, assuming there is data to be read
	// Move position back to read size from buffer
	pf->undo_buffer.position -= sizeof(uint32_t);

	uint32_t sz;
	byte_buffer_read(&pf->undo_buffer, uint32_t, &sz);

	// Move back in buffer entire write size now, including size variable
	pf->undo_buffer.position -= (sz + sizeof(uint32_t));

	// Save current position. We'll use this reset ourselves after applying undo.
	uint32_t start_position = pf->undo_buffer.position;

	pixel_frame_action_op_code_type op;
	byte_buffer_read(&pf->undo_buffer, uint32_t, &op);

	switch (op)
	{
		case pixel_frame_action_op_write_pixels:
		{
			const uint32_t num_pixels = (sz - sizeof(uint32_t)) / sizeof(pixel_frame_action_write_t);

			// Write op into redo buffer
			byte_buffer_write(&pf->redo_buffer, uint32_t, pixel_frame_action_op_write_pixels);

			// Write data into redo buffer and reset pixels before action
			for (u32 i = 0; i < num_pixels; ++i)
			{
				pixel_frame_action_write_t wd;
				byte_buffer_read(&pf->undo_buffer, pixel_frame_action_write_t, &wd);

				// Compute new delta based on this change
				gs_color_t c = pf->pixel_data[ wd.idx ];

				u8 r = wd.r; 
				u8 g = wd.g; 
				u8 b = wd.b; 
				u8 a = wd.a;

				gs_color_t p;
				p.r = (wd.sign_bits & 0x01) ? c.r + r : c.r - r;
				p.g = (wd.sign_bits & 0x02) ? c.g + g : c.g - g;
				p.b = (wd.sign_bits & 0x04) ? c.b + b : c.b - b;
				p.a = (wd.sign_bits & 0x08) ? c.a + a : c.a - a;

				pf->pixel_data[ wd.idx ] = p;

				// Calculate new delta for redo
				wd.sign_bits = 0x0;
				wd.sign_bits |= c.r > p.r ? 0x01 : 0x0;
				wd.sign_bits |= c.g > p.g ? 0x02 : 0x0;
				wd.sign_bits |= c.b > p.b ? 0x04 : 0x0;
				wd.sign_bits |= c.a > p.a ? 0x08 : 0x0;

				byte_buffer_write(&pf->redo_buffer, pixel_frame_action_write_t, wd);
			}

			// Write total size into redo buffer
			byte_buffer_write(&pf->redo_buffer, uint32_t, sz);

			// Set back to position before this action was recorded
			pf->undo_buffer.position = start_position;
		} break;

		default:
		{
			gs_assert(false);
		} break;
	}
}

typedef struct texture_t {
	uint32_t width;
	uint32_t height;
	uint32_t num_comps;
	void* pixels;
} texture_t;

void pixel_frame_redo_action(pixel_frame_t* pf)
{
 	if (pixel_frame_action_is_recording(pf)) {

		return;
	}

	if (pf->redo_buffer.position == 0)
	{
		return;
	}

	// Same as undo
	pf->redo_buffer.position -= sizeof(uint32_t);

	uint32_t sz;
	byte_buffer_read(&pf->redo_buffer, uint32_t, &sz);

	// Move back in buffer entire write size now, including size variable
	pf->redo_buffer.position -= (sz + sizeof(uint32_t));

	// Save current position. We'll use this reset ourselves after applying undo.
	uint32_t start_position = pf->redo_buffer.position;

	pixel_frame_action_op_code_type op;
	byte_buffer_read(&pf->redo_buffer, uint32_t, &op);

	switch (op)
	{
		case pixel_frame_action_op_write_pixels:
		{
			const uint32_t num_pixels = (sz - sizeof(uint32_t)) / sizeof(pixel_frame_action_write_t);

			// Write op into undo buffer
			byte_buffer_write(&pf->undo_buffer, uint32_t, pixel_frame_action_op_write_pixels);

			// Write data into redo buffer and reset pixels before action
			for (u32 i = 0; i < num_pixels; ++i)
			{
				pixel_frame_action_write_t wd;
				byte_buffer_read(&pf->redo_buffer, pixel_frame_action_write_t, &wd);

				// Compute new delta based on this change
				gs_color_t c = pf->pixel_data[ wd.idx ];

				u8 r = wd.r; 
				u8 g = wd.g; 
				u8 b = wd.b; 
				u8 a = wd.a; 

				gs_color_t p;
				p.r = (wd.sign_bits & 0x01) ? c.r + r : c.r - r;
				p.g = (wd.sign_bits & 0x02) ? c.g + g : c.g - g;
				p.b = (wd.sign_bits & 0x04) ? c.b + b : c.b - b;
				p.a = (wd.sign_bits & 0x08) ? c.a + a : c.a - a;

				pf->pixel_data[ wd.idx ] = p;

				// Calculate new delta for redo
				wd.sign_bits = 0x0;
				wd.sign_bits |= c.r > p.r ? 0x01 : 0x0;
				wd.sign_bits |= c.g > p.g ? 0x02 : 0x0;
				wd.sign_bits |= c.b > p.b ? 0x04 : 0x0;
				wd.sign_bits |= c.a > p.a ? 0x08 : 0x0;

				byte_buffer_write(&pf->undo_buffer, pixel_frame_action_write_t, wd);
			}

			// Write total size into redo buffer
			byte_buffer_write(&pf->undo_buffer, uint32_t, sz);

			// Set back to position before this action was recorded
			pf->redo_buffer.position = start_position;
		} break;

		default:
		{
			gs_assert(false);
		} break;
	}
}

gs_vec2 pixel_frame_calculate_mouse_position(pixel_frame_t* pf, gs_camera_t* camera)
{
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	gs_vec2 ws = platform->window_size(platform->main_window());

	gs_vec2 pmp = platform->mouse_position();
	gs_vec3 _tpmp = gs_camera_unproject(camera, (gs_vec3){pmp.x, pmp.y, 0.f}, ws.x, ws.y);
	gs_vec2 tpmp = (gs_vec2){_tpmp.x, _tpmp.y};
	tpmp.x = tpmp.x * 0.5f + 0.5f;
	tpmp.y = tpmp.y * 0.5f + 0.5f;
	tpmp.y = gs_map_range(1.f, 0.f, 0.f, 1.f, tpmp.y);

	// Need to place mouse into frame
	f32 x_scale = tpmp.x;
	f32 y_scale = tpmp.y;
	return (gs_vec2){ x_scale * (f32)pf->pixel_frame_width, y_scale * (f32)pf->pixel_frame_height };
}

int32_t pixel_frame_compute_idx_from_position(pixel_frame_t* pf, int32_t x, int32_t y)
{
	if (x >= pf->pixel_frame_width || y >= pf->pixel_frame_height || x < 0 || y < 0 ) {
		return -1;
	}

	return (y * pf->pixel_frame_width + x);
}

void pixel_frame_draw_pixel(void* data, gs_color_t color, int32_t x, int32_t y)
{
	pixel_frame_t* pf = (pixel_frame_t*)data;

	if (x < 0 || x >= pf->pixel_frame_width || y < 0 || y >= pf->pixel_frame_height)
		return;

	int32_t idx = pixel_frame_compute_idx_from_position(pf, x, y);

	if (idx != -1) {

		// Get converted color from color picker
		gs_color_t c = color;
		gs_color_t p = pf->pixel_data[ idx ];

		// Compute delta and signs
		uint8_t sign_bits = 0x0;
		uint8_t r = (uint8_t)abs((int32_t)c.r - (int32_t)p.r);
		uint8_t g = (uint8_t)abs((int32_t)c.g - (int32_t)p.g);
		uint8_t b = (uint8_t)abs((int32_t)c.b - (int32_t)p.b);
		uint8_t a = (uint8_t)abs((int32_t)c.a - (int32_t)p.a);

		sign_bits |= c.r < p.r ? 0x01 : 0x0;
		sign_bits |= c.g < p.g ? 0x02 : 0x0;
		sign_bits |= c.b < p.b ? 0x04 : 0x0;
		sign_bits |= c.a < p.a ? 0x08 : 0x0;

		pixel_frame_action_write_t wd = 
		{
			(uint16_t)idx, 
			r, g, b, a,
			sign_bits
		};

		// Only write if there's an actual change
		if (!color_equal(c, p)) {

			pixel_frame_write_action_op(pf, wd);
			pf->pixel_data[ idx ] = color;
		}
	}
}

void pixel_frame_draw_ui_pixel(void* data, gs_color_t color, int32_t x, int32_t y)
{
	pixel_frame_t* pf = (pixel_frame_t*)data;

	if (x >= ui_frame_width || x < 0 || y >= ui_frame_height || y < 0) 
		return;

	uint32_t idx = y * ui_frame_width + x;
		
	// Get converted color from color picker
	gs_color_t c = (gs_color_t){g_nk_color.r * 255, g_nk_color.g * 255, g_nk_color.b * 255, g_nk_color.a * 100};
	pf->ui_data[ idx ] = color;
}

void pixel_frame_clear_data(pixel_frame_t* pf)
{
	if (!pixel_frame_action_is_recording(pf)) 
	{
		// Start record
		pixel_frame_action_start_record(pf, pixel_frame_action_op_write_pixels);

		const gs_color_t clear_color = (gs_color_t){ 0, 0, 0, 0 };

		// Clear all data
		for (uint32_t h = 0; h < pf->pixel_frame_height; ++h) {
			for (uint32_t w = 0; w < pf->pixel_frame_width; ++w) {

				pixel_frame_draw_pixel(pf, clear_color, w, h);
			}
		}

		// End record
		pixel_frame_action_end_record(pf);
	}
	// memset(pf->pixel_data, 0, pf->pixel_frame_width * pf->pixel_frame_height * sizeof(gs_color_t));
}


void pixel_frame_save_image_to_disk(pixel_frame_t* pf)
{
	if (pixel_frame_action_is_recording(pf)) {
		return;
	}

	// We'll just write it to 'test.bin'
	byte_buffer_t buffer = byte_buffer_new();

	// Serialize all pixel frame data to disk
	for (uint32_t h = 0; h < pf->pixel_frame_height; ++h)
	{
		for (uint32_t w = 0; w < pf->pixel_frame_width; ++w)
		{
			uint32_t idx = h * pf->pixel_frame_width + w;
			byte_buffer_write(&buffer, uint8_t, pf->pixel_data[ idx ].r);
			byte_buffer_write(&buffer, uint8_t, pf->pixel_data[ idx ].g);
			byte_buffer_write(&buffer, uint8_t, pf->pixel_data[ idx ].b);
			byte_buffer_write(&buffer, uint8_t, pf->pixel_data[ idx ].a);
		}
	}

	const char* filter_patterns[] = {
		"*.pix"
	};

	const char* file_name = tinyfd_saveFileDialog(
		"Save Image", 
		"./image.pix", 
		sizeof(filter_patterns) / sizeof(char*), 
		filter_patterns, 
		NULL 
	);

	// Write to file if valid
	if (file_name) {
		byte_buffer_write_to_file(&buffer, file_name);
	}

	byte_buffer_free(&buffer);

}

void pixel_frame_load_image_from_disk(pixel_frame_t* pf)
{
	if (pixel_frame_action_is_recording(pf)) {
		return;
	}

	const char* filter_patterns[] = {
		"*.pix", "*.png"
	};

	const char* file_name = tinyfd_openFileDialog(
		"Open Image", 
		"./", 
		sizeof(filter_patterns) / sizeof(char*),
		filter_patterns,
		NULL,
		false
	);

	if (file_name == NULL) {
		return;
	}

	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	if (!platform->file_exists(file_name)) {
		return;
		}

	char file_ext[256];
	gs_util_get_file_extension(file_ext, sizeof(file_ext), file_name);

	if (gs_string_compare_equal(file_ext, "pix"))
	{
		byte_buffer_t buffer = byte_buffer_new();

		byte_buffer_read_from_file(&buffer, file_name);

		// Serialize all pixel frame data to disk
		for (uint32_t h = 0; h < pf->pixel_frame_height; ++h)
		{
			for (uint32_t w = 0; w < pf->pixel_frame_width; ++w)
			{
				uint32_t idx = h * pf->pixel_frame_width + w;
				byte_buffer_read(&buffer, uint8_t, &pf->pixel_data[ idx ].r);
				byte_buffer_read(&buffer, uint8_t, &pf->pixel_data[ idx ].g);
				byte_buffer_read(&buffer, uint8_t, &pf->pixel_data[ idx ].b);
				byte_buffer_read(&buffer, uint8_t, &pf->pixel_data[ idx ].a);
			}
		}

		// Clear out undo/redo buffers
		byte_buffer_clear(&pf->undo_buffer);
		byte_buffer_clear(&pf->redo_buffer);
		byte_buffer_free(&buffer);
	}
	else if (gs_string_compare_equal(file_ext, "png"))
	{
		// Need to load in .png and then change size of texture...	
	}
}

b32 pixel_frame_hovering_ui_window()
{
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	gs_vec2 mp = platform->mouse_position();
	gs_vec2 ws = platform->window_size(platform->main_window());

	uint32_t sw = 250.f;

	return mp.x < sw;
}

// Drag/drop texture into frame?
// Save/Load images
// Change colors	(might just have a set number of colors - not sure how I'd represent 32 bit colors without some
// 						complicated gui mechanism)
// Radius for painting

void pixel_frame_update(pixel_frame_t* pf, gs_camera_t* camera)
{
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	b32 need_update = false;
	static gs_vec2 original_mouse_position;

	b32 alt_down = platform->key_down(gs_keycode_lalt);
	b32 space_down = platform->key_down(gs_keycode_space);

	gs_vec2 mp = pixel_frame_calculate_mouse_position(pf, camera);
	const uint32_t mp_x = (uint32_t)mp.x;
	const uint32_t mp_y = pf->pixel_frame_height - (uint32_t)mp.y - 1;
	const int32_t idx = pixel_frame_compute_idx_from_position(pf, mp_x, mp_y);

	// Painting operation
	if (platform->mouse_down(gs_mouse_lbutton) && !pixel_frame_hovering_ui_window()) 
	{
		if (!alt_down && !space_down)
		{
			if (!pf->mouse_down) {
				pf->mouse_down = true;

				// Start recording
				pixel_frame_action_start_record(pf, pixel_frame_action_op_write_pixels);	
			}

			if (idx != -1) {

				// Get converted color from color picker
				gs_color_t col = (gs_color_t){g_nk_color.r * 255, g_nk_color.g * 255, g_nk_color.b * 255, g_nk_color.a * 255};

				if (pf->paint_radius > 1) {
					circleBres(pf, col, true, mp.x, pf->pixel_frame_height - mp.y, pf->paint_radius, &pixel_frame_draw_pixel);
				} else {
					pixel_frame_draw_pixel(pf, col, mp_x, mp_y);
				}
			}
		}
		// Color picking
		else if (alt_down)
		{
			if (idx != -1) {

				gs_color_t c = pf->pixel_data[ idx ];
				g_nk_color.r = (f32)c.r / 255.f;
				g_nk_color.g = (f32)c.g / 255.f;
				g_nk_color.b = (f32)c.b / 255.f;
				g_nk_color.a = (f32)c.a / 255.f;
			}
		}
		// Camera pan
		else if (space_down)
		{
			pan_camera();
		}
	}

	// Need to record actions here
	if (platform->mouse_released(gs_mouse_lbutton))
	{
		// Start recording
		pixel_frame_action_end_record(pf);
		pf->mouse_down = false;
	}

	// Paint radius
	if (platform->key_pressed(gs_keycode_lbracket))
	{
		pf->paint_radius = gs_max((int32_t)1, (int32_t)pf->paint_radius - 1);
	}

	if (platform->key_pressed(gs_keycode_rbracket))
	{
		pf->paint_radius = gs_min(20, pf->paint_radius + 1);
	}

	if (platform->key_down(gs_keycode_lctrl) && platform->key_pressed(gs_keycode_z))
	{
		pixel_frame_undo_action(pf);
	}

	if (platform->key_down(gs_keycode_lctrl) && platform->key_pressed(gs_keycode_y))
	{
		pixel_frame_redo_action(pf);
	}

	if (platform->key_down(gs_keycode_lctrl) && platform->key_pressed(gs_keycode_s))
	{
		pixel_frame_save_image_to_disk(pf);
	}

	if (platform->key_down(gs_keycode_lctrl) && platform->key_pressed(gs_keycode_o))
	{
		pixel_frame_load_image_from_disk(pf);
	}

	if (platform->key_pressed(gs_keycode_c))
	{
		pixel_frame_clear_data(pf);
	}

	// Update GPU texture data
	gs_graphics_i* gfx = gs_engine_instance()->ctx.graphics;
	gs_texture_parameter_desc desc = pixel_frame_texture_parameter_desc();
	desc.width = pf->pixel_frame_width;
	desc.height = pf->pixel_frame_height;
	desc.data = pf->pixel_data;
	gfx->update_texture_data(&pf->texture, desc);	

	// Draw ui into buffer
	memset(pf->ui_data, 0, ui_frame_width * ui_frame_height * sizeof(gs_color_t));
	const gs_color_t col = (gs_color_t){ (u8)g_nk_color.r * 255, (u8)g_nk_color.g * 255, (u8)g_nk_color.b * 255, 50 };
	gs_vec2 ws = platform->window_size(platform->main_window());
	gs_vec2 m_pos = platform->mouse_position();
	f32 scl_x = m_pos.x / ws.x;
	f32 scl_y = m_pos.y / ws.y;
	if (pf->paint_radius > 0) 
	{
		circleBres(pf, col, false, mp.x, ui_frame_height - mp.y, pf->paint_radius, &pixel_frame_draw_ui_pixel);
	}

	desc = pixel_frame_texture_parameter_desc();
	desc.width = ui_frame_width;
	desc.height = ui_frame_height;
	desc.data = pf->ui_data;
	gfx->update_texture_data(&pf->ui_texture, desc);	
}

void pixel_frame_render(pixel_frame_t* pf, gs_command_buffer_t* cb, gs_camera_t* camera)
{
	gs_graphics_i* gfx = gs_engine_instance()->ctx.graphics;
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	gs_vec2 ws = platform->window_size(platform->main_window());

	gs_mat4 proj_mtx = gs_camera_get_projection(camera, ws.x, ws.y);
	gs_mat4 view_mtx = gs_camera_get_view(camera);

	f32 clear_color[4] = { 0.5f, 0.5f, 0.5f, 1.f };
	gfx->set_view_clear(cb, clear_color);

	// Bind shader
	gfx->bind_shader(cb, pf->shader);
	gfx->bind_uniform(cb, pf->u_proj, &proj_mtx);
	gfx->bind_uniform(cb, pf->u_view, &view_mtx);

	// Render background texture
	gfx->bind_texture(cb, pf->u_tex, pf->bg_texture, 0);
	gfx->bind_vertex_buffer(cb, pf->vbo);
	gfx->bind_index_buffer(cb, pf->ibo);
	gfx->draw_indexed(cb, 6, 0);

	// Render paint texture
	gfx->bind_texture(cb, pf->u_tex, pf->texture, 0);
	gfx->bind_vertex_buffer(cb, pf->vbo);
	gfx->bind_index_buffer(cb, pf->ibo);
	gfx->draw_indexed(cb, 6, 0);

	// Render ui texture
	gfx->bind_texture(cb, pf->u_tex, pf->ui_texture, 0);
	gfx->bind_vertex_buffer(cb, pf->vbo);
	gfx->bind_index_buffer(cb, pf->ibo);
	gfx->draw_indexed(cb, 6, 0);
}

//================================================================

// Globals
gs_global gs_command_buffer_t g_cb = {0};
gs_global pixel_frame_t g_pixel_frame = {0};
gs_global gs_camera_t g_camera = {0};

// Forward Decls.
gs_result app_init();		// Use to init your application
gs_result app_update();		// Use to update your application
gs_result app_shutdown();	// Use to shutdown your appliaction

typedef struct test_t
{
	u32 unsigned_val;
	s32 signed_val;
	f32 float_val;
	f64 double_val;
} test_t;

void print_test(test_t* t)
{
	gs_println("test: { %zu, %d, %.2f, %.5f }", 
		t->unsigned_val, t->signed_val, t->float_val, t->double_val);
}

int main(int argc, char** argv)
{
	gs_application_desc_t app = {0};
	app.window_title 		= "Serialization Example";
	app.window_width 		= 1200;
	app.window_height 		= 600;
	app.init 				= &app_init;
	app.update 				= &app_update;
	app.shutdown 			= &app_shutdown;

	// Construct internal instance of our engine
	gs_engine_t* engine = gs_engine_construct(app);

	// Run the internal engine loop until completion
	gs_result res = engine->run();

	// Check result of engine after exiting loop
	if (res != gs_result_success) 
	{
		gs_println("Error: Engine did not successfully finish running.");
		return -1;
	}

	gs_println("Gunslinger exited successfully.");

	return 0;	
}

void byte_buffer_test()
{
	test_t t0 = {0};
	t0.unsigned_val = 5;
	t0.signed_val = -20;
	t0.float_val = -3.145f;
	t0.double_val = 2.37854;

	byte_buffer_t buffer = byte_buffer_new();

	// Serialize our test data structure into our buffer
	byte_buffer_write(&buffer, uint32_t, t0.unsigned_val);
	byte_buffer_write(&buffer, int32_t, t0.signed_val);
	byte_buffer_write(&buffer, float, t0.float_val);
	byte_buffer_write(&buffer, double, t0.double_val);

	// Seek back to beginning
	byte_buffer_seek_to_beg(&buffer);

	// Read values into our new test data
	test_t t1 = {0};

	byte_buffer_read(&buffer, uint32_t, &t1.unsigned_val);
	byte_buffer_read(&buffer, int32_t, &t1.signed_val);
	byte_buffer_read(&buffer, float, &t1.float_val);
	byte_buffer_read(&buffer, double, &t1.double_val);

	print_test(&t1);

	// Write to file
	byte_buffer_write_to_file(&buffer, "./test.bin");

	// Read back from file
	byte_buffer_read_from_file(&buffer, "./test.bin");

	// Read back into new object
	test_t t2 = {0};

	// Read back entire object from memory
	byte_buffer_read(&buffer, uint32_t, &t2.unsigned_val);
	byte_buffer_read(&buffer, int32_t, &t2.signed_val);
	byte_buffer_read(&buffer, float, &t2.float_val);
	byte_buffer_read(&buffer, double, &t2.double_val);

	print_test(&t2);

	// Clean up byte buffer memory
	byte_buffer_free(&buffer);
}

// Here, we'll initialize all of our application data, which in this case is our graphics resources
gs_result app_init()
{
	// Cache instance of graphics/platform apis from engine
	gs_graphics_i* gfx = gs_engine_instance()->ctx.graphics;
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;

	byte_buffer_test();

	g_pixel_frame = pixel_frame_new();

	// This is a descriptor for our texture. It includes various metrics, such as the width, height, texture format, 
	// and holds the actual uncompressed texture data for the texture. After using it for loading a raw texture 
	// from file, it's the responsibility of the user to free the data.
	gs_texture_parameter_desc desc = gs_texture_parameter_desc_default();

	// Construct command buffer (the command buffer is used to allow for immediate drawing at any point in our program)
	g_cb = gs_command_buffer_new();

	// Construct camera parameters
	g_camera.transform = gs_vqs_default();
	g_camera.transform.position = (gs_vec3){-1.f, 0.f, -1.f};
	g_camera.fov = 60.f;
	g_camera.near_plane = 0.1f;
	g_camera.far_plane = 1000.f;
	g_camera.ortho_scale = 2.f;
	g_camera.proj_type = gs_projection_type_orthographic;

	nk_init_ui();

	return gs_result_success;
}

gs_result app_update()
{
	// Grab global instance of engine
	gs_engine_t* engine = gs_engine_instance();

	// Platform api 
	gs_platform_i* platform = engine->ctx.platform;

	// Main window size
	gs_vec2 ws = platform->window_size(platform->main_window());
	gs_vec2 fbs = platform->frame_buffer_size(platform->main_window());

	// If we press the escape key, exit the application
	if (platform->key_pressed(gs_keycode_esc))
	{
		return gs_result_success;
	}

	const f32 dt = platform->time.delta;
	const f32 t = platform->elapsed_time();

	/*=================
	// Camera controls
	==================*/

	if (platform->key_down(gs_keycode_q)) {
		g_camera.ortho_scale += 0.1f;
	}
	if (platform->key_down(gs_keycode_e)) {
		g_camera.ortho_scale -= 0.1f;
	}

	if (platform->key_down(gs_keycode_a)) {
		g_camera.transform.position.x -= 0.1f;
	}
	if (platform->key_down(gs_keycode_d)) {
		g_camera.transform.position.x += 0.1f;
	}
	if (platform->key_down(gs_keycode_w)) {
		g_camera.transform.position.y += 0.1f;
	}
	if (platform->key_down(gs_keycode_s)) {
		g_camera.transform.position.y -= 0.1f;
	}
	if (platform->mouse_down(gs_mouse_mbutton))
	{
		// Need to transform the camera's position by the transformation of the mouse in world space only...I think
		gs_vec2 md = platform->mouse_delta();
		gs_vec2 mc = platform->mouse_position();
		gs_vec3 wc = (gs_vec3){mc.x, mc.y, 0.f};
		gs_vec3 pmp = gs_camera_unproject(&g_camera, wc, ws.x, ws.y);
		gs_vec3 pmp_d = gs_camera_unproject(&g_camera, (gs_vec3){mc.x + md.x, mc.y + md.y, 0.f}, ws.x, ws.y);
		gs_vec3 delta = gs_vec3_sub(pmp, pmp_d);

		g_camera.transform.position.x += delta.x;
		g_camera.transform.position.y += delta.y;
	}

	f32 mwx, mwy;
	platform->mouse_wheel(&mwx, &mwy);
	g_camera.ortho_scale = gs_clamp(g_camera.ortho_scale - mwy * 0.2f, 0.2f, 10.f);

	/*===============
	// Update scene
	================*/

	pixel_frame_update(&g_pixel_frame, &g_camera);

	/*===============
	// Render scene
	================*/

	// Graphics api instance
	gs_graphics_i* gfx = engine->ctx.graphics;
	gs_command_buffer_t* cb = &g_cb;

	// Set clear color and clear screen
	f32 clear_color[4] = { 0.1f, 0.1f, 0.1f, 1.f };
	gfx->set_view_clear(cb, clear_color);

	gfx->set_viewport(cb, 0.f, 0.f, fbs.x, fbs.y);
	gfx->set_depth_enabled(cb, false);
	gfx->set_blend_mode(cb, gs_blend_mode_src_alpha, gs_blend_mode_one_minus_src_alpha);

	pixel_frame_render(&g_pixel_frame, cb, &g_camera);

	// Submit command buffer for rendering
	gfx->submit_command_buffer(cb);

	// Handle ui
	nk_do_ui(&g_pixel_frame);

	return gs_result_in_progress;
}

gs_result app_shutdown()
{
	gs_println("Goodbye, Gunslinger.");
	return gs_result_success;
}

void pan_camera()
{
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	gs_vec2 ws = platform->window_size(platform->main_window());

	gs_vec2 md = platform->mouse_delta();
	gs_vec2 mc = platform->mouse_position();
	gs_vec3 wc = (gs_vec3){mc.x, mc.y, 0.f};
	gs_vec3 pmp = gs_camera_unproject(&g_camera, wc, ws.x, ws.y);
	gs_vec3 pmp_d = gs_camera_unproject(&g_camera, (gs_vec3){mc.x + md.x, mc.y + md.y, 0.f}, ws.x, ws.y);
	gs_vec3 delta = gs_vec3_sub(pmp, pmp_d);

	g_camera.transform.position.x += delta.x;
	g_camera.transform.position.y += delta.y;
}

void nk_init_ui()
{
	g_nk_color = (struct nk_colorf){0.f, 0.f, 0.f, 1.f};
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
    GLFWwindow* win = platform->raw_window_handle(platform->main_window());
    g_nk_ctx = nk_glfw3_init(&g_nk_glfw, win, 0);
    struct nk_font_atlas* atlas;
    nk_glfw3_font_stash_begin(&g_nk_glfw, &atlas);
    nk_glfw3_font_stash_end(&g_nk_glfw);
}

void nk_do_ui(struct pixel_frame_t* pf)
{
	gs_platform_i* platform = gs_engine_instance()->ctx.platform;
	gs_vec2 ws = platform->window_size(platform->main_window());

	// Do the ui stuff
	nk_glfw3_new_frame(&g_nk_glfw);

    /* GUI */
    if (nk_begin(g_nk_ctx, "Demo", nk_rect(0, 0, 250, ws.y), NK_WINDOW_BORDER))
    {
        nk_layout_row_dynamic(g_nk_ctx, 20, 1);
        nk_label(g_nk_ctx, "Color", NK_TEXT_LEFT);
        {
            nk_layout_row_dynamic(g_nk_ctx, 120, 1);

            g_nk_color = nk_color_picker(g_nk_ctx, g_nk_color, NK_RGBA);

            nk_layout_row_dynamic(g_nk_ctx, 25, 1);
            g_nk_color.r = nk_propertyf(g_nk_ctx, "#R:", 0, g_nk_color.r, 1.0f, 0.01f,0.005f);
            g_nk_color.g = nk_propertyf(g_nk_ctx, "#G:", 0, g_nk_color.g, 1.0f, 0.01f,0.005f);
            g_nk_color.b = nk_propertyf(g_nk_ctx, "#B:", 0, g_nk_color.b, 1.0f, 0.01f,0.005f);
            g_nk_color.a = nk_propertyf(g_nk_ctx, "#A:", 0, g_nk_color.a, 1.0f, 0.01f,0.005f);
        }

        // nk_layout_row_begin(g_nk_ctx, NK_STATIC, 2, 3);
        {
            g_pixel_frame.paint_radius = nk_propertyi(g_nk_ctx, "Paint Radius", 0, g_pixel_frame.paint_radius, 20, 1, 0.8f);

	        // nk_layout_row_static(g_nk_ctx, 30, 80, 1);
	        if (nk_button_label(g_nk_ctx, "Save"))
	        {
	        	pixel_frame_save_image_to_disk(pf);
	        }

	        // nk_layout_row_static(g_nk_ctx, 30, 80, 1);
	        if (nk_button_label(g_nk_ctx, "Load"))
	        {
	        	pixel_frame_load_image_from_disk(pf);
	        }
        }
        // nk_layout_row_end(g_nk_ctx);
    }
    nk_end(g_nk_ctx);
    nk_glfw3_render(&g_nk_glfw, NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER, MAX_ELEMENT_BUFFER);
}