Dengine/src/Renderer.c

#include "Dengine/Renderer.h"
#include "Dengine/AssetManager.h"
#include "Dengine/Assets.h"
#include "Dengine/Debug.h"
#include "Dengine/Entity.h"
#include "Dengine/MemoryArena.h"
#include "Dengine/OpenGL.h"
#include "Dengine/Shader.h"
#include "Dengine/Texture.h"

typedef struct RenderQuad
{
	Vertex vertex[4];
} RenderQuad_;

typedef struct RenderTriangle
{
	Vertex vertex[3];
} RenderTriangle_;

INTERNAL void addVertexToRenderGroup(Renderer *renderer, Texture *tex, v4 color,
                                     Vertex *vertexList, i32 numVertexes,
                                     enum RenderMode targetRenderMode,
                                     RenderFlags flags)
{

#ifdef DENGINE_DEBUG
	ASSERT(numVertexes > 0);

	for (i32 i = 0; i < numVertexes; i++)
		debug_countIncrement(debugcount_numVertex);
#endif

	/* Find vacant/matching render group */
	RenderGroup *targetGroup = NULL;
	for (i32 i = 0; i < ARRAY_COUNT(renderer->groups); i++)
	{
		RenderGroup *group = &renderer->groups[i];
		b32 groupIsValid = FALSE;
		if (group->init)
		{
			/* If the textures match and have the same color modulation, we can
			 * add these vertices to the current group */

			b32 renderModeMatches = FALSE;
			if (group->mode == targetRenderMode) renderModeMatches = TRUE;

			b32 colorMatches = FALSE;
			if (v4_equals(group->color, color)) colorMatches = TRUE;

			b32 flagsMatches = FALSE;
			if (group->flags == flags) flagsMatches = TRUE;

			b32 texMatches = TRUE;
			if (!tex && !group->tex)
			{
				texMatches = TRUE;
			}
			else if (tex && group->tex)
			{
				if (group->tex->id == tex->id)
				{
					texMatches = TRUE;
				}
			}

			if (texMatches && colorMatches && renderModeMatches && flagsMatches)
				groupIsValid = TRUE;
		}
		else
		{
			/* New group, unused so initialise it */
			groupIsValid = TRUE;

			// NOTE(doyle): Mark first vertex as degenerate vertex
			group->vertexList[group->vertexIndex++] = vertexList[0];

			group->init  = TRUE;
			group->tex   = tex;
			group->color = color;
			group->mode  = targetRenderMode;
			group->flags = flags;

#ifdef DENGINE_DEBUG
			debug_countIncrement(debugcount_renderGroups);
#endif
		}

		if (groupIsValid)
		{
			i32 freeVertexSlots = renderer->groupCapacity - group->vertexIndex;
			if (numVertexes < freeVertexSlots)
			{
				if (i != 0)
				{
					RenderGroup tmp     = renderer->groups[0];
					renderer->groups[0] = renderer->groups[i];
					renderer->groups[i] = tmp;
				}
				targetGroup = &renderer->groups[0];
				break;
			}
		}
	}

	/* Valid group, add to the render group for rendering */
	if (targetGroup)
	{
		for (i32 i = 0; i < numVertexes; i++)
		{
			targetGroup->vertexList[targetGroup->vertexIndex++] = vertexList[i];
		}
	}
	else
	{
		// TODO(doyle): Log no remaining render groups
		DEBUG_LOG(
		    "WARNING: All render groups used up, some items will not be "
		    "rendered!");

		printf(
		    "WARNING: All render groups used up, some items will not be "
		    "rendered!\n");
	}
}

INTERNAL inline void flipTexCoord(v4 *texCoords, b32 flipX, b32 flipY)
{
	if (flipX)
	{
		v4 tmp       = *texCoords;
		texCoords->x = tmp.z;
		texCoords->z = tmp.x;
	}

	if (flipY)
	{
		v4 tmp       = *texCoords;
		texCoords->y = tmp.w;
		texCoords->w = tmp.y;
	}
}

INTERNAL void bufferRenderGroupToGL(Renderer *renderer, RenderGroup *group)
{
	Vertex *vertexList = group->vertexList;
	i32 numVertex = group->vertexIndex;

	// TODO(doyle): We assume that vbo and vao are assigned
	renderer->numVertexesInVbo = numVertex;
	glBindBuffer(GL_ARRAY_BUFFER, renderer->vbo[group->mode]);
	glBufferData(GL_ARRAY_BUFFER, numVertex * sizeof(Vertex), vertexList,
	             GL_STREAM_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}

INTERNAL void applyRotationToVertexes(v2 pos, v2 pivotPoint, Radians rotate,
                                      Vertex *vertexList, i32 vertexListSize)
{
	if (rotate == 0) return;
	// NOTE(doyle): Move the world origin to the base position of the object.
	// Then move the origin to the pivot point (e.g. center of object) and
	// rotate from that point.
	v2 pointOfRotation = v2_add(pivotPoint, pos);

	mat4 rotateMat = mat4_translate(pointOfRotation.x, pointOfRotation.y, 0.0f);
	rotateMat      = mat4_mul(rotateMat, mat4_rotate(rotate, 0.0f, 0.0f, 1.0f));
	rotateMat      = mat4_mul(rotateMat, mat4_translate(-pointOfRotation.x,
	                                               -pointOfRotation.y, 0.0f));
	for (i32 i = 0; i < vertexListSize; i++)
	{
		// NOTE(doyle): Manual matrix multiplication since vertex pos is 2D and
		// matrix is 4D
		v2 oldP = vertexList[i].pos;
		v2 newP = {0};

		newP.x = (oldP.x * rotateMat.e[0][0]) + (oldP.y * rotateMat.e[1][0]) +
		         (rotateMat.e[3][0]);
		newP.y = (oldP.x * rotateMat.e[0][1]) + (oldP.y * rotateMat.e[1][1]) +
		         (rotateMat.e[3][1]);

		vertexList[i].pos = newP;
	}
}

INTERNAL v4 getTexRectNormaliseDeviceCoords(RenderTex renderTex)
{
	/* Convert texture coordinates to normalised texture coordinates */
	v4 result = renderTex.texRect;
	if (renderTex.tex)
	{
		v2 texNdcFactor =
		    V2(1.0f / renderTex.tex->width, 1.0f / renderTex.tex->height);
		result.e[0] *= texNdcFactor.w;
		result.e[1] *= texNdcFactor.h;
		result.e[2] *= texNdcFactor.w;
		result.e[3] *= texNdcFactor.h;
	}

	return result;

}

INTERNAL RenderQuad_ createRenderQuad(Renderer *renderer, v2 pos, v2 size,
                                      v2 pivotPoint, Radians rotate,
                                      RenderTex renderTex)
{
	/*
	 * Rendering order
	 *
	 * 0   2
	 * +---+
	 * +  /+
	 * + / +
	 * +/  +
	 * +---+
	 * 1   3
	 *
	 */

	v4 vertexPair       = {0};
	vertexPair.vec2[0]  = pos;
	vertexPair.vec2[1]  = v2_add(pos, size);
	v4 texRectNdc = getTexRectNormaliseDeviceCoords(renderTex);

	// NOTE(doyle): Create a quad composed of 4 vertexes to be rendered as
	// a triangle strip using vertices v0, v1, v2, then v2, v1, v3 (note the
	// order)
	RenderQuad_ result = {0};
	result.vertex[0].pos      = V2(vertexPair.x, vertexPair.w); // Top left
	result.vertex[0].texCoord = V2(texRectNdc.x, texRectNdc.w);

	result.vertex[1].pos      = V2(vertexPair.x, vertexPair.y); // Bottom left
	result.vertex[1].texCoord = V2(texRectNdc.x, texRectNdc.y);

	result.vertex[2].pos      = V2(vertexPair.z, vertexPair.w); // Top right
	result.vertex[2].texCoord = V2(texRectNdc.z, texRectNdc.w);

	result.vertex[3].pos      = V2(vertexPair.z, vertexPair.y); // Bottom right
	result.vertex[3].texCoord = V2(texRectNdc.z, texRectNdc.y);

	// NOTE(doyle): Precalculate rotation on vertex positions
	// NOTE(doyle): No translation/scale matrix as we pre-calculate it from
	// entity data and work in world space until GLSL uses the projection matrix
	applyRotationToVertexes(pos, pivotPoint, rotate, result.vertex,
	                        ARRAY_COUNT(result.vertex));
	return result;
}

INTERNAL RenderTriangle_ createRenderTriangle(Renderer *renderer,
                                              TrianglePoints triangle,
                                              v2 pivotPoint, Radians rotate,
                                              RenderTex renderTex)
{
	/* Convert texture coordinates to normalised texture coordinates */
	v4 texRectNdc = getTexRectNormaliseDeviceCoords(renderTex);

	RenderTriangle_ result = {0};
	result.vertex[0].pos       = triangle.points[0];
	result.vertex[0].texCoord  = V2(texRectNdc.x, texRectNdc.w);

	result.vertex[1].pos       = triangle.points[1];
	result.vertex[1].texCoord  = V2(texRectNdc.x, texRectNdc.y);

	result.vertex[2].pos       = triangle.points[2];
	result.vertex[2].texCoord  = V2(texRectNdc.z, texRectNdc.w);

	applyRotationToVertexes(triangle.points[0], pivotPoint, rotate,
	                        result.vertex, ARRAY_COUNT(result.vertex));

	return result;
}

INTERNAL inline RenderQuad_
createDefaultTexQuad(Renderer *renderer, RenderTex *renderTex)
{
	RenderQuad_ result = {0};
	result = createRenderQuad(renderer, V2(0, 0), V2(0, 0), V2(0, 0),
	                          0.0f, *renderTex);
	return result;
}

INTERNAL void renderGLBufferedData(Renderer *renderer, RenderGroup *group)
{
	ASSERT(group->mode < rendermode_invalid);

	if (group->flags & renderflag_wireframe)
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	else
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	GL_CHECK_ERROR();

	if (group->flags & renderflag_no_texture)
	{
		renderer->activeShaderId =
		    renderer->shaderList[shaderlist_default_no_tex];
		shader_use(renderer->activeShaderId);
	}
	else
	{
		renderer->activeShaderId = renderer->shaderList[shaderlist_default];
		shader_use(renderer->activeShaderId);
		Texture *tex = group->tex;
		if (tex)
		{
			glActiveTexture(GL_TEXTURE0);
			glBindTexture(GL_TEXTURE_2D, tex->id);
			shader_uniformSet1i(renderer->activeShaderId, "tex", 0);
			GL_CHECK_ERROR();
		}
	}

	/* Set color modulation value */
	shader_uniformSetVec4f(renderer->activeShaderId, "spriteColor",
	                       group->color);

	glBindVertexArray(renderer->vao[group->mode]);
	glDrawArrays(GL_TRIANGLE_STRIP, 0, renderer->numVertexesInVbo);
	GL_CHECK_ERROR();
	debug_countIncrement(debugcount_drawArrays);

	/* Unbind */
	glBindVertexArray(0);
	glBindTexture(GL_TEXTURE_2D, 0);
	GL_CHECK_ERROR();

}

RenderTex renderer_createNullRenderTex(AssetManager *const assetManager)
{
	Texture *emptyTex = asset_getTex(assetManager, "nullTex");
	RenderTex result  = {emptyTex, V4(0, 1, 1, 0)};
	return result;
}

void renderer_rect(Renderer *const renderer, Rect camera, v2 pos, v2 size,
                   v2 pivotPoint, Radians rotate, RenderTex *renderTex, v4 color,
                   RenderFlags flags)
{
	// NOTE(doyle): Bottom left and top right position of quad in world space
	v2 posInCameraSpace = v2_sub(pos, camera.min);

	RenderTex emptyRenderTex = {0};
	if (!renderTex) renderTex = &emptyRenderTex;

	RenderQuad_ quad = createRenderQuad(renderer, posInCameraSpace, size,
	                                    pivotPoint, rotate, *renderTex);

	/*
	   NOTE(doyle): Entity rendering is always done in two pairs of
	   triangles, i.e. quad. To batch render quads as a triangle strip, we
	   need to create zero-area triangles which OGL will omit from
	   rendering. Render groups are initialised with 1 degenerate vertex and
	   then the first two vertexes sent to the render group are the same to
	   form 1 zero-area triangle strip.

	   A degenerate vertex has to be copied from the last vertex in the
	   rendering quad, to repeat this process as more entities are
	   renderered.

	   Alternative implementation is recognising if the rendered
	   entity is the first in its render group, then we don't need to init
	   a degenerate vertex, and only at the end of its vertex list. But on
	   subsequent renders, we need a degenerate vertex at the front to
	   create the zero-area triangle strip.

	   The first has been chosen for simplicity of code, at the cost of
	   1 degenerate vertex at the start of each render group.
	   */


		Vertex vertexList[6] = {quad.vertex[0], quad.vertex[0], quad.vertex[1],
		                        quad.vertex[2], quad.vertex[3], quad.vertex[3]};
		addVertexToRenderGroup(renderer, renderTex->tex, color, vertexList,
		                       ARRAY_COUNT(vertexList), rendermode_quad, flags);
}

void renderer_polygon(Renderer *const renderer, Rect camera,
                      v2 *polygonPoints, i32 numPoints, v2 pivotPoint,
                      Radians rotate, RenderTex *renderTex, v4 color,
                      RenderFlags flags)
{
	ASSERT(numPoints > 3);

	for (i32 i = 0; i < numPoints; i++)
		polygonPoints[i] = v2_sub(polygonPoints[i], camera.min);

	RenderTex emptyRenderTex  = {0};
	if (!renderTex) renderTex = &emptyRenderTex;

	i32 numTrisInTriangulation = numPoints - 2;
	v2 triangulationBaseP = polygonPoints[0];
	i32 triangulationIndex = 0;

	Vertex triangulationBaseVertex = {0};
	triangulationBaseVertex.pos = triangulationBaseP;

	addVertexToRenderGroup(renderer, renderTex->tex, color,
	                       &triangulationBaseVertex, 1, rendermode_polygon,
	                       flags);
	RenderTriangle_ lastRenderTriForDegeneration = {0};
	for (i32 i = 1; triangulationIndex < numTrisInTriangulation; i++)
	{
		RenderTriangle_ tri = {0};
		tri.vertex[0].pos  = triangulationBaseP;
		tri.vertex[1].pos  = polygonPoints[i + 1];
		tri.vertex[2].pos  = polygonPoints[i];

		addVertexToRenderGroup(renderer, renderTex->tex, color, tri.vertex,
		                       ARRAY_COUNT(tri.vertex), rendermode_polygon,
		                       flags);

		if (triangulationIndex++ >= numTrisInTriangulation)
		{
			lastRenderTriForDegeneration = tri;
		}
	}
	for (i32 i = 0; i < 3; i++)
	{
		addVertexToRenderGroup(renderer, renderTex->tex, color,
		                       &lastRenderTriForDegeneration.vertex[2], 1,
		                       rendermode_polygon, flags);
	}
}

void renderer_triangle(Renderer *const renderer, Rect camera,
                       TrianglePoints triangle, v2 pivotPoint, Radians rotate,
                       RenderTex *renderTex, v4 color, RenderFlags flags)
{
	TrianglePoints triangleInCamSpace = {0};
	ASSERT(ARRAY_COUNT(triangle.points) ==
	       ARRAY_COUNT(triangleInCamSpace.points));

	for (i32 i = 0; i < ARRAY_COUNT(triangleInCamSpace.points); i++)
		triangleInCamSpace.points[i] = v2_sub(triangle.points[i], camera.min);

	RenderTex emptyRenderTex = {0};
	if (!renderTex) renderTex = &emptyRenderTex;

	RenderTriangle_ renderTriangle = createRenderTriangle(
	    renderer, triangleInCamSpace, pivotPoint, rotate, *renderTex);

	// NOTE(doyle): Create degenerate vertex setup
	Vertex vertexList[5] = {renderTriangle.vertex[0], renderTriangle.vertex[0],
	                        renderTriangle.vertex[1], renderTriangle.vertex[2],
	                        renderTriangle.vertex[2]};

	addVertexToRenderGroup(renderer, renderTex->tex, color, vertexList,
	                       ARRAY_COUNT(vertexList), rendermode_triangle, flags);
}

void renderer_string(Renderer *const renderer, MemoryArena_ *arena, Rect camera,
                     Font *const font, const char *const string, v2 pos,
                     v2 pivotPoint, Radians rotate, v4 color, RenderFlags flags)
{
	i32 strLen = common_strlen(string);
	if (strLen <= 0) return;

	// TODO(doyle): Slightly incorrect string length in pixels calculation,
	// because we use the advance metric of each character for length not
	// maximum character size in rendering
	v2 rightAlignedP =
	    v2_add(pos, V2((CAST(f32) font->maxSize.w * CAST(f32) strLen),
	                   CAST(f32) font->maxSize.h));
	v2 leftAlignedP = pos;
	if (math_pointInRect(camera, leftAlignedP) ||
	    math_pointInRect(camera, rightAlignedP))
	{
		i32 vertexIndex        = 0;
		i32 numVertexPerQuad   = 4;
		i32 numVertexesToAlloc = (strLen * (numVertexPerQuad + 2));
		Vertex *vertexList =
		    memory_pushBytes(arena, numVertexesToAlloc * sizeof(Vertex));

		v2 posInCameraSpace = v2_sub(pos, camera.min);
		pos = posInCameraSpace;

		// TODO(doyle): Find why font is 1px off, might be arial font semantics
		Texture *tex = font->atlas->tex;
		f32 baseline = pos.y - font->verticalSpacing + 1;
		for (i32 i = 0; i < strLen; i++)
		{
			i32 codepoint     = string[i];
			i32 relativeIndex = CAST(i32)(codepoint - font->codepointRange.x);
			CharMetrics metric = font->charMetrics[relativeIndex];
			pos.y              = baseline - (metric.offset.y);

			/* Get texture out */
			SubTexture subTexture =
			    asset_getAtlasSubTex(font->atlas, &CAST(char)codepoint);

			v4 charTexRect      = {0};
			charTexRect.vec2[0] = subTexture.rect.min;
			charTexRect.vec2[1] =
			    v2_add(subTexture.rect.min, subTexture.rect.max);
			flipTexCoord(&charTexRect, FALSE, TRUE);

			RenderTex renderTex = {tex, charTexRect};
			RenderQuad_ quad    = createRenderQuad(renderer, pos, font->maxSize,
			                                    pivotPoint, rotate, renderTex);

			vertexList[vertexIndex++] = quad.vertex[0];
			for (i32 i = 0; i < ARRAY_COUNT(quad.vertex); i++)
			{
				vertexList[vertexIndex++] = quad.vertex[i];
			}
			vertexList[vertexIndex++] = quad.vertex[3];
			pos.x += metric.advance;
		}

		addVertexToRenderGroup(renderer, tex, color, vertexList,
		                       numVertexesToAlloc, rendermode_quad, flags);
		// TODO(doyle): Mem free
		// PLATFORM_MEM_FREE(arena, vertexList,
		//                  sizeof(Vertex) * numVertexesToAlloc);
	}
}

void renderer_entity(Renderer *renderer, MemoryArena_ *transientArena,
                     Rect camera, Entity *entity, v2 pivotPoint, Degrees rotate,
                     v4 color, RenderFlags flags)
{
	// TODO(doyle): Add early exit on entities out of camera bounds
	Radians totalRotation = DEGREES_TO_RADIANS((entity->rotation + rotate));
	RenderTex renderTex   = {0};
	if (entity->tex)
	{
		EntityAnim *entityAnim = &entity->animList[entity->animListIndex];
		v4 texRect             = {0};
		if (entityAnim->anim)
		{
			Animation *anim   = entityAnim->anim;
			char *frameName   = anim->frameList[entityAnim->currFrame];
			SubTexture subTex = asset_getAtlasSubTex(anim->atlas, frameName);

			texRect.vec2[0] = subTex.rect.min;
			texRect.vec2[1] = v2_add(subTex.rect.min, subTex.rect.max);
			flipTexCoord(&texRect, entity->flipX, entity->flipY);
		}
		else
		{
			texRect = V4(0.0f, 0.0f, (f32)entity->tex->width,
			             (f32)entity->tex->height);
		}

		if (entity->direction == direction_east)
		{
			flipTexCoord(&texRect, TRUE, FALSE);
		}

		renderTex.tex     = entity->tex;
		renderTex.texRect = texRect;
	}

	if (entity->renderMode == rendermode_quad)
	{
		renderer_rect(renderer, camera, entity->pos, entity->size, pivotPoint,
		              totalRotation, &renderTex, color, flags);
	}
	else if (entity->renderMode == rendermode_triangle)
	{
		TrianglePoints triangle = {0};

		v2 entityPWithOffset = v2_sub(entity->pos, entity->offset);
		v2 triangleTopPoint  = V2(entityPWithOffset.x + (entity->size.w * 0.5f),
		                         entityPWithOffset.y + entity->size.h);

		v2 triangleRightSide =
		    V2(entityPWithOffset.x + entity->size.w, entityPWithOffset.y);

		triangle.points[0] = entityPWithOffset;
		triangle.points[1] = triangleRightSide;
		triangle.points[2] = triangleTopPoint;

		renderer_triangle(renderer, camera, triangle, pivotPoint, totalRotation,
		                  &renderTex, color, flags);
	}
	else if (entity->renderMode == rendermode_polygon)
	{
		ASSERT(entity->numVertexPoints > 3);
		ASSERT(entity->vertexPoints);

		v2 *offsetVertexPoints = memory_pushBytes(
		    transientArena, entity->numVertexPoints * sizeof(v2));
		for (i32 i = 0; i < entity->numVertexPoints; i++)
		{
			offsetVertexPoints[i] =
			    v2_add(entity->vertexPoints[i], entity->pos);
		}

		renderer_polygon(renderer, camera, offsetVertexPoints,
		                 entity->numVertexPoints, pivotPoint, totalRotation,
		                 &renderTex, color, flags);
	}
	else
	{
		ASSERT(INVALID_CODE_PATH);
	}
}

void renderer_renderGroups(Renderer *renderer)
{
	for (i32 i = 0; i < ARRAY_COUNT(renderer->groups); i++)
	{
		RenderGroup *currGroup = &renderer->groups[i];
		if (currGroup->init)
		{
			bufferRenderGroupToGL(renderer, currGroup);
			renderGLBufferedData(renderer, currGroup);

			RenderGroup cleanGroup = {0};
			cleanGroup.vertexList = currGroup->vertexList;
			*currGroup = cleanGroup;
		}
		else
		{
			break;
		}
	}
}