3dcam-headers/src/graphics.c

641 lines
40 KiB
C
Raw Normal View History

2021-11-28 19:59:05 +01:00
#include <psx.h>
#include <graphics.h>
#include <math.h>
#include <CPUMAC.H>
void updateLight(void){
RotMatrix_gte(dc_lgtangp, dc_lgtmatp);
gte_MulMatrix0(dc_lvllgtmatp, dc_lgtmatp, dc_lgtmatp);
gte_SetLightMatrix(dc_lgtmatp);
}
void enlightMesh(LEVEL * curLvl, MESH * mesh, SVECTOR * lgtang){
// Update light rotation on actor
//~ MATRIX rotlgt, rotmesh, light;
// Find rotmat from actor angle
RotMatrix_gte(&mesh->rot, dc_wrkmatp);
RotMatrix_gte(lgtang, dc_retmatp);
gte_MulMatrix0(dc_wrkmatp, dc_retmatp, dc_retmatp);
gte_MulMatrix0(curLvl->lgtmat, dc_retmatp, dc_retmatp);
gte_SetLightMatrix(dc_retmatp);
};
2021-06-23 19:25:12 +02:00
void transformMesh(CAMERA * camera, MESH * mesh){
//~ MATRIX mat;
// Find rotation matrix
RotMatrix_gte(&mesh->rot, dc_wrkmatp);
// Find translation matrix
TransMatrix(dc_wrkmatp, &mesh->pos);
// Compose matrix with cam
gte_CompMatrix(dc_camMat, dc_wrkmatp, dc_wrkmatp);
gte_SetRotMatrix(dc_wrkmatp);
gte_SetTransMatrix(dc_wrkmatp);
//~ }
2021-06-23 19:25:12 +02:00
};
void drawPoly(MESH * mesh, int atime, int * camMode, char ** nextpri, u_long * ot, char * db, DRAWENV * draw) {
long t = 0;
2021-06-23 19:25:12 +02:00
// mesh is POLY_GT3 ( triangle )
2021-07-03 11:57:06 +02:00
for (int i = 0; i < (mesh->totalVerts) && (mesh->totalVerts - i) > 2;) {
if (mesh->index[t].code == 4) {
t = drawTri(mesh, atime, camMode, nextpri, ot, db, draw, t, i);
i += 3;
}
// If mesh is quad
if (mesh->index[t].code == 8) {
t = drawQuad(mesh, atime, camMode, nextpri, ot, db, draw, t, i);
i += 4;
}
2021-06-25 17:01:35 +02:00
}
};
void set3VertexLerPos(MESH * mesh, long t){
// Find and set 3 interpolated vertex value
// TODO : Fix artifacts at meshes seams.
// TODO : Pre-calculate lerp positions at runtime (for i in nframes, do calc)
2021-06-25 17:01:35 +02:00
// Fixed point math precision
short precision = 12;
2021-09-25 19:39:49 +02:00
//~ mesh->tmesh->v[ mesh->index[ t ].order.vx ].vx = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vx].vx << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vx].vx << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vx ].vz = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vx].vz << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vx].vz << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vx ].vy = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vx].vy << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vx].vy << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ // Vertex 2
//~ mesh->tmesh->v[ mesh->index[ t ].order.vz ].vx = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vz].vx << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vz].vx << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vz ].vz = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vz].vz << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vz].vz << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vz ].vy = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vz].vy << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vz].vy << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ // Vertex 3
//~ mesh->tmesh->v[ mesh->index[ t ].order.vy ].vx = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vy].vx << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vy].vx << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vy ].vz = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vy].vz << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vy].vz << precision, mesh->currentAnim->cursor << precision)) >> precision;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vy ].vy = round(lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vy].vy << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vy].vy << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vx = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vx].vx << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vx].vx << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vz = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vx].vz << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vx].vz << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vy = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vx].vy << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vx].vy << precision, mesh->currentAnim->cursor << precision)) >> precision;
// Vertex 2
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vx = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vz].vx << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vz].vx << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vz = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vz].vz << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vz].vz << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vy = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vz].vy << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vz].vy << precision, mesh->currentAnim->cursor << precision)) >> precision;
// Vertex 3
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vx = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vy].vx << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vy].vx << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vz = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vy].vz << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vy].vz << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vy = (lerpD( mesh->currentAnim->data[mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[t].order.vy].vy << precision , mesh->currentAnim->data[(mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[t].order.vy].vy << precision, mesh->currentAnim->cursor << precision)) >> precision;
mesh->currentAnim->cursor += 24 * mesh->currentAnim->dir;
2021-06-25 17:01:35 +02:00
};
2021-10-13 11:53:23 +02:00
void set3VertexPos(MESH * mesh, long t, int atime){
// Set vertices according to anim
2021-11-28 19:59:05 +01:00
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vx = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vx ].vx;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vy = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vx ].vy;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vz = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vx ].vz;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vx = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vz ].vx;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vy = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vz ].vy;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vz = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vz ].vz;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vx = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vy ].vx;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vy = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vy ].vy;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vz = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vy ].vz;
2021-10-13 11:53:23 +02:00
}
2021-06-25 17:01:35 +02:00
void set4VertexLerPos(MESH * mesh, long t){
// Find and set 4 interpolated vertex value
2021-09-25 19:39:49 +02:00
short precision = 12;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vx = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vx ].vx << precision ,
mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vx ].vx << precision,
mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vz = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vx ].vz << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vx ].vz << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vy = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vx ].vy << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vx ].vy << precision, mesh->currentAnim->cursor << precision) >> precision;
2021-06-25 17:01:35 +02:00
// Vertex 2
2021-09-25 19:39:49 +02:00
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vx = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vz ].vx << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vz ].vx << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vz = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vz ].vz << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vz ].vz << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vy = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vz ].vy << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vz ].vy << precision, mesh->currentAnim->cursor << precision) >> precision;
2021-06-25 17:01:35 +02:00
// Vertex 3
2021-09-25 19:39:49 +02:00
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vx = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vy ].vx << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vy ].vx << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vz = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vy ].vz << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vy ].vz << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vy = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.vy ].vy << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.vy ].vy << precision, mesh->currentAnim->cursor << precision) >> precision;
2021-06-25 17:01:35 +02:00
// Vertex 4
2021-09-25 19:39:49 +02:00
mesh->tmesh->v[ mesh->index[ t ].order.pad ].vx = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.pad ].vx << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.pad ].vx << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.pad ].vz = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.pad ].vz << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.pad ].vz << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->tmesh->v[ mesh->index[ t ].order.pad ].vy = lerpD( mesh->currentAnim->data[ mesh->currentAnim->lerpCursor * mesh->currentAnim->nvert + mesh->index[ t ].order.pad ].vy << precision , mesh->currentAnim->data[ (mesh->currentAnim->lerpCursor + 1) * mesh->currentAnim->nvert + mesh->index[ t ].order.pad ].vy << precision, mesh->currentAnim->cursor << precision) >> precision;
mesh->currentAnim->cursor += 24 * mesh->currentAnim->dir;
2021-06-25 17:01:35 +02:00
}
2021-10-13 11:53:23 +02:00
void set4VertexPos(MESH * mesh, long t, int atime){
// Set vertices according to anim
2021-11-28 19:59:05 +01:00
// TODO : fix using delta animation
//~ SVECTOR x, y, z, pad;
//~ addVector2(&mesh->tmesh->v[ mesh->index[ t ].order.vx ], &mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vx ], &x );
//~ addVector2(&mesh->tmesh->v[ mesh->index[ t ].order.vz ], &mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vz ], &z );
//~ addVector2(&mesh->tmesh->v[ mesh->index[ t ].order.vy ], &mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vy ], &y );
//~ addVector2(&mesh->tmesh->v[ mesh->index[ t ].order.pad ], &mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.pad ], &pad );
//~ mesh->tmesh->v[ mesh->index[ t ].order.vx ] = x;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vz ] = z;
//~ mesh->tmesh->v[ mesh->index[ t ].order.vy ] = y;
//~ mesh->tmesh->v[ mesh->index[ t ].order.pad ] = pad;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vx = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vx ].vx;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vy = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vx ].vy;
mesh->tmesh->v[ mesh->index[ t ].order.vx ].vz = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vx ].vz;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vx = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vz ].vx;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vy = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vz ].vy;
mesh->tmesh->v[ mesh->index[ t ].order.vz ].vz = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vz ].vz;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vx = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vy ].vx;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vy = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vy ].vy;
mesh->tmesh->v[ mesh->index[ t ].order.vy ].vz = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.vy ].vz;
mesh->tmesh->v[ mesh->index[ t ].order.pad ].vx = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.pad ].vx;
mesh->tmesh->v[ mesh->index[ t ].order.pad ].vy = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.pad ].vy;
mesh->tmesh->v[ mesh->index[ t ].order.pad ].vz = mesh->currentAnim->data[ atime % mesh->currentAnim->nframes * mesh->currentAnim->nvert + mesh->index[t].order.pad ].vz;
2021-10-13 11:53:23 +02:00
}
void interpolateTri(POLY_GT3 * poly, MESH * mesh, long t){
long Flag, nclip = 0;
2021-06-25 17:01:35 +02:00
// Ping pong
//~ //if (mesh->anim->cursor > 4096 || mesh->anim->cursor < 0){
//~ // mesh->anim->dir *= -1;
//~ //}
// Find next keyframe
2021-09-25 19:39:49 +02:00
if (mesh->currentAnim->cursor > (1 << 12)) {
2021-06-25 17:01:35 +02:00
// There are still keyframes to interpolate between
2021-09-25 19:39:49 +02:00
if ( mesh->currentAnim->lerpCursor < mesh->currentAnim->nframes - 1 ) {
mesh->currentAnim->lerpCursor ++;
mesh->currentAnim->cursor = 0;
2021-06-25 17:01:35 +02:00
}
// We've reached last frame, go back to first frame
2021-09-25 19:39:49 +02:00
if ( mesh->currentAnim->lerpCursor == mesh->currentAnim->nframes - 1 ) {
mesh->currentAnim->lerpCursor = 0;
mesh->currentAnim->cursor = 0;
2021-06-25 17:01:35 +02:00
}
}
// Find and set interpolated vertex value
set3VertexLerPos(mesh, t);
};
2021-10-13 11:53:23 +02:00
void interpolateQuad(POLY_GT4 * poly4, MESH * mesh, long t){
long Flag, nclip = 0;
2021-06-25 17:01:35 +02:00
// ping pong
//~ if (mesh->anim->cursor > 4096 || mesh->anim->cursor < 0){
//~ mesh->anim->dir *= -1;
//~ }
short precision = 12;
2021-09-25 19:39:49 +02:00
//~ if ( mesh->anim->cursor > 1<<precision ) {
if ( mesh->currentAnim->cursor > (1 << 12) ) {
if ( mesh->currentAnim->lerpCursor < mesh->currentAnim->nframes - 1 ) {
mesh->currentAnim->lerpCursor ++;
mesh->currentAnim->cursor = 0;
2021-06-25 17:01:35 +02:00
}
2021-09-25 19:39:49 +02:00
if ( mesh->currentAnim->lerpCursor == mesh->currentAnim->nframes - 1 ) {
mesh->currentAnim->lerpCursor = 0;
mesh->currentAnim->cursor = 0;
2021-06-25 17:01:35 +02:00
}
}
// Find and set interpolated vertex value
set4VertexLerPos(mesh, t);
};
2021-07-29 12:04:31 +02:00
void set3Prism(POLY_GT3 * poly, MESH * mesh, DRAWENV * draw, char * db, int i, int t){
2021-06-25 17:01:35 +02:00
// Transparency effect :
// Use current DRAWENV clip as TPAGE instead of regular textures
//
// FIXME : Fixed BGs : find a way to know we're using em.
// With pre-rendered background, just set the tpage to bpp, x, y of the image in vram : 8bpp, 320, 0 by default for now
// But how do we now fixed BGs are used ?
//~ if (fixed_BGS){
//~ ( (POLY_GT3 *) poly )->tpage = getTPage( 0, 0, 320, 0 );
//~ }
2021-07-29 12:04:31 +02:00
// Use Drawenv's Tpages 0,0 and 0,256
setTPage( poly, 2, 0, 0, !(*db)<<8);
2021-08-02 14:03:41 +02:00
//~ setShadeTex(poly, 1);
2021-06-25 17:01:35 +02:00
// Use projected coordinates (results from RotAverage...) as UV coords and clamp them to 0-255,0-224 -> 240 - 16
2021-07-29 12:04:31 +02:00
// ( 256 * 4096 ) / 320 ) => 3277
// ( 240 * 4096 ) / 256 ) => 3840
setUV3( poly,
(poly->x0 * 3277) >> 12,
((poly->y0 * 3840) >> 12) - (!(*db) << 4),
(poly->x1 * 3277) >> 12,
((poly->y1 * 3840) >> 12) - (!(*db) << 4),
(poly->x2 * 3277) >> 12,
((poly->y2 * 3840) >> 12) - (!(*db) << 4)
2021-06-25 17:01:35 +02:00
);
2021-07-29 12:04:31 +02:00
// Add color tint
2021-08-02 14:03:41 +02:00
CVECTOR prismCol = {0x40,0x40,0xff,0x0};
2021-07-29 12:04:31 +02:00
// work color vectors
CVECTOR outCol, outCol1, outCol2;
// Find local color from normal and prismCol
gte_NormalColorDpq3( &mesh->tmesh->n[ mesh->index[t].order.vx ],
&mesh->tmesh->n[ mesh->index[t].order.vz ],
&mesh->tmesh->n[ mesh->index[t].order.vy ],
&prismCol,
mesh->p,
&outCol,
&outCol1,
&outCol2
);
// Set col
setRGB0(poly, outCol.r, outCol.g , outCol.b);
setRGB1(poly, outCol1.r, outCol1.g, outCol1.b);
setRGB2(poly, outCol2.r, outCol2.g, outCol2.b);
2021-06-25 17:01:35 +02:00
};
2021-07-29 12:04:31 +02:00
void set4Prism(POLY_GT4 * poly4, MESH * mesh, DRAWENV * draw, char * db, int i, int t){
// Use Drawenv's Tpages 0,0 and 0,256
setTPage( poly4, 2, 0, 0, !(*db)<<8);
2021-06-25 17:01:35 +02:00
// Use projected coordinates
setUV4( poly4,
2021-07-29 12:04:31 +02:00
(poly4->x0 * 3277) >> 12,
// Remove 16 pix offset when using tpage 0,256
((poly4->y0 * 3840) >> 12) - (!(*db) << 4),
(poly4->x1 * 3277) >> 12,
((poly4->y1 * 3840) >> 12) - (!(*db) << 4),
(poly4->x2 * 3277) >> 12,
((poly4->y2 * 3840) >> 12) - (!(*db) << 4),
(poly4->x3 * 3277) >> 12,
((poly4->y3 * 3840) >> 12) - (!(*db) << 4)
2021-06-25 17:01:35 +02:00
);
2021-07-29 12:04:31 +02:00
// Add color tint
CVECTOR prismCol = {0,70,255, 0};
// work color vectors
CVECTOR outCol, outCol1, outCol2, outCol3;
// Find local color from normal and prismCol
gte_NormalColorDpq3( &mesh->tmesh->n[ mesh->index[t].order.pad ],
&mesh->tmesh->n[ mesh->index[t].order.vz ],
&mesh->tmesh->n[ mesh->index[t].order.vx ],
&prismCol,
mesh->p,
&outCol,
&outCol1,
&outCol2
);
gte_NormalColorDpq( &mesh->tmesh->n[ mesh->index[t].order.vy ],
&prismCol,
mesh->p,
&outCol3
);
// Set col
setRGB0(poly4, outCol.r, outCol.g , outCol.b);
setRGB1(poly4, outCol1.r, outCol1.g, outCol1.b);
setRGB2(poly4, outCol2.r, outCol2.g, outCol2.b);
setRGB3(poly4, outCol3.r, outCol3.g, outCol3.b);
2021-06-25 17:01:35 +02:00
};
void set3Tex(POLY_GT3 * poly, MESH * mesh, DRAWENV * draw, long t, int i){
CVECTOR outCol = { 0,0,0,0 };
CVECTOR outCol1 = { 0,0,0,0 };
CVECTOR outCol2 = { 0,0,0,0 };
// Use regular TPAGE
2021-07-01 17:35:08 +02:00
if (mesh->tim){
( (POLY_GT3 *) poly )->tpage = getTPage(mesh->tim->mode&0x3, 0,
mesh->tim->prect->x,
mesh->tim->prect->y
);
setUV3(poly, mesh->tmesh->u[i].vx , mesh->tmesh->u[i].vy + mesh->tim->prect->y,
mesh->tmesh->u[i+2].vx, mesh->tmesh->u[i+2].vy + mesh->tim->prect->y,
mesh->tmesh->u[i+1].vx, mesh->tmesh->u[i+1].vy + mesh->tim->prect->y);
} else {
( (POLY_GT3 *) poly)->tpage = getTPage( 2,0,0,0 );
setUV3(poly, 0,0,0,0,0,0);
}
gte_NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vx ], &mesh->tmesh->c[ i+0 ], mesh->p, &outCol);
gte_NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vz ], &mesh->tmesh->c[ i+2 ], mesh->p, &outCol1);
gte_NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vy ], &mesh->tmesh->c[ i+1 ], mesh->p, &outCol2);
2021-06-25 17:01:35 +02:00
setRGB0(poly, outCol.r, outCol.g , outCol.b);
setRGB1(poly, outCol1.r, outCol1.g, outCol1.b);
setRGB2(poly, outCol2.r, outCol2.g, outCol2.b);
};
void set4Tex(POLY_GT4 * poly4, MESH * mesh, DRAWENV * draw, long t, int i){
2021-07-01 17:35:08 +02:00
CVECTOR outCol = {255,255,255,0};
CVECTOR outCol1 = {255,255,255,0};
CVECTOR outCol2 = {255,255,255,0};
CVECTOR outCol3 = {255,255,255,0};
2021-06-25 17:01:35 +02:00
// Use regular TPAGE
2021-07-01 17:35:08 +02:00
if (mesh->tim){
( (POLY_GT4 *) poly4)->tpage = getTPage(
mesh->tim->mode&0x3, 0,
mesh->tim->prect->x,
mesh->tim->prect->y
);
// Use model UV coordinates
setUV4( poly4,
mesh->tmesh->u[i+3].vx, mesh->tmesh->u[i+3].vy + mesh->tim->prect->y,
mesh->tmesh->u[i+2].vx, mesh->tmesh->u[i+2].vy + mesh->tim->prect->y,
mesh->tmesh->u[i+0].vx, mesh->tmesh->u[i+0].vy + mesh->tim->prect->y,
mesh->tmesh->u[i+1].vx, mesh->tmesh->u[i+1].vy + mesh->tim->prect->y
);
} else {
( (POLY_GT4 *) poly4)->tpage = getTPage( 2,0,0,0 );
setUV4(poly4, 0,0,0,0,0,0,0,0);
}
gte_NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.pad ] , &mesh->tmesh->c[ i+3 ], mesh->p, &outCol);
gte_NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vz ] , &mesh->tmesh->c[ i+2 ], mesh->p, &outCol1);
gte_NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vx ] , &mesh->tmesh->c[ i+0 ], mesh->p, &outCol2);
gte_NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vy ] , &mesh->tmesh->c[ i+1 ], mesh->p, &outCol3);
2021-06-25 17:01:35 +02:00
setRGB0(poly4, outCol.r, outCol.g , outCol.b);
setRGB1(poly4, outCol1.r, outCol1.g, outCol1.b);
setRGB2(poly4, outCol2.r, outCol2.g, outCol2.b);
setRGB3(poly4, outCol3.r, outCol3.g, outCol3.b);
};
int set4Subdiv(MESH * mesh, POLY_GT4 * poly4, u_long * ot, long t, int i, char ** nextpri){
//~ // FIXME : Poly subdiv
2021-06-25 17:01:35 +02:00
//~ DIVPOLYGON4 div4 = { 0 };
//~ div4.pih = SCREENXRES;
//~ div4.piv = SCREENYRES;
//~ div4.ndiv = 1;
//~ long OTc = mesh->OTz >> 4;
2021-06-25 17:01:35 +02:00
//~ FntPrint("OTC:%d", OTc);
//~ if (OTc < 4) {
//~ // if (OTc > 1) div4.ndiv = 1; else div4.ndiv = 2;
2021-06-25 17:01:35 +02:00
//~ DivideGT4(
//~ // Vertex coord
//~ mesh->tmesh->v[ mesh->index[t].order.pad ],
//~ mesh->tmesh->v[ mesh->index[t].order.vz ],
//~ mesh->tmesh->v[ mesh->index[t].order.vx ],
//~ mesh->tmesh->v[ mesh->index[t].order.vy ],
2021-06-25 17:01:35 +02:00
//~ // UV coord
//~ mesh->tmesh->u[i+3],
//~ mesh->tmesh->u[i+2],
//~ mesh->tmesh->u[i+0],
//~ mesh->tmesh->u[i+1],
//~ // Color
//~ mesh->tmesh->c[i+3],
//~ mesh->tmesh->c[i+2],
//~ mesh->tmesh->c[i+0],
//~ mesh->tmesh->c[i+1],
2021-06-25 17:01:35 +02:00
//~ // Gpu packet
//~ poly4,
//~ &ot[ mesh->OTz-4],
2021-06-25 17:01:35 +02:00
//~ &div4);
//~ // Increment primitive list pointer
//~ // *nextpri += ( (sizeof(POLY_GT4) + 3) / 4 ) * (( 1 << ( div4.ndiv )) << ( div4.ndiv ));
//~ return ( (sizeof(POLY_GT4) * 4) );
//~ // triCount = ((1<<(div4.ndiv))<<(div4.ndiv));
//~ }
//~ else if (OTc < 48) {
//~ return (sizeof( POLY_GT4 ));
2021-06-25 17:01:35 +02:00
//~ }
return 0;
2021-06-25 17:01:35 +02:00
};
long drawQuad(MESH * mesh, int atime, int * camMode, char ** nextpri, u_long * ot, char * db, DRAWENV * draw, int t, int i) {
long Flag, nclip = 0;
int subSkip = 0;
2021-06-25 17:01:35 +02:00
// If mesh is quad
POLY_GT4 * poly4;
//~ for (int i = 0; i < (mesh->tmesh->len * 4); i += 4) {
2021-06-25 17:01:35 +02:00
// if mesh is not part of BG, draw them, else, discard
if ( !(mesh->isBG) || *camMode != 2 ) {
poly4 = (POLY_GT4 *)*nextpri;
// Vertex Anim
2021-09-25 19:39:49 +02:00
if (mesh->isAnim && mesh->currentAnim){
2021-06-25 17:01:35 +02:00
// with interpolation
2021-10-13 10:51:58 +02:00
if ( mesh->currentAnim->interpolate ){
2021-10-13 11:53:23 +02:00
//~ nclip = interpolateQuad(poly4, mesh, t);
interpolateQuad(poly4, mesh, t);
2021-06-23 19:25:12 +02:00
} else {
2021-09-25 19:39:49 +02:00
// TODO : write playAnim()
2021-06-25 17:01:35 +02:00
// No interpolation, use all vertices coordinates in anim data
2021-10-13 11:53:23 +02:00
set4VertexPos(mesh, t, atime);
}
2021-10-13 11:53:23 +02:00
}
// Mesh is sprite
if (mesh->isSprite){
// Find inverse rotation matrix so that sprite always faces camera
MATRIX rot, invRot;
gte_ReadRotMatrix(&rot);
TransposeMatrix(&rot, &invRot);
//~ SetMulRotMatrix(&invRot);
gte_MulMatrix0(&rot, &invRot, &invRot);
gte_SetRotMatrix(&invRot);
2021-06-25 17:01:35 +02:00
}
2021-10-13 11:53:23 +02:00
// Apply rtp
gte_RotAverageNclip4(
&mesh->tmesh->v[ mesh->index[t].order.pad ],
&mesh->tmesh->v[ mesh->index[t].order.vz],
&mesh->tmesh->v[ mesh->index[t].order.vx ],
&mesh->tmesh->v[ mesh->index[t].order.vy ],
(long*)&poly4->x0, (long*)&poly4->x1, (long*)&poly4->x2, (long*)&poly4->x3,
&mesh->p,
&mesh->OTz,
&Flag,
&nclip
);
2021-06-25 17:01:35 +02:00
if (nclip > 0 && mesh->OTz > 0 && (mesh->p < 4096)) {
SetPolyGT4(poly4);
if (mesh->tim){
// If tim mode == 0 | 1, set CLUT coordinates
if ( (mesh->tim->mode & 0x3) < 2 ) {
setClut(poly4,
mesh->tim->crect->x,
mesh->tim->crect->y
);
}
2021-06-25 17:01:35 +02:00
}
if (mesh->isSprite){
// Turn off shading on sprite
2021-06-25 17:01:35 +02:00
SetShadeTex( poly4, 1 );
2021-06-23 19:25:12 +02:00
}
2021-06-25 17:01:35 +02:00
// Transparency effect
if (mesh->isPrism){
2021-07-29 12:04:31 +02:00
set4Prism(poly4, mesh, draw, db, i, t);
2021-06-25 17:01:35 +02:00
} else {
set4Tex(poly4, mesh, draw, t, i);
}
if ( (mesh->OTz > 0) /*&& (*mesh->OTz < OTLEN)*/ && (mesh->p < 4096) ) {
2021-10-13 11:53:23 +02:00
AddPrim( &ot[ mesh->OTz-5 ], poly4 );
2021-06-25 17:01:35 +02:00
}
*nextpri += sizeof( POLY_GT4 );
2021-06-23 19:25:12 +02:00
}
t++;
return t;
2021-06-23 19:25:12 +02:00
}
//~ }
2021-06-25 17:01:35 +02:00
};
long drawTri(MESH * mesh, int atime, int * camMode, char ** nextpri, u_long * ot, char * db, DRAWENV * draw, int t, int i) {
long Flag, nclip = 0;
2021-06-25 17:01:35 +02:00
// mesh is POLY_GT3 ( triangle )
POLY_GT3 * poly;
// len member == # vertices, but here it's # of triangle... So, for each tri * 3 vertices ...
//~ for ( int i = 0; i < (mesh->tmesh->len * 3); i += 3 ) {
2021-06-25 17:01:35 +02:00
// If mesh is not part of precalculated background, draw them, else, discard
if ( !( mesh->isBG ) || *camMode != 2) {
poly = (POLY_GT3 *)*nextpri;
// If Vertex Anim flag is set, use it
2021-09-25 19:39:49 +02:00
if (mesh->isAnim && mesh->currentAnim){
2021-06-25 17:01:35 +02:00
// If interpolation flag is set, use it
2021-10-13 10:51:58 +02:00
if(mesh->currentAnim->interpolate){
2021-10-13 11:53:23 +02:00
interpolateTri(poly, mesh, t);
2021-06-25 17:01:35 +02:00
} else {
// No interpolation
2021-10-13 11:53:23 +02:00
// Use the pre-calculated vertices coordinates from the animation data
set3VertexPos(mesh, t, atime);
}
}
// No animation
if (mesh->isSprite){
// Find inverse rotation matrix so that sprite always faces camera
//~ MATRIX rot, invRot;
// Use scratchpad dc_wrkmatp and dc_retmatp
gte_ReadRotMatrix(dc_wrkmatp);
TransposeMatrix(dc_wrkmatp, dc_retmatp);
//~ SetMulRotMatrix(&invRot);
gte_MulMatrix0(dc_wrkmatp, dc_retmatp, dc_retmatp);
gte_SetRotMatrix(dc_retmatp);
}
// Use model's regular vertex coordinates
gte_RotAverageNclip3(
&mesh->tmesh->v[ mesh->index[t].order.vx ],
&mesh->tmesh->v[ mesh->index[t].order.vz ],
&mesh->tmesh->v[ mesh->index[t].order.vy ],
( long * ) &poly->x0, ( long * ) &poly->x1, ( long * ) &poly->x2,
&mesh->p,
&mesh->OTz,
&Flag,
&nclip
2021-06-23 19:25:12 +02:00
);
2021-06-25 17:01:35 +02:00
// Do not draw invisible meshes
if ( nclip > 0 && mesh->OTz > 0 && (mesh->p < 4096) ) {
SetPolyGT3( poly );
if (mesh->tim){
// CLUT setup
// If tim mode == 0 | 1 (4bits/8bits image), set CLUT coordinates
if ( (mesh->tim->mode & 0x3 ) < 2){
setClut(poly,
mesh->tim->crect->x,
mesh->tim->crect->y);
}
if ( mesh->isSprite ) {
SetShadeTex( poly, 1 );
}
2021-06-25 17:01:35 +02:00
}
// If isPrism flag is set, use it
if ( mesh->isPrism ) {
2021-07-29 12:04:31 +02:00
set3Prism(poly, mesh, draw, db, i, t);
2021-06-25 17:01:35 +02:00
} else {
set3Tex(poly, mesh, draw, t, i);
}
if ( (mesh->OTz > 0) /*&& (*mesh->OTz < OTLEN)*/ && (mesh->p < 4096) ) {
AddPrim(&ot[ mesh->OTz-4 ], poly);
2021-06-25 17:01:35 +02:00
}
*nextpri += sizeof(POLY_GT3);
2021-06-23 19:25:12 +02:00
}
t++;
return t;
2021-06-23 19:25:12 +02:00
}
//~ }
2021-06-23 19:25:12 +02:00
};
void drawBG(CAMANGLE * camPtr, char ** nextpri, u_long * otdisc, char * db) {
// Draw BG image in two SPRT since max width == 256 px
SPRT * sprt;
DR_TPAGE * tpage;
// Left part
sprt = ( SPRT * ) *nextpri;
setSprt( sprt );
setRGB0( sprt, 128, 128, 128 );
setXY0( sprt, 0, 0 );
setWH( sprt, 256, SCREENYRES );
setUV0( sprt, 0, 0 );
setClut( sprt,
camPtr->BGtim->crect->x,
camPtr->BGtim->crect->y
);
addPrim( otdisc[ OT2LEN - 1 ], sprt );
*nextpri += sizeof( SPRT );
// Change TPAGE
tpage = (DR_TPAGE *) *nextpri;
setDrawTPage(
tpage, 0, 1,
getTPage(
camPtr->BGtim->mode & 0x3, 0,
camPtr->BGtim->prect->x,
camPtr->BGtim->prect->y
)
);
addPrim( otdisc[OT2LEN-1], tpage);
*nextpri += sizeof(DR_TPAGE);
// Right part
sprt = ( SPRT * ) *nextpri;
setSprt( sprt );
setRGB0( sprt, 128, 128, 128 );
setXY0( sprt, SCREENXRES - ( SCREENXRES - 256 ), 0 );
setWH( sprt, SCREENXRES - 256, SCREENYRES );
setUV0( sprt, 0, 0 );
setClut( sprt,
camPtr->BGtim->crect->x,
camPtr->BGtim->crect->y
);
addPrim( otdisc[ OT2LEN-1 ], sprt );
*nextpri += sizeof( SPRT );
tpage = ( DR_TPAGE * ) *nextpri;
// Change TPAGE
setDrawTPage(
tpage, 0, 1,
getTPage(
camPtr->BGtim->mode & 0x3, 0,
// X offset width depends on TIM's mode
camPtr->BGtim->prect->x + ( 64 << ( camPtr->BGtim->mode & 0x3 ) ),
camPtr->BGtim->prect->y
)
);
addPrim( otdisc[ OT2LEN-1 ], tpage );
*nextpri += sizeof( DR_TPAGE );
};
void renderScene(LEVEL * curLvl, CAMERA * camera, int * camMode, char ** nextpri, u_long * ot, u_long * otdisc, char * db, DRAWENV * draw, short curCamAngle, int atime){
if ( (*camMode == 2) && (curLvl->camPtr->tim_data ) ) {
drawBG(curLvl->camPtr, nextpri, otdisc, db);
// Loop on camAngles
for ( int mesh = 0 ; mesh < curLvl->camAngles[ curCamAngle ]->index; mesh ++ ) {
enlightMesh(curLvl, curLvl->camAngles[curCamAngle]->objects[mesh], dc_lgtangp);
transformMesh(camera, curLvl->camAngles[curCamAngle]->objects[mesh]);
drawPoly(curLvl->camAngles[curCamAngle]->objects[mesh], atime, camMode, nextpri, ot, db, draw);
}
}
else {
// Draw current node's plane
drawPoly( curLvl->curNode->plane, atime, camMode, nextpri, &ot[*db], db, &draw[*db]);
// Draw surrounding planes
for ( int sibling = 0; sibling < curLvl->curNode->siblings->index; sibling++ ) {
drawPoly(curLvl->curNode->siblings->list[ sibling ]->plane, atime, camMode, nextpri, &ot[*db], db, &draw[*db]);
}
// Draw adjacent planes's children
for ( int sibling = 0; sibling < curLvl->curNode->siblings->index; sibling++ ) {
for ( int object = 0; object < curLvl->curNode->siblings->list[ sibling ]->objects->index; object++ ) {
long t = 0;
enlightMesh(curLvl, curLvl->curNode->siblings->list[ sibling ]->objects->list[ object ], dc_lgtangp);
transformMesh(camera, curLvl->curNode->siblings->list[ sibling ]->objects->list[ object ]);
drawPoly( curLvl->curNode->siblings->list[ sibling ]->objects->list[ object ], atime, camMode, nextpri, &ot[*db], db, &draw[*db]);
}
}
// Draw current plane children
for ( int object = 0; object < curLvl->curNode->objects->index; object++ ) {
enlightMesh(curLvl, curLvl->curNode->objects->list[ object ], dc_lgtangp);
transformMesh(camera, curLvl->curNode->objects->list[ object ]);
drawPoly( curLvl->curNode->objects->list[ object ], atime, camMode, nextpri, &ot[*db], db, &draw[*db]);
}
// Draw rigidbodies
for ( int object = 0; object < curLvl->curNode->rigidbodies->index; object++ ) {
enlightMesh(curLvl, curLvl->curNode->rigidbodies->list[ object ], dc_lgtangp);
transformMesh(camera, curLvl->curNode->rigidbodies->list[ object ]);
drawPoly( curLvl->curNode->rigidbodies->list[ object ], atime, camMode, nextpri, &ot[*db], db, &draw[*db]);
}
}
updateLight();
};
2021-09-25 19:39:49 +02:00
void playAnim(MESH * mesh, VANIM * anim, int loop){
if (mesh->isAnim){
// Set looping (-1 : infinite, n > 0 : loop n times )
if (mesh->currentAnim->loop == 0){
mesh->currentAnim->loop = loop;
}
// If anim not is not playing yet
if (mesh->currentAnim->cursor == -1){
// if cursor is -1, set to 0, start playback
mesh->currentAnim->cursor = 0;
} else {
}
// Anim is already playing
} else if (mesh->currentAnim == anim){
// If we're not in an infinite loop (-1)
if (mesh->currentAnim->loop > 0){
// Add loop iterations ?
mesh->currentAnim->loop = loop;
}
}
};