/*
 * libTangerine, a small, modern openGL renderer specializing in flat shaded,
 * 	solid color models using pallete textures. See README for build instructions
 * 	and look in the examples folder for... examples
 *
 * fixmes)
 * FIXME: remove mesh.h, mesh.cpp
 * FIXME: remove platform_wait_for_vblank
 * FIXME: clean up examples with new asset system
 * FIXME: merger render_group_fix branch back into master
 * FIXME: make a test case for overflowing default array sizes, rg->assets
 * 	rg_info->groups, render_group->enitities, rg->textures
 * FIXME: look for glm::mat4 in structs, and replace with pointers
 * FIXME: better shader abstraction so we can store a list of shaders on
 * 	render_state
 *
 * todos)
 * TODO: make assetInit* functions generic
 * TODO: make initModel/initTexture functions generic
 */

#pragma once

#if defined (_WIN32)
	#include <SDL.h>
#else
	#include <SDL2/SDL.h>
#endif
#include <GL/glew.h>
#include <glm/glm.hpp>

#include "asset.h"
#include "camera.h"
#include "entity.h"
#include "lights.h"
#include "util.h"
#include "shader_program.h"


// NOTE: array of entities rendered with the same shader program
struct render_group
{
	// TODO: also needs to be resizable
	entity* entities;
	uint count;
	uint max_size;
	shader_wrapper shader;
};

struct rg_info
{
	render_group* groups;
	uint count;
	uint max_size;
};

render_group*
rgAlloc(rg_info* rgi, uint num_entites, shader_wrapper shader);

entity*
rgAppend(render_group* rg,
	model_assets* assets,
	texture_assets* textures,
	memory_arena* arena,
	const char* model_path);

struct SDL_Handles
{
	SDL_Window *window;
	SDL_GLContext glContext;
	SDL_DisplayMode currentDisplayMode;
};

#define DEFAULT_RG_COUNT 256
struct render_state
{
	glm::vec2 viewport_dims;
	camera* cam;
	util_RGBA clear_col;
	SDL_Handles* handles;
	bool running;

	rg_info* render_groups;

	memory_arena* arena;
	model_assets* assets;
	texture_assets* textures;

	// TODO: hide shaders behind a better abstraction than 'shader_wrapper'
	default_shader_program* default_shader;
	simple_shader_program* simple_shader;

	light_group* lights;
};

#define DEFAULT_ASSET_SIZE 256
render_state*
renInit(const char* title = "Tangerine",
	glm::vec2 viewport_dims = glm::vec2(1280, 720),
	Uint32 SDL_init_flags = 0,
	size_t arena_size = DEFAULT_ARENA_SIZE,
	uint asset_size = DEFAULT_ASSET_SIZE);

void renShutdown(render_state* rs);

// NOTE: callback function signature to use with renDoRenderLoop()
typedef void (*frame_callback_fn) (render_state*);

// NOTE: There are 2 callbacks to use here, cb_func_pre is called before
// 	the call to renRenderFrame(), cb_fun_post is called after
// NOTE: if you use cb_func_pre, you will have to use SDL_PollEvent() manually
// 	and at minimum set rs->running = false on SDL_QUIT event
void
renDoRenderLoop(render_state* rs,
	uint framerate = 60,
	frame_callback_fn cb_func_pre = nullptr,
	frame_callback_fn cb_func_post = nullptr);

void renRenderFrame(render_state* rs);

bool
renAddLight(render_state* rs,
	glm::vec3 pos = glm::vec3(0, 0, 0),
	glm::vec3 color = glm::vec3(1, 1, 1),
	float intensity = 1.0);

glm::vec2
renGetWindowDims(render_state* rs);