410 lines
13 KiB
C
410 lines
13 KiB
C
// SONIC ROBO BLAST 2
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) 2020-2023 by Sonic Team Junior.
|
|
//
|
|
// This program is free software distributed under the
|
|
// terms of the GNU General Public License, version 2.
|
|
// See the 'LICENSE' file for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file hw_batching.c
|
|
/// \brief Draw call batching and related things.
|
|
|
|
#ifdef HWRENDER
|
|
#include "hw_glob.h"
|
|
#include "hw_batching.h"
|
|
#include "hw_main.h"
|
|
#include "../i_system.h"
|
|
|
|
typedef struct
|
|
{
|
|
FSurfaceInfo surf; // surf also has its own polyflags for some reason, but it seems unused
|
|
unsigned int vertsIndex; // location of verts in unsortedVertices
|
|
FUINT numVerts;
|
|
FBITFIELD polyFlags;
|
|
GLMipmap_t *texture;
|
|
int shader;
|
|
// this tells batching that the plane belongs to a horizon line and must be drawn in correct order with the skywalls
|
|
boolean horizonSpecial;
|
|
INT32 hash;
|
|
} DrawCallInfo;
|
|
|
|
// The texture for the next polygon given to HWR_ProcessPolygon.
|
|
// Set with HWR_SetCurrentTexture.
|
|
GLMipmap_t *current_texture = NULL;
|
|
|
|
boolean currently_batching = false;
|
|
|
|
// Dynamic arrays for:
|
|
// - unsorted draw calls
|
|
// - sorted order of draw calls
|
|
// - unsorted vertices
|
|
// - final (sorted) vertices
|
|
// - vertex indices for sorted vertices
|
|
|
|
// contains the draw calls from DrawPolygon, waiting to be processed
|
|
DrawCallInfo* drawCalls = NULL;
|
|
int drawCallsSize = 0;
|
|
int drawCallsCapacity = 65536;
|
|
|
|
// contains sorted order (array indices) for drawCalls
|
|
// (therefore size and capacity shared with it)
|
|
UINT32* drawCallOrder = NULL;
|
|
|
|
// contains unsorted vertices and texture coordinates from DrawPolygon
|
|
FOutVector* unsortedVertices = NULL;
|
|
int unsortedVerticesSize = 0;
|
|
int unsortedVerticesCapacity = 65536;
|
|
|
|
// contains subset of sorted vertices and texture coordinates to be sent to gpu
|
|
FOutVector* finalVertices = NULL;
|
|
int finalVerticesSize = 0;
|
|
int finalVerticesCapacity = 65536;
|
|
|
|
// contains vertex indices into finalVertices for glDrawElements,
|
|
// taking into account fan->triangles conversion
|
|
UINT32* finalIndices = NULL; // this is alloced with 3x finalVertices size
|
|
int finalIndicesSize = 0;
|
|
|
|
// Enables batching mode. HWR_ProcessPolygon will collect polygons instead of passing them directly to the rendering backend.
|
|
// Call HWR_RenderBatches to render all the collected geometry.
|
|
void HWR_StartBatching(void)
|
|
{
|
|
if (currently_batching)
|
|
I_Error("Repeat call to HWR_StartBatching without HWR_RenderBatches");
|
|
|
|
// init arrays if that has not been done yet
|
|
if (!finalVertices)
|
|
{
|
|
finalVertices = malloc(finalVerticesCapacity * sizeof(FOutVector));
|
|
finalIndices = malloc(finalVerticesCapacity * 3 * sizeof(UINT32));
|
|
drawCalls = malloc(drawCallsCapacity * sizeof(DrawCallInfo));
|
|
drawCallOrder = malloc(drawCallsCapacity * sizeof(UINT32));
|
|
unsortedVertices = malloc(unsortedVerticesCapacity * sizeof(FOutVector));
|
|
}
|
|
|
|
currently_batching = true;
|
|
}
|
|
|
|
// This replaces the direct calls to pfnSetTexture in cases where batching is available.
|
|
// The texture selection is saved for the next HWR_ProcessPolygon call.
|
|
// Doing this was easier than getting a texture pointer to HWR_ProcessPolygon.
|
|
void HWR_SetCurrentTexture(GLMipmap_t *texture)
|
|
{
|
|
if (currently_batching)
|
|
current_texture = texture;
|
|
else
|
|
HWD.pfnSetTexture(texture);
|
|
}
|
|
|
|
static void HWR_CollectDrawCallInfo(FSurfaceInfo *pSurf, FUINT iNumPts, FBITFIELD PolyFlags, int shader_target, boolean horizonSpecial)
|
|
{
|
|
// make sure dynamic array has capacity
|
|
if (drawCallsSize == drawCallsCapacity)
|
|
{
|
|
DrawCallInfo* new_array;
|
|
// ran out of space, make new array double the size
|
|
drawCallsCapacity *= 2;
|
|
new_array = malloc(drawCallsCapacity * sizeof(DrawCallInfo));
|
|
memcpy(new_array, drawCalls, drawCallsSize * sizeof(DrawCallInfo));
|
|
free(drawCalls);
|
|
drawCalls = new_array;
|
|
// also need to redo the index array, dont need to copy it though
|
|
free(drawCallOrder);
|
|
drawCallOrder = malloc(drawCallsCapacity * sizeof(UINT32));
|
|
}
|
|
// add entry to array
|
|
drawCalls[drawCallsSize].surf = *pSurf;
|
|
drawCalls[drawCallsSize].vertsIndex = unsortedVerticesSize;
|
|
drawCalls[drawCallsSize].numVerts = iNumPts;
|
|
drawCalls[drawCallsSize].polyFlags = PolyFlags;
|
|
drawCalls[drawCallsSize].texture = current_texture;
|
|
drawCalls[drawCallsSize].shader = (shader_target != -1) ? HWR_GetShaderFromTarget(shader_target) : shader_target;
|
|
drawCalls[drawCallsSize].horizonSpecial = horizonSpecial;
|
|
drawCalls[drawCallsSize].hash = drawCallsSize;
|
|
drawCallsSize++;
|
|
|
|
if (!(PolyFlags & PF_NoTexture) && !horizonSpecial)
|
|
{
|
|
// use FNV-1a to hash polygons for later sorting.
|
|
INT32 hash = 0x811c9dc5;
|
|
#define DIGEST(h, x) h ^= (x); h *= 0x01000193
|
|
if (current_texture)
|
|
{
|
|
DIGEST(hash, current_texture->downloaded);
|
|
}
|
|
DIGEST(hash, PolyFlags);
|
|
DIGEST(hash, pSurf->PolyColor.rgba);
|
|
if (cv_grshaders.value && gr_shadersavailable)
|
|
{
|
|
DIGEST(hash, shader_target);
|
|
DIGEST(hash, pSurf->TintColor.rgba);
|
|
DIGEST(hash, pSurf->FadeColor.rgba);
|
|
DIGEST(hash, pSurf->LightInfo.light_level);
|
|
DIGEST(hash, pSurf->LightInfo.fade_start);
|
|
DIGEST(hash, pSurf->LightInfo.fade_end);
|
|
}
|
|
#undef DIGEST
|
|
// remove the sign bit to ensure that skybox and horizon line comes first.
|
|
drawCalls[drawCallsSize-1].hash = (hash & INT32_MAX);
|
|
}
|
|
}
|
|
|
|
static void HWR_CollectDrawCallVertices(FOutVector *pOutVerts, FUINT iNumPts)
|
|
{
|
|
// make sure dynamic array has capacity
|
|
while (unsortedVerticesSize + (int)iNumPts > unsortedVerticesCapacity)
|
|
{
|
|
FOutVector* new_array;
|
|
// need more space for vertices in unsortedVertices
|
|
unsortedVerticesCapacity *= 2;
|
|
new_array = malloc(unsortedVerticesCapacity * sizeof(FOutVector));
|
|
memcpy(new_array, unsortedVertices, unsortedVerticesSize * sizeof(FOutVector));
|
|
free(unsortedVertices);
|
|
unsortedVertices = new_array;
|
|
}
|
|
// add vertices to array
|
|
memcpy(&unsortedVertices[unsortedVerticesSize], pOutVerts, iNumPts * sizeof(FOutVector));
|
|
unsortedVerticesSize += iNumPts;
|
|
}
|
|
|
|
// If batching is enabled, this function collects the polygon data and the chosen texture
|
|
// for later use in HWR_RenderBatches. Otherwise the rendering backend is used to
|
|
// render the polygon immediately.
|
|
void HWR_ProcessPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags, int shader_target, boolean horizonSpecial)
|
|
{
|
|
if (currently_batching)
|
|
{
|
|
if (!pSurf)
|
|
{
|
|
// handling null FSurfaceInfo is not implemented
|
|
I_Error("Got a null FSurfaceInfo in batching");
|
|
}
|
|
|
|
HWR_CollectDrawCallInfo(pSurf, iNumPts, PolyFlags, shader_target, horizonSpecial);
|
|
HWR_CollectDrawCallVertices(pOutVerts, iNumPts);
|
|
}
|
|
else
|
|
{
|
|
HWD.pfnSetShader((shader_target != SHADER_NONE) ? HWR_GetShaderFromTarget(shader_target) : shader_target);
|
|
HWD.pfnDrawPolygon(pSurf, pOutVerts, iNumPts, PolyFlags);
|
|
}
|
|
}
|
|
|
|
static int compareDrawCalls(const void *p1, const void *p2)
|
|
{
|
|
UINT32 index1 = *(const UINT32*)p1;
|
|
UINT32 index2 = *(const UINT32*)p2;
|
|
DrawCallInfo* poly1 = &drawCalls[index1];
|
|
DrawCallInfo* poly2 = &drawCalls[index2];
|
|
return poly1->hash - poly2->hash;
|
|
}
|
|
|
|
static void HWR_CollectVerticesIntoBatch(DrawCallInfo *drawCall)
|
|
{
|
|
int firstVIndex;
|
|
int lastVIndex;
|
|
int numVerts = drawCall->numVerts;
|
|
// before writing, check if there is enough room
|
|
// using 'while' instead of 'if' here makes sure that there will *always* be enough room.
|
|
// probably never will this loop run more than once though
|
|
while (finalVerticesSize + numVerts > finalVerticesCapacity)
|
|
{
|
|
FOutVector* new_array;
|
|
UINT32* new_index_array;
|
|
finalVerticesCapacity *= 2;
|
|
new_array = malloc(finalVerticesCapacity * sizeof(FOutVector));
|
|
memcpy(new_array, finalVertices, finalVerticesSize * sizeof(FOutVector));
|
|
free(finalVertices);
|
|
finalVertices = new_array;
|
|
// also increase size of index array, 3x of vertex array since
|
|
// going from fans to triangles increases vertex count to 3x
|
|
new_index_array = malloc(finalVerticesCapacity * 3 * sizeof(UINT32));
|
|
memcpy(new_index_array, finalIndices, finalIndicesSize * sizeof(UINT32));
|
|
free(finalIndices);
|
|
finalIndices = new_index_array;
|
|
}
|
|
// write the vertices of the polygon
|
|
memcpy(&finalVertices[finalVerticesSize], &unsortedVertices[drawCall->vertsIndex],
|
|
numVerts * sizeof(FOutVector));
|
|
// write the indexes, pointing to the fan vertexes but in triangles format
|
|
firstVIndex = finalVerticesSize;
|
|
lastVIndex = finalVerticesSize + numVerts;
|
|
finalVerticesSize += 2;
|
|
while (finalVerticesSize < lastVIndex)
|
|
{
|
|
finalIndices[finalIndicesSize++] = firstVIndex;
|
|
finalIndices[finalIndicesSize++] = finalVerticesSize - 1;
|
|
finalIndices[finalIndicesSize++] = finalVerticesSize++;
|
|
}
|
|
}
|
|
|
|
static GLMipmap_t *HWR_GetDrawCallTexture(DrawCallInfo *dc)
|
|
{
|
|
return (dc->polyFlags & PF_NoTexture) ? NULL : dc->texture;
|
|
}
|
|
|
|
// flags returned by HWR_MarkStateChanges
|
|
#define SHADER_CHANGED 1
|
|
#define TEXTURE_CHANGED 2
|
|
#define POLYFLAGS_CHANGED 4
|
|
#define SURFACEINFO_CHANGED 8
|
|
|
|
static unsigned int HWR_MarkStateChanges(DrawCallInfo *current, DrawCallInfo *next)
|
|
{
|
|
unsigned int stateChanges = 0;
|
|
FSurfaceInfo *currentSI = ¤t->surf;
|
|
FSurfaceInfo *nextSI = &next->surf;
|
|
|
|
// check if a state change is required and flag it to stateChanges
|
|
|
|
if (current->shader != next->shader && cv_grshaders.value && gr_shadersavailable)
|
|
stateChanges |= SHADER_CHANGED;
|
|
if (HWR_GetDrawCallTexture(current) != HWR_GetDrawCallTexture(next))
|
|
stateChanges |= TEXTURE_CHANGED;
|
|
if (current->polyFlags != next->polyFlags)
|
|
stateChanges |= POLYFLAGS_CHANGED;
|
|
if (cv_grshaders.value && gr_shadersavailable)
|
|
{
|
|
if (currentSI->PolyColor.rgba != nextSI->PolyColor.rgba ||
|
|
currentSI->TintColor.rgba != nextSI->TintColor.rgba ||
|
|
currentSI->FadeColor.rgba != nextSI->FadeColor.rgba ||
|
|
currentSI->LightInfo.light_level != nextSI->LightInfo.light_level ||
|
|
currentSI->LightInfo.fade_start != nextSI->LightInfo.fade_start ||
|
|
currentSI->LightInfo.fade_end != nextSI->LightInfo.fade_end)
|
|
{
|
|
stateChanges |= SURFACEINFO_CHANGED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (currentSI->PolyColor.rgba != nextSI->PolyColor.rgba)
|
|
stateChanges |= SURFACEINFO_CHANGED;
|
|
}
|
|
|
|
return stateChanges;
|
|
}
|
|
|
|
static void HWR_ExecuteStateChanges(unsigned int stateChanges, DrawCallInfo *dc)
|
|
{
|
|
if ((stateChanges & SHADER_CHANGED) && cv_grshaders.value && gr_shadersavailable)
|
|
{
|
|
HWD.pfnSetShader(dc->shader);
|
|
ps_hw_numshaders.value.i++;
|
|
}
|
|
if (stateChanges & TEXTURE_CHANGED)
|
|
{
|
|
// for PF_NoTexture the texture is set in DrawIndexedTriangles
|
|
if (!(dc->polyFlags & PF_NoTexture))
|
|
{
|
|
// texture should be already ready for use from calls to
|
|
// SetTexture during batch collection
|
|
HWD.pfnSetTexture(dc->texture);
|
|
}
|
|
ps_hw_numtextures.value.i++;
|
|
}
|
|
// these two are just parameters to DrawIndexedTriangles
|
|
// (changes to polyflags states are tracked in r_opengl.c though)
|
|
if (stateChanges & POLYFLAGS_CHANGED)
|
|
ps_hw_numpolyflags.value.i++;
|
|
if (stateChanges & SURFACEINFO_CHANGED)
|
|
ps_hw_numcolors.value.i++;
|
|
}
|
|
|
|
|
|
static void HWR_InitBatchingStats(void)
|
|
{
|
|
ps_hw_numpolys.value.i = drawCallsSize;
|
|
ps_hw_numcalls.value.i = ps_hw_numverts.value.i
|
|
= ps_hw_numshaders.value.i = ps_hw_numtextures.value.i
|
|
= ps_hw_numpolyflags.value.i = ps_hw_numcolors.value.i = 0;
|
|
}
|
|
|
|
// This function organizes the geometry and draw calls collected by HWR_ProcessPolygon
|
|
// calls into batches and uses the rendering backend to draw them.
|
|
void HWR_RenderBatches(void)
|
|
{
|
|
int drawCallReadPos = 0; // position in drawCallOrder
|
|
int i;
|
|
|
|
if (!currently_batching)
|
|
I_Error("HWR_RenderBatches called without starting batching");
|
|
|
|
currently_batching = false; // no longer collecting batches
|
|
|
|
HWR_InitBatchingStats();
|
|
|
|
if (!drawCallsSize)
|
|
return; // nothing to draw
|
|
|
|
// init drawCallOrder
|
|
for (i = 0; i < drawCallsSize; i++)
|
|
drawCallOrder[i] = i;
|
|
|
|
// sort the draw calls
|
|
PS_START_TIMING(ps_hw_batchsorttime);
|
|
qsort(drawCallOrder, drawCallsSize, sizeof(UINT32), compareDrawCalls);
|
|
PS_STOP_TIMING(ps_hw_batchsorttime);
|
|
// sort grouping order
|
|
// 1. shader
|
|
// 2. texture
|
|
// 3. polyflags
|
|
// 4. colors + light level
|
|
// not sure about what order of the last 2 should be, or if it even matters
|
|
|
|
PS_START_TIMING(ps_hw_batchdrawtime);
|
|
|
|
// set state for first batch
|
|
HWR_ExecuteStateChanges(0xFFFF, &drawCalls[drawCallOrder[0]]);
|
|
|
|
// - iterate through draw calls
|
|
// - accumulate converted vertices and indices into finalVertices and finalIndices
|
|
// and send them as a combined draw call when a state change occurs
|
|
while (1)
|
|
{
|
|
boolean stopFlag = false;
|
|
unsigned int stateChanges = 0; // flags defined above HWR_MarkStateChanges
|
|
DrawCallInfo *currentDrawCall = &drawCalls[drawCallOrder[drawCallReadPos++]];
|
|
DrawCallInfo *nextDrawCall = NULL;
|
|
|
|
HWR_CollectVerticesIntoBatch(currentDrawCall);
|
|
|
|
if (drawCallReadPos >= drawCallsSize) // was that the last draw call?
|
|
{
|
|
stopFlag = true;
|
|
}
|
|
else
|
|
{
|
|
nextDrawCall = &drawCalls[drawCallOrder[drawCallReadPos]];
|
|
stateChanges = HWR_MarkStateChanges(currentDrawCall, nextDrawCall);
|
|
}
|
|
|
|
if (stateChanges || stopFlag)
|
|
{
|
|
// execute combined draw call
|
|
HWD.pfnDrawIndexedTriangles(¤tDrawCall->surf, finalVertices,
|
|
finalIndicesSize, currentDrawCall->polyFlags, finalIndices);
|
|
// update stats
|
|
ps_hw_numcalls.value.i++;
|
|
ps_hw_numverts.value.i += finalIndicesSize;
|
|
// reset final geometry collection arrays
|
|
finalVerticesSize = 0;
|
|
finalIndicesSize = 0;
|
|
}
|
|
else
|
|
continue;
|
|
|
|
// if we're here then either its time to stop or time to change state
|
|
if (stopFlag)
|
|
break;
|
|
else
|
|
HWR_ExecuteStateChanges(stateChanges, nextDrawCall);
|
|
}
|
|
// reset the arrays (set sizes to 0)
|
|
drawCallsSize = 0;
|
|
unsortedVerticesSize = 0;
|
|
|
|
PS_STOP_TIMING(ps_hw_batchdrawtime);
|
|
}
|
|
|
|
#endif // HWRENDER
|