libTangerine/src/renderer.cpp

#include <vector>
#include <cmath> // trig functions

#if defined (_WIN32)
	#include <SDL.h>
#else
	#include <SDL2/SDL.h>
#endif
#include <glm/glm.hpp>
#include <glm/geometric.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include "dumbLog.h"
#include "render_object.h"
#include "renderer.h"
#include "default_shaders.cpp"

#define MAX_LIGHTS 10 // NOTE: needs to match the fragment shader source
#define CLEAR_COL_R 55.f / 255.f
#define CLEAR_COL_G 55.f / 255.f
#define CLEAR_COL_B 55.f / 255.f
#define CLEAR_COL_A 1.f
#define USE_SECOND_MONITOR 0


// forward declarations
void openglDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity,
		GLsizei length, const GLchar* message, const void* userParam);
bool initSDL(SDL_Handles& handles);
bool createWindow(const char* title,
		SDL_Handles& handles,
		glm::vec2& viewport_dims);
bool initContext(SDL_Handles& handles);
bool initGlOptions();
void setDefaults(render_state* rs, glm::vec2 viewport_dims);


// interface

render_state*
renInit(const char* title, glm::vec2 viewport_dims)
{
	render_state* rs = UTIL_ALLOC(1, render_state);
	setDefaults(rs, viewport_dims);

	if (initSDL(rs->handles) &&
		createWindow(title, rs->handles, rs->viewport_dims) &&
		initContext(rs->handles) &&
		initGlOptions())
	{
		rs->default_shader =
			shaderInit(DEFAULT_VERTEX_SHADER, DEFAULT_FRAGMENT_SHADER);

		if (rs->default_shader != nullptr) {
			return rs;
		} else {
			LOG(Error) << "shader loading failed\n";
			return nullptr;
		}
	}

	LOG(Error) << "renderer initialization failed, aborting\n";
	return nullptr;
}

void
renShutdown(render_state* rs)
{
	// TODO: need a nicer way to loop over entities and render_objects
	for (uint i = 0; i < rs->render_group_count; i++) {
		render_group& rg = rs->render_groups[i];

		for (uint j = 0; j < rg.entity_count; j++) {
			entity& e = rg.entities[j];

			for (uint k = 0; k < e.ro_count; k++)
				roFree(e.render_objs[k]);

			utilSafeFree(e.render_objs);
		}

		utilSafeFree(rg.entities);
	}

	shaderFree(rs->default_shader);
	lightsOut(rs->lights);
	utilSafeFree(rs->render_groups);
	utilSafeFree(rs->default_shader);
	SDL_GL_DeleteContext(rs->handles.glContext);
	SDL_DestroyWindow(rs->handles.window);
	SDL_Quit();
}

render_group*
renAllocateGroup(uint entity_count, shader_program shader)
{
	assert(entity_count > 0);
	render_group* rg = UTIL_ALLOC(1, render_group);
	rg->entities = UTIL_ALLOC(entity_count, entity);
	rg->entity_count = entity_count;
	rg->shader = shader;
	return rg;
}

void
renRenderFrame(render_state* rs)
{
	glClearColor(rs->clear_col.R, rs->clear_col.G, rs->clear_col.B, rs->clear_col.A);
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

	for (uint i = 0; i < rs->render_group_count; i++) {
		render_group& rg = rs->render_groups[i];

		for (uint j = 0; j < rg.entity_count; j++) {
			entity& e = rg.entities[j];

			for (uint k = 0; k < e.ro_count; k++) {
				roDraw(e.render_objs[k],
					rs->cam,
					rg.shader,
					rs->lights);
			}
		}
	}
}

bool
renAddLight(render_state* rs, glm::vec3 pos, glm::vec3 color, float intensity)
{
	return lightsAdd(rs->lights, pos, color, intensity);
}


// internal

void
openglDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity,
					GLsizei length, const GLchar* message, const void* userParam)
{
	LOG((type == GL_DEBUG_TYPE_ERROR) ? Error : Debug)
		<< (type == GL_DEBUG_TYPE_ERROR ? "** GL Error **" : "")
		<< ", type: " << type
		<< ", severity: " << severity
		<< ", message: " << message << "\n";
}

bool
initSDL(SDL_Handles& handles)
{
	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
		LOG(Error) << "Error, SDL_Init: " << SDL_GetError() << "\n";
		return false;
	}

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
	SDL_GetCurrentDisplayMode(0, &handles.currentDisplayMode);

	return true;
}

bool
createWindow(const char* title, SDL_Handles& handles, glm::vec2& viewport_dims)
{
	uint display_id = 0;
	if (USE_SECOND_MONITOR && SDL_GetNumVideoDisplays() > 1)
		display_id = 1;

	handles.window = SDL_CreateWindow(
		title,
		SDL_WINDOWPOS_CENTERED_DISPLAY(display_id),
		SDL_WINDOWPOS_CENTERED_DISPLAY(display_id),
		viewport_dims.x,
		viewport_dims.y,
		SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE
	);

	if (!handles.window) {
		LOG(Error) << "Error creating window: " << SDL_GetError() << "\n";
		return false;
	}

	return true;
}

bool
initContext(SDL_Handles& handles)
{
	handles.glContext = SDL_GL_CreateContext(handles.window);

	if (!handles.glContext) {
		LOG(Error) << "Error creating glContext: " << SDL_GetError() << "\n";
		return false;
	}

	if (SDL_GL_SetSwapInterval(1) != 0) {	// vsync
		LOG(Error) << "SDL Errors: " << SDL_GetError() << "\n";
		return false;
	}

	return true;
}

bool
initGlOptions()
{
	if (glewInit()) {
		LOG(Error) << "failed to initialize OpenGL\n";
		return false;
	}

	LOG(Info) << "opengl vendor: " << glGetString(GL_VENDOR) << "\n";
	LOG(Info)<< "opengl renderer: " << glGetString(GL_RENDERER) << "\n";
	LOG(Info) << "opengl version: " << glGetString(GL_VERSION) << "\n";

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_LINE_SMOOTH);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
#if 0
	// TODO: blending messes up rendering with mesa on intel graphics 4000
	glEnable(GL_BLEND);
	glBlendEquation(GL_FUNC_ADD);
	glBlendFunc(GL_ONE, GL_SRC_ALPHA);
#endif

	// TODO: glDebugMessageCallback is only availabe  from >v4.3
	//  check and warn if context doesn't support this function here
	glEnable (GL_DEBUG_OUTPUT);
	glDebugMessageCallback((GLDEBUGPROC) openglDebugCallback, 0);
	// hide VRAM debug messages
	glDebugMessageControl(GL_DONT_CARE, 33361, GL_DONT_CARE, 0, 0, GL_FALSE);

	return true;
}

void
setDefaults(render_state* rs, glm::vec2 viewport_dims)
{
	rs->viewport_dims = viewport_dims;
	rs->lights = lightsInit();
	rs->clear_col.R = CLEAR_COL_R;
	rs->clear_col.B = CLEAR_COL_B;
	rs->clear_col.G = CLEAR_COL_G;
	rs->clear_col.A = CLEAR_COL_A;
}