drummyfish/Licar
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Change some names

Browse source
This commit is contained in:
Miloslav Ciz 2024-08-14 15:19:54 +02:00
parent 0078bbf1cd
commit 71b1230880
1 changed files with 72 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

133
renderer.h
View file

@ -33,15 +33,13 @@
struct struct
{ {
S3L_Scene scene; S3L_Scene scene;
S3L_Model3D models[9]; /**< 0: whole map model,
1, 2, 3, 4, 5, 6, 7, 8: nearest map chunks S3L_Model3D mapModel; ///< whole map model
models */ S3L_Model3D models[8];
/* TODO: separate the whole model from the array? it's confusing if it's /**< 0, 1, 2, 3, 4, 5, 6, 7: nearest map chunk models */
in the array and then doesn't get rendered? */
uint8_t loadedChunks[8]; uint8_t loadedChunks[8];
S3L_Model3D *mapModel;
S3L_Unit mapVerts[LCR_SETTING_MAX_MAP_VERTICES * 3]; S3L_Unit mapVerts[LCR_SETTING_MAX_MAP_VERTICES * 3];
S3L_Index mapTris[LCR_SETTING_MAX_MAP_TRIANGLES * 3]; S3L_Index mapTris[LCR_SETTING_MAX_MAP_TRIANGLES * 3];
@ -71,7 +69,7 @@ void LCR_pixelFunc3D(S3L_PixelInfo *pixel)
if (pixel->triangleIndex != LCR_renderer.previousTriID) if (pixel->triangleIndex != LCR_renderer.previousTriID)
{ {
const S3L_Index *t = const S3L_Index *t =
LCR_renderer.models[1 + pixel->modelIndex].triangles + LCR_renderer.models[pixel->modelIndex].triangles +
3 * pixel->triangleIndex; 3 * pixel->triangleIndex;
S3L_Unit *v[3]; S3L_Unit *v[3];
@ -174,12 +172,12 @@ void LCR_pixelFunc3D(S3L_PixelInfo *pixel)
LCR_drawPixelXYUnsafe(pixel->x,pixel->y,color); LCR_drawPixelXYUnsafe(pixel->x,pixel->y,color);
} }
S3L_Index _LCR_addMapVert(S3L_Unit x, S3L_Unit y, S3L_Unit z) S3L_Index _LCR_rendererAddMapVert(S3L_Unit x, S3L_Unit y, S3L_Unit z)
{ {
S3L_Index index = 0; S3L_Index index = 0;
S3L_Unit *verts = LCR_renderer.mapVerts; S3L_Unit *verts = LCR_renderer.mapVerts;
while (index < LCR_renderer.mapModel->vertexCount) // if exists, return index while (index < LCR_renderer.mapModel.vertexCount) // if exists, return index
{ {
if (verts[0] == x && verts[1] == y && verts[2] == z) if (verts[0] == x && verts[1] == y && verts[2] == z)
return index; return index;
@ -189,13 +187,13 @@ S3L_Index _LCR_addMapVert(S3L_Unit x, S3L_Unit y, S3L_Unit z)
} }
// if it doesn't exist, add it // if it doesn't exist, add it
if (LCR_renderer.mapModel->vertexCount < LCR_SETTING_MAX_MAP_VERTICES) if (LCR_renderer.mapModel.vertexCount < LCR_SETTING_MAX_MAP_VERTICES)
{ {
*verts = x; verts++; *verts = x; verts++;
*verts = y; verts++; *verts = y; verts++;
*verts = z; *verts = z;
LCR_renderer.mapModel->vertexCount++; LCR_renderer.mapModel.vertexCount++;
return LCR_renderer.mapModel->vertexCount - 1; return LCR_renderer.mapModel.vertexCount - 1;
} }
LCR_log("couldn't add map vertex!"); LCR_log("couldn't add map vertex!");
@ -203,25 +201,25 @@ S3L_Index _LCR_addMapVert(S3L_Unit x, S3L_Unit y, S3L_Unit z)
return 0; return 0;
} }
void _LCR_addMapTri(S3L_Index a, S3L_Index b, S3L_Index c, uint8_t mat) void _LCR_rendererAddMapTri(S3L_Index a, S3L_Index b, S3L_Index c, uint8_t mat)
{ {
if (LCR_renderer.mapModel->triangleCount < LCR_SETTING_MAX_MAP_TRIANGLES) if (LCR_renderer.mapModel.triangleCount < LCR_SETTING_MAX_MAP_TRIANGLES)
{ {
S3L_Index *t = S3L_Index *t =
&(LCR_renderer.mapTris[LCR_renderer.mapModel->triangleCount * 3]); &(LCR_renderer.mapTris[LCR_renderer.mapModel.triangleCount * 3]);
*t = a; t++; *t = a; t++;
*t = b; t++; *t = b; t++;
*t = c; *t = c;
LCR_renderer.mapTriangleData[LCR_renderer.mapModel->triangleCount] = LCR_renderer.mapTriangleData[LCR_renderer.mapModel.triangleCount] =
mat; mat;
LCR_renderer.mapModel->triangleCount++; LCR_renderer.mapModel.triangleCount++;
} }
} }
void _LCR_swapMapTris(unsigned int index1, unsigned int index2) void _LCR_rendererSwapMapTris(unsigned int index1, unsigned int index2)
{ {
uint8_t tmpMat; uint8_t tmpMat;
S3L_Index tmpIndex, S3L_Index tmpIndex,
@ -240,7 +238,7 @@ void _LCR_swapMapTris(unsigned int index1, unsigned int index2)
LCR_renderer.mapTriangleData[index2] = tmpMat; LCR_renderer.mapTriangleData[index2] = tmpMat;
} }
int _LCR_quadCoversTri(const S3L_Unit quad[8], const S3L_Unit tri[6]) int _LCR_rendererQuadCoversTri(const S3L_Unit quad[8], const S3L_Unit tri[6])
{ {
for (int i = 0; i < 3; ++i) // for each triangle point for (int i = 0; i < 3; ++i) // for each triangle point
{ {
@ -284,7 +282,7 @@ int _LCR_quadCoversTri(const S3L_Unit quad[8], const S3L_Unit tri[6])
other, in return values lowest bit means whether t1 is covered and the second other, in return values lowest bit means whether t1 is covered and the second
lowest bit means whether t2 is covered. lowest bit means whether t2 is covered.
*/ */
uint8_t _LCR_checkMapTriCover(const S3L_Index *t1, uint8_t _LCR_rendererCheckMapTriCover(const S3L_Index *t1,
const S3L_Index *t2) const S3L_Index *t2)
{ {
if ((t1[0] == t2[0] || t1[0] == t2[1] || t1[0] == t2[2]) && if ((t1[0] == t2[0] || t1[0] == t2[1] || t1[0] == t2[2]) &&
@ -338,7 +336,7 @@ uint8_t _LCR_checkMapTriCover(const S3L_Index *t1,
points2D[13] = (4 * points2D[7] + 3 * points2D[9] + points2D[11]) / 8; points2D[13] = (4 * points2D[7] + 3 * points2D[9] + points2D[11]) / 8;
// first: does the triangle alone cover the other one? // first: does the triangle alone cover the other one?
if (_LCR_quadCoversTri(points2D + 6,points2D)) if (_LCR_rendererQuadCoversTri(points2D + 6,points2D))
result |= 1 << j; result |= 1 << j;
else else
{ {
@ -346,7 +344,7 @@ uint8_t _LCR_checkMapTriCover(const S3L_Index *t1,
S3L_Index *t3 = LCR_renderer.mapTris; S3L_Index *t3 = LCR_renderer.mapTris;
for (int i = 0; i < LCR_renderer.mapModel->triangleCount; ++i) for (int i = 0; i < LCR_renderer.mapModel.triangleCount; ++i)
{ {
uint8_t sharedVerts = uint8_t sharedVerts =
(t3[0] == t2[0] || t3[0] == t2[1] || t3[0] == t2[2]) | (t3[0] == t2[0] || t3[0] == t2[1] || t3[0] == t2[2]) |
@ -372,7 +370,7 @@ uint8_t _LCR_checkMapTriCover(const S3L_Index *t1,
points2D[12] = LCR_renderer.mapVerts[3 * t3[freeVert] + coordX]; points2D[12] = LCR_renderer.mapVerts[3 * t3[freeVert] + coordX];
points2D[13] = LCR_renderer.mapVerts[3 * t3[freeVert] + coordY]; points2D[13] = LCR_renderer.mapVerts[3 * t3[freeVert] + coordY];
if (_LCR_quadCoversTri(points2D + 6,points2D)) if (_LCR_rendererQuadCoversTri(points2D + 6,points2D))
{ {
result |= 1 << j; result |= 1 << j;
break; break;
@ -419,24 +417,24 @@ void _LCR_cullHiddenMapTris(void)
We'll be moving the covered triangles to the end of the array, then at the We'll be moving the covered triangles to the end of the array, then at the
end we'll just shorten the array by number of removed triangles. end we'll just shorten the array by number of removed triangles.
*/ */
while (i < LCR_renderer.mapModel->triangleCount - n) while (i < LCR_renderer.mapModel.triangleCount - n)
{ {
t2 = t1 + 3; // t2 is the the other triangle against which we check t2 = t1 + 3; // t2 is the the other triangle against which we check
int t1Covered = 0; int t1Covered = 0;
for (int j = i + 1; j < LCR_renderer.mapModel->triangleCount; ++j) for (int j = i + 1; j < LCR_renderer.mapModel.triangleCount; ++j)
{ {
uint8_t cover = _LCR_checkMapTriCover(t1,t2); uint8_t cover = _LCR_rendererCheckMapTriCover(t1,t2);
t1Covered |= cover & 0x01; t1Covered |= cover & 0x01;
if (cover & 0x02) if (cover & 0x02)
{ {
if (j < LCR_renderer.mapModel->triangleCount - n) if (j < LCR_renderer.mapModel.triangleCount - n)
{ {
_LCR_swapMapTris(j, _LCR_rendererSwapMapTris(j,
LCR_renderer.mapModel->triangleCount - 1 - n); LCR_renderer.mapModel.triangleCount - 1 - n);
n++; n++;
} }
@ -447,8 +445,8 @@ void _LCR_cullHiddenMapTris(void)
if (t1Covered) if (t1Covered)
{ {
_LCR_swapMapTris(i, _LCR_rendererSwapMapTris(i,
LCR_renderer.mapModel->triangleCount - 1 - n); LCR_renderer.mapModel.triangleCount - 1 - n);
n++; n++;
// we stay at this position because we've swapped the triangle here // we stay at this position because we've swapped the triangle here
@ -460,17 +458,17 @@ void _LCR_cullHiddenMapTris(void)
} }
} }
LCR_renderer.mapModel->triangleCount -= n; // cut off the removed triangles LCR_renderer.mapModel.triangleCount -= n; // cut off the removed triangles
// remove unused vertices: // remove unused vertices:
i = 0; i = 0;
while (i < LCR_renderer.mapModel->vertexCount) while (i < LCR_renderer.mapModel.vertexCount)
{ {
int used = 0; int used = 0;
for (int j = 0; j < LCR_renderer.mapModel->triangleCount * 3; ++j) for (int j = 0; j < LCR_renderer.mapModel.triangleCount * 3; ++j)
if (LCR_renderer.mapTris[j] == i) if (LCR_renderer.mapTris[j] == i)
{ {
used = 1; used = 1;
@ -483,13 +481,13 @@ void _LCR_cullHiddenMapTris(void)
{ {
for (int j = 0; j < 3; ++j) for (int j = 0; j < 3; ++j)
LCR_renderer.mapVerts[3 * i + j] = LCR_renderer.mapVerts[3 * i + j] =
LCR_renderer.mapVerts[(LCR_renderer.mapModel->vertexCount - 1) * 3 + j]; LCR_renderer.mapVerts[(LCR_renderer.mapModel.vertexCount - 1) * 3 + j];
for (int j = 0; j < LCR_renderer.mapModel->triangleCount * 3; ++j) for (int j = 0; j < LCR_renderer.mapModel.triangleCount * 3; ++j)
if (LCR_renderer.mapTris[j] == LCR_renderer.mapModel->vertexCount - 1) if (LCR_renderer.mapTris[j] == LCR_renderer.mapModel.vertexCount - 1)
LCR_renderer.mapTris[j] = i; LCR_renderer.mapTris[j] = i;
LCR_renderer.mapModel->vertexCount--; LCR_renderer.mapModel.vertexCount--;
} }
} }
} }
@ -515,7 +513,7 @@ void _LCR_makeMapChunks(void)
chunkCorner[1] -= LCR_MAP_SIZE_BLOCKS * LCR_RENDERER_UNIT / 4; chunkCorner[1] -= LCR_MAP_SIZE_BLOCKS * LCR_RENDERER_UNIT / 4;
chunkCorner[2] -= LCR_MAP_SIZE_BLOCKS * LCR_RENDERER_UNIT / 2; chunkCorner[2] -= LCR_MAP_SIZE_BLOCKS * LCR_RENDERER_UNIT / 2;
for (int i = start; i < LCR_renderer.mapModel->triangleCount; ++i) for (int i = start; i < LCR_renderer.mapModel.triangleCount; ++i)
{ {
const S3L_Unit *v = LCR_renderer.mapVerts + 3 * tri[0]; const S3L_Unit *v = LCR_renderer.mapVerts + 3 * tri[0];
@ -526,7 +524,7 @@ void _LCR_makeMapChunks(void)
v[2] >= chunkCorner[2] && v[2] >= chunkCorner[2] &&
v[2] < chunkCorner[2] + LCR_RENDERER_CHUNK_SIZE_HORIZONTAL) v[2] < chunkCorner[2] + LCR_RENDERER_CHUNK_SIZE_HORIZONTAL)
{ {
_LCR_swapMapTris(i,start); _LCR_rendererSwapMapTris(i,start);
start++; start++;
} }
@ -546,7 +544,8 @@ uint8_t _LCR_buildMapModel(void)
uint8_t blockShapeBytes[LCR_MAP_BLOCK_SHAPE_MAX_BYTES]; uint8_t blockShapeBytes[LCR_MAP_BLOCK_SHAPE_MAX_BYTES];
uint8_t blockShapeByteCount; uint8_t blockShapeByteCount;
S3L_model3DInit(LCR_renderer.mapVerts,0,LCR_renderer.mapTris,0,LCR_renderer.mapModel); S3L_model3DInit(LCR_renderer.mapVerts,0,LCR_renderer.mapTris,0,
&LCR_renderer.mapModel);
for (int j = 0; j < LCR_currentMap.blockCount; ++j) for (int j = 0; j < LCR_currentMap.blockCount; ++j)
{ {
@ -584,7 +583,7 @@ uint8_t _LCR_buildMapModel(void)
((vx == 0) << 2) | ((vx == LCR_BLOCK_SHAPE_COORD_MAX) << 3) | ((vx == 0) << 2) | ((vx == LCR_BLOCK_SHAPE_COORD_MAX) << 3) |
((vz == 0) << 4) | ((vz == LCR_BLOCK_SHAPE_COORD_MAX) << 5); ((vz == 0) << 4) | ((vz == LCR_BLOCK_SHAPE_COORD_MAX) << 5);
triIndices[vi] = _LCR_addMapVert( triIndices[vi] = _LCR_rendererAddMapVert(
originOffset + (((S3L_Unit) bx) * LCR_RENDERER_UNIT) + originOffset + (((S3L_Unit) bx) * LCR_RENDERER_UNIT) +
(LCR_RENDERER_UNIT * ((S3L_Unit) vx)) / LCR_BLOCK_SHAPE_COORD_MAX, (LCR_RENDERER_UNIT * ((S3L_Unit) vx)) / LCR_BLOCK_SHAPE_COORD_MAX,
(originOffset + (((S3L_Unit) by) * LCR_RENDERER_UNIT)) / 2 + (originOffset + (((S3L_Unit) by) * LCR_RENDERER_UNIT)) / 2 +
@ -647,7 +646,7 @@ uint8_t _LCR_buildMapModel(void)
} }
} }
_LCR_addMapTri(triIndices[0],triIndices[1],triIndices[2],triData); _LCR_rendererAddMapTri(triIndices[0],triIndices[1],triIndices[2],triData);
} }
vi = 0; vi = 0;
@ -664,7 +663,7 @@ uint8_t _LCR_buildMapModel(void)
return 1; return 1;
} }
void _LCR_computeLOD(void) void _LCR_rendererComputeLOD(void)
{ {
LCR_log("computing LOD"); LCR_log("computing LOD");
@ -689,17 +688,15 @@ uint8_t LCR_rendererInit(void)
{ {
LCR_log("initializing renderer"); LCR_log("initializing renderer");
LCR_renderer.mapModel = LCR_renderer.models;
if (!_LCR_buildMapModel()) if (!_LCR_buildMapModel())
return 0; return 0;
_LCR_makeMapChunks(); _LCR_makeMapChunks();
_LCR_computeLOD(); _LCR_rendererComputeLOD();
S3L_sceneInit( S3L_sceneInit(
LCR_renderer.models + 1,8,&LCR_renderer.scene); LCR_renderer.models,8,&LCR_renderer.scene);
return 1; return 1;
} }
@ -809,7 +806,7 @@ void LCR_rendererDrawRect(int x, int y, unsigned int w, unsigned int h,
} }
} }
void _LCR_drawLODBlock(int blockX, int blockY, int blockZ, unsigned int size, void _LCR_rendererDrawLODBlock(int blockX, int blockY, int blockZ, unsigned int size,
uint16_t color) uint16_t color)
{ {
S3L_Vec4 p, r; S3L_Vec4 p, r;
@ -965,15 +962,15 @@ void LCR_rendererDrawSky(int sky, S3L_Unit offsetH, S3L_Unit offsetV)
} }
} }
void _LCR_loadMapChunk(uint8_t chunk, int8_t x, int8_t y, int8_t z) void _LCR_rendererLoadMapChunk(uint8_t chunk, int8_t x, int8_t y, int8_t z)
{ {
LCR_renderer.models[chunk + 1] = LCR_renderer.models[0]; LCR_renderer.models[chunk] = LCR_renderer.mapModel;
if (x < 0 || x >= LCR_RENDERER_CHUNK_RESOLUTION || if (x < 0 || x >= LCR_RENDERER_CHUNK_RESOLUTION ||
y < 0 || y >= LCR_RENDERER_CHUNK_RESOLUTION || y < 0 || y >= LCR_RENDERER_CHUNK_RESOLUTION ||
z < 0 || z >= LCR_RENDERER_CHUNK_RESOLUTION) z < 0 || z >= LCR_RENDERER_CHUNK_RESOLUTION)
{ {
LCR_renderer.models[chunk + 1].triangleCount = 0; LCR_renderer.models[chunk].triangleCount = 0;
LCR_renderer.loadedChunks[chunk] = 0; LCR_renderer.loadedChunks[chunk] = 0;
} }
else else
@ -984,21 +981,25 @@ void _LCR_loadMapChunk(uint8_t chunk, int8_t x, int8_t y, int8_t z)
int triCount = int triCount =
(blockNum == LCR_RENDERER_CHUNKS_TOTAL - 1 ? (blockNum == LCR_RENDERER_CHUNKS_TOTAL - 1 ?
(LCR_renderer.mapModel->triangleCount - 1) : (LCR_renderer.mapModel.triangleCount - 1) :
LCR_renderer.chunkStarts[blockNum + 1]) LCR_renderer.chunkStarts[blockNum + 1])
- LCR_renderer.chunkStarts[blockNum]; - LCR_renderer.chunkStarts[blockNum];
if (triCount < 0) if (triCount < 0)
triCount = 0; triCount = 0;
LCR_renderer.models[chunk + 1].triangles = LCR_renderer.models[chunk].triangles =
LCR_renderer.mapTris + LCR_renderer.chunkStarts[blockNum] * 3; LCR_renderer.mapTris + LCR_renderer.chunkStarts[blockNum] * 3;
LCR_renderer.models[chunk + 1].triangleCount = triCount; LCR_renderer.models[chunk].triangleCount = triCount;
} }
} }
void _LCR_loadMapChunks(void) /**
Loads the map models with 8 chunks that are nearest to a certain point
towards which camera is looking.
*/
void _LCR_rendererLoadMapChunks(void)
{ {
int8_t camChunk[3], chunkOffsets[3]; int8_t camChunk[3], chunkOffsets[3];
S3L_Vec4 cp = LCR_renderer.scene.camera.transform.translation; S3L_Vec4 cp = LCR_renderer.scene.camera.transform.translation;
@ -1029,14 +1030,18 @@ void _LCR_loadMapChunks(void)
(cf.z >= (LCR_RENDERER_CHUNK_SIZE_HORIZONTAL / 2)) ? 1 : -1; (cf.z >= (LCR_RENDERER_CHUNK_SIZE_HORIZONTAL / 2)) ? 1 : -1;
for (uint8_t i = 0; i < 8; ++i) for (uint8_t i = 0; i < 8; ++i)
_LCR_loadMapChunk(i, _LCR_rendererLoadMapChunk(i,
camChunk[0] + ((i & 0x01) ? chunkOffsets[0] : 0), camChunk[0] + ((i & 0x01) ? chunkOffsets[0] : 0),
camChunk[1] + ((i & 0x02) ? chunkOffsets[1] : 0), camChunk[1] + ((i & 0x02) ? chunkOffsets[1] : 0),
camChunk[2] + ((i & 0x04) ? chunkOffsets[2] : 0)); camChunk[2] + ((i & 0x04) ? chunkOffsets[2] : 0));
} }
/**
Draws the LOD overlay.
*/
void LCR_rendererDrawLOD(void) void LCR_rendererDrawLOD(void)
{ {
#if LCR_SETTING_LOD_DISTANCE < 64
for (unsigned int i = 0; i < LCR_RENDERER_LOD_BLOCKS; ++i) for (unsigned int i = 0; i < LCR_RENDERER_LOD_BLOCKS; ++i)
if (LCR_renderer.gridLOD[i]) if (LCR_renderer.gridLOD[i])
{ {
@ -1046,18 +1051,24 @@ void LCR_rendererDrawLOD(void)
bz = (i / 8) * 8 + 4; bz = (i / 8) * 8 + 4;
by = (i % 8) * 8 + 4; by = (i % 8) * 8 + 4;
int var = 0;
for (unsigned int j = 0; j < 8; ++j) for (unsigned int j = 0; j < 8; ++j)
{ {
if (byte & 0x01) if (byte & 0x01)
{ {
var = var < 2 ? var + 1 : 0;
bx = j * 8 + 4; bx = j * 8 + 4;
_LCR_drawLODBlock(bx,by,bz,(LCR_EFFECTIVE_RESOLUTION_X * 3) / 2,
LCR_SETTING_LOD_COLOR); _LCR_rendererDrawLODBlock(bx,by,bz,
} // TODO: this ^ (LCR_EFFECTIVE_RESOLUTION_X * (2 + var)) / 2,
LCR_SETTING_LOD_COLOR | (0x4108 >> var));
}
byte >>= 1; byte >>= 1;
} }
} }
#endif
} }
void LCR_rendererDraw(void) void LCR_rendererDraw(void)
@ -1065,7 +1076,7 @@ void LCR_rendererDraw(void)
LCR_renderer.previousTriID = -1; LCR_renderer.previousTriID = -1;
S3L_newFrame(); S3L_newFrame();
_LCR_loadMapChunks(); _LCR_rendererLoadMapChunks(); // TODO: call only once in a while?
LCR_rendererDrawSky(2, LCR_rendererDrawSky(2,
LCR_renderer.scene.camera.transform.rotation.y, LCR_renderer.scene.camera.transform.rotation.y,