// 3dcam // With huge help from : // @NicolasNoble : https://discord.com/channels/642647820683444236/646765703143227394/796876392670429204 // @Lameguy64 // @Impiaa // @paul /* PSX screen coordinate system * * Z+ * / * / * +------X+ * /| * / | * / Y+ * eye */ // Blender debug mode // bpy. app. debug = True #include #include #include #include #include #include #include // Precalculated arctan values #include "atan.c" // Sample level #include "coridor2.c" // #define VMODE 0 #define SCREENXRES 320 #define SCREENYRES 240 #define CENTERX SCREENXRES/2 #define CENTERY SCREENYRES/2 #define FOV CENTERX // With a FOV of 1/2, camera focal length is ~= 16 mm / 90° // Lower values mean wider angle // pixel > cm : used in physics calculations #define SCALE 4 #define FNT_POS_X 960 #define FNT_POS_Y 256 #define OT2LEN 8 #define OTLEN 256 // Maximum number of OT entries #define PRIMBUFFLEN 4096 * sizeof(POLY_GT4) // Maximum number of POLY_GT3 primitives // MACROS // swap(x, y, buffer) #define SWAP(a,b,c) {(c)=(a); (a)=(b); (b)=(c);} // dotproduct of two vectors #define dotProduct(v0, v1) \ (v0).vx * (v1).vx + \ (v0).vy * (v1).vy + \ (v0).vz * (v1).vz // min value #define min(a,b) \ (a)-(b)>0?(b):(a) // max #define max(a,b) \ (a)-(b)>0?(a):(b) // substract vector #define subVector(v0, v1) \ (v0).vx - (v1).vx, \ (v0).vy - (v1).vy, \ (v0).vz - (v1).vz #define normalizeVector(v) \ ((v)->vx << 12) >> 8, \ ((v)->vy << 12) >> 8, \ ((v)->vz << 12) >> 8 // Display and draw environments, double buffered DISPENV disp[2]; DRAWENV draw[2]; // OT for BG/FG discrimination u_long otdisc[2][OT2LEN] = {0}; // Main OT u_long ot[2][OTLEN] = {0}; // Ordering table (contains addresses to primitives) char primbuff[2][PRIMBUFFLEN] = {0}; // Primitive list // That's our prim buffer //~ int primcnt=0; // Primitive counter char * nextpri = primbuff[0]; // Primitive counter char db = 0; // Current buffer counter CVECTOR BGc = {50, 50, 75, 0}; // Far color VECTOR BKc = {128, 128, 128, 0}; // Back color // Local color matrix //~ static MATRIX cmat = { //~ /* light source #0, #1, #2, */ //~ ONE, 0, 0, /* R */ //~ 0, ONE, 0, /* G */ //~ 0, 0, ONE, /* B */ //~ }; //~ // local light matrix : Direction and reach of each light source. //~ // Each light is aligned with the axis, hence direction is in the same coordinate system as the PSX (Y-axis down) //~ // One == 4096 is reach/intensity of light source //~ static MATRIX lgtmat = { //~ // X Y Z //~ ONE, 0, 0, // Light 0 //~ 0,0,0, // Light 1 //~ 0,0,0 // Light 2 //~ }; // Light //~ MATRIX rottrans; MATRIX rotlgt; SVECTOR lgtang = {0, 0, 0}; MATRIX light; static int m_cosTable[512]; // precalc costable static const unsigned int DC_2PI = 2048; // this is from here : https://github.com/grumpycoders/Balau/blob/master/tests/test-Handles.cc#L20-L102 static const unsigned int DC_PI = 1024; static const unsigned int DC_PI2 = 512; short vs; typedef struct{ int x, xv; // x: current value += xv : new value int y, yv; // x,y,z, vx, vy, vz are in PSX units (ONE == 4096) int z, zv; int pan, panv; int tilt, tiltv; int rol; VECTOR pos; SVECTOR rot; SVECTOR dvs; MATRIX mat; } CAMERA; CAMERA camera = { 0,0, 0,0, 0,0, 0,0, 0,0, 0, {0,0,0}, {0,0,0}, {0,0,0} }; // physics long time = 0; const int gravity = 10; //Pad int pressed = 0; u_short timer = 0; // Cam stuff int camMode = 0; long timeB = 0; int lerping = 0; short curCamAngle = 0; // Inverted Cam coordinates for Forward Vector calc VECTOR InvCamPos = {0,0,0,0}; VECTOR fVecActor = {0,0,0,0}; u_long triCount = 0; // Prototypes // Stolen from grumpycoder // Sin/Cos Table void generateTable(void); int ncos(u_int t); int nsin(u_int t); // Atan table long long patan(long x, long y); // Sqrt u_int psqrt(u_int n); // fixed point math static inline int32_t dMul(int32_t a, int32_t b); static inline uint32_t lerpU(uint32_t start, uint32_t dest, unsigned pos); static inline int32_t lerpS(int32_t start, int32_t dest, unsigned pos); static inline int32_t lerpD(int32_t start, int32_t dest, int32_t pos); static inline long long lerpL(long long start, long long dest, long long pos); // PSX setup void init(void); void display(void); // Utils void LoadTexture(u_long * tim, TIM_IMAGE * tparam); int cliptest3(short * v1); int lerp(int start, int end, int factor); // FIXME : not working as it should SVECTOR SVlerp(SVECTOR start, SVECTOR end, int factor); // FIXME VECTOR getVectorTo(VECTOR actor, VECTOR target); //~ int alignAxisToVect(VECTOR target, short axis, int factor); void worldToScreen( VECTOR * worldPos, VECTOR * screenPos ); void screenToWorld( VECTOR * screenPos, VECTOR * worldPos ); short checkLineW( VECTOR * pointA, VECTOR * pointB, MESH * mesh ); short checkLineS( VECTOR * pointA, VECTOR * pointB, MESH * mesh ); // Drawing void transformMesh(MESH * meshes); void drawBG(void); void drawPoly(MESH * meshes, long * Flag, int atime); // Camera void getCameraXZ(int * x, int * z, int actorX, int actorZ, int angle, int distance); void applyCamera(CAMERA * cam); void setCameraPos(VECTOR pos, SVECTOR rot); // Physics VECTOR getIntCollision(BODY one, BODY two); VECTOR getExtCollision(BODY one, BODY two); void ResolveCollision( BODY * one, BODY * two ); VECTOR angularMom(BODY body); // Not this kind of mom ;) void applyAcceleration(BODY * actor); // Pad void callback(); int main() { VECTOR sp = {CENTERX,CENTERY,0}; VECTOR wp = {0,0,0}; // FIXME : Poly subdiv //~ DIVPOLYGON4 div4 = { 0 }; //~ div4.pih = SCREENXRES; //~ div4.piv = SCREENYRES; //~ div4.ndiv = 2; //~ long OTc = 0; //~ DIVPOLYGON3 div3 = { 0 }; //~ div3.pih = SCREENXRES; //~ div3.piv = SCREENYRES; //~ div3.ndiv = 1; init(); generateTable(); VSyncCallback(callback); // Load textures for (int k = 0; k < sizeof(meshes)/sizeof(TMESH *); k++){ LoadTexture(meshes[k]->tim_data, meshes[k]->tim); } // Load current BG if (camPtr->tim_data){ LoadTexture(camPtr->tim_data, camPtr->BGtim); } // Physics short physics = 1; long dt; VECTOR col_lvl, col_sphere, col_sphere_act = {0}; // Cam stuff VECTOR posToActor = {0, 0, 0, 0}; // position of camera relative to actor VECTOR camAngleToAct = {0, 0, 0, 0}; // rotation angles for the camera to point at actor // Sprite system VECTOR posToCam = {0, 0, 0, 0}; VECTOR objAngleToCam = {0, 0, 0, 0}; int angle = 0; //PSX units = 4096 == 360° = 2Pi int dist = 0; //PSX units short timediv = 1; int atime = 0; // Polycount for (int k = 0; k < sizeof(meshes)/sizeof(meshes[0]); k++){ triCount += meshes[k]->tmesh->len; } // Set camera starting pos setCameraPos(camPtr->campos->pos, camPtr->campos->rot); // Find curCamAngle if using pre-calculated BGs if (camMode == 2) { if (camPtr->tim_data){ curCamAngle = 1; } } // Main loop //~ while (1) { while ( VSync(1) ) { // Clear the main OT ClearOTagR(otdisc[db], OT2LEN); // Clear Secondary OT ClearOTagR(ot[db], OTLEN); // timeB = time; time ++; // atime is used for animations timing timediv = 1; if (time % timediv == 0){ atime ++; } // Angle between camera and actor // using atantable (faster) camAngleToAct.vy = (patan(-posToActor.vx, -posToActor.vz) / 16) - 3076 ; camAngleToAct.vx = patan(dist, posToActor.vy) >> 4; // Sprite system WIP objAngleToCam.vy = patan( posToCam.vx,posToCam.vz ); objAngleToCam.vx = patan( posToCam.vx,posToCam.vy ); //~ objAngleToCam.vz = patan( posToCam.vz,posToCam.vy ); //~ objAngleToCam.vx = patan( psqrt(posToCam.vx * posToCam.vx + posToCam.vy * posToCam.vy), posToCam.vy ); //~ meshPlan.rot->vx = -( (objAngleToCam.vx >> 4) - 3076 ) ; //~ meshPlan.rot->vx = (( (objAngleToCam.vx >> 4) - 3076 ) * ( (objAngleToCam.vz >> 4) - 3076 ) >> 12) * (nsin(posToCam.vz) >> 10 < 0 ? -1 : 1); //~ meshPlan.rot->vx = ( (objAngleToCam.vx >> 4) - 3076 ) * ( (objAngleToCam.vz >> 4) - 3076 ) >> 12 ; meshPlan.rot->vy = -( (objAngleToCam.vy >> 4) + 1024 ) ; //~ posToCam = getVectorTo(*meshPlan.pos, camera.pos); //~ posToCam = getVectorTo(camera.pos, *meshPlan.pos); posToCam.vx = -camera.pos.vx - modelPlan_pos.vx ; posToCam.vz = -camera.pos.vz - modelPlan_pos.vz ; posToCam.vy = -camera.pos.vy - modelPlan_pos.vy ; //~ psqrt(posToCam.vx * posToCam.vx + posToCam.vy * posToCam.vy); // Actor Forward vector for 3d relative orientation fVecActor = *actorPtr->pos; fVecActor.vx = actorPtr->pos->vx + (nsin(actorPtr->rot->vy/2)); fVecActor.vz = actorPtr->pos->vz - (ncos(actorPtr->rot->vy/2)); // Camera modes if(camMode != 2) { camera.rot.vy = camAngleToAct.vy; // using csin/ccos, no need for theta //~ camera.rot.vy = angle; camera.rot.vx = camAngleToAct.vx; } if(camMode < 4 ) { lerping = 0; } // Camera follows actor with lerp for rotations if(camMode == 0) { dist = 150; camera.pos.vx = -(camera.x/ONE); //~ camera.pos.vy = -(camera.y/ONE); camera.pos.vz = -(camera.z/ONE); //~ InvCamPos.vx = camera.x/ONE; //~ InvCamPos.vz = camera.z/ONE; //~ applyVector(&InvCamPos, -1,-1,-1, *=); angle = -actorPtr->rot->vy / 2; //~ angle = actorPtr->rot->vy; getCameraXZ(&camera.x, &camera.z, actorPtr->pos->vx, actorPtr->pos->vz, angle, dist); // FIXME! camera lerping to pos //~ angle += lerp(camera.rot.vy, -actorPtr->rot->vy, 128); //~ angle = lerpD(camera.rot.vy << 12, actorPtr->rot->vy << 12, 1024 << 12) >> 12; } // Camera rotates continuously around actor if (camMode == 1) { dist = 150; camera.pos.vx = -(camera.x/ONE); //~ camera.pos.vy = -(camera.y/ONE); camera.pos.vz = -(camera.z/ONE); //~ fVecActor = *actorPtr->pos; //~ fVecActor.vx = actorPtr->pos->vx + (nsin(actorPtr->rot->vy)); //~ fVecActor.vz = actorPtr->pos->vz - (ncos(actorPtr->rot->vy)); getCameraXZ(&camera.x, &camera.z, actorPtr->pos->vx, actorPtr->pos->vz, angle, dist); angle += 10; } // Fixed Camera with actor tracking if (camMode == 3) { // Using precalc sqrt dist = psqrt( (posToActor.vx * posToActor.vx ) + (posToActor.vz * posToActor.vz) ); camera.pos.vx = 190; camera.pos.vz = 100; camera.pos.vy = 180; } // Fixed Camera angle if (camMode == 2) { // If BG images exist if (camPtr->tim_data){ checkLineW( &camAngles[ curCamAngle ]->fw.v3, &camAngles[ curCamAngle ]->fw.v2, actorPtr); if ( camAngles[ curCamAngle ]->fw.v0.vx ) { //~ FntPrint("BL x : %d, y : %d\n", camAngles[ curCamAngle ]->fw.v3.vx, camAngles[ curCamAngle ]->fw.v3.vy); //~ FntPrint("BR x : %d, y : %d\n", camAngles[ curCamAngle ]->fw.v2.vx, camAngles[ curCamAngle ]->fw.v2.vy); //~ FntPrint("Pos : %d\n", checkLineW( &camAngles[ curCamAngle ]->fw.v3, &camAngles[ curCamAngle ]->fw.v2, actorPtr) ); //~ FntPrint("Pos : %d\n", checkLineW( &camAngles[ curCamAngle ]->bw.v2, &camAngles[ curCamAngle ]->bw.v3, actorPtr) ); // If actor in camAngle->fw area of screen if ( checkLineW( &camAngles[ curCamAngle ]->fw.v3, &camAngles[ curCamAngle ]->fw.v2, actorPtr) == -1 && ( checkLineW( &camAngles[ curCamAngle ]->bw.v2, &camAngles[ curCamAngle ]->bw.v3, actorPtr) >= 0 ) ) { if (curCamAngle < 5) { curCamAngle++; camPtr = camAngles[ curCamAngle ]; LoadTexture(camPtr->tim_data, camPtr->BGtim); } } } if ( camAngles[ curCamAngle ]->bw.v0.vx ) { //~ FntPrint("BL x : %d, y : %d\n", camAngles[ curCamAngle ]->bw.v3.vx, camAngles[ curCamAngle ]->bw.v3.vy); //~ FntPrint("BR x : %d, y : %d\n", camAngles[ curCamAngle ]->bw.v2.vx, camAngles[ curCamAngle ]->bw.v2.vy); //~ // FntPrint("Pos : %d\n", checkLineW( &camAngles[ curCamAngle ]->bw.v2, &camAngles[ curCamAngle ]->bw.v3, actorPtr) ); // If actor in camAngle->bw area of screen if ( checkLineW( &camAngles[ curCamAngle ]->fw.v3, &camAngles[ curCamAngle ]->fw.v2, actorPtr) >= 0 && checkLineW( &camAngles[ curCamAngle ]->bw.v2, &camAngles[ curCamAngle ]->bw.v3, actorPtr) == -1 ) { if (curCamAngle > 0) { curCamAngle--; camPtr = camAngles[ curCamAngle ]; LoadTexture(camPtr->tim_data, camPtr->BGtim); } } } } setCameraPos(camPtr->campos->pos, camPtr->campos->rot); } // Flyby mode with LERP from camStart to camEnd if (camMode == 4) { // If key pos exist for camera if (camPath.len) { // Lerping sequence has not begun if (!lerping){ // Set cam start position ( first key pos ) camera.pos.vx = camPath.points[camPath.cursor].vx; camera.pos.vy = camPath.points[camPath.cursor].vy; camera.pos.vz = camPath.points[camPath.cursor].vz; // Lerping sequence is starting lerping = 1; // Set cam pos index to 0 camPath.pos = 0; } // Pre calculated sqrt ( see psqrt() ) dist = psqrt( (posToActor.vx * posToActor.vx ) + (posToActor.vz * posToActor.vz)); // Fixed point precision 2^12 == 4096 int precision = 12; camera.pos.vx = lerpD(camPath.points[camPath.cursor].vx << precision, camPath.points[camPath.cursor+1].vx << precision, camPath.pos << precision) >> precision; camera.pos.vy = lerpD(camPath.points[camPath.cursor].vy << precision, camPath.points[camPath.cursor+1].vy << precision, camPath.pos << precision) >> precision; camera.pos.vz = lerpD(camPath.points[camPath.cursor].vz << precision, camPath.points[camPath.cursor+1].vz << precision, camPath.pos << precision) >> precision; //~ FntPrint("Cam %d, %d\n", (int32_t)camPath.points[camPath.cursor].vx, camPath.points[camPath.cursor+1].vx); //~ FntPrint("Cam %d, %d, %d\n", camera.pos.vx, camera.pos.vy, camera.pos.vz); //~ FntPrint("Theta y: %d x: %d\n", theta.vy, theta.vx); //~ FntPrint("Pos: %d Cur: %d\nTheta y: %d x: %d\n", camPath.pos, camPath.cursor, theta.vy, theta.vx); // Linearly increment the lerp factor camPath.pos += 20; // If camera has reached next key pos, reset pos index, move cursor to next key pos if (camPath.pos > (1 << precision) ){ camPath.pos = 0; camPath.cursor ++; } // Last key pos is reached, reset cursor to first key pos, lerping sequence is over if ( camPath.cursor == camPath.len - 1 ){ lerping = 0; camPath.cursor = 0; } } else { // if no key pos exists, switch to next camMode camMode ++; } } // Camera "on a rail" - cam is tracking actor, and moving with constraints on all axis if (camMode == 5) { // track actor. If theta (actor/cam rotation angle) is above or below an arbitrary angle, // move cam so that the angle doesn't increase/decrease anymore. short cameraSpeed = 40; if (camPath.len) { // Lerping sequence has not begun if (!lerping){ // Set cam start position ( first key pos ) camera.pos.vx = camPath.points[camPath.cursor].vx; camera.pos.vy = camPath.points[camPath.cursor].vy; camera.pos.vz = camPath.points[camPath.cursor].vz; // Lerping sequence is starting lerping = 1; // Set cam pos index to 0 camPath.pos = 0; } // Pre calculated sqrt ( see psqrt() ) dist = psqrt( (posToActor.vx * posToActor.vx ) + (posToActor.vz * posToActor.vz)); // Fixed point precision 2^12 == 4096 short precision = 12; camera.pos.vx = lerpD(camPath.points[camPath.cursor].vx << precision, camPath.points[camPath.cursor + 1].vx << precision, camPath.pos << precision) >> precision; camera.pos.vy = lerpD(camPath.points[camPath.cursor].vy << precision, camPath.points[camPath.cursor + 1].vy << precision, camPath.pos << precision) >> precision; camera.pos.vz = lerpD(camPath.points[camPath.cursor].vz << precision, camPath.points[camPath.cursor + 1].vz << precision, camPath.pos << precision) >> precision; //~ FntPrint("%d %d %d %d\n", camAngleToAct.vy, camera.pos.vx, camera.rot.vy, dist); // Ony move cam if position is between first camPath.vx and last camPath.vx if ( camAngleToAct.vy < -50 && camera.pos.vx > camPath.points[camPath.len - 1].vx ) { // Clamp camPath position to cameraSpeed camPath.pos += dist < cameraSpeed ? 0 : cameraSpeed ; } if ( camAngleToAct.vy > 50 && camera.pos.vx > camPath.points[camPath.cursor].vx ) { camPath.pos -= dist < cameraSpeed ? 0 : cameraSpeed; } // If camera has reached next key pos, reset pos index, move cursor to next key pos if (camPath.pos > (1 << precision) ){ camPath.pos = 0; camPath.cursor ++; } if (camPath.pos < -100 ){ camPath.pos = 1 << precision; camPath.cursor --; } // Last key pos is reached, reset cursor to first key pos, lerping sequence is over if ( camPath.cursor == camPath.len - 1 || camPath.cursor < 0 ){ lerping = 0; camPath.cursor = 0; } } else { // if no key pos exists, switch to next camMode camMode ++; } } // Spatial partitioning for ( int msh = 0; msh < curNode->siblings->index; msh ++ ) { // Actor if ( !getIntCollision( *actorPtr->body , *curNode->siblings->list[msh]->plane->body).vx && !getIntCollision( *actorPtr->body , *curNode->siblings->list[msh]->plane->body).vz ) { if ( curNode != curNode->siblings->list[msh] ) { curNode = curNode->siblings->list[msh]; levelPtr = curNode->plane; } } // DONTNEED ? // Moveable prop //~ if ( !getIntCollision( *propPtr->body , *curNode->siblings->list[msh]->plane->body).vx && //~ !getIntCollision( *propPtr->body , *curNode->siblings->list[msh]->plane->body).vz ) { //~ if ( propPtr->node != curNode->siblings->list[ msh ]){ //~ propPtr->node = curNode->siblings->list[ msh ]; //~ } //~ } if ( !getIntCollision( *propPtr->body , *curNode->plane->body).vx && !getIntCollision( *propPtr->body , *curNode->plane->body).vz ) { propPtr->node = curNode; } } // Physics if ( physics ) { // if(time%1 == 0){ for ( int k = 0; k < sizeof(meshes)/sizeof(meshes[0]);k ++ ) { //~ for ( int k = 0; k < curNode->objects->index ; k ++){ if ( ( *meshes[k]->isRigidBody == 1 ) ) { //~ if ( ( *curNode->rigidbodies->list[k]->isRigidBody == 1 ) ) { //~ applyAcceleration(curNode->rigidbodies->list[k]->body); applyAcceleration(meshes[k]->body); // Get col with level ( modelgnd_body ) col_lvl = getIntCollision( *meshes[k]->body , *levelPtr->body ); col_sphere = getIntCollision( *propPtr->body, *propPtr->node->plane->body ); // col_sphere = getIntCollision( *propPtr->body, *levelPtr->body ); col_sphere_act = getExtCollision( *actorPtr->body, *propPtr->body ); // If no col with ground, fall off if ( col_lvl.vy ) { if ( !col_lvl.vx && !col_lvl.vz ) { actorPtr->body->position.vy = actorPtr->body->min.vy; } } if (col_sphere.vy){ if ( !col_sphere.vx && !col_sphere.vz ) { propPtr->body->position.vy = propPtr->body->min.vy; } } if (col_sphere_act.vx && col_sphere_act.vz ) { propPtr->body->velocity.vx += actorPtr->body->velocity.vx; propPtr->body->velocity.vz += actorPtr->body->velocity.vz; if ( propPtr->body->velocity.vx ) { VECTOR L = angularMom(*propPtr->body); propPtr->rot->vz -= L.vx; } if ( propPtr->body->velocity.vz ) { VECTOR L = angularMom( *propPtr->body ); propPtr->rot->vx -= L.vz; } } meshes[k]->pos->vx = meshes[k]->body->position.vx; meshes[k]->pos->vy = meshes[k]->body->position.vy ; meshes[k]->pos->vz = meshes[k]->body->position.vz; } meshes[k]->body->velocity.vy = 0; meshes[k]->body->velocity.vx = 0; meshes[k]->body->velocity.vz = 0; } // } } if ( (camMode == 2) && (camPtr->tim_data ) ) { worldToScreen(actorPtr->pos, &actorPtr->pos2D); } // Camera setup // position of cam relative to actor posToActor.vx = actorPtr->pos->vx + camera.pos.vx; posToActor.vz = actorPtr->pos->vz + camera.pos.vz; posToActor.vy = actorPtr->pos->vy + camera.pos.vy; // Polygon drawing static long Flag; if ( (camMode == 2) && (camPtr->tim_data ) ) { drawBG(); // Loop on camAngles for ( int mesh = 0 ; mesh < camAngles[ curCamAngle ]->index; mesh ++ ) { transformMesh(camAngles[curCamAngle]->objects[mesh]); drawPoly(camAngles[curCamAngle]->objects[mesh], &Flag, atime); } } else { // Draw current node's plane drawPoly( curNode->plane, &Flag, atime); // Draw surrounding planes for ( int sibling = 0; sibling < curNode->siblings->index; sibling++ ) { drawPoly( curNode->siblings->list[ sibling ]->plane, &Flag, atime); } // Draw adjacent planes's children for ( int sibling = 0; sibling < curNode->siblings->index; sibling++ ) { for ( int object = 0; object < curNode->siblings->list[ sibling ]->objects->index; object++ ) { long t = 0; transformMesh(curNode->siblings->list[ sibling ]->objects->list[ object ]); drawPoly( curNode->siblings->list[ sibling ]->objects->list[ object ], &Flag, atime); } } // Draw current plane children for ( int object = 0; object < curNode->objects->index; object++ ) { transformMesh(curNode->objects->list[ object ]); drawPoly( curNode->objects->list[ object ], &Flag, atime); } // Draw rigidbodies for ( int object = 0; object < curNode->rigidbodies->index; object++ ) { transformMesh(curNode->rigidbodies->list[ object ]); drawPoly( curNode->rigidbodies->list[ object ], &Flag, atime); } } // Find and apply light rotation matrix RotMatrix(&lgtang, &rotlgt); MulMatrix0(&lgtmat, &rotlgt, &light); SetLightMatrix(&light); // Set camera applyCamera(&camera); // Add secondary OT to main OT AddPrims(otdisc[db], ot[db] + OTLEN - 1, ot[db]); //~ FntPrint("CurNode : %x\nIndex: %d", curNode, curNode->siblings->index); FntPrint("Time : %d dt :%d\n", VSync(-1) / 60, dt); FntPrint("%d\n", curCamAngle ); //~ FntPrint("Actor : %d %d\n", actorPtr->pos->vx, actorPtr->pos->vy); //~ FntPrint("%d %d\n", actorPtr->pos->vx, actorPtr->pos->vz); //~ FntPrint("%d %d\n", actorPtr->pos2D.vx + CENTERX, actorPtr->pos2D.vy + CENTERY); //~ FntPrint(" %d %d %d\n", wp.vx, wp.vy, wp.vz); FntFlush(-1); display(); //~ frame = VSync(-1); } return 0; } void init() { ResetCallback(); // Reset the GPU before doing anything and the controller ResetGraph(0); PadInit(0); // Initialize and setup the GTE InitGeom(); SetGeomOffset( CENTERX, CENTERY ); // x, y offset SetGeomScreen( FOV ); // Distance between eye and screen - Camera FOV // Set the display and draw environments SetDefDispEnv(&disp[0], 0, 0 , SCREENXRES, SCREENYRES); SetDefDispEnv(&disp[1], 0, SCREENYRES, SCREENXRES, SCREENYRES); SetDefDrawEnv(&draw[0], 0, SCREENYRES, SCREENXRES, SCREENYRES); SetDefDrawEnv(&draw[1], 0, 0, SCREENXRES, SCREENYRES); // If PAL if ( VMODE ) { SetVideoMode(MODE_PAL); disp[0].screen.y += 8; disp[1].screen.y += 8; } // Set Draw area color setRGB0(&draw[0], BGc.r, BGc.g, BGc.b); setRGB0(&draw[1], BGc.r, BGc.g, BGc.b); // Set Draw area clear flag draw[0].isbg = 1; draw[1].isbg = 1; // Set the disp and draw env PutDispEnv(&disp[db]); PutDrawEnv(&draw[db]); // Init font system FntLoad(FNT_POS_X, FNT_POS_Y); FntOpen(16, 90, 240, 180, 0, 512); // Lighting setup SetColorMatrix(&cmat); SetBackColor(BKc.vx,BKc.vy,BKc.vz); SetFarColor(BGc.r, BGc.g, BGc.b); SetFogNearFar(1200, 1600, SCREENXRES); }; void display(void){ //~ DrawSync(0); vs = VSync(2); // Using VSync 2 insures constant framerate. 0 makes the fr polycount dependant. ResetGraph(1); PutDispEnv(&disp[db]); PutDrawEnv(&draw[db]); SetDispMask(1); // Main OT DrawOTag(otdisc[db] + OT2LEN - 1); db = !db; nextpri = primbuff[db]; }; void LoadTexture(u_long * tim, TIM_IMAGE * tparam){ // This part is from Lameguy64's tutorial series : lameguy64.net/svn/pstutorials/chapter1/3-textures.html login/pw: annoyingmous OpenTIM(tim); // Open the tim binary data, feed it the address of the data in memory ReadTIM(tparam); // This read the header of the TIM data and sets the corresponding members of the TIM_IMAGE structure LoadImage(tparam->prect, tparam->paddr); // Transfer the data from memory to VRAM at position prect.x, prect.y DrawSync(0); // Wait for the drawing to end if (tparam->mode & 0x8){ // check 4th bit // If 4th bit == 1, TIM has a CLUT LoadImage(tparam->crect, tparam->caddr); // Load it to VRAM at position crect.x, crect.y DrawSync(0); // Wait for drawing to end } }; void transformMesh(MESH * mesh){ MATRIX mat; // Apply rotation matrix RotMatrix_gte(mesh->rot, &mat); // Apply translation matrix TransMatrix(&mat, mesh->pos); // Compose matrix with cam CompMatrix(&camera.mat, &mat, &mat); // Set default rotation and translation matrices SetRotMatrix(&mat); SetTransMatrix(&mat); //~ } }; // Drawing void drawPoly(MESH * mesh, long * Flag, int atime){ long nclip, t = 0; // mesh is POLY_GT3 ( triangle ) if (mesh->index[t].code == 4) { 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 ) { // 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 if (*mesh->isAnim){ // If interpolation flag is set, use it if(mesh->anim->interpolate){ // Ping pong //~ //if (mesh->anim->cursor > 4096 || mesh->anim->cursor < 0){ //~ // mesh->anim->dir *= -1; //~ //} // Fixed point math precision short precision = 12; // Find next keyframe if (mesh->anim->cursor > (1 << precision)) { // There are still keyframes to interpolate between if ( mesh->anim->lerpCursor < mesh->anim->nframes - 1 ) { mesh->anim->lerpCursor ++; mesh->anim->cursor = 0; } // We've reached last frame, go back to first frame if ( mesh->anim->lerpCursor == mesh->anim->nframes - 1 ) { mesh->anim->lerpCursor = 0; mesh->anim->cursor = 0; } } // Let's lerp between keyframes // TODO : Finish lerped animation implementation // Vertex 1 mesh->tmesh->v[ mesh->index[ t ].order.vx ].vx = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vx].vx << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vx].vx << precision, mesh->anim->cursor << precision) >> precision; mesh->tmesh->v[ mesh->index[ t ].order.vx ].vz = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vx].vz << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vx].vz << precision, mesh->anim->cursor << precision) >> precision; mesh->tmesh->v[ mesh->index[ t ].order.vx ].vy = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vx].vy << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vx].vy << precision, mesh->anim->cursor << precision) >> precision; // Vertex 2 mesh->tmesh->v[ mesh->index[ t ].order.vz ].vx = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vz].vx << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vz].vx << precision, mesh->anim->cursor << precision) >> precision; mesh->tmesh->v[ mesh->index[ t ].order.vz ].vz = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vz].vz << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vz].vz << precision, mesh->anim->cursor << precision) >> precision; mesh->tmesh->v[ mesh->index[ t ].order.vz ].vy = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vz].vy << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vz].vy << precision, mesh->anim->cursor << precision) >> precision; // Vertex 3 mesh->tmesh->v[ mesh->index[ t ].order.vy ].vx = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vy].vx << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vy].vx << precision, mesh->anim->cursor << precision) >> precision; mesh->tmesh->v[ mesh->index[ t ].order.vy ].vz = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vy].vz << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vy].vz << precision, mesh->anim->cursor << precision) >> precision; mesh->tmesh->v[ mesh->index[ t ].order.vy ].vy = lerpD( mesh->anim->data[mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[t].order.vy].vy << precision , mesh->anim->data[(mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[t].order.vy].vy << precision, mesh->anim->cursor << precision) >> precision; mesh->anim->cursor += 24 * mesh->anim->dir; // Coord transformation from world space to screen space nclip = 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 ); } else { // No interpolation // Use the pre-calculated vertices coordinates from the animation data nclip = RotAverageNclip3( &mesh->anim->data[ atime % mesh->anim->nframes * mesh->anim->nvert + mesh->index[t].order.vx ], &mesh->anim->data[ atime % mesh->anim->nframes * mesh->anim->nvert + mesh->index[t].order.vz ], &mesh->anim->data[ atime % mesh->anim->nframes * mesh->anim->nvert + mesh->index[t].order.vy ], ( long* ) &poly->x0, ( long* ) &poly->x1, ( long* ) &poly->x2, mesh->p, mesh->OTz, Flag ); } } else { // No animation // Use model's regular vertex coordinates nclip = 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 ); } // Do not draw invisible meshes if ( nclip > 0 && *mesh->OTz > 0 && (*mesh->p < 4096) ) { SetPolyGT3( poly ); // If isPrism flag is set, use it // FIXME : Doesn't work with pre-rendered BGs if ( *mesh->isPrism ) { // Transparency effect : // Use current DRAWENV clip as TPAGE instead of regular textures ( (POLY_GT3 *) poly )->tpage = getTPage( mesh->tim->mode&0x3, 0, draw[db].clip.x, draw[db].clip.y ); // Use projected coordinates (results from RotAverage...) as UV coords and clamp them to 0-255,0-224 Why 224 though ? setUV3(poly, (poly->x0 < 0 ? 0 : poly->x0 > 255 ? 255 : poly->x0), (poly->y0 < 0 ? 0 : poly->y0 > 240 ? 240 : poly->y0), (poly->x1 < 0 ? 0 : poly->x1 > 255 ? 255 : poly->x1), (poly->y1 < 0 ? 0 : poly->y1 > 240 ? 240 : poly->y1), (poly->x2 < 0 ? 0 : poly->x2 > 255 ? 255 : poly->x2), (poly->y2 < 0 ? 0 : poly->y2 > 240 ? 240 : poly->y2) ); } else { // No transparency effect // Use regular TPAGE ( (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); } // 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 ); } // Defaults depth color to neutral grey CVECTOR outCol = { 128,128,128,0 }; CVECTOR outCol1 = { 128,128,128,0 }; CVECTOR outCol2 = { 128,128,128,0 }; NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vx ], &mesh->tmesh->c[ mesh->index[t].order.vx ], *mesh->p, &outCol); NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vz ], &mesh->tmesh->c[ mesh->index[t].order.vz ], *mesh->p, &outCol1); NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vy ], &mesh->tmesh->c[ mesh->index[t].order.vy ], *mesh->p, &outCol2); // If transparent effect is in use, inhibate shadows if (*mesh->isPrism){ // Use un-interpolated (i.e: no light, no fog) colors setRGB0(poly, mesh->tmesh->c[i].r, mesh->tmesh->c[i].g, mesh->tmesh->c[i].b); setRGB1(poly, mesh->tmesh->c[i+1].r, mesh->tmesh->c[i+1].g, mesh->tmesh->c[i+1].b); setRGB2(poly, mesh->tmesh->c[i+2].r, mesh->tmesh->c[i+2].g, mesh->tmesh->c[i+2].b); } else { setRGB0(poly, outCol.r, outCol.g , outCol.b); setRGB1(poly, outCol1.r, outCol1.g, outCol1.b); setRGB2(poly, outCol2.r, outCol2.g, outCol2.b); } if ( (*mesh->OTz > 0) && (*mesh->OTz < OTLEN) && (*mesh->p < 4096) ) { AddPrim(&ot[db][*mesh->OTz-2], poly); } //~ mesh->pos2D.vx = *(&poly->x0); //~ mesh->pos2D.vy = *(&poly->x0 + 1); // mesh->pos2D.vy = poly->x0; // FntPrint("%d %d\n", *(&poly->x0), *(&poly->x0 + 1)); nextpri += sizeof(POLY_GT3); } t+=1; } } } // If mesh is quad if (mesh->index[t].code == 8) { POLY_GT4 * poly4; for (int i = 0; i < (mesh->tmesh->len * 4); i += 4) { // if mesh is not part of BG, draw them, else, discard if ( !(*mesh->isBG) || camMode != 2 ) { poly4 = (POLY_GT4 *)nextpri; // Vertex Anim if (*mesh->isAnim){ // with interpolation if ( mesh->anim->interpolate ){ // ping pong //~ if (mesh->anim->cursor > 4096 || mesh->anim->cursor < 0){ //~ mesh->anim->dir *= -1; //~ } short precision = 12; if ( mesh->anim->cursor > 1<anim->lerpCursor < mesh->anim->nframes - 1 ) { mesh->anim->lerpCursor ++; mesh->anim->cursor = 0; } if ( mesh->anim->lerpCursor == mesh->anim->nframes - 1 ) { mesh->anim->lerpCursor = 0; mesh->anim->cursor = 0; } } // Vertex 1 mesh->tmesh->v[ mesh->index[ t ].order.vx ].vx = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vx ].vx << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vx ].vx << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.vx ].vz = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vx ].vz << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vx ].vz << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.vx ].vy = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vx ].vy << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vx ].vy << 12, mesh->anim->cursor << 12) >> 12; // Vertex 2 mesh->tmesh->v[ mesh->index[ t ].order.vz ].vx = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vz ].vx << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vz ].vx << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.vz ].vz = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vz ].vz << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vz ].vz << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.vz ].vy = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vz ].vy << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vz ].vy << 12, mesh->anim->cursor << 12) >> 12; // Vertex 3 mesh->tmesh->v[ mesh->index[ t ].order.vy ].vx = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vy ].vx << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vy ].vx << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.vy ].vz = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vy ].vz << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vy ].vz << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.vy ].vy = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.vy ].vy << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.vy ].vy << 12, mesh->anim->cursor << 12) >> 12; // Vertex 4 mesh->tmesh->v[ mesh->index[ t ].order.pad ].vx = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.pad ].vx << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.pad ].vx << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.pad ].vz = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.pad ].vz << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.pad ].vz << 12, mesh->anim->cursor << 12) >> 12; mesh->tmesh->v[ mesh->index[ t ].order.pad ].vy = lerpD( mesh->anim->data[ mesh->anim->lerpCursor * mesh->anim->nvert + mesh->index[ t ].order.pad ].vy << 12 , mesh->anim->data[ (mesh->anim->lerpCursor + 1) * mesh->anim->nvert + mesh->index[ t ].order.pad ].vy << 12, mesh->anim->cursor << 12) >> 12; mesh->anim->cursor += 2 * mesh->anim->dir; // Coord transformations nclip = 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 ); } else { // No interpolation, use all vertices coordinates in anim data nclip = RotAverageNclip4( &mesh->anim->data[ atime % mesh->anim->nframes * mesh->anim->nvert + mesh->index[t].order.pad ], &mesh->anim->data[ atime % mesh->anim->nframes * mesh->anim->nvert + mesh->index[t].order.vz ], &mesh->anim->data[ atime % mesh->anim->nframes * mesh->anim->nvert + mesh->index[t].order.vx ], &mesh->anim->data[ atime % mesh->anim->nframes * mesh->anim->nvert + mesh->index[t].order.vy ], ( long* )&poly4->x0, ( long* )&poly4->x1, ( long* )&poly4->x2, ( long* )&poly4->x3, mesh->p, mesh->OTz, Flag ); } } else { // No animation // Use regulare vertex coords nclip = 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 ); } if (nclip > 0 && *mesh->OTz > 0 && (*mesh->p < 4096)) { SetPolyGT4(poly4); // FIXME : Polygon subdiv - is it working ? //~ OTc = *mesh->OTz >> 4; //~ FntPrint("OTC:%d", OTc); //~ if (OTc < 4) { //~ if (OTc > 1) div4.ndiv = 1; else div4.ndiv = 2; //~ 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 ], //~ // 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], //~ mesh->tmesh->c[i+1], //~ mesh->tmesh->c[i+2], //~ mesh->tmesh->c[i+3], //~ // Gpu packet //~ poly4, //~ &ot[db][*mesh->OTz], //~ &div4); //~ // Increment primitive list pointer //~ nextpri += ( (sizeof(POLY_GT4) + 3) / 4 ) * (( 1 << ( div4.ndiv )) << ( div4.ndiv )); //~ triCount = ((1<<(div4.ndiv))<<(div4.ndiv)); //~ } else if (OTc < 48) { // Transparency effect if (*mesh->isPrism){ // Use current DRAWENV clip as TPAGE ( (POLY_GT4 *) poly4)->tpage = getTPage(mesh->tim->mode&0x3, 0, draw[db].clip.x, draw[db].clip.y ); // Use projected coordinates setUV4( poly4, (poly4->x0 < 0? 0 : poly4->x0 > 255? 255 : poly4->x0), (poly4->y0 < 0? 0 : poly4->y0 > 224? 224 : poly4->y0), (poly4->x1 < 0? 0 : poly4->x1 > 255? 255 : poly4->x1), (poly4->y1 < 0? 0 : poly4->y1 > 224? 224 : poly4->y1), (poly4->x2 < 0? 0 : poly4->x2 > 255? 255 : poly4->x2), (poly4->y2 < 0? 0 : poly4->y2 > 224? 224 : poly4->y2), (poly4->x3 < 0? 0 : poly4->x3 > 255? 255 : poly4->x3), (poly4->y3 < 0? 0 : poly4->y3 > 224? 224 : poly4->y3) ); } else { // Use regular TPAGE ( (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 ); } if (*mesh->isSprite){ SetShadeTex( poly4, 1 ); } // If tim mode == 0 | 1, set CLUT coordinates if ( (mesh->tim->mode & 0x3) < 2 ) { setClut(poly4, mesh->tim->crect->x, mesh->tim->crect->y ); } CVECTOR outCol = {128,128,128,0}; CVECTOR outCol1 = {128,128,128,0}; CVECTOR outCol2 = {128,128,128,0}; CVECTOR outCol3 = {128,128,128,0}; NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.pad ] , &mesh->tmesh->c[ mesh->index[t].order.pad ], *mesh->p, &outCol); NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vz ], &mesh->tmesh->c[ mesh->index[t].order.vz ], *mesh->p, &outCol1); NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vx ], &mesh->tmesh->c[ mesh->index[t].order.vx ], *mesh->p, &outCol2); NormalColorDpq(&mesh->tmesh->n[ mesh->index[t].order.vy ], &mesh->tmesh->c[ mesh->index[t].order.vy ], *mesh->p, &outCol3); if (*mesh->isPrism){ setRGB0(poly4, mesh->tmesh->c[i].r, mesh->tmesh->c[i].g, mesh->tmesh->c[i].b); setRGB1(poly4, mesh->tmesh->c[i+1].r, mesh->tmesh->c[i+1].g, mesh->tmesh->c[i+1].b); setRGB2(poly4, mesh->tmesh->c[i+2].r, mesh->tmesh->c[i+2].g, mesh->tmesh->c[i+2].b); setRGB3(poly4, mesh->tmesh->c[i+3].r, mesh->tmesh->c[i+3].g, mesh->tmesh->c[i+3].b); } else { 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); } if ( (*mesh->OTz > 0) && (*mesh->OTz < OTLEN) && (*mesh->p < 4096) ) { AddPrim( &ot[ db ][ *mesh->OTz-3 ], poly4 ); } nextpri += sizeof( POLY_GT4 ); } t += 1; } } } }; void drawBG(void){ // 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[ db ][ 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[db][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[ db ][ 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[ db ][ OT2LEN-1 ], tpage ); nextpri += sizeof( DR_TPAGE ); }; // Maths void getCameraXZ(int * x, int * z, int actorX, int actorZ, int angle, int distance) { // Using Nic's Costable : https://github.com/grumpycoders/Balau/blob/master/tests/test-Handles.cc#L20-L102 // https://godbolt.org/z/q6cMcj *x = (actorX << 12) + (distance * nsin(angle)); *z = (actorZ << 12) - (distance * ncos(angle)); }; // @Will : you might want to use sin/cos to move the camera in a circle but you could do that by moving it along it’s tangent and then clamping the distance void applyCamera( CAMERA * cam ) { VECTOR vec; // Vector that holds the output values of the following instructions RotMatrix_gte(&cam->rot, &cam->mat); // Convert rotation angle in psx units (360° == 4096) to rotation matrix) ApplyMatrixLV(&cam->mat, &cam->pos, &vec); // Multiply matrix by vector pos and output to vec TransMatrix(&cam->mat, &vec); // Apply transform vector SetRotMatrix(&cam->mat); // Set Rotation matrix SetTransMatrix(&cam->mat); // Set Transform matrix }; void setCameraPos( VECTOR pos, SVECTOR rot ) { camera.pos = pos; camera.rot = rot; }; VECTOR getVectorTo( VECTOR actor, VECTOR target ) { VECTOR direction = { subVector(target, actor) }; VECTOR Ndirection = {0,0,0,0}; u_int distSq = (direction.vx * direction.vx) + (direction.vz * direction.vz); direction.pad = psqrt(distSq); VectorNormal(&direction, &Ndirection); return Ndirection ; }; // From 'psyq/addons/graphics/ZIMEN/CLIP.C' void worldToScreen( VECTOR * worldPos, VECTOR * screenPos ) { int distToScreen; // corresponds to FOV MATRIX curRot; // current rotation matrix // Get current matrix and projection */ distToScreen = ReadGeomScreen(); ReadRotMatrix(&curRot); // Get Rotation, Translation coordinates, apply perspective correction // Muliply world coordinates vector by current rotation matrix, store in screenPos ApplyMatrixLV(&curRot, worldPos, screenPos); // Get world translation vectors from rot and add to screenPos vx, vy, vz applyVector(screenPos, curRot.t[0], curRot.t[1], curRot.t[2], +=); // Correct perspective screenPos -> vx = screenPos -> vx * distToScreen / ( screenPos -> vz + 1 ) ; // Add 1 to avoid division by 0 screenPos -> vy = screenPos -> vy * distToScreen / ( screenPos -> vz + 1 ) ; screenPos -> vz = distToScreen ; }; void screenToWorld( VECTOR * screenPos, VECTOR * worldPos ) { int distToScreen; // corresponds to FOV MATRIX curRot, invRot; // current rotation matrix, transpose matrix VECTOR Trans; // working translation vector // Get current matrix and projection distToScreen = ReadGeomScreen(); ReadRotMatrix( &curRot ); PushMatrix(); // Store matrix on the stack (slow!) //// worldTrans = invRot * (screenPos - Rot.t) // Get world translation Trans.vx = screenPos->vx - curRot.t[0]; // Substract world translation from screenpos Trans.vy = screenPos->vy - curRot.t[1]; Trans.vz = screenPos->vz - curRot.t[2]; // We want the inverse of the current rotation matrix. // // Inverse matrix : M^-1 = 1 / detM * T(M) // We know that the determinant of a rotation matrix is 1, thus: // M^-1 = T(M) // // Get transpose of current rotation matrix // > The transpose of a matrix is a new matrix whose rows are the columns of the original. // https://www.quora.com/What-is-the-geometric-interpretation-of-the-transpose-of-a-matrix TransposeMatrix( &curRot, &invRot ); // Multiply the transpose of current rotation matrix by the current translation vector ApplyMatrixLV( &invRot, &Trans, worldPos ); // Get original rotation matrix back PopMatrix(); }; short checkLineW( VECTOR * pointA, VECTOR * pointB, MESH * mesh ) { long val1 = ( ( mesh->body->position.vx + mesh->body->min.vx ) - pointA->vx ) * ( pointB->vy - pointA->vy ) - ( ( mesh->body->position.vz + mesh->body->min.vy ) - pointA->vy ) * ( pointB->vx - pointA->vx ) ; long val2 = ( ( mesh->body->position.vx + mesh->body->max.vx ) - pointA->vx ) * ( pointB->vy - pointA->vy ) - ( ( mesh->body->position.vz + mesh->body->max.vy ) - pointA->vy ) * ( pointB->vx - pointA->vx ) ; if ( val1 > 0 && val2 > 0 ) { // right return 1; } else if ( val1 < 0 && val2 < 0 ) { // left return -1; } else if ( val1 == 0 && val2 == 0 ) { // identical return 0; } else if ( ( val1 > 0 && val2 == 0 ) || ( val1 == 0 && val2 > 0 ) ) { // right return 1; } else if ( ( val1 < 0 && val2 == 0 ) || ( val1 == 0 && val2 < 0 ) ) { // left return -1; } else if ( ( val1 < 0 && val2 > 0 ) || ( val1 > 0 && val2 < 0 ) ) { // intersect return 3; } }; // Screen space variant short checkLineS( VECTOR * pointA, VECTOR * pointB, MESH * mesh ) { // FIXME : mesh->body->min.vx is not in screen space int val1 = ( ( mesh->pos2D.vx + mesh->body->min.vx ) - pointA->vx ) * ( pointB->vy - pointA->vy ) - ( ( mesh->pos2D.vy + mesh->body->min.vy ) - pointA->vy ) * ( pointB->vx - pointA->vx ) ; int val2 = ( ( mesh->pos2D.vx + mesh->body->max.vx ) - pointA->vx ) * ( pointB->vy - pointA->vy ) - ( ( mesh->pos2D.vy + mesh->body->max.vy ) - pointA->vy ) * ( pointB->vx - pointA->vx ) ; if ( val1 > 0 && val2 > 0 ) { // right return 1; } else if ( val1 < 0 && val2 < 0 ) { // left return -1; } else if ( val1 == 0 && val2 == 0 ) { // identical return 2; } else if ( ( val1 > 0 && val2 == 0 ) || ( val1 == 0 && val2 > 0 ) ) { // right return 1; } else if ( ( val1 < 0 && val2 == 0 ) || ( val1 == 0 && val2 < 0 ) ) { // left return -1; } else if ( ( val1 < 0 && val2 > 0 ) || ( val1 > 0 && val2 < 0 ) ) { // intersect return 3; } }; //~ int alignAxisToVect(VECTOR target, short axis, int factor){ //~ } // Lerp int lerp(int start, int end, int factor){ // lerp interpolated cam movement // InBetween = Value 1 + ( ( Value2 - Value1 ) * lerpValue ) ; // lerpValue should be a float between 0 and 1. return ( start ) + (( end - start ) * factor ) >> 12; }; long long easeIn(long long i, int div){ return ((i << 7) * (i << 7) * (i << 7) / div ) >> 19; }; int easeOut(int i){ return (4096 >> 7) - ((4096 - (i << 7)) * (4096 - (i << 7))) >> 12; }; int easeInOut(int i, int div){ return lerp(easeIn(i, div), easeOut(i) , i); }; SVECTOR SVlerp(SVECTOR start, SVECTOR end, int factor){ SVECTOR output = {0,0,0,0}; output.vx = lerp(start.vx, end.vx, factor); output.vy = lerp(start.vy, end.vy, factor); output.vz = lerp(start.vz, end.vz, factor); return output; }; // Physics VECTOR getIntCollision(BODY one, BODY two){ VECTOR d1, d2, col; short correction = 50; d1.vx = (one.position.vx + one.max.vx) - (two.position.vx + two.min.vx); d1.vy = (one.position.vy + one.max.vy) - (two.position.vy + two.min.vy); d1.vz = (one.position.vz + one.max.vz) - (two.position.vz + two.min.vz); d2.vx = (two.position.vx + two.max.vx) - (one.position.vx - one.max.vx); d2.vy = (two.position.vy + two.max.vy) - (one.position.vy + one.min.vy); d2.vz = (two.position.vz + two.max.vz) - (one.position.vz - one.max.vz); col.vx = !(d1.vx > 0 && d2.vx > 0); col.vy = d1.vy > 0 && d2.vy > 0; col.vz = !(d1.vz > 0 && d2.vz > 0); return col; }; VECTOR getExtCollision(BODY one, BODY two){ VECTOR d1, d2, col; d1.vx = (one.position.vx + one.max.vx) - (two.position.vx + two.min.vx); d1.vy = (one.position.vy + one.max.vy) - (two.position.vy + two.min.vy); d1.vz = (one.position.vz + one.max.vz) - (two.position.vz + two.min.vz); d2.vx = (two.position.vx + two.max.vx) - (one.position.vx + one.min.vx); d2.vy = (two.position.vy + two.max.vy) - (one.position.vy + one.min.vy); d2.vz = (two.position.vz + two.max.vz) - (one.position.vz + one.min.vz); col.vx = d1.vx > 0 && d2.vx > 0; col.vy = d1.vy > 0 && d2.vy > 0; col.vz = d1.vz > 0 && d2.vz > 0; return col; }; void applyAcceleration(BODY * actor){ short dt = 1; VECTOR acceleration = {actor->invMass * actor->gForce.vx , (actor->invMass * actor->gForce.vy) + (gravity * ONE), actor->invMass * actor->gForce.vz}; //~ FntPrint("acc: %d %d %d\n", acceleration.vx, acceleration.vy, acceleration.vz ); actor->velocity.vx += (acceleration.vx * dt) >> 12; actor->velocity.vy += (acceleration.vy * dt) >> 12; actor->velocity.vz += (acceleration.vz * dt) >> 12; //~ FntPrint("acc: %d %d %d\n", acceleration.vx / ONE, acceleration.vy / ONE, acceleration.vz / ONE ); actor->position.vx += (actor->velocity.vx * dt); actor->position.vy += (actor->velocity.vy * dt); actor->position.vz += (actor->velocity.vz * dt); //~ FntPrint("vel: %d %d %d\n", actor->velocity.vx, actor->velocity.vy, actor->velocity.vz ); }; //~ // https://gamedevelopment.tutsplus.com/tutorials/how-to-create-a-custom-2d-physics-engine-the-basics-and-impulse-resolution--gamedev-6331 void ResolveCollision( BODY * one, BODY * two ){ //~ FntPrint("rv: %d, %d, %d\n", one->velocity.vx, one->velocity.vy, one->velocity.vz); // Calculate relative velocity VECTOR rv = { subVector( one->velocity, two->velocity) }; //~ FntPrint("rv: %d, %d, %d\n", rv.vx,rv.vy,rv.vz); // Collision normal VECTOR normal = { subVector( two->position, one->position ) }; // Normalize collision normal normal.vx = normal.vx > 0 ? 1 : normal.vx < 0 ? -1 : 0 ; normal.vy = normal.vy > 256 ? 1 : normal.vy < -256 ? -1 : 0 ; normal.vz = normal.vz > 0 ? 1 : normal.vz < 0 ? -1 : 0 ; //~ FntPrint("norm: %d, %d, %d\n", normal.vx,normal.vy,normal.vz); // Calculate relative velocity in terms of the normal direction long velAlongNormal = dotProduct( rv, normal ); //~ FntPrint("velN: %d\n", velAlongNormal); // Do not resolve if velocities are separating if(velAlongNormal > 0) return; // Calculate restitution long e = min( one->restitution, two->restitution ); //~ FntPrint("e: %d\n", e); //~ // Calculate impulse scalar long j = -(1 + e) * velAlongNormal * ONE; j /= one->invMass + two->invMass; //~ j /= ONE; //~ FntPrint("j: %d\n", j); // Apply impulse applyVector(&normal, j, j, j, *=); //~ FntPrint("Cnormal %d %d %d\n",normal.vx,normal.vy,normal.vz); VECTOR velOne = normal; VECTOR velTwo = normal; applyVector(&velOne,one->invMass,one->invMass,one->invMass, *=); applyVector(&velTwo,two->invMass,two->invMass,two->invMass, *=); //~ FntPrint("V1 %d %d %d\n", velOne.vx/4096,velOne.vy/4096,velOne.vz/4096); //~ FntPrint("V2 %d %d %d\n", velTwo.vx/4096,velTwo.vy/4096,velTwo.vz/4096); applyVector(&one->velocity, velOne.vx/4096/4096, velOne.vy/4096/4096, velOne.vz/4096/4096, +=); applyVector(&two->velocity, velTwo.vx/4096/4096, velTwo.vy/4096/4096, velTwo.vz/4096/4096, -=); //~ FntPrint("V1 %d %d %d\n", velOne.vx/4096/4096,velOne.vy/4096/4096,velOne.vz/4096/4096); //~ FntPrint("V2 %d %d %d\n", velTwo.vx/4096/4096,velTwo.vy/4096/4096,velTwo.vz/4096/4096); }; VECTOR angularMom(BODY body){ // L = r * p // p = m * v VECTOR w = {0,0,0,0}; int r = (body.max.vx - body.min.vx) >> 1; w.vx = (r * body.mass * body.velocity.vx) >> 2; w.vy = (r * body.mass * body.velocity.vy) >> 2; w.vz = (r * body.mass * body.velocity.vz) >> 2; //~ FntPrint("v: %d, r:%d, w:%d\n", body.velocity.vz * r, r * r, w.vz); return w; }; // From : https://github.com/grumpycoders/pcsx-redux/blob/7438e9995833db5bc1e14da735bbf9dc78300f0b/src/mips/shell/math.h static inline int32_t dMul(int32_t a, int32_t b) { long long r = a; r *= b; return r >> 24; }; // standard lerp function // s = source, an arbitrary number up to 2^24 // d = destination, an arbitrary number up to 2^24 // p = position, a number between 0 and 256, inclusive // p = 0 means output = s // p = 256 means output = d static inline uint32_t lerpU(uint32_t start, uint32_t dest, unsigned pos) { return (start * (256 - pos) + dest * pos) >> 8; }; static inline int32_t lerpS(int32_t start, int32_t dest, unsigned pos) { return (start * (256 - pos) + dest * pos) >> 8; }; // start, dest and pos have to be << x, then the result has to be >> x where x defines precision: // precision = 2^24 - 2^x // << x : 0 < pos < precision // https://discord.com/channels/642647820683444236/646765703143227394/811318550978494505 // my angles are between 0 and 2048 (full circle), so 2^11 for the range of angles; with numbers on a 8.24 representation, a 1.0 angle (or 2pi) means it's 2^24, so to "convert" my angles from 8.24 to my internal discrete cos, I only have to shift by 13 static inline int32_t lerpD(int32_t start, int32_t dest, int32_t pos) { return dMul(start, 16777216 - pos) + dMul(dest, pos); }; static inline long long lerpL(long long start, long long dest, long long pos){ return dMul( (start << 12), 16777216 - (pos << 12) ) + dMul((dest << 12), (pos << 12) ) >> 12; }; // A few notes on the following code : int ncos(unsigned int t) { t %= DC_2PI; int r; if (t < DC_PI2) { r = m_cosTable[t]; } else if (t < DC_PI) { r = -m_cosTable[DC_PI - 1 - t]; } else if (t < (DC_PI + DC_PI2)) { r = -m_cosTable[t - DC_PI]; } else { r = m_cosTable[DC_2PI - 1 - t]; }; return r >> 12; }; // sin(x) = cos(x - pi / 2) int nsin(unsigned int t) { t %= DC_2PI; if (t < DC_PI2){ return ncos(t + DC_2PI - DC_PI2); }; return ncos(t - DC_PI2); }; // f(n) = cos(n * 2pi / 2048) <- 2048 is == DC_2PI value // f(n) = 2 * f(1) * f(n - 1) - f(n - 2) void generateTable(void){ m_cosTable[0] = 16777216; // 2^24 * cos(0 * 2pi / 2048) => 2^24 * 1 = 2^24 : here, 2^24 defines the precision we want after the decimal point static const long long C = 16777137; // 2^24 * cos(1 * 2pi / 2048) = C = f(1); m_cosTable[1] = C; for (int i = 2; i < 512; i++){ m_cosTable[i] = ((C * m_cosTable[i - 1]) >> 23) - m_cosTable[i - 2]; m_cosTable[511] = 0; } }; // https://github.com/Arsunt/TR2Main/blob/411cacb35914c616cb7960c0e677e00c71c7ee88/3dsystem/phd_math.cpp#L432 long long patan(long x, long y){ long long result; int swapBuf; int flags = 0; // if either x or y are 0, return 0 if( x == 0 && y == 0){ return 0; } if( x < 0 ) { flags |= 4; x = -x; } if ( y < 0 ) { flags |= 2; y = -y; } if ( y > x ) { flags |= 1; SWAP(x, y ,swapBuf); } result = AtanBaseTable[flags] + AtanAngleTable[0x800 * y / x]; if ( result < 0 ){ result = -result; return result; } }; u_int psqrt(u_int n){ u_int result = 0; u_int base = 0x40000000; u_int basedResult; for( ; base != 0; base >>= 2 ) { for( ; base != 0; base >>= 2 ) { basedResult = base + result; result >>= 1; if( basedResult > n ) { break; } n -= basedResult; result |= base; } } return result; }; int cliptest3( short *v1 ) { if( v1[0]<0 && v1[2]<0 && v1[4]<0 ) return 0; if( v1[1]<0 && v1[3]<0 && v1[5]<0 ) return 0; if( v1[0] > SCREENXRES && v1[2] > SCREENXRES && v1[4] > SCREENXRES) return 0; if( v1[1] > SCREENYRES && v1[3] > SCREENYRES && v1[5] > SCREENYRES) return 0; return 1; }; void callback() { u_short pad = PadRead(0); static u_short lastPad; static short forceApplied = 0; int div = 4096 >> 7; static int lerpValues[4096 >> 7]; static short cursor = 0; //~ static short curCamAngle = 0; if( !lerpValues[0] ) { for ( long long i = 0; i < div ; i++ ){ lerpValues[(div-1)-i] = lerp(-24, -264, easeIn(i, div)); } } if( timer ) { timer--; } if( cursor>0 ) { cursor--; } if ( pad & PADR1 && !timer ) { if (!camPtr->tim_data){ if(camMode < 6){ camMode ++; lerping = 0; } else { setCameraPos(camPtr->campos->pos, camPtr->campos->rot); camPath.cursor = 0; camMode = 0; lerping = 0; } } else { if (curCamAngle > 4) { curCamAngle = 0; } if (curCamAngle < 5) { curCamAngle++; camPtr = camAngles[ curCamAngle ]; LoadTexture(camPtr->tim_data, camPtr->BGtim); } } lastPad = pad; timer = 10; } if ( !(pad & PADR1) && lastPad & PADR1 ) { //~ pressed = 0; } if ( pad & PADL2 ) { lgtang.vy += 32; } if ( pad & PADL1 ) { lgtang.vz += 32; } if ( pad & PADRup && !timer ){ if (*actorPtr->isPrism){ *actorPtr->isPrism = 0; } else { *actorPtr->isPrism = 1; } timer = 10; lastPad = pad; } if ( pad & PADRdown && !timer ){ //~ if (actorPtr->body->gForce.vy >= 0 && actorPtr->body->position.vy >= actorPtr->body->min.vy ){ //~ forceApplied -= 150; //~ } cursor = div - 15; timer = 30; lastPad = pad; } if ( !(pad & PADRdown) && lastPad & PADRdown ) { //~ lastPad = pad; } if ( pad & PADRleft && !timer ) { if (actorPtr->anim->interpolate){ actorPtr->anim->interpolate = 0; } else { actorPtr->anim->interpolate = 1; } timer = 10; lastPad = pad; } if ( pad & PADLup ) { actorPtr->body->gForce.vz = getVectorTo(fVecActor, *actorPtr->pos).vz >> 8 ; actorPtr->body->gForce.vx = -getVectorTo(fVecActor, *actorPtr->pos).vx >> 8 ; lastPad = pad; } if ( !(pad & PADLup) && lastPad & PADLup) { actorPtr->body->gForce.vz = 0; actorPtr->body->gForce.vx = 0; } if ( pad & PADLdown ) { actorPtr->body->gForce.vz = -getVectorTo(fVecActor, *actorPtr->pos).vz >> 8 ; actorPtr->body->gForce.vx = getVectorTo(fVecActor, *actorPtr->pos).vx >> 8 ; lastPad = pad; } if ( !(pad & PADLdown) && lastPad & PADLdown) { actorPtr->body->gForce.vz = 0; actorPtr->body->gForce.vx = 0; lastPad = pad; } if ( pad & PADLleft ) { actorPtr->rot->vy -= 32; lastPad = pad; } if ( pad & PADLright ) { actorPtr->rot->vy += 32; lastPad = pad; } if ( cursor ) { actorPtr->body->position.vy = lerpValues[cursor];} };