6711 lines
213 KiB
C
6711 lines
213 KiB
C
#include <ultra64.h>
|
|
#include "constants.h"
|
|
#include "game/prop.h"
|
|
#include "game/game_1531a0.h"
|
|
#include "game/bg.h"
|
|
#include "bss.h"
|
|
#include "lib/dma.h"
|
|
#include "lib/memp.h"
|
|
#include "lib/mtx.h"
|
|
#include "lib/lib_17ce0.h"
|
|
#include "lib/anim.h"
|
|
#include "lib/collision.h"
|
|
#include "lib/lib_2f490.h"
|
|
#include "lib/libc/ll.h"
|
|
#include "data.h"
|
|
#include "types.h"
|
|
|
|
union filedataptr g_TileFileData;
|
|
s32 g_TileNumRooms;
|
|
u32 *g_TileRooms;
|
|
s32 var8009a8ac;
|
|
f32 var8009a8b0;
|
|
s32 var8009a8b4;
|
|
struct coord var8009a8b8;
|
|
s32 var8009a8c4;
|
|
struct coord var8009a8c8;
|
|
struct prop *g_CdObstacle;
|
|
s32 var8009a8d8;
|
|
s32 var8009a8dc;
|
|
struct coord g_CdPos;
|
|
s32 var8009a8ec;
|
|
f32 var8009a8f0;
|
|
bool var8009a8f4;
|
|
struct coord var8009a8f8;
|
|
s32 var8009a904;
|
|
struct coord var8009a908;
|
|
s32 var8009a914;
|
|
struct geoblock var8009a918;
|
|
struct geo *var8009a964;
|
|
s32 var8009a968;
|
|
s32 var8009a96c;
|
|
|
|
s32 var8005f030 = 0;
|
|
s32 var8005f034 = 0;
|
|
s32 var8005f038 = 0;
|
|
|
|
f32 cd00024e40(void)
|
|
{
|
|
return var8009a8f0;
|
|
}
|
|
|
|
void cd00024e4c(struct coord *a, struct coord *b, u32 line, char *file)
|
|
{
|
|
a->x = var8009a8b8.x;
|
|
a->y = var8009a8b8.y;
|
|
a->z = var8009a8b8.z;
|
|
|
|
b->x = var8009a8c8.x;
|
|
b->y = var8009a8c8.y;
|
|
b->z = var8009a8c8.z;
|
|
}
|
|
|
|
f32 cd00024e98(void)
|
|
{
|
|
return var8009a8b0;
|
|
}
|
|
|
|
s32 cd00024ea4(void)
|
|
{
|
|
return var8009a8ac;
|
|
}
|
|
|
|
struct prop *cdGetObstacle(void)
|
|
{
|
|
return g_CdObstacle;
|
|
}
|
|
|
|
void cdGetPos(struct coord *pos, u32 line, char *file)
|
|
{
|
|
pos->x = g_CdPos.x;
|
|
pos->y = g_CdPos.y;
|
|
pos->z = g_CdPos.z;
|
|
}
|
|
|
|
void cd00024ee8(struct coord *arg0)
|
|
{
|
|
cd00025928(var8009a964, arg0);
|
|
}
|
|
|
|
u32 cdGetTileFlags(void)
|
|
{
|
|
u32 flags = 0;
|
|
|
|
switch (var8009a964->type) {
|
|
case GEOTYPE_TILE_I:
|
|
flags = var8009a964->flags;
|
|
break;
|
|
case GEOTYPE_TILE_F:
|
|
flags = var8009a964->flags;
|
|
break;
|
|
case GEOTYPE_BLOCK:
|
|
flags = GEOFLAG_COLLISIONS | GEOFLAG_0008 | GEOFLAG_OPAQUE;
|
|
break;
|
|
case GEOTYPE_CYL:
|
|
flags = var8009a964->flags;
|
|
break;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
void cd00024f6c(void)
|
|
{
|
|
var8009a8b4 = 0;
|
|
var8009a8ac = 0;
|
|
g_CdObstacle = NULL;
|
|
var8009a8d8 = 0;
|
|
var8009a8ec = 0;
|
|
var8009a8f4 = false;
|
|
var8005f034 = 0;
|
|
var8005f038 = 0;
|
|
}
|
|
|
|
void cd00024fb0(struct coord *arg0, struct coord *arg1, struct prop *prop)
|
|
{
|
|
var8009a8b8.x = arg0->x;
|
|
var8009a8b8.y = arg0->y;
|
|
var8009a8b8.z = arg0->z;
|
|
|
|
var8009a8c8.x = arg1->x;
|
|
var8009a8c8.y = arg1->y;
|
|
var8009a8c8.z = arg1->z;
|
|
|
|
var8009a8b4 = 1;
|
|
var8009a8ac = 0;
|
|
g_CdObstacle = prop;
|
|
var8009a8d8 = 0;
|
|
var8009a8ec = 0;
|
|
var8009a8f4 = false;
|
|
var8005f034 = 0;
|
|
var8005f038 = 0;
|
|
}
|
|
|
|
void cd00025038(struct coord *arg0, struct coord *arg1, struct prop *prop, f32 arg3)
|
|
{
|
|
var8009a8b0 = arg3;
|
|
|
|
var8009a8b8.x = arg0->x;
|
|
var8009a8b8.y = arg0->y;
|
|
var8009a8b8.z = arg0->z;
|
|
|
|
var8009a8c8.x = arg1->x;
|
|
var8009a8c8.y = arg1->y;
|
|
var8009a8c8.z = arg1->z;
|
|
|
|
var8009a8b4 = 1;
|
|
var8009a8ac = 1;
|
|
g_CdObstacle = prop;
|
|
var8009a8d8 = 0;
|
|
var8009a8ec = 0;
|
|
var8009a8f4 = 0;
|
|
var8005f034 = 0;
|
|
var8005f038 = 0;
|
|
}
|
|
|
|
void cd000250cc(struct coord *arg0, struct coord *arg1, f32 width)
|
|
{
|
|
f32 sp38[2];
|
|
f32 sp34;
|
|
f32 sp2c[2];
|
|
f32 sp24[2];
|
|
f32 sp1c[2];
|
|
|
|
sp34 = width;
|
|
|
|
sp38[0] = arg0->x;
|
|
sp38[1] = arg0->z;
|
|
|
|
sp1c[0] = arg1->x;
|
|
sp1c[1] = arg1->z;
|
|
|
|
sp2c[0] = var8009a8b8.x;
|
|
sp2c[1] = var8009a8b8.z;
|
|
|
|
sp24[0] = var8009a8c8.x;
|
|
sp24[1] = var8009a8c8.z;
|
|
|
|
var8009a8b0 = func0f1579cc(&sp34, sp2c, sp24, sp1c);
|
|
var8009a8ac = 1;
|
|
}
|
|
|
|
void cd00025168(struct prop *prop)
|
|
{
|
|
var8009a8b4 = 0;
|
|
var8009a8ac = 0;
|
|
g_CdObstacle = prop;
|
|
var8009a8d8 = 0;
|
|
var8009a8ec = 0;
|
|
var8009a8f4 = false;
|
|
var8005f034 = 0;
|
|
var8005f038 = 0;
|
|
}
|
|
|
|
void cd000251ac(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct prop *prop)
|
|
{
|
|
var8009a8b8.x = arg0->x;
|
|
var8009a8b8.y = arg0->y;
|
|
var8009a8b8.z = arg0->z;
|
|
|
|
var8009a8c8.x = arg1->x;
|
|
var8009a8c8.y = arg1->y;
|
|
var8009a8c8.z = arg1->z;
|
|
|
|
g_CdPos.x = arg2->x;
|
|
g_CdPos.y = arg2->y;
|
|
g_CdPos.z = arg2->z;
|
|
|
|
var8009a8b4 = 1;
|
|
var8009a8ac = 0;
|
|
g_CdObstacle = prop;
|
|
var8009a8d8 = 1;
|
|
var8009a8ec = 0;
|
|
var8009a8f4 = 0;
|
|
var8005f034 = 0;
|
|
var8005f038 = 0;
|
|
}
|
|
|
|
void cd00025254(struct coord *arg0, struct coord *arg1, struct coord *pos, struct prop *prop, f32 arg4, struct geo *geo)
|
|
{
|
|
var8009a8b8.x = arg0->x;
|
|
var8009a8b8.y = arg0->y;
|
|
var8009a8b8.z = arg0->z;
|
|
|
|
var8009a8c8.x = arg1->x;
|
|
var8009a8c8.y = arg1->y;
|
|
var8009a8c8.z = arg1->z;
|
|
|
|
g_CdPos.x = pos->x;
|
|
g_CdPos.y = pos->y;
|
|
g_CdPos.z = pos->z;
|
|
|
|
var8009a8b4 = 1;
|
|
var8009a8ac = 0;
|
|
g_CdObstacle = prop;
|
|
var8009a8d8 = 1;
|
|
var8009a8f0 = arg4;
|
|
var8009a8ec = 1;
|
|
var8009a8f4 = false;
|
|
var8005f034 = 0;
|
|
var8009a964 = geo;
|
|
var8005f038 = 1;
|
|
}
|
|
|
|
void cd00025314(struct coord *arg0, struct coord *arg1)
|
|
{
|
|
var8009a8f8.x = arg0->x;
|
|
var8009a8f8.y = arg0->y;
|
|
var8009a8f8.z = arg0->z;
|
|
|
|
var8009a908.x = arg1->x;
|
|
var8009a908.y = arg1->y;
|
|
var8009a908.z = arg1->z;
|
|
|
|
var8009a8f4 = true;
|
|
}
|
|
|
|
bool cd00025364(struct coord *arg0, struct coord *arg1)
|
|
{
|
|
if (var8009a8f4) {
|
|
arg0->x = var8009a8f8.x;
|
|
arg0->y = var8009a8f8.y;
|
|
arg0->z = var8009a8f8.z;
|
|
|
|
arg1->x = var8009a908.x;
|
|
arg1->y = var8009a908.y;
|
|
arg1->z = var8009a908.z;
|
|
}
|
|
|
|
return var8009a8f4;
|
|
}
|
|
|
|
void cd000253c4(struct geoblock *block)
|
|
{
|
|
var8009a918 = *block;
|
|
var8005f034 = true;
|
|
}
|
|
|
|
s32 cd00025410(f32 arg0, f32 arg1, f32 arg2, f32 arg3)
|
|
{
|
|
f32 f0 = arg0 * arg3;
|
|
f32 f2 = arg1 * arg2;
|
|
|
|
if (f2 < f0) {
|
|
return 1;
|
|
}
|
|
|
|
if (f2 > f0) {
|
|
return -1;
|
|
}
|
|
|
|
if (arg0 * arg2 < 0.0f || arg1 * arg3 < 0.0f) {
|
|
return -1;
|
|
}
|
|
|
|
if (arg0 * arg0 + arg1 * arg1 < arg2 * arg2 + arg3 * arg3) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 cd000254d8(struct coord *arg0, struct coord *arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, s32 *arg6)
|
|
{
|
|
f32 sp54;
|
|
f32 sp50;
|
|
f32 sp4c;
|
|
f32 sp48;
|
|
s32 sp44;
|
|
s32 sp40;
|
|
s32 sp3c;
|
|
s32 sp38;
|
|
s32 sp34;
|
|
s32 sp30;
|
|
bool result = false;
|
|
|
|
sp54 = arg0->x - arg2;
|
|
sp50 = arg0->z - arg3;
|
|
|
|
sp3c = cd00025410(arg4 - arg2, arg5 - arg3, sp54, sp50);
|
|
sp44 = cd00025410(arg4 - arg2, arg5 - arg3, arg1->x - arg2, arg1->z - arg3);
|
|
sp38 = sp3c * sp44;
|
|
|
|
if (sp38 <= 0) {
|
|
sp4c = arg1->x - arg0->x;
|
|
sp48 = arg1->z - arg0->z;
|
|
|
|
sp34 = cd00025410(sp4c, sp48, -sp54, -sp50);
|
|
sp40 = cd00025410(sp4c, sp48, arg4 - arg0->x, arg5 - arg0->z);
|
|
sp30 = sp34 * sp40;
|
|
|
|
if (sp30 <= 0) {
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
if (*arg6 && (result || sp3c <= 0)) {
|
|
*arg6 = 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
f32 cd00025654(f32 x1, f32 z1, f32 x2, f32 z2, f32 x3, f32 z3)
|
|
{
|
|
u32 stack[8];
|
|
f32 result;
|
|
|
|
result = sqrtf((x2 - x1) * (x2 - x1) + (z2 - z1) * (z2 - z1));
|
|
|
|
if (result == 0.0f) {
|
|
return sqrtf((x3 - x2) * (x3 - x2) + (z3 - z2) * (z3 - z2));
|
|
}
|
|
|
|
return ((x3 - x1) * (z2 - z1) + -(x2 - x1) * (z3 - z1)) / result;
|
|
}
|
|
|
|
f32 cd00025724(f32 x1, f32 z1, f32 x2, f32 z2)
|
|
{
|
|
x2 -= x1;
|
|
z2 -= z1;
|
|
|
|
return sqrtf(x2 * x2 + z2 * z2);
|
|
}
|
|
|
|
bool cd00025774(f32 x1, f32 z1, f32 x2, f32 z2, f32 x3, f32 z3)
|
|
{
|
|
f32 f0;
|
|
f32 f2;
|
|
f32 f16;
|
|
f32 f18;
|
|
|
|
x3 -= x1;
|
|
z3 -= z1;
|
|
|
|
f0 = x2 - x1;
|
|
f2 = z2 - z1;
|
|
|
|
f16 = x3 * f0 + z3 * f2;
|
|
f18 = f0 * f0 + f2 * f2;
|
|
|
|
return (f18 < f16 && f16 < 0) || (f16 > 0 && f16 < f18);
|
|
}
|
|
|
|
void cd00025848(f32 tilex, f32 tilez, f32 tilewidth, f32 posx, f32 posz, f32 *x1, f32 *z1, f32 *x2, f32 *z2)
|
|
{
|
|
posx -= tilex;
|
|
posz -= tilez;
|
|
|
|
if (posx != 0 || posz != 0) {
|
|
f32 dist = sqrtf(posx * posx + posz * posz);
|
|
|
|
if (dist > 0) {
|
|
dist = tilewidth / dist;
|
|
posx *= dist;
|
|
posz *= dist;
|
|
}
|
|
}
|
|
|
|
*x1 = tilex + posx + posz;
|
|
*z1 = tilez + posz - posx;
|
|
*x2 = tilex + posx - posz;
|
|
*z2 = tilez + posz + posx;
|
|
}
|
|
|
|
void cd00025928(struct geo *geo, struct coord *arg1)
|
|
{
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile0 = (struct geotilei *) geo;
|
|
s32 sp38[3];
|
|
s32 sp2c[3];
|
|
s32 sp20[3];
|
|
|
|
sp38[0] = tile0->vertices[1][0] - tile0->vertices[0][0];
|
|
sp38[1] = tile0->vertices[1][1] - tile0->vertices[0][1];
|
|
sp38[2] = tile0->vertices[1][2] - tile0->vertices[0][2];
|
|
|
|
sp2c[0] = tile0->vertices[2][0] - tile0->vertices[0][0];
|
|
sp2c[1] = tile0->vertices[2][1] - tile0->vertices[0][1];
|
|
sp2c[2] = tile0->vertices[2][2] - tile0->vertices[0][2];
|
|
|
|
sp20[0] = sp38[1] * sp2c[2] - sp38[2] * sp2c[1];
|
|
sp20[1] = sp38[2] * sp2c[0] - sp38[0] * sp2c[2];
|
|
sp20[2] = sp38[0] * sp2c[1] - sp38[1] * sp2c[0];
|
|
|
|
arg1->x = sp20[0];
|
|
arg1->y = sp20[1];
|
|
arg1->z = sp20[2];
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *tile1 = (struct geotilef *) geo;
|
|
f32 sp10[3];
|
|
f32 sp04[3];
|
|
|
|
sp10[0] = tile1->vertices[1].x - tile1->vertices[0].x;
|
|
sp10[1] = tile1->vertices[1].y - tile1->vertices[0].y;
|
|
sp10[2] = tile1->vertices[1].z - tile1->vertices[0].z;
|
|
|
|
sp04[0] = tile1->vertices[2].x - tile1->vertices[0].x;
|
|
sp04[1] = tile1->vertices[2].y - tile1->vertices[0].y;
|
|
sp04[2] = tile1->vertices[2].z - tile1->vertices[0].z;
|
|
|
|
arg1->x = sp10[1] * sp04[2] - sp10[2] * sp04[1];
|
|
arg1->y = sp10[2] * sp04[0] - sp10[0] * sp04[2];
|
|
arg1->z = sp10[0] * sp04[1] - sp10[1] * sp04[0];
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
arg1->x = 0;
|
|
arg1->y = 1;
|
|
arg1->z = 0;
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
arg1->x = 0;
|
|
arg1->y = 1;
|
|
arg1->z = 0;
|
|
}
|
|
}
|
|
|
|
void cdGetFloorCol(struct geo *geo, u16 *floorcol)
|
|
{
|
|
if (geo == NULL) {
|
|
*floorcol = 0xfff;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile0 = (struct geotilei *) geo;
|
|
*floorcol = tile0->floorcol;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *tile1 = (struct geotilef *) geo;
|
|
*floorcol = tile1->floorcol;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_BLOCK) {
|
|
*floorcol = 0xfff;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_CYL) {
|
|
*floorcol = 0xfff;
|
|
}
|
|
}
|
|
|
|
void cdGetFloorType(struct geo *geo, u8 *floortype)
|
|
{
|
|
bool water = false;
|
|
|
|
if (geo && (geo->flags & GEOFLAG_UNDERWATER)) {
|
|
water = true;
|
|
}
|
|
|
|
if (geo == NULL) {
|
|
*floortype = 0xff;
|
|
return;
|
|
}
|
|
|
|
if (water) {
|
|
*floortype = FLOORTYPE_WATER;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile0 = (struct geotilei *) geo;
|
|
*floortype = tile0->floortype;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *tile1 = (struct geotilef *) geo;
|
|
*floortype = tile1->floortype;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_BLOCK) {
|
|
*floortype = 0xff;
|
|
return;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_CYL) {
|
|
*floortype = 0xff;
|
|
}
|
|
}
|
|
|
|
f32 cdFindGroundInIntTileAtVertex(struct geotilei *tile, f32 x, f32 z, s32 vertexindex)
|
|
{
|
|
struct coord sp7c;
|
|
struct coord sp70;
|
|
s64 sp68;
|
|
s64 sp60;
|
|
s64 sp58;
|
|
s64 tmp;
|
|
f32 ground;
|
|
s32 next;
|
|
|
|
if (vertexindex == 0) {
|
|
vertexindex = 1;
|
|
}
|
|
|
|
next = (vertexindex + 1) % tile->header.numvertices;
|
|
|
|
if (next == 0) {
|
|
next = 1;
|
|
}
|
|
|
|
sp7c.x = tile->vertices[vertexindex][0] - tile->vertices[0][0];
|
|
sp7c.y = tile->vertices[vertexindex][1] - tile->vertices[0][1];
|
|
sp7c.z = tile->vertices[vertexindex][2] - tile->vertices[0][2];
|
|
|
|
sp70.x = tile->vertices[next][0] - tile->vertices[0][0];
|
|
sp70.y = tile->vertices[next][1] - tile->vertices[0][1];
|
|
sp70.z = tile->vertices[next][2] - tile->vertices[0][2];
|
|
|
|
sp58 = sp7c.f[1] * sp70.f[2] - sp7c.f[2] * sp70.f[1];
|
|
sp60 = sp7c.f[2] * sp70.f[0] - sp7c.f[0] * sp70.f[2];
|
|
sp68 = sp7c.f[0] * sp70.f[1] - sp7c.f[1] * sp70.f[0];
|
|
|
|
tmp = sp58 * tile->vertices[0][0]
|
|
+ sp60 * tile->vertices[0][1]
|
|
+ sp68 * tile->vertices[0][2];
|
|
|
|
if (sp60 == 0) {
|
|
return *(s16 *)(tile->ymax + (u32)tile);
|
|
}
|
|
|
|
ground = (tmp - (f64)x * sp58 - (f64)z * sp68) / sp60;
|
|
|
|
if (ground > *(s16 *)(tile->ymax + (u32)tile)) {
|
|
ground = *(s16 *)(tile->ymax + (u32)tile);
|
|
} else if (ground < *(s16 *)(tile->ymin + (u32)tile)) {
|
|
ground = *(s16 *)(tile->ymin + (u32)tile);
|
|
}
|
|
|
|
return ground;
|
|
}
|
|
|
|
#if VERSION < VERSION_NTSC_1_0
|
|
f32 cdFindGroundInTileType0AtVertex1(struct geotilei *tile, f32 x, f32 z)
|
|
{
|
|
return cdFindGroundInIntTileAtVertex(tile, x, z, 1);
|
|
}
|
|
#endif
|
|
|
|
GLOBAL_ASM(
|
|
glabel cdFindGroundInIntTile
|
|
/* 25f90: 27bdffd8 */ addiu $sp,$sp,-40
|
|
/* 25f94: f7b40010 */ sdc1 $f20,0x10($sp)
|
|
/* 25f98: 4485a000 */ mtc1 $a1,$f20
|
|
/* 25f9c: afbf0024 */ sw $ra,0x24($sp)
|
|
/* 25fa0: f7b60018 */ sdc1 $f22,0x18($sp)
|
|
/* 25fa4: 90850001 */ lbu $a1,0x1($a0)
|
|
/* 25fa8: 4486b000 */ mtc1 $a2,$f22
|
|
/* 25fac: 24070001 */ addiu $a3,$zero,0x1
|
|
/* 25fb0: 28a10004 */ slti $at,$a1,0x4
|
|
/* 25fb4: 1420003c */ bnez $at,.L000260a8
|
|
/* 25fb8: 2403ffff */ addiu $v1,$zero,-1
|
|
/* 25fbc: 28a10002 */ slti $at,$a1,0x2
|
|
/* 25fc0: 14200039 */ bnez $at,.L000260a8
|
|
/* 25fc4: 00077880 */ sll $t7,$a3,0x2
|
|
/* 25fc8: 848e0012 */ lh $t6,0x12($a0)
|
|
/* 25fcc: 8498000e */ lh $t8,0xe($a0)
|
|
/* 25fd0: 01e77823 */ subu $t7,$t7,$a3
|
|
/* 25fd4: 448e2000 */ mtc1 $t6,$f4
|
|
/* 25fd8: 44983000 */ mtc1 $t8,$f6
|
|
/* 25fdc: 000f7840 */ sll $t7,$t7,0x1
|
|
/* 25fe0: 44807000 */ mtc1 $zero,$f14
|
|
/* 25fe4: 008f1021 */ addu $v0,$a0,$t7
|
|
/* 25fe8: 46802420 */ cvt.s.w $f16,$f4
|
|
/* 25fec: 468034a0 */ cvt.s.w $f18,$f6
|
|
.L00025ff0:
|
|
/* 25ff0: 84590012 */ lh $t9,0x12($v0)
|
|
/* 25ff4: 8448000e */ lh $t0,0xe($v0)
|
|
/* 25ff8: 44994000 */ mtc1 $t9,$f8
|
|
/* 25ffc: 44885000 */ mtc1 $t0,$f10
|
|
/* 26000: 46804020 */ cvt.s.w $f0,$f8
|
|
/* 26004: 468050a0 */ cvt.s.w $f2,$f10
|
|
/* 26008: 46008101 */ sub.s $f4,$f16,$f0
|
|
/* 2600c: 4602a181 */ sub.s $f6,$f20,$f2
|
|
/* 26010: 4600b281 */ sub.s $f10,$f22,$f0
|
|
/* 26014: 46062202 */ mul.s $f8,$f4,$f6
|
|
/* 26018: 46029101 */ sub.s $f4,$f18,$f2
|
|
/* 2601c: 46045182 */ mul.s $f6,$f10,$f4
|
|
/* 26020: 46064301 */ sub.s $f12,$f8,$f6
|
|
/* 26024: 460e6032 */ c.eq.s $f12,$f14
|
|
/* 26028: 00000000 */ nop
|
|
/* 2602c: 4503001b */ bc1tl .L0002609c
|
|
/* 26030: 24e70001 */ addiu $a3,$a3,0x1
|
|
/* 26034: 04610008 */ bgez $v1,.L00026058
|
|
/* 26038: 00000000 */ nop
|
|
/* 2603c: 460c703c */ c.lt.s $f14,$f12
|
|
/* 26040: 00001825 */ or $v1,$zero,$zero
|
|
/* 26044: 45020015 */ bc1fl .L0002609c
|
|
/* 26048: 24e70001 */ addiu $a3,$a3,0x1
|
|
/* 2604c: 24030001 */ addiu $v1,$zero,0x1
|
|
/* 26050: 10000012 */ b .L0002609c
|
|
/* 26054: 24e70001 */ addiu $a3,$a3,0x1
|
|
.L00026058:
|
|
/* 26058: 10600007 */ beqz $v1,.L00026078
|
|
/* 2605c: 00000000 */ nop
|
|
/* 26060: 460e603c */ c.lt.s $f12,$f14
|
|
/* 26064: 00000000 */ nop
|
|
/* 26068: 45000003 */ bc1f .L00026078
|
|
/* 2606c: 00000000 */ nop
|
|
/* 26070: 1000000d */ b .L000260a8
|
|
/* 26074: 24e7ffff */ addiu $a3,$a3,-1
|
|
.L00026078:
|
|
/* 26078: 54600008 */ bnezl $v1,.L0002609c
|
|
/* 2607c: 24e70001 */ addiu $a3,$a3,0x1
|
|
/* 26080: 460c703c */ c.lt.s $f14,$f12
|
|
/* 26084: 00000000 */ nop
|
|
/* 26088: 45020004 */ bc1fl .L0002609c
|
|
/* 2608c: 24e70001 */ addiu $a3,$a3,0x1
|
|
/* 26090: 10000005 */ b .L000260a8
|
|
/* 26094: 24e7ffff */ addiu $a3,$a3,-1
|
|
/* 26098: 24e70001 */ addiu $a3,$a3,0x1
|
|
.L0002609c:
|
|
/* 2609c: 00e5082a */ slt $at,$a3,$a1
|
|
/* 260a0: 1420ffd3 */ bnez $at,.L00025ff0
|
|
/* 260a4: 24420006 */ addiu $v0,$v0,0x6
|
|
.L000260a8:
|
|
/* 260a8: 4405a000 */ mfc1 $a1,$f20
|
|
/* 260ac: 4406b000 */ mfc1 $a2,$f22
|
|
/* 260b0: 0c00971d */ jal cdFindGroundInIntTileAtVertex
|
|
/* 260b4: 00000000 */ nop
|
|
/* 260b8: 8fbf0024 */ lw $ra,0x24($sp)
|
|
/* 260bc: d7b40010 */ ldc1 $f20,0x10($sp)
|
|
/* 260c0: d7b60018 */ ldc1 $f22,0x18($sp)
|
|
/* 260c4: 03e00008 */ jr $ra
|
|
/* 260c8: 27bd0028 */ addiu $sp,$sp,0x28
|
|
);
|
|
|
|
// Mismatch: regalloc, and operators for second mult are swapped
|
|
//f32 cdFindGroundInIntTile(struct geotilei *tile, f32 x, f32 z)
|
|
//{
|
|
// s32 i = 1;
|
|
// s32 ival = -1;
|
|
// f32 tmpx;
|
|
// f32 tmpz;
|
|
// f32 fval;
|
|
//
|
|
// if (tile->header.numvertices >= 4) {
|
|
// while (i < tile->header.numvertices) { \
|
|
// tmpz = tile->vertices[i][2];
|
|
// tmpx = tile->vertices[i][0];
|
|
//
|
|
// fval =
|
|
// (tile->vertices[0][2] - tmpz) * (x - tmpx) -
|
|
// (tile->vertices[0][0] - tmpx) * (z - tmpz);
|
|
//
|
|
// if (fval != 0) {
|
|
// if (ival < 0) {
|
|
// ival = (fval > 0);
|
|
// } else if (ival != 0 && fval < 0) {
|
|
// i--;
|
|
// break;
|
|
// } else if (ival == 0 && fval > 0) {
|
|
// i--;
|
|
// break;
|
|
// }
|
|
// }
|
|
//
|
|
// i++;
|
|
// }
|
|
// }
|
|
//
|
|
// return cdFindGroundInIntTileAtVertex(tile, x, z, i);
|
|
//}
|
|
|
|
f32 cdFindGroundInFltTile(struct geotilef *tile, f32 x, f32 z)
|
|
{
|
|
struct coord sp24;
|
|
struct coord sp18;
|
|
struct coord sp0c;
|
|
f32 tmp;
|
|
f32 ground;
|
|
|
|
sp24.x = tile->vertices[1].x - tile->vertices[0].x;
|
|
sp24.y = tile->vertices[1].y - tile->vertices[0].y;
|
|
sp24.z = tile->vertices[1].z - tile->vertices[0].z;
|
|
|
|
sp18.x = tile->vertices[2].x - tile->vertices[0].x;
|
|
sp18.y = tile->vertices[2].y - tile->vertices[0].y;
|
|
sp18.z = tile->vertices[2].z - tile->vertices[0].z;
|
|
|
|
sp0c.x = sp24.f[1] * sp18.f[2] - sp24.f[2] * sp18.f[1];
|
|
sp0c.y = sp24.f[2] * sp18.f[0] - sp24.f[0] * sp18.f[2];
|
|
sp0c.z = sp24.f[0] * sp18.f[1] - sp24.f[1] * sp18.f[0];
|
|
|
|
tmp = sp0c.f[0] * tile->vertices[0].f[0]
|
|
+ sp0c.f[1] * tile->vertices[0].f[1]
|
|
+ sp0c.f[2] * tile->vertices[0].f[2];
|
|
|
|
if (sp0c.f[1] == 0) {
|
|
return tile->vertices[tile->ymax].y;
|
|
}
|
|
|
|
ground = (tmp - (f64)x * (f64)sp0c.f[0] - (f64)z * (f64)sp0c.f[2]) / (f64)sp0c.f[1];
|
|
|
|
if (ground > tile->vertices[tile->ymax].y) {
|
|
ground = tile->vertices[tile->ymax].y;
|
|
} else if (ground < tile->vertices[tile->ymin].y) {
|
|
ground = tile->vertices[tile->ymin].y;
|
|
}
|
|
|
|
return ground;
|
|
}
|
|
|
|
bool cdIs2dPointInIntTile(struct geotilei *tile, f32 x, f32 z)
|
|
{
|
|
s32 result = -1;
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 i;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
|
|
f32 value = ((f32)tile->vertices[next][2] - (f32)tile->vertices[i][2]) * (x - tile->vertices[i][0])
|
|
- ((f32)tile->vertices[next][0] - (f32)tile->vertices[i][0]) * (z - tile->vertices[i][2]);
|
|
|
|
if (value != 0) {
|
|
if (i == 0 || result < 0) {
|
|
result = (value > 0);
|
|
} else {
|
|
if (result != 0 && value < 0) {
|
|
return false;
|
|
}
|
|
|
|
if (result == 0 && value > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result < 0) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cdIs2dPointInFltTile(struct geotilef *tile, f32 x, f32 z)
|
|
{
|
|
s32 result = -1;
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 i;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
|
|
f32 value = (tile->vertices[next].z - tile->vertices[i].z) * (x - tile->vertices[i].x)
|
|
- (tile->vertices[next].x - tile->vertices[i].x) * (z - tile->vertices[i].z);
|
|
|
|
if (value != 0) {
|
|
if (i == 0 || result < 0) {
|
|
result = (value > 0);
|
|
} else {
|
|
if (result != 0 && value < 0) {
|
|
return false;
|
|
}
|
|
|
|
if (result == 0 && value > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result < 0) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cdIs2dPointInBlock(struct geoblock *tile, f32 x, f32 z)
|
|
{
|
|
s32 result = -1;
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 i;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
|
|
f32 value = (tile->vertices[next][1] - tile->vertices[i][1]) * (x - tile->vertices[i][0])
|
|
- (tile->vertices[next][0] - tile->vertices[i][0]) * (z - tile->vertices[i][1]);
|
|
|
|
if (value != 0) {
|
|
if (i == 0 || result < 0) {
|
|
result = (value > 0);
|
|
} else {
|
|
if (result != 0 && value < 0) {
|
|
return false;
|
|
}
|
|
|
|
if (result == 0 && value > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result < 0) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cdIs2dPointInCyl(struct geocyl *cyl, f32 x, f32 z)
|
|
{
|
|
f32 xdiff = x - cyl->x;
|
|
f32 zdiff = z - cyl->z;
|
|
|
|
return xdiff * xdiff + zdiff * zdiff <= cyl->radius * cyl->radius;
|
|
}
|
|
|
|
bool func000266a4(f32 x, f32 z, struct geo *geo)
|
|
{
|
|
if (geo == NULL) {
|
|
return false;
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_BLOCK) {
|
|
return cdIs2dPointInBlock((struct geoblock *) geo, x, z);
|
|
}
|
|
|
|
if (geo->type == GEOTYPE_CYL) {
|
|
return cdIs2dPointInCyl((struct geocyl *) geo, x, z);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* For a lift or escalator step, find the props which are riding on it.
|
|
*/
|
|
void cdGetPropsOnPlatform(struct prop *platform, s16 *propnums, s32 maxlen)
|
|
{
|
|
u8 *start;
|
|
u8 *end;
|
|
s16 roompropnums[257];
|
|
struct prop *prop;
|
|
s16 *roompropnumptr;
|
|
struct geo *geo;
|
|
s32 len = 0;
|
|
|
|
if (propUpdateGeometry(platform, &start, &end)) {
|
|
roomGetProps(platform->rooms, roompropnums, 256);
|
|
roompropnumptr = roompropnums;
|
|
|
|
while (*roompropnumptr >= 0) {
|
|
prop = &g_Vars.props[*roompropnumptr];
|
|
|
|
if (prop != platform) {
|
|
geo = (struct geo *) start;
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *) geo;
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geotilei) + sizeof(tile->vertices[0]) * (tile->header.numvertices - ARRAYCOUNT(tile->vertices)));
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *type1 = (struct geotilef *) geo;
|
|
struct coord *pos = &prop->pos;
|
|
|
|
if ((geo->flags & (GEOFLAG_0001 | GEOFLAG_0002))
|
|
&& pos->x >= type1->vertices[type1->xmin].x
|
|
&& pos->x <= type1->vertices[type1->xmax].x
|
|
&& pos->z >= type1->vertices[type1->zmin].z
|
|
&& pos->z <= type1->vertices[type1->zmax].z
|
|
&& pos->y >= type1->vertices[type1->ymin].y
|
|
&& cdIs2dPointInFltTile(type1, pos->x, pos->z)
|
|
&& pos->y >= cdFindGroundInFltTile(type1, pos->x, pos->z)) {
|
|
break;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geotilef) + sizeof(struct coord) * (type1->header.numvertices - ARRAYCOUNT(type1->vertices)));
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geoblock));
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geocyl));
|
|
}
|
|
}
|
|
|
|
if (geo < (struct geo *) end) {
|
|
if (len < maxlen - 2) {
|
|
propnums[len] = *roompropnumptr;
|
|
len++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
roompropnumptr++;
|
|
}
|
|
}
|
|
|
|
propnums[len] = -1;
|
|
}
|
|
|
|
#if VERSION < VERSION_NTSC_1_0
|
|
void cdSetPropYBounds(struct prop *prop, f32 ymax, f32 ymin)
|
|
{
|
|
u8 *start;
|
|
u8 *end;
|
|
|
|
if (propUpdateGeometry(prop, &start, &end)) {
|
|
struct geo *geo = (struct geo *) start;
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *) geo;
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geotilei) + sizeof(tile->vertices[0]) * (tile->header.numvertices - ARRAYCOUNT(tile->vertices)));
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *type1 = (struct geotilef *) geo;
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geotilef) + sizeof(struct coord) * (type1->header.numvertices - ARRAYCOUNT(type1->vertices)));
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
struct geoblock *block = (struct geoblock *) geo;
|
|
block->ymax = ymax;
|
|
block->ymin = ymin;
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geoblock));
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
struct geocyl *cyl = (struct geocyl *) geo;
|
|
cyl->ymax = ymax;
|
|
cyl->ymin = ymin;
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geocyl));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
bool cd00026a04(struct coord *pos, u8 *start, u8 *end, u16 flags, s32 room, struct geo **tileptr, s32 *roomptr, f32 *groundptr, bool arg8)
|
|
{
|
|
bool result = false;
|
|
struct geo *geo = (struct geo *) start;
|
|
|
|
if (room);
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *) geo;
|
|
|
|
if ((geo->flags & flags)
|
|
&& pos->x >= *(s16 *)(tile->xmin + (u32)tile)
|
|
&& pos->x <= *(s16 *)(tile->xmax + (u32)tile)
|
|
&& pos->z >= *(s16 *)(tile->zmin + (u32)tile)
|
|
&& pos->z <= *(s16 *)(tile->zmax + (u32)tile)) {
|
|
if ((!arg8 && pos->y >= *(s16 *)(tile->ymin + (u32)tile))
|
|
|| (arg8 && pos->y <= *(s16 *)(tile->ymax + (u32)tile))) {
|
|
if (cdIs2dPointInIntTile(tile, pos->x, pos->z)) {
|
|
f32 ground = cdFindGroundInIntTile(tile, pos->x, pos->z);
|
|
|
|
if ((!arg8 && ground <= pos->y && ground > *groundptr)
|
|
|| (arg8 && ground >= pos->y && ground < *groundptr)) {
|
|
*groundptr = ground;
|
|
*tileptr = geo;
|
|
*roomptr = room;
|
|
result = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geotilei) + sizeof(tile->vertices[0]) * (tile->header.numvertices - ARRAYCOUNT(tile->vertices)));
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *type1 = (struct geotilef *) geo;
|
|
|
|
if ((geo->flags & flags)
|
|
&& pos->x >= type1->vertices[type1->xmin].x
|
|
&& pos->x <= type1->vertices[type1->xmax].x
|
|
&& pos->z >= type1->vertices[type1->zmin].z
|
|
&& pos->z <= type1->vertices[type1->zmax].z) {
|
|
if ((!arg8 && pos->y >= type1->vertices[type1->ymin].y)
|
|
|| (arg8 && pos->y <= type1->vertices[type1->ymax].y)) {
|
|
if (cdIs2dPointInFltTile(type1, pos->x, pos->z)) {
|
|
f32 ground = cdFindGroundInFltTile(type1, pos->x, pos->z);
|
|
|
|
if ((!arg8 && pos->y >= ground && ground > *groundptr)
|
|
|| (arg8 && pos->y <= ground && ground < *groundptr)) {
|
|
*groundptr = ground;
|
|
*tileptr = geo;
|
|
*roomptr = room;
|
|
result = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geotilef) + sizeof(struct coord) * (type1->header.numvertices - ARRAYCOUNT(type1->vertices)));
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geoblock));
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geocyl));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void cd00026e7c(struct coord *pos, s16 *rooms, u16 arg2, struct geo **tileptr, s16 *arg4, f32 *arg5, struct prop **arg6, s32 arg7)
|
|
{
|
|
s16 *roomptr;
|
|
s32 roomnum;
|
|
u8 *start;
|
|
u8 *end;
|
|
f32 sp274;
|
|
struct geo *sp270 = NULL;
|
|
s32 sp26c = 0;
|
|
struct prop *sp268 = NULL;
|
|
s16 *propnumptr;
|
|
s16 propnums[256];
|
|
|
|
if (arg7) {
|
|
sp274 = 4294967296;
|
|
} else {
|
|
sp274 = -4294967296;
|
|
}
|
|
|
|
roomptr = rooms;
|
|
roomnum = rooms[0];
|
|
|
|
while (roomnum != -1) {
|
|
if (roomnum < g_TileNumRooms) {
|
|
start = g_TileFileData.u8 + g_TileRooms[roomnum];
|
|
end = g_TileFileData.u8 + g_TileRooms[roomnum + 1];
|
|
|
|
cd00026a04(pos, start, end, arg2, roomnum, &sp270, &sp26c, &sp274, arg7);
|
|
}
|
|
|
|
roomptr++;
|
|
roomnum = *roomptr;
|
|
}
|
|
|
|
roomGetProps(rooms, propnums, 256);
|
|
propnumptr = propnums;
|
|
|
|
while (*propnumptr >= 0) {
|
|
struct prop *prop = &g_Vars.props[*propnumptr];
|
|
|
|
if (propUpdateGeometry(prop, &start, &end)
|
|
&& cd00026a04(pos, start, end, arg2, prop->rooms[0], &sp270, &sp26c, &sp274, arg7)) {
|
|
sp268 = prop;
|
|
}
|
|
|
|
propnumptr++;
|
|
}
|
|
|
|
*tileptr = sp270;
|
|
*arg4 = sp26c;
|
|
*arg5 = sp274;
|
|
|
|
if (arg6 != NULL) {
|
|
*arg6 = sp268;
|
|
}
|
|
}
|
|
|
|
bool cd0002709c(struct geotilei *tile, f32 x, f32 z, f32 width, struct prop *prop, struct collisionthing *thing)
|
|
{
|
|
bool result = false;
|
|
|
|
if (cdIs2dPointInIntTile(tile, x, z)) {
|
|
thing->geo = &tile->header;
|
|
thing->vertexindex = 0;
|
|
thing->prop = prop;
|
|
result = true;
|
|
} else {
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 i;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
f32 value = cd00025654(tile->vertices[i][0], tile->vertices[i][2], tile->vertices[next][0], tile->vertices[next][2], x, z);
|
|
|
|
if (value < 0) {
|
|
value = -value;
|
|
}
|
|
|
|
if (value <= width
|
|
&& (cd00025724(tile->vertices[i][0], tile->vertices[i][2], x, z) <= width
|
|
|| cd00025724(tile->vertices[next][0], tile->vertices[next][2], x, z) <= width
|
|
|| cd00025774(tile->vertices[i][0], tile->vertices[i][2], tile->vertices[next][0], tile->vertices[next][2], x, z))) {
|
|
thing->geo = &tile->header;
|
|
thing->vertexindex = i;
|
|
thing->prop = prop;
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd000272f8(struct geotilef *tile, f32 x, f32 z, f32 radius, struct prop *prop, struct collisionthing *thing)
|
|
{
|
|
bool result = false;
|
|
|
|
if (cdIs2dPointInFltTile(tile, x, z)) {
|
|
thing->geo = &tile->header;
|
|
thing->vertexindex = 0;
|
|
thing->prop = prop;
|
|
result = true;
|
|
} else {
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 i;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
f32 value = cd00025654(tile->vertices[i].x, tile->vertices[i].z, tile->vertices[next].x, tile->vertices[next].z, x, z);
|
|
|
|
if (value < 0) {
|
|
value = -value;
|
|
}
|
|
|
|
if (value <= radius
|
|
&& (cd00025724(tile->vertices[i].x, tile->vertices[i].z, x, z) <= radius
|
|
|| cd00025724(tile->vertices[next].x, tile->vertices[next].z, x, z) <= radius
|
|
|| cd00025774(tile->vertices[i].x, tile->vertices[i].z, tile->vertices[next].x, tile->vertices[next].z, x, z))) {
|
|
thing->geo = &tile->header;
|
|
thing->vertexindex = i;
|
|
thing->prop = prop;
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s32 cd000274e0(struct geoblock *tile, f32 x, f32 z, f32 width, struct prop *prop, struct collisionthing *thing)
|
|
{
|
|
bool result = false;
|
|
|
|
if (cdIs2dPointInBlock(tile, x, z)) {
|
|
if (thing) {
|
|
thing->geo = &tile->header;
|
|
thing->vertexindex = 0;
|
|
thing->prop = prop;
|
|
}
|
|
|
|
result = true;
|
|
} else {
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 i;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
f32 value = cd00025654(tile->vertices[i][0], tile->vertices[i][1],
|
|
tile->vertices[next][0], tile->vertices[next][1],
|
|
x, z);
|
|
|
|
if (value < 0) {
|
|
value = -value;
|
|
}
|
|
|
|
if (value <= width
|
|
&& (cd00025724(tile->vertices[i][0], tile->vertices[i][1], x, z) <= width
|
|
|| cd00025724(tile->vertices[next][0], tile->vertices[next][1], x, z) <= width
|
|
|| cd00025774(tile->vertices[i][0], tile->vertices[i][1], tile->vertices[next][0], tile->vertices[next][1], x, z))) {
|
|
if (thing) {
|
|
thing->geo = &tile->header;
|
|
thing->vertexindex = i;
|
|
thing->prop = prop;
|
|
}
|
|
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd000276c8(struct geocyl *cyl, f32 x, f32 z, f32 width, struct prop *prop, struct collisionthing *thing)
|
|
{
|
|
bool result = false;
|
|
|
|
f32 sumx = x - cyl->x;
|
|
f32 sumz = z - cyl->z;
|
|
f32 sumwidth = cyl->radius + width;
|
|
|
|
if (sumx * sumx + sumz * sumz <= sumwidth * sumwidth) {
|
|
result = true;
|
|
|
|
if (thing) {
|
|
thing->geo = &cyl->header;
|
|
thing->vertexindex = 0;
|
|
thing->prop = prop;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void cd00027738(struct coord *pos, f32 radius, u8 *start, u8 *end, u16 flags,
|
|
bool checkvertical, f32 arg6, f32 arg7, struct prop *prop,
|
|
struct collisionthing *things, s32 maxthings, s32 *thingnum, s32 roomnum)
|
|
{
|
|
struct geo *geo = (struct geo *) start;
|
|
s32 result;
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *) geo;
|
|
|
|
if ((geo->flags & flags)
|
|
&& pos->x >= *(s16 *)(tile->xmin + (u32)tile) - radius
|
|
&& pos->x <= *(s16 *)(tile->xmax + (u32)tile) + radius
|
|
&& pos->z >= *(s16 *)(tile->zmin + (u32)tile) - radius
|
|
&& pos->z <= *(s16 *)(tile->zmax + (u32)tile) + radius
|
|
&& (!checkvertical || (pos->y + arg6 >= *(s16 *)(tile->ymin + (u32)tile)
|
|
&& pos->y + arg7 <= *(s16 *)(tile->ymax + (u32)tile)))) {
|
|
if (geo->flags & GEOFLAG_0080) {
|
|
result = cd00028200(tile, pos, radius, pos->y + arg7, pos->y + arg6);
|
|
} else {
|
|
result = 1;
|
|
}
|
|
|
|
if (result != 0) {
|
|
if (cd0002709c(tile, pos->x, pos->z, radius, prop, &things[*thingnum])) {
|
|
things[*thingnum].room = roomnum;
|
|
*thingnum = *thingnum + 1;
|
|
|
|
if (*thingnum >= maxthings) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + tile->header.numvertices * 6 + 0xe);
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *tile = (struct geotilef *) geo;
|
|
s32 tmp = 0x40;
|
|
|
|
if ((geo->flags & flags)
|
|
&& pos->x >= *(f32 *)((u32)tile + tile->xmin * 0xc + 0x10) - radius
|
|
&& pos->x <= *(f32 *)((u32)tile + tile->xmax * 0xc + 0x10) + radius
|
|
&& pos->z >= *(f32 *)((u32)tile + tile->zmin * 0xc + 0x18) - radius
|
|
&& pos->z <= *(f32 *)((u32)tile + tile->zmax * 0xc + 0x18) + radius
|
|
&& (!checkvertical || (pos->y + arg6 >= *(f32*)((u32)tile + tile->ymin * 0xc + 0x14)
|
|
&& pos->y + arg7 <= *(f32 *)((u32)tile + tile->ymax * 0xc + 0x14)))) {
|
|
result = cd000272f8(tile, pos->x, pos->z, radius, prop, &things[*thingnum]);
|
|
|
|
if (result != 0) {
|
|
things[*thingnum].room = roomnum;
|
|
*thingnum = *thingnum + 1;
|
|
|
|
if (*thingnum >= maxthings) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + (tile->header.numvertices - tmp) * 0xc + 0x310);
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
struct geoblock *block = (struct geoblock *) geo;
|
|
|
|
if ((flags & (GEOFLAG_COLLISIONS | GEOFLAG_0008 | GEOFLAG_OPAQUE))
|
|
&& (!checkvertical || (pos->y + arg6 >= block->ymin && pos->y + arg7 <= block->ymax))) {
|
|
result = cd000274e0(block, pos->x, pos->z, radius, prop, &things[*thingnum]);
|
|
|
|
if (result) {
|
|
things[*thingnum].room = roomnum;
|
|
*thingnum = *thingnum + 1;
|
|
|
|
if (*thingnum >= maxthings) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + 0x4c);
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
struct geocyl *cyl = (struct geocyl *) geo;
|
|
|
|
if ((flags & geo->flags)
|
|
&& (!checkvertical || (pos->y + arg6 >= cyl->ymin && pos->y + arg7 <= cyl->ymax))) {
|
|
result = cd000276c8(cyl, pos->x, pos->z, radius, prop, &things[*thingnum]);
|
|
|
|
if (result) {
|
|
things[*thingnum].room = roomnum;
|
|
*thingnum = *thingnum + 1;
|
|
|
|
if (*thingnum >= maxthings) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + 0x18);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cd00027d1c(struct coord *pos, f32 radius, s16 *rooms, u32 types, u16 arg4, u32 arg5, f32 arg6, f32 arg7, struct collisionthing *arg8, s32 arg9)
|
|
{
|
|
s16 *roomptr;
|
|
s32 roomnum;
|
|
u8 *start;
|
|
u8 *end;
|
|
s32 sp294 = 0;
|
|
s16 *propnumptr;
|
|
s16 propnums[256];
|
|
|
|
// Check BG
|
|
if (types & CDTYPE_BG) {
|
|
roomptr = rooms;
|
|
roomnum = rooms[0];
|
|
|
|
while (roomnum != -1) {
|
|
if (roomnum < g_TileNumRooms) {
|
|
start = g_TileFileData.u8 + g_TileRooms[roomnum];
|
|
end = g_TileFileData.u8 + g_TileRooms[roomnum + 1];
|
|
|
|
cd00027738(pos, radius, start, end, arg4, arg5, arg6, arg7, NULL, arg8, arg9, &sp294, roomnum);
|
|
|
|
if (sp294 >= arg9) {
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
roomptr++;
|
|
roomnum = *roomptr;
|
|
}
|
|
}
|
|
|
|
// Check props
|
|
roomGetProps(rooms, propnums, 256);
|
|
propnumptr = propnums;
|
|
|
|
while (*propnumptr >= 0) {
|
|
struct prop *prop = &g_Vars.props[*propnumptr];
|
|
|
|
if (propIsOfCdType(prop, types) && propUpdateGeometry(prop, &start, &end)) {
|
|
cd00027738(pos, radius, start, end, arg4, arg5, arg6, arg7, prop, arg8, arg9, &sp294, prop->rooms[0]);
|
|
|
|
if (sp294 >= arg9) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
propnumptr++;
|
|
}
|
|
|
|
end:
|
|
arg8[sp294].geo = NULL;
|
|
}
|
|
|
|
void cd00027f78(struct geotilei *tile, f32 arg1, f32 arg2, f32 arg3, struct prop *prop, struct collisionthing *things, s32 maxthings, s32 *thingindex)
|
|
{
|
|
s32 i;
|
|
s32 numvertices = tile->header.numvertices;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
|
|
if (tile->vertices[i][0] != tile->vertices[next][0] || tile->vertices[i][2] != tile->vertices[next][2]) {
|
|
f32 f0 = cd00025654(tile->vertices[i][0], tile->vertices[i][2], tile->vertices[next][0], tile->vertices[next][2], arg1, arg2);
|
|
|
|
if (f0 < 0.0f) {
|
|
f0 = -f0;
|
|
}
|
|
|
|
if (f0 <= arg3
|
|
&& (cd00025724(tile->vertices[i][0], tile->vertices[i][2], arg1, arg2) <= arg3
|
|
|| cd00025724(tile->vertices[next][0], tile->vertices[next][2], arg1, arg2) <= arg3
|
|
|| cd00025774(tile->vertices[i][0], tile->vertices[i][2], tile->vertices[next][0], tile->vertices[next][2], arg1, arg2))) {
|
|
if (*thingindex < maxthings) {
|
|
things[*thingindex].geo = &tile->header;
|
|
things[*thingindex].vertexindex = i;
|
|
things[*thingindex].prop = prop;
|
|
*thingindex += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s32 cd00028200(struct geotilei *tile, struct coord *pos, f32 width, f32 y1, f32 y2)
|
|
{
|
|
s32 count;
|
|
s32 i;
|
|
s32 y1count;
|
|
s32 y2count;
|
|
s32 numverts;
|
|
|
|
if (!g_Vars.enableslopes && (tile->header.flags & GEOFLAG_0100)) {
|
|
return 0;
|
|
}
|
|
|
|
numverts = tile->header.numvertices;
|
|
y2count = 0;
|
|
y1count = 0;
|
|
count = 0;
|
|
|
|
for (i = 0; i < numverts; i++) {
|
|
s32 next = i + 1;
|
|
s32 last = numverts - 1;
|
|
f32 posval;
|
|
f32 thisvals[2];
|
|
f32 nextvals[2];
|
|
f32 somefloat;
|
|
f32 somefloat2;
|
|
s32 xdiff;
|
|
s32 zdiff;
|
|
|
|
if (i == last) {
|
|
next = 0;
|
|
}
|
|
|
|
xdiff = tile->vertices[next][0] - tile->vertices[i][0];
|
|
zdiff = tile->vertices[next][2] - tile->vertices[i][2];
|
|
|
|
if (xdiff < 0) {
|
|
xdiff = -xdiff;
|
|
}
|
|
|
|
if (zdiff < 0) {
|
|
zdiff = -zdiff;
|
|
}
|
|
|
|
if (xdiff || zdiff) {
|
|
thisvals[1] = tile->vertices[i][1];
|
|
nextvals[1] = tile->vertices[next][1];
|
|
|
|
if (zdiff < xdiff) {
|
|
thisvals[0] = tile->vertices[i][0];
|
|
nextvals[0] = tile->vertices[next][0];
|
|
posval = pos->x;
|
|
} else {
|
|
thisvals[0] = tile->vertices[i][2];
|
|
nextvals[0] = tile->vertices[next][2];
|
|
posval = pos->z;
|
|
}
|
|
|
|
somefloat = (posval - thisvals[0]) / (nextvals[0] - thisvals[0]);
|
|
|
|
if (somefloat <= 1.0f && somefloat >= 0.0f) {
|
|
somefloat2 = thisvals[1] + (nextvals[1] - thisvals[1]) * somefloat;
|
|
|
|
if (somefloat2 >= y2 - 1.0f) {
|
|
y2count++;
|
|
|
|
if (y1count != 0) {
|
|
count++;
|
|
}
|
|
} else if (somefloat2 <= y1 + 1.0f) {
|
|
y1count++;
|
|
|
|
if (y2count != 0) {
|
|
count++;
|
|
}
|
|
} else {
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
void cd0002840c(struct geotilef *tile, f32 arg1, f32 arg2, f32 arg3, struct prop *prop, struct collisionthing *things, s32 maxthings, s32 *thingindex)
|
|
{
|
|
s32 i;
|
|
s32 numvertices = tile->header.numvertices;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
|
|
if (tile->vertices[i].x != tile->vertices[next].x || tile->vertices[i].z != tile->vertices[next].z) {
|
|
f32 f0 = cd00025654(tile->vertices[i].x, tile->vertices[i].z, tile->vertices[next].x, tile->vertices[next].z, arg1, arg2);
|
|
|
|
if (f0 < 0.0f) {
|
|
f0 = -f0;
|
|
}
|
|
|
|
if (f0 <= arg3
|
|
&& (cd00025724(tile->vertices[i].x, tile->vertices[i].z, arg1, arg2) <= arg3
|
|
|| cd00025724(tile->vertices[next].x, tile->vertices[next].z, arg1, arg2) <= arg3
|
|
|| cd00025774(tile->vertices[i].x, tile->vertices[i].z, tile->vertices[next].x, tile->vertices[next].z, arg1, arg2))) {
|
|
if (*thingindex < maxthings) {
|
|
things[*thingindex].geo = &tile->header;
|
|
things[*thingindex].vertexindex = i;
|
|
things[*thingindex].prop = prop;
|
|
*thingindex += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cd00028638(struct geoblock *block, f32 arg1, f32 arg2, f32 arg3, struct prop *prop, struct collisionthing *things, s32 maxthings, s32 *thingindex)
|
|
{
|
|
s32 i;
|
|
s32 numvertices = block->header.numvertices;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
s32 next = (i + 1) % numvertices;
|
|
|
|
if (block->vertices[i][0] != block->vertices[next][0] || block->vertices[i][1] != block->vertices[next][1]) {
|
|
f32 f0 = cd00025654(block->vertices[i][0], block->vertices[i][1], block->vertices[next][0], block->vertices[next][1], arg1, arg2);
|
|
|
|
if (f0 < 0.0f) {
|
|
f0 = -f0;
|
|
}
|
|
|
|
if (f0 <= arg3
|
|
&& (cd00025724(block->vertices[i][0], block->vertices[i][1], arg1, arg2) <= arg3
|
|
|| cd00025724(block->vertices[next][0], block->vertices[next][1], arg1, arg2) <= arg3
|
|
|| cd00025774(block->vertices[i][0], block->vertices[i][1], block->vertices[next][0], block->vertices[next][1], arg1, arg2))) {
|
|
if (*thingindex < maxthings) {
|
|
things[*thingindex].geo = &block->header;
|
|
things[*thingindex].vertexindex = i;
|
|
things[*thingindex].prop = prop;
|
|
*thingindex += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cd0002885c(struct geocyl *cyl, f32 x, f32 z, f32 arg3, struct prop *prop, struct collisionthing *things, s32 maxthings, s32 *thingindex)
|
|
{
|
|
f32 xdiff = x - cyl->x;
|
|
f32 zdiff = z - cyl->z;
|
|
f32 f16 = arg3 + cyl->radius;
|
|
|
|
if (xdiff * xdiff + zdiff * zdiff <= f16 * f16) {
|
|
if (*thingindex < maxthings) {
|
|
things[*thingindex].geo = &cyl->header;
|
|
things[*thingindex].vertexindex = 0;
|
|
things[*thingindex].prop = prop;
|
|
*thingindex += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void cd00028914(u8 *start, u8 *end, struct coord *pos, f32 radius, u16 flags,
|
|
bool checkvertical, f32 arg6, f32 arg7, struct prop *prop,
|
|
struct collisionthing *things, s32 maxthings, s32 *thingindex)
|
|
{
|
|
struct geo *geo = (struct geo *) start;
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *) geo;
|
|
|
|
if (geo->flags & flags) {
|
|
if (pos->x >= *(s16 *)(tile->xmin + (u32)tile) - radius
|
|
&& pos->x <= *(s16 *)(tile->xmax + (u32)tile) + radius
|
|
&& pos->z >= *(s16 *)(tile->zmin + (u32)tile) - radius
|
|
&& pos->z <= *(s16 *)(tile->zmax + (u32)tile) + radius
|
|
&& (!checkvertical || (pos->y + arg6 >= *(s16 *)(tile->ymin + (u32)tile)
|
|
&& pos->y + arg7 <= *(s16 *)(tile->ymax + (u32)tile)))) {
|
|
bool pass;
|
|
|
|
if (geo->flags & GEOFLAG_0080) {
|
|
pass = cd00028200(tile, pos, radius, pos->y + arg7, pos->y + arg6);
|
|
} else {
|
|
pass = true;
|
|
}
|
|
|
|
if (pass) {
|
|
cd00027f78(tile, pos->x, pos->z, radius, prop, things, maxthings, thingindex);
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + tile->header.numvertices * 6 + 0xe);
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *tile = (struct geotilef *) geo;
|
|
|
|
if ((geo->flags & flags)
|
|
&& pos->x >= tile->vertices[tile->xmin].x - radius
|
|
&& pos->x <= tile->vertices[tile->xmax].x + radius
|
|
&& pos->z >= tile->vertices[tile->zmin].z - radius
|
|
&& pos->z <= tile->vertices[tile->zmax].z + radius
|
|
&& (!checkvertical || (pos->y + arg6 >= tile->vertices[tile->ymin].y
|
|
&& pos->y + arg7 <= tile->vertices[tile->ymax].y))) {
|
|
cd0002840c(tile, pos->x, pos->z, radius, prop, things, maxthings, thingindex);
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + (u32)(tile->header.numvertices - 0x40) * 0xc + 0x310);
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
struct geoblock *block = (struct geoblock *) geo;
|
|
|
|
if ((flags & (GEOFLAG_COLLISIONS | GEOFLAG_0008 | GEOFLAG_OPAQUE))
|
|
&& (!checkvertical || (pos->y + arg6 >= block->ymin && pos->y + arg7 <= block->ymax))) {
|
|
cd00028638(block, pos->x, pos->z, radius, prop, things, maxthings, thingindex);
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geoblock));
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
struct geocyl *cyl = (struct geocyl *) geo;
|
|
|
|
if ((flags & geo->flags)
|
|
&& (!checkvertical || (pos->y + arg6 >= cyl->ymin && pos->y + arg7 <= cyl->ymax))) {
|
|
cd0002885c(cyl, pos->x, pos->z, radius, prop, things, maxthings, thingindex);
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geocyl));
|
|
}
|
|
}
|
|
}
|
|
|
|
void cd00028df0(struct coord *pos, f32 width, s16 *rooms, u32 types, u16 arg4, u32 arg5, f32 ymax, f32 ymin, struct collisionthing *arg8, s32 arg9)
|
|
{
|
|
s16 *roomptr;
|
|
s32 roomnum;
|
|
u8 *start;
|
|
u8 *end;
|
|
s32 sp294 = 0;
|
|
s16 *propnumptr;
|
|
s16 propnums[256];
|
|
|
|
// Check BG
|
|
if (types & CDTYPE_BG) {
|
|
roomptr = rooms;
|
|
roomnum = rooms[0];
|
|
|
|
while (roomnum != -1) {
|
|
if (roomnum < g_TileNumRooms) {
|
|
start = g_TileFileData.u8 + g_TileRooms[roomnum];
|
|
end = g_TileFileData.u8 + g_TileRooms[roomnum + 1];
|
|
|
|
cd00028914(start, end, pos, width, arg4, arg5, ymax, ymin, NULL, arg8, arg9, &sp294);
|
|
}
|
|
|
|
roomptr++;
|
|
roomnum = *roomptr;
|
|
}
|
|
}
|
|
|
|
// Check props
|
|
roomGetProps(rooms, propnums, 256);
|
|
propnumptr = propnums;
|
|
|
|
while (*propnumptr >= 0) {
|
|
struct prop *prop = &g_Vars.props[*propnumptr];
|
|
|
|
if (propIsOfCdType(prop, types) && propUpdateGeometry(prop, &start, &end)) {
|
|
cd00028914(start, end, pos, width, arg4, arg5, ymax, ymin, prop, arg8, arg9, &sp294);
|
|
}
|
|
|
|
propnumptr++;
|
|
}
|
|
|
|
arg8[sp294].geo = NULL;
|
|
}
|
|
|
|
GLOBAL_ASM(
|
|
glabel cd0002901c
|
|
/* 2901c: 27bdfef8 */ addiu $sp,$sp,-264
|
|
/* 29020: afbf0064 */ sw $ra,0x64($sp)
|
|
/* 29024: afbe0060 */ sw $s8,0x60($sp)
|
|
/* 29028: afb7005c */ sw $s7,0x5c($sp)
|
|
/* 2902c: afb60058 */ sw $s6,0x58($sp)
|
|
/* 29030: afb50054 */ sw $s5,0x54($sp)
|
|
/* 29034: afb40050 */ sw $s4,0x50($sp)
|
|
/* 29038: afb3004c */ sw $s3,0x4c($sp)
|
|
/* 2903c: afb20048 */ sw $s2,0x48($sp)
|
|
/* 29040: afb10044 */ sw $s1,0x44($sp)
|
|
/* 29044: afb00040 */ sw $s0,0x40($sp)
|
|
/* 29048: f7b60038 */ sdc1 $f22,0x38($sp)
|
|
/* 2904c: f7b40030 */ sdc1 $f20,0x30($sp)
|
|
/* 29050: afa70114 */ sw $a3,0x114($sp)
|
|
/* 29054: 8ce30000 */ lw $v1,0x0($a3)
|
|
/* 29058: 4486b000 */ mtc1 $a2,$f22
|
|
/* 2905c: 4480a000 */ mtc1 $zero,$f20
|
|
/* 29060: 00a08825 */ or $s1,$a1,$zero
|
|
/* 29064: 00809025 */ or $s2,$a0,$zero
|
|
/* 29068: 2410ffff */ addiu $s0,$zero,-1
|
|
/* 2906c: 00009825 */ or $s3,$zero,$zero
|
|
/* 29070: 106000dc */ beqz $v1,.L000293e4
|
|
/* 29074: 00e07025 */ or $t6,$a3,$zero
|
|
/* 29078: 01c0a025 */ or $s4,$t6,$zero
|
|
/* 2907c: 27be00e0 */ addiu $s8,$sp,0xe0
|
|
/* 29080: 27b700e8 */ addiu $s7,$sp,0xe8
|
|
/* 29084: 27b600f0 */ addiu $s6,$sp,0xf0
|
|
/* 29088: 27b500f8 */ addiu $s5,$sp,0xf8
|
|
/* 2908c: 90620000 */ lbu $v0,0x0($v1)
|
|
.L00029090:
|
|
/* 29090: 54400042 */ bnezl $v0,.L0002919c
|
|
/* 29094: 24010001 */ addiu $at,$zero,0x1
|
|
/* 29098: e7b600f8 */ swc1 $f22,0xf8($sp)
|
|
/* 2909c: c6440000 */ lwc1 $f4,0x0($s2)
|
|
/* 290a0: 240b0006 */ addiu $t3,$zero,0x6
|
|
/* 290a4: 02a02025 */ or $a0,$s5,$zero
|
|
/* 290a8: e7a400fc */ swc1 $f4,0xfc($sp)
|
|
/* 290ac: c6460008 */ lwc1 $f6,0x8($s2)
|
|
/* 290b0: 02c02825 */ or $a1,$s6,$zero
|
|
/* 290b4: 02e03025 */ or $a2,$s7,$zero
|
|
/* 290b8: e7a60100 */ swc1 $f6,0x100($sp)
|
|
/* 290bc: c6280000 */ lwc1 $f8,0x0($s1)
|
|
/* 290c0: 03c03825 */ or $a3,$s8,$zero
|
|
/* 290c4: e7a800e0 */ swc1 $f8,0xe0($sp)
|
|
/* 290c8: c62a0008 */ lwc1 $f10,0x8($s1)
|
|
/* 290cc: e7aa00e4 */ swc1 $f10,0xe4($sp)
|
|
/* 290d0: 8e820008 */ lw $v0,0x8($s4)
|
|
/* 290d4: 90780001 */ lbu $t8,0x1($v1)
|
|
/* 290d8: 244f0001 */ addiu $t7,$v0,0x1
|
|
/* 290dc: 01f8001a */ div $zero,$t7,$t8
|
|
/* 290e0: 00004010 */ mfhi $t0
|
|
/* 290e4: 17000002 */ bnez $t8,.L000290f0
|
|
/* 290e8: 00000000 */ nop
|
|
/* 290ec: 0007000d */ break 0x7
|
|
.L000290f0:
|
|
/* 290f0: 2401ffff */ addiu $at,$zero,-1
|
|
/* 290f4: 17010004 */ bne $t8,$at,.L00029108
|
|
/* 290f8: 3c018000 */ lui $at,0x8000
|
|
/* 290fc: 15e10002 */ bne $t7,$at,.L00029108
|
|
/* 29100: 00000000 */ nop
|
|
/* 29104: 0006000d */ break 0x6
|
|
.L00029108:
|
|
/* 29108: 004b0019 */ multu $v0,$t3
|
|
/* 2910c: 0000c812 */ mflo $t9
|
|
/* 29110: 00794821 */ addu $t1,$v1,$t9
|
|
/* 29114: 852c000e */ lh $t4,0xe($t1)
|
|
/* 29118: 010b0019 */ multu $t0,$t3
|
|
/* 2911c: 448c8000 */ mtc1 $t4,$f16
|
|
/* 29120: 00000000 */ nop
|
|
/* 29124: 468084a0 */ cvt.s.w $f18,$f16
|
|
/* 29128: 00007012 */ mflo $t6
|
|
/* 2912c: e7b200f0 */ swc1 $f18,0xf0($sp)
|
|
/* 29130: 852d0012 */ lh $t5,0x12($t1)
|
|
/* 29134: 006e5021 */ addu $t2,$v1,$t6
|
|
/* 29138: 448d2000 */ mtc1 $t5,$f4
|
|
/* 2913c: 00000000 */ nop
|
|
/* 29140: 468021a0 */ cvt.s.w $f6,$f4
|
|
/* 29144: e7a600f4 */ swc1 $f6,0xf4($sp)
|
|
/* 29148: 854f000e */ lh $t7,0xe($t2)
|
|
/* 2914c: 448f4000 */ mtc1 $t7,$f8
|
|
/* 29150: 00000000 */ nop
|
|
/* 29154: 468042a0 */ cvt.s.w $f10,$f8
|
|
/* 29158: e7aa00e8 */ swc1 $f10,0xe8($sp)
|
|
/* 2915c: 85580012 */ lh $t8,0x12($t2)
|
|
/* 29160: 44988000 */ mtc1 $t8,$f16
|
|
/* 29164: 00000000 */ nop
|
|
/* 29168: 468084a0 */ cvt.s.w $f18,$f16
|
|
/* 2916c: 0fc55e73 */ jal func0f1579cc
|
|
/* 29170: e7b200ec */ swc1 $f18,0xec($sp)
|
|
/* 29174: 06020006 */ bltzl $s0,.L00029190
|
|
/* 29178: 46000506 */ mov.s $f20,$f0
|
|
/* 2917c: 4614003c */ c.lt.s $f0,$f20
|
|
/* 29180: 00000000 */ nop
|
|
/* 29184: 45020093 */ bc1fl .L000293d4
|
|
/* 29188: 8e830014 */ lw $v1,0x14($s4)
|
|
/* 2918c: 46000506 */ mov.s $f20,$f0
|
|
.L00029190:
|
|
/* 29190: 1000008f */ b .L000293d0
|
|
/* 29194: 02608025 */ or $s0,$s3,$zero
|
|
/* 29198: 24010001 */ addiu $at,$zero,0x1
|
|
.L0002919c:
|
|
/* 2919c: 54410036 */ bnel $v0,$at,.L00029278
|
|
/* 291a0: 24010002 */ addiu $at,$zero,0x2
|
|
/* 291a4: e7b600f8 */ swc1 $f22,0xf8($sp)
|
|
/* 291a8: c6440000 */ lwc1 $f4,0x0($s2)
|
|
/* 291ac: 240b000c */ addiu $t3,$zero,0xc
|
|
/* 291b0: 02a02025 */ or $a0,$s5,$zero
|
|
/* 291b4: e7a400fc */ swc1 $f4,0xfc($sp)
|
|
/* 291b8: c6460008 */ lwc1 $f6,0x8($s2)
|
|
/* 291bc: 02c02825 */ or $a1,$s6,$zero
|
|
/* 291c0: 02e03025 */ or $a2,$s7,$zero
|
|
/* 291c4: e7a60100 */ swc1 $f6,0x100($sp)
|
|
/* 291c8: c6280000 */ lwc1 $f8,0x0($s1)
|
|
/* 291cc: 03c03825 */ or $a3,$s8,$zero
|
|
/* 291d0: e7a800e0 */ swc1 $f8,0xe0($sp)
|
|
/* 291d4: c62a0008 */ lwc1 $f10,0x8($s1)
|
|
/* 291d8: e7aa00e4 */ swc1 $f10,0xe4($sp)
|
|
/* 291dc: 8e820008 */ lw $v0,0x8($s4)
|
|
/* 291e0: 906c0001 */ lbu $t4,0x1($v1)
|
|
/* 291e4: 24590001 */ addiu $t9,$v0,0x1
|
|
/* 291e8: 032c001a */ div $zero,$t9,$t4
|
|
/* 291ec: 00004010 */ mfhi $t0
|
|
/* 291f0: 15800002 */ bnez $t4,.L000291fc
|
|
/* 291f4: 00000000 */ nop
|
|
/* 291f8: 0007000d */ break 0x7
|
|
.L000291fc:
|
|
/* 291fc: 2401ffff */ addiu $at,$zero,-1
|
|
/* 29200: 15810004 */ bne $t4,$at,.L00029214
|
|
/* 29204: 3c018000 */ lui $at,0x8000
|
|
/* 29208: 17210002 */ bne $t9,$at,.L00029214
|
|
/* 2920c: 00000000 */ nop
|
|
/* 29210: 0006000d */ break 0x6
|
|
.L00029214:
|
|
/* 29214: 004b0019 */ multu $v0,$t3
|
|
/* 29218: 00006812 */ mflo $t5
|
|
/* 2921c: 006d4821 */ addu $t1,$v1,$t5
|
|
/* 29220: c5300010 */ lwc1 $f16,0x10($t1)
|
|
/* 29224: 010b0019 */ multu $t0,$t3
|
|
/* 29228: e7b000f0 */ swc1 $f16,0xf0($sp)
|
|
/* 2922c: c5320018 */ lwc1 $f18,0x18($t1)
|
|
/* 29230: e7b200f4 */ swc1 $f18,0xf4($sp)
|
|
/* 29234: 00007012 */ mflo $t6
|
|
/* 29238: 006e5021 */ addu $t2,$v1,$t6
|
|
/* 2923c: c5440010 */ lwc1 $f4,0x10($t2)
|
|
/* 29240: e7a400e8 */ swc1 $f4,0xe8($sp)
|
|
/* 29244: c5460018 */ lwc1 $f6,0x18($t2)
|
|
/* 29248: 0fc55e73 */ jal func0f1579cc
|
|
/* 2924c: e7a600ec */ swc1 $f6,0xec($sp)
|
|
/* 29250: 06020006 */ bltzl $s0,.L0002926c
|
|
/* 29254: 46000506 */ mov.s $f20,$f0
|
|
/* 29258: 4614003c */ c.lt.s $f0,$f20
|
|
/* 2925c: 00000000 */ nop
|
|
/* 29260: 4502005c */ bc1fl .L000293d4
|
|
/* 29264: 8e830014 */ lw $v1,0x14($s4)
|
|
/* 29268: 46000506 */ mov.s $f20,$f0
|
|
.L0002926c:
|
|
/* 2926c: 10000058 */ b .L000293d0
|
|
/* 29270: 02608025 */ or $s0,$s3,$zero
|
|
/* 29274: 24010002 */ addiu $at,$zero,0x2
|
|
.L00029278:
|
|
/* 29278: 54410033 */ bnel $v0,$at,.L00029348
|
|
/* 2927c: 24010003 */ addiu $at,$zero,0x3
|
|
/* 29280: e7b600f8 */ swc1 $f22,0xf8($sp)
|
|
/* 29284: c6480000 */ lwc1 $f8,0x0($s2)
|
|
/* 29288: 02a02025 */ or $a0,$s5,$zero
|
|
/* 2928c: 02c02825 */ or $a1,$s6,$zero
|
|
/* 29290: e7a800fc */ swc1 $f8,0xfc($sp)
|
|
/* 29294: c64a0008 */ lwc1 $f10,0x8($s2)
|
|
/* 29298: 02e03025 */ or $a2,$s7,$zero
|
|
/* 2929c: 03c03825 */ or $a3,$s8,$zero
|
|
/* 292a0: e7aa0100 */ swc1 $f10,0x100($sp)
|
|
/* 292a4: c6300000 */ lwc1 $f16,0x0($s1)
|
|
/* 292a8: e7b000e0 */ swc1 $f16,0xe0($sp)
|
|
/* 292ac: c6320008 */ lwc1 $f18,0x8($s1)
|
|
/* 292b0: e7b200e4 */ swc1 $f18,0xe4($sp)
|
|
/* 292b4: 90780001 */ lbu $t8,0x1($v1)
|
|
/* 292b8: 8e820008 */ lw $v0,0x8($s4)
|
|
/* 292bc: 244f0001 */ addiu $t7,$v0,0x1
|
|
/* 292c0: 01f8001a */ div $zero,$t7,$t8
|
|
/* 292c4: 0002c8c0 */ sll $t9,$v0,0x3
|
|
/* 292c8: 00794821 */ addu $t1,$v1,$t9
|
|
/* 292cc: c524000c */ lwc1 $f4,0xc($t1)
|
|
/* 292d0: 00004010 */ mfhi $t0
|
|
/* 292d4: 000860c0 */ sll $t4,$t0,0x3
|
|
/* 292d8: e7a400f0 */ swc1 $f4,0xf0($sp)
|
|
/* 292dc: c5260010 */ lwc1 $f6,0x10($t1)
|
|
/* 292e0: 006c5021 */ addu $t2,$v1,$t4
|
|
/* 292e4: 17000002 */ bnez $t8,.L000292f0
|
|
/* 292e8: 00000000 */ nop
|
|
/* 292ec: 0007000d */ break 0x7
|
|
.L000292f0:
|
|
/* 292f0: 2401ffff */ addiu $at,$zero,-1
|
|
/* 292f4: 17010004 */ bne $t8,$at,.L00029308
|
|
/* 292f8: 3c018000 */ lui $at,0x8000
|
|
/* 292fc: 15e10002 */ bne $t7,$at,.L00029308
|
|
/* 29300: 00000000 */ nop
|
|
/* 29304: 0006000d */ break 0x6
|
|
.L00029308:
|
|
/* 29308: e7a600f4 */ swc1 $f6,0xf4($sp)
|
|
/* 2930c: c548000c */ lwc1 $f8,0xc($t2)
|
|
/* 29310: e7a800e8 */ swc1 $f8,0xe8($sp)
|
|
/* 29314: c54a0010 */ lwc1 $f10,0x10($t2)
|
|
/* 29318: 0fc55e73 */ jal func0f1579cc
|
|
/* 2931c: e7aa00ec */ swc1 $f10,0xec($sp)
|
|
/* 29320: 06020006 */ bltzl $s0,.L0002933c
|
|
/* 29324: 46000506 */ mov.s $f20,$f0
|
|
/* 29328: 4614003c */ c.lt.s $f0,$f20
|
|
/* 2932c: 00000000 */ nop
|
|
/* 29330: 45020028 */ bc1fl .L000293d4
|
|
/* 29334: 8e830014 */ lw $v1,0x14($s4)
|
|
/* 29338: 46000506 */ mov.s $f20,$f0
|
|
.L0002933c:
|
|
/* 2933c: 10000024 */ b .L000293d0
|
|
/* 29340: 02608025 */ or $s0,$s3,$zero
|
|
/* 29344: 24010003 */ addiu $at,$zero,0x3
|
|
.L00029348:
|
|
/* 29348: 54410022 */ bnel $v0,$at,.L000293d4
|
|
/* 2934c: 8e830014 */ lw $v1,0x14($s4)
|
|
/* 29350: c4700014 */ lwc1 $f16,0x14($v1)
|
|
/* 29354: 02a02025 */ or $a0,$s5,$zero
|
|
/* 29358: 02c02825 */ or $a1,$s6,$zero
|
|
/* 2935c: 46168480 */ add.s $f18,$f16,$f22
|
|
/* 29360: 02e03025 */ or $a2,$s7,$zero
|
|
/* 29364: 03c03825 */ or $a3,$s8,$zero
|
|
/* 29368: e7b200f8 */ swc1 $f18,0xf8($sp)
|
|
/* 2936c: c6440000 */ lwc1 $f4,0x0($s2)
|
|
/* 29370: e7a400fc */ swc1 $f4,0xfc($sp)
|
|
/* 29374: c6460008 */ lwc1 $f6,0x8($s2)
|
|
/* 29378: e7a60100 */ swc1 $f6,0x100($sp)
|
|
/* 2937c: c6280000 */ lwc1 $f8,0x0($s1)
|
|
/* 29380: e7a800e0 */ swc1 $f8,0xe0($sp)
|
|
/* 29384: c62a0008 */ lwc1 $f10,0x8($s1)
|
|
/* 29388: e7aa00e4 */ swc1 $f10,0xe4($sp)
|
|
/* 2938c: c470000c */ lwc1 $f16,0xc($v1)
|
|
/* 29390: e7b000f0 */ swc1 $f16,0xf0($sp)
|
|
/* 29394: c4720010 */ lwc1 $f18,0x10($v1)
|
|
/* 29398: e7b200f4 */ swc1 $f18,0xf4($sp)
|
|
/* 2939c: c464000c */ lwc1 $f4,0xc($v1)
|
|
/* 293a0: e7a400e8 */ swc1 $f4,0xe8($sp)
|
|
/* 293a4: c4660010 */ lwc1 $f6,0x10($v1)
|
|
/* 293a8: 0fc55e73 */ jal func0f1579cc
|
|
/* 293ac: e7a600ec */ swc1 $f6,0xec($sp)
|
|
/* 293b0: 06020006 */ bltzl $s0,.L000293cc
|
|
/* 293b4: 46000506 */ mov.s $f20,$f0
|
|
/* 293b8: 4614003c */ c.lt.s $f0,$f20
|
|
/* 293bc: 00000000 */ nop
|
|
/* 293c0: 45020004 */ bc1fl .L000293d4
|
|
/* 293c4: 8e830014 */ lw $v1,0x14($s4)
|
|
/* 293c8: 46000506 */ mov.s $f20,$f0
|
|
.L000293cc:
|
|
/* 293cc: 02608025 */ or $s0,$s3,$zero
|
|
.L000293d0:
|
|
/* 293d0: 8e830014 */ lw $v1,0x14($s4)
|
|
.L000293d4:
|
|
/* 293d4: 26730001 */ addiu $s3,$s3,0x1
|
|
/* 293d8: 26940014 */ addiu $s4,$s4,0x14
|
|
/* 293dc: 5460ff2c */ bnezl $v1,.L00029090
|
|
/* 293e0: 90620000 */ lbu $v0,0x0($v1)
|
|
.L000293e4:
|
|
/* 293e4: 8fad0114 */ lw $t5,0x114($sp)
|
|
/* 293e8: 00107080 */ sll $t6,$s0,0x2
|
|
/* 293ec: 01d07021 */ addu $t6,$t6,$s0
|
|
/* 293f0: 000e7080 */ sll $t6,$t6,0x2
|
|
/* 293f4: 01ae8821 */ addu $s1,$t5,$t6
|
|
/* 293f8: 8e280000 */ lw $t0,0x0($s1)
|
|
/* 293fc: 91020000 */ lbu $v0,0x0($t0)
|
|
/* 29400: 54400037 */ bnezl $v0,.L000294e0
|
|
/* 29404: 24010001 */ addiu $at,$zero,0x1
|
|
/* 29408: 91180001 */ lbu $t8,0x1($t0)
|
|
/* 2940c: 8e250008 */ lw $a1,0x8($s1)
|
|
/* 29410: 01001025 */ or $v0,$t0,$zero
|
|
/* 29414: 24af0001 */ addiu $t7,$a1,0x1
|
|
/* 29418: 01f8001a */ div $zero,$t7,$t8
|
|
/* 2941c: 0005c880 */ sll $t9,$a1,0x2
|
|
/* 29420: 0325c823 */ subu $t9,$t9,$a1
|
|
/* 29424: 0019c840 */ sll $t9,$t9,0x1
|
|
/* 29428: 00591821 */ addu $v1,$v0,$t9
|
|
/* 2942c: 846c000e */ lh $t4,0xe($v1)
|
|
/* 29430: 00003010 */ mfhi $a2
|
|
/* 29434: 448c4000 */ mtc1 $t4,$f8
|
|
/* 29438: 17000002 */ bnez $t8,.L00029444
|
|
/* 2943c: 00000000 */ nop
|
|
/* 29440: 0007000d */ break 0x7
|
|
.L00029444:
|
|
/* 29444: 2401ffff */ addiu $at,$zero,-1
|
|
/* 29448: 17010004 */ bne $t8,$at,.L0002945c
|
|
/* 2944c: 3c018000 */ lui $at,0x8000
|
|
/* 29450: 15e10002 */ bne $t7,$at,.L0002945c
|
|
/* 29454: 00000000 */ nop
|
|
/* 29458: 0006000d */ break 0x6
|
|
.L0002945c:
|
|
/* 2945c: 468042a0 */ cvt.s.w $f10,$f8
|
|
/* 29460: 00067880 */ sll $t7,$a2,0x2
|
|
/* 29464: 01e67823 */ subu $t7,$t7,$a2
|
|
/* 29468: 000f7840 */ sll $t7,$t7,0x1
|
|
/* 2946c: 004f2021 */ addu $a0,$v0,$t7
|
|
/* 29470: e7aa00bc */ swc1 $f10,0xbc($sp)
|
|
/* 29474: 846d0010 */ lh $t5,0x10($v1)
|
|
/* 29478: 448d8000 */ mtc1 $t5,$f16
|
|
/* 2947c: 00000000 */ nop
|
|
/* 29480: 468084a0 */ cvt.s.w $f18,$f16
|
|
/* 29484: e7b200c0 */ swc1 $f18,0xc0($sp)
|
|
/* 29488: 846e0012 */ lh $t6,0x12($v1)
|
|
/* 2948c: 448e2000 */ mtc1 $t6,$f4
|
|
/* 29490: 00000000 */ nop
|
|
/* 29494: 468021a0 */ cvt.s.w $f6,$f4
|
|
/* 29498: e7a600c4 */ swc1 $f6,0xc4($sp)
|
|
/* 2949c: 8498000e */ lh $t8,0xe($a0)
|
|
/* 294a0: 44984000 */ mtc1 $t8,$f8
|
|
/* 294a4: 00000000 */ nop
|
|
/* 294a8: 468042a0 */ cvt.s.w $f10,$f8
|
|
/* 294ac: e7aa00b0 */ swc1 $f10,0xb0($sp)
|
|
/* 294b0: 84990010 */ lh $t9,0x10($a0)
|
|
/* 294b4: 44998000 */ mtc1 $t9,$f16
|
|
/* 294b8: 00000000 */ nop
|
|
/* 294bc: 468084a0 */ cvt.s.w $f18,$f16
|
|
/* 294c0: e7b200b4 */ swc1 $f18,0xb4($sp)
|
|
/* 294c4: 848c0012 */ lh $t4,0x12($a0)
|
|
/* 294c8: 448c2000 */ mtc1 $t4,$f4
|
|
/* 294cc: 00000000 */ nop
|
|
/* 294d0: 468021a0 */ cvt.s.w $f6,$f4
|
|
/* 294d4: 1000005f */ b .L00029654
|
|
/* 294d8: e7a600b8 */ swc1 $f6,0xb8($sp)
|
|
/* 294dc: 24010001 */ addiu $at,$zero,0x1
|
|
.L000294e0:
|
|
/* 294e0: 54410025 */ bnel $v0,$at,.L00029578
|
|
/* 294e4: 24010002 */ addiu $at,$zero,0x2
|
|
/* 294e8: 8e250008 */ lw $a1,0x8($s1)
|
|
/* 294ec: 910e0001 */ lbu $t6,0x1($t0)
|
|
/* 294f0: 2407000c */ addiu $a3,$zero,0xc
|
|
/* 294f4: 24ad0001 */ addiu $t5,$a1,0x1
|
|
/* 294f8: 01ae001a */ div $zero,$t5,$t6
|
|
/* 294fc: 00003010 */ mfhi $a2
|
|
/* 29500: 01001025 */ or $v0,$t0,$zero
|
|
/* 29504: 15c00002 */ bnez $t6,.L00029510
|
|
/* 29508: 00000000 */ nop
|
|
/* 2950c: 0007000d */ break 0x7
|
|
.L00029510:
|
|
/* 29510: 2401ffff */ addiu $at,$zero,-1
|
|
/* 29514: 15c10004 */ bne $t6,$at,.L00029528
|
|
/* 29518: 3c018000 */ lui $at,0x8000
|
|
/* 2951c: 15a10002 */ bne $t5,$at,.L00029528
|
|
/* 29520: 00000000 */ nop
|
|
/* 29524: 0006000d */ break 0x6
|
|
.L00029528:
|
|
/* 29528: 00a70019 */ multu $a1,$a3
|
|
/* 2952c: 00007812 */ mflo $t7
|
|
/* 29530: 004f1821 */ addu $v1,$v0,$t7
|
|
/* 29534: c4680010 */ lwc1 $f8,0x10($v1)
|
|
/* 29538: 00c70019 */ multu $a2,$a3
|
|
/* 2953c: e7a800bc */ swc1 $f8,0xbc($sp)
|
|
/* 29540: c46a0014 */ lwc1 $f10,0x14($v1)
|
|
/* 29544: e7aa00c0 */ swc1 $f10,0xc0($sp)
|
|
/* 29548: c4700018 */ lwc1 $f16,0x18($v1)
|
|
/* 2954c: 0000c012 */ mflo $t8
|
|
/* 29550: 00582021 */ addu $a0,$v0,$t8
|
|
/* 29554: e7b000c4 */ swc1 $f16,0xc4($sp)
|
|
/* 29558: c4920010 */ lwc1 $f18,0x10($a0)
|
|
/* 2955c: e7b200b0 */ swc1 $f18,0xb0($sp)
|
|
/* 29560: c4840014 */ lwc1 $f4,0x14($a0)
|
|
/* 29564: e7a400b4 */ swc1 $f4,0xb4($sp)
|
|
/* 29568: c4860018 */ lwc1 $f6,0x18($a0)
|
|
/* 2956c: 10000039 */ b .L00029654
|
|
/* 29570: e7a600b8 */ swc1 $f6,0xb8($sp)
|
|
/* 29574: 24010002 */ addiu $at,$zero,0x2
|
|
.L00029578:
|
|
/* 29578: 54410022 */ bnel $v0,$at,.L00029604
|
|
/* 2957c: 24010003 */ addiu $at,$zero,0x3
|
|
/* 29580: 910c0001 */ lbu $t4,0x1($t0)
|
|
/* 29584: 8e230008 */ lw $v1,0x8($s1)
|
|
/* 29588: 01001025 */ or $v0,$t0,$zero
|
|
/* 2958c: 24790001 */ addiu $t9,$v1,0x1
|
|
/* 29590: 032c001a */ div $zero,$t9,$t4
|
|
/* 29594: 000368c0 */ sll $t5,$v1,0x3
|
|
/* 29598: 004d2021 */ addu $a0,$v0,$t5
|
|
/* 2959c: c488000c */ lwc1 $f8,0xc($a0)
|
|
/* 295a0: 00003010 */ mfhi $a2
|
|
/* 295a4: 000670c0 */ sll $t6,$a2,0x3
|
|
/* 295a8: e7a800bc */ swc1 $f8,0xbc($sp)
|
|
/* 295ac: c64a0004 */ lwc1 $f10,0x4($s2)
|
|
/* 295b0: 004e2821 */ addu $a1,$v0,$t6
|
|
/* 295b4: 15800002 */ bnez $t4,.L000295c0
|
|
/* 295b8: 00000000 */ nop
|
|
/* 295bc: 0007000d */ break 0x7
|
|
.L000295c0:
|
|
/* 295c0: 2401ffff */ addiu $at,$zero,-1
|
|
/* 295c4: 15810004 */ bne $t4,$at,.L000295d8
|
|
/* 295c8: 3c018000 */ lui $at,0x8000
|
|
/* 295cc: 17210002 */ bne $t9,$at,.L000295d8
|
|
/* 295d0: 00000000 */ nop
|
|
/* 295d4: 0006000d */ break 0x6
|
|
.L000295d8:
|
|
/* 295d8: e7aa00c0 */ swc1 $f10,0xc0($sp)
|
|
/* 295dc: c4900010 */ lwc1 $f16,0x10($a0)
|
|
/* 295e0: e7b000c4 */ swc1 $f16,0xc4($sp)
|
|
/* 295e4: c4b2000c */ lwc1 $f18,0xc($a1)
|
|
/* 295e8: e7b200b0 */ swc1 $f18,0xb0($sp)
|
|
/* 295ec: c6440004 */ lwc1 $f4,0x4($s2)
|
|
/* 295f0: e7a400b4 */ swc1 $f4,0xb4($sp)
|
|
/* 295f4: c4a60010 */ lwc1 $f6,0x10($a1)
|
|
/* 295f8: 10000016 */ b .L00029654
|
|
/* 295fc: e7a600b8 */ swc1 $f6,0xb8($sp)
|
|
/* 29600: 24010003 */ addiu $at,$zero,0x3
|
|
.L00029604:
|
|
/* 29604: 14410013 */ bne $v0,$at,.L00029654
|
|
/* 29608: 27af00bc */ addiu $t7,$sp,0xbc
|
|
/* 2960c: c6480008 */ lwc1 $f8,0x8($s2)
|
|
/* 29610: c50c000c */ lwc1 $f12,0xc($t0)
|
|
/* 29614: c50e0010 */ lwc1 $f14,0x10($t0)
|
|
/* 29618: 8d060014 */ lw $a2,0x14($t0)
|
|
/* 2961c: 8e470000 */ lw $a3,0x0($s2)
|
|
/* 29620: 27b800c4 */ addiu $t8,$sp,0xc4
|
|
/* 29624: 27b900b0 */ addiu $t9,$sp,0xb0
|
|
/* 29628: 27ac00b8 */ addiu $t4,$sp,0xb8
|
|
/* 2962c: afac0020 */ sw $t4,0x20($sp)
|
|
/* 29630: afb9001c */ sw $t9,0x1c($sp)
|
|
/* 29634: afb80018 */ sw $t8,0x18($sp)
|
|
/* 29638: afaf0014 */ sw $t7,0x14($sp)
|
|
/* 2963c: 0c009612 */ jal cd00025848
|
|
/* 29640: e7a80010 */ swc1 $f8,0x10($sp)
|
|
/* 29644: c64a0004 */ lwc1 $f10,0x4($s2)
|
|
/* 29648: e7aa00c0 */ swc1 $f10,0xc0($sp)
|
|
/* 2964c: c6500004 */ lwc1 $f16,0x4($s2)
|
|
/* 29650: e7b000b4 */ swc1 $f16,0xb4($sp)
|
|
.L00029654:
|
|
/* 29654: 4407a000 */ mfc1 $a3,$f20
|
|
/* 29658: 27a400bc */ addiu $a0,$sp,0xbc
|
|
/* 2965c: 27a500b0 */ addiu $a1,$sp,0xb0
|
|
/* 29660: 0c00940e */ jal cd00025038
|
|
/* 29664: 8e26000c */ lw $a2,0xc($s1)
|
|
/* 29668: 8fbf0064 */ lw $ra,0x64($sp)
|
|
/* 2966c: d7b40030 */ ldc1 $f20,0x30($sp)
|
|
/* 29670: d7b60038 */ ldc1 $f22,0x38($sp)
|
|
/* 29674: 8fb00040 */ lw $s0,0x40($sp)
|
|
/* 29678: 8fb10044 */ lw $s1,0x44($sp)
|
|
/* 2967c: 8fb20048 */ lw $s2,0x48($sp)
|
|
/* 29680: 8fb3004c */ lw $s3,0x4c($sp)
|
|
/* 29684: 8fb40050 */ lw $s4,0x50($sp)
|
|
/* 29688: 8fb50054 */ lw $s5,0x54($sp)
|
|
/* 2968c: 8fb60058 */ lw $s6,0x58($sp)
|
|
/* 29690: 8fb7005c */ lw $s7,0x5c($sp)
|
|
/* 29694: 8fbe0060 */ lw $s8,0x60($sp)
|
|
/* 29698: 03e00008 */ jr $ra
|
|
/* 2969c: 27bd0108 */ addiu $sp,$sp,0x108
|
|
);
|
|
|
|
#if VERSION >= VERSION_NTSC_1_0
|
|
GLOBAL_ASM(
|
|
glabel cd000296a0
|
|
/* 296a0: 27bdfef0 */ addiu $sp,$sp,-272
|
|
/* 296a4: 3c01cf80 */ lui $at,0xcf80
|
|
/* 296a8: 44812000 */ mtc1 $at,$f4
|
|
/* 296ac: afbf0074 */ sw $ra,0x74($sp)
|
|
/* 296b0: afbe0070 */ sw $s8,0x70($sp)
|
|
/* 296b4: afb7006c */ sw $s7,0x6c($sp)
|
|
/* 296b8: afb60068 */ sw $s6,0x68($sp)
|
|
/* 296bc: afb50064 */ sw $s5,0x64($sp)
|
|
/* 296c0: afb40060 */ sw $s4,0x60($sp)
|
|
/* 296c4: afb3005c */ sw $s3,0x5c($sp)
|
|
/* 296c8: afb20058 */ sw $s2,0x58($sp)
|
|
/* 296cc: afb10054 */ sw $s1,0x54($sp)
|
|
/* 296d0: afb00050 */ sw $s0,0x50($sp)
|
|
/* 296d4: f7be0048 */ sdc1 $f30,0x48($sp)
|
|
/* 296d8: f7bc0040 */ sdc1 $f28,0x40($sp)
|
|
/* 296dc: f7ba0038 */ sdc1 $f26,0x38($sp)
|
|
/* 296e0: f7b80030 */ sdc1 $f24,0x30($sp)
|
|
/* 296e4: f7b60028 */ sdc1 $f22,0x28($sp)
|
|
/* 296e8: f7b40020 */ sdc1 $f20,0x20($sp)
|
|
/* 296ec: afa60118 */ sw $a2,0x118($sp)
|
|
/* 296f0: afa7011c */ sw $a3,0x11c($sp)
|
|
/* 296f4: afa00100 */ sw $zero,0x100($sp)
|
|
/* 296f8: e7a40104 */ swc1 $f4,0x104($sp)
|
|
/* 296fc: acc00000 */ sw $zero,0x0($a2)
|
|
/* 29700: 8c8f0000 */ lw $t7,0x0($a0)
|
|
/* 29704: 00a09025 */ or $s2,$a1,$zero
|
|
/* 29708: 00809825 */ or $s3,$a0,$zero
|
|
/* 2970c: 00008025 */ or $s0,$zero,$zero
|
|
/* 29710: 00008825 */ or $s1,$zero,$zero
|
|
/* 29714: 0000f025 */ or $s8,$zero,$zero
|
|
/* 29718: 11e00024 */ beqz $t7,.L000297ac
|
|
/* 2971c: 0080a825 */ or $s5,$a0,$zero
|
|
/* 29720: 8ea70000 */ lw $a3,0x0($s5)
|
|
/* 29724: 90e20000 */ lbu $v0,0x0($a3)
|
|
.L00029728:
|
|
/* 29728: 24010001 */ addiu $at,$zero,0x1
|
|
/* 2972c: 14400012 */ bnez $v0,.L00029778
|
|
/* 29730: 00000000 */ nop
|
|
/* 29734: 94e20002 */ lhu $v0,0x2($a3)
|
|
/* 29738: 00e02025 */ or $a0,$a3,$zero
|
|
/* 2973c: 30584000 */ andi $t8,$v0,0x4000
|
|
/* 29740: 13000003 */ beqz $t8,.L00029750
|
|
/* 29744: 30590100 */ andi $t9,$v0,0x100
|
|
/* 29748: 10000014 */ b .L0002979c
|
|
/* 2974c: aea00004 */ sw $zero,0x4($s5)
|
|
.L00029750:
|
|
/* 29750: 53200003 */ beqzl $t9,.L00029760
|
|
/* 29754: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 29758: 24110001 */ addiu $s1,$zero,0x1
|
|
/* 2975c: 8e450000 */ lw $a1,0x0($s2)
|
|
.L00029760:
|
|
/* 29760: 0c0098a2 */ jal cdIs2dPointInIntTile
|
|
/* 29764: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 29768: 1040000c */ beqz $v0,.L0002979c
|
|
/* 2976c: aea20004 */ sw $v0,0x4($s5)
|
|
/* 29770: 1000000a */ b .L0002979c
|
|
/* 29774: 24100001 */ addiu $s0,$zero,0x1
|
|
.L00029778:
|
|
/* 29778: 54410009 */ bnel $v0,$at,.L000297a0
|
|
/* 2977c: 8ea70014 */ lw $a3,0x14($s5)
|
|
/* 29780: 00e02025 */ or $a0,$a3,$zero
|
|
/* 29784: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 29788: 0c0098f9 */ jal cdIs2dPointInFltTile
|
|
/* 2978c: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 29790: 10400002 */ beqz $v0,.L0002979c
|
|
/* 29794: aea20004 */ sw $v0,0x4($s5)
|
|
/* 29798: 24100001 */ addiu $s0,$zero,0x1
|
|
.L0002979c:
|
|
/* 2979c: 8ea70014 */ lw $a3,0x14($s5)
|
|
.L000297a0:
|
|
/* 297a0: 26b50014 */ addiu $s5,$s5,0x14
|
|
/* 297a4: 54e0ffe0 */ bnezl $a3,.L00029728
|
|
/* 297a8: 90e20000 */ lbu $v0,0x0($a3)
|
|
.L000297ac:
|
|
/* 297ac: 52000068 */ beqzl $s0,.L00029950
|
|
/* 297b0: 8fae0100 */ lw $t6,0x100($sp)
|
|
/* 297b4: 8e620000 */ lw $v0,0x0($s3)
|
|
/* 297b8: 0260a825 */ or $s5,$s3,$zero
|
|
/* 297bc: 1040003c */ beqz $v0,.L000298b0
|
|
/* 297c0: 00000000 */ nop
|
|
/* 297c4: 8ea80004 */ lw $t0,0x4($s5)
|
|
.L000297c8:
|
|
/* 297c8: 51000034 */ beqzl $t0,.L0002989c
|
|
/* 297cc: 8eaf0014 */ lw $t7,0x14($s5)
|
|
/* 297d0: 8ea70000 */ lw $a3,0x0($s5)
|
|
/* 297d4: 24010001 */ addiu $at,$zero,0x1
|
|
/* 297d8: 90e20000 */ lbu $v0,0x0($a3)
|
|
/* 297dc: 14400019 */ bnez $v0,.L00029844
|
|
/* 297e0: 00000000 */ nop
|
|
/* 297e4: 94e90002 */ lhu $t1,0x2($a3)
|
|
/* 297e8: 312a2000 */ andi $t2,$t1,0x2000
|
|
/* 297ec: 5540002b */ bnezl $t2,.L0002989c
|
|
/* 297f0: 8eaf0014 */ lw $t7,0x14($s5)
|
|
/* 297f4: 00e02025 */ or $a0,$a3,$zero
|
|
/* 297f8: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 297fc: 0c0097e4 */ jal cdFindGroundInIntTile
|
|
/* 29800: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 29804: c7a60104 */ lwc1 $f6,0x104($sp)
|
|
/* 29808: 4600303e */ c.le.s $f6,$f0
|
|
/* 2980c: 00000000 */ nop
|
|
/* 29810: 45020022 */ bc1fl .L0002989c
|
|
/* 29814: 8eaf0014 */ lw $t7,0x14($s5)
|
|
/* 29818: c6480004 */ lwc1 $f8,0x4($s2)
|
|
/* 2981c: 4608003c */ c.lt.s $f0,$f8
|
|
/* 29820: 00000000 */ nop
|
|
/* 29824: 4502001d */ bc1fl .L0002989c
|
|
/* 29828: 8eaf0014 */ lw $t7,0x14($s5)
|
|
/* 2982c: 8fab0118 */ lw $t3,0x118($sp)
|
|
/* 29830: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29834: 240c0001 */ addiu $t4,$zero,0x1
|
|
/* 29838: ad750000 */ sw $s5,0x0($t3)
|
|
/* 2983c: 10000016 */ b .L00029898
|
|
/* 29840: afac0100 */ sw $t4,0x100($sp)
|
|
.L00029844:
|
|
/* 29844: 54410015 */ bnel $v0,$at,.L0002989c
|
|
/* 29848: 8eaf0014 */ lw $t7,0x14($s5)
|
|
/* 2984c: 00e02025 */ or $a0,$a3,$zero
|
|
/* 29850: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 29854: 0c009833 */ jal cdFindGroundInFltTile
|
|
/* 29858: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 2985c: c7aa0104 */ lwc1 $f10,0x104($sp)
|
|
/* 29860: 4600503e */ c.le.s $f10,$f0
|
|
/* 29864: 00000000 */ nop
|
|
/* 29868: 4502000c */ bc1fl .L0002989c
|
|
/* 2986c: 8eaf0014 */ lw $t7,0x14($s5)
|
|
/* 29870: c6500004 */ lwc1 $f16,0x4($s2)
|
|
/* 29874: 4610003c */ c.lt.s $f0,$f16
|
|
/* 29878: 00000000 */ nop
|
|
/* 2987c: 45020007 */ bc1fl .L0002989c
|
|
/* 29880: 8eaf0014 */ lw $t7,0x14($s5)
|
|
/* 29884: 8fad0118 */ lw $t5,0x118($sp)
|
|
/* 29888: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 2988c: 240e0001 */ addiu $t6,$zero,0x1
|
|
/* 29890: adb50000 */ sw $s5,0x0($t5)
|
|
/* 29894: afae0100 */ sw $t6,0x100($sp)
|
|
.L00029898:
|
|
/* 29898: 8eaf0014 */ lw $t7,0x14($s5)
|
|
.L0002989c:
|
|
/* 2989c: 26b50014 */ addiu $s5,$s5,0x14
|
|
/* 298a0: 55e0ffc9 */ bnezl $t7,.L000297c8
|
|
/* 298a4: 8ea80004 */ lw $t0,0x4($s5)
|
|
/* 298a8: 0260a825 */ or $s5,$s3,$zero
|
|
/* 298ac: 8e620000 */ lw $v0,0x0($s3)
|
|
.L000298b0:
|
|
/* 298b0: 50400027 */ beqzl $v0,.L00029950
|
|
/* 298b4: 8fae0100 */ lw $t6,0x100($sp)
|
|
/* 298b8: 8eb80004 */ lw $t8,0x4($s5)
|
|
.L000298bc:
|
|
/* 298bc: 53000020 */ beqzl $t8,.L00029940
|
|
/* 298c0: 8ead0014 */ lw $t5,0x14($s5)
|
|
/* 298c4: 8ea70000 */ lw $a3,0x0($s5)
|
|
/* 298c8: 90f90000 */ lbu $t9,0x0($a3)
|
|
/* 298cc: 5720001c */ bnezl $t9,.L00029940
|
|
/* 298d0: 8ead0014 */ lw $t5,0x14($s5)
|
|
/* 298d4: 94e80002 */ lhu $t0,0x2($a3)
|
|
/* 298d8: 31092000 */ andi $t1,$t0,0x2000
|
|
/* 298dc: 51200018 */ beqzl $t1,.L00029940
|
|
/* 298e0: 8ead0014 */ lw $t5,0x14($s5)
|
|
/* 298e4: 00e02025 */ or $a0,$a3,$zero
|
|
/* 298e8: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 298ec: 0c0097e4 */ jal cdFindGroundInIntTile
|
|
/* 298f0: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 298f4: c7b20104 */ lwc1 $f18,0x104($sp)
|
|
/* 298f8: 4600903e */ c.le.s $f18,$f0
|
|
/* 298fc: 00000000 */ nop
|
|
/* 29900: 4502000f */ bc1fl .L00029940
|
|
/* 29904: 8ead0014 */ lw $t5,0x14($s5)
|
|
/* 29908: c6440004 */ lwc1 $f4,0x4($s2)
|
|
/* 2990c: 4604003c */ c.lt.s $f0,$f4
|
|
/* 29910: 00000000 */ nop
|
|
/* 29914: 45030005 */ bc1tl .L0002992c
|
|
/* 29918: 8fab0118 */ lw $t3,0x118($sp)
|
|
/* 2991c: 8faa0100 */ lw $t2,0x100($sp)
|
|
/* 29920: 55400007 */ bnezl $t2,.L00029940
|
|
/* 29924: 8ead0014 */ lw $t5,0x14($s5)
|
|
/* 29928: 8fab0118 */ lw $t3,0x118($sp)
|
|
.L0002992c:
|
|
/* 2992c: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29930: 240c0001 */ addiu $t4,$zero,0x1
|
|
/* 29934: ad750000 */ sw $s5,0x0($t3)
|
|
/* 29938: afac0100 */ sw $t4,0x100($sp)
|
|
/* 2993c: 8ead0014 */ lw $t5,0x14($s5)
|
|
.L00029940:
|
|
/* 29940: 26b50014 */ addiu $s5,$s5,0x14
|
|
/* 29944: 55a0ffdd */ bnezl $t5,.L000298bc
|
|
/* 29948: 8eb80004 */ lw $t8,0x4($s5)
|
|
/* 2994c: 8fae0100 */ lw $t6,0x100($sp)
|
|
.L00029950:
|
|
/* 29950: 3c014f80 */ lui $at,0x4f80
|
|
/* 29954: 11c00003 */ beqz $t6,.L00029964
|
|
/* 29958: afae00f0 */ sw $t6,0xf0($sp)
|
|
/* 2995c: 52200195 */ beqzl $s1,.L00029fb4
|
|
/* 29960: 8fbf0074 */ lw $ra,0x74($sp)
|
|
.L00029964:
|
|
/* 29964: 44813000 */ mtc1 $at,$f6
|
|
/* 29968: 0260a825 */ or $s5,$s3,$zero
|
|
/* 2996c: e7a600e4 */ swc1 $f6,0xe4($sp)
|
|
/* 29970: 8e6f0000 */ lw $t7,0x0($s3)
|
|
/* 29974: 51e0018f */ beqzl $t7,.L00029fb4
|
|
/* 29978: 8fbf0074 */ lw $ra,0x74($sp)
|
|
/* 2997c: 8eb80004 */ lw $t8,0x4($s5)
|
|
.L00029980:
|
|
/* 29980: 8fb900f0 */ lw $t9,0xf0($sp)
|
|
/* 29984: 57000187 */ bnezl $t8,.L00029fa4
|
|
/* 29988: 8ea80014 */ lw $t0,0x14($s5)
|
|
/* 2998c: 13200008 */ beqz $t9,.L000299b0
|
|
/* 29990: 8ea70000 */ lw $a3,0x0($s5)
|
|
/* 29994: 90e80000 */ lbu $t0,0x0($a3)
|
|
/* 29998: 55000182 */ bnezl $t0,.L00029fa4
|
|
/* 2999c: 8ea80014 */ lw $t0,0x14($s5)
|
|
/* 299a0: 94e90002 */ lhu $t1,0x2($a3)
|
|
/* 299a4: 312a0100 */ andi $t2,$t1,0x100
|
|
/* 299a8: 5140017e */ beqzl $t2,.L00029fa4
|
|
/* 299ac: 8ea80014 */ lw $t0,0x14($s5)
|
|
.L000299b0:
|
|
/* 299b0: 90e20000 */ lbu $v0,0x0($a3)
|
|
/* 299b4: 544000d8 */ bnezl $v0,.L00029d18
|
|
/* 299b8: 24010001 */ addiu $at,$zero,0x1
|
|
/* 299bc: 94f70002 */ lhu $s7,0x2($a3)
|
|
/* 299c0: 00e0a025 */ or $s4,$a3,$zero
|
|
/* 299c4: 90e20001 */ lbu $v0,0x1($a3)
|
|
/* 299c8: 32eb4000 */ andi $t3,$s7,0x4000
|
|
/* 299cc: 000b602b */ sltu $t4,$zero,$t3
|
|
/* 299d0: 11800004 */ beqz $t4,.L000299e4
|
|
/* 299d4: 0180b825 */ or $s7,$t4,$zero
|
|
/* 299d8: 8fad0100 */ lw $t5,0x100($sp)
|
|
/* 299dc: 55a00171 */ bnezl $t5,.L00029fa4
|
|
/* 299e0: 8ea80014 */ lw $t0,0x14($s5)
|
|
.L000299e4:
|
|
/* 299e4: 1840016e */ blez $v0,.L00029fa0
|
|
/* 299e8: 00008825 */ or $s1,$zero,$zero
|
|
/* 299ec: 02809825 */ or $s3,$s4,$zero
|
|
/* 299f0: afa200bc */ sw $v0,0xbc($sp)
|
|
/* 299f4: 8fa200bc */ lw $v0,0xbc($sp)
|
|
.L000299f8:
|
|
/* 299f8: 26360001 */ addiu $s6,$s1,0x1
|
|
/* 299fc: 866e000e */ lh $t6,0xe($s3)
|
|
/* 29a00: 02c2001a */ div $zero,$s6,$v0
|
|
/* 29a04: 0000c010 */ mfhi $t8
|
|
/* 29a08: 0018c880 */ sll $t9,$t8,0x2
|
|
/* 29a0c: 0338c823 */ subu $t9,$t9,$t8
|
|
/* 29a10: 0019c840 */ sll $t9,$t9,0x1
|
|
/* 29a14: 02998021 */ addu $s0,$s4,$t9
|
|
/* 29a18: 8608000e */ lh $t0,0xe($s0)
|
|
/* 29a1c: 86090012 */ lh $t1,0x12($s0)
|
|
/* 29a20: 866f0012 */ lh $t7,0x12($s3)
|
|
/* 29a24: 44888000 */ mtc1 $t0,$f16
|
|
/* 29a28: 44899000 */ mtc1 $t1,$f18
|
|
/* 29a2c: 448e4000 */ mtc1 $t6,$f8
|
|
/* 29a30: 448f5000 */ mtc1 $t7,$f10
|
|
/* 29a34: 468086a0 */ cvt.s.w $f26,$f16
|
|
/* 29a38: c6440000 */ lwc1 $f4,0x0($s2)
|
|
/* 29a3c: e7a40010 */ swc1 $f4,0x10($sp)
|
|
/* 29a40: 46809720 */ cvt.s.w $f28,$f18
|
|
/* 29a44: c6460008 */ lwc1 $f6,0x8($s2)
|
|
/* 29a48: 4406d000 */ mfc1 $a2,$f26
|
|
/* 29a4c: e7a60014 */ swc1 $f6,0x14($sp)
|
|
/* 29a50: 468045a0 */ cvt.s.w $f22,$f8
|
|
/* 29a54: 4407e000 */ mfc1 $a3,$f28
|
|
/* 29a58: 46805620 */ cvt.s.w $f24,$f10
|
|
/* 29a5c: 14400002 */ bnez $v0,.L00029a68
|
|
/* 29a60: 00000000 */ nop
|
|
/* 29a64: 0007000d */ break 0x7
|
|
.L00029a68:
|
|
/* 29a68: 2401ffff */ addiu $at,$zero,-1
|
|
/* 29a6c: 14410004 */ bne $v0,$at,.L00029a80
|
|
/* 29a70: 3c018000 */ lui $at,0x8000
|
|
/* 29a74: 16c10002 */ bne $s6,$at,.L00029a80
|
|
/* 29a78: 00000000 */ nop
|
|
/* 29a7c: 0006000d */ break 0x6
|
|
.L00029a80:
|
|
/* 29a80: 4600c386 */ mov.s $f14,$f24
|
|
/* 29a84: 0c009595 */ jal cd00025654
|
|
/* 29a88: 4600b306 */ mov.s $f12,$f22
|
|
/* 29a8c: 44804000 */ mtc1 $zero,$f8
|
|
/* 29a90: e7a000d4 */ swc1 $f0,0xd4($sp)
|
|
/* 29a94: 46000786 */ mov.s $f30,$f0
|
|
/* 29a98: 4608003c */ c.lt.s $f0,$f8
|
|
/* 29a9c: c7aa00e4 */ lwc1 $f10,0xe4($sp)
|
|
/* 29aa0: 45020003 */ bc1fl .L00029ab0
|
|
/* 29aa4: 460af03c */ c.lt.s $f30,$f10
|
|
/* 29aa8: 46000787 */ neg.s $f30,$f0
|
|
/* 29aac: 460af03c */ c.lt.s $f30,$f10
|
|
.L00029ab0:
|
|
/* 29ab0: 00000000 */ nop
|
|
/* 29ab4: 45030004 */ bc1tl .L00029ac8
|
|
/* 29ab8: c6500000 */ lwc1 $f16,0x0($s2)
|
|
/* 29abc: 53c0008f */ beqzl $s8,.L00029cfc
|
|
/* 29ac0: 8fa900bc */ lw $t1,0xbc($sp)
|
|
/* 29ac4: c6500000 */ lwc1 $f16,0x0($s2)
|
|
.L00029ac8:
|
|
/* 29ac8: 4406d000 */ mfc1 $a2,$f26
|
|
/* 29acc: 4407e000 */ mfc1 $a3,$f28
|
|
/* 29ad0: e7b00010 */ swc1 $f16,0x10($sp)
|
|
/* 29ad4: c6520008 */ lwc1 $f18,0x8($s2)
|
|
/* 29ad8: 4600b306 */ mov.s $f12,$f22
|
|
/* 29adc: 4600c386 */ mov.s $f14,$f24
|
|
/* 29ae0: 0c0095dd */ jal cd00025774
|
|
/* 29ae4: e7b20014 */ swc1 $f18,0x14($sp)
|
|
/* 29ae8: 5040002c */ beqzl $v0,.L00029b9c
|
|
/* 29aec: 4600b306 */ mov.s $f12,$f22
|
|
/* 29af0: 4616d001 */ sub.s $f0,$f26,$f22
|
|
/* 29af4: 4618e501 */ sub.s $f20,$f28,$f24
|
|
/* 29af8: 46000102 */ mul.s $f4,$f0,$f0
|
|
/* 29afc: e7a000b8 */ swc1 $f0,0xb8($sp)
|
|
/* 29b00: 4614a182 */ mul.s $f6,$f20,$f20
|
|
/* 29b04: 0c012974 */ jal sqrtf
|
|
/* 29b08: 46062300 */ add.s $f12,$f4,$f6
|
|
/* 29b0c: c7a800d4 */ lwc1 $f8,0xd4($sp)
|
|
/* 29b10: 4600a407 */ neg.s $f16,$f20
|
|
/* 29b14: c7a600b8 */ lwc1 $f6,0xb8($sp)
|
|
/* 29b18: 46004383 */ div.s $f14,$f8,$f0
|
|
/* 29b1c: c64a0000 */ lwc1 $f10,0x0($s2)
|
|
/* 29b20: c6440008 */ lwc1 $f4,0x8($s2)
|
|
/* 29b24: 02802025 */ or $a0,$s4,$zero
|
|
/* 29b28: 02203825 */ or $a3,$s1,$zero
|
|
/* 29b2c: 46107482 */ mul.s $f18,$f14,$f16
|
|
/* 29b30: 00000000 */ nop
|
|
/* 29b34: 46067202 */ mul.s $f8,$f14,$f6
|
|
/* 29b38: 46125080 */ add.s $f2,$f10,$f18
|
|
/* 29b3c: 46082300 */ add.s $f12,$f4,$f8
|
|
/* 29b40: 44051000 */ mfc1 $a1,$f2
|
|
/* 29b44: 44066000 */ mfc1 $a2,$f12
|
|
/* 29b48: 0c00971d */ jal cdFindGroundInIntTileAtVertex
|
|
/* 29b4c: 00000000 */ nop
|
|
/* 29b50: c6500004 */ lwc1 $f16,0x4($s2)
|
|
/* 29b54: 4610003c */ c.lt.s $f0,$f16
|
|
/* 29b58: 00000000 */ nop
|
|
/* 29b5c: 45030007 */ bc1tl .L00029b7c
|
|
/* 29b60: 8fad0118 */ lw $t5,0x118($sp)
|
|
/* 29b64: 8eaa0000 */ lw $t2,0x0($s5)
|
|
/* 29b68: 954b0002 */ lhu $t3,0x2($t2)
|
|
/* 29b6c: 316c2000 */ andi $t4,$t3,0x2000
|
|
/* 29b70: 51800062 */ beqzl $t4,.L00029cfc
|
|
/* 29b74: 8fa900bc */ lw $t1,0xbc($sp)
|
|
/* 29b78: 8fad0118 */ lw $t5,0x118($sp)
|
|
.L00029b7c:
|
|
/* 29b7c: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29b80: 240e0001 */ addiu $t6,$zero,0x1
|
|
/* 29b84: adb50000 */ sw $s5,0x0($t5)
|
|
/* 29b88: e7be00e4 */ swc1 $f30,0xe4($sp)
|
|
/* 29b8c: afae0100 */ sw $t6,0x100($sp)
|
|
/* 29b90: 10000059 */ b .L00029cf8
|
|
/* 29b94: 02e0f025 */ or $s8,$s7,$zero
|
|
/* 29b98: 4600b306 */ mov.s $f12,$f22
|
|
.L00029b9c:
|
|
/* 29b9c: 4600c386 */ mov.s $f14,$f24
|
|
/* 29ba0: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 29ba4: 0c0095c9 */ jal cd00025724
|
|
/* 29ba8: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 29bac: 46000506 */ mov.s $f20,$f0
|
|
/* 29bb0: 4600d306 */ mov.s $f12,$f26
|
|
/* 29bb4: 4600e386 */ mov.s $f14,$f28
|
|
/* 29bb8: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 29bbc: 0c0095c9 */ jal cd00025724
|
|
/* 29bc0: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 29bc4: 4600a03c */ c.lt.s $f20,$f0
|
|
/* 29bc8: 46000586 */ mov.s $f22,$f0
|
|
/* 29bcc: 45020027 */ bc1fl .L00029c6c
|
|
/* 29bd0: c7a800e4 */ lwc1 $f8,0xe4($sp)
|
|
/* 29bd4: c7aa00e4 */ lwc1 $f10,0xe4($sp)
|
|
/* 29bd8: 460aa03c */ c.lt.s $f20,$f10
|
|
/* 29bdc: 00000000 */ nop
|
|
/* 29be0: 45030004 */ bc1tl .L00029bf4
|
|
/* 29be4: 866f000e */ lh $t7,0xe($s3)
|
|
/* 29be8: 53c00044 */ beqzl $s8,.L00029cfc
|
|
/* 29bec: 8fa900bc */ lw $t1,0xbc($sp)
|
|
/* 29bf0: 866f000e */ lh $t7,0xe($s3)
|
|
.L00029bf4:
|
|
/* 29bf4: 86780012 */ lh $t8,0x12($s3)
|
|
/* 29bf8: 02802025 */ or $a0,$s4,$zero
|
|
/* 29bfc: 448f9000 */ mtc1 $t7,$f18
|
|
/* 29c00: 44983000 */ mtc1 $t8,$f6
|
|
/* 29c04: 02203825 */ or $a3,$s1,$zero
|
|
/* 29c08: 468090a0 */ cvt.s.w $f2,$f18
|
|
/* 29c0c: 46803320 */ cvt.s.w $f12,$f6
|
|
/* 29c10: 44051000 */ mfc1 $a1,$f2
|
|
/* 29c14: 44066000 */ mfc1 $a2,$f12
|
|
/* 29c18: 0c00971d */ jal cdFindGroundInIntTileAtVertex
|
|
/* 29c1c: 00000000 */ nop
|
|
/* 29c20: c6440004 */ lwc1 $f4,0x4($s2)
|
|
/* 29c24: 4604003c */ c.lt.s $f0,$f4
|
|
/* 29c28: 00000000 */ nop
|
|
/* 29c2c: 45030007 */ bc1tl .L00029c4c
|
|
/* 29c30: 8faa0118 */ lw $t2,0x118($sp)
|
|
/* 29c34: 8eb90000 */ lw $t9,0x0($s5)
|
|
/* 29c38: 97280002 */ lhu $t0,0x2($t9)
|
|
/* 29c3c: 31092000 */ andi $t1,$t0,0x2000
|
|
/* 29c40: 5120002e */ beqzl $t1,.L00029cfc
|
|
/* 29c44: 8fa900bc */ lw $t1,0xbc($sp)
|
|
/* 29c48: 8faa0118 */ lw $t2,0x118($sp)
|
|
.L00029c4c:
|
|
/* 29c4c: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29c50: 240b0001 */ addiu $t3,$zero,0x1
|
|
/* 29c54: ad550000 */ sw $s5,0x0($t2)
|
|
/* 29c58: e7b400e4 */ swc1 $f20,0xe4($sp)
|
|
/* 29c5c: afab0100 */ sw $t3,0x100($sp)
|
|
/* 29c60: 10000025 */ b .L00029cf8
|
|
/* 29c64: 02e0f025 */ or $s8,$s7,$zero
|
|
/* 29c68: c7a800e4 */ lwc1 $f8,0xe4($sp)
|
|
.L00029c6c:
|
|
/* 29c6c: 4608003c */ c.lt.s $f0,$f8
|
|
/* 29c70: 00000000 */ nop
|
|
/* 29c74: 45030004 */ bc1tl .L00029c88
|
|
/* 29c78: 860c000e */ lh $t4,0xe($s0)
|
|
/* 29c7c: 53c0001f */ beqzl $s8,.L00029cfc
|
|
/* 29c80: 8fa900bc */ lw $t1,0xbc($sp)
|
|
/* 29c84: 860c000e */ lh $t4,0xe($s0)
|
|
.L00029c88:
|
|
/* 29c88: 860d0012 */ lh $t5,0x12($s0)
|
|
/* 29c8c: 02802025 */ or $a0,$s4,$zero
|
|
/* 29c90: 448c8000 */ mtc1 $t4,$f16
|
|
/* 29c94: 448d5000 */ mtc1 $t5,$f10
|
|
/* 29c98: 02203825 */ or $a3,$s1,$zero
|
|
/* 29c9c: 468080a0 */ cvt.s.w $f2,$f16
|
|
/* 29ca0: 46805320 */ cvt.s.w $f12,$f10
|
|
/* 29ca4: 44051000 */ mfc1 $a1,$f2
|
|
/* 29ca8: 44066000 */ mfc1 $a2,$f12
|
|
/* 29cac: 0c00971d */ jal cdFindGroundInIntTileAtVertex
|
|
/* 29cb0: 00000000 */ nop
|
|
/* 29cb4: c6520004 */ lwc1 $f18,0x4($s2)
|
|
/* 29cb8: 4612003c */ c.lt.s $f0,$f18
|
|
/* 29cbc: 00000000 */ nop
|
|
/* 29cc0: 45030007 */ bc1tl .L00029ce0
|
|
/* 29cc4: 8fb90118 */ lw $t9,0x118($sp)
|
|
/* 29cc8: 8eae0000 */ lw $t6,0x0($s5)
|
|
/* 29ccc: 95cf0002 */ lhu $t7,0x2($t6)
|
|
/* 29cd0: 31f82000 */ andi $t8,$t7,0x2000
|
|
/* 29cd4: 53000009 */ beqzl $t8,.L00029cfc
|
|
/* 29cd8: 8fa900bc */ lw $t1,0xbc($sp)
|
|
/* 29cdc: 8fb90118 */ lw $t9,0x118($sp)
|
|
.L00029ce0:
|
|
/* 29ce0: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29ce4: 24080001 */ addiu $t0,$zero,0x1
|
|
/* 29ce8: af350000 */ sw $s5,0x0($t9)
|
|
/* 29cec: e7b600e4 */ swc1 $f22,0xe4($sp)
|
|
/* 29cf0: afa80100 */ sw $t0,0x100($sp)
|
|
/* 29cf4: 02e0f025 */ or $s8,$s7,$zero
|
|
.L00029cf8:
|
|
/* 29cf8: 8fa900bc */ lw $t1,0xbc($sp)
|
|
.L00029cfc:
|
|
/* 29cfc: 02c08825 */ or $s1,$s6,$zero
|
|
/* 29d00: 26730006 */ addiu $s3,$s3,0x6
|
|
/* 29d04: 56c9ff3c */ bnel $s6,$t1,.L000299f8
|
|
/* 29d08: 8fa200bc */ lw $v0,0xbc($sp)
|
|
/* 29d0c: 100000a5 */ b .L00029fa4
|
|
/* 29d10: 8ea80014 */ lw $t0,0x14($s5)
|
|
/* 29d14: 24010001 */ addiu $at,$zero,0x1
|
|
.L00029d18:
|
|
/* 29d18: 544100a2 */ bnel $v0,$at,.L00029fa4
|
|
/* 29d1c: 8ea80014 */ lw $t0,0x14($s5)
|
|
/* 29d20: 90f60001 */ lbu $s6,0x1($a3)
|
|
/* 29d24: 00e09825 */ or $s3,$a3,$zero
|
|
/* 29d28: 00001025 */ or $v0,$zero,$zero
|
|
/* 29d2c: 1ac0009c */ blez $s6,.L00029fa0
|
|
/* 29d30: 00e08825 */ or $s1,$a3,$zero
|
|
.L00029d34:
|
|
/* 29d34: 24540001 */ addiu $s4,$v0,0x1
|
|
/* 29d38: 0296001a */ div $zero,$s4,$s6
|
|
/* 29d3c: 00005010 */ mfhi $t2
|
|
/* 29d40: 000a5880 */ sll $t3,$t2,0x2
|
|
/* 29d44: 016a5823 */ subu $t3,$t3,$t2
|
|
/* 29d48: 000b5880 */ sll $t3,$t3,0x2
|
|
/* 29d4c: 026b8021 */ addu $s0,$s3,$t3
|
|
/* 29d50: c6460000 */ lwc1 $f6,0x0($s2)
|
|
/* 29d54: c61a0010 */ lwc1 $f26,0x10($s0)
|
|
/* 29d58: c61c0018 */ lwc1 $f28,0x18($s0)
|
|
/* 29d5c: c6360010 */ lwc1 $f22,0x10($s1)
|
|
/* 29d60: c6380018 */ lwc1 $f24,0x18($s1)
|
|
/* 29d64: e7a60010 */ swc1 $f6,0x10($sp)
|
|
/* 29d68: c6440008 */ lwc1 $f4,0x8($s2)
|
|
/* 29d6c: 16c00002 */ bnez $s6,.L00029d78
|
|
/* 29d70: 00000000 */ nop
|
|
/* 29d74: 0007000d */ break 0x7
|
|
.L00029d78:
|
|
/* 29d78: 2401ffff */ addiu $at,$zero,-1
|
|
/* 29d7c: 16c10004 */ bne $s6,$at,.L00029d90
|
|
/* 29d80: 3c018000 */ lui $at,0x8000
|
|
/* 29d84: 16810002 */ bne $s4,$at,.L00029d90
|
|
/* 29d88: 00000000 */ nop
|
|
/* 29d8c: 0006000d */ break 0x6
|
|
.L00029d90:
|
|
/* 29d90: 4406d000 */ mfc1 $a2,$f26
|
|
/* 29d94: 4407e000 */ mfc1 $a3,$f28
|
|
/* 29d98: 4600b306 */ mov.s $f12,$f22
|
|
/* 29d9c: 4600c386 */ mov.s $f14,$f24
|
|
/* 29da0: 0c009595 */ jal cd00025654
|
|
/* 29da4: e7a40014 */ swc1 $f4,0x14($sp)
|
|
/* 29da8: 44804000 */ mtc1 $zero,$f8
|
|
/* 29dac: e7a00094 */ swc1 $f0,0x94($sp)
|
|
/* 29db0: 46000786 */ mov.s $f30,$f0
|
|
/* 29db4: 4608003c */ c.lt.s $f0,$f8
|
|
/* 29db8: c7b000e4 */ lwc1 $f16,0xe4($sp)
|
|
/* 29dbc: 45020003 */ bc1fl .L00029dcc
|
|
/* 29dc0: 4610f03c */ c.lt.s $f30,$f16
|
|
/* 29dc4: 46000787 */ neg.s $f30,$f0
|
|
/* 29dc8: 4610f03c */ c.lt.s $f30,$f16
|
|
.L00029dcc:
|
|
/* 29dcc: 00000000 */ nop
|
|
/* 29dd0: 45020071 */ bc1fl .L00029f98
|
|
/* 29dd4: 02801025 */ or $v0,$s4,$zero
|
|
/* 29dd8: c64a0000 */ lwc1 $f10,0x0($s2)
|
|
/* 29ddc: 4406d000 */ mfc1 $a2,$f26
|
|
/* 29de0: 4407e000 */ mfc1 $a3,$f28
|
|
/* 29de4: e7aa0010 */ swc1 $f10,0x10($sp)
|
|
/* 29de8: c6520008 */ lwc1 $f18,0x8($s2)
|
|
/* 29dec: 4600b306 */ mov.s $f12,$f22
|
|
/* 29df0: 4600c386 */ mov.s $f14,$f24
|
|
/* 29df4: 0c0095dd */ jal cd00025774
|
|
/* 29df8: e7b20014 */ swc1 $f18,0x14($sp)
|
|
/* 29dfc: 50400026 */ beqzl $v0,.L00029e98
|
|
/* 29e00: 4600b306 */ mov.s $f12,$f22
|
|
/* 29e04: 4616d001 */ sub.s $f0,$f26,$f22
|
|
/* 29e08: 4618e501 */ sub.s $f20,$f28,$f24
|
|
/* 29e0c: 46000182 */ mul.s $f6,$f0,$f0
|
|
/* 29e10: e7a00078 */ swc1 $f0,0x78($sp)
|
|
/* 29e14: 4614a102 */ mul.s $f4,$f20,$f20
|
|
/* 29e18: 0c012974 */ jal sqrtf
|
|
/* 29e1c: 46043300 */ add.s $f12,$f6,$f4
|
|
/* 29e20: c7a80094 */ lwc1 $f8,0x94($sp)
|
|
/* 29e24: 4600a287 */ neg.s $f10,$f20
|
|
/* 29e28: c7a40078 */ lwc1 $f4,0x78($sp)
|
|
/* 29e2c: 46004383 */ div.s $f14,$f8,$f0
|
|
/* 29e30: c6500000 */ lwc1 $f16,0x0($s2)
|
|
/* 29e34: c6460008 */ lwc1 $f6,0x8($s2)
|
|
/* 29e38: 02602025 */ or $a0,$s3,$zero
|
|
/* 29e3c: 460a7482 */ mul.s $f18,$f14,$f10
|
|
/* 29e40: 00000000 */ nop
|
|
/* 29e44: 46047202 */ mul.s $f8,$f14,$f4
|
|
/* 29e48: 46128080 */ add.s $f2,$f16,$f18
|
|
/* 29e4c: 46083300 */ add.s $f12,$f6,$f8
|
|
/* 29e50: 44051000 */ mfc1 $a1,$f2
|
|
/* 29e54: 44066000 */ mfc1 $a2,$f12
|
|
/* 29e58: 0c009833 */ jal cdFindGroundInFltTile
|
|
/* 29e5c: 00000000 */ nop
|
|
/* 29e60: c64a0004 */ lwc1 $f10,0x4($s2)
|
|
/* 29e64: 460a003c */ c.lt.s $f0,$f10
|
|
/* 29e68: 00000000 */ nop
|
|
/* 29e6c: 4502004a */ bc1fl .L00029f98
|
|
/* 29e70: 02801025 */ or $v0,$s4,$zero
|
|
/* 29e74: 8fac0118 */ lw $t4,0x118($sp)
|
|
/* 29e78: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29e7c: 240d0001 */ addiu $t5,$zero,0x1
|
|
/* 29e80: ad950000 */ sw $s5,0x0($t4)
|
|
/* 29e84: e7be00e4 */ swc1 $f30,0xe4($sp)
|
|
/* 29e88: afad0100 */ sw $t5,0x100($sp)
|
|
/* 29e8c: 10000041 */ b .L00029f94
|
|
/* 29e90: 0000f025 */ or $s8,$zero,$zero
|
|
/* 29e94: 4600b306 */ mov.s $f12,$f22
|
|
.L00029e98:
|
|
/* 29e98: 4600c386 */ mov.s $f14,$f24
|
|
/* 29e9c: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 29ea0: 0c0095c9 */ jal cd00025724
|
|
/* 29ea4: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 29ea8: 46000506 */ mov.s $f20,$f0
|
|
/* 29eac: 4600d306 */ mov.s $f12,$f26
|
|
/* 29eb0: 4600e386 */ mov.s $f14,$f28
|
|
/* 29eb4: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 29eb8: 0c0095c9 */ jal cd00025724
|
|
/* 29ebc: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 29ec0: 4600a03c */ c.lt.s $f20,$f0
|
|
/* 29ec4: 46000586 */ mov.s $f22,$f0
|
|
/* 29ec8: 4502001b */ bc1fl .L00029f38
|
|
/* 29ecc: c7a400e4 */ lwc1 $f4,0xe4($sp)
|
|
/* 29ed0: c7b000e4 */ lwc1 $f16,0xe4($sp)
|
|
/* 29ed4: 4610a03c */ c.lt.s $f20,$f16
|
|
/* 29ed8: 00000000 */ nop
|
|
/* 29edc: 4502002e */ bc1fl .L00029f98
|
|
/* 29ee0: 02801025 */ or $v0,$s4,$zero
|
|
/* 29ee4: c6220010 */ lwc1 $f2,0x10($s1)
|
|
/* 29ee8: c62c0018 */ lwc1 $f12,0x18($s1)
|
|
/* 29eec: 02602025 */ or $a0,$s3,$zero
|
|
/* 29ef0: 44051000 */ mfc1 $a1,$f2
|
|
/* 29ef4: 44066000 */ mfc1 $a2,$f12
|
|
/* 29ef8: 0c009833 */ jal cdFindGroundInFltTile
|
|
/* 29efc: 00000000 */ nop
|
|
/* 29f00: c6520004 */ lwc1 $f18,0x4($s2)
|
|
/* 29f04: 4612003c */ c.lt.s $f0,$f18
|
|
/* 29f08: 00000000 */ nop
|
|
/* 29f0c: 45020022 */ bc1fl .L00029f98
|
|
/* 29f10: 02801025 */ or $v0,$s4,$zero
|
|
/* 29f14: 8fae0118 */ lw $t6,0x118($sp)
|
|
/* 29f18: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29f1c: 240f0001 */ addiu $t7,$zero,0x1
|
|
/* 29f20: add50000 */ sw $s5,0x0($t6)
|
|
/* 29f24: e7b400e4 */ swc1 $f20,0xe4($sp)
|
|
/* 29f28: afaf0100 */ sw $t7,0x100($sp)
|
|
/* 29f2c: 10000019 */ b .L00029f94
|
|
/* 29f30: 0000f025 */ or $s8,$zero,$zero
|
|
/* 29f34: c7a400e4 */ lwc1 $f4,0xe4($sp)
|
|
.L00029f38:
|
|
/* 29f38: 4604003c */ c.lt.s $f0,$f4
|
|
/* 29f3c: 00000000 */ nop
|
|
/* 29f40: 45020015 */ bc1fl .L00029f98
|
|
/* 29f44: 02801025 */ or $v0,$s4,$zero
|
|
/* 29f48: c6020010 */ lwc1 $f2,0x10($s0)
|
|
/* 29f4c: c60c0018 */ lwc1 $f12,0x18($s0)
|
|
/* 29f50: 02602025 */ or $a0,$s3,$zero
|
|
/* 29f54: 44051000 */ mfc1 $a1,$f2
|
|
/* 29f58: 44066000 */ mfc1 $a2,$f12
|
|
/* 29f5c: 0c009833 */ jal cdFindGroundInFltTile
|
|
/* 29f60: 00000000 */ nop
|
|
/* 29f64: c6460004 */ lwc1 $f6,0x4($s2)
|
|
/* 29f68: 4606003c */ c.lt.s $f0,$f6
|
|
/* 29f6c: 00000000 */ nop
|
|
/* 29f70: 45020009 */ bc1fl .L00029f98
|
|
/* 29f74: 02801025 */ or $v0,$s4,$zero
|
|
/* 29f78: 8fb80118 */ lw $t8,0x118($sp)
|
|
/* 29f7c: e7a00104 */ swc1 $f0,0x104($sp)
|
|
/* 29f80: 24190001 */ addiu $t9,$zero,0x1
|
|
/* 29f84: af150000 */ sw $s5,0x0($t8)
|
|
/* 29f88: e7b600e4 */ swc1 $f22,0xe4($sp)
|
|
/* 29f8c: afb90100 */ sw $t9,0x100($sp)
|
|
/* 29f90: 0000f025 */ or $s8,$zero,$zero
|
|
.L00029f94:
|
|
/* 29f94: 02801025 */ or $v0,$s4,$zero
|
|
.L00029f98:
|
|
/* 29f98: 1696ff66 */ bne $s4,$s6,.L00029d34
|
|
/* 29f9c: 2631000c */ addiu $s1,$s1,0xc
|
|
.L00029fa0:
|
|
/* 29fa0: 8ea80014 */ lw $t0,0x14($s5)
|
|
.L00029fa4:
|
|
/* 29fa4: 26b50014 */ addiu $s5,$s5,0x14
|
|
/* 29fa8: 5500fe75 */ bnezl $t0,.L00029980
|
|
/* 29fac: 8eb80004 */ lw $t8,0x4($s5)
|
|
/* 29fb0: 8fbf0074 */ lw $ra,0x74($sp)
|
|
.L00029fb4:
|
|
/* 29fb4: c7a00104 */ lwc1 $f0,0x104($sp)
|
|
/* 29fb8: d7b40020 */ ldc1 $f20,0x20($sp)
|
|
/* 29fbc: d7b60028 */ ldc1 $f22,0x28($sp)
|
|
/* 29fc0: d7b80030 */ ldc1 $f24,0x30($sp)
|
|
/* 29fc4: d7ba0038 */ ldc1 $f26,0x38($sp)
|
|
/* 29fc8: d7bc0040 */ ldc1 $f28,0x40($sp)
|
|
/* 29fcc: d7be0048 */ ldc1 $f30,0x48($sp)
|
|
/* 29fd0: 8fb00050 */ lw $s0,0x50($sp)
|
|
/* 29fd4: 8fb10054 */ lw $s1,0x54($sp)
|
|
/* 29fd8: 8fb20058 */ lw $s2,0x58($sp)
|
|
/* 29fdc: 8fb3005c */ lw $s3,0x5c($sp)
|
|
/* 29fe0: 8fb40060 */ lw $s4,0x60($sp)
|
|
/* 29fe4: 8fb50064 */ lw $s5,0x64($sp)
|
|
/* 29fe8: 8fb60068 */ lw $s6,0x68($sp)
|
|
/* 29fec: 8fb7006c */ lw $s7,0x6c($sp)
|
|
/* 29ff0: 8fbe0070 */ lw $s8,0x70($sp)
|
|
/* 29ff4: 03e00008 */ jr $ra
|
|
/* 29ff8: 27bd0110 */ addiu $sp,$sp,0x110
|
|
);
|
|
#else
|
|
GLOBAL_ASM(
|
|
glabel cd000296a0
|
|
/* 2ab9c: 27bdfef8 */ addiu $sp,$sp,-264
|
|
/* 2aba0: 3c01cf80 */ lui $at,0xcf80
|
|
/* 2aba4: 44812000 */ mtc1 $at,$f4
|
|
/* 2aba8: afbf0074 */ sw $ra,0x74($sp)
|
|
/* 2abac: afbe0070 */ sw $s8,0x70($sp)
|
|
/* 2abb0: afb7006c */ sw $s7,0x6c($sp)
|
|
/* 2abb4: afb60068 */ sw $s6,0x68($sp)
|
|
/* 2abb8: afb50064 */ sw $s5,0x64($sp)
|
|
/* 2abbc: afb40060 */ sw $s4,0x60($sp)
|
|
/* 2abc0: afb3005c */ sw $s3,0x5c($sp)
|
|
/* 2abc4: afb20058 */ sw $s2,0x58($sp)
|
|
/* 2abc8: afb10054 */ sw $s1,0x54($sp)
|
|
/* 2abcc: afb00050 */ sw $s0,0x50($sp)
|
|
/* 2abd0: f7be0048 */ sdc1 $f30,0x48($sp)
|
|
/* 2abd4: f7bc0040 */ sdc1 $f28,0x40($sp)
|
|
/* 2abd8: f7ba0038 */ sdc1 $f26,0x38($sp)
|
|
/* 2abdc: f7b80030 */ sdc1 $f24,0x30($sp)
|
|
/* 2abe0: f7b60028 */ sdc1 $f22,0x28($sp)
|
|
/* 2abe4: f7b40020 */ sdc1 $f20,0x20($sp)
|
|
/* 2abe8: afa70114 */ sw $a3,0x114($sp)
|
|
/* 2abec: afa000f8 */ sw $zero,0xf8($sp)
|
|
/* 2abf0: e7a400fc */ swc1 $f4,0xfc($sp)
|
|
/* 2abf4: acc00000 */ sw $zero,0x0($a2)
|
|
/* 2abf8: 8c8e0000 */ lw $t6,0x0($a0)
|
|
/* 2abfc: 00a09025 */ or $s2,$a1,$zero
|
|
/* 2ac00: 00809825 */ or $s3,$a0,$zero
|
|
/* 2ac04: 00c0f025 */ or $s8,$a2,$zero
|
|
/* 2ac08: 00008025 */ or $s0,$zero,$zero
|
|
/* 2ac0c: 00008825 */ or $s1,$zero,$zero
|
|
/* 2ac10: 11c00025 */ beqz $t6,.NB0002aca8
|
|
/* 2ac14: 0080b025 */ or $s6,$a0,$zero
|
|
/* 2ac18: 8ec70000 */ lw $a3,0x0($s6)
|
|
/* 2ac1c: 90e20000 */ lbu $v0,0x0($a3)
|
|
.NB0002ac20:
|
|
/* 2ac20: 24010001 */ addiu $at,$zero,0x1
|
|
/* 2ac24: 14400013 */ bnez $v0,.NB0002ac74
|
|
/* 2ac28: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2ac2c: 94e20002 */ lhu $v0,0x2($a3)
|
|
/* 2ac30: 00e02025 */ or $a0,$a3,$zero
|
|
/* 2ac34: 304f4000 */ andi $t7,$v0,0x4000
|
|
/* 2ac38: 51e00004 */ beqzl $t7,.NB0002ac4c
|
|
/* 2ac3c: 30580100 */ andi $t8,$v0,0x100
|
|
/* 2ac40: 10000015 */ beqz $zero,.NB0002ac98
|
|
/* 2ac44: aec00004 */ sw $zero,0x4($s6)
|
|
/* 2ac48: 30580100 */ andi $t8,$v0,0x100
|
|
.NB0002ac4c:
|
|
/* 2ac4c: 53000003 */ beqzl $t8,.NB0002ac5c
|
|
/* 2ac50: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 2ac54: 24110001 */ addiu $s1,$zero,0x1
|
|
/* 2ac58: 8e450000 */ lw $a1,0x0($s2)
|
|
.NB0002ac5c:
|
|
/* 2ac5c: 0c009da6 */ jal cdIs2dPointInIntTile
|
|
/* 2ac60: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 2ac64: 1040000c */ beqz $v0,.NB0002ac98
|
|
/* 2ac68: aec20004 */ sw $v0,0x4($s6)
|
|
/* 2ac6c: 1000000a */ beqz $zero,.NB0002ac98
|
|
/* 2ac70: 24100001 */ addiu $s0,$zero,0x1
|
|
.NB0002ac74:
|
|
/* 2ac74: 54410009 */ bnel $v0,$at,.NB0002ac9c
|
|
/* 2ac78: 8ec70014 */ lw $a3,0x14($s6)
|
|
/* 2ac7c: 00e02025 */ or $a0,$a3,$zero
|
|
/* 2ac80: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 2ac84: 0c009dfd */ jal cdIs2dPointInFltTile
|
|
/* 2ac88: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 2ac8c: 10400002 */ beqz $v0,.NB0002ac98
|
|
/* 2ac90: aec20004 */ sw $v0,0x4($s6)
|
|
/* 2ac94: 24100001 */ addiu $s0,$zero,0x1
|
|
.NB0002ac98:
|
|
/* 2ac98: 8ec70014 */ lw $a3,0x14($s6)
|
|
.NB0002ac9c:
|
|
/* 2ac9c: 26d60014 */ addiu $s6,$s6,0x14
|
|
/* 2aca0: 54e0ffdf */ bnezl $a3,.NB0002ac20
|
|
/* 2aca4: 90e20000 */ lbu $v0,0x0($a3)
|
|
.NB0002aca8:
|
|
/* 2aca8: 52000065 */ beqzl $s0,.NB0002ae40
|
|
/* 2acac: 8faa00f8 */ lw $t2,0xf8($sp)
|
|
/* 2acb0: 8e620000 */ lw $v0,0x0($s3)
|
|
/* 2acb4: 0260b025 */ or $s6,$s3,$zero
|
|
/* 2acb8: 1040003a */ beqz $v0,.NB0002ada4
|
|
/* 2acbc: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2acc0: 8ed90004 */ lw $t9,0x4($s6)
|
|
.NB0002acc4:
|
|
/* 2acc4: 53200032 */ beqzl $t9,.NB0002ad90
|
|
/* 2acc8: 8ecc0014 */ lw $t4,0x14($s6)
|
|
/* 2accc: 8ec70000 */ lw $a3,0x0($s6)
|
|
/* 2acd0: 24010001 */ addiu $at,$zero,0x1
|
|
/* 2acd4: 90e20000 */ lbu $v0,0x0($a3)
|
|
/* 2acd8: 14400018 */ bnez $v0,.NB0002ad3c
|
|
/* 2acdc: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2ace0: 94e80002 */ lhu $t0,0x2($a3)
|
|
/* 2ace4: 31092000 */ andi $t1,$t0,0x2000
|
|
/* 2ace8: 55200029 */ bnezl $t1,.NB0002ad90
|
|
/* 2acec: 8ecc0014 */ lw $t4,0x14($s6)
|
|
/* 2acf0: 00e02025 */ or $a0,$a3,$zero
|
|
/* 2acf4: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 2acf8: 0c009ce8 */ jal cdFindGroundInIntTile
|
|
/* 2acfc: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 2ad00: c7a600fc */ lwc1 $f6,0xfc($sp)
|
|
/* 2ad04: 4600303e */ c.le.s $f6,$f0
|
|
/* 2ad08: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2ad0c: 45020020 */ bc1fl .NB0002ad90
|
|
/* 2ad10: 8ecc0014 */ lw $t4,0x14($s6)
|
|
/* 2ad14: c6480004 */ lwc1 $f8,0x4($s2)
|
|
/* 2ad18: 240a0001 */ addiu $t2,$zero,0x1
|
|
/* 2ad1c: 4608003c */ c.lt.s $f0,$f8
|
|
/* 2ad20: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2ad24: 4502001a */ bc1fl .NB0002ad90
|
|
/* 2ad28: 8ecc0014 */ lw $t4,0x14($s6)
|
|
/* 2ad2c: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2ad30: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2ad34: 10000015 */ beqz $zero,.NB0002ad8c
|
|
/* 2ad38: afaa00f8 */ sw $t2,0xf8($sp)
|
|
.NB0002ad3c:
|
|
/* 2ad3c: 54410014 */ bnel $v0,$at,.NB0002ad90
|
|
/* 2ad40: 8ecc0014 */ lw $t4,0x14($s6)
|
|
/* 2ad44: 00e02025 */ or $a0,$a3,$zero
|
|
/* 2ad48: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 2ad4c: 0c009d37 */ jal cdFindGroundInFltTile
|
|
/* 2ad50: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 2ad54: c7aa00fc */ lwc1 $f10,0xfc($sp)
|
|
/* 2ad58: 4600503e */ c.le.s $f10,$f0
|
|
/* 2ad5c: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2ad60: 4502000b */ bc1fl .NB0002ad90
|
|
/* 2ad64: 8ecc0014 */ lw $t4,0x14($s6)
|
|
/* 2ad68: c6500004 */ lwc1 $f16,0x4($s2)
|
|
/* 2ad6c: 240b0001 */ addiu $t3,$zero,0x1
|
|
/* 2ad70: 4610003c */ c.lt.s $f0,$f16
|
|
/* 2ad74: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2ad78: 45020005 */ bc1fl .NB0002ad90
|
|
/* 2ad7c: 8ecc0014 */ lw $t4,0x14($s6)
|
|
/* 2ad80: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2ad84: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2ad88: afab00f8 */ sw $t3,0xf8($sp)
|
|
.NB0002ad8c:
|
|
/* 2ad8c: 8ecc0014 */ lw $t4,0x14($s6)
|
|
.NB0002ad90:
|
|
/* 2ad90: 26d60014 */ addiu $s6,$s6,0x14
|
|
/* 2ad94: 5580ffcb */ bnezl $t4,.NB0002acc4
|
|
/* 2ad98: 8ed90004 */ lw $t9,0x4($s6)
|
|
/* 2ad9c: 0260b025 */ or $s6,$s3,$zero
|
|
/* 2ada0: 8e620000 */ lw $v0,0x0($s3)
|
|
.NB0002ada4:
|
|
/* 2ada4: 50400026 */ beqzl $v0,.NB0002ae40
|
|
/* 2ada8: 8faa00f8 */ lw $t2,0xf8($sp)
|
|
/* 2adac: 8ecd0004 */ lw $t5,0x4($s6)
|
|
.NB0002adb0:
|
|
/* 2adb0: 51a0001f */ beqzl $t5,.NB0002ae30
|
|
/* 2adb4: 8ec90014 */ lw $t1,0x14($s6)
|
|
/* 2adb8: 8ec70000 */ lw $a3,0x0($s6)
|
|
/* 2adbc: 90ee0000 */ lbu $t6,0x0($a3)
|
|
/* 2adc0: 55c0001b */ bnezl $t6,.NB0002ae30
|
|
/* 2adc4: 8ec90014 */ lw $t1,0x14($s6)
|
|
/* 2adc8: 94ef0002 */ lhu $t7,0x2($a3)
|
|
/* 2adcc: 31f82000 */ andi $t8,$t7,0x2000
|
|
/* 2add0: 53000017 */ beqzl $t8,.NB0002ae30
|
|
/* 2add4: 8ec90014 */ lw $t1,0x14($s6)
|
|
/* 2add8: 00e02025 */ or $a0,$a3,$zero
|
|
/* 2addc: 8e450000 */ lw $a1,0x0($s2)
|
|
/* 2ade0: 0c009ce8 */ jal cdFindGroundInIntTile
|
|
/* 2ade4: 8e460008 */ lw $a2,0x8($s2)
|
|
/* 2ade8: c7b200fc */ lwc1 $f18,0xfc($sp)
|
|
/* 2adec: 4600903e */ c.le.s $f18,$f0
|
|
/* 2adf0: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2adf4: 4502000e */ bc1fl .NB0002ae30
|
|
/* 2adf8: 8ec90014 */ lw $t1,0x14($s6)
|
|
/* 2adfc: c6440004 */ lwc1 $f4,0x4($s2)
|
|
/* 2ae00: 4604003c */ c.lt.s $f0,$f4
|
|
/* 2ae04: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2ae08: 45030005 */ bc1tl .NB0002ae20
|
|
/* 2ae0c: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2ae10: 8fb900f8 */ lw $t9,0xf8($sp)
|
|
/* 2ae14: 57200006 */ bnezl $t9,.NB0002ae30
|
|
/* 2ae18: 8ec90014 */ lw $t1,0x14($s6)
|
|
/* 2ae1c: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
.NB0002ae20:
|
|
/* 2ae20: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2ae24: 24080001 */ addiu $t0,$zero,0x1
|
|
/* 2ae28: afa800f8 */ sw $t0,0xf8($sp)
|
|
/* 2ae2c: 8ec90014 */ lw $t1,0x14($s6)
|
|
.NB0002ae30:
|
|
/* 2ae30: 26d60014 */ addiu $s6,$s6,0x14
|
|
/* 2ae34: 5520ffde */ bnezl $t1,.NB0002adb0
|
|
/* 2ae38: 8ecd0004 */ lw $t5,0x4($s6)
|
|
/* 2ae3c: 8faa00f8 */ lw $t2,0xf8($sp)
|
|
.NB0002ae40:
|
|
/* 2ae40: 3c014f80 */ lui $at,0x4f80
|
|
/* 2ae44: 51400004 */ beqzl $t2,.NB0002ae58
|
|
/* 2ae48: 44813000 */ mtc1 $at,$f6
|
|
/* 2ae4c: 5220016b */ beqzl $s1,.NB0002b3fc
|
|
/* 2ae50: 8fbf0074 */ lw $ra,0x74($sp)
|
|
/* 2ae54: 44813000 */ mtc1 $at,$f6
|
|
.NB0002ae58:
|
|
/* 2ae58: 0260b025 */ or $s6,$s3,$zero
|
|
/* 2ae5c: e7a600e4 */ swc1 $f6,0xe4($sp)
|
|
/* 2ae60: 8e6b0000 */ lw $t3,0x0($s3)
|
|
/* 2ae64: 51600165 */ beqzl $t3,.NB0002b3fc
|
|
/* 2ae68: 8fbf0074 */ lw $ra,0x74($sp)
|
|
/* 2ae6c: 8ecc0004 */ lw $t4,0x4($s6)
|
|
.NB0002ae70:
|
|
/* 2ae70: 8fad00f8 */ lw $t5,0xf8($sp)
|
|
/* 2ae74: 5580015d */ bnezl $t4,.NB0002b3ec
|
|
/* 2ae78: 8ec80014 */ lw $t0,0x14($s6)
|
|
/* 2ae7c: 11a00008 */ beqz $t5,.NB0002aea0
|
|
/* 2ae80: 8ec70000 */ lw $a3,0x0($s6)
|
|
/* 2ae84: 90ee0000 */ lbu $t6,0x0($a3)
|
|
/* 2ae88: 55c00158 */ bnezl $t6,.NB0002b3ec
|
|
/* 2ae8c: 8ec80014 */ lw $t0,0x14($s6)
|
|
/* 2ae90: 94ef0002 */ lhu $t7,0x2($a3)
|
|
/* 2ae94: 31f80100 */ andi $t8,$t7,0x100
|
|
/* 2ae98: 53000154 */ beqzl $t8,.NB0002b3ec
|
|
/* 2ae9c: 8ec80014 */ lw $t0,0x14($s6)
|
|
.NB0002aea0:
|
|
/* 2aea0: 90e20000 */ lbu $v0,0x0($a3)
|
|
/* 2aea4: 544000ba */ bnezl $v0,.NB0002b190
|
|
/* 2aea8: 24010001 */ addiu $at,$zero,0x1
|
|
/* 2aeac: 90f70001 */ lbu $s7,0x1($a3)
|
|
/* 2aeb0: 00e0a025 */ or $s4,$a3,$zero
|
|
/* 2aeb4: 00008825 */ or $s1,$zero,$zero
|
|
/* 2aeb8: 1ae0014b */ blez $s7,.NB0002b3e8
|
|
/* 2aebc: 00e09825 */ or $s3,$a3,$zero
|
|
.NB0002aec0:
|
|
/* 2aec0: 26350001 */ addiu $s5,$s1,0x1
|
|
/* 2aec4: 02b7001a */ div $zero,$s5,$s7
|
|
/* 2aec8: 00004810 */ mfhi $t1
|
|
/* 2aecc: 00095080 */ sll $t2,$t1,0x2
|
|
/* 2aed0: 01495023 */ subu $t2,$t2,$t1
|
|
/* 2aed4: 000a5040 */ sll $t2,$t2,0x1
|
|
/* 2aed8: 028a8021 */ addu $s0,$s4,$t2
|
|
/* 2aedc: 860b000e */ lh $t3,0xe($s0)
|
|
/* 2aee0: 860c0012 */ lh $t4,0x12($s0)
|
|
/* 2aee4: 8679000e */ lh $t9,0xe($s3)
|
|
/* 2aee8: 86680012 */ lh $t0,0x12($s3)
|
|
/* 2aeec: 448b8000 */ mtc1 $t3,$f16
|
|
/* 2aef0: 448c9000 */ mtc1 $t4,$f18
|
|
/* 2aef4: 44994000 */ mtc1 $t9,$f8
|
|
/* 2aef8: 44885000 */ mtc1 $t0,$f10
|
|
/* 2aefc: 468086a0 */ cvt.s.w $f26,$f16
|
|
/* 2af00: c6440000 */ lwc1 $f4,0x0($s2)
|
|
/* 2af04: e7a40010 */ swc1 $f4,0x10($sp)
|
|
/* 2af08: 46809720 */ cvt.s.w $f28,$f18
|
|
/* 2af0c: c6460008 */ lwc1 $f6,0x8($s2)
|
|
/* 2af10: 4406d000 */ mfc1 $a2,$f26
|
|
/* 2af14: e7a60014 */ swc1 $f6,0x14($sp)
|
|
/* 2af18: 468045a0 */ cvt.s.w $f22,$f8
|
|
/* 2af1c: 4407e000 */ mfc1 $a3,$f28
|
|
/* 2af20: 46805620 */ cvt.s.w $f24,$f10
|
|
/* 2af24: 16e00002 */ bnez $s7,.NB0002af30
|
|
/* 2af28: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2af2c: 0007000d */ break 0x7
|
|
.NB0002af30:
|
|
/* 2af30: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2af34: 16e10004 */ bne $s7,$at,.NB0002af48
|
|
/* 2af38: 3c018000 */ lui $at,0x8000
|
|
/* 2af3c: 16a10002 */ bne $s5,$at,.NB0002af48
|
|
/* 2af40: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2af44: 0006000d */ break 0x6
|
|
.NB0002af48:
|
|
/* 2af48: 4600c386 */ mov.s $f14,$f24
|
|
/* 2af4c: 0c009a8d */ jal cd00025654
|
|
/* 2af50: 4600b306 */ mov.s $f12,$f22
|
|
/* 2af54: 44804000 */ mtc1 $zero,$f8
|
|
/* 2af58: e7a000d4 */ swc1 $f0,0xd4($sp)
|
|
/* 2af5c: 46000786 */ mov.s $f30,$f0
|
|
/* 2af60: 4608003c */ c.lt.s $f0,$f8
|
|
/* 2af64: c7aa00e4 */ lwc1 $f10,0xe4($sp)
|
|
/* 2af68: 45020003 */ bc1fl .NB0002af78
|
|
/* 2af6c: 460af03c */ c.lt.s $f30,$f10
|
|
/* 2af70: 46000787 */ neg.s $f30,$f0
|
|
/* 2af74: 460af03c */ c.lt.s $f30,$f10
|
|
.NB0002af78:
|
|
/* 2af78: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2af7c: 4502007f */ bc1fl .NB0002b17c
|
|
/* 2af80: 02a08825 */ or $s1,$s5,$zero
|
|
/* 2af84: c6500000 */ lwc1 $f16,0x0($s2)
|
|
/* 2af88: 4406d000 */ mfc1 $a2,$f26
|
|
/* 2af8c: 4407e000 */ mfc1 $a3,$f28
|
|
/* 2af90: e7b00010 */ swc1 $f16,0x10($sp)
|
|
/* 2af94: c6520008 */ lwc1 $f18,0x8($s2)
|
|
/* 2af98: 4600b306 */ mov.s $f12,$f22
|
|
/* 2af9c: 4600c386 */ mov.s $f14,$f24
|
|
/* 2afa0: 0c009ad5 */ jal cd00025774
|
|
/* 2afa4: e7b20014 */ swc1 $f18,0x14($sp)
|
|
/* 2afa8: 50400028 */ beqzl $v0,.NB0002b04c
|
|
/* 2afac: 4600b306 */ mov.s $f12,$f22
|
|
/* 2afb0: 4616d001 */ sub.s $f0,$f26,$f22
|
|
/* 2afb4: 4618e501 */ sub.s $f20,$f28,$f24
|
|
/* 2afb8: 46000102 */ mul.s $f4,$f0,$f0
|
|
/* 2afbc: e7a000b8 */ swc1 $f0,0xb8($sp)
|
|
/* 2afc0: 4614a182 */ mul.s $f6,$f20,$f20
|
|
/* 2afc4: 0c012e84 */ jal sqrtf
|
|
/* 2afc8: 46062300 */ add.s $f12,$f4,$f6
|
|
/* 2afcc: c7a800d4 */ lwc1 $f8,0xd4($sp)
|
|
/* 2afd0: 4600a407 */ neg.s $f16,$f20
|
|
/* 2afd4: c7a600b8 */ lwc1 $f6,0xb8($sp)
|
|
/* 2afd8: 46004383 */ div.s $f14,$f8,$f0
|
|
/* 2afdc: c64a0000 */ lwc1 $f10,0x0($s2)
|
|
/* 2afe0: c6440008 */ lwc1 $f4,0x8($s2)
|
|
/* 2afe4: 02802025 */ or $a0,$s4,$zero
|
|
/* 2afe8: 02203825 */ or $a3,$s1,$zero
|
|
/* 2afec: 46107482 */ mul.s $f18,$f14,$f16
|
|
/* 2aff0: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2aff4: 46067202 */ mul.s $f8,$f14,$f6
|
|
/* 2aff8: 46125080 */ add.s $f2,$f10,$f18
|
|
/* 2affc: 46082300 */ add.s $f12,$f4,$f8
|
|
/* 2b000: 44051000 */ mfc1 $a1,$f2
|
|
/* 2b004: 44066000 */ mfc1 $a2,$f12
|
|
/* 2b008: 0c009c15 */ jal cdFindGroundInIntTileAtVertex
|
|
/* 2b00c: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b010: c6500004 */ lwc1 $f16,0x4($s2)
|
|
/* 2b014: 4610003c */ c.lt.s $f0,$f16
|
|
/* 2b018: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b01c: 45030007 */ bc1tl .NB0002b03c
|
|
/* 2b020: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2b024: 8ecd0000 */ lw $t5,0x0($s6)
|
|
/* 2b028: 95ae0002 */ lhu $t6,0x2($t5)
|
|
/* 2b02c: 31cf2000 */ andi $t7,$t6,0x2000
|
|
/* 2b030: 51e00052 */ beqzl $t7,.NB0002b17c
|
|
/* 2b034: 02a08825 */ or $s1,$s5,$zero
|
|
/* 2b038: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
.NB0002b03c:
|
|
/* 2b03c: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2b040: 1000004d */ beqz $zero,.NB0002b178
|
|
/* 2b044: e7be00e4 */ swc1 $f30,0xe4($sp)
|
|
/* 2b048: 4600b306 */ mov.s $f12,$f22
|
|
.NB0002b04c:
|
|
/* 2b04c: 4600c386 */ mov.s $f14,$f24
|
|
/* 2b050: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 2b054: 0c009ac1 */ jal cd00025724
|
|
/* 2b058: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 2b05c: 46000506 */ mov.s $f20,$f0
|
|
/* 2b060: 4600d306 */ mov.s $f12,$f26
|
|
/* 2b064: 4600e386 */ mov.s $f14,$f28
|
|
/* 2b068: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 2b06c: 0c009ac1 */ jal cd00025724
|
|
/* 2b070: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 2b074: 4600a03c */ c.lt.s $f20,$f0
|
|
/* 2b078: 46000586 */ mov.s $f22,$f0
|
|
/* 2b07c: 45020021 */ bc1fl .NB0002b104
|
|
/* 2b080: c7a800e4 */ lwc1 $f8,0xe4($sp)
|
|
/* 2b084: c7aa00e4 */ lwc1 $f10,0xe4($sp)
|
|
/* 2b088: 460aa03c */ c.lt.s $f20,$f10
|
|
/* 2b08c: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b090: 4502003a */ bc1fl .NB0002b17c
|
|
/* 2b094: 02a08825 */ or $s1,$s5,$zero
|
|
/* 2b098: 8678000e */ lh $t8,0xe($s3)
|
|
/* 2b09c: 86790012 */ lh $t9,0x12($s3)
|
|
/* 2b0a0: 02802025 */ or $a0,$s4,$zero
|
|
/* 2b0a4: 44989000 */ mtc1 $t8,$f18
|
|
/* 2b0a8: 44993000 */ mtc1 $t9,$f6
|
|
/* 2b0ac: 02203825 */ or $a3,$s1,$zero
|
|
/* 2b0b0: 468090a0 */ cvt.s.w $f2,$f18
|
|
/* 2b0b4: 46803320 */ cvt.s.w $f12,$f6
|
|
/* 2b0b8: 44051000 */ mfc1 $a1,$f2
|
|
/* 2b0bc: 44066000 */ mfc1 $a2,$f12
|
|
/* 2b0c0: 0c009c15 */ jal cdFindGroundInIntTileAtVertex
|
|
/* 2b0c4: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b0c8: c6440004 */ lwc1 $f4,0x4($s2)
|
|
/* 2b0cc: 4604003c */ c.lt.s $f0,$f4
|
|
/* 2b0d0: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b0d4: 45030007 */ bc1tl .NB0002b0f4
|
|
/* 2b0d8: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2b0dc: 8ec80000 */ lw $t0,0x0($s6)
|
|
/* 2b0e0: 95090002 */ lhu $t1,0x2($t0)
|
|
/* 2b0e4: 312a2000 */ andi $t2,$t1,0x2000
|
|
/* 2b0e8: 51400024 */ beqzl $t2,.NB0002b17c
|
|
/* 2b0ec: 02a08825 */ or $s1,$s5,$zero
|
|
/* 2b0f0: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
.NB0002b0f4:
|
|
/* 2b0f4: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2b0f8: 1000001f */ beqz $zero,.NB0002b178
|
|
/* 2b0fc: e7b400e4 */ swc1 $f20,0xe4($sp)
|
|
/* 2b100: c7a800e4 */ lwc1 $f8,0xe4($sp)
|
|
.NB0002b104:
|
|
/* 2b104: 4608003c */ c.lt.s $f0,$f8
|
|
/* 2b108: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b10c: 4502001b */ bc1fl .NB0002b17c
|
|
/* 2b110: 02a08825 */ or $s1,$s5,$zero
|
|
/* 2b114: 860b000e */ lh $t3,0xe($s0)
|
|
/* 2b118: 860c0012 */ lh $t4,0x12($s0)
|
|
/* 2b11c: 02802025 */ or $a0,$s4,$zero
|
|
/* 2b120: 448b8000 */ mtc1 $t3,$f16
|
|
/* 2b124: 448c5000 */ mtc1 $t4,$f10
|
|
/* 2b128: 02203825 */ or $a3,$s1,$zero
|
|
/* 2b12c: 468080a0 */ cvt.s.w $f2,$f16
|
|
/* 2b130: 46805320 */ cvt.s.w $f12,$f10
|
|
/* 2b134: 44051000 */ mfc1 $a1,$f2
|
|
/* 2b138: 44066000 */ mfc1 $a2,$f12
|
|
/* 2b13c: 0c009c15 */ jal cdFindGroundInIntTileAtVertex
|
|
/* 2b140: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b144: c6520004 */ lwc1 $f18,0x4($s2)
|
|
/* 2b148: 4612003c */ c.lt.s $f0,$f18
|
|
/* 2b14c: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b150: 45030007 */ bc1tl .NB0002b170
|
|
/* 2b154: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2b158: 8ecd0000 */ lw $t5,0x0($s6)
|
|
/* 2b15c: 95ae0002 */ lhu $t6,0x2($t5)
|
|
/* 2b160: 31cf2000 */ andi $t7,$t6,0x2000
|
|
/* 2b164: 51e00005 */ beqzl $t7,.NB0002b17c
|
|
/* 2b168: 02a08825 */ or $s1,$s5,$zero
|
|
/* 2b16c: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
.NB0002b170:
|
|
/* 2b170: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2b174: e7b600e4 */ swc1 $f22,0xe4($sp)
|
|
.NB0002b178:
|
|
/* 2b178: 02a08825 */ or $s1,$s5,$zero
|
|
.NB0002b17c:
|
|
/* 2b17c: 16b7ff50 */ bne $s5,$s7,.NB0002aec0
|
|
/* 2b180: 26730006 */ addiu $s3,$s3,0x6
|
|
/* 2b184: 10000099 */ beqz $zero,.NB0002b3ec
|
|
/* 2b188: 8ec80014 */ lw $t0,0x14($s6)
|
|
/* 2b18c: 24010001 */ addiu $at,$zero,0x1
|
|
.NB0002b190:
|
|
/* 2b190: 54410096 */ bnel $v0,$at,.NB0002b3ec
|
|
/* 2b194: 8ec80014 */ lw $t0,0x14($s6)
|
|
/* 2b198: 90f50001 */ lbu $s5,0x1($a3)
|
|
/* 2b19c: 00e09825 */ or $s3,$a3,$zero
|
|
/* 2b1a0: 00001025 */ or $v0,$zero,$zero
|
|
/* 2b1a4: 1aa00090 */ blez $s5,.NB0002b3e8
|
|
/* 2b1a8: 00e08825 */ or $s1,$a3,$zero
|
|
.NB0002b1ac:
|
|
/* 2b1ac: 24540001 */ addiu $s4,$v0,0x1
|
|
/* 2b1b0: 0295001a */ div $zero,$s4,$s5
|
|
/* 2b1b4: 0000c010 */ mfhi $t8
|
|
/* 2b1b8: 0018c880 */ sll $t9,$t8,0x2
|
|
/* 2b1bc: 0338c823 */ subu $t9,$t9,$t8
|
|
/* 2b1c0: 0019c880 */ sll $t9,$t9,0x2
|
|
/* 2b1c4: 02798021 */ addu $s0,$s3,$t9
|
|
/* 2b1c8: c6460000 */ lwc1 $f6,0x0($s2)
|
|
/* 2b1cc: c61a0010 */ lwc1 $f26,0x10($s0)
|
|
/* 2b1d0: c61c0018 */ lwc1 $f28,0x18($s0)
|
|
/* 2b1d4: c6360010 */ lwc1 $f22,0x10($s1)
|
|
/* 2b1d8: c6380018 */ lwc1 $f24,0x18($s1)
|
|
/* 2b1dc: e7a60010 */ swc1 $f6,0x10($sp)
|
|
/* 2b1e0: c6440008 */ lwc1 $f4,0x8($s2)
|
|
/* 2b1e4: 16a00002 */ bnez $s5,.NB0002b1f0
|
|
/* 2b1e8: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b1ec: 0007000d */ break 0x7
|
|
.NB0002b1f0:
|
|
/* 2b1f0: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2b1f4: 16a10004 */ bne $s5,$at,.NB0002b208
|
|
/* 2b1f8: 3c018000 */ lui $at,0x8000
|
|
/* 2b1fc: 16810002 */ bne $s4,$at,.NB0002b208
|
|
/* 2b200: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b204: 0006000d */ break 0x6
|
|
.NB0002b208:
|
|
/* 2b208: 4406d000 */ mfc1 $a2,$f26
|
|
/* 2b20c: 4407e000 */ mfc1 $a3,$f28
|
|
/* 2b210: 4600b306 */ mov.s $f12,$f22
|
|
/* 2b214: 4600c386 */ mov.s $f14,$f24
|
|
/* 2b218: 0c009a8d */ jal cd00025654
|
|
/* 2b21c: e7a40014 */ swc1 $f4,0x14($sp)
|
|
/* 2b220: 44804000 */ mtc1 $zero,$f8
|
|
/* 2b224: e7a00098 */ swc1 $f0,0x98($sp)
|
|
/* 2b228: 46000786 */ mov.s $f30,$f0
|
|
/* 2b22c: 4608003c */ c.lt.s $f0,$f8
|
|
/* 2b230: c7b000e4 */ lwc1 $f16,0xe4($sp)
|
|
/* 2b234: 45020003 */ bc1fl .NB0002b244
|
|
/* 2b238: 4610f03c */ c.lt.s $f30,$f16
|
|
/* 2b23c: 46000787 */ neg.s $f30,$f0
|
|
/* 2b240: 4610f03c */ c.lt.s $f30,$f16
|
|
.NB0002b244:
|
|
/* 2b244: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b248: 45020065 */ bc1fl .NB0002b3e0
|
|
/* 2b24c: 02801025 */ or $v0,$s4,$zero
|
|
/* 2b250: c64a0000 */ lwc1 $f10,0x0($s2)
|
|
/* 2b254: 4406d000 */ mfc1 $a2,$f26
|
|
/* 2b258: 4407e000 */ mfc1 $a3,$f28
|
|
/* 2b25c: e7aa0010 */ swc1 $f10,0x10($sp)
|
|
/* 2b260: c6520008 */ lwc1 $f18,0x8($s2)
|
|
/* 2b264: 4600b306 */ mov.s $f12,$f22
|
|
/* 2b268: 4600c386 */ mov.s $f14,$f24
|
|
/* 2b26c: 0c009ad5 */ jal cd00025774
|
|
/* 2b270: e7b20014 */ swc1 $f18,0x14($sp)
|
|
/* 2b274: 50400022 */ beqzl $v0,.NB0002b300
|
|
/* 2b278: 4600b306 */ mov.s $f12,$f22
|
|
/* 2b27c: 4616d001 */ sub.s $f0,$f26,$f22
|
|
/* 2b280: 4618e501 */ sub.s $f20,$f28,$f24
|
|
/* 2b284: 46000182 */ mul.s $f6,$f0,$f0
|
|
/* 2b288: e7a0007c */ swc1 $f0,0x7c($sp)
|
|
/* 2b28c: 4614a102 */ mul.s $f4,$f20,$f20
|
|
/* 2b290: 0c012e84 */ jal sqrtf
|
|
/* 2b294: 46043300 */ add.s $f12,$f6,$f4
|
|
/* 2b298: c7a80098 */ lwc1 $f8,0x98($sp)
|
|
/* 2b29c: 4600a287 */ neg.s $f10,$f20
|
|
/* 2b2a0: c7a4007c */ lwc1 $f4,0x7c($sp)
|
|
/* 2b2a4: 46004383 */ div.s $f14,$f8,$f0
|
|
/* 2b2a8: c6500000 */ lwc1 $f16,0x0($s2)
|
|
/* 2b2ac: c6460008 */ lwc1 $f6,0x8($s2)
|
|
/* 2b2b0: 02602025 */ or $a0,$s3,$zero
|
|
/* 2b2b4: 460a7482 */ mul.s $f18,$f14,$f10
|
|
/* 2b2b8: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b2bc: 46047202 */ mul.s $f8,$f14,$f4
|
|
/* 2b2c0: 46128080 */ add.s $f2,$f16,$f18
|
|
/* 2b2c4: 46083300 */ add.s $f12,$f6,$f8
|
|
/* 2b2c8: 44051000 */ mfc1 $a1,$f2
|
|
/* 2b2cc: 44066000 */ mfc1 $a2,$f12
|
|
/* 2b2d0: 0c009d37 */ jal cdFindGroundInFltTile
|
|
/* 2b2d4: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b2d8: c64a0004 */ lwc1 $f10,0x4($s2)
|
|
/* 2b2dc: 460a003c */ c.lt.s $f0,$f10
|
|
/* 2b2e0: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b2e4: 4502003e */ bc1fl .NB0002b3e0
|
|
/* 2b2e8: 02801025 */ or $v0,$s4,$zero
|
|
/* 2b2ec: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2b2f0: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2b2f4: 10000039 */ beqz $zero,.NB0002b3dc
|
|
/* 2b2f8: e7be00e4 */ swc1 $f30,0xe4($sp)
|
|
/* 2b2fc: 4600b306 */ mov.s $f12,$f22
|
|
.NB0002b300:
|
|
/* 2b300: 4600c386 */ mov.s $f14,$f24
|
|
/* 2b304: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 2b308: 0c009ac1 */ jal cd00025724
|
|
/* 2b30c: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 2b310: 46000506 */ mov.s $f20,$f0
|
|
/* 2b314: 4600d306 */ mov.s $f12,$f26
|
|
/* 2b318: 4600e386 */ mov.s $f14,$f28
|
|
/* 2b31c: 8e460000 */ lw $a2,0x0($s2)
|
|
/* 2b320: 0c009ac1 */ jal cd00025724
|
|
/* 2b324: 8e470008 */ lw $a3,0x8($s2)
|
|
/* 2b328: 4600a03c */ c.lt.s $f20,$f0
|
|
/* 2b32c: 46000586 */ mov.s $f22,$f0
|
|
/* 2b330: 45020017 */ bc1fl .NB0002b390
|
|
/* 2b334: c7a400e4 */ lwc1 $f4,0xe4($sp)
|
|
/* 2b338: c7b000e4 */ lwc1 $f16,0xe4($sp)
|
|
/* 2b33c: 4610a03c */ c.lt.s $f20,$f16
|
|
/* 2b340: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b344: 45020026 */ bc1fl .NB0002b3e0
|
|
/* 2b348: 02801025 */ or $v0,$s4,$zero
|
|
/* 2b34c: c6220010 */ lwc1 $f2,0x10($s1)
|
|
/* 2b350: c62c0018 */ lwc1 $f12,0x18($s1)
|
|
/* 2b354: 02602025 */ or $a0,$s3,$zero
|
|
/* 2b358: 44051000 */ mfc1 $a1,$f2
|
|
/* 2b35c: 44066000 */ mfc1 $a2,$f12
|
|
/* 2b360: 0c009d37 */ jal cdFindGroundInFltTile
|
|
/* 2b364: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b368: c6520004 */ lwc1 $f18,0x4($s2)
|
|
/* 2b36c: 4612003c */ c.lt.s $f0,$f18
|
|
/* 2b370: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b374: 4502001a */ bc1fl .NB0002b3e0
|
|
/* 2b378: 02801025 */ or $v0,$s4,$zero
|
|
/* 2b37c: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2b380: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2b384: 10000015 */ beqz $zero,.NB0002b3dc
|
|
/* 2b388: e7b400e4 */ swc1 $f20,0xe4($sp)
|
|
/* 2b38c: c7a400e4 */ lwc1 $f4,0xe4($sp)
|
|
.NB0002b390:
|
|
/* 2b390: 4604003c */ c.lt.s $f0,$f4
|
|
/* 2b394: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b398: 45020011 */ bc1fl .NB0002b3e0
|
|
/* 2b39c: 02801025 */ or $v0,$s4,$zero
|
|
/* 2b3a0: c6020010 */ lwc1 $f2,0x10($s0)
|
|
/* 2b3a4: c60c0018 */ lwc1 $f12,0x18($s0)
|
|
/* 2b3a8: 02602025 */ or $a0,$s3,$zero
|
|
/* 2b3ac: 44051000 */ mfc1 $a1,$f2
|
|
/* 2b3b0: 44066000 */ mfc1 $a2,$f12
|
|
/* 2b3b4: 0c009d37 */ jal cdFindGroundInFltTile
|
|
/* 2b3b8: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b3bc: c6460004 */ lwc1 $f6,0x4($s2)
|
|
/* 2b3c0: 4606003c */ c.lt.s $f0,$f6
|
|
/* 2b3c4: 00000000 */ sll $zero,$zero,0x0
|
|
/* 2b3c8: 45020005 */ bc1fl .NB0002b3e0
|
|
/* 2b3cc: 02801025 */ or $v0,$s4,$zero
|
|
/* 2b3d0: e7a000fc */ swc1 $f0,0xfc($sp)
|
|
/* 2b3d4: afd60000 */ sw $s6,0x0($s8)
|
|
/* 2b3d8: e7b600e4 */ swc1 $f22,0xe4($sp)
|
|
.NB0002b3dc:
|
|
/* 2b3dc: 02801025 */ or $v0,$s4,$zero
|
|
.NB0002b3e0:
|
|
/* 2b3e0: 1695ff72 */ bne $s4,$s5,.NB0002b1ac
|
|
/* 2b3e4: 2631000c */ addiu $s1,$s1,0xc
|
|
.NB0002b3e8:
|
|
/* 2b3e8: 8ec80014 */ lw $t0,0x14($s6)
|
|
.NB0002b3ec:
|
|
/* 2b3ec: 26d60014 */ addiu $s6,$s6,0x14
|
|
/* 2b3f0: 5500fe9f */ bnezl $t0,.NB0002ae70
|
|
/* 2b3f4: 8ecc0004 */ lw $t4,0x4($s6)
|
|
/* 2b3f8: 8fbf0074 */ lw $ra,0x74($sp)
|
|
.NB0002b3fc:
|
|
/* 2b3fc: c7a000fc */ lwc1 $f0,0xfc($sp)
|
|
/* 2b400: d7b40020 */ ldc1 $f20,0x20($sp)
|
|
/* 2b404: d7b60028 */ ldc1 $f22,0x28($sp)
|
|
/* 2b408: d7b80030 */ ldc1 $f24,0x30($sp)
|
|
/* 2b40c: d7ba0038 */ ldc1 $f26,0x38($sp)
|
|
/* 2b410: d7bc0040 */ ldc1 $f28,0x40($sp)
|
|
/* 2b414: d7be0048 */ ldc1 $f30,0x48($sp)
|
|
/* 2b418: 8fb00050 */ lw $s0,0x50($sp)
|
|
/* 2b41c: 8fb10054 */ lw $s1,0x54($sp)
|
|
/* 2b420: 8fb20058 */ lw $s2,0x58($sp)
|
|
/* 2b424: 8fb3005c */ lw $s3,0x5c($sp)
|
|
/* 2b428: 8fb40060 */ lw $s4,0x60($sp)
|
|
/* 2b42c: 8fb50064 */ lw $s5,0x64($sp)
|
|
/* 2b430: 8fb60068 */ lw $s6,0x68($sp)
|
|
/* 2b434: 8fb7006c */ lw $s7,0x6c($sp)
|
|
/* 2b438: 8fbe0070 */ lw $s8,0x70($sp)
|
|
/* 2b43c: 03e00008 */ jr $ra
|
|
/* 2b440: 27bd0108 */ addiu $sp,$sp,0x108
|
|
);
|
|
#endif
|
|
|
|
bool cd00029ffc(struct coord *pos, f32 width, f32 foreheadheight, f32 inversefeettoeyesheight, s16 *rooms, u16 arg5, struct coord *laddernormal)
|
|
{
|
|
u32 stack[5];
|
|
struct collisionthing thing;
|
|
|
|
cd00027d1c(pos, width, rooms, CDTYPE_BG,
|
|
arg5, 1, foreheadheight, inversefeettoeyesheight,
|
|
&thing, 1);
|
|
|
|
if (thing.geo) {
|
|
struct geotilei *tile = (struct geotilei *) thing.geo;
|
|
struct coord dist;
|
|
|
|
cd00025928(thing.geo, laddernormal);
|
|
|
|
dist.x = pos->x - tile->vertices[0][0];
|
|
dist.y = pos->y - tile->vertices[0][1];
|
|
dist.z = pos->z - tile->vertices[0][2];
|
|
|
|
if (dist.f[0] * laddernormal->f[0] + dist.f[1] * laddernormal->f[1] + dist.f[2] * laddernormal->f[2] < 0) {
|
|
laddernormal->x = -laddernormal->x;
|
|
laddernormal->y = -laddernormal->y;
|
|
laddernormal->z = -laddernormal->z;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool cd0002a13c(struct coord *pos, f32 radius, f32 arg2, f32 arg3, s16 *rooms, u16 arg5)
|
|
{
|
|
u32 stack[5];
|
|
struct collisionthing thing;
|
|
|
|
cd00027d1c(pos, radius, rooms, CDTYPE_BG, arg5, 1, arg2, arg3, &thing, 1);
|
|
|
|
if (thing.geo) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
f32 cdFindGroundY(struct coord *pos, f32 radius, s16 *rooms, u16 *floorcol,
|
|
u8 *floortype, u16 *floorflags, s16 *floorroom, s32 *inlift, struct prop **lift)
|
|
{
|
|
struct collisionthing cdthings[21];
|
|
struct collisionthing *sp72 = NULL;
|
|
f32 ground;
|
|
struct geo *geo = NULL;
|
|
|
|
cd00027d1c(pos, radius, rooms, CDTYPE_ALL, 3, 0, 0, 0, cdthings, 20);
|
|
ground = cd000296a0(cdthings, pos, &sp72, radius);
|
|
|
|
if (sp72) {
|
|
geo = sp72->geo;
|
|
}
|
|
|
|
if (floorcol) {
|
|
cdGetFloorCol(geo, floorcol);
|
|
}
|
|
|
|
if (floortype) {
|
|
cdGetFloorType(geo, floortype);
|
|
}
|
|
|
|
if (floorflags && geo) {
|
|
*floorflags = geo->flags;
|
|
}
|
|
|
|
if (floorroom) {
|
|
if (sp72) {
|
|
*floorroom = sp72->room;
|
|
} else {
|
|
*floorroom = -1;
|
|
}
|
|
}
|
|
|
|
if (inlift) {
|
|
if (geo && geo->type == GEOTYPE_TILE_F && (geo->flags & GEOFLAG_LIFTFLOOR)) {
|
|
*inlift = true;
|
|
*lift = sp72->prop;
|
|
|
|
if (*lift && (*lift)->obj->modelnum == MODEL_ESCA_STEP && floortype) {
|
|
*floortype = FLOORTYPE_METAL;
|
|
}
|
|
} else {
|
|
*inlift = false;
|
|
*lift = NULL;
|
|
}
|
|
}
|
|
|
|
return ground;
|
|
}
|
|
|
|
/**
|
|
* This function must come immediately after cdFindGroundY.
|
|
*
|
|
* A piracy check looks for this function, then backtracks two instructions to
|
|
* nop the jr ra at the end of cdFindGroundY, causing it to flow into this
|
|
* function and return 0.
|
|
*/
|
|
f32 cd0002a324(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
f32 cdFindGroundYSimple(struct coord *pos, f32 width, s16 *rooms, u16 *floorcol, u8 *floortype)
|
|
{
|
|
return cdFindGroundY(pos, width, rooms, floorcol, floortype, NULL, NULL, NULL, NULL);
|
|
}
|
|
|
|
f32 cd0002a36c(struct coord *coord, s16 *rooms, u16 *floorcol, u8 *floortype)
|
|
{
|
|
struct geo *geo;
|
|
s16 sp30[2];
|
|
f32 sp2c;
|
|
f32 result = -4294967296;
|
|
|
|
cd00026e7c(coord, rooms, 3, &geo, &sp30[1], &sp2c, NULL, 0);
|
|
|
|
if (geo) {
|
|
result = sp2c;
|
|
}
|
|
|
|
if (floorcol) {
|
|
cdGetFloorCol(geo, floorcol);
|
|
}
|
|
|
|
if (floortype) {
|
|
cdGetFloorType(geo, floortype);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s32 cd0002a400(struct coord *pos, s16 *rooms)
|
|
{
|
|
struct geo *geo;
|
|
s16 sp32;
|
|
f32 sp2c;
|
|
|
|
cd00026e7c(pos, rooms, 3, &geo, &sp32, &sp2c, 0, 0);
|
|
|
|
return sp32;
|
|
}
|
|
|
|
#if VERSION >= VERSION_NTSC_1_0
|
|
s16 cd0002a440(struct coord *pos, s16 *rooms, f32 *arg2, u16 *floorcolptr, u16 *flagsptr)
|
|
#else
|
|
s16 cd0002a440(struct coord *pos, s16 *rooms, f32 *arg2, u16 *floorcolptr)
|
|
#endif
|
|
{
|
|
struct geo *geo;
|
|
s16 room;
|
|
f32 sp2c;
|
|
|
|
cd00026e7c(pos, rooms, 3, &geo, &room, &sp2c, NULL, 0);
|
|
|
|
if (geo != NULL) {
|
|
*arg2 = sp2c;
|
|
}
|
|
|
|
if (floorcolptr != NULL) {
|
|
cdGetFloorCol(geo, floorcolptr);
|
|
}
|
|
|
|
#if VERSION >= VERSION_NTSC_1_0
|
|
if (flagsptr != NULL && geo != NULL) {
|
|
*flagsptr = geo->flags;
|
|
}
|
|
#endif
|
|
|
|
return room;
|
|
}
|
|
|
|
s16 cd0002a4d0(struct coord *pos, s16 *rooms, f32 *arg2, u16 *floorcolptr, u16 *flagsptr)
|
|
{
|
|
struct geo *geo;
|
|
s16 sp32;
|
|
f32 sp2c;
|
|
|
|
cd00026e7c(pos, rooms, 3, &geo, &sp32, &sp2c, NULL, 1);
|
|
|
|
if (geo != NULL) {
|
|
*arg2 = sp2c;
|
|
}
|
|
|
|
if (floorcolptr != NULL) {
|
|
cdGetFloorCol(geo, floorcolptr);
|
|
}
|
|
|
|
#if VERSION >= VERSION_NTSC_1_0
|
|
if (flagsptr != NULL && geo != NULL) {
|
|
*flagsptr = geo->flags;
|
|
}
|
|
#endif
|
|
|
|
return sp32;
|
|
}
|
|
|
|
s32 cd0002a564(struct coord *pos, s16 *rooms, f32 *arg2, u16 *floorcol, struct coord *arg4, struct prop **propptr)
|
|
{
|
|
struct geo *geo;
|
|
s16 sp32;
|
|
f32 sp2c;
|
|
|
|
cd00026e7c(pos, rooms, 3, &geo, &sp32, &sp2c, propptr, 0);
|
|
|
|
if (geo) {
|
|
*arg2 = sp2c;
|
|
cd00025928(geo, arg4);
|
|
}
|
|
|
|
if (floorcol) {
|
|
cdGetFloorCol(geo, floorcol);
|
|
}
|
|
|
|
return sp32;
|
|
}
|
|
|
|
s32 cd0002a5e4(struct coord *pos, s16 *rooms, f32 *arg2, u16 *floorcol, u16 *flagsptr, struct coord *arg5)
|
|
{
|
|
struct geo *geo;
|
|
s16 sp32;
|
|
f32 sp2c;
|
|
|
|
cd00026e7c(pos, rooms, 3, &geo, &sp32, &sp2c, NULL, 1);
|
|
|
|
if (geo) {
|
|
*arg2 = sp2c;
|
|
cd00025928(geo, arg5);
|
|
}
|
|
|
|
if (floorcol) {
|
|
cdGetFloorCol(geo, floorcol);
|
|
}
|
|
|
|
if (flagsptr != NULL && geo != NULL) {
|
|
*flagsptr = geo->flags;
|
|
}
|
|
|
|
return sp32;
|
|
}
|
|
|
|
/**
|
|
* Tests if a cylinder volume fits in the given position.
|
|
*/
|
|
s32 cdTestVolume(struct coord *pos, f32 width, s16 *rooms, s32 types, s32 arg4, f32 ymax, f32 ymin)
|
|
{
|
|
struct collisionthing cdthings[2];
|
|
bool result = true;
|
|
|
|
cd00027d1c(pos, width, rooms, types, 4, arg4, ymax, ymin, cdthings, 1);
|
|
|
|
if (cdthings[0].geo) {
|
|
result = false;
|
|
cd00025168(cdthings[0].prop);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
GLOBAL_ASM(
|
|
glabel cd0002a6fc
|
|
/* 2a6fc: 27bdff58 */ addiu $sp,$sp,-168
|
|
/* 2a700: 44866000 */ mtc1 $a2,$f12
|
|
/* 2a704: afb00030 */ sw $s0,0x30($sp)
|
|
/* 2a708: 00808025 */ or $s0,$a0,$zero
|
|
/* 2a70c: 8fb800bc */ lw $t8,0xbc($sp)
|
|
/* 2a710: c7a400c0 */ lwc1 $f4,0xc0($sp)
|
|
/* 2a714: c7a600c4 */ lwc1 $f6,0xc4($sp)
|
|
/* 2a718: afa500ac */ sw $a1,0xac($sp)
|
|
/* 2a71c: 00a02025 */ or $a0,$a1,$zero
|
|
/* 2a720: afbf0034 */ sw $ra,0x34($sp)
|
|
/* 2a724: afa700b4 */ sw $a3,0xb4($sp)
|
|
/* 2a728: 240e0001 */ addiu $t6,$zero,0x1
|
|
/* 2a72c: 00e03025 */ or $a2,$a3,$zero
|
|
/* 2a730: 27b90080 */ addiu $t9,$sp,0x80
|
|
/* 2a734: 240f0004 */ addiu $t7,$zero,0x4
|
|
/* 2a738: 24080001 */ addiu $t0,$zero,0x1
|
|
/* 2a73c: 44056000 */ mfc1 $a1,$f12
|
|
/* 2a740: afae007c */ sw $t6,0x7c($sp)
|
|
/* 2a744: afa80024 */ sw $t0,0x24($sp)
|
|
/* 2a748: afaf0010 */ sw $t7,0x10($sp)
|
|
/* 2a74c: afb90020 */ sw $t9,0x20($sp)
|
|
/* 2a750: 8fa700b8 */ lw $a3,0xb8($sp)
|
|
/* 2a754: afb80014 */ sw $t8,0x14($sp)
|
|
/* 2a758: e7a40018 */ swc1 $f4,0x18($sp)
|
|
/* 2a75c: 0c009f47 */ jal cd00027d1c
|
|
/* 2a760: e7a6001c */ swc1 $f6,0x1c($sp)
|
|
/* 2a764: 8fa90080 */ lw $t1,0x80($sp)
|
|
/* 2a768: 5120009d */ beqzl $t1,.L0002a9e0
|
|
/* 2a76c: 8fbf0034 */ lw $ra,0x34($sp)
|
|
/* 2a770: afa0007c */ sw $zero,0x7c($sp)
|
|
/* 2a774: 91220000 */ lbu $v0,0x0($t1)
|
|
/* 2a778: 54400037 */ bnezl $v0,.L0002a858
|
|
/* 2a77c: 24010001 */ addiu $at,$zero,0x1
|
|
/* 2a780: 8fa50088 */ lw $a1,0x88($sp)
|
|
/* 2a784: 912b0001 */ lbu $t3,0x1($t1)
|
|
/* 2a788: 24070006 */ addiu $a3,$zero,0x6
|
|
/* 2a78c: 24aa0001 */ addiu $t2,$a1,0x1
|
|
/* 2a790: 014b001a */ div $zero,$t2,$t3
|
|
/* 2a794: 00003010 */ mfhi $a2
|
|
/* 2a798: 01201025 */ or $v0,$t1,$zero
|
|
/* 2a79c: 15600002 */ bnez $t3,.L0002a7a8
|
|
/* 2a7a0: 00000000 */ nop
|
|
/* 2a7a4: 0007000d */ break 0x7
|
|
.L0002a7a8:
|
|
/* 2a7a8: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2a7ac: 15610004 */ bne $t3,$at,.L0002a7c0
|
|
/* 2a7b0: 3c018000 */ lui $at,0x8000
|
|
/* 2a7b4: 15410002 */ bne $t2,$at,.L0002a7c0
|
|
/* 2a7b8: 00000000 */ nop
|
|
/* 2a7bc: 0006000d */ break 0x6
|
|
.L0002a7c0:
|
|
/* 2a7c0: 00a70019 */ multu $a1,$a3
|
|
/* 2a7c4: 00006012 */ mflo $t4
|
|
/* 2a7c8: 004c1821 */ addu $v1,$v0,$t4
|
|
/* 2a7cc: 846d000e */ lh $t5,0xe($v1)
|
|
/* 2a7d0: 00c70019 */ multu $a2,$a3
|
|
/* 2a7d4: 448d4000 */ mtc1 $t5,$f8
|
|
/* 2a7d8: 00000000 */ nop
|
|
/* 2a7dc: 468042a0 */ cvt.s.w $f10,$f8
|
|
/* 2a7e0: 0000c012 */ mflo $t8
|
|
/* 2a7e4: e7aa0070 */ swc1 $f10,0x70($sp)
|
|
/* 2a7e8: 846e0010 */ lh $t6,0x10($v1)
|
|
/* 2a7ec: 00582021 */ addu $a0,$v0,$t8
|
|
/* 2a7f0: 448e8000 */ mtc1 $t6,$f16
|
|
/* 2a7f4: 00000000 */ nop
|
|
/* 2a7f8: 468084a0 */ cvt.s.w $f18,$f16
|
|
/* 2a7fc: e7b20074 */ swc1 $f18,0x74($sp)
|
|
/* 2a800: 846f0012 */ lh $t7,0x12($v1)
|
|
/* 2a804: 448f2000 */ mtc1 $t7,$f4
|
|
/* 2a808: 00000000 */ nop
|
|
/* 2a80c: 468021a0 */ cvt.s.w $f6,$f4
|
|
/* 2a810: e7a60078 */ swc1 $f6,0x78($sp)
|
|
/* 2a814: 8499000e */ lh $t9,0xe($a0)
|
|
/* 2a818: 44994000 */ mtc1 $t9,$f8
|
|
/* 2a81c: 00000000 */ nop
|
|
/* 2a820: 468042a0 */ cvt.s.w $f10,$f8
|
|
/* 2a824: e7aa0064 */ swc1 $f10,0x64($sp)
|
|
/* 2a828: 84880010 */ lh $t0,0x10($a0)
|
|
/* 2a82c: 44888000 */ mtc1 $t0,$f16
|
|
/* 2a830: 00000000 */ nop
|
|
/* 2a834: 468084a0 */ cvt.s.w $f18,$f16
|
|
/* 2a838: e7b20068 */ swc1 $f18,0x68($sp)
|
|
/* 2a83c: 84890012 */ lh $t1,0x12($a0)
|
|
/* 2a840: 44892000 */ mtc1 $t1,$f4
|
|
/* 2a844: 00000000 */ nop
|
|
/* 2a848: 468021a0 */ cvt.s.w $f6,$f4
|
|
/* 2a84c: 1000005f */ b .L0002a9cc
|
|
/* 2a850: e7a6006c */ swc1 $f6,0x6c($sp)
|
|
/* 2a854: 24010001 */ addiu $at,$zero,0x1
|
|
.L0002a858:
|
|
/* 2a858: 54410025 */ bnel $v0,$at,.L0002a8f0
|
|
/* 2a85c: 24010002 */ addiu $at,$zero,0x2
|
|
/* 2a860: 8fa20080 */ lw $v0,0x80($sp)
|
|
/* 2a864: 8fa50088 */ lw $a1,0x88($sp)
|
|
/* 2a868: 2407000c */ addiu $a3,$zero,0xc
|
|
/* 2a86c: 904b0001 */ lbu $t3,0x1($v0)
|
|
/* 2a870: 24aa0001 */ addiu $t2,$a1,0x1
|
|
/* 2a874: 014b001a */ div $zero,$t2,$t3
|
|
/* 2a878: 00003010 */ mfhi $a2
|
|
/* 2a87c: 15600002 */ bnez $t3,.L0002a888
|
|
/* 2a880: 00000000 */ nop
|
|
/* 2a884: 0007000d */ break 0x7
|
|
.L0002a888:
|
|
/* 2a888: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2a88c: 15610004 */ bne $t3,$at,.L0002a8a0
|
|
/* 2a890: 3c018000 */ lui $at,0x8000
|
|
/* 2a894: 15410002 */ bne $t2,$at,.L0002a8a0
|
|
/* 2a898: 00000000 */ nop
|
|
/* 2a89c: 0006000d */ break 0x6
|
|
.L0002a8a0:
|
|
/* 2a8a0: 00a70019 */ multu $a1,$a3
|
|
/* 2a8a4: 00006012 */ mflo $t4
|
|
/* 2a8a8: 004c1821 */ addu $v1,$v0,$t4
|
|
/* 2a8ac: c4680010 */ lwc1 $f8,0x10($v1)
|
|
/* 2a8b0: 00c70019 */ multu $a2,$a3
|
|
/* 2a8b4: e7a80070 */ swc1 $f8,0x70($sp)
|
|
/* 2a8b8: c46a0014 */ lwc1 $f10,0x14($v1)
|
|
/* 2a8bc: e7aa0074 */ swc1 $f10,0x74($sp)
|
|
/* 2a8c0: c4700018 */ lwc1 $f16,0x18($v1)
|
|
/* 2a8c4: 00006812 */ mflo $t5
|
|
/* 2a8c8: 004d2021 */ addu $a0,$v0,$t5
|
|
/* 2a8cc: e7b00078 */ swc1 $f16,0x78($sp)
|
|
/* 2a8d0: c4920010 */ lwc1 $f18,0x10($a0)
|
|
/* 2a8d4: e7b20064 */ swc1 $f18,0x64($sp)
|
|
/* 2a8d8: c4840014 */ lwc1 $f4,0x14($a0)
|
|
/* 2a8dc: e7a40068 */ swc1 $f4,0x68($sp)
|
|
/* 2a8e0: c4860018 */ lwc1 $f6,0x18($a0)
|
|
/* 2a8e4: 10000039 */ b .L0002a9cc
|
|
/* 2a8e8: e7a6006c */ swc1 $f6,0x6c($sp)
|
|
/* 2a8ec: 24010002 */ addiu $at,$zero,0x2
|
|
.L0002a8f0:
|
|
/* 2a8f0: 14410020 */ bne $v0,$at,.L0002a974
|
|
/* 2a8f4: 8fa30088 */ lw $v1,0x88($sp)
|
|
/* 2a8f8: 8fa20080 */ lw $v0,0x80($sp)
|
|
/* 2a8fc: 246e0001 */ addiu $t6,$v1,0x1
|
|
/* 2a900: 0003c0c0 */ sll $t8,$v1,0x3
|
|
/* 2a904: 904f0001 */ lbu $t7,0x1($v0)
|
|
/* 2a908: 00582021 */ addu $a0,$v0,$t8
|
|
/* 2a90c: c488000c */ lwc1 $f8,0xc($a0)
|
|
/* 2a910: 01cf001a */ div $zero,$t6,$t7
|
|
/* 2a914: e7a80070 */ swc1 $f8,0x70($sp)
|
|
/* 2a918: c60a0004 */ lwc1 $f10,0x4($s0)
|
|
/* 2a91c: 00003010 */ mfhi $a2
|
|
/* 2a920: 0006c8c0 */ sll $t9,$a2,0x3
|
|
/* 2a924: e7aa0074 */ swc1 $f10,0x74($sp)
|
|
/* 2a928: c4900010 */ lwc1 $f16,0x10($a0)
|
|
/* 2a92c: 00592821 */ addu $a1,$v0,$t9
|
|
/* 2a930: 15e00002 */ bnez $t7,.L0002a93c
|
|
/* 2a934: 00000000 */ nop
|
|
/* 2a938: 0007000d */ break 0x7
|
|
.L0002a93c:
|
|
/* 2a93c: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2a940: 15e10004 */ bne $t7,$at,.L0002a954
|
|
/* 2a944: 3c018000 */ lui $at,0x8000
|
|
/* 2a948: 15c10002 */ bne $t6,$at,.L0002a954
|
|
/* 2a94c: 00000000 */ nop
|
|
/* 2a950: 0006000d */ break 0x6
|
|
.L0002a954:
|
|
/* 2a954: e7b00078 */ swc1 $f16,0x78($sp)
|
|
/* 2a958: c4b2000c */ lwc1 $f18,0xc($a1)
|
|
/* 2a95c: e7b20064 */ swc1 $f18,0x64($sp)
|
|
/* 2a960: c6040004 */ lwc1 $f4,0x4($s0)
|
|
/* 2a964: e7a40068 */ swc1 $f4,0x68($sp)
|
|
/* 2a968: c4a60010 */ lwc1 $f6,0x10($a1)
|
|
/* 2a96c: 10000017 */ b .L0002a9cc
|
|
/* 2a970: e7a6006c */ swc1 $f6,0x6c($sp)
|
|
.L0002a974:
|
|
/* 2a974: 24010003 */ addiu $at,$zero,0x3
|
|
/* 2a978: 14410014 */ bne $v0,$at,.L0002a9cc
|
|
/* 2a97c: 27a80070 */ addiu $t0,$sp,0x70
|
|
/* 2a980: 8fa20080 */ lw $v0,0x80($sp)
|
|
/* 2a984: c6080008 */ lwc1 $f8,0x8($s0)
|
|
/* 2a988: 8e070000 */ lw $a3,0x0($s0)
|
|
/* 2a98c: c44c000c */ lwc1 $f12,0xc($v0)
|
|
/* 2a990: c44e0010 */ lwc1 $f14,0x10($v0)
|
|
/* 2a994: 8c460014 */ lw $a2,0x14($v0)
|
|
/* 2a998: 27a90078 */ addiu $t1,$sp,0x78
|
|
/* 2a99c: 27aa0064 */ addiu $t2,$sp,0x64
|
|
/* 2a9a0: 27ab006c */ addiu $t3,$sp,0x6c
|
|
/* 2a9a4: afab0020 */ sw $t3,0x20($sp)
|
|
/* 2a9a8: afaa001c */ sw $t2,0x1c($sp)
|
|
/* 2a9ac: afa90018 */ sw $t1,0x18($sp)
|
|
/* 2a9b0: afa80014 */ sw $t0,0x14($sp)
|
|
/* 2a9b4: 0c009612 */ jal cd00025848
|
|
/* 2a9b8: e7a80010 */ swc1 $f8,0x10($sp)
|
|
/* 2a9bc: c60a0004 */ lwc1 $f10,0x4($s0)
|
|
/* 2a9c0: e7aa0074 */ swc1 $f10,0x74($sp)
|
|
/* 2a9c4: c6100004 */ lwc1 $f16,0x4($s0)
|
|
/* 2a9c8: e7b00068 */ swc1 $f16,0x68($sp)
|
|
.L0002a9cc:
|
|
/* 2a9cc: 27a40070 */ addiu $a0,$sp,0x70
|
|
/* 2a9d0: 27a50064 */ addiu $a1,$sp,0x64
|
|
/* 2a9d4: 0c0093ec */ jal cd00024fb0
|
|
/* 2a9d8: 8fa6008c */ lw $a2,0x8c($sp)
|
|
/* 2a9dc: 8fbf0034 */ lw $ra,0x34($sp)
|
|
.L0002a9e0:
|
|
/* 2a9e0: 8fa2007c */ lw $v0,0x7c($sp)
|
|
/* 2a9e4: 8fb00030 */ lw $s0,0x30($sp)
|
|
/* 2a9e8: 03e00008 */ jr $ra
|
|
/* 2a9ec: 27bd00a8 */ addiu $sp,$sp,0xa8
|
|
);
|
|
|
|
// Mismatch: Goal copies geo from t1 to v0 in the type 0 block
|
|
//s32 cd0002a6fc(struct coord *pos, struct coord *pos2, f32 width, s16 *rooms, s32 types, bool arg5, f32 arg6, f32 arg7)
|
|
//{
|
|
// u32 stack[5];
|
|
// struct collisionthing thing; // 80
|
|
// s32 cdresult;
|
|
// struct coord sp70;
|
|
// struct coord sp64;
|
|
//
|
|
// cdresult = CDRESULT_NOCOLLISION;
|
|
//
|
|
// cd00027d1c(pos2, width, rooms, types, 4, arg5, arg6, arg7, &thing, 1);
|
|
//
|
|
// // 768
|
|
// if (thing.geo != NULL) {
|
|
// cdresult = CDRESULT_COLLISION;
|
|
//
|
|
// // 778
|
|
// if (thing.geo->type == GEOTYPE_TILE_I) {
|
|
// struct geotilei *tile = (struct geotilei *) thing.geo;
|
|
// s32 this = thing.vertexindex;
|
|
// s32 next = (this + 1) % thing.geo->numvertices;
|
|
//
|
|
// sp70.x = tile->vertices[this][0];
|
|
// sp70.y = tile->vertices[this][1];
|
|
// sp70.z = tile->vertices[this][2];
|
|
//
|
|
// sp64.x = tile->vertices[next][0];
|
|
// sp64.y = tile->vertices[next][1];
|
|
// sp64.z = tile->vertices[next][2];
|
|
// } else /*854*/ if (thing.geo->type == GEOTYPE_TILE_F) {
|
|
// struct geotilef *type1 = (struct geotilef *) thing.geo;
|
|
// s32 this = thing.vertexindex;
|
|
// s32 next = (this + 1) % thing.geo->numvertices;
|
|
//
|
|
// sp70.x = type1->vertices[this].x;
|
|
// sp70.y = type1->vertices[this].y;
|
|
// sp70.z = type1->vertices[this].z;
|
|
//
|
|
// sp64.x = type1->vertices[next].x;
|
|
// sp64.y = type1->vertices[next].y;
|
|
// sp64.z = type1->vertices[next].z;
|
|
// } else if (thing.geo->type == GEOTYPE_BLOCK) {
|
|
// struct geoblock *block = (struct geoblock *) thing.geo;
|
|
// s32 this = thing.vertexindex;
|
|
// s32 next = (this + 1) % thing.geo->numvertices;
|
|
//
|
|
// sp70.x = block->vertices[this][0];
|
|
// sp70.y = pos->y;
|
|
// sp70.z = block->vertices[this][1];
|
|
//
|
|
// sp64.x = block->vertices[next][0];
|
|
// sp64.y = pos->y;
|
|
// sp64.z = block->vertices[next][1];
|
|
// } else if (thing.geo->type == GEOTYPE_CYL) {
|
|
// struct geocyl *cyl = (struct geocyl *) thing.geo;
|
|
//
|
|
// if (1);
|
|
//
|
|
// cd00025848(cyl->x, cyl->z, cyl->width, pos->x, pos->z, &sp70.x, &sp70.z, &sp64.x, &sp64.z);
|
|
//
|
|
// sp70.y = pos->y;
|
|
// sp64.y = pos->y;
|
|
// }
|
|
//
|
|
// cd00024fb0(&sp70, &sp64, thing.prop);
|
|
// }
|
|
//
|
|
// return cdresult;
|
|
//}
|
|
|
|
s32 cdTestAToB1(struct coord *origpos, struct coord *dstpos, f32 width, s16 *dstrooms, s32 types, s32 arg5, f32 ymax, f32 ymin)
|
|
{
|
|
struct collisionthing things[21];
|
|
struct coord dist;
|
|
s32 result = CDRESULT_NOCOLLISION;
|
|
|
|
cd00028df0(dstpos, width, dstrooms, types, 4, arg5, ymax, ymin, things, 20);
|
|
|
|
if (things[0].geo) {
|
|
result = CDRESULT_COLLISION;
|
|
|
|
dist.x = dstpos->x - origpos->x;
|
|
dist.y = dstpos->y - origpos->y;
|
|
dist.z = dstpos->z - origpos->z;
|
|
|
|
cd0002901c(origpos, &dist, width, things);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002aac0(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct geotilei *tile, struct coord *arg4, struct coord *arg5)
|
|
{
|
|
s32 i;
|
|
u8 numvertices = tile->header.numvertices;
|
|
|
|
for (i = 2; i < numvertices; i++) {
|
|
if (func0002f490((struct vec3s16 *)&tile->vertices[0][0],
|
|
(struct vec3s16 *)&tile->vertices[i - 1][0],
|
|
(struct vec3s16 *)&tile->vertices[i][0],
|
|
0, arg0, arg1, arg2, arg4, arg5)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool cd0002ab98(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct geotilef *tile, struct coord *arg4, struct coord *arg5)
|
|
{
|
|
s32 i;
|
|
u8 numvertices = tile->header.numvertices;
|
|
|
|
for (i = 2; i < numvertices; i++) {
|
|
if (func0002f560(&tile->vertices[0], &tile->vertices[i - 1], &tile->vertices[i],
|
|
0, arg0, arg1, arg2, arg4, arg5)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool cd0002ac70(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct geotilei *tile,
|
|
struct coord *arg4, struct coord *arg5, struct coord *arg6, bool arg7, f32 arg8, f32 arg9)
|
|
{
|
|
bool result = false;
|
|
s32 i;
|
|
f32 f0;
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 next;
|
|
s32 spb8 = 1;
|
|
f32 f22 = 1.0f;
|
|
s32 spb0;
|
|
f32 spac;
|
|
f32 spa8;
|
|
f32 ymax = *(s16 *)(tile->ymax + (u32)tile);
|
|
f32 ymin = *(s16 *)(tile->ymin + (u32)tile);
|
|
f32 spa0[2];
|
|
f32 sp98[2];
|
|
f32 sp90[2];
|
|
f32 sp88[2];
|
|
|
|
if (!arg7
|
|
|| (arg0->y + arg8 >= ymin && arg1->y + arg9 <= ymax)
|
|
|| (arg0->y + arg9 <= ymax && arg1->y + arg8 >= ymin)) {
|
|
for (i = 0; i < numvertices; i++) {
|
|
next = (i + 1) % numvertices;
|
|
|
|
if (cd000254d8(arg0, arg1, tile->vertices[i][0], tile->vertices[i][2], tile->vertices[next][0], tile->vertices[next][2], &spb8)) {
|
|
spa0[0] = arg0->x;
|
|
spa0[1] = arg0->z;
|
|
sp98[0] = arg1->x;
|
|
sp98[1] = arg1->z;
|
|
sp90[0] = tile->vertices[i][0];
|
|
sp90[1] = tile->vertices[i][2];
|
|
sp88[0] = tile->vertices[next][0];
|
|
sp88[1] = tile->vertices[next][2];
|
|
|
|
f0 = func0f1577f0(spa0, sp98, sp90, sp88);
|
|
|
|
if (f0 < f22) {
|
|
if (arg7) {
|
|
spa8 = (arg1->y - arg0->y) * f0 + arg0->y;
|
|
spac = spa8 + arg8;
|
|
spa8 = spa8 + arg9;
|
|
}
|
|
|
|
if (!arg7 || (!(spa8 >= ymax) && !(spac <= ymin))) {
|
|
result = true;
|
|
f22 = f0;
|
|
spb0 = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result) {
|
|
arg4->x = arg0->x + arg2->f[0] * f22;
|
|
arg4->y = arg0->y + arg2->f[1] * f22;
|
|
arg4->z = arg0->z + arg2->f[2] * f22;
|
|
|
|
if (arg5 != NULL && arg6 != NULL) {
|
|
arg5->x = tile->vertices[spb0][0];
|
|
arg5->y = arg4->y;
|
|
arg5->z = tile->vertices[spb0][2];
|
|
|
|
arg6->x = tile->vertices[(spb0 + 1) % numvertices][0];
|
|
arg6->y = arg4->y;
|
|
arg6->z = tile->vertices[(spb0 + 1) % numvertices][2];
|
|
}
|
|
} else if (!result && spb8) {
|
|
result = true;
|
|
|
|
arg4->x = arg0->x;
|
|
arg4->y = arg0->y;
|
|
arg4->z = arg0->z;
|
|
|
|
if (arg5 != NULL && arg6 != NULL) {
|
|
arg5->x = arg0->x;
|
|
arg5->y = arg0->y;
|
|
arg5->z = arg0->z;
|
|
|
|
arg6->x = arg0->x;
|
|
arg6->y = arg0->y;
|
|
arg6->z = arg0->z;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002b128(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct geotilef *tile,
|
|
struct coord *arg4, struct coord *arg5, struct coord *arg6, bool arg7, f32 arg8, f32 arg9)
|
|
{
|
|
bool result = false;
|
|
s32 i;
|
|
f32 f0;
|
|
s32 numvertices = tile->header.numvertices;
|
|
s32 next;
|
|
s32 spb8 = 1;
|
|
f32 f22 = 1.0f;
|
|
s32 spb0;
|
|
f32 spac;
|
|
f32 spa8;
|
|
f32 ymax = tile->vertices[tile->ymax].y;
|
|
f32 ymin = tile->vertices[tile->ymin].y;
|
|
f32 spa0[2];
|
|
f32 sp98[2];
|
|
f32 sp90[2];
|
|
f32 sp88[2];
|
|
|
|
if (!arg7
|
|
|| (arg0->y + arg8 >= ymin && arg1->y + arg9 <= ymax)
|
|
|| (arg0->y + arg9 <= ymax && arg1->y + arg8 >= ymin)) {
|
|
for (i = 0; i < numvertices; i++) {
|
|
next = (i + 1) % numvertices;
|
|
|
|
if (cd000254d8(arg0, arg1, tile->vertices[i].x, tile->vertices[i].z, tile->vertices[next].x, tile->vertices[next].z, &spb8)) {
|
|
spa0[0] = arg0->x;
|
|
spa0[1] = arg0->z;
|
|
sp98[0] = arg1->x;
|
|
sp98[1] = arg1->z;
|
|
sp90[0] = tile->vertices[i].x;
|
|
sp90[1] = tile->vertices[i].z;
|
|
sp88[0] = tile->vertices[next].x;
|
|
sp88[1] = tile->vertices[next].z;
|
|
|
|
f0 = func0f1577f0(spa0, sp98, sp90, sp88);
|
|
|
|
if (f0 < f22) {
|
|
if (arg7) {
|
|
spa8 = (arg1->y - arg0->y) * f0 + arg0->y;
|
|
spac = spa8 + arg8;
|
|
spa8 = spa8 + arg9;
|
|
}
|
|
|
|
if (!arg7 || (!(spa8 >= ymax) && !(spac <= ymin))) {
|
|
result = true;
|
|
f22 = f0;
|
|
spb0 = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result) {
|
|
arg4->x = arg0->x + arg2->f[0] * f22;
|
|
arg4->y = arg0->y + arg2->f[1] * f22;
|
|
arg4->z = arg0->z + arg2->f[2] * f22;
|
|
|
|
if (arg5 != NULL && arg6 != NULL) {
|
|
arg5->x = tile->vertices[spb0].x;
|
|
arg5->y = arg4->y;
|
|
arg5->z = tile->vertices[spb0].z;
|
|
|
|
arg6->x = tile->vertices[(spb0 + 1) % numvertices].x;
|
|
arg6->y = arg4->y;
|
|
arg6->z = tile->vertices[(spb0 + 1) % numvertices].z;
|
|
}
|
|
} else if (!result && spb8) {
|
|
result = true;
|
|
|
|
arg4->x = arg0->x;
|
|
arg4->y = arg0->y;
|
|
arg4->z = arg0->z;
|
|
|
|
if (arg5 != NULL && arg6 != NULL) {
|
|
arg5->x = arg0->x;
|
|
arg5->y = arg0->y;
|
|
arg5->z = arg0->z;
|
|
|
|
arg6->x = arg0->x;
|
|
arg6->y = arg0->y;
|
|
arg6->z = arg0->z;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002b560(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct geoblock *block,
|
|
struct coord *arg4, struct coord *arg5, struct coord *arg6, bool arg7, f32 arg8, f32 arg9)
|
|
{
|
|
bool result = false;
|
|
s32 i;
|
|
f32 f0;
|
|
s32 numvertices = block->header.numvertices;
|
|
s32 next;
|
|
s32 spb8 = 1;
|
|
f32 f22 = 1.0f;
|
|
s32 spb0;
|
|
f32 spac;
|
|
f32 spa8;
|
|
f32 spa0[2];
|
|
f32 sp98[2];
|
|
f32 sp90[2];
|
|
f32 sp88[2];
|
|
|
|
if (!arg7
|
|
|| (arg0->y + arg8 >= block->ymin && arg1->y + arg9 <= block->ymax)
|
|
|| (arg0->y + arg9 <= block->ymax && arg1->y + arg8 >= block->ymin)) {
|
|
for (i = 0; i < numvertices; i++) {
|
|
next = (i + 1) % numvertices;
|
|
|
|
if (cd000254d8(arg0, arg1, block->vertices[i][0], block->vertices[i][1], block->vertices[next][0], block->vertices[next][1], &spb8)) {
|
|
spa0[0] = arg0->x;
|
|
spa0[1] = arg0->z;
|
|
sp98[0] = arg1->x;
|
|
sp98[1] = arg1->z;
|
|
sp90[0] = block->vertices[i][0];
|
|
sp90[1] = block->vertices[i][1];
|
|
sp88[0] = block->vertices[next][0];
|
|
sp88[1] = block->vertices[next][1];
|
|
|
|
f0 = func0f1577f0(spa0, sp98, sp90, sp88);
|
|
|
|
if (f0 < f22) {
|
|
if (arg7) {
|
|
spa8 = (arg1->y - arg0->y) * f0 + arg0->y;
|
|
spac = spa8 + arg8;
|
|
spa8 = spa8 + arg9;
|
|
}
|
|
|
|
if (!arg7 || (!(spa8 >= block->ymax) && !(spac <= block->ymin))) {
|
|
result = true;
|
|
f22 = f0;
|
|
spb0 = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result) {
|
|
arg4->x = arg0->x + arg2->f[0] * f22;
|
|
arg4->y = arg0->y + arg2->f[1] * f22;
|
|
arg4->z = arg0->z + arg2->f[2] * f22;
|
|
|
|
if (arg5 != NULL && arg6 != NULL) {
|
|
arg5->x = block->vertices[spb0][0];
|
|
arg5->y = arg4->y;
|
|
arg5->z = block->vertices[spb0][1];
|
|
|
|
arg6->x = block->vertices[(spb0 + 1) % numvertices][0];
|
|
arg6->y = arg4->y;
|
|
arg6->z = block->vertices[(spb0 + 1) % numvertices][1];
|
|
}
|
|
} else if (!result && spb8) {
|
|
result = true;
|
|
|
|
arg4->x = arg0->x;
|
|
arg4->y = arg0->y;
|
|
arg4->z = arg0->z;
|
|
|
|
if (arg5 != NULL && arg6 != NULL) {
|
|
arg5->x = arg0->x;
|
|
arg5->y = arg0->y;
|
|
arg5->z = arg0->z;
|
|
|
|
arg6->x = arg0->x;
|
|
arg6->y = arg0->y;
|
|
arg6->z = arg0->z;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002b954(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct geocyl *cyl,
|
|
struct coord *arg4, struct coord *arg5, struct coord *arg6, bool arg7, f32 arg8, f32 arg9)
|
|
{
|
|
bool result = false;
|
|
f32 mult;
|
|
f32 sp74;
|
|
f32 x = cyl->x;
|
|
f32 z = cyl->z;
|
|
f32 radius = cyl->radius;
|
|
|
|
if (!arg7
|
|
|| (arg0->y + arg8 >= cyl->ymin && arg1->y + arg9 <= cyl->ymax)
|
|
|| (arg0->y + arg9 <= cyl->ymax && arg1->y + arg8 >= cyl->ymin)) {
|
|
sp74 = cd00025654(arg0->x, arg0->z, arg1->x, arg1->z, x, z);
|
|
|
|
if (sp74 < 0.0f) {
|
|
sp74 = -sp74;
|
|
}
|
|
|
|
if (sp74 < radius
|
|
&& (cd00025724(arg0->x, arg0->z, x, z) < radius
|
|
|| cd00025724(arg1->x, arg1->z, x, z) < radius
|
|
|| cd00025774(arg0->x, arg0->z, arg1->x, arg1->z, x, z))) {
|
|
f32 xdiff = arg1->x - arg0->x;
|
|
f32 zdiff = arg1->z - arg0->z;
|
|
f32 sqdist;
|
|
f32 dist;
|
|
u32 stack;
|
|
f32 sp50;
|
|
f32 sp4c;
|
|
f32 sp48;
|
|
|
|
sp50 = sqrtf(xdiff * xdiff + zdiff * zdiff);
|
|
|
|
if (sp50 > 0.0f) {
|
|
xdiff = x - arg0->x;
|
|
zdiff = z - arg0->z;
|
|
|
|
sqdist = xdiff * xdiff + zdiff * zdiff;
|
|
|
|
if (sp74 * sp74 <= sqdist) {
|
|
dist = sqrtf(sqdist - sp74 * sp74) - sqrtf(radius * radius - sp74 * sp74);
|
|
} else {
|
|
dist = 0.0f;
|
|
}
|
|
|
|
mult = dist / sp50;
|
|
} else {
|
|
mult = 0.0f;
|
|
}
|
|
|
|
if (mult < 1.0f) {
|
|
if (arg7) {
|
|
sp48 = (arg1->y - arg0->y) * mult + arg0->y;
|
|
sp4c = sp48 + arg8;
|
|
sp48 = sp48 + arg9;
|
|
}
|
|
|
|
if (!arg7 || (!(sp48 >= cyl->ymax) && !(sp4c <= cyl->ymin))) {
|
|
result = true;
|
|
|
|
arg4->x = arg0->x + arg2->f[0] * mult;
|
|
arg4->y = arg0->y + arg2->f[1] * mult;
|
|
arg4->z = arg0->z + arg2->f[2] * mult;
|
|
|
|
if (arg5 != NULL && arg6 != NULL) {
|
|
cd00025848(x, z, radius, arg0->x, arg0->z, &arg5->x, &arg5->z, &arg6->x, &arg6->z);
|
|
|
|
arg5->y = arg4->y;
|
|
arg6->y = arg4->y;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002bd04(u8 *start, u8 *end, struct coord *arg2, struct coord *arg3, struct coord *arg4, u16 flags, bool arg6, s32 arg7, f32 arg8, f32 arg9)
|
|
{
|
|
struct geo *geo = (struct geo *) start;
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *) geo;
|
|
struct coord min;
|
|
struct coord max;
|
|
struct coord spc4;
|
|
struct coord spb8;
|
|
|
|
if (tile->header.flags & flags) {
|
|
min.x = *(s16 *)(tile->xmin + (u32)tile);
|
|
|
|
if ((!(arg2->x < min.x)) || !(arg3->x < min.x)) {
|
|
max.x = *(s16 *)(tile->xmax + (u32)tile);
|
|
|
|
if ((!(arg2->x > max.x)) || !(arg3->x > max.x)) {
|
|
min.z = *(s16 *)(tile->zmin + (u32)tile);
|
|
|
|
if ((!(arg2->z < min.z)) || !(arg3->z < min.z)) {
|
|
max.z = *(s16 *)(tile->zmax + (u32)tile);
|
|
|
|
if ((!(arg2->z > max.z)) || !(arg3->z > max.z)) {
|
|
if (1);
|
|
if (arg6) {
|
|
min.y = *(s16 *)(tile->ymin + (u32)tile);
|
|
max.y = *(s16 *)(tile->ymax + (u32)tile);
|
|
|
|
if ((!(arg2->y < min.y) || !(arg3->y < min.y))
|
|
&& (!(arg2->y > max.y) || !(arg3->y > max.y))
|
|
&& bg0f15f2b0(arg2, arg4, &min, &max)
|
|
&& cd0002aac0(arg2, arg3, arg4, tile, &spc4, &spb8)) {
|
|
return false;
|
|
}
|
|
} else if (cd0002ac70(arg2, arg3, arg4, tile, &spc4, 0, 0, arg7, arg8, arg9)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + tile->header.numvertices * 6 + 0xe);
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *tile = (struct geotilef *) geo;
|
|
struct coord min;
|
|
struct coord max;
|
|
struct coord sp90;
|
|
struct coord sp84;
|
|
|
|
if (tile->header.flags & flags) {
|
|
min.x = tile->vertices[tile->xmin].x;
|
|
max.x = tile->vertices[tile->xmax].x;
|
|
min.z = tile->vertices[tile->zmin].z;
|
|
max.z = tile->vertices[tile->zmax].z;
|
|
|
|
if (((!(arg2->x < min.x)) || !(arg3->x < min.x))
|
|
&& (!(arg2->x > max.x) || !(arg3->x > max.x))
|
|
&& ((!(arg2->z < min.z)) || !(arg3->z < min.z))
|
|
&& (!(arg2->z > max.z) || !(arg3->z > max.z))) {
|
|
if (arg6) {
|
|
min.y = tile->vertices[tile->ymin].y;
|
|
max.y = tile->vertices[tile->ymax].y;
|
|
|
|
if ((!(arg2->y < min.y) || !(arg3->y < min.y))
|
|
&& (!(arg2->y > max.y) || !(arg3->y > max.y))
|
|
&& bg0f15f2b0(arg2, arg4, &min, &max)
|
|
&& cd0002ab98(arg2, arg3, arg4, tile, &sp90, &sp84)) {
|
|
return false;
|
|
}
|
|
} else if (cd0002b128(arg2, arg3, arg4, tile, &sp90, 0, 0, arg7, arg8, arg9)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + (u32)(tile->header.numvertices - 0x40) * 0xc + 0x310);
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
struct coord sp78;
|
|
struct geoblock *block = (struct geoblock *) geo;
|
|
|
|
if ((flags & (GEOFLAG_COLLISIONS | GEOFLAG_0008 | GEOFLAG_OPAQUE))
|
|
&& cd0002b560(arg2, arg3, arg4, block, &sp78, 0, 0, arg7, arg8, arg9)) {
|
|
return false;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geoblock));
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
struct coord sp68;
|
|
struct geocyl *cyl = (struct geocyl *) geo;
|
|
|
|
if ((flags & cyl->header.flags)
|
|
&& cd0002b954(arg2, arg3, arg4, cyl, &sp68, 0, 0, arg7, arg8, arg9)) {
|
|
return false;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geocyl));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void cd0002c328(struct geotilei *tile, struct coord *arg1, struct coord *arg2, struct coord *arg3, struct coord *arg4)
|
|
{
|
|
struct coord sp3c;
|
|
u32 stack[2];
|
|
u8 numvertices;
|
|
f32 max = 0.0f;
|
|
f32 min = 0.0f;
|
|
f32 dist;
|
|
s32 i;
|
|
|
|
if (arg2->x != 0.0f || arg2->z != 0.0f) {
|
|
sp3c.x = arg2->z;
|
|
sp3c.y = 0.0f;
|
|
sp3c.z = -arg2->x;
|
|
|
|
dist = sqrtf(sp3c.f[0] * sp3c.f[0] + sp3c.f[2] * sp3c.f[2]);
|
|
|
|
if (dist > 0.0f) {
|
|
sp3c.x *= 1.0f / dist;
|
|
sp3c.z *= 1.0f / dist;
|
|
} else {
|
|
sp3c.x = 0.0f;
|
|
sp3c.y = 0.0f;
|
|
sp3c.z = 1.0f;
|
|
}
|
|
} else {
|
|
sp3c.x = 0.0f;
|
|
sp3c.y = 0.0f;
|
|
sp3c.z = 1.0f;
|
|
}
|
|
|
|
numvertices = tile->header.numvertices;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
f32 xdiff = tile->vertices[i][0] - arg1->x;
|
|
f32 zdiff = tile->vertices[i][2] - arg1->z;
|
|
f32 f0 = xdiff * sp3c.f[0] + zdiff * sp3c.f[2];
|
|
|
|
if (f0 > max) {
|
|
max = f0;
|
|
} else if (f0 < min) {
|
|
min = f0;
|
|
}
|
|
}
|
|
|
|
arg3->x = arg1->x + sp3c.f[0] * max;
|
|
arg3->y = arg1->y;
|
|
arg3->z = arg1->z + sp3c.f[2] * max;
|
|
|
|
arg4->x = arg1->x + sp3c.f[0] * min;
|
|
arg4->y = arg1->y;
|
|
arg4->z = arg1->z + sp3c.f[2] * min;
|
|
}
|
|
|
|
void cd0002c528(struct geotilef *tile, struct coord *arg1, struct coord *arg2, struct coord *arg3, struct coord *arg4)
|
|
{
|
|
struct coord sp3c;
|
|
u32 stack[2];
|
|
u8 numvertices;
|
|
f32 max = 0.0f;
|
|
f32 min = 0.0f;
|
|
f32 dist;
|
|
s32 i;
|
|
|
|
if (arg2->x != 0.0f || arg2->z != 0.0f) {
|
|
sp3c.x = arg2->z;
|
|
sp3c.y = 0.0f;
|
|
sp3c.z = -arg2->x;
|
|
|
|
dist = sqrtf(sp3c.f[0] * sp3c.f[0] + sp3c.f[2] * sp3c.f[2]);
|
|
|
|
if (dist > 0.0f) {
|
|
sp3c.x *= 1.0f / dist;
|
|
sp3c.z *= 1.0f / dist;
|
|
} else {
|
|
sp3c.x = 0.0f;
|
|
sp3c.y = 0.0f;
|
|
sp3c.z = 1.0f;
|
|
}
|
|
} else {
|
|
sp3c.x = 0.0f;
|
|
sp3c.y = 0.0f;
|
|
sp3c.z = 1.0f;
|
|
}
|
|
|
|
numvertices = tile->header.numvertices;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
f32 xdiff = tile->vertices[i].x - arg1->x;
|
|
f32 zdiff = tile->vertices[i].z - arg1->z;
|
|
f32 f0 = xdiff * sp3c.f[0] + zdiff * sp3c.f[2];
|
|
|
|
if (f0 > max) {
|
|
max = f0;
|
|
} else if (f0 < min) {
|
|
min = f0;
|
|
}
|
|
}
|
|
|
|
arg3->x = arg1->x + sp3c.f[0] * max;
|
|
arg3->y = arg1->y;
|
|
arg3->z = arg1->z + sp3c.f[2] * max;
|
|
|
|
arg4->x = arg1->x + sp3c.f[0] * min;
|
|
arg4->y = arg1->y;
|
|
arg4->z = arg1->z + sp3c.f[2] * min;
|
|
}
|
|
|
|
GLOBAL_ASM(
|
|
glabel cd0002c714
|
|
/* 2c714: 27bdfe90 */ addiu $sp,$sp,-368
|
|
/* 2c718: afb3004c */ sw $s3,0x4c($sp)
|
|
/* 2c71c: afb10044 */ sw $s1,0x44($sp)
|
|
/* 2c720: afb00040 */ sw $s0,0x40($sp)
|
|
/* 2c724: 0085082b */ sltu $at,$a0,$a1
|
|
/* 2c728: 00c08825 */ or $s1,$a2,$zero
|
|
/* 2c72c: 00e09825 */ or $s3,$a3,$zero
|
|
/* 2c730: afbf0064 */ sw $ra,0x64($sp)
|
|
/* 2c734: afbe0060 */ sw $s8,0x60($sp)
|
|
/* 2c738: afb7005c */ sw $s7,0x5c($sp)
|
|
/* 2c73c: afb60058 */ sw $s6,0x58($sp)
|
|
/* 2c740: afb50054 */ sw $s5,0x54($sp)
|
|
/* 2c744: afb40050 */ sw $s4,0x50($sp)
|
|
/* 2c748: afb20048 */ sw $s2,0x48($sp)
|
|
/* 2c74c: f7b60038 */ sdc1 $f22,0x38($sp)
|
|
/* 2c750: f7b40030 */ sdc1 $f20,0x30($sp)
|
|
/* 2c754: afa50174 */ sw $a1,0x174($sp)
|
|
/* 2c758: afa00154 */ sw $zero,0x154($sp)
|
|
/* 2c75c: 1020026e */ beqz $at,.L0002d118
|
|
/* 2c760: 00808025 */ or $s0,$a0,$zero
|
|
/* 2c764: c7b60190 */ lwc1 $f22,0x190($sp)
|
|
/* 2c768: c7b40194 */ lwc1 $f20,0x194($sp)
|
|
/* 2c76c: 241e000c */ addiu $s8,$zero,0xc
|
|
/* 2c770: 8fb70180 */ lw $s7,0x180($sp)
|
|
/* 2c774: 8fb60198 */ lw $s6,0x198($sp)
|
|
/* 2c778: 8fb501a4 */ lw $s5,0x1a4($sp)
|
|
/* 2c77c: 8fb401a0 */ lw $s4,0x1a0($sp)
|
|
/* 2c780: 8fb2019c */ lw $s2,0x19c($sp)
|
|
/* 2c784: 92020000 */ lbu $v0,0x0($s0)
|
|
.L0002c788:
|
|
/* 2c788: 24010001 */ addiu $at,$zero,0x1
|
|
/* 2c78c: 144000fb */ bnez $v0,.L0002cb7c
|
|
/* 2c790: 00000000 */ nop
|
|
/* 2c794: afb00150 */ sw $s0,0x150($sp)
|
|
/* 2c798: 960f0002 */ lhu $t7,0x2($s0)
|
|
/* 2c79c: 24030001 */ addiu $v1,$zero,0x1
|
|
/* 2c7a0: 31f80080 */ andi $t8,$t7,0x80
|
|
/* 2c7a4: 1300000c */ beqz $t8,.L0002c7d8
|
|
/* 2c7a8: 00000000 */ nop
|
|
/* 2c7ac: c6200004 */ lwc1 $f0,0x4($s1)
|
|
/* 2c7b0: 02002025 */ or $a0,$s0,$zero
|
|
/* 2c7b4: 02202825 */ or $a1,$s1,$zero
|
|
/* 2c7b8: 46140100 */ add.s $f4,$f0,$f20
|
|
/* 2c7bc: 24060000 */ addiu $a2,$zero,0x0
|
|
/* 2c7c0: 46160180 */ add.s $f6,$f0,$f22
|
|
/* 2c7c4: 44072000 */ mfc1 $a3,$f4
|
|
/* 2c7c8: 0c00a080 */ jal cd00028200
|
|
/* 2c7cc: e7a60010 */ swc1 $f6,0x10($sp)
|
|
/* 2c7d0: 10000001 */ b .L0002c7d8
|
|
/* 2c7d4: 00401825 */ or $v1,$v0,$zero
|
|
.L0002c7d8:
|
|
/* 2c7d8: 106000e0 */ beqz $v1,.L0002cb5c
|
|
/* 2c7dc: 97a80186 */ lhu $t0,0x186($sp)
|
|
/* 2c7e0: 96190002 */ lhu $t9,0x2($s0)
|
|
/* 2c7e4: 03284824 */ and $t1,$t9,$t0
|
|
/* 2c7e8: 512000dd */ beqzl $t1,.L0002cb60
|
|
/* 2c7ec: 8fa90150 */ lw $t1,0x150($sp)
|
|
/* 2c7f0: 920a0006 */ lbu $t2,0x6($s0)
|
|
/* 2c7f4: 01505821 */ addu $t3,$t2,$s0
|
|
/* 2c7f8: 856c0000 */ lh $t4,0x0($t3)
|
|
/* 2c7fc: 448c4000 */ mtc1 $t4,$f8
|
|
/* 2c800: 00000000 */ nop
|
|
/* 2c804: 468042a0 */ cvt.s.w $f10,$f8
|
|
/* 2c808: e7aa0144 */ swc1 $f10,0x144($sp)
|
|
/* 2c80c: c7b20144 */ lwc1 $f18,0x144($sp)
|
|
/* 2c810: c6300000 */ lwc1 $f16,0x0($s1)
|
|
/* 2c814: 4612803c */ c.lt.s $f16,$f18
|
|
/* 2c818: 00000000 */ nop
|
|
/* 2c81c: 45020007 */ bc1fl .L0002c83c
|
|
/* 2c820: 920d0009 */ lbu $t5,0x9($s0)
|
|
/* 2c824: c6640000 */ lwc1 $f4,0x0($s3)
|
|
/* 2c828: 4612203c */ c.lt.s $f4,$f18
|
|
/* 2c82c: 00000000 */ nop
|
|
/* 2c830: 450300cb */ bc1tl .L0002cb60
|
|
/* 2c834: 8fa90150 */ lw $t1,0x150($sp)
|
|
/* 2c838: 920d0009 */ lbu $t5,0x9($s0)
|
|
.L0002c83c:
|
|
/* 2c83c: 01b07021 */ addu $t6,$t5,$s0
|
|
/* 2c840: 85cf0000 */ lh $t7,0x0($t6)
|
|
/* 2c844: 448f3000 */ mtc1 $t7,$f6
|
|
/* 2c848: 00000000 */ nop
|
|
/* 2c84c: 46803220 */ cvt.s.w $f8,$f6
|
|
/* 2c850: e7a80138 */ swc1 $f8,0x138($sp)
|
|
/* 2c854: c6300000 */ lwc1 $f16,0x0($s1)
|
|
/* 2c858: c7aa0138 */ lwc1 $f10,0x138($sp)
|
|
/* 2c85c: 4610503c */ c.lt.s $f10,$f16
|
|
/* 2c860: 00000000 */ nop
|
|
/* 2c864: 45020007 */ bc1fl .L0002c884
|
|
/* 2c868: 92180008 */ lbu $t8,0x8($s0)
|
|
/* 2c86c: c6640000 */ lwc1 $f4,0x0($s3)
|
|
/* 2c870: 4604503c */ c.lt.s $f10,$f4
|
|
/* 2c874: 00000000 */ nop
|
|
/* 2c878: 450300b9 */ bc1tl .L0002cb60
|
|
/* 2c87c: 8fa90150 */ lw $t1,0x150($sp)
|
|
/* 2c880: 92180008 */ lbu $t8,0x8($s0)
|
|
.L0002c884:
|
|
/* 2c884: 0310c821 */ addu $t9,$t8,$s0
|
|
/* 2c888: 87280000 */ lh $t0,0x0($t9)
|
|
/* 2c88c: 44889000 */ mtc1 $t0,$f18
|
|
/* 2c890: 00000000 */ nop
|
|
/* 2c894: 468091a0 */ cvt.s.w $f6,$f18
|
|
/* 2c898: e7a6014c */ swc1 $f6,0x14c($sp)
|
|
/* 2c89c: c7b0014c */ lwc1 $f16,0x14c($sp)
|
|
/* 2c8a0: c6280008 */ lwc1 $f8,0x8($s1)
|
|
/* 2c8a4: 4610403c */ c.lt.s $f8,$f16
|
|
/* 2c8a8: 00000000 */ nop
|
|
/* 2c8ac: 45020007 */ bc1fl .L0002c8cc
|
|
/* 2c8b0: 9209000b */ lbu $t1,0xb($s0)
|
|
/* 2c8b4: c66a0008 */ lwc1 $f10,0x8($s3)
|
|
/* 2c8b8: 4610503c */ c.lt.s $f10,$f16
|
|
/* 2c8bc: 00000000 */ nop
|
|
/* 2c8c0: 450300a7 */ bc1tl .L0002cb60
|
|
/* 2c8c4: 8fa90150 */ lw $t1,0x150($sp)
|
|
/* 2c8c8: 9209000b */ lbu $t1,0xb($s0)
|
|
.L0002c8cc:
|
|
/* 2c8cc: 8fac0188 */ lw $t4,0x188($sp)
|
|
/* 2c8d0: 01305021 */ addu $t2,$t1,$s0
|
|
/* 2c8d4: 854b0000 */ lh $t3,0x0($t2)
|
|
/* 2c8d8: 448b2000 */ mtc1 $t3,$f4
|
|
/* 2c8dc: 00000000 */ nop
|
|
/* 2c8e0: 468024a0 */ cvt.s.w $f18,$f4
|
|
/* 2c8e4: e7b20140 */ swc1 $f18,0x140($sp)
|
|
/* 2c8e8: c6280008 */ lwc1 $f8,0x8($s1)
|
|
/* 2c8ec: c7a60140 */ lwc1 $f6,0x140($sp)
|
|
/* 2c8f0: 4608303c */ c.lt.s $f6,$f8
|
|
/* 2c8f4: 00000000 */ nop
|
|
/* 2c8f8: 45000006 */ bc1f .L0002c914
|
|
/* 2c8fc: 00000000 */ nop
|
|
/* 2c900: c66a0008 */ lwc1 $f10,0x8($s3)
|
|
/* 2c904: 460a303c */ c.lt.s $f6,$f10
|
|
/* 2c908: 00000000 */ nop
|
|
/* 2c90c: 45030094 */ bc1tl .L0002cb60
|
|
/* 2c910: 8fa90150 */ lw $t1,0x150($sp)
|
|
.L0002c914:
|
|
/* 2c914: 11800058 */ beqz $t4,.L0002ca78
|
|
/* 2c918: 02202025 */ or $a0,$s1,$zero
|
|
/* 2c91c: 920d0007 */ lbu $t5,0x7($s0)
|
|
/* 2c920: 01b07021 */ addu $t6,$t5,$s0
|
|
/* 2c924: 85cf0000 */ lh $t7,0x0($t6)
|
|
/* 2c928: 448f8000 */ mtc1 $t7,$f16
|
|
/* 2c92c: 00000000 */ nop
|
|
/* 2c930: 46808120 */ cvt.s.w $f4,$f16
|
|
/* 2c934: e7a40148 */ swc1 $f4,0x148($sp)
|
|
/* 2c938: 9218000a */ lbu $t8,0xa($s0)
|
|
/* 2c93c: c7a60148 */ lwc1 $f6,0x148($sp)
|
|
/* 2c940: 0310c821 */ addu $t9,$t8,$s0
|
|
/* 2c944: 87280000 */ lh $t0,0x0($t9)
|
|
/* 2c948: 44889000 */ mtc1 $t0,$f18
|
|
/* 2c94c: 00000000 */ nop
|
|
/* 2c950: 46809220 */ cvt.s.w $f8,$f18
|
|
/* 2c954: e7a8013c */ swc1 $f8,0x13c($sp)
|
|
/* 2c958: c6200004 */ lwc1 $f0,0x4($s1)
|
|
/* 2c95c: c7b0013c */ lwc1 $f16,0x13c($sp)
|
|
/* 2c960: 4606003c */ c.lt.s $f0,$f6
|
|
/* 2c964: 00000000 */ nop
|
|
/* 2c968: 45020007 */ bc1fl .L0002c988
|
|
/* 2c96c: 4600803c */ c.lt.s $f16,$f0
|
|
/* 2c970: c66a0004 */ lwc1 $f10,0x4($s3)
|
|
/* 2c974: 4606503c */ c.lt.s $f10,$f6
|
|
/* 2c978: 00000000 */ nop
|
|
/* 2c97c: 45030078 */ bc1tl .L0002cb60
|
|
/* 2c980: 8fa90150 */ lw $t1,0x150($sp)
|
|
/* 2c984: 4600803c */ c.lt.s $f16,$f0
|
|
.L0002c988:
|
|
/* 2c988: 02202025 */ or $a0,$s1,$zero
|
|
/* 2c98c: 02e02825 */ or $a1,$s7,$zero
|
|
/* 2c990: 27a60144 */ addiu $a2,$sp,0x144
|
|
/* 2c994: 45000006 */ bc1f .L0002c9b0
|
|
/* 2c998: 00000000 */ nop
|
|
/* 2c99c: c6640004 */ lwc1 $f4,0x4($s3)
|
|
/* 2c9a0: 4604803c */ c.lt.s $f16,$f4
|
|
/* 2c9a4: 00000000 */ nop
|
|
/* 2c9a8: 4503006d */ bc1tl .L0002cb60
|
|
/* 2c9ac: 8fa90150 */ lw $t1,0x150($sp)
|
|
.L0002c9b0:
|
|
/* 2c9b0: 0fc57cac */ jal bg0f15f2b0
|
|
/* 2c9b4: 27a70138 */ addiu $a3,$sp,0x138
|
|
/* 2c9b8: 10400068 */ beqz $v0,.L0002cb5c
|
|
/* 2c9bc: 02202025 */ or $a0,$s1,$zero
|
|
/* 2c9c0: 27a9012c */ addiu $t1,$sp,0x12c
|
|
/* 2c9c4: 27aa0120 */ addiu $t2,$sp,0x120
|
|
/* 2c9c8: afaa0014 */ sw $t2,0x14($sp)
|
|
/* 2c9cc: afa90010 */ sw $t1,0x10($sp)
|
|
/* 2c9d0: 02602825 */ or $a1,$s3,$zero
|
|
/* 2c9d4: 02e03025 */ or $a2,$s7,$zero
|
|
/* 2c9d8: 0c00aab0 */ jal cd0002aac0
|
|
/* 2c9dc: 02003825 */ or $a3,$s0,$zero
|
|
/* 2c9e0: 1040005e */ beqz $v0,.L0002cb5c
|
|
/* 2c9e4: c7b2012c */ lwc1 $f18,0x12c($sp)
|
|
/* 2c9e8: c6280000 */ lwc1 $f8,0x0($s1)
|
|
/* 2c9ec: c7aa0130 */ lwc1 $f10,0x130($sp)
|
|
/* 2c9f0: c6260004 */ lwc1 $f6,0x4($s1)
|
|
/* 2c9f4: 46089001 */ sub.s $f0,$f18,$f8
|
|
/* 2c9f8: c7b00134 */ lwc1 $f16,0x134($sp)
|
|
/* 2c9fc: c6240008 */ lwc1 $f4,0x8($s1)
|
|
/* 2ca00: 46065081 */ sub.s $f2,$f10,$f6
|
|
/* 2ca04: 46000482 */ mul.s $f18,$f0,$f0
|
|
/* 2ca08: 240b0001 */ addiu $t3,$zero,0x1
|
|
/* 2ca0c: 46048301 */ sub.s $f12,$f16,$f4
|
|
/* 2ca10: 46021202 */ mul.s $f8,$f2,$f2
|
|
/* 2ca14: c6d00000 */ lwc1 $f16,0x0($s6)
|
|
/* 2ca18: 460c6182 */ mul.s $f6,$f12,$f12
|
|
/* 2ca1c: 46089280 */ add.s $f10,$f18,$f8
|
|
/* 2ca20: 46065380 */ add.s $f14,$f10,$f6
|
|
/* 2ca24: 4610703c */ c.lt.s $f14,$f16
|
|
/* 2ca28: 00000000 */ nop
|
|
/* 2ca2c: 4502004c */ bc1fl .L0002cb60
|
|
/* 2ca30: 8fa90150 */ lw $t1,0x150($sp)
|
|
/* 2ca34: afab0154 */ sw $t3,0x154($sp)
|
|
/* 2ca38: e6ce0000 */ swc1 $f14,0x0($s6)
|
|
/* 2ca3c: c7a4012c */ lwc1 $f4,0x12c($sp)
|
|
/* 2ca40: 02002025 */ or $a0,$s0,$zero
|
|
/* 2ca44: 27a5012c */ addiu $a1,$sp,0x12c
|
|
/* 2ca48: e6440000 */ swc1 $f4,0x0($s2)
|
|
/* 2ca4c: c7b20130 */ lwc1 $f18,0x130($sp)
|
|
/* 2ca50: 27a60120 */ addiu $a2,$sp,0x120
|
|
/* 2ca54: 02803825 */ or $a3,$s4,$zero
|
|
/* 2ca58: e6520004 */ swc1 $f18,0x4($s2)
|
|
/* 2ca5c: c7a80134 */ lwc1 $f8,0x134($sp)
|
|
/* 2ca60: e6480008 */ swc1 $f8,0x8($s2)
|
|
/* 2ca64: 0c00b0ca */ jal cd0002c328
|
|
/* 2ca68: afb50010 */ sw $s5,0x10($sp)
|
|
/* 2ca6c: 8fac01a8 */ lw $t4,0x1a8($sp)
|
|
/* 2ca70: 1000003a */ b .L0002cb5c
|
|
/* 2ca74: ad900000 */ sw $s0,0x0($t4)
|
|
.L0002ca78:
|
|
/* 2ca78: 8fb8018c */ lw $t8,0x18c($sp)
|
|
/* 2ca7c: 27ad012c */ addiu $t5,$sp,0x12c
|
|
/* 2ca80: 27ae0114 */ addiu $t6,$sp,0x114
|
|
/* 2ca84: 27af0108 */ addiu $t7,$sp,0x108
|
|
/* 2ca88: afaf0018 */ sw $t7,0x18($sp)
|
|
/* 2ca8c: afae0014 */ sw $t6,0x14($sp)
|
|
/* 2ca90: afad0010 */ sw $t5,0x10($sp)
|
|
/* 2ca94: 02602825 */ or $a1,$s3,$zero
|
|
/* 2ca98: 02e03025 */ or $a2,$s7,$zero
|
|
/* 2ca9c: 02003825 */ or $a3,$s0,$zero
|
|
/* 2caa0: e7b60020 */ swc1 $f22,0x20($sp)
|
|
/* 2caa4: e7b40024 */ swc1 $f20,0x24($sp)
|
|
/* 2caa8: 0c00ab1c */ jal cd0002ac70
|
|
/* 2caac: afb8001c */ sw $t8,0x1c($sp)
|
|
/* 2cab0: 1040002a */ beqz $v0,.L0002cb5c
|
|
/* 2cab4: c7aa012c */ lwc1 $f10,0x12c($sp)
|
|
/* 2cab8: c6260000 */ lwc1 $f6,0x0($s1)
|
|
/* 2cabc: c7b00130 */ lwc1 $f16,0x130($sp)
|
|
/* 2cac0: c6240004 */ lwc1 $f4,0x4($s1)
|
|
/* 2cac4: 46065001 */ sub.s $f0,$f10,$f6
|
|
/* 2cac8: c7b20134 */ lwc1 $f18,0x134($sp)
|
|
/* 2cacc: c6280008 */ lwc1 $f8,0x8($s1)
|
|
/* 2cad0: 46048081 */ sub.s $f2,$f16,$f4
|
|
/* 2cad4: 46000282 */ mul.s $f10,$f0,$f0
|
|
/* 2cad8: 24190001 */ addiu $t9,$zero,0x1
|
|
/* 2cadc: 46089301 */ sub.s $f12,$f18,$f8
|
|
/* 2cae0: 46021182 */ mul.s $f6,$f2,$f2
|
|
/* 2cae4: c6d20000 */ lwc1 $f18,0x0($s6)
|
|
/* 2cae8: 460c6102 */ mul.s $f4,$f12,$f12
|
|
/* 2caec: 46065400 */ add.s $f16,$f10,$f6
|
|
/* 2caf0: 46048380 */ add.s $f14,$f16,$f4
|
|
/* 2caf4: 4612703c */ c.lt.s $f14,$f18
|
|
/* 2caf8: 00000000 */ nop
|
|
/* 2cafc: 45020018 */ bc1fl .L0002cb60
|
|
/* 2cb00: 8fa90150 */ lw $t1,0x150($sp)
|
|
/* 2cb04: afb90154 */ sw $t9,0x154($sp)
|
|
/* 2cb08: e6ce0000 */ swc1 $f14,0x0($s6)
|
|
/* 2cb0c: c7a8012c */ lwc1 $f8,0x12c($sp)
|
|
/* 2cb10: e6480000 */ swc1 $f8,0x0($s2)
|
|
/* 2cb14: c7aa0130 */ lwc1 $f10,0x130($sp)
|
|
/* 2cb18: e64a0004 */ swc1 $f10,0x4($s2)
|
|
/* 2cb1c: c7a60134 */ lwc1 $f6,0x134($sp)
|
|
/* 2cb20: e6460008 */ swc1 $f6,0x8($s2)
|
|
/* 2cb24: c7b00114 */ lwc1 $f16,0x114($sp)
|
|
/* 2cb28: e6900000 */ swc1 $f16,0x0($s4)
|
|
/* 2cb2c: c7a40118 */ lwc1 $f4,0x118($sp)
|
|
/* 2cb30: e6840004 */ swc1 $f4,0x4($s4)
|
|
/* 2cb34: c7b2011c */ lwc1 $f18,0x11c($sp)
|
|
/* 2cb38: e6920008 */ swc1 $f18,0x8($s4)
|
|
/* 2cb3c: c7a80108 */ lwc1 $f8,0x108($sp)
|
|
/* 2cb40: e6a80000 */ swc1 $f8,0x0($s5)
|
|
/* 2cb44: c7aa010c */ lwc1 $f10,0x10c($sp)
|
|
/* 2cb48: e6aa0004 */ swc1 $f10,0x4($s5)
|
|
/* 2cb4c: c7a60110 */ lwc1 $f6,0x110($sp)
|
|
/* 2cb50: e6a60008 */ swc1 $f6,0x8($s5)
|
|
/* 2cb54: 8fa801a8 */ lw $t0,0x1a8($sp)
|
|
/* 2cb58: ad100000 */ sw $s0,0x0($t0)
|
|
.L0002cb5c:
|
|
/* 2cb5c: 8fa90150 */ lw $t1,0x150($sp)
|
|
.L0002cb60:
|
|
/* 2cb60: 912a0001 */ lbu $t2,0x1($t1)
|
|
/* 2cb64: 000a5880 */ sll $t3,$t2,0x2
|
|
/* 2cb68: 016a5823 */ subu $t3,$t3,$t2
|
|
/* 2cb6c: 000b5840 */ sll $t3,$t3,0x1
|
|
/* 2cb70: 020b8021 */ addu $s0,$s0,$t3
|
|
/* 2cb74: 10000164 */ b .L0002d108
|
|
/* 2cb78: 2610000e */ addiu $s0,$s0,0xe
|
|
.L0002cb7c:
|
|
/* 2cb7c: 544100e1 */ bnel $v0,$at,.L0002cf04
|
|
/* 2cb80: 24010002 */ addiu $at,$zero,0x2
|
|
/* 2cb84: afb00104 */ sw $s0,0x104($sp)
|
|
/* 2cb88: 960c0002 */ lhu $t4,0x2($s0)
|
|
/* 2cb8c: 97ad0186 */ lhu $t5,0x186($sp)
|
|
/* 2cb90: 018d7024 */ and $t6,$t4,$t5
|
|
/* 2cb94: 51c000d3 */ beqzl $t6,.L0002cee4
|
|
/* 2cb98: 8fae0104 */ lw $t6,0x104($sp)
|
|
/* 2cb9c: 920f0006 */ lbu $t7,0x6($s0)
|
|
/* 2cba0: 01fe0019 */ multu $t7,$s8
|
|
/* 2cba4: 0000c012 */ mflo $t8
|
|
/* 2cba8: 0218c821 */ addu $t9,$s0,$t8
|
|
/* 2cbac: c7300010 */ lwc1 $f16,0x10($t9)
|
|
/* 2cbb0: e7b000f8 */ swc1 $f16,0xf8($sp)
|
|
/* 2cbb4: 92080009 */ lbu $t0,0x9($s0)
|
|
/* 2cbb8: c7aa00f8 */ lwc1 $f10,0xf8($sp)
|
|
/* 2cbbc: 011e0019 */ multu $t0,$s8
|
|
/* 2cbc0: 00004812 */ mflo $t1
|
|
/* 2cbc4: 02095021 */ addu $t2,$s0,$t1
|
|
/* 2cbc8: c5440010 */ lwc1 $f4,0x10($t2)
|
|
/* 2cbcc: e7a400ec */ swc1 $f4,0xec($sp)
|
|
/* 2cbd0: 920b0008 */ lbu $t3,0x8($s0)
|
|
/* 2cbd4: c7b000ec */ lwc1 $f16,0xec($sp)
|
|
/* 2cbd8: 017e0019 */ multu $t3,$s8
|
|
/* 2cbdc: 00006012 */ mflo $t4
|
|
/* 2cbe0: 020c6821 */ addu $t5,$s0,$t4
|
|
/* 2cbe4: c5b20018 */ lwc1 $f18,0x18($t5)
|
|
/* 2cbe8: e7b20100 */ swc1 $f18,0x100($sp)
|
|
/* 2cbec: 920e000b */ lbu $t6,0xb($s0)
|
|
/* 2cbf0: 01de0019 */ multu $t6,$s8
|
|
/* 2cbf4: 00007812 */ mflo $t7
|
|
/* 2cbf8: 020fc021 */ addu $t8,$s0,$t7
|
|
/* 2cbfc: c7080018 */ lwc1 $f8,0x18($t8)
|
|
/* 2cc00: e7a800f4 */ swc1 $f8,0xf4($sp)
|
|
/* 2cc04: c6200000 */ lwc1 $f0,0x0($s1)
|
|
/* 2cc08: 460a003c */ c.lt.s $f0,$f10
|
|
/* 2cc0c: 00000000 */ nop
|
|
/* 2cc10: 45020007 */ bc1fl .L0002cc30
|
|
/* 2cc14: 4600803c */ c.lt.s $f16,$f0
|
|
/* 2cc18: c6660000 */ lwc1 $f6,0x0($s3)
|
|
/* 2cc1c: 460a303c */ c.lt.s $f6,$f10
|
|
/* 2cc20: 00000000 */ nop
|
|
/* 2cc24: 450300af */ bc1tl .L0002cee4
|
|
/* 2cc28: 8fae0104 */ lw $t6,0x104($sp)
|
|
/* 2cc2c: 4600803c */ c.lt.s $f16,$f0
|
|
.L0002cc30:
|
|
/* 2cc30: c7b20100 */ lwc1 $f18,0x100($sp)
|
|
/* 2cc34: 45020007 */ bc1fl .L0002cc54
|
|
/* 2cc38: c6200008 */ lwc1 $f0,0x8($s1)
|
|
/* 2cc3c: c6640000 */ lwc1 $f4,0x0($s3)
|
|
/* 2cc40: 4604803c */ c.lt.s $f16,$f4
|
|
/* 2cc44: 00000000 */ nop
|
|
/* 2cc48: 450300a6 */ bc1tl .L0002cee4
|
|
/* 2cc4c: 8fae0104 */ lw $t6,0x104($sp)
|
|
/* 2cc50: c6200008 */ lwc1 $f0,0x8($s1)
|
|
.L0002cc54:
|
|
/* 2cc54: c7a600f4 */ lwc1 $f6,0xf4($sp)
|
|
/* 2cc58: 4612003c */ c.lt.s $f0,$f18
|
|
/* 2cc5c: 00000000 */ nop
|
|
/* 2cc60: 45020007 */ bc1fl .L0002cc80
|
|
/* 2cc64: 4600303c */ c.lt.s $f6,$f0
|
|
/* 2cc68: c6680008 */ lwc1 $f8,0x8($s3)
|
|
/* 2cc6c: 4612403c */ c.lt.s $f8,$f18
|
|
/* 2cc70: 00000000 */ nop
|
|
/* 2cc74: 4503009b */ bc1tl .L0002cee4
|
|
/* 2cc78: 8fae0104 */ lw $t6,0x104($sp)
|
|
/* 2cc7c: 4600303c */ c.lt.s $f6,$f0
|
|
.L0002cc80:
|
|
/* 2cc80: 8fb90188 */ lw $t9,0x188($sp)
|
|
/* 2cc84: 45000006 */ bc1f .L0002cca0
|
|
/* 2cc88: 00000000 */ nop
|
|
/* 2cc8c: c66a0008 */ lwc1 $f10,0x8($s3)
|
|
/* 2cc90: 460a303c */ c.lt.s $f6,$f10
|
|
/* 2cc94: 00000000 */ nop
|
|
/* 2cc98: 45030092 */ bc1tl .L0002cee4
|
|
/* 2cc9c: 8fae0104 */ lw $t6,0x104($sp)
|
|
.L0002cca0:
|
|
/* 2cca0: 13200056 */ beqz $t9,.L0002cdfc
|
|
/* 2cca4: 02202025 */ or $a0,$s1,$zero
|
|
/* 2cca8: 92080007 */ lbu $t0,0x7($s0)
|
|
/* 2ccac: 011e0019 */ multu $t0,$s8
|
|
/* 2ccb0: 00004812 */ mflo $t1
|
|
/* 2ccb4: 02095021 */ addu $t2,$s0,$t1
|
|
/* 2ccb8: c5500014 */ lwc1 $f16,0x14($t2)
|
|
/* 2ccbc: e7b000fc */ swc1 $f16,0xfc($sp)
|
|
/* 2ccc0: 920b000a */ lbu $t3,0xa($s0)
|
|
/* 2ccc4: c7a800fc */ lwc1 $f8,0xfc($sp)
|
|
/* 2ccc8: 017e0019 */ multu $t3,$s8
|
|
/* 2cccc: 00006012 */ mflo $t4
|
|
/* 2ccd0: 020c6821 */ addu $t5,$s0,$t4
|
|
/* 2ccd4: c5a40014 */ lwc1 $f4,0x14($t5)
|
|
/* 2ccd8: e7a400f0 */ swc1 $f4,0xf0($sp)
|
|
/* 2ccdc: c6200004 */ lwc1 $f0,0x4($s1)
|
|
/* 2cce0: c7a600f0 */ lwc1 $f6,0xf0($sp)
|
|
/* 2cce4: 4608003c */ c.lt.s $f0,$f8
|
|
/* 2cce8: 00000000 */ nop
|
|
/* 2ccec: 45020007 */ bc1fl .L0002cd0c
|
|
/* 2ccf0: 4600303c */ c.lt.s $f6,$f0
|
|
/* 2ccf4: c6720004 */ lwc1 $f18,0x4($s3)
|
|
/* 2ccf8: 4608903c */ c.lt.s $f18,$f8
|
|
/* 2ccfc: 00000000 */ nop
|
|
/* 2cd00: 45030078 */ bc1tl .L0002cee4
|
|
/* 2cd04: 8fae0104 */ lw $t6,0x104($sp)
|
|
/* 2cd08: 4600303c */ c.lt.s $f6,$f0
|
|
.L0002cd0c:
|
|
/* 2cd0c: 02202025 */ or $a0,$s1,$zero
|
|
/* 2cd10: 02e02825 */ or $a1,$s7,$zero
|
|
/* 2cd14: 27a600f8 */ addiu $a2,$sp,0xf8
|
|
/* 2cd18: 45000006 */ bc1f .L0002cd34
|
|
/* 2cd1c: 00000000 */ nop
|
|
/* 2cd20: c66a0004 */ lwc1 $f10,0x4($s3)
|
|
/* 2cd24: 460a303c */ c.lt.s $f6,$f10
|
|
/* 2cd28: 00000000 */ nop
|
|
/* 2cd2c: 4503006d */ bc1tl .L0002cee4
|
|
/* 2cd30: 8fae0104 */ lw $t6,0x104($sp)
|
|
.L0002cd34:
|
|
/* 2cd34: 0fc57cac */ jal bg0f15f2b0
|
|
/* 2cd38: 27a700ec */ addiu $a3,$sp,0xec
|
|
/* 2cd3c: 10400068 */ beqz $v0,.L0002cee0
|
|
/* 2cd40: 02202025 */ or $a0,$s1,$zero
|
|
/* 2cd44: 27ae00e0 */ addiu $t6,$sp,0xe0
|
|
/* 2cd48: 27af00d4 */ addiu $t7,$sp,0xd4
|
|
/* 2cd4c: afaf0014 */ sw $t7,0x14($sp)
|
|
/* 2cd50: afae0010 */ sw $t6,0x10($sp)
|
|
/* 2cd54: 02602825 */ or $a1,$s3,$zero
|
|
/* 2cd58: 02e03025 */ or $a2,$s7,$zero
|
|
/* 2cd5c: 0c00aae6 */ jal cd0002ab98
|
|
/* 2cd60: 02003825 */ or $a3,$s0,$zero
|
|
/* 2cd64: 1040005e */ beqz $v0,.L0002cee0
|
|
/* 2cd68: c7b000e0 */ lwc1 $f16,0xe0($sp)
|
|
/* 2cd6c: c6240000 */ lwc1 $f4,0x0($s1)
|
|
/* 2cd70: c7b200e4 */ lwc1 $f18,0xe4($sp)
|
|
/* 2cd74: c6280004 */ lwc1 $f8,0x4($s1)
|
|
/* 2cd78: 46048001 */ sub.s $f0,$f16,$f4
|
|
/* 2cd7c: c7a600e8 */ lwc1 $f6,0xe8($sp)
|
|
/* 2cd80: c62a0008 */ lwc1 $f10,0x8($s1)
|
|
/* 2cd84: 46089081 */ sub.s $f2,$f18,$f8
|
|
/* 2cd88: 46000402 */ mul.s $f16,$f0,$f0
|
|
/* 2cd8c: 24180001 */ addiu $t8,$zero,0x1
|
|
/* 2cd90: 460a3301 */ sub.s $f12,$f6,$f10
|
|
/* 2cd94: 46021102 */ mul.s $f4,$f2,$f2
|
|
/* 2cd98: c6c60000 */ lwc1 $f6,0x0($s6)
|
|
/* 2cd9c: 460c6202 */ mul.s $f8,$f12,$f12
|
|
/* 2cda0: 46048480 */ add.s $f18,$f16,$f4
|
|
/* 2cda4: 46089380 */ add.s $f14,$f18,$f8
|
|
/* 2cda8: 4606703c */ c.lt.s $f14,$f6
|
|
/* 2cdac: 00000000 */ nop
|
|
/* 2cdb0: 4502004c */ bc1fl .L0002cee4
|
|
/* 2cdb4: 8fae0104 */ lw $t6,0x104($sp)
|
|
/* 2cdb8: afb80154 */ sw $t8,0x154($sp)
|
|
/* 2cdbc: e6ce0000 */ swc1 $f14,0x0($s6)
|
|
/* 2cdc0: c7aa00e0 */ lwc1 $f10,0xe0($sp)
|
|
/* 2cdc4: 02002025 */ or $a0,$s0,$zero
|
|
/* 2cdc8: 27a500e0 */ addiu $a1,$sp,0xe0
|
|
/* 2cdcc: e64a0000 */ swc1 $f10,0x0($s2)
|
|
/* 2cdd0: c7b000e4 */ lwc1 $f16,0xe4($sp)
|
|
/* 2cdd4: 27a600d4 */ addiu $a2,$sp,0xd4
|
|
/* 2cdd8: 02803825 */ or $a3,$s4,$zero
|
|
/* 2cddc: e6500004 */ swc1 $f16,0x4($s2)
|
|
/* 2cde0: c7a400e8 */ lwc1 $f4,0xe8($sp)
|
|
/* 2cde4: e6440008 */ swc1 $f4,0x8($s2)
|
|
/* 2cde8: 0c00b14a */ jal cd0002c528
|
|
/* 2cdec: afb50010 */ sw $s5,0x10($sp)
|
|
/* 2cdf0: 8fb901a8 */ lw $t9,0x1a8($sp)
|
|
/* 2cdf4: 1000003a */ b .L0002cee0
|
|
/* 2cdf8: af300000 */ sw $s0,0x0($t9)
|
|
.L0002cdfc:
|
|
/* 2cdfc: 8fab018c */ lw $t3,0x18c($sp)
|
|
/* 2ce00: 27a800e0 */ addiu $t0,$sp,0xe0
|
|
/* 2ce04: 27a900c8 */ addiu $t1,$sp,0xc8
|
|
/* 2ce08: 27aa00bc */ addiu $t2,$sp,0xbc
|
|
/* 2ce0c: afaa0018 */ sw $t2,0x18($sp)
|
|
/* 2ce10: afa90014 */ sw $t1,0x14($sp)
|
|
/* 2ce14: afa80010 */ sw $t0,0x10($sp)
|
|
/* 2ce18: 02602825 */ or $a1,$s3,$zero
|
|
/* 2ce1c: 02e03025 */ or $a2,$s7,$zero
|
|
/* 2ce20: 02003825 */ or $a3,$s0,$zero
|
|
/* 2ce24: e7b60020 */ swc1 $f22,0x20($sp)
|
|
/* 2ce28: e7b40024 */ swc1 $f20,0x24($sp)
|
|
/* 2ce2c: 0c00ac4a */ jal cd0002b128
|
|
/* 2ce30: afab001c */ sw $t3,0x1c($sp)
|
|
/* 2ce34: 1040002a */ beqz $v0,.L0002cee0
|
|
/* 2ce38: c7b200e0 */ lwc1 $f18,0xe0($sp)
|
|
/* 2ce3c: c6280000 */ lwc1 $f8,0x0($s1)
|
|
/* 2ce40: c7a600e4 */ lwc1 $f6,0xe4($sp)
|
|
/* 2ce44: c62a0004 */ lwc1 $f10,0x4($s1)
|
|
/* 2ce48: 46089001 */ sub.s $f0,$f18,$f8
|
|
/* 2ce4c: c7b000e8 */ lwc1 $f16,0xe8($sp)
|
|
/* 2ce50: c6240008 */ lwc1 $f4,0x8($s1)
|
|
/* 2ce54: 460a3081 */ sub.s $f2,$f6,$f10
|
|
/* 2ce58: 46000482 */ mul.s $f18,$f0,$f0
|
|
/* 2ce5c: 240c0001 */ addiu $t4,$zero,0x1
|
|
/* 2ce60: 46048301 */ sub.s $f12,$f16,$f4
|
|
/* 2ce64: 46021202 */ mul.s $f8,$f2,$f2
|
|
/* 2ce68: c6d00000 */ lwc1 $f16,0x0($s6)
|
|
/* 2ce6c: 460c6282 */ mul.s $f10,$f12,$f12
|
|
/* 2ce70: 46089180 */ add.s $f6,$f18,$f8
|
|
/* 2ce74: 460a3380 */ add.s $f14,$f6,$f10
|
|
/* 2ce78: 4610703c */ c.lt.s $f14,$f16
|
|
/* 2ce7c: 00000000 */ nop
|
|
/* 2ce80: 45020018 */ bc1fl .L0002cee4
|
|
/* 2ce84: 8fae0104 */ lw $t6,0x104($sp)
|
|
/* 2ce88: afac0154 */ sw $t4,0x154($sp)
|
|
/* 2ce8c: e6ce0000 */ swc1 $f14,0x0($s6)
|
|
/* 2ce90: c7a400e0 */ lwc1 $f4,0xe0($sp)
|
|
/* 2ce94: e6440000 */ swc1 $f4,0x0($s2)
|
|
/* 2ce98: c7b200e4 */ lwc1 $f18,0xe4($sp)
|
|
/* 2ce9c: e6520004 */ swc1 $f18,0x4($s2)
|
|
/* 2cea0: c7a800e8 */ lwc1 $f8,0xe8($sp)
|
|
/* 2cea4: e6480008 */ swc1 $f8,0x8($s2)
|
|
/* 2cea8: c7a600c8 */ lwc1 $f6,0xc8($sp)
|
|
/* 2ceac: e6860000 */ swc1 $f6,0x0($s4)
|
|
/* 2ceb0: c7aa00cc */ lwc1 $f10,0xcc($sp)
|
|
/* 2ceb4: e68a0004 */ swc1 $f10,0x4($s4)
|
|
/* 2ceb8: c7b000d0 */ lwc1 $f16,0xd0($sp)
|
|
/* 2cebc: e6900008 */ swc1 $f16,0x8($s4)
|
|
/* 2cec0: c7a400bc */ lwc1 $f4,0xbc($sp)
|
|
/* 2cec4: e6a40000 */ swc1 $f4,0x0($s5)
|
|
/* 2cec8: c7b200c0 */ lwc1 $f18,0xc0($sp)
|
|
/* 2cecc: e6b20004 */ swc1 $f18,0x4($s5)
|
|
/* 2ced0: c7a800c4 */ lwc1 $f8,0xc4($sp)
|
|
/* 2ced4: e6a80008 */ swc1 $f8,0x8($s5)
|
|
/* 2ced8: 8fad01a8 */ lw $t5,0x1a8($sp)
|
|
/* 2cedc: adb00000 */ sw $s0,0x0($t5)
|
|
.L0002cee0:
|
|
/* 2cee0: 8fae0104 */ lw $t6,0x104($sp)
|
|
.L0002cee4:
|
|
/* 2cee4: 91cf0001 */ lbu $t7,0x1($t6)
|
|
/* 2cee8: 25f8ffc0 */ addiu $t8,$t7,-64
|
|
/* 2ceec: 031e0019 */ multu $t8,$s8
|
|
/* 2cef0: 0000c812 */ mflo $t9
|
|
/* 2cef4: 02198021 */ addu $s0,$s0,$t9
|
|
/* 2cef8: 10000083 */ b .L0002d108
|
|
/* 2cefc: 26100310 */ addiu $s0,$s0,0x310
|
|
/* 2cf00: 24010002 */ addiu $at,$zero,0x2
|
|
.L0002cf04:
|
|
/* 2cf04: 1441003f */ bne $v0,$at,.L0002d004
|
|
/* 2cf08: 97a80186 */ lhu $t0,0x186($sp)
|
|
/* 2cf0c: 3109001c */ andi $t1,$t0,0x1c
|
|
/* 2cf10: 1120003a */ beqz $t1,.L0002cffc
|
|
/* 2cf14: 02202025 */ or $a0,$s1,$zero
|
|
/* 2cf18: 8fad018c */ lw $t5,0x18c($sp)
|
|
/* 2cf1c: 27aa00b0 */ addiu $t2,$sp,0xb0
|
|
/* 2cf20: 27ab00a4 */ addiu $t3,$sp,0xa4
|
|
/* 2cf24: 27ac0098 */ addiu $t4,$sp,0x98
|
|
/* 2cf28: afac0018 */ sw $t4,0x18($sp)
|
|
/* 2cf2c: afab0014 */ sw $t3,0x14($sp)
|
|
/* 2cf30: afaa0010 */ sw $t2,0x10($sp)
|
|
/* 2cf34: 02602825 */ or $a1,$s3,$zero
|
|
/* 2cf38: 02e03025 */ or $a2,$s7,$zero
|
|
/* 2cf3c: 02003825 */ or $a3,$s0,$zero
|
|
/* 2cf40: e7b60020 */ swc1 $f22,0x20($sp)
|
|
/* 2cf44: e7b40024 */ swc1 $f20,0x24($sp)
|
|
/* 2cf48: 0c00ad58 */ jal cd0002b560
|
|
/* 2cf4c: afad001c */ sw $t5,0x1c($sp)
|
|
/* 2cf50: 1040002a */ beqz $v0,.L0002cffc
|
|
/* 2cf54: c7a600b0 */ lwc1 $f6,0xb0($sp)
|
|
/* 2cf58: c62a0000 */ lwc1 $f10,0x0($s1)
|
|
/* 2cf5c: c7b000b4 */ lwc1 $f16,0xb4($sp)
|
|
/* 2cf60: c6240004 */ lwc1 $f4,0x4($s1)
|
|
/* 2cf64: 460a3001 */ sub.s $f0,$f6,$f10
|
|
/* 2cf68: c7b200b8 */ lwc1 $f18,0xb8($sp)
|
|
/* 2cf6c: c6280008 */ lwc1 $f8,0x8($s1)
|
|
/* 2cf70: 46048081 */ sub.s $f2,$f16,$f4
|
|
/* 2cf74: 46000182 */ mul.s $f6,$f0,$f0
|
|
/* 2cf78: 240e0001 */ addiu $t6,$zero,0x1
|
|
/* 2cf7c: 46089301 */ sub.s $f12,$f18,$f8
|
|
/* 2cf80: 46021282 */ mul.s $f10,$f2,$f2
|
|
/* 2cf84: c6d20000 */ lwc1 $f18,0x0($s6)
|
|
/* 2cf88: 460c6102 */ mul.s $f4,$f12,$f12
|
|
/* 2cf8c: 460a3400 */ add.s $f16,$f6,$f10
|
|
/* 2cf90: 46048380 */ add.s $f14,$f16,$f4
|
|
/* 2cf94: 4612703c */ c.lt.s $f14,$f18
|
|
/* 2cf98: 00000000 */ nop
|
|
/* 2cf9c: 45000017 */ bc1f .L0002cffc
|
|
/* 2cfa0: 00000000 */ nop
|
|
/* 2cfa4: afae0154 */ sw $t6,0x154($sp)
|
|
/* 2cfa8: e6ce0000 */ swc1 $f14,0x0($s6)
|
|
/* 2cfac: c7a800b0 */ lwc1 $f8,0xb0($sp)
|
|
/* 2cfb0: e6480000 */ swc1 $f8,0x0($s2)
|
|
/* 2cfb4: c7a600b4 */ lwc1 $f6,0xb4($sp)
|
|
/* 2cfb8: e6460004 */ swc1 $f6,0x4($s2)
|
|
/* 2cfbc: c7aa00b8 */ lwc1 $f10,0xb8($sp)
|
|
/* 2cfc0: e64a0008 */ swc1 $f10,0x8($s2)
|
|
/* 2cfc4: c7b000a4 */ lwc1 $f16,0xa4($sp)
|
|
/* 2cfc8: e6900000 */ swc1 $f16,0x0($s4)
|
|
/* 2cfcc: c7a400a8 */ lwc1 $f4,0xa8($sp)
|
|
/* 2cfd0: e6840004 */ swc1 $f4,0x4($s4)
|
|
/* 2cfd4: c7b200ac */ lwc1 $f18,0xac($sp)
|
|
/* 2cfd8: e6920008 */ swc1 $f18,0x8($s4)
|
|
/* 2cfdc: c7a80098 */ lwc1 $f8,0x98($sp)
|
|
/* 2cfe0: e6a80000 */ swc1 $f8,0x0($s5)
|
|
/* 2cfe4: c7a6009c */ lwc1 $f6,0x9c($sp)
|
|
/* 2cfe8: e6a60004 */ swc1 $f6,0x4($s5)
|
|
/* 2cfec: c7aa00a0 */ lwc1 $f10,0xa0($sp)
|
|
/* 2cff0: e6aa0008 */ swc1 $f10,0x8($s5)
|
|
/* 2cff4: 8faf01a8 */ lw $t7,0x1a8($sp)
|
|
/* 2cff8: adf00000 */ sw $s0,0x0($t7)
|
|
.L0002cffc:
|
|
/* 2cffc: 10000042 */ b .L0002d108
|
|
/* 2d000: 2610004c */ addiu $s0,$s0,0x4c
|
|
.L0002d004:
|
|
/* 2d004: 24010003 */ addiu $at,$zero,0x3
|
|
/* 2d008: 1441003f */ bne $v0,$at,.L0002d108
|
|
/* 2d00c: 97b80186 */ lhu $t8,0x186($sp)
|
|
/* 2d010: 96190002 */ lhu $t9,0x2($s0)
|
|
/* 2d014: 02202025 */ or $a0,$s1,$zero
|
|
/* 2d018: 02602825 */ or $a1,$s3,$zero
|
|
/* 2d01c: 03194024 */ and $t0,$t8,$t9
|
|
/* 2d020: 11000038 */ beqz $t0,.L0002d104
|
|
/* 2d024: 02e03025 */ or $a2,$s7,$zero
|
|
/* 2d028: 8fac018c */ lw $t4,0x18c($sp)
|
|
/* 2d02c: 27a90088 */ addiu $t1,$sp,0x88
|
|
/* 2d030: 27aa007c */ addiu $t2,$sp,0x7c
|
|
/* 2d034: 27ab0070 */ addiu $t3,$sp,0x70
|
|
/* 2d038: afab0018 */ sw $t3,0x18($sp)
|
|
/* 2d03c: afaa0014 */ sw $t2,0x14($sp)
|
|
/* 2d040: afa90010 */ sw $t1,0x10($sp)
|
|
/* 2d044: 02003825 */ or $a3,$s0,$zero
|
|
/* 2d048: e7b60020 */ swc1 $f22,0x20($sp)
|
|
/* 2d04c: e7b40024 */ swc1 $f20,0x24($sp)
|
|
/* 2d050: 0c00ae55 */ jal cd0002b954
|
|
/* 2d054: afac001c */ sw $t4,0x1c($sp)
|
|
/* 2d058: 1040002a */ beqz $v0,.L0002d104
|
|
/* 2d05c: c7b00088 */ lwc1 $f16,0x88($sp)
|
|
/* 2d060: c6240000 */ lwc1 $f4,0x0($s1)
|
|
/* 2d064: c7b2008c */ lwc1 $f18,0x8c($sp)
|
|
/* 2d068: c6280004 */ lwc1 $f8,0x4($s1)
|
|
/* 2d06c: 46048001 */ sub.s $f0,$f16,$f4
|
|
/* 2d070: c7a60090 */ lwc1 $f6,0x90($sp)
|
|
/* 2d074: c62a0008 */ lwc1 $f10,0x8($s1)
|
|
/* 2d078: 46089081 */ sub.s $f2,$f18,$f8
|
|
/* 2d07c: 46000402 */ mul.s $f16,$f0,$f0
|
|
/* 2d080: 240d0001 */ addiu $t5,$zero,0x1
|
|
/* 2d084: 460a3301 */ sub.s $f12,$f6,$f10
|
|
/* 2d088: 46021102 */ mul.s $f4,$f2,$f2
|
|
/* 2d08c: c6c60000 */ lwc1 $f6,0x0($s6)
|
|
/* 2d090: 460c6202 */ mul.s $f8,$f12,$f12
|
|
/* 2d094: 46048480 */ add.s $f18,$f16,$f4
|
|
/* 2d098: 46089380 */ add.s $f14,$f18,$f8
|
|
/* 2d09c: 4606703c */ c.lt.s $f14,$f6
|
|
/* 2d0a0: 00000000 */ nop
|
|
/* 2d0a4: 45020018 */ bc1fl .L0002d108
|
|
/* 2d0a8: 26100018 */ addiu $s0,$s0,0x18
|
|
/* 2d0ac: afad0154 */ sw $t5,0x154($sp)
|
|
/* 2d0b0: e6ce0000 */ swc1 $f14,0x0($s6)
|
|
/* 2d0b4: c7aa0088 */ lwc1 $f10,0x88($sp)
|
|
/* 2d0b8: e64a0000 */ swc1 $f10,0x0($s2)
|
|
/* 2d0bc: c7b0008c */ lwc1 $f16,0x8c($sp)
|
|
/* 2d0c0: e6500004 */ swc1 $f16,0x4($s2)
|
|
/* 2d0c4: c7a40090 */ lwc1 $f4,0x90($sp)
|
|
/* 2d0c8: e6440008 */ swc1 $f4,0x8($s2)
|
|
/* 2d0cc: c7b2007c */ lwc1 $f18,0x7c($sp)
|
|
/* 2d0d0: e6920000 */ swc1 $f18,0x0($s4)
|
|
/* 2d0d4: c7a80080 */ lwc1 $f8,0x80($sp)
|
|
/* 2d0d8: e6880004 */ swc1 $f8,0x4($s4)
|
|
/* 2d0dc: c7a60084 */ lwc1 $f6,0x84($sp)
|
|
/* 2d0e0: e6860008 */ swc1 $f6,0x8($s4)
|
|
/* 2d0e4: c7aa0070 */ lwc1 $f10,0x70($sp)
|
|
/* 2d0e8: e6aa0000 */ swc1 $f10,0x0($s5)
|
|
/* 2d0ec: c7b00074 */ lwc1 $f16,0x74($sp)
|
|
/* 2d0f0: e6b00004 */ swc1 $f16,0x4($s5)
|
|
/* 2d0f4: c7a40078 */ lwc1 $f4,0x78($sp)
|
|
/* 2d0f8: e6a40008 */ swc1 $f4,0x8($s5)
|
|
/* 2d0fc: 8fae01a8 */ lw $t6,0x1a8($sp)
|
|
/* 2d100: add00000 */ sw $s0,0x0($t6)
|
|
.L0002d104:
|
|
/* 2d104: 26100018 */ addiu $s0,$s0,0x18
|
|
.L0002d108:
|
|
/* 2d108: 8faf0174 */ lw $t7,0x174($sp)
|
|
/* 2d10c: 020f082b */ sltu $at,$s0,$t7
|
|
/* 2d110: 5420fd9d */ bnezl $at,.L0002c788
|
|
/* 2d114: 92020000 */ lbu $v0,0x0($s0)
|
|
.L0002d118:
|
|
/* 2d118: 8fa20154 */ lw $v0,0x154($sp)
|
|
/* 2d11c: 8fbf0064 */ lw $ra,0x64($sp)
|
|
/* 2d120: d7b40030 */ ldc1 $f20,0x30($sp)
|
|
/* 2d124: d7b60038 */ ldc1 $f22,0x38($sp)
|
|
/* 2d128: 8fb00040 */ lw $s0,0x40($sp)
|
|
/* 2d12c: 8fb10044 */ lw $s1,0x44($sp)
|
|
/* 2d130: 8fb20048 */ lw $s2,0x48($sp)
|
|
/* 2d134: 8fb3004c */ lw $s3,0x4c($sp)
|
|
/* 2d138: 8fb40050 */ lw $s4,0x50($sp)
|
|
/* 2d13c: 8fb50054 */ lw $s5,0x54($sp)
|
|
/* 2d140: 8fb60058 */ lw $s6,0x58($sp)
|
|
/* 2d144: 8fb7005c */ lw $s7,0x5c($sp)
|
|
/* 2d148: 8fbe0060 */ lw $s8,0x60($sp)
|
|
/* 2d14c: 2c580001 */ sltiu $t8,$v0,0x1
|
|
/* 2d150: 03001025 */ or $v0,$t8,$zero
|
|
/* 2d154: 03e00008 */ jr $ra
|
|
/* 2d158: 27bd0170 */ addiu $sp,$sp,0x170
|
|
);
|
|
|
|
bool cd0002d15c(struct coord *pos, struct coord *coord2, s16 *rooms, u32 types, u16 arg4, s32 arg5, s32 arg6, f32 arg7, f32 arg8)
|
|
{
|
|
s32 roomnum;
|
|
s16 *roomptr;
|
|
u8 *start;
|
|
u8 *end;
|
|
struct coord sp27c;
|
|
s16 *propnumptr;
|
|
s16 propnums[256];
|
|
|
|
sp27c.x = coord2->x - pos->x;
|
|
sp27c.y = coord2->y - pos->y;
|
|
sp27c.z = coord2->z - pos->z;
|
|
|
|
if (types & CDTYPE_BG) {
|
|
roomptr = rooms;
|
|
roomnum = rooms[0];
|
|
|
|
while (roomnum != -1) {
|
|
if (roomnum < g_TileNumRooms) {
|
|
start = g_TileFileData.u8 + g_TileRooms[roomnum];
|
|
end = g_TileFileData.u8 + g_TileRooms[roomnum + 1];
|
|
|
|
if (cd0002bd04(start, end, pos, coord2, &sp27c, arg4, arg5, arg6, arg7, arg8) == 0) {
|
|
cd00025168(NULL);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
roomptr++;
|
|
roomnum = *roomptr;
|
|
}
|
|
}
|
|
|
|
roomGetProps(rooms, propnums, 256);
|
|
|
|
propnumptr = propnums;
|
|
|
|
while (*propnumptr >= 0) {
|
|
struct prop *prop = &g_Vars.props[*propnumptr];
|
|
|
|
if (propIsOfCdType(prop, types)
|
|
&& propUpdateGeometry(prop, &start, &end)
|
|
&& cd0002bd04(start, end, pos, coord2, &sp27c, arg4, arg5, arg6, arg7, arg8) == 0) {
|
|
cd00025168(prop);
|
|
return false;
|
|
}
|
|
|
|
propnumptr++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
GLOBAL_ASM(
|
|
glabel cd0002d3b0
|
|
/* 2d3b0: 27bdfd20 */ addiu $sp,$sp,-736
|
|
/* 2d3b4: 3c014f80 */ lui $at,0x4f80
|
|
/* 2d3b8: 44812000 */ mtc1 $at,$f4
|
|
/* 2d3bc: afbf007c */ sw $ra,0x7c($sp)
|
|
/* 2d3c0: afbe0078 */ sw $s8,0x78($sp)
|
|
/* 2d3c4: afb70074 */ sw $s7,0x74($sp)
|
|
/* 2d3c8: afb60070 */ sw $s6,0x70($sp)
|
|
/* 2d3cc: afb5006c */ sw $s5,0x6c($sp)
|
|
/* 2d3d0: afb40068 */ sw $s4,0x68($sp)
|
|
/* 2d3d4: afb30064 */ sw $s3,0x64($sp)
|
|
/* 2d3d8: afb20060 */ sw $s2,0x60($sp)
|
|
/* 2d3dc: afb1005c */ sw $s1,0x5c($sp)
|
|
/* 2d3e0: afb00058 */ sw $s0,0x58($sp)
|
|
/* 2d3e4: f7b60050 */ sdc1 $f22,0x50($sp)
|
|
/* 2d3e8: f7b40048 */ sdc1 $f20,0x48($sp)
|
|
/* 2d3ec: afa402e0 */ sw $a0,0x2e0($sp)
|
|
/* 2d3f0: afa502e4 */ sw $a1,0x2e4($sp)
|
|
/* 2d3f4: afa702ec */ sw $a3,0x2ec($sp)
|
|
/* 2d3f8: afa002c0 */ sw $zero,0x2c0($sp)
|
|
/* 2d3fc: e7a40298 */ swc1 $f4,0x298($sp)
|
|
/* 2d400: c4880000 */ lwc1 $f8,0x0($a0)
|
|
/* 2d404: c4a60000 */ lwc1 $f6,0x0($a1)
|
|
/* 2d408: 30f90020 */ andi $t9,$a3,0x20
|
|
/* 2d40c: 00c0f025 */ or $s8,$a2,$zero
|
|
/* 2d410: 46083281 */ sub.s $f10,$f6,$f8
|
|
/* 2d414: e7aa02c4 */ swc1 $f10,0x2c4($sp)
|
|
/* 2d418: c4920004 */ lwc1 $f18,0x4($a0)
|
|
/* 2d41c: c4b00004 */ lwc1 $f16,0x4($a1)
|
|
/* 2d420: 46128101 */ sub.s $f4,$f16,$f18
|
|
/* 2d424: e7a402c8 */ swc1 $f4,0x2c8($sp)
|
|
/* 2d428: c4880008 */ lwc1 $f8,0x8($a0)
|
|
/* 2d42c: c4a60008 */ lwc1 $f6,0x8($a1)
|
|
/* 2d430: 46083281 */ sub.s $f10,$f6,$f8
|
|
/* 2d434: 13200043 */ beqz $t9,.L0002d544
|
|
/* 2d438: e7aa02cc */ swc1 $f10,0x2cc($sp)
|
|
/* 2d43c: 84c80000 */ lh $t0,0x0($a2)
|
|
/* 2d440: 2411ffff */ addiu $s1,$zero,-1
|
|
/* 2d444: 00c08025 */ or $s0,$a2,$zero
|
|
/* 2d448: 1111003e */ beq $t0,$s1,.L0002d544
|
|
/* 2d44c: c7b60300 */ lwc1 $f22,0x300($sp)
|
|
/* 2d450: 3c17800a */ lui $s7,%hi(g_TileFileData)
|
|
/* 2d454: 3c16800a */ lui $s6,%hi(g_TileRooms)
|
|
/* 2d458: 3c15800a */ lui $s5,%hi(g_TileNumRooms)
|
|
/* 2d45c: 26b5a8a4 */ addiu $s5,$s5,%lo(g_TileNumRooms)
|
|
/* 2d460: 26d6a8a8 */ addiu $s6,$s6,%lo(g_TileRooms)
|
|
/* 2d464: 26f7a8a0 */ addiu $s7,$s7,%lo(g_TileFileData)
|
|
/* 2d468: c7b402fc */ lwc1 $f20,0x2fc($sp)
|
|
/* 2d46c: 27b4029c */ addiu $s4,$sp,0x29c
|
|
/* 2d470: 27b302a8 */ addiu $s3,$sp,0x2a8
|
|
/* 2d474: 27b202b4 */ addiu $s2,$sp,0x2b4
|
|
/* 2d478: 8ea90000 */ lw $t1,0x0($s5)
|
|
.L0002d47c:
|
|
/* 2d47c: 00085080 */ sll $t2,$t0,0x2
|
|
/* 2d480: 27b802c4 */ addiu $t8,$sp,0x2c4
|
|
/* 2d484: 0109082a */ slt $at,$t0,$t1
|
|
/* 2d488: 5020002b */ beqzl $at,.L0002d538
|
|
/* 2d48c: 86080002 */ lh $t0,0x2($s0)
|
|
/* 2d490: 8ecb0000 */ lw $t3,0x0($s6)
|
|
/* 2d494: 8ee30000 */ lw $v1,0x0($s7)
|
|
/* 2d498: 97b902f2 */ lhu $t9,0x2f2($sp)
|
|
/* 2d49c: 014b1021 */ addu $v0,$t2,$t3
|
|
/* 2d4a0: 8c4c0000 */ lw $t4,0x0($v0)
|
|
/* 2d4a4: 8faa02f8 */ lw $t2,0x2f8($sp)
|
|
/* 2d4a8: 8fa902f4 */ lw $t1,0x2f4($sp)
|
|
/* 2d4ac: 01832021 */ addu $a0,$t4,$v1
|
|
/* 2d4b0: afa402d4 */ sw $a0,0x2d4($sp)
|
|
/* 2d4b4: 8c4e0004 */ lw $t6,0x4($v0)
|
|
/* 2d4b8: 27ac0294 */ addiu $t4,$sp,0x294
|
|
/* 2d4bc: 27ab0298 */ addiu $t3,$sp,0x298
|
|
/* 2d4c0: 01c32821 */ addu $a1,$t6,$v1
|
|
/* 2d4c4: afa502d0 */ sw $a1,0x2d0($sp)
|
|
/* 2d4c8: afab0028 */ sw $t3,0x28($sp)
|
|
/* 2d4cc: afac0038 */ sw $t4,0x38($sp)
|
|
/* 2d4d0: afa8003c */ sw $t0,0x3c($sp)
|
|
/* 2d4d4: afb40034 */ sw $s4,0x34($sp)
|
|
/* 2d4d8: afb30030 */ sw $s3,0x30($sp)
|
|
/* 2d4dc: afb2002c */ sw $s2,0x2c($sp)
|
|
/* 2d4e0: e7b60024 */ swc1 $f22,0x24($sp)
|
|
/* 2d4e4: e7b40020 */ swc1 $f20,0x20($sp)
|
|
/* 2d4e8: afb80010 */ sw $t8,0x10($sp)
|
|
/* 2d4ec: 8fa602e0 */ lw $a2,0x2e0($sp)
|
|
/* 2d4f0: 8fa702e4 */ lw $a3,0x2e4($sp)
|
|
/* 2d4f4: afb90014 */ sw $t9,0x14($sp)
|
|
/* 2d4f8: afaa001c */ sw $t2,0x1c($sp)
|
|
/* 2d4fc: 0c00b1c5 */ jal cd0002c714
|
|
/* 2d500: afa90018 */ sw $t1,0x18($sp)
|
|
/* 2d504: 1440000b */ bnez $v0,.L0002d534
|
|
/* 2d508: 240d0001 */ addiu $t5,$zero,0x1
|
|
/* 2d50c: c7b00298 */ lwc1 $f16,0x298($sp)
|
|
/* 2d510: 8fae0294 */ lw $t6,0x294($sp)
|
|
/* 2d514: afad02c0 */ sw $t5,0x2c0($sp)
|
|
/* 2d518: 02602025 */ or $a0,$s3,$zero
|
|
/* 2d51c: 02802825 */ or $a1,$s4,$zero
|
|
/* 2d520: 02403025 */ or $a2,$s2,$zero
|
|
/* 2d524: 00003825 */ or $a3,$zero,$zero
|
|
/* 2d528: e7b00010 */ swc1 $f16,0x10($sp)
|
|
/* 2d52c: 0c009495 */ jal cd00025254
|
|
/* 2d530: afae0014 */ sw $t6,0x14($sp)
|
|
.L0002d534:
|
|
/* 2d534: 86080002 */ lh $t0,0x2($s0)
|
|
.L0002d538:
|
|
/* 2d538: 26100002 */ addiu $s0,$s0,0x2
|
|
/* 2d53c: 5511ffcf */ bnel $t0,$s1,.L0002d47c
|
|
/* 2d540: 8ea90000 */ lw $t1,0x0($s5)
|
|
.L0002d544:
|
|
/* 2d544: 27b00090 */ addiu $s0,$sp,0x90
|
|
/* 2d548: 27b202b4 */ addiu $s2,$sp,0x2b4
|
|
/* 2d54c: 27b302a8 */ addiu $s3,$sp,0x2a8
|
|
/* 2d550: 27b4029c */ addiu $s4,$sp,0x29c
|
|
/* 2d554: c7b402fc */ lwc1 $f20,0x2fc($sp)
|
|
/* 2d558: c7b60300 */ lwc1 $f22,0x300($sp)
|
|
/* 2d55c: 02002825 */ or $a1,$s0,$zero
|
|
/* 2d560: 03c02025 */ or $a0,$s8,$zero
|
|
/* 2d564: 0fc197e0 */ jal roomGetProps
|
|
/* 2d568: 24060100 */ addiu $a2,$zero,0x100
|
|
/* 2d56c: 87af0090 */ lh $t7,0x90($sp)
|
|
/* 2d570: 02008825 */ or $s1,$s0,$zero
|
|
/* 2d574: 27b80090 */ addiu $t8,$sp,0x90
|
|
/* 2d578: 05e0003b */ bltz $t7,.L0002d668
|
|
/* 2d57c: 27be02d0 */ addiu $s8,$sp,0x2d0
|
|
/* 2d580: 3c16800a */ lui $s6,%hi(g_Vars)
|
|
/* 2d584: 26d69fc0 */ addiu $s6,$s6,%lo(g_Vars)
|
|
/* 2d588: 87020000 */ lh $v0,0x0($t8)
|
|
/* 2d58c: 27b702d4 */ addiu $s7,$sp,0x2d4
|
|
/* 2d590: 24150048 */ addiu $s5,$zero,0x48
|
|
.L0002d594:
|
|
/* 2d594: 00550019 */ multu $v0,$s5
|
|
/* 2d598: 8ec90338 */ lw $t1,0x338($s6)
|
|
/* 2d59c: 8fa502ec */ lw $a1,0x2ec($sp)
|
|
/* 2d5a0: 0000c812 */ mflo $t9
|
|
/* 2d5a4: 03298021 */ addu $s0,$t9,$t1
|
|
/* 2d5a8: 0fc19553 */ jal propIsOfCdType
|
|
/* 2d5ac: 02002025 */ or $a0,$s0,$zero
|
|
/* 2d5b0: 10400029 */ beqz $v0,.L0002d658
|
|
/* 2d5b4: 02002025 */ or $a0,$s0,$zero
|
|
/* 2d5b8: 02e02825 */ or $a1,$s7,$zero
|
|
/* 2d5bc: 0fc198a4 */ jal propUpdateGeometry
|
|
/* 2d5c0: 03c03025 */ or $a2,$s8,$zero
|
|
/* 2d5c4: 10400024 */ beqz $v0,.L0002d658
|
|
/* 2d5c8: 8fa402d4 */ lw $a0,0x2d4($sp)
|
|
/* 2d5cc: 97ab02f2 */ lhu $t3,0x2f2($sp)
|
|
/* 2d5d0: 8fac02f4 */ lw $t4,0x2f4($sp)
|
|
/* 2d5d4: 8fad02f8 */ lw $t5,0x2f8($sp)
|
|
/* 2d5d8: 27aa02c4 */ addiu $t2,$sp,0x2c4
|
|
/* 2d5dc: 27ae0298 */ addiu $t6,$sp,0x298
|
|
/* 2d5e0: 27af0294 */ addiu $t7,$sp,0x294
|
|
/* 2d5e4: 2418fc19 */ addiu $t8,$zero,-999
|
|
/* 2d5e8: afb8003c */ sw $t8,0x3c($sp)
|
|
/* 2d5ec: afaf0038 */ sw $t7,0x38($sp)
|
|
/* 2d5f0: afae0028 */ sw $t6,0x28($sp)
|
|
/* 2d5f4: afaa0010 */ sw $t2,0x10($sp)
|
|
/* 2d5f8: 8fa502d0 */ lw $a1,0x2d0($sp)
|
|
/* 2d5fc: 8fa602e0 */ lw $a2,0x2e0($sp)
|
|
/* 2d600: 8fa702e4 */ lw $a3,0x2e4($sp)
|
|
/* 2d604: e7b40020 */ swc1 $f20,0x20($sp)
|
|
/* 2d608: e7b60024 */ swc1 $f22,0x24($sp)
|
|
/* 2d60c: afb2002c */ sw $s2,0x2c($sp)
|
|
/* 2d610: afb30030 */ sw $s3,0x30($sp)
|
|
/* 2d614: afb40034 */ sw $s4,0x34($sp)
|
|
/* 2d618: afab0014 */ sw $t3,0x14($sp)
|
|
/* 2d61c: afac0018 */ sw $t4,0x18($sp)
|
|
/* 2d620: 0c00b1c5 */ jal cd0002c714
|
|
/* 2d624: afad001c */ sw $t5,0x1c($sp)
|
|
/* 2d628: 1440000b */ bnez $v0,.L0002d658
|
|
/* 2d62c: 24190001 */ addiu $t9,$zero,0x1
|
|
/* 2d630: c7b20298 */ lwc1 $f18,0x298($sp)
|
|
/* 2d634: 8fa90294 */ lw $t1,0x294($sp)
|
|
/* 2d638: afb902c0 */ sw $t9,0x2c0($sp)
|
|
/* 2d63c: 02602025 */ or $a0,$s3,$zero
|
|
/* 2d640: 02802825 */ or $a1,$s4,$zero
|
|
/* 2d644: 02403025 */ or $a2,$s2,$zero
|
|
/* 2d648: 02003825 */ or $a3,$s0,$zero
|
|
/* 2d64c: e7b20010 */ swc1 $f18,0x10($sp)
|
|
/* 2d650: 0c009495 */ jal cd00025254
|
|
/* 2d654: afa90014 */ sw $t1,0x14($sp)
|
|
.L0002d658:
|
|
/* 2d658: 86220002 */ lh $v0,0x2($s1)
|
|
/* 2d65c: 26310002 */ addiu $s1,$s1,0x2
|
|
/* 2d660: 0441ffcc */ bgez $v0,.L0002d594
|
|
/* 2d664: 00000000 */ nop
|
|
.L0002d668:
|
|
/* 2d668: 8fa202c0 */ lw $v0,0x2c0($sp)
|
|
/* 2d66c: 8fbf007c */ lw $ra,0x7c($sp)
|
|
/* 2d670: d7b40048 */ ldc1 $f20,0x48($sp)
|
|
/* 2d674: d7b60050 */ ldc1 $f22,0x50($sp)
|
|
/* 2d678: 8fb00058 */ lw $s0,0x58($sp)
|
|
/* 2d67c: 8fb1005c */ lw $s1,0x5c($sp)
|
|
/* 2d680: 8fb20060 */ lw $s2,0x60($sp)
|
|
/* 2d684: 8fb30064 */ lw $s3,0x64($sp)
|
|
/* 2d688: 8fb40068 */ lw $s4,0x68($sp)
|
|
/* 2d68c: 8fb5006c */ lw $s5,0x6c($sp)
|
|
/* 2d690: 8fb60070 */ lw $s6,0x70($sp)
|
|
/* 2d694: 8fb70074 */ lw $s7,0x74($sp)
|
|
/* 2d698: 8fbe0078 */ lw $s8,0x78($sp)
|
|
/* 2d69c: 2c4a0001 */ sltiu $t2,$v0,0x1
|
|
/* 2d6a0: 01401025 */ or $v0,$t2,$zero
|
|
/* 2d6a4: 03e00008 */ jr $ra
|
|
/* 2d6a8: 27bd02e0 */ addiu $sp,$sp,0x2e0
|
|
);
|
|
|
|
// Mismatch: Calculation of g_TileRooms[roomnum] is different
|
|
// Other functions and the below use t3 as the offset, t2 as the base, then t2 + t3
|
|
// But goal for this function uses t2 as the offset, t3 as the base, then t2 + t3
|
|
//s32 cd0002d3b0(struct coord *arg0, struct coord *arg1, s16 *rooms, s32 types, u16 arg4, s32 arg5, s32 arg6, f32 ymax, f32 ymin)
|
|
//{
|
|
// s32 roomnum;
|
|
// s16 *roomptr;
|
|
// u8 *start;
|
|
// u8 *end;
|
|
// struct coord sp2c4;
|
|
// bool sp2c0 = false;
|
|
// u32 sp2b4[3];
|
|
// struct coord sp2a8;
|
|
// struct coord sp29c;
|
|
// f32 sp298 = 4294967296;
|
|
// struct geo *sp294;
|
|
// s16 *propnumptr;
|
|
// s16 propnums[256];
|
|
//
|
|
// sp2c4.x = arg1->x - arg0->x;
|
|
// sp2c4.y = arg1->y - arg0->y;
|
|
// sp2c4.z = arg1->z - arg0->z;
|
|
//
|
|
// if (types & CDTYPE_BG) {
|
|
// roomptr = rooms;
|
|
// roomnum = rooms[0];
|
|
//
|
|
// while (roomnum != -1) {
|
|
// if (roomnum < g_TileNumRooms) {
|
|
// start = g_TileFileData.u8 + g_TileRooms[roomnum];
|
|
// end = g_TileFileData.u8 + g_TileRooms[roomnum + 1];
|
|
//
|
|
// if (!cd0002c714(start, end, arg0, arg1, &sp2c4, arg4, arg5, arg6, ymax, ymin, &sp298, sp2b4, &sp2a8, &sp29c, &sp294, roomnum)) {
|
|
// sp2c0 = true;
|
|
// cd00025254(&sp2a8, &sp29c, sp2b4, NULL, sp298, sp294);
|
|
// }
|
|
// }
|
|
//
|
|
// roomptr++;
|
|
// roomnum = *roomptr;
|
|
// }
|
|
// }
|
|
//
|
|
// roomGetProps(rooms, propnums, 256);
|
|
// propnumptr = propnums;
|
|
//
|
|
// while (*propnumptr >= 0) {
|
|
// struct prop *prop = &g_Vars.props[*propnumptr];
|
|
//
|
|
// if (propIsOfCdType(prop, types)
|
|
// && propUpdateGeometry(prop, &start, &end)
|
|
// && !cd0002c714(start, end, arg0, arg1, &sp2c4, arg4, arg5, arg6, ymax, ymin, &sp298, sp2b4, &sp2a8, &sp29c, &sp294, -999)) {
|
|
// sp2c0 = true;
|
|
// cd00025254(&sp2a8, &sp29c, sp2b4, prop, sp298, sp294);
|
|
// }
|
|
//
|
|
// propnumptr++;
|
|
// }
|
|
//
|
|
// return !sp2c0;
|
|
//}
|
|
|
|
bool cd0002d6ac(struct coord *pos, s16 *rooms, struct coord *targetpos, u32 types, u32 arg4, f32 arg5, f32 arg6)
|
|
{
|
|
s16 sp44[21];
|
|
s16 sp34[8];
|
|
|
|
portal00018148(pos, targetpos, rooms, sp34, sp44, 20);
|
|
|
|
return cd0002d15c(pos, targetpos, sp44, types, 4, 0, arg4, arg5, arg6);
|
|
}
|
|
|
|
s32 cdTestAToB2(struct coord *pos, s16 *rooms, struct coord *coord2, s16 *rooms2, u32 types, s32 arg5, f32 arg6, f32 arg7)
|
|
{
|
|
s32 result;
|
|
s16 sp44[20];
|
|
s16 sp34[8];
|
|
|
|
func0f065d1c(pos, rooms, coord2, sp34, sp44, 20);
|
|
|
|
if (arrayIntersects(sp34, rooms2)) {
|
|
result = cd0002d15c(pos, coord2, sp44, types, 4, 0, arg5, arg6, arg7);
|
|
} else {
|
|
result = 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002d7c0(struct coord *pos, s16 *rooms, struct coord *arg2, u32 arg3, u32 arg4, f32 ymax, f32 ymin)
|
|
{
|
|
s16 sp44[21];
|
|
s16 sp34[8];
|
|
|
|
portal00018148(pos, arg2, rooms, sp34, sp44, 20);
|
|
|
|
return cd0002d3b0(pos, arg2, sp44, arg3, 4, 0, arg4, ymax, ymin);
|
|
}
|
|
|
|
s32 cd0002d840(struct coord *arg0, s16 *arg1, struct coord *arg2, s16 *arg3, u32 types, s32 arg5, f32 ymax, f32 ymin)
|
|
{
|
|
s16 rooms[21];
|
|
|
|
portal00018148(arg0, arg2, arg1, arg3, rooms, 20);
|
|
|
|
return cd0002d15c(arg0, arg2, rooms, types, 4, 0, arg5, ymax, ymin);
|
|
}
|
|
|
|
s32 cd0002d8b8(struct coord *pos, s16 *rooms, struct coord *pos2, s16 *rooms2, s32 types, bool arg5, f32 ymax, f32 ymin)
|
|
{
|
|
s16 sp44[21];
|
|
s16 sp34[8];
|
|
s32 result;
|
|
|
|
func0f065d1c(pos, rooms, pos2, sp34, sp44, 20);
|
|
|
|
result = cd0002d3b0(pos, pos2, sp44, types, 4, 0, arg5, ymax, ymin);
|
|
|
|
if (result != CDRESULT_COLLISION && !arrayIntersects(sp34, rooms2)) {
|
|
cd00024f6c();
|
|
result = CDRESULT_ERROR;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s32 cdTestAToB3(struct coord *arg0, s16 *arg1, struct coord *arg2, s16 *arg3, f32 width, s32 types, s32 arg6, f32 ymax, f32 ymin)
|
|
{
|
|
u32 stack[7];
|
|
s16 sp5c[8];
|
|
s16 sp4c[8];
|
|
struct coord sp40;
|
|
s32 result;
|
|
|
|
func0f065d1c(arg0, arg1, arg2, sp4c, sp5c, 20);
|
|
|
|
result = cd0002d3b0(arg0, arg2, sp5c, types, 4, 0, arg6, ymax, ymin);
|
|
|
|
if (result == CDRESULT_COLLISION) {
|
|
sp40.x = arg2->x - arg0->x;
|
|
sp40.y = arg2->y - arg0->y;
|
|
sp40.z = arg2->z - arg0->z;
|
|
|
|
cd000250cc(arg0, &sp40, width);
|
|
} else if (!arrayIntersects(sp4c, arg3)) {
|
|
cd00024f6c();
|
|
result = -1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s32 cd0002da50(struct coord *arg0, s16 *arg1, struct coord *arg2, s16 *arg3, u32 types, s32 arg5, f32 ymax, f32 ymin)
|
|
{
|
|
s16 rooms[21];
|
|
|
|
portal00018148(arg0, arg2, arg1, arg3, rooms, 20);
|
|
|
|
return cd0002d3b0(arg0, arg2, rooms, types, 4, 0, arg5, ymax, ymin);
|
|
}
|
|
|
|
s32 cd0002dac8(struct coord *arg0, s16 *arg1, struct coord *arg2, s16 *arg3, f32 width, u32 types, s32 arg6, f32 ymax, f32 ymin)
|
|
{
|
|
s16 rooms[21];
|
|
struct coord sp40;
|
|
s32 result;
|
|
|
|
portal00018148(arg0, arg2, arg1, arg3, rooms, 20);
|
|
|
|
result = cd0002d3b0(arg0, arg2, rooms, types, 4, 0, arg6, ymax, ymin);
|
|
|
|
if (result == 0) {
|
|
sp40.x = arg2->x - arg0->x;
|
|
sp40.y = arg2->y - arg0->y;
|
|
sp40.z = arg2->z - arg0->z;
|
|
|
|
cd000250cc(arg0, &sp40, width);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002db98(struct coord *viewpos, s16 *rooms, struct coord *targetpos, u32 types, u16 arg4)
|
|
{
|
|
s16 sp44[21];
|
|
s16 sp34[8];
|
|
|
|
portal00018148(viewpos, targetpos, rooms, sp34, sp44, 20);
|
|
|
|
return cd0002d15c(viewpos, targetpos, sp44, types, arg4, 1, 1, 0, 0);
|
|
}
|
|
|
|
bool cd0002dc18(struct coord *coord, s16 *rooms, struct coord *coord2, s32 arg3)
|
|
{
|
|
return cd0002db98(coord, rooms, coord2, arg3, 0x1c);
|
|
}
|
|
|
|
bool cdHasLineOfSight(struct coord *coord, s16 *rooms, struct coord *coord2, s16 *rooms2, s32 arg4, u16 arg5)
|
|
{
|
|
bool result;
|
|
s16 sp44[20];
|
|
s16 sp34[8];
|
|
|
|
func0f065d1c(coord, rooms, coord2, sp34, sp44, 20);
|
|
|
|
if (arrayIntersects(sp34, rooms2)) {
|
|
result = cd0002d15c(coord, coord2, sp44, arg4, arg5, 1, 1, 0, 0);
|
|
} else {
|
|
result = false;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002dcd0(struct coord *arg0, s16 *rooms1, struct coord *arg2, s16 *rooms2, u32 arg4)
|
|
{
|
|
return cdHasLineOfSight(arg0, rooms1, arg2, rooms2, arg4, 0x1c);
|
|
}
|
|
|
|
bool cd0002dcfc(struct coord *pos, s16 *rooms, struct coord *pos2, s16 *rooms2, s16 *rooms3, u32 types, u16 arg6)
|
|
{
|
|
bool result;
|
|
s16 sp34[20];
|
|
|
|
func0f065d1c(pos, rooms, pos2, rooms3, sp34, 20);
|
|
|
|
if (arrayIntersects(rooms3, rooms2)) {
|
|
result = cd0002d15c(pos, pos2, sp34, types, arg6, 1, 1, 0, 0);
|
|
} else {
|
|
result = false;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s32 cdTestAToB4(struct coord *pos, s16 *rooms, struct coord *pos2, u32 types, u16 arg4)
|
|
{
|
|
s16 sp44[21];
|
|
s16 sp34[8];
|
|
|
|
portal00018148(pos, pos2, rooms, sp34, sp44, 20);
|
|
|
|
return cd0002d3b0(pos, pos2, sp44, types, arg4, 1, 1, 0, 0);
|
|
}
|
|
|
|
s32 cd0002de10(struct coord *pos, s16 *rooms, struct coord *pos2, u32 types)
|
|
{
|
|
return cdTestAToB4(pos, rooms, pos2, types, 0x1c);
|
|
}
|
|
|
|
s32 cd0002de34(struct coord *arg0, s16 *arg1, struct coord *arg2, s16 *arg3, u32 types, u16 arg5)
|
|
{
|
|
s16 rooms[21];
|
|
|
|
portal00018148(arg0, arg2, arg1, arg3, rooms, 20);
|
|
|
|
return cd0002d15c(arg0, arg2, rooms, types, arg5, 1, 1, 0, 0);
|
|
}
|
|
|
|
s32 cd0002deac(struct coord *arg0, s16 *arg1, struct coord *arg2, s16 *arg3, u32 types)
|
|
{
|
|
return cd0002de34(arg0, arg1, arg2, arg3, types, 0x1c);
|
|
}
|
|
|
|
bool cd0002ded8(struct coord *arg0, struct coord *arg1, struct prop *prop)
|
|
{
|
|
u8 *start;
|
|
u8 *end;
|
|
struct coord sp7c;
|
|
bool result = false;
|
|
struct coord sp6c;
|
|
struct coord sp60;
|
|
struct coord sp54;
|
|
f32 sp50 = 4294967296;
|
|
struct geo *geo;
|
|
|
|
sp7c.x = arg1->x - arg0->x;
|
|
sp7c.y = arg1->y - arg0->y;
|
|
sp7c.z = arg1->z - arg0->z;
|
|
|
|
if (propUpdateGeometry(prop, &start, &end)) {
|
|
if (!cd0002c714(start, end, arg0, arg1, &sp7c, 0x1c, 1, 1, 0, 0, &sp50, &sp6c, &sp60, &sp54, &geo, -999)) {
|
|
result = true;
|
|
cd00025254(&sp60, &sp54, &sp6c, prop, sp50, geo);
|
|
}
|
|
}
|
|
|
|
return !result;
|
|
}
|
|
|
|
GLOBAL_ASM(
|
|
glabel cd0002dffc
|
|
/* 2dffc: 27bdff78 */ addiu $sp,$sp,-136
|
|
/* 2e000: afbf003c */ sw $ra,0x3c($sp)
|
|
/* 2e004: afb50038 */ sw $s5,0x38($sp)
|
|
/* 2e008: afb40034 */ sw $s4,0x34($sp)
|
|
/* 2e00c: afb30030 */ sw $s3,0x30($sp)
|
|
/* 2e010: afb2002c */ sw $s2,0x2c($sp)
|
|
/* 2e014: afb10028 */ sw $s1,0x28($sp)
|
|
/* 2e018: afb00024 */ sw $s0,0x24($sp)
|
|
/* 2e01c: f7b60018 */ sdc1 $f22,0x18($sp)
|
|
/* 2e020: f7b40010 */ sdc1 $f20,0x10($sp)
|
|
/* 2e024: 90900001 */ lbu $s0,0x1($a0)
|
|
/* 2e028: 00809025 */ or $s2,$a0,$zero
|
|
/* 2e02c: 00a0a825 */ or $s5,$a1,$zero
|
|
/* 2e030: 90b10001 */ lbu $s1,0x1($a1)
|
|
/* 2e034: 1a000084 */ blez $s0,.L0002e248
|
|
/* 2e038: 00003025 */ or $a2,$zero,$zero
|
|
/* 2e03c: 44802000 */ mtc1 $zero,$f4
|
|
/* 2e040: 00809825 */ or $s3,$a0,$zero
|
|
/* 2e044: d7b40040 */ ldc1 $f20,0x40($sp)
|
|
/* 2e048: 460025a1 */ cvt.d.s $f22,$f4
|
|
.L0002e04c:
|
|
/* 2e04c: 24d40001 */ addiu $s4,$a2,0x1
|
|
/* 2e050: 0290001a */ div $zero,$s4,$s0
|
|
/* 2e054: 00002810 */ mfhi $a1
|
|
/* 2e058: 000570c0 */ sll $t6,$a1,0x3
|
|
/* 2e05c: 024e1021 */ addu $v0,$s2,$t6
|
|
/* 2e060: c4460010 */ lwc1 $f6,0x10($v0)
|
|
/* 2e064: c6620010 */ lwc1 $f2,0x10($s3)
|
|
/* 2e068: c44a000c */ lwc1 $f10,0xc($v0)
|
|
/* 2e06c: 46003221 */ cvt.d.s $f8,$f6
|
|
/* 2e070: 46001021 */ cvt.d.s $f0,$f2
|
|
/* 2e074: c672000c */ lwc1 $f18,0xc($s3)
|
|
/* 2e078: 46204301 */ sub.d $f12,$f8,$f0
|
|
/* 2e07c: 16000002 */ bnez $s0,.L0002e088
|
|
/* 2e080: 00000000 */ nop
|
|
/* 2e084: 0007000d */ break 0x7
|
|
.L0002e088:
|
|
/* 2e088: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2e08c: 16010004 */ bne $s0,$at,.L0002e0a0
|
|
/* 2e090: 3c018000 */ lui $at,0x8000
|
|
/* 2e094: 16810002 */ bne $s4,$at,.L0002e0a0
|
|
/* 2e098: 00000000 */ nop
|
|
/* 2e09c: 0006000d */ break 0x6
|
|
.L0002e0a0:
|
|
/* 2e0a0: 46366032 */ c.eq.d $f12,$f22
|
|
/* 2e0a4: 24af0001 */ addiu $t7,$a1,0x1
|
|
/* 2e0a8: 46005121 */ cvt.d.s $f4,$f10
|
|
/* 2e0ac: 46009421 */ cvt.d.s $f16,$f18
|
|
/* 2e0b0: 4500000d */ bc1f .L0002e0e8
|
|
/* 2e0b4: 46248381 */ sub.d $f14,$f16,$f4
|
|
/* 2e0b8: 46367032 */ c.eq.d $f14,$f22
|
|
/* 2e0bc: 00000000 */ nop
|
|
/* 2e0c0: 45000009 */ bc1f .L0002e0e8
|
|
/* 2e0c4: 00000000 */ nop
|
|
/* 2e0c8: 44059000 */ mfc1 $a1,$f18
|
|
/* 2e0cc: 44061000 */ mfc1 $a2,$f2
|
|
/* 2e0d0: 0c009948 */ jal cdIs2dPointInBlock
|
|
/* 2e0d4: 02a02025 */ or $a0,$s5,$zero
|
|
/* 2e0d8: 50400058 */ beqzl $v0,.L0002e23c
|
|
/* 2e0dc: 02803025 */ or $a2,$s4,$zero
|
|
/* 2e0e0: 1000005a */ b .L0002e24c
|
|
/* 2e0e4: 00001025 */ or $v0,$zero,$zero
|
|
.L0002e0e8:
|
|
/* 2e0e8: 01f0001a */ div $zero,$t7,$s0
|
|
/* 2e0ec: 462e0182 */ mul.d $f6,$f0,$f14
|
|
/* 2e0f0: 00001010 */ mfhi $v0
|
|
/* 2e0f4: 00401825 */ or $v1,$v0,$zero
|
|
/* 2e0f8: 00002025 */ or $a0,$zero,$zero
|
|
/* 2e0fc: 462c8202 */ mul.d $f8,$f16,$f12
|
|
/* 2e100: 46283080 */ add.d $f2,$f6,$f8
|
|
/* 2e104: 16000002 */ bnez $s0,.L0002e110
|
|
/* 2e108: 00000000 */ nop
|
|
/* 2e10c: 0007000d */ break 0x7
|
|
.L0002e110:
|
|
/* 2e110: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2e114: 16010004 */ bne $s0,$at,.L0002e128
|
|
/* 2e118: 3c018000 */ lui $at,0x8000
|
|
/* 2e11c: 15e10002 */ bne $t7,$at,.L0002e128
|
|
/* 2e120: 00000000 */ nop
|
|
/* 2e124: 0006000d */ break 0x6
|
|
.L0002e128:
|
|
/* 2e128: 10c2001d */ beq $a2,$v0,.L0002e1a0
|
|
/* 2e12c: 00000000 */ nop
|
|
/* 2e130: 0003c0c0 */ sll $t8,$v1,0x3
|
|
.L0002e134:
|
|
/* 2e134: 02581021 */ addu $v0,$s2,$t8
|
|
/* 2e138: c44a0010 */ lwc1 $f10,0x10($v0)
|
|
/* 2e13c: c448000c */ lwc1 $f8,0xc($v0)
|
|
/* 2e140: 46005121 */ cvt.d.s $f4,$f10
|
|
/* 2e144: 460042a1 */ cvt.d.s $f10,$f8
|
|
/* 2e148: 462e2182 */ mul.d $f6,$f4,$f14
|
|
/* 2e14c: 00000000 */ nop
|
|
/* 2e150: 462c5102 */ mul.d $f4,$f10,$f12
|
|
/* 2e154: 46243500 */ add.d $f20,$f6,$f4
|
|
/* 2e158: 4622a032 */ c.eq.d $f20,$f2
|
|
/* 2e15c: 00000000 */ nop
|
|
/* 2e160: 4500000f */ bc1f .L0002e1a0
|
|
/* 2e164: 00000000 */ nop
|
|
/* 2e168: 24790001 */ addiu $t9,$v1,0x1
|
|
/* 2e16c: 0330001a */ div $zero,$t9,$s0
|
|
/* 2e170: 00001810 */ mfhi $v1
|
|
/* 2e174: 16000002 */ bnez $s0,.L0002e180
|
|
/* 2e178: 00000000 */ nop
|
|
/* 2e17c: 0007000d */ break 0x7
|
|
.L0002e180:
|
|
/* 2e180: 2401ffff */ addiu $at,$zero,-1
|
|
/* 2e184: 16010004 */ bne $s0,$at,.L0002e198
|
|
/* 2e188: 3c018000 */ lui $at,0x8000
|
|
/* 2e18c: 17210002 */ bne $t9,$at,.L0002e198
|
|
/* 2e190: 00000000 */ nop
|
|
/* 2e194: 0006000d */ break 0x6
|
|
.L0002e198:
|
|
/* 2e198: 5466ffe6 */ bnel $v1,$a2,.L0002e134
|
|
/* 2e19c: 0003c0c0 */ sll $t8,$v1,0x3
|
|
.L0002e1a0:
|
|
/* 2e1a0: 1a200021 */ blez $s1,.L0002e228
|
|
/* 2e1a4: 00000000 */ nop
|
|
/* 2e1a8: 02a01025 */ or $v0,$s5,$zero
|
|
.L0002e1ac:
|
|
/* 2e1ac: c4480010 */ lwc1 $f8,0x10($v0)
|
|
/* 2e1b0: c444000c */ lwc1 $f4,0xc($v0)
|
|
/* 2e1b4: 4622a032 */ c.eq.d $f20,$f2
|
|
/* 2e1b8: 460042a1 */ cvt.d.s $f10,$f8
|
|
/* 2e1bc: 46002221 */ cvt.d.s $f8,$f4
|
|
/* 2e1c0: 462e5182 */ mul.d $f6,$f10,$f14
|
|
/* 2e1c4: 00000000 */ nop
|
|
/* 2e1c8: 462c4282 */ mul.d $f10,$f8,$f12
|
|
/* 2e1cc: 45000003 */ bc1f .L0002e1dc
|
|
/* 2e1d0: 462a3000 */ add.d $f0,$f6,$f10
|
|
/* 2e1d4: 46201101 */ sub.d $f4,$f2,$f0
|
|
/* 2e1d8: 46222500 */ add.d $f20,$f4,$f2
|
|
.L0002e1dc:
|
|
/* 2e1dc: 4622003c */ c.lt.d $f0,$f2
|
|
/* 2e1e0: 00000000 */ nop
|
|
/* 2e1e4: 45020006 */ bc1fl .L0002e200
|
|
/* 2e1e8: 4620103c */ c.lt.d $f2,$f0
|
|
/* 2e1ec: 4622a03c */ c.lt.d $f20,$f2
|
|
/* 2e1f0: 00000000 */ nop
|
|
/* 2e1f4: 4501000c */ bc1t .L0002e228
|
|
/* 2e1f8: 00000000 */ nop
|
|
/* 2e1fc: 4620103c */ c.lt.d $f2,$f0
|
|
.L0002e200:
|
|
/* 2e200: 00000000 */ nop
|
|
/* 2e204: 45020006 */ bc1fl .L0002e220
|
|
/* 2e208: 24840001 */ addiu $a0,$a0,0x1
|
|
/* 2e20c: 4634103c */ c.lt.d $f2,$f20
|
|
/* 2e210: 00000000 */ nop
|
|
/* 2e214: 45010004 */ bc1t .L0002e228
|
|
/* 2e218: 00000000 */ nop
|
|
/* 2e21c: 24840001 */ addiu $a0,$a0,0x1
|
|
.L0002e220:
|
|
/* 2e220: 1491ffe2 */ bne $a0,$s1,.L0002e1ac
|
|
/* 2e224: 24420008 */ addiu $v0,$v0,0x8
|
|
.L0002e228:
|
|
/* 2e228: 54910004 */ bnel $a0,$s1,.L0002e23c
|
|
/* 2e22c: 02803025 */ or $a2,$s4,$zero
|
|
/* 2e230: 10000006 */ b .L0002e24c
|
|
/* 2e234: 24020001 */ addiu $v0,$zero,0x1
|
|
/* 2e238: 02803025 */ or $a2,$s4,$zero
|
|
.L0002e23c:
|
|
/* 2e23c: 1690ff83 */ bne $s4,$s0,.L0002e04c
|
|
/* 2e240: 26730008 */ addiu $s3,$s3,0x8
|
|
/* 2e244: f7b40040 */ sdc1 $f20,0x40($sp)
|
|
.L0002e248:
|
|
/* 2e248: 00001025 */ or $v0,$zero,$zero
|
|
.L0002e24c:
|
|
/* 2e24c: 8fbf003c */ lw $ra,0x3c($sp)
|
|
/* 2e250: d7b40010 */ ldc1 $f20,0x10($sp)
|
|
/* 2e254: d7b60018 */ ldc1 $f22,0x18($sp)
|
|
/* 2e258: 8fb00024 */ lw $s0,0x24($sp)
|
|
/* 2e25c: 8fb10028 */ lw $s1,0x28($sp)
|
|
/* 2e260: 8fb2002c */ lw $s2,0x2c($sp)
|
|
/* 2e264: 8fb30030 */ lw $s3,0x30($sp)
|
|
/* 2e268: 8fb40034 */ lw $s4,0x34($sp)
|
|
/* 2e26c: 8fb50038 */ lw $s5,0x38($sp)
|
|
/* 2e270: 03e00008 */ jr $ra
|
|
/* 2e274: 27bd0088 */ addiu $sp,$sp,0x88
|
|
);
|
|
|
|
// Mismatch: Float regalloc, likely related to the zero variable
|
|
//bool cd0002dffc(struct geoblock *arg0, struct geoblock *arg1)
|
|
//{
|
|
// u32 stack[4];
|
|
// f32 zero = 0;
|
|
// s32 numvertices0 = arg0->header.numvertices;
|
|
// s32 numvertices1 = arg1->header.numvertices;
|
|
// s32 i;
|
|
//
|
|
// for (i = 0; i < numvertices0; i++) {
|
|
// s32 next = (i + 1) % numvertices0;
|
|
// f64 diff1;
|
|
// f64 diff2;
|
|
//
|
|
// diff1 = arg0->vertices[next][1] - (f64)arg0->vertices[i][1];
|
|
// diff2 = arg0->vertices[i][0] - (f64)arg0->vertices[next][0];
|
|
//
|
|
// if (diff1 == zero && diff2 == zero) {
|
|
// if (cdIs2dPointInBlock(arg1, arg0->vertices[i][0], arg0->vertices[i][1])) {
|
|
// return false;
|
|
// }
|
|
// } else {
|
|
// f64 sum1 = arg0->vertices[i][0] * diff1 + arg0->vertices[i][1] * diff2;
|
|
// f64 sum2;
|
|
// s32 j = (next + 1) % numvertices0;
|
|
// s32 k;
|
|
//
|
|
// while (j != i) {
|
|
// sum2 = arg0->vertices[j][0] * diff1 + arg0->vertices[j][1] * diff2;
|
|
//
|
|
// if (sum2 != sum1) {
|
|
// break;
|
|
// }
|
|
//
|
|
// j = (j + 1) % numvertices0;
|
|
// }
|
|
//
|
|
// for (k = 0; k < numvertices1; k++) {
|
|
// f64 sum3 = arg1->vertices[k][0] * diff1 + arg1->vertices[k][1] * diff2;
|
|
//
|
|
// if (sum2 == sum1) {
|
|
// sum2 = sum1 - sum3 + sum1;
|
|
// }
|
|
//
|
|
// if ((sum3 < sum1 && sum2 < sum1) || (sum3 > sum1 && sum2 > sum1)) {
|
|
// break;
|
|
// }
|
|
// }
|
|
//
|
|
// if (k == numvertices1) {
|
|
// return true;
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// return false;
|
|
//}
|
|
|
|
s32 cd0002e278(u8 *start, u8 *end, struct geoblock *ref, u16 flags)
|
|
{
|
|
struct geo *geo = (struct geo *) start;
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *) geo;
|
|
geo = (struct geo *)((u32)geo + tile->header.numvertices * 6 + 0xe);
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *type1 = (struct geotilef *) geo;
|
|
geo = (struct geo *)((u32)geo + type1->header.numvertices * 0xc + 0x10);
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
struct geoblock *tile2 = (struct geoblock *) geo;
|
|
|
|
if ((flags & (GEOFLAG_COLLISIONS | GEOFLAG_0008 | GEOFLAG_OPAQUE))
|
|
&& tile2->ymax >= ref->ymin
|
|
&& tile2->ymin <= ref->ymax) {
|
|
// Tiles are overlapping vertically
|
|
s32 i;
|
|
|
|
for (i = 0; i < ref->header.numvertices; i++) {
|
|
if (cdIs2dPointInBlock(tile2, ref->vertices[i][0], ref->vertices[i][1])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < tile2->header.numvertices; i++) {
|
|
if (cdIs2dPointInBlock(ref, tile2->vertices[i][0], tile2->vertices[i][1])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!cd0002dffc(ref, tile2) && !cd0002dffc(tile2, ref)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + 0x4c);
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
struct geocyl *cyl = (struct geocyl *) geo;
|
|
|
|
if ((flags & geo->flags)
|
|
&& cyl->ymax >= ref->ymin
|
|
&& cyl->ymin <= ref->ymax
|
|
&& cd000274e0(ref, cyl->x, cyl->z, cyl->radius, NULL, NULL)) {
|
|
return false;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + 0x18);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
s32 cd0002e4c4(struct geoblock *geo, s16 *rooms, u32 types)
|
|
{
|
|
s32 result = CDRESULT_NOCOLLISION;
|
|
s32 roomnum;
|
|
u8 *start;
|
|
u8 *end;
|
|
s16 *roomptr;
|
|
s16 propnums[256];
|
|
s16 *propnumptr;
|
|
|
|
// Check BG
|
|
if (types & CDTYPE_BG) {
|
|
roomptr = rooms;
|
|
roomnum = rooms[0];
|
|
|
|
while (roomnum != -1) {
|
|
if (roomnum < g_TileNumRooms) {
|
|
start = g_TileFileData.u8 + g_TileRooms[roomnum];
|
|
end = g_TileFileData.u8 + g_TileRooms[roomnum + 1];
|
|
|
|
result = cd0002e278(start, end, geo, GEOFLAG_COLLISIONS);
|
|
|
|
if (result == CDRESULT_COLLISION) {
|
|
cd00025168(NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
roomptr++;
|
|
roomnum = *roomptr;
|
|
}
|
|
}
|
|
|
|
// Check props
|
|
if (result != CDRESULT_COLLISION) {
|
|
roomGetProps(rooms, propnums, 256);
|
|
propnumptr = propnums;
|
|
|
|
while (*propnumptr >= 0) {
|
|
struct prop *prop = &g_Vars.props[*propnumptr];
|
|
|
|
if (propIsOfCdType(prop, types) && propUpdateGeometry(prop, &start, &end)) {
|
|
result = cd0002e278(start, end, geo, GEOFLAG_COLLISIONS);
|
|
|
|
if (result == CDRESULT_COLLISION) {
|
|
cd00025168(prop);
|
|
break;
|
|
}
|
|
}
|
|
|
|
propnumptr++;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002e680(struct geotilei *tile, s32 numvertices, struct coord *arg2, struct coord *arg3, struct prop *prop, struct geoblock *block)
|
|
{
|
|
bool result = false;
|
|
s32 i;
|
|
s32 next;
|
|
s32 curr;
|
|
struct coord sp84;
|
|
struct coord sp78;
|
|
struct coord sp6c;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
if (var8005f030) {
|
|
s32 remaining = numvertices - i;
|
|
next = (remaining + numvertices - 2) % numvertices;
|
|
curr = remaining - 1;
|
|
} else {
|
|
next = (i + 1) % numvertices;
|
|
curr = i;
|
|
}
|
|
|
|
if (cd0002ac70((struct coord *)((u32)arg2 + curr * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg2 + next * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg3 + curr * sizeof(struct coord)),
|
|
tile, &sp6c, &sp84, &sp78, 0, 0.0f, 0.0f)) {
|
|
cd000251ac(&sp84, &sp78, &sp6c, prop);
|
|
cd00025314((struct coord *)((u32)arg2 + curr * sizeof(struct coord)), (struct coord *)((u32)arg2 + next * sizeof(struct coord)));
|
|
cd000253c4(block);
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002e82c(struct geotilef *tile, s32 numvertices, struct coord *arg2, struct coord *arg3, struct prop *prop, struct geoblock *block)
|
|
{
|
|
bool result = false;
|
|
s32 i;
|
|
s32 next;
|
|
s32 curr;
|
|
struct coord sp84;
|
|
struct coord sp78;
|
|
struct coord sp6c;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
if (var8005f030) {
|
|
s32 remaining = numvertices - i;
|
|
next = (remaining + numvertices - 2) % numvertices;
|
|
curr = remaining - 1;
|
|
} else {
|
|
next = (i + 1) % numvertices;
|
|
curr = i;
|
|
}
|
|
|
|
if (cd0002b128((struct coord *)((u32)arg2 + curr * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg2 + next * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg3 + curr * sizeof(struct coord)),
|
|
tile, &sp6c, &sp84, &sp78, 0, 0.0f, 0.0f)) {
|
|
cd000251ac(&sp84, &sp78, &sp6c, prop);
|
|
cd00025314((struct coord *)((u32)arg2 + curr * sizeof(struct coord)), (struct coord *)((u32)arg2 + next * sizeof(struct coord)));
|
|
cd000253c4(block);
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002e9d8(struct geoblock *thisblock, s32 numvertices, struct coord *arg2, struct coord *arg3, struct prop *prop, struct geoblock *block)
|
|
{
|
|
bool result = false;
|
|
s32 i;
|
|
s32 next;
|
|
s32 curr;
|
|
struct coord sp84;
|
|
struct coord sp78;
|
|
struct coord sp6c;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
if (var8005f030) {
|
|
s32 remaining = numvertices - i;
|
|
next = (remaining + numvertices - 2) % numvertices;
|
|
curr = remaining - 1;
|
|
} else {
|
|
next = (i + 1) % numvertices;
|
|
curr = i;
|
|
}
|
|
|
|
if (cd0002b560((struct coord *)((u32)arg2 + curr * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg2 + next * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg3 + curr * sizeof(struct coord)),
|
|
thisblock, &sp6c, &sp84, &sp78, 0, 0.0f, 0.0f)) {
|
|
cd000251ac(&sp84, &sp78, &sp6c, prop);
|
|
cd00025314((struct coord *)((u32)arg2 + curr * sizeof(struct coord)), (struct coord *)((u32)arg2 + next * sizeof(struct coord)));
|
|
cd000253c4(block);
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002eb84(struct geocyl *cyl, s32 numvertices, struct coord *arg2, struct coord *arg3, struct prop *prop, struct geoblock *block)
|
|
{
|
|
bool result = false;
|
|
s32 i;
|
|
s32 next;
|
|
s32 curr;
|
|
struct coord sp84;
|
|
struct coord sp78;
|
|
struct coord sp6c;
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
if (var8005f030) {
|
|
s32 remaining = numvertices - i;
|
|
next = (remaining + numvertices - 2) % numvertices;
|
|
curr = remaining - 1;
|
|
} else {
|
|
next = (i + 1) % numvertices;
|
|
curr = i;
|
|
}
|
|
|
|
if (cd0002b954((struct coord *)((u32)arg2 + curr * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg2 + next * sizeof(struct coord)),
|
|
(struct coord *)((u32)arg3 + curr * sizeof(struct coord)),
|
|
cyl, &sp6c, &sp84, &sp78, 0, 0.0f, 0.0f)) {
|
|
cd000251ac(&sp84, &sp78, &sp6c, prop);
|
|
cd00025314((struct coord *)((u32)arg2 + curr * sizeof(struct coord)), (struct coord *)((u32)arg2 + next * sizeof(struct coord)));
|
|
cd000253c4(block);
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cd0002ed30(u8 *start, u8 *end, struct geoblock *block, s32 numvertices, struct coord *arg4, struct coord *arg5, u16 flags, struct prop *prop)
|
|
{
|
|
struct geo *geo = (struct geo *) start;
|
|
|
|
while (geo < (struct geo *) end) {
|
|
if (1);
|
|
|
|
if (geo->type == GEOTYPE_TILE_I) {
|
|
struct geotilei *tile = (struct geotilei *)geo;
|
|
|
|
if ((flags & geo->flags)
|
|
&& *(s16 *)(tile->ymax + (u32)tile) >= block->ymin
|
|
&& *(s16 *)(tile->ymin + (u32)tile) <= block->ymax
|
|
&& cd0002e680(tile, numvertices, arg4, arg5, prop, block)) {
|
|
return false;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + tile->header.numvertices * 6 + 0xe);
|
|
} else if (geo->type == GEOTYPE_TILE_F) {
|
|
struct geotilef *tile = (struct geotilef *)geo;
|
|
|
|
if ((flags & geo->flags)
|
|
&& tile->vertices[tile->ymax].y >= block->ymin
|
|
&& tile->vertices[tile->ymin].y <= block->ymax
|
|
&& cd0002e82c(tile, numvertices, arg4, arg5, prop, block)) {
|
|
return false;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + (u32)(tile->header.numvertices - 0x40) * 0xc + 0x310);
|
|
} else if (geo->type == GEOTYPE_BLOCK) {
|
|
struct geoblock *block2 = (struct geoblock *)geo;
|
|
|
|
if ((flags & (GEOFLAG_COLLISIONS | GEOFLAG_0008 | GEOFLAG_OPAQUE))
|
|
&& block2->ymax >= block->ymin
|
|
&& block2->ymin <= block->ymax
|
|
&& cd0002e9d8(block2, numvertices, arg4, arg5, prop, block)) {
|
|
return false;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geoblock));
|
|
} else if (geo->type == GEOTYPE_CYL) {
|
|
struct geocyl *cyl = (struct geocyl *)geo;
|
|
|
|
if ((flags & geo->flags)
|
|
&& cyl->ymax >= block->ymin
|
|
&& cyl->ymin <= block->ymax
|
|
&& cd0002eb84(cyl, numvertices, arg4, arg5, prop, block)) {
|
|
return false;
|
|
}
|
|
|
|
geo = (struct geo *)((u32)geo + sizeof(struct geocyl));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cd0002f02c(struct geoblock *block, s16 *rooms, s32 types)
|
|
{
|
|
s32 numvertices = block->header.numvertices;
|
|
s32 i;
|
|
u8 *start;
|
|
u8 *end;
|
|
s32 next;
|
|
s16 propnums[256];
|
|
s16 *propnumptr;
|
|
bool result = true;
|
|
struct coord spcc[8];
|
|
struct coord sp6c[8];
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
spcc[i].x = block->vertices[i][0];
|
|
spcc[i].y = block->ymax;
|
|
spcc[i].z = block->vertices[i][1];
|
|
}
|
|
|
|
for (i = 0; i < numvertices; i++) {
|
|
next = (i + 1) % numvertices;
|
|
|
|
sp6c[i].x = spcc[next].x - spcc[i].x;
|
|
sp6c[i].y = spcc[next].y - spcc[i].y;
|
|
sp6c[i].z = spcc[next].z - spcc[i].z;
|
|
}
|
|
|
|
if (types & CDTYPE_BG) {
|
|
s16 *roomsptr = rooms;
|
|
s32 roomnum = *roomsptr;
|
|
|
|
while (roomnum != -1) {
|
|
if (roomnum < g_TileNumRooms) {
|
|
start = g_TileFileData.u8 + g_TileRooms[roomnum];
|
|
end = g_TileFileData.u8 + g_TileRooms[roomnum + 1];
|
|
|
|
result = cd0002ed30(start, end, block, numvertices, spcc, sp6c, 4, NULL);
|
|
|
|
if (!result) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
roomsptr++;
|
|
roomnum = *roomsptr;
|
|
}
|
|
}
|
|
|
|
if (result) {
|
|
roomGetProps(rooms, propnums, 256);
|
|
|
|
propnumptr = propnums;
|
|
|
|
while (*propnumptr >= 0) {
|
|
struct prop *prop = &g_Vars.props[*propnumptr];
|
|
|
|
if (propIsOfCdType(prop, types)) {
|
|
if (propUpdateGeometry(prop, &start, &end)) {
|
|
result = cd0002ed30(start, end, block, numvertices, spcc, sp6c, 4, prop);
|
|
|
|
if (!result) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
propnumptr++;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#if VERSION < VERSION_NTSC_1_0
|
|
GLOBAL_ASM(
|
|
glabel func000306f0nb
|
|
/* 306f0: 27bdff78 */ addiu $sp,$sp,-136
|
|
/* 306f4: afb1000c */ sw $s1,0xc($sp)
|
|
/* 306f8: afb00008 */ sw $s0,0x8($sp)
|
|
/* 306fc: 94ce0002 */ lhu $t6,0x2($a2)
|
|
/* 30700: 00a08025 */ or $s0,$a1,$zero
|
|
/* 30704: 00808825 */ or $s1,$a0,$zero
|
|
/* 30708: 31cf0005 */ andi $t7,$t6,0x5
|
|
/* 3070c: 51e00072 */ beqzl $t7,.NB000308d8
|
|
/* 30710: 02201025 */ or $v0,$s1,$zero
|
|
/* 30714: 90c20001 */ lbu $v0,0x1($a2)
|
|
/* 30718: 27a40020 */ addiu $a0,$sp,0x20
|
|
/* 3071c: 00c02825 */ or $a1,$a2,$zero
|
|
/* 30720: 28410011 */ slti $at,$v0,0x11
|
|
/* 30724: 14200002 */ bnez $at,.NB00030730
|
|
/* 30728: 3c07800a */ lui $a3,0x800a
|
|
/* 3072c: 24020010 */ addiu $v0,$zero,0x10
|
|
.NB00030730:
|
|
/* 30730: 18400044 */ blez $v0,.NB00030844
|
|
/* 30734: 00001825 */ or $v1,$zero,$zero
|
|
/* 30738: 8ce7e944 */ lw $a3,-0x16bc($a3)
|
|
/* 3073c: 24630001 */ addiu $v1,$v1,0x1
|
|
/* 30740: 10620022 */ beq $v1,$v0,.NB000307cc
|
|
/* 30744: 84b8000e */ lh $t8,0xe($a1)
|
|
.NB00030748:
|
|
/* 30748: 44989000 */ mtc1 $t8,$f18
|
|
/* 3074c: c4f00038 */ lwc1 $f16,0x38($a3)
|
|
/* 30750: 24630001 */ addiu $v1,$v1,0x1
|
|
/* 30754: 468094a0 */ cvt.s.w $f18,$f18
|
|
/* 30758: 24840006 */ addiu $a0,$a0,0x6
|
|
/* 3075c: 24a50006 */ addiu $a1,$a1,0x6
|
|
/* 30760: 46109401 */ sub.s $f16,$f18,$f16
|
|
/* 30764: 4600840d */ trunc.w.s $f16,$f16
|
|
/* 30768: 44088000 */ mfc1 $t0,$f16
|
|
/* 3076c: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30770: a488fffa */ sh $t0,-0x6($a0)
|
|
/* 30774: 84a9000a */ lh $t1,0xa($a1)
|
|
/* 30778: c4f0003c */ lwc1 $f16,0x3c($a3)
|
|
/* 3077c: 44899000 */ mtc1 $t1,$f18
|
|
/* 30780: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30784: 468094a0 */ cvt.s.w $f18,$f18
|
|
/* 30788: 46109401 */ sub.s $f16,$f18,$f16
|
|
/* 3078c: 4600840d */ trunc.w.s $f16,$f16
|
|
/* 30790: 440b8000 */ mfc1 $t3,$f16
|
|
/* 30794: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30798: a48bfffc */ sh $t3,-0x4($a0)
|
|
/* 3079c: 84ac000c */ lh $t4,0xc($a1)
|
|
/* 307a0: c4f00040 */ lwc1 $f16,0x40($a3)
|
|
/* 307a4: 448c9000 */ mtc1 $t4,$f18
|
|
/* 307a8: 00000000 */ sll $zero,$zero,0x0
|
|
/* 307ac: 468094a0 */ cvt.s.w $f18,$f18
|
|
/* 307b0: 46109401 */ sub.s $f16,$f18,$f16
|
|
/* 307b4: 4600840d */ trunc.w.s $f16,$f16
|
|
/* 307b8: 440e8000 */ mfc1 $t6,$f16
|
|
/* 307bc: 00000000 */ sll $zero,$zero,0x0
|
|
/* 307c0: a48efffe */ sh $t6,-0x2($a0)
|
|
/* 307c4: 1462ffe0 */ bne $v1,$v0,.NB00030748
|
|
/* 307c8: 84b8000e */ lh $t8,0xe($a1)
|
|
.NB000307cc:
|
|
/* 307cc: 44989000 */ mtc1 $t8,$f18
|
|
/* 307d0: c4f00038 */ lwc1 $f16,0x38($a3)
|
|
/* 307d4: 24840006 */ addiu $a0,$a0,0x6
|
|
/* 307d8: 468094a0 */ cvt.s.w $f18,$f18
|
|
/* 307dc: 24a50006 */ addiu $a1,$a1,0x6
|
|
/* 307e0: 46109401 */ sub.s $f16,$f18,$f16
|
|
/* 307e4: 4600840d */ trunc.w.s $f16,$f16
|
|
/* 307e8: 44088000 */ mfc1 $t0,$f16
|
|
/* 307ec: 00000000 */ sll $zero,$zero,0x0
|
|
/* 307f0: a488fffa */ sh $t0,-0x6($a0)
|
|
/* 307f4: 84a9000a */ lh $t1,0xa($a1)
|
|
/* 307f8: c4f0003c */ lwc1 $f16,0x3c($a3)
|
|
/* 307fc: 44899000 */ mtc1 $t1,$f18
|
|
/* 30800: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30804: 468094a0 */ cvt.s.w $f18,$f18
|
|
/* 30808: 46109401 */ sub.s $f16,$f18,$f16
|
|
/* 3080c: 4600840d */ trunc.w.s $f16,$f16
|
|
/* 30810: 440b8000 */ mfc1 $t3,$f16
|
|
/* 30814: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30818: a48bfffc */ sh $t3,-0x4($a0)
|
|
/* 3081c: 84ac000c */ lh $t4,0xc($a1)
|
|
/* 30820: c4f00040 */ lwc1 $f16,0x40($a3)
|
|
/* 30824: 448c9000 */ mtc1 $t4,$f18
|
|
/* 30828: 00000000 */ sll $zero,$zero,0x0
|
|
/* 3082c: 468094a0 */ cvt.s.w $f18,$f18
|
|
/* 30830: 46109401 */ sub.s $f16,$f18,$f16
|
|
/* 30834: 4600840d */ trunc.w.s $f16,$f16
|
|
/* 30838: 440e8000 */ mfc1 $t6,$f16
|
|
/* 3083c: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30840: a48efffe */ sh $t6,-0x2($a0)
|
|
.NB00030844:
|
|
/* 30844: 28410003 */ slti $at,$v0,0x3
|
|
/* 30848: 14200022 */ bnez $at,.NB000308d4
|
|
/* 3084c: 24030002 */ addiu $v1,$zero,0x2
|
|
/* 30850: 24070006 */ addiu $a3,$zero,0x6
|
|
/* 30854: 27a60020 */ addiu $a2,$sp,0x20
|
|
.NB00030858:
|
|
/* 30858: 8e050000 */ lw $a1,0x0($s0)
|
|
/* 3085c: 87af0020 */ lh $t7,0x20($sp)
|
|
/* 30860: 58a00019 */ blezl $a1,.NB000308c8
|
|
/* 30864: 24630001 */ addiu $v1,$v1,0x1
|
|
/* 30868: 00670019 */ multu $v1,$a3
|
|
/* 3086c: a62f0000 */ sh $t7,0x0($s1)
|
|
/* 30870: 87b80022 */ lh $t8,0x22($sp)
|
|
/* 30874: 26310014 */ addiu $s1,$s1,0x14
|
|
/* 30878: a638ffee */ sh $t8,-0x12($s1)
|
|
/* 3087c: 87b90024 */ lh $t9,0x24($sp)
|
|
/* 30880: a639fff0 */ sh $t9,-0x10($s1)
|
|
/* 30884: 00004012 */ mflo $t0
|
|
/* 30888: 00c82021 */ addu $a0,$a2,$t0
|
|
/* 3088c: 8489fffa */ lh $t1,-0x6($a0)
|
|
/* 30890: a629fff2 */ sh $t1,-0xe($s1)
|
|
/* 30894: 848afffc */ lh $t2,-0x4($a0)
|
|
/* 30898: a62afff4 */ sh $t2,-0xc($s1)
|
|
/* 3089c: 848bfffe */ lh $t3,-0x2($a0)
|
|
/* 308a0: a62bfff6 */ sh $t3,-0xa($s1)
|
|
/* 308a4: 848c0000 */ lh $t4,0x0($a0)
|
|
/* 308a8: a62cfff8 */ sh $t4,-0x8($s1)
|
|
/* 308ac: 848d0002 */ lh $t5,0x2($a0)
|
|
/* 308b0: a62dfffa */ sh $t5,-0x6($s1)
|
|
/* 308b4: 848e0004 */ lh $t6,0x4($a0)
|
|
/* 308b8: a220fffe */ sb $zero,-0x2($s1)
|
|
/* 308bc: a62efffc */ sh $t6,-0x4($s1)
|
|
/* 308c0: 8e050000 */ lw $a1,0x0($s0)
|
|
/* 308c4: 24630001 */ addiu $v1,$v1,0x1
|
|
.NB000308c8:
|
|
/* 308c8: 24afffff */ addiu $t7,$a1,-1
|
|
/* 308cc: 1462ffe2 */ bne $v1,$v0,.NB00030858
|
|
/* 308d0: ae0f0000 */ sw $t7,0x0($s0)
|
|
.NB000308d4:
|
|
/* 308d4: 02201025 */ or $v0,$s1,$zero
|
|
.NB000308d8:
|
|
/* 308d8: 8fb1000c */ lw $s1,0xc($sp)
|
|
/* 308dc: 8fb00008 */ lw $s0,0x8($sp)
|
|
/* 308e0: 03e00008 */ jr $ra
|
|
/* 308e4: 27bd0088 */ addiu $sp,$sp,0x88
|
|
);
|
|
#endif
|
|
|
|
#if VERSION < VERSION_NTSC_1_0
|
|
GLOBAL_ASM(
|
|
glabel func000308e8nb
|
|
/* 308e8: 27bdff78 */ addiu $sp,$sp,-136
|
|
/* 308ec: afb1000c */ sw $s1,0xc($sp)
|
|
/* 308f0: afb00008 */ sw $s0,0x8($sp)
|
|
/* 308f4: 94ce0002 */ lhu $t6,0x2($a2)
|
|
/* 308f8: 00a08025 */ or $s0,$a1,$zero
|
|
/* 308fc: 00808825 */ or $s1,$a0,$zero
|
|
/* 30900: 31cf0005 */ andi $t7,$t6,0x5
|
|
/* 30904: 51e00048 */ beqzl $t7,.NB00030a28
|
|
/* 30908: 02201025 */ or $v0,$s1,$zero
|
|
/* 3090c: 90c20001 */ lbu $v0,0x1($a2)
|
|
/* 30910: 27a40020 */ addiu $a0,$sp,0x20
|
|
/* 30914: 00c02825 */ or $a1,$a2,$zero
|
|
/* 30918: 28410011 */ slti $at,$v0,0x11
|
|
/* 3091c: 14200002 */ bnez $at,.NB00030928
|
|
/* 30920: 3c07800a */ lui $a3,0x800a
|
|
/* 30924: 24020010 */ addiu $v0,$zero,0x10
|
|
.NB00030928:
|
|
/* 30928: 1840001a */ blez $v0,.NB00030994
|
|
/* 3092c: 00001825 */ or $v1,$zero,$zero
|
|
/* 30930: 8ce7e944 */ lw $a3,-0x16bc($a3)
|
|
.NB00030934:
|
|
/* 30934: c4a40010 */ lwc1 $f4,0x10($a1)
|
|
/* 30938: c4e60038 */ lwc1 $f6,0x38($a3)
|
|
/* 3093c: 24630001 */ addiu $v1,$v1,0x1
|
|
/* 30940: 24840006 */ addiu $a0,$a0,0x6
|
|
/* 30944: 46062201 */ sub.s $f8,$f4,$f6
|
|
/* 30948: 24a5000c */ addiu $a1,$a1,0xc
|
|
/* 3094c: 4600428d */ trunc.w.s $f10,$f8
|
|
/* 30950: 44195000 */ mfc1 $t9,$f10
|
|
/* 30954: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30958: a499fffa */ sh $t9,-0x6($a0)
|
|
/* 3095c: c4f2003c */ lwc1 $f18,0x3c($a3)
|
|
/* 30960: c4b00008 */ lwc1 $f16,0x8($a1)
|
|
/* 30964: 46128101 */ sub.s $f4,$f16,$f18
|
|
/* 30968: 4600218d */ trunc.w.s $f6,$f4
|
|
/* 3096c: 44093000 */ mfc1 $t1,$f6
|
|
/* 30970: 00000000 */ sll $zero,$zero,0x0
|
|
/* 30974: a489fffc */ sh $t1,-0x4($a0)
|
|
/* 30978: c4ea0040 */ lwc1 $f10,0x40($a3)
|
|
/* 3097c: c4a8000c */ lwc1 $f8,0xc($a1)
|
|
/* 30980: 460a4401 */ sub.s $f16,$f8,$f10
|
|
/* 30984: 4600848d */ trunc.w.s $f18,$f16
|
|
/* 30988: 440b9000 */ mfc1 $t3,$f18
|
|
/* 3098c: 1462ffe9 */ bne $v1,$v0,.NB00030934
|
|
/* 30990: a48bfffe */ sh $t3,-0x2($a0)
|
|
.NB00030994:
|
|
/* 30994: 28410003 */ slti $at,$v0,0x3
|
|
/* 30998: 14200022 */ bnez $at,.NB00030a24
|
|
/* 3099c: 24030002 */ addiu $v1,$zero,0x2
|
|
/* 309a0: 24070006 */ addiu $a3,$zero,0x6
|
|
/* 309a4: 27a60020 */ addiu $a2,$sp,0x20
|
|
.NB000309a8:
|
|
/* 309a8: 8e050000 */ lw $a1,0x0($s0)
|
|
/* 309ac: 87ac0020 */ lh $t4,0x20($sp)
|
|
/* 309b0: 58a00019 */ blezl $a1,.NB00030a18
|
|
/* 309b4: 24630001 */ addiu $v1,$v1,0x1
|
|
/* 309b8: 00670019 */ multu $v1,$a3
|
|
/* 309bc: a62c0000 */ sh $t4,0x0($s1)
|
|
/* 309c0: 87ad0022 */ lh $t5,0x22($sp)
|
|
/* 309c4: 26310014 */ addiu $s1,$s1,0x14
|
|
/* 309c8: a62dffee */ sh $t5,-0x12($s1)
|
|
/* 309cc: 87ae0024 */ lh $t6,0x24($sp)
|
|
/* 309d0: a62efff0 */ sh $t6,-0x10($s1)
|
|
/* 309d4: 00007812 */ mflo $t7
|
|
/* 309d8: 00cf2021 */ addu $a0,$a2,$t7
|
|
/* 309dc: 8498fffa */ lh $t8,-0x6($a0)
|
|
/* 309e0: a638fff2 */ sh $t8,-0xe($s1)
|
|
/* 309e4: 8499fffc */ lh $t9,-0x4($a0)
|
|
/* 309e8: a639fff4 */ sh $t9,-0xc($s1)
|
|
/* 309ec: 8488fffe */ lh $t0,-0x2($a0)
|
|
/* 309f0: a628fff6 */ sh $t0,-0xa($s1)
|
|
/* 309f4: 84890000 */ lh $t1,0x0($a0)
|
|
/* 309f8: a629fff8 */ sh $t1,-0x8($s1)
|
|
/* 309fc: 848a0002 */ lh $t2,0x2($a0)
|
|
/* 30a00: a62afffa */ sh $t2,-0x6($s1)
|
|
/* 30a04: 848b0004 */ lh $t3,0x4($a0)
|
|
/* 30a08: a220fffe */ sb $zero,-0x2($s1)
|
|
/* 30a0c: a62bfffc */ sh $t3,-0x4($s1)
|
|
/* 30a10: 8e050000 */ lw $a1,0x0($s0)
|
|
/* 30a14: 24630001 */ addiu $v1,$v1,0x1
|
|
.NB00030a18:
|
|
/* 30a18: 24acffff */ addiu $t4,$a1,-1
|
|
/* 30a1c: 1462ffe2 */ bne $v1,$v0,.NB000309a8
|
|
/* 30a20: ae0c0000 */ sw $t4,0x0($s0)
|
|
.NB00030a24:
|
|
/* 30a24: 02201025 */ or $v0,$s1,$zero
|
|
.NB00030a28:
|
|
/* 30a28: 8fb1000c */ lw $s1,0xc($sp)
|
|
/* 30a2c: 8fb00008 */ lw $s0,0x8($sp)
|
|
/* 30a30: 03e00008 */ jr $ra
|
|
/* 30a34: 27bd0088 */ addiu $sp,$sp,0x88
|
|
);
|
|
#endif
|
|
|
|
u32 cd0002f2e8(u32 arg0, u32 arg1, u32 arg2, u32 arg3)
|
|
{
|
|
return arg0;
|
|
}
|
|
|
|
void func0002f2fc(u32 arg0, u32 arg1)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
bool cd0002f308(struct coord *viewpos, s16 *rooms, struct coord *targetpos, f32 distance, s32 arg4, u16 arg5)
|
|
{
|
|
struct coord diff;
|
|
f32 x;
|
|
f32 z;
|
|
struct coord vector;
|
|
|
|
if (cd0002db98(viewpos, rooms, targetpos, arg4, arg5)) {
|
|
return true;
|
|
}
|
|
|
|
vector.x = targetpos->x - viewpos->x;
|
|
vector.y = 0;
|
|
vector.z = targetpos->z - viewpos->z;
|
|
|
|
guNormalize(&vector.x, &vector.y, &vector.z);
|
|
|
|
x = vector.f[0] * distance;
|
|
z = vector.f[2] * distance;
|
|
|
|
diff.x = targetpos->x - z;
|
|
diff.y = targetpos->y;
|
|
diff.z = targetpos->z + x;
|
|
|
|
if (cd0002db98(viewpos, rooms, &diff, arg4, arg5)) {
|
|
return true;
|
|
}
|
|
|
|
diff.x = targetpos->x + z;
|
|
diff.y = targetpos->y;
|
|
diff.z = targetpos->z - x;
|
|
|
|
if (cd0002db98(viewpos, rooms, &diff, arg4, arg5)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool cd0002f450(struct coord *viewpos, s16 *rooms, struct coord *targetpos, f32 distance, s32 arg4)
|
|
{
|
|
return cd0002f308(viewpos, rooms, targetpos, distance, arg4, 8);
|
|
}
|