763 lines
21 KiB
C
763 lines
21 KiB
C
/**
|
|
3D renderer: implements 3D rendering.
|
|
*/
|
|
|
|
#ifndef _LCR_RENDERER_H
|
|
#define _LCR_RENDERER_H
|
|
|
|
#define S3L_RESOLUTION_X LCR_SETTING_RESOLUTION_X
|
|
#define S3L_RESOLUTION_Y LCR_SETTING_RESOLUTION_Y
|
|
#define S3L_PIXEL_FUNCTION LCR_pixelFunc3D
|
|
|
|
#define S3L_PERSPECTIVE_CORRECTION 2
|
|
#define S3L_NEAR_CROSS_STRATEGY 0
|
|
|
|
#define S3L_Z_BUFFER 1
|
|
|
|
#include "small3dlib.h"
|
|
|
|
/// Renderer specific unit, length of one map square.
|
|
#define LCR_RENDERER_UNIT S3L_FRACTIONS_PER_UNIT
|
|
|
|
struct
|
|
{
|
|
S3L_Scene scene3D;
|
|
S3L_Model3D models3D[3]; // TODO
|
|
|
|
S3L_Model3D *mapModel;
|
|
S3L_Unit mapVertices[LCR_SETTING_MAX_MAP_VERTICES * 3];
|
|
S3L_Index mapTriangles[LCR_SETTING_MAX_MAP_TRIANGLES * 3];
|
|
|
|
/**
|
|
Additional data for triangles. 4 higher bits hold direction (for lighting):
|
|
0 is floor, 1 is wall, 2 is wall (90 degrees). 4 lower bits hold the
|
|
texture index.
|
|
*/
|
|
uint8_t mapTriangleData[LCR_SETTING_MAX_MAP_TRIANGLES];
|
|
|
|
// pixel function precomputed values:
|
|
int previousTriangleID;
|
|
int triangleUVs[6];
|
|
} LCR_renderer;
|
|
|
|
void LCR_pixelFunc3D(S3L_PixelInfo *pixel)
|
|
{
|
|
// once we get a new triangle, we precompute things for it:
|
|
if (pixel->triangleIndex != LCR_renderer.previousTriangleID)
|
|
{
|
|
S3L_Index *t = LCR_renderer.mapTriangles + 3 * pixel->triangleIndex;
|
|
|
|
S3L_Unit *v[3];
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
v[i] = LCR_renderer.mapVertices + 3 * t[i];
|
|
|
|
uint8_t type = LCR_renderer.mapTriangleData[pixel->triangleID] >> 4;
|
|
|
|
LCR_loadImage(LCR_renderer.mapTriangleData[pixel->triangleID] & 0x0f);
|
|
|
|
if (type == 0) // floor?
|
|
{
|
|
if (v[0][1] != v[1][1] || v[1][1] != v[2][1]) // angled floor?
|
|
LCR_imageChangeBrightness(1);
|
|
|
|
for (int i = 0; i < 6; ++i)
|
|
LCR_renderer.triangleUVs[i] = ((
|
|
(v[i / 2][(i % 2) * 2]) *
|
|
LCR_IMAGE_SIZE) / LCR_RENDERER_UNIT);
|
|
}
|
|
else
|
|
{
|
|
if (type == 1)
|
|
LCR_imageChangeBrightness(0);
|
|
|
|
for (int i = 0; i < 6; ++i)
|
|
{
|
|
LCR_renderer.triangleUVs[i] = ((
|
|
(v[i / 2][i % 2 ? 1 : (type == 1 ? 2 : 0)]) *
|
|
LCR_IMAGE_SIZE) / LCR_RENDERER_UNIT);
|
|
|
|
if (i % 2)
|
|
LCR_renderer.triangleUVs[i] = LCR_IMAGE_SIZE -
|
|
LCR_renderer.triangleUVs[i];
|
|
}
|
|
}
|
|
|
|
// shift the UVs to the origin (prevent high values of UV coords)
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
uint8_t minCoord = LCR_renderer.triangleUVs[i] <
|
|
LCR_renderer.triangleUVs[2 + i] ? (0 + i) : (2 + i);
|
|
|
|
if (LCR_renderer.triangleUVs[4 + i] < LCR_renderer.triangleUVs[minCoord])
|
|
minCoord = 4 + i;
|
|
|
|
S3L_Unit shiftBy = LCR_renderer.triangleUVs[minCoord] % LCR_IMAGE_SIZE;
|
|
|
|
if (shiftBy < 0)
|
|
shiftBy += LCR_IMAGE_SIZE;
|
|
|
|
shiftBy -= LCR_renderer.triangleUVs[minCoord];
|
|
|
|
LCR_renderer.triangleUVs[i] += shiftBy;
|
|
LCR_renderer.triangleUVs[2 + i] += shiftBy;
|
|
LCR_renderer.triangleUVs[4 + i] += shiftBy;
|
|
}
|
|
|
|
LCR_renderer.previousTriangleID = pixel->triangleIndex;
|
|
}
|
|
|
|
int barycentric[3];
|
|
|
|
barycentric[0] = pixel->barycentric[0] / 8;
|
|
barycentric[1] = pixel->barycentric[1] / 8;
|
|
barycentric[2] = pixel->barycentric[2] / 8;
|
|
|
|
uint16_t color = LCR_sampleImage(
|
|
(barycentric[0] * LCR_renderer.triangleUVs[0] +
|
|
barycentric[1] * LCR_renderer.triangleUVs[2] +
|
|
barycentric[2] * LCR_renderer.triangleUVs[4])
|
|
/ (S3L_FRACTIONS_PER_UNIT / 8),
|
|
(barycentric[0] * LCR_renderer.triangleUVs[1] +
|
|
barycentric[1] * LCR_renderer.triangleUVs[3] +
|
|
barycentric[2] * LCR_renderer.triangleUVs[5])
|
|
/ (S3L_FRACTIONS_PER_UNIT / 8)
|
|
);
|
|
|
|
LCR_drawPixelXYUnsafe(pixel->x,pixel->y,color);
|
|
}
|
|
|
|
S3L_Index _LCR_addMapVertex(S3L_Unit x, S3L_Unit y, S3L_Unit z)
|
|
{
|
|
S3L_Index index = 0;
|
|
S3L_Unit *vertices = LCR_renderer.mapVertices;
|
|
|
|
while (index < LCR_renderer.mapModel->vertexCount) // if exists, return vertex index
|
|
{
|
|
if (vertices[0] == x && vertices[1] == y && vertices[2] == z)
|
|
return index;
|
|
|
|
vertices += 3;
|
|
index++;
|
|
}
|
|
|
|
// if it doesn't exist, add it
|
|
if (LCR_renderer.mapModel->vertexCount < LCR_SETTING_MAX_MAP_VERTICES)
|
|
{
|
|
*vertices = x; vertices++;
|
|
*vertices = y; vertices++;
|
|
*vertices = z;
|
|
LCR_renderer.mapModel->vertexCount++;
|
|
return LCR_renderer.mapModel->vertexCount - 1;
|
|
}
|
|
|
|
LCR_log("couldn't add map vertex!");
|
|
|
|
return 0;
|
|
}
|
|
|
|
void _LCR_addMapTriangle(S3L_Index a, S3L_Index b, S3L_Index c, uint8_t mat)
|
|
{
|
|
if (LCR_renderer.mapModel->triangleCount < LCR_SETTING_MAX_MAP_TRIANGLES)
|
|
{
|
|
S3L_Index *t =
|
|
&(LCR_renderer.mapTriangles[LCR_renderer.mapModel->triangleCount * 3]);
|
|
|
|
*t = a; t++;
|
|
*t = b; t++;
|
|
*t = c;
|
|
|
|
LCR_renderer.mapTriangleData[LCR_renderer.mapModel->triangleCount] =
|
|
mat;
|
|
|
|
LCR_renderer.mapModel->triangleCount++;
|
|
}
|
|
}
|
|
|
|
void _LCR_rendererSwapMapTriangles(unsigned int index1, unsigned int index2)
|
|
{
|
|
uint8_t tmpMat;
|
|
S3L_Index tmpIndex,
|
|
*t1 = LCR_renderer.mapTriangles + index1 * 3,
|
|
*t2 = LCR_renderer.mapTriangles + index2 * 3;
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
tmpIndex = t1[i];
|
|
t1[i] = t2[i];
|
|
t2[i] = tmpIndex;
|
|
}
|
|
|
|
tmpMat = LCR_renderer.mapTriangleData[index1];
|
|
LCR_renderer.mapTriangleData[index1] =
|
|
LCR_renderer.mapTriangleData[index2];
|
|
LCR_renderer.mapTriangleData[index2] = tmpMat;
|
|
}
|
|
|
|
int _LCR_quadCoversTriangle(const S3L_Unit quad[8], const S3L_Unit tri[6])
|
|
{
|
|
for (int i = 0; i < 3; ++i) // for each triangle point
|
|
{
|
|
int covered = 0;
|
|
|
|
for (int j = 0; j < 3; ++j) // for each quad subtriangle
|
|
{
|
|
uint8_t winds = 0;
|
|
|
|
for (int k = 0; k < 3; ++k) // for each subtriangle side
|
|
{
|
|
S3L_Unit w = // triangle winding
|
|
(quad[(2 * (j + ((k + 1) % 3))) % 8 + 1] -
|
|
quad[(2 * (j + k)) % 8 + 1]) *
|
|
(tri[2 * i] - quad[(2 * (j + (k + 1) % 3)) % 8]) -
|
|
(quad[(2 * (j + ((k + 1) % 3))) % 8] - quad[(2 * (j + k)) % 8])
|
|
* (tri[2 * i + 1] - quad[(2 * (j + (k + 1) % 3)) % 8 + 1]);
|
|
|
|
if (w > 0)
|
|
winds |= 1;
|
|
else if (w < 0)
|
|
winds |= 2;
|
|
}
|
|
|
|
if (winds != 3) // no opposite winds?
|
|
{
|
|
covered = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!covered)
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
Checks whether two triangles (and potenrially their neighbors) cover each
|
|
other, in return values lowest bit means whether t1 is covered and the second
|
|
lowest bit means whether t2 is covered.
|
|
*/
|
|
uint8_t _LCR_rendererCheckMapTriangleCover(const S3L_Index *t1,
|
|
const S3L_Index *t2)
|
|
{
|
|
if ((t1[0] == t2[0] || t1[0] == t2[1] || t1[0] == t2[2]) &&
|
|
(t1[1] == t2[0] || t1[1] == t2[1] || t1[1] == t2[2]) &&
|
|
(t1[2] == t2[0] || t1[2] == t2[1] || t1[2] == t2[2]))
|
|
return 0x03;
|
|
|
|
uint8_t result = 0;
|
|
int plane = -1;
|
|
S3L_Unit *vertices[6];
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
vertices[i] = LCR_renderer.mapVertices + 3 * t1[i];
|
|
vertices[3 + i] = LCR_renderer.mapVertices + 3 * t2[i];
|
|
}
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
if (vertices[0][i] == vertices[1][i] && vertices[1][i] == vertices[2][i] &&
|
|
vertices[2][i] == vertices[3][i] && vertices[3][i] == vertices[4][i] &&
|
|
vertices[4][i] == vertices[5][i])
|
|
{
|
|
plane = i;
|
|
break;
|
|
}
|
|
|
|
if (plane >= 0) // both triangles in the same plane => then do more checks
|
|
{
|
|
for (int j = 0; j < 2; ++j)
|
|
{
|
|
S3L_Unit points2D[14]; // tri1, quad (tri2 + 1 extra vert)
|
|
|
|
int coordX = plane == 0 ? 1 : 0,
|
|
coordY = plane == 2 ? 1 : 2;
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
points2D[i * 2] = vertices[i][coordX];
|
|
points2D[i * 2 + 1] = vertices[i][coordY];
|
|
points2D[6 + i * 2] = vertices[3 + i][coordX];
|
|
points2D[6 + i * 2 + 1] = vertices[3 + i][coordY];
|
|
}
|
|
|
|
points2D[12] = (4 * points2D[6] + 3 * points2D[8] + points2D[10]) / 8;
|
|
points2D[13] = (4 * points2D[7] + 3 * points2D[9] + points2D[11]) / 8;
|
|
|
|
// first: does the triangle alone cover the other one?
|
|
if (_LCR_quadCoversTriangle(points2D + 6,points2D))
|
|
result |= 1 << j;
|
|
else
|
|
{
|
|
// now check if this triangle along with a neighbor cover the other one
|
|
|
|
S3L_Index *t3 = LCR_renderer.mapTriangles;
|
|
|
|
for (int i = 0; i < LCR_renderer.mapModel->triangleCount; ++i)
|
|
{
|
|
uint8_t sharedVerts =
|
|
(t3[0] == t2[0] || t3[0] == t2[1] || t3[0] == t2[2]) |
|
|
((t3[1] == t2[0] || t3[1] == t2[1] || t3[1] == t2[2]) << 1) |
|
|
((t3[2] == t2[0] || t3[2] == t2[1] || t3[2] == t2[2]) << 2);
|
|
|
|
if (
|
|
t3 != t1 && t3 != t2 &&
|
|
(sharedVerts == 3 || sharedVerts == 5 || sharedVerts == 6) &&
|
|
LCR_renderer.mapVertices[3 * t3[0] + plane] ==
|
|
LCR_renderer.mapVertices[3 * t3[1] + plane] &&
|
|
LCR_renderer.mapVertices[3 * t3[1] + plane] ==
|
|
LCR_renderer.mapVertices[3 * t3[2] + plane] &&
|
|
LCR_renderer.mapVertices[3 * t3[0] + plane] ==
|
|
LCR_renderer.mapVertices[3 * t1[0] + plane]
|
|
)
|
|
{
|
|
// here shares exactly two vertices and is in the same plane
|
|
|
|
uint8_t freeVert =
|
|
sharedVerts == 3 ? 2 : (sharedVerts == 5 ? 1 : 0);
|
|
|
|
points2D[12] = LCR_renderer.mapVertices[3 * t3[freeVert] + coordX];
|
|
points2D[13] = LCR_renderer.mapVertices[3 * t3[freeVert] + coordY];
|
|
|
|
if (_LCR_quadCoversTriangle(points2D + 6,points2D))
|
|
{
|
|
result |= 1 << j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
t3 += 3;
|
|
}
|
|
}
|
|
|
|
// now swap both triangles and do it all again:
|
|
|
|
const S3L_Index *tmp = t1;
|
|
t1 = t2;
|
|
t2 = tmp;
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
S3L_Unit *tmpCoord = vertices[i];
|
|
vertices[i] = vertices[3 + i];
|
|
vertices[3 + i] = tmpCoord;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
Removes map triangles that are covered by other triangles (and also vertices
|
|
that by this become unused). This makes the map model smaller, faster and
|
|
prevents bleeding through due to z-bugger imprecisions.
|
|
*/
|
|
void _LCR_rendererCullHiddenMapTriangles(void)
|
|
{
|
|
LCR_log("culling invisible triangles");
|
|
|
|
int n = 0; // number of removed elements
|
|
int i = 0;
|
|
|
|
S3L_Index *t1 = LCR_renderer.mapTriangles, *t2;
|
|
|
|
/*
|
|
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.
|
|
*/
|
|
while (i < LCR_renderer.mapModel->triangleCount - n)
|
|
{
|
|
t2 = t1 + 3; // t2 is the the other triangle against which we check
|
|
|
|
int t1Covered = 0;
|
|
|
|
for (int j = i + 1; j < LCR_renderer.mapModel->triangleCount; ++j)
|
|
{
|
|
uint8_t cover = _LCR_rendererCheckMapTriangleCover(t1,t2);
|
|
|
|
t1Covered |= cover & 0x01;
|
|
|
|
if (cover & 0x02)
|
|
{
|
|
if (j < LCR_renderer.mapModel->triangleCount - n)
|
|
{
|
|
|
|
_LCR_rendererSwapMapTriangles(j,
|
|
LCR_renderer.mapModel->triangleCount - 1 - n);
|
|
|
|
n++;
|
|
}
|
|
}
|
|
|
|
t2 += 3; // check next triangle
|
|
}
|
|
|
|
if (t1Covered)
|
|
{
|
|
_LCR_rendererSwapMapTriangles(i,
|
|
LCR_renderer.mapModel->triangleCount - 1 - n);
|
|
|
|
n++;
|
|
// we stay at this position because we've swapped the triangle here
|
|
}
|
|
else
|
|
{
|
|
t1 += 3;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
LCR_renderer.mapModel->triangleCount -= n; // cut off the removed triangles
|
|
|
|
// remove unused vertices:
|
|
|
|
i = 0;
|
|
|
|
while (i < LCR_renderer.mapModel->vertexCount)
|
|
{
|
|
int used = 0;
|
|
|
|
for (int j = 0; j < LCR_renderer.mapModel->triangleCount * 3; ++j)
|
|
if (LCR_renderer.mapTriangles[j] == i)
|
|
{
|
|
used = 1;
|
|
break;
|
|
}
|
|
|
|
if (used)
|
|
i++;
|
|
else
|
|
{
|
|
for (int j = 0; j < 3; ++j)
|
|
LCR_renderer.mapVertices[3 * i + j] =
|
|
LCR_renderer.mapVertices[(LCR_renderer.mapModel->vertexCount - 1) * 3 + j];
|
|
|
|
for (int j = 0; j < LCR_renderer.mapModel->triangleCount * 3; ++j)
|
|
if (LCR_renderer.mapTriangles[j] == LCR_renderer.mapModel->vertexCount - 1)
|
|
LCR_renderer.mapTriangles[j] = i;
|
|
|
|
LCR_renderer.mapModel->vertexCount--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
Builds the internal 3D model of the currently loaded map. Returns 1 on
|
|
success, 0 otherwise (e.g. not enough space).
|
|
*/
|
|
uint8_t _LCR_rendererBuildMapModel(void)
|
|
{
|
|
LCR_log("building map model");
|
|
|
|
uint8_t blockShapeBytes[LCR_MAP_BLOCK_SHAPE_MAX_BYTES];
|
|
uint8_t blockShapeByteCount;
|
|
|
|
S3L_model3DInit(LCR_renderer.mapVertices,0,LCR_renderer.mapTriangles,0,LCR_renderer.mapModel);
|
|
|
|
for (int j = 0; j < LCR_currentMap.blockCount; ++j)
|
|
{
|
|
if ((j + 1) % LCR_SETTING_TRIANGLE_CULLING_PERIOD == 0)
|
|
_LCR_rendererCullHiddenMapTriangles();
|
|
|
|
S3L_Unit originOffset = -1 * LCR_MAP_SIZE_BLOCKS / 2 * LCR_RENDERER_UNIT;
|
|
S3L_Index triangleIndices[3];
|
|
const uint8_t *block = LCR_currentMap.blocks + j * LCR_BLOCK_SIZE;
|
|
uint8_t
|
|
blockType = block[0],
|
|
edgeBits, // bottom, top, left, right, front, bottom
|
|
bx, by, bz, // block coords
|
|
vx, vy, vz, // vertex coords
|
|
vi = 0; // vertex index (0, 1 or 2)
|
|
|
|
LCR_mapBlockGetCoords(block,&bx,&by,&bz);
|
|
|
|
LCR_mapGetBlockShape(blockType,LCR_mapBlockGetTransform(block),
|
|
blockShapeBytes,&blockShapeByteCount);
|
|
|
|
for (int i = 0; i < blockShapeByteCount; ++i)
|
|
{
|
|
if (vi == 0)
|
|
edgeBits = (by == 0) |
|
|
((by == LCR_MAP_SIZE_BLOCKS - 1) << 1) |
|
|
((bx == 0) << 2) |
|
|
((bx == LCR_MAP_SIZE_BLOCKS - 1) << 3) |
|
|
((bz == 0) << 4) |
|
|
((bz == LCR_MAP_SIZE_BLOCKS - 1) << 5);
|
|
|
|
LCR_decodeMapBlockCoords(blockShapeBytes[i],&vx,&vy,&vz);
|
|
|
|
edgeBits &= (vy == 0) | ((vy == LCR_BLOCK_SHAPE_COORD_MAX) << 1) |
|
|
((vx == 0) << 2) | ((vx == LCR_BLOCK_SHAPE_COORD_MAX) << 3) |
|
|
((vz == 0) << 4) | ((vz == LCR_BLOCK_SHAPE_COORD_MAX) << 5);
|
|
|
|
triangleIndices[vi] = _LCR_addMapVertex(
|
|
originOffset + (((S3L_Unit) bx) * LCR_RENDERER_UNIT) +
|
|
(LCR_RENDERER_UNIT * ((S3L_Unit) vx)) / LCR_BLOCK_SHAPE_COORD_MAX,
|
|
(originOffset + (((S3L_Unit) by) * LCR_RENDERER_UNIT)) / 2 +
|
|
(LCR_RENDERER_UNIT / 2 * ((S3L_Unit) vy)) / LCR_BLOCK_SHAPE_COORD_MAX,
|
|
originOffset + (((S3L_Unit) bz) * LCR_RENDERER_UNIT) +
|
|
(LCR_RENDERER_UNIT * ((S3L_Unit) vz)) / LCR_BLOCK_SHAPE_COORD_MAX);
|
|
|
|
if (vi < 2)
|
|
vi++;
|
|
else
|
|
{
|
|
// don't add triangles completely at the floor or ceiling of the map
|
|
if (!edgeBits)
|
|
{
|
|
#define VERT(n,c) LCR_renderer.mapVertices[3 * n + c]
|
|
uint8_t blockMat = LCR_mapBlockGetMaterial(block);
|
|
uint8_t triangleData =
|
|
(((VERT(triangleIndices[0],0) == VERT(triangleIndices[1],0)) &&
|
|
(VERT(triangleIndices[1],0) == VERT(triangleIndices[2],0))) << 4) |
|
|
(((VERT(triangleIndices[0],2) == VERT(triangleIndices[1],2)) &&
|
|
(VERT(triangleIndices[1],2) == VERT(triangleIndices[2],2))) << 5);
|
|
#undef VERT
|
|
|
|
if (triangleData & 0xf0) // wall?
|
|
{
|
|
triangleData |=
|
|
((blockMat == LCR_BLOCK_MATERIAL_CONCRETE) ||
|
|
(blockMat == LCR_BLOCK_MATERIAL_ICE) ||
|
|
(blockType == LCR_BLOCK_FULL_ACCEL) ||
|
|
(blockType == LCR_BLOCK_FULL_STICKER)) ?
|
|
LCR_IMAGE_WALL_CONCRETE : LCR_IMAGE_WALL_WOOD;
|
|
}
|
|
else
|
|
{ // TODO: tidy this mess?
|
|
if (blockType == LCR_BLOCK_FULL_ACCEL)
|
|
triangleData |= LCR_IMAGE_GROUND_ACCEL;
|
|
else if (blockType == LCR_BLOCK_FULL_STICKER)
|
|
triangleData |= LCR_IMAGE_GROUND_STICKER;
|
|
else
|
|
switch (blockMat)
|
|
{
|
|
case LCR_BLOCK_MATERIAL_CONCRETE:
|
|
triangleData |= LCR_IMAGE_GROUND_CONCRETE;
|
|
break;
|
|
|
|
case LCR_BLOCK_MATERIAL_GRASS:
|
|
triangleData |= LCR_IMAGE_GROUND_GRASS;
|
|
break;
|
|
|
|
case LCR_BLOCK_MATERIAL_DIRT:
|
|
triangleData |= LCR_IMAGE_GROUND_DIRT;
|
|
break;
|
|
|
|
case LCR_BLOCK_MATERIAL_ICE:
|
|
triangleData |= LCR_IMAGE_GROUND_ICE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
_LCR_addMapTriangle(
|
|
triangleIndices[0],triangleIndices[1],triangleIndices[2],
|
|
triangleData);
|
|
}
|
|
|
|
vi = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: also cull the triangles in the loop by some N steps
|
|
|
|
_LCR_rendererCullHiddenMapTriangles();
|
|
|
|
return 1;
|
|
}
|
|
|
|
uint8_t LCR_rendererInit(void)
|
|
{
|
|
LCR_log("initializing renderer");
|
|
|
|
LCR_renderer.mapModel = LCR_renderer.models3D;
|
|
|
|
if (!_LCR_rendererBuildMapModel())
|
|
return 0;
|
|
|
|
S3L_sceneInit(LCR_renderer.models3D,1,&LCR_renderer.scene3D);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void LCR_rendererMoveCamera(LCR_SpaceUnit forwRightUpOffset[3],
|
|
LCR_SpaceUnit yawPitchOffset[2])
|
|
{
|
|
S3L_Vec4 f, r, u;
|
|
|
|
S3L_rotationToDirections(LCR_renderer.scene3D.camera.transform.rotation,
|
|
S3L_FRACTIONS_PER_UNIT,&f,&r,&u);
|
|
|
|
LCR_renderer.scene3D.camera.transform.translation.x +=
|
|
((f.x * forwRightUpOffset[0] + r.x * forwRightUpOffset[1] +
|
|
u.x * forwRightUpOffset[2]) * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;
|
|
|
|
LCR_renderer.scene3D.camera.transform.translation.y +=
|
|
((f.y * forwRightUpOffset[0] + r.y * forwRightUpOffset[1] +
|
|
u.y * forwRightUpOffset[2]) * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;
|
|
|
|
LCR_renderer.scene3D.camera.transform.translation.z +=
|
|
((f.z * forwRightUpOffset[0] + r.z * forwRightUpOffset[1] +
|
|
u.z * forwRightUpOffset[2]) * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;
|
|
|
|
LCR_renderer.scene3D.camera.transform.rotation.y +=
|
|
(yawPitchOffset[0] * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;
|
|
|
|
LCR_renderer.scene3D.camera.transform.rotation.x +=
|
|
(yawPitchOffset[1] * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;
|
|
|
|
if (LCR_renderer.scene3D.camera.transform.rotation.x > S3L_FRACTIONS_PER_UNIT / 4)
|
|
LCR_renderer.scene3D.camera.transform.rotation.x = S3L_FRACTIONS_PER_UNIT / 4;
|
|
|
|
if (LCR_renderer.scene3D.camera.transform.rotation.x < -1 * S3L_FRACTIONS_PER_UNIT / 4)
|
|
LCR_renderer.scene3D.camera.transform.rotation.x = -1 * S3L_FRACTIONS_PER_UNIT / 4;
|
|
}
|
|
|
|
/**
|
|
Draws background sky, offsets are in multiples of screen dimensions
|
|
(e.g. S3L_FRACTIONS_PER_UNIT / 2 for offsetH means half the screen width).
|
|
*/
|
|
void LCR_rendererDrawSky(int sky, S3L_Unit offsetH, S3L_Unit offsetV)
|
|
{
|
|
int anchorPoint[2], y;
|
|
unsigned long pixelIndex;
|
|
unsigned int topColor, bottomColor;
|
|
|
|
sky = 8 + 4 * sky;
|
|
|
|
LCR_loadImage(sky);
|
|
topColor = LCR_sampleImage(0,0);
|
|
|
|
LCR_loadImage(sky + 3);
|
|
bottomColor = LCR_sampleImage(LCR_IMAGE_SIZE - 1,LCR_IMAGE_SIZE - 1);
|
|
|
|
anchorPoint[0] = ((LCR_EFFECTIVE_RESOLUTION_X * offsetH)
|
|
/ S3L_FRACTIONS_PER_UNIT) %
|
|
(2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE);
|
|
|
|
if (anchorPoint[0] < 0)
|
|
anchorPoint[0] += 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
|
|
|
|
anchorPoint[1] =
|
|
(LCR_EFFECTIVE_RESOLUTION_Y) / 3 - // 3: we place the center a bit more up
|
|
(LCR_EFFECTIVE_RESOLUTION_Y * offsetV) / S3L_FRACTIONS_PER_UNIT
|
|
- LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
|
|
|
|
pixelIndex = 0;
|
|
y = anchorPoint[1] < 0 ? anchorPoint[1] : 0;
|
|
|
|
while (y < anchorPoint[1] && y < LCR_EFFECTIVE_RESOLUTION_Y) // top strip
|
|
{
|
|
for (int x = 0; x < LCR_EFFECTIVE_RESOLUTION_X; ++x)
|
|
{
|
|
LCR_drawPixel(pixelIndex,topColor);
|
|
pixelIndex++;
|
|
}
|
|
|
|
y++;
|
|
}
|
|
|
|
anchorPoint[1] += 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
|
|
|
|
int linesLeft = 0;
|
|
int skyPart = 0;
|
|
|
|
while (y < anchorPoint[1] && y < LCR_EFFECTIVE_RESOLUTION_Y) // image strip
|
|
{
|
|
if (!linesLeft)
|
|
{
|
|
LCR_loadImage(sky + skyPart);
|
|
linesLeft = LCR_IMAGE_SIZE / 2;
|
|
skyPart++;
|
|
}
|
|
|
|
if (y >= 0)
|
|
{
|
|
for (int ix = 0; ix < 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
|
|
ix += LCR_SETTING_SKY_SIZE)
|
|
{
|
|
unsigned int color = LCR_getNextImagePixel();
|
|
unsigned long startIndex = pixelIndex;
|
|
|
|
for (int k = 0; k < LCR_SETTING_SKY_SIZE; ++k)
|
|
{
|
|
if (y + k >= LCR_EFFECTIVE_RESOLUTION_Y)
|
|
break;
|
|
|
|
for (int j = 0; j < LCR_SETTING_SKY_SIZE; ++j)
|
|
{
|
|
int x = anchorPoint[0] + ix + j;
|
|
|
|
if (x >= 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE)
|
|
x -= 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
|
|
|
|
while (x < LCR_EFFECTIVE_RESOLUTION_X)
|
|
{
|
|
LCR_drawPixel(startIndex + x,color);
|
|
x += 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
|
|
}
|
|
}
|
|
|
|
startIndex += LCR_EFFECTIVE_RESOLUTION_X;
|
|
}
|
|
}
|
|
|
|
pixelIndex += LCR_EFFECTIVE_RESOLUTION_X * LCR_SETTING_SKY_SIZE;
|
|
y += LCR_SETTING_SKY_SIZE;
|
|
}
|
|
else
|
|
{
|
|
for (int ix = 0; ix < 2 * LCR_IMAGE_SIZE; ++ix)
|
|
LCR_getNextImagePixel();
|
|
|
|
for (int i = 0; i < LCR_SETTING_SKY_SIZE; ++i)
|
|
{
|
|
if (y >= 0)
|
|
for (int x = 0; x < LCR_EFFECTIVE_RESOLUTION_X; ++x)
|
|
{
|
|
LCR_drawPixel(pixelIndex,topColor);
|
|
pixelIndex++;
|
|
}
|
|
|
|
y++;
|
|
}
|
|
}
|
|
|
|
linesLeft--;
|
|
}
|
|
|
|
while (y < 0) // can still be the case
|
|
y = 0;
|
|
|
|
while (y < LCR_EFFECTIVE_RESOLUTION_Y) // bottom strip
|
|
{
|
|
for (int x = 0; x < LCR_EFFECTIVE_RESOLUTION_X; ++x)
|
|
{
|
|
LCR_drawPixel(pixelIndex,bottomColor);
|
|
pixelIndex++;
|
|
}
|
|
|
|
y++;
|
|
}
|
|
}
|
|
|
|
void LCR_rendererDraw(void)
|
|
{
|
|
LCR_renderer.previousTriangleID = -1;
|
|
S3L_newFrame();
|
|
|
|
LCR_rendererDrawSky(2,
|
|
LCR_renderer.scene3D.camera.transform.rotation.y,
|
|
-4 * LCR_renderer.scene3D.camera.transform.rotation.x);
|
|
|
|
S3L_drawScene(LCR_renderer.scene3D);
|
|
}
|
|
|
|
#endif // guard
|