mirror of
https://github.com/zeldaret/tww.git
synced 2026-06-14 14:08:07 -04:00
766 lines
26 KiB
C++
766 lines
26 KiB
C++
//
|
|
// Generated by dtk
|
|
// Translation Unit: c_bg_w.cpp
|
|
//
|
|
|
|
#include "SSystem/SComponent/c_bg_w.h"
|
|
#include "SSystem/SComponent/c_bg_s_gnd_chk.h"
|
|
#include "SSystem/SComponent/c_bg_s_lin_chk.h"
|
|
#include "SSystem/SComponent/c_bg_s_shdw_draw.h"
|
|
#include "SSystem/SComponent/c_m3d_g_tri.h"
|
|
#include "SSystem/SComponent/c_math.h"
|
|
#include "JSystem/JUtility/JUTAssert.h"
|
|
#include "JSystem/JKernel/JKRHeap.h"
|
|
#include "m_Do/m_Do_printf.h"
|
|
#include "m_Do/m_Do_mtx.h"
|
|
#include "dolphin/mtx/mtxvec.h"
|
|
#include "dolphin/types.h"
|
|
|
|
/* 80247500-8024754C .text ASSERT_SOLDHEAP__Fv */
|
|
void ASSERT_SOLDHEAP() {
|
|
if (JKRHeap::sCurrentHeap->getHeapType() != 'SLID')
|
|
OSReport_Error("*******Aバグです*******\n*******Aバグです*******\n*******Aバグです*******\ncBgWはカレントヒープがソリッドヒープ以外だと破綻します。\n必ず、カレントヒープをソリッドヒープにしてください。\nここでnewされた領域は二度と開放されることはありません。\n慢性的にメモリーリークを繰り返し、いずれ確実にAバグを引き起こすことでしょう。\n必ずp修正してください。この下の水色のメッセージにアクターの名前が書いてあるはずです。\n");
|
|
}
|
|
|
|
/* 8024754C-8024760C .text __ct__4cBgWFv */
|
|
cBgW::cBgW() {
|
|
pm_bgd = NULL;
|
|
mFlags = GLOBAL_e;
|
|
mbNeedsFullTransform = true;
|
|
mMoveCounter = 0;
|
|
mTransVel.setall(0.0f);
|
|
pm_tri = NULL;
|
|
pm_rwg = NULL;
|
|
pm_blk = NULL;
|
|
m_nt_tbl = NULL;
|
|
pm_grp = NULL;
|
|
pm_vtx_tbl = NULL;
|
|
pm_base = NULL;
|
|
mDoMtx_identity(mOldMtx);
|
|
mDoMtx_identity(mCurMtx);
|
|
m_rootGrpIdx = 0xFFFF;
|
|
mWallCorrectPriority = 2;
|
|
mIgnorePlaneType = 0;
|
|
}
|
|
|
|
/* 8024760C-8024767C .text __dt__4cBgWFv */
|
|
cBgW::~cBgW() {
|
|
FreeArea();
|
|
}
|
|
|
|
/* 8024767C-8024769C .text FreeArea__4cBgWFv */
|
|
void cBgW::FreeArea() {
|
|
pm_tri = NULL;
|
|
pm_rwg = NULL;
|
|
m_nt_tbl = NULL;
|
|
pm_blk = NULL;
|
|
pm_grp = NULL;
|
|
pm_vtx_tbl = NULL;
|
|
}
|
|
|
|
/* 8024769C-8024775C .text GlobalVtx__4cBgWFv */
|
|
void cBgW::GlobalVtx() {
|
|
if (pm_base != NULL) {
|
|
if (!mbNeedsFullTransform) {
|
|
for (s32 i = 0; i < pm_bgd->m_v_num; i++)
|
|
VECAdd(&pm_vtx_tbl[i], &mTransVel, &pm_vtx_tbl[i]);
|
|
} else {
|
|
for (s32 i = 0; i < pm_bgd->m_v_num; i++)
|
|
MTXMultVec(*pm_base, &pm_bgd->m_v_tbl[i], &pm_vtx_tbl[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 8024775C-80247840 .text SetVtx__4cBgWFv */
|
|
bool cBgW::SetVtx() {
|
|
ASSERT_SOLDHEAP();
|
|
if (mFlags & NO_VTX_TBL_e) {
|
|
pm_vtx_tbl = NULL;
|
|
} else {
|
|
if (ChkMoveBg()) {
|
|
pm_vtx_tbl = new Vec[pm_bgd->m_v_num];
|
|
if (pm_vtx_tbl == NULL)
|
|
return true;
|
|
|
|
if (mFlags & UNK40_e) {
|
|
for (s32 i = 0; i < pm_bgd->m_v_num; i++) {
|
|
pm_vtx_tbl[i].x = 0.0f;
|
|
pm_vtx_tbl[i].y = 0.0f;
|
|
pm_vtx_tbl[i].z = 0.0f;
|
|
}
|
|
}
|
|
GlobalVtx();
|
|
} else {
|
|
pm_vtx_tbl = pm_bgd->m_v_tbl;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* 80247840-80247944 .text CalcPlane__4cBgWFv */
|
|
void cBgW::CalcPlane() {
|
|
const cBgD_Tri_t* t_tbl = pm_bgd->m_t_tbl;
|
|
|
|
if (pm_vtx_tbl == NULL)
|
|
return;
|
|
|
|
if (!mbNeedsFullTransform) {
|
|
for (s32 i = 0; i < pm_bgd->m_t_num; i++) {
|
|
f32 dot = VECDotProduct(pm_tri[i].m_plane.GetNP(), &mTransVel);
|
|
pm_tri[i].m_plane.mD -= dot;
|
|
}
|
|
} else {
|
|
for (s32 i = 0; i < pm_bgd->m_t_num; i++) {
|
|
cBgW_TriElm* tri_elm = &pm_tri[i];
|
|
cM3d_CalcPla(&pm_vtx_tbl[t_tbl[i].vtx0], &pm_vtx_tbl[t_tbl[i].vtx1], &pm_vtx_tbl[t_tbl[i].vtx2], tri_elm->m_plane.GetNP(), &tri_elm->m_plane.mD);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 80247944-802479D8 .text SetTri__4cBgWFv */
|
|
bool cBgW::SetTri() {
|
|
ASSERT_SOLDHEAP();
|
|
pm_tri = new cBgW_TriElm[pm_bgd->m_t_num];
|
|
if (pm_tri == NULL)
|
|
return true;
|
|
CalcPlane();
|
|
return false;
|
|
}
|
|
|
|
/* 802479D8-80247A24 .text BlckConnect__4cBgWFPUsPii */
|
|
void cBgW::BlckConnect(u16* rwg, int* prev, int i_no) {
|
|
if (*rwg == 0xFFFF)
|
|
*rwg = i_no;
|
|
if (*prev != 0xFFFF)
|
|
pm_rwg[*prev].next = i_no;
|
|
*prev = i_no;
|
|
pm_rwg[*prev].next = -1;
|
|
}
|
|
|
|
inline bool cBgW_CheckBGround(f32 ny) {
|
|
return ny >= 0.5f;
|
|
}
|
|
|
|
inline bool cBgW_CheckBRoof(f32 ny) {
|
|
return ny < (-4.0f / 5.0f);
|
|
}
|
|
|
|
/* 80247A24-80247BF8 .text ClassifyPlane__4cBgWFv */
|
|
void cBgW::ClassifyPlane() {
|
|
if (pm_vtx_tbl == NULL)
|
|
return;
|
|
|
|
s32 i = 0;
|
|
|
|
int roof, wall, ground;
|
|
for (; i < pm_bgd->m_b_num; i++) {
|
|
s32 startTri = pm_bgd->m_b_tbl[i].startTri;
|
|
s32 lastTri;
|
|
if (i != pm_bgd->m_b_num - 1)
|
|
lastTri = pm_bgd->m_b_tbl[i + 1].startTri - 1;
|
|
else
|
|
lastTri = pm_bgd->m_t_num - 1;
|
|
|
|
pm_blk[i].roof = 0xFFFF;
|
|
pm_blk[i].wall = 0xFFFF;
|
|
pm_blk[i].ground = 0xFFFF;
|
|
|
|
ground = 0xFFFF;
|
|
wall = 0xFFFF;
|
|
roof = 0xFFFF;
|
|
|
|
for (s32 j = startTri; j <= lastTri; j++) {
|
|
cBgW_TriElm* tri_elm = &pm_tri[j];
|
|
|
|
f32 ny = tri_elm->m_plane.GetNP()->y;
|
|
if (cM3d_IsZero(tri_elm->m_plane.GetNP()->x) && cM3d_IsZero(tri_elm->m_plane.GetNP()->y) && cM3d_IsZero(tri_elm->m_plane.GetNP()->z))
|
|
continue;
|
|
|
|
if (cBgW_CheckBGround(ny)) {
|
|
if (!(mIgnorePlaneType & 1))
|
|
BlckConnect(&pm_blk[i].ground, &ground, j);
|
|
} else if (cBgW_CheckBRoof(ny)) {
|
|
if (!(mIgnorePlaneType & 4))
|
|
BlckConnect(&pm_blk[i].roof, &roof, j);
|
|
} else {
|
|
if (!(mIgnorePlaneType & 2))
|
|
BlckConnect(&pm_blk[i].wall, &wall, j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 80247BF8-80247C4C .text MakeBlckTransMinMax__4cBgWFP4cXyzP4cXyz */
|
|
void cBgW::MakeBlckTransMinMax(cXyz* min, cXyz* max) {
|
|
VECAdd(min, &mTransVel, min);
|
|
VECAdd(max, &mTransVel, max);
|
|
}
|
|
|
|
/* 80247C4C-80247CD4 .text MakeBlckMinMax__4cBgWFiP4cXyzP4cXyz */
|
|
void cBgW::MakeBlckMinMax(int i_no, cXyz* min, cXyz* max) {
|
|
Vec* vtx = &pm_vtx_tbl[i_no];
|
|
if (min->x > vtx->x) min->x = vtx->x;
|
|
if (max->x < vtx->x) max->x = vtx->x;
|
|
if (min->y > vtx->y) min->y = vtx->y;
|
|
if (max->y < vtx->y) max->y = vtx->y;
|
|
if (min->z > vtx->z) min->z = vtx->z;
|
|
if (max->z < vtx->z) max->z = vtx->z;
|
|
}
|
|
|
|
/* 80247CD4-80247E48 .text MakeBlckBnd__4cBgWFiP4cXyzP4cXyz */
|
|
void cBgW::MakeBlckBnd(int i, cXyz* min, cXyz* max) {
|
|
s32 startTri = pm_bgd->m_b_tbl[i].startTri;
|
|
s32 lastTri = (i != pm_bgd->m_b_num - 1) ? pm_bgd->m_b_tbl[i + 1].startTri - 1 : pm_bgd->m_t_num - 1;
|
|
|
|
if (!mbNeedsFullTransform) {
|
|
MakeBlckTransMinMax(min, max);
|
|
} else {
|
|
min->x = min->y = min->z = 1000000000.0f;
|
|
max->x = max->y = max->z = -1000000000.0f;
|
|
|
|
for (s32 j = startTri; j <= lastTri; j++) {
|
|
MakeBlckMinMax(pm_bgd->m_t_tbl[j].vtx0, min, max);
|
|
MakeBlckMinMax(pm_bgd->m_t_tbl[j].vtx1, min, max);
|
|
MakeBlckMinMax(pm_bgd->m_t_tbl[j].vtx2, min, max);
|
|
}
|
|
|
|
min->x -= 1.0f;
|
|
min->y -= 1.0f;
|
|
min->z -= 1.0f;
|
|
max->x += 1.0f;
|
|
max->y += 1.0f;
|
|
max->z += 1.0f;
|
|
}
|
|
}
|
|
|
|
/* 80247E48-80247F4C .text MakeNodeTreeRp__4cBgWFi */
|
|
void cBgW::MakeNodeTreeRp(int i) {
|
|
const cBgD_Tree_t* tree = &pm_bgd->m_tree_tbl[i];
|
|
if (tree->mFlag & 1) {
|
|
// leaf
|
|
s32 block = tree->mBlock;
|
|
if (block != 0xFFFF) {
|
|
MakeBlckBnd(tree->mBlock, m_nt_tbl[i].GetMinP(), m_nt_tbl[i].GetMaxP());
|
|
}
|
|
} else {
|
|
// branch
|
|
m_nt_tbl[i].ClearForMinMax();
|
|
for (s32 j = 0; j < 8; j++) {
|
|
s32 child = tree->mChild[j];
|
|
if (child == 0xFFFF)
|
|
continue;
|
|
MakeNodeTreeRp(child);
|
|
m_nt_tbl[i].SetMinMax(*m_nt_tbl[child].GetMinP());
|
|
m_nt_tbl[i].SetMinMax(*m_nt_tbl[child].GetMaxP());
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 80247F4C-80248078 .text MakeNodeTreeGrpRp__4cBgWFi */
|
|
void cBgW::MakeNodeTreeGrpRp(int grp_id) {
|
|
u32 tree_idx = pm_bgd->m_g_tbl[grp_id].m_tree_idx;
|
|
if (tree_idx != 0xFFFF) {
|
|
MakeNodeTreeRp(tree_idx);
|
|
pm_grp[grp_id].aab.SetMin(*m_nt_tbl[pm_bgd->m_g_tbl[grp_id].m_tree_idx].GetMinP());
|
|
pm_grp[grp_id].aab.SetMax(*m_nt_tbl[pm_bgd->m_g_tbl[grp_id].m_tree_idx].GetMaxP());
|
|
}
|
|
|
|
s32 child_idx = pm_bgd->m_g_tbl[grp_id].m_first_child;
|
|
while (true) {
|
|
if (child_idx == 0xFFFF)
|
|
break;
|
|
MakeNodeTreeGrpRp(child_idx);
|
|
pm_grp[grp_id].aab.SetMin(*pm_grp[child_idx].aab.GetMinP());
|
|
pm_grp[grp_id].aab.SetMax(*pm_grp[child_idx].aab.GetMaxP());
|
|
child_idx = pm_bgd->m_g_tbl[child_idx].m_next_sibling;
|
|
}
|
|
}
|
|
|
|
/* 80248078-80248178 .text MakeNodeTree__4cBgWFv */
|
|
void cBgW::MakeNodeTree() {
|
|
if (pm_vtx_tbl == NULL) {
|
|
for (s32 i = 0; i < pm_bgd->m_g_num; i++) {
|
|
if (pm_bgd->m_g_tbl[i].m_parent == 0xFFFF) {
|
|
m_rootGrpIdx = i;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for (s32 i = 0; i < pm_bgd->m_g_num; i++) {
|
|
pm_grp[i].aab.ClearForMinMax();
|
|
}
|
|
|
|
for (s32 i = 0; i < pm_bgd->m_g_num; i++) {
|
|
if (pm_bgd->m_g_tbl[i].m_parent == 0xFFFF) {
|
|
m_rootGrpIdx = i;
|
|
MakeNodeTreeGrpRp(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 80248178-802481C4 .text ChkMemoryError__4cBgWFv */
|
|
bool cBgW::ChkMemoryError() {
|
|
if (pm_tri == NULL || pm_rwg == NULL || pm_blk == NULL || m_nt_tbl == NULL || pm_grp == NULL)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/* 802481C4-80248414 .text Set__4cBgWFP6cBgD_tUlPA3_A4_f */
|
|
bool cBgW::Set(cBgD_t* bgd, u32 flag, Mtx* mtx) {
|
|
ASSERT_SOLDHEAP();
|
|
mFlags = GLOBAL_e;
|
|
pm_vtx_tbl = NULL;
|
|
pm_tri = NULL;
|
|
pm_rwg = NULL;
|
|
pm_blk = NULL;
|
|
m_nt_tbl = NULL;
|
|
pm_grp = NULL;
|
|
mMoveCounter = cM_rndF(128.0f);
|
|
if (bgd == NULL)
|
|
return true;
|
|
|
|
mFlags = flag;
|
|
if (mFlags & GLOBAL_e) {
|
|
pm_base = NULL;
|
|
mDoMtx_identity(mOldMtx);
|
|
mDoMtx_identity(mCurMtx);
|
|
} else {
|
|
pm_base = mtx;
|
|
mDoMtx_copy(*pm_base, mOldMtx);
|
|
mDoMtx_copy(*pm_base, mCurMtx);
|
|
}
|
|
|
|
pm_bgd = bgd;
|
|
if (SetVtx() || SetTri()) {
|
|
FreeArea();
|
|
return true;
|
|
}
|
|
|
|
pm_rwg = new cBgW_RwgElm[pm_bgd->m_t_num];
|
|
if (pm_rwg == NULL) {
|
|
FreeArea();
|
|
return true;
|
|
}
|
|
|
|
pm_blk = new cBgW_BlkElm[pm_bgd->m_b_num];
|
|
if (pm_blk == NULL) {
|
|
FreeArea();
|
|
return true;
|
|
}
|
|
|
|
m_nt_tbl = new cBgW_NodeTree[pm_bgd->m_tree_num];
|
|
if (m_nt_tbl == NULL) {
|
|
FreeArea();
|
|
return true;
|
|
}
|
|
|
|
pm_grp = new cBgW_GrpElm[pm_bgd->m_g_num];
|
|
if (pm_grp == NULL) {
|
|
FreeArea();
|
|
return true;
|
|
}
|
|
|
|
ClassifyPlane();
|
|
mbNeedsFullTransform = true;
|
|
MakeNodeTree();
|
|
return false;
|
|
}
|
|
|
|
/* 80248414-802485FC .text RwgLineCheck__4cBgWFUsP11cBgS_LinChk */
|
|
bool cBgW::RwgLineCheck(u16 poly_index, cBgS_LinChk* chk) {
|
|
bool ret = false;
|
|
cM3dGTri gtri;
|
|
|
|
cM3dGLin *lin = chk->GetLinP();
|
|
while (true) {
|
|
cBgW_TriElm* tri_elm;
|
|
cBgD_Tri_t* tri;
|
|
|
|
tri = &pm_bgd->m_t_tbl[poly_index];
|
|
tri_elm = &pm_tri[poly_index];
|
|
|
|
gtri.setBg(&pm_vtx_tbl[tri->vtx0], &pm_vtx_tbl[tri->vtx1], &pm_vtx_tbl[tri->vtx2], &tri_elm->m_plane);
|
|
bool backFlag = chk->ChkBackFlag();
|
|
bool frontFlag = chk->ChkFrontFlag();
|
|
|
|
cXyz pt;
|
|
if (cM3d_Cross_LinTri(lin, >ri, &pt, frontFlag, backFlag) && !ChkPolyThrough(poly_index, chk->GetPolyPassChk())) {
|
|
chk->GetLinP()->SetEnd(pt);
|
|
chk->SetPolyIndex(poly_index);
|
|
ret = true;
|
|
}
|
|
|
|
if (pm_rwg[poly_index].next == 0xFFFF)
|
|
break;
|
|
|
|
poly_index = pm_rwg[poly_index].next;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void dummy() {
|
|
// 0 <= bg_index
|
|
cBgS_PolyInfo pi;
|
|
pi.SetActorInfo(-1, NULL, 0);
|
|
}
|
|
|
|
/* 802485FC-80248868 .text LineCheckRp__4cBgWFP11cBgS_LinChki */
|
|
bool cBgW::LineCheckRp(cBgS_LinChk* chk, int i) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[i];
|
|
if (!cM3d_Cross_MinMaxBoxLine(node->GetMinP(), node->GetMaxP(), chk->GetLinP()->GetStartP(), chk->GetLinP()->GetEndP()))
|
|
return false;
|
|
|
|
cBgD_Tree_t* tree = &pm_bgd->m_tree_tbl[i];
|
|
bool ret = false;
|
|
if (tree->mFlag & 1) {
|
|
if (chk->mPreWallChk && pm_blk[tree->mBlock].wall != 0xFFFF && RwgLineCheck(pm_blk[tree->mBlock].wall, chk))
|
|
ret = true;
|
|
if (chk->mPreGroundChk && pm_blk[tree->mBlock].ground != 0xFFFF && RwgLineCheck(pm_blk[tree->mBlock].ground, chk))
|
|
ret = true;
|
|
if (chk->mPreRoofChk && pm_blk[tree->mBlock].roof != 0xFFFF && RwgLineCheck(pm_blk[tree->mBlock].roof, chk))
|
|
ret = true;
|
|
return ret;
|
|
} else {
|
|
// was this manually unrolled?
|
|
if (tree->mChild[0] != 0xFFFF && LineCheckRp(chk, tree->mChild[0]))
|
|
ret = true;
|
|
if (tree->mChild[1] != 0xFFFF && LineCheckRp(chk, tree->mChild[1]))
|
|
ret = true;
|
|
if (tree->mChild[2] != 0xFFFF && LineCheckRp(chk, tree->mChild[2]))
|
|
ret = true;
|
|
if (tree->mChild[3] != 0xFFFF && LineCheckRp(chk, tree->mChild[3]))
|
|
ret = true;
|
|
if (tree->mChild[4] != 0xFFFF && LineCheckRp(chk, tree->mChild[4]))
|
|
ret = true;
|
|
if (tree->mChild[5] != 0xFFFF && LineCheckRp(chk, tree->mChild[5]))
|
|
ret = true;
|
|
if (tree->mChild[6] != 0xFFFF && LineCheckRp(chk, tree->mChild[6]))
|
|
ret = true;
|
|
if (tree->mChild[7] != 0xFFFF && LineCheckRp(chk, tree->mChild[7]))
|
|
ret = true;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* 80248868-8024898C .text LineCheckGrpRp__4cBgWFP11cBgS_LinChkii */
|
|
bool cBgW::LineCheckGrpRp(cBgS_LinChk* chk, int grp_id, int depth) {
|
|
if (ChkGrpThrough(grp_id, chk->GetGrpPassChk(), depth))
|
|
return false;
|
|
|
|
if (!pm_grp[grp_id].aab.Cross(chk->GetLinP()))
|
|
return false;
|
|
|
|
bool ret = false;
|
|
u16 tree = pm_bgd->m_g_tbl[grp_id].m_tree_idx;
|
|
if (tree != 0xFFFF && LineCheckRp(chk, tree))
|
|
ret = true;
|
|
|
|
s32 child_idx = pm_bgd->m_g_tbl[grp_id].m_first_child;
|
|
while (true) {
|
|
if (child_idx == 0xFFFF)
|
|
break;
|
|
if (LineCheckGrpRp(chk, child_idx, depth + 1))
|
|
ret = true;
|
|
child_idx = pm_bgd->m_g_tbl[child_idx].m_next_sibling;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* 8024898C-80248AB8 .text RwgGroundCheckCommon__4cBgWFfUsP11cBgS_GndChk */
|
|
bool cBgW::RwgGroundCheckCommon(f32 y, u16 poly_index, cBgS_GndChk* chk) {
|
|
if (y < chk->GetPointP()->y && y > chk->GetNowY()) {
|
|
cBgD_Tri_t* tri = &pm_bgd->m_t_tbl[poly_index];
|
|
if (cM3d_CrossY_Tri_Front(pm_vtx_tbl[tri->vtx0], pm_vtx_tbl[tri->vtx1], pm_vtx_tbl[tri->vtx2], &chk->m_pos) && !ChkPolyThrough(poly_index, chk->GetPolyPassChk())) {
|
|
chk->SetNowY(y);
|
|
chk->SetPolyIndex(poly_index);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* 80248AB8-80248B68 .text RwgGroundCheckGnd__4cBgWFUsP11cBgS_GndChk */
|
|
bool cBgW::RwgGroundCheckGnd(u16 poly_index, cBgS_GndChk* chk) {
|
|
bool ret = false;
|
|
while (true) {
|
|
cBgW_RwgElm* rwg = &pm_rwg[poly_index];
|
|
cBgW_TriElm* tri = &pm_tri[poly_index];
|
|
f32 y = tri->m_plane.getCrossY_NonIsZero(*chk->GetPointP());
|
|
if (RwgGroundCheckCommon(y, (u16)poly_index, chk))
|
|
ret = true;
|
|
if (rwg->next == 0xFFFF)
|
|
break;
|
|
poly_index = rwg->next;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* 80248B68-80248C38 .text RwgGroundCheckWall__4cBgWFUsP11cBgS_GndChk */
|
|
bool cBgW::RwgGroundCheckWall(u16 poly_index, cBgS_GndChk* chk) {
|
|
bool ret = false;
|
|
while (true) {
|
|
cBgW_TriElm* tri = &pm_tri[poly_index];
|
|
cBgW_RwgElm* rwg = &pm_rwg[poly_index];
|
|
if (tri->m_plane.mNormal.y >= 0.014f && RwgGroundCheckCommon(tri->m_plane.getCrossY_NonIsZero(*chk->GetPointP()), (u16)poly_index, chk))
|
|
ret = true;
|
|
if (rwg->next == 0xFFFF)
|
|
break;
|
|
poly_index = rwg->next;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* 80248C38-802491F4 .text GroundCrossRp__4cBgWFP11cBgS_GndChki */
|
|
bool cBgW::GroundCrossRp(cBgS_GndChk* chk, int i) {
|
|
bool ret = false;
|
|
cBgD_Tree_t* tree = &pm_bgd->m_tree_tbl[i];
|
|
if (tree->mFlag & 1) {
|
|
if (chk->GetGndPrecheck() && pm_blk[tree->mBlock].ground != 0xFFFF && RwgGroundCheckGnd(pm_blk[tree->mBlock].ground, chk))
|
|
ret = true;
|
|
if (chk->GetWallPrecheck() && pm_blk[tree->mBlock].wall != 0xFFFF && RwgGroundCheckWall(pm_blk[tree->mBlock].wall, chk))
|
|
ret = true;
|
|
return ret;
|
|
} else {
|
|
if (tree->mChild[2] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[2]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[2]))
|
|
ret = true;
|
|
}
|
|
|
|
if (tree->mChild[3] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[3]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[3]))
|
|
ret = true;
|
|
}
|
|
|
|
if (tree->mChild[6] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[6]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[6]))
|
|
ret = true;
|
|
}
|
|
|
|
if (tree->mChild[7] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[7]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[7]))
|
|
ret = true;
|
|
}
|
|
|
|
if (tree->mChild[0] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[0]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[0]))
|
|
ret = true;
|
|
}
|
|
|
|
if (tree->mChild[1] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[1]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[1]))
|
|
ret = true;
|
|
}
|
|
|
|
if (tree->mChild[4] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[4]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[4]))
|
|
ret = true;
|
|
}
|
|
|
|
if (tree->mChild[5] != 0xFFFF) {
|
|
cBgW_NodeTree* node = &m_nt_tbl[tree->mChild[5]];
|
|
if (node->CrossY(chk->GetPointP()) && node->UnderPlaneYUnder(chk->GetPointP()->y) && !node->TopPlaneYUnder(chk->mNowY) && GroundCrossRp(chk, tree->mChild[5]))
|
|
ret = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* 802491F4-80249368 .text GroundCrossGrpRp__4cBgWFP11cBgS_GndChkii */
|
|
bool cBgW::GroundCrossGrpRp(cBgS_GndChk* chk, int grp_id, int depth) {
|
|
if (ChkGrpThrough(grp_id, chk->GetGrpPassChk(), depth))
|
|
return false;
|
|
|
|
cBgW_GrpElm* grp = &pm_grp[grp_id];
|
|
|
|
if (!grp->aab.CrossY(chk->GetPointP()) || !grp->aab.UnderPlaneYUnder(chk->GetPointP()->y) || grp->aab.TopPlaneYUnder(chk->mNowY))
|
|
return false;
|
|
|
|
bool ret = false;
|
|
u32 tree_idx = pm_bgd->m_g_tbl[grp_id].m_tree_idx;
|
|
if (tree_idx != 0xFFFF && GroundCrossRp(chk, tree_idx))
|
|
ret = true;
|
|
|
|
s32 child_idx = pm_bgd->m_g_tbl[grp_id].m_first_child;
|
|
while (true) {
|
|
if (child_idx == 0xFFFF)
|
|
break;
|
|
if (GroundCrossGrpRp(chk, child_idx, depth + 1))
|
|
ret = true;
|
|
child_idx = pm_bgd->m_g_tbl[child_idx].m_next_sibling;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* 80249368-802493B4 .text CopyOldMtx__4cBgWFv */
|
|
void cBgW::CopyOldMtx() {
|
|
if (pm_base != NULL) {
|
|
MTXCopy(mCurMtx, mOldMtx);
|
|
MTXCopy(*pm_base, mCurMtx);
|
|
}
|
|
}
|
|
|
|
/* 802493B4-80249584 .text Move__4cBgWFv */
|
|
void cBgW::Move() {
|
|
if (!ChkLock() && ChkMoveBg()) {
|
|
if (!ChkNoCalcVtx()) {
|
|
if (mMoveCounter >= 0xFF ||
|
|
mCurMtx[0][0] != (*pm_base)[0][0] || mCurMtx[0][1] != (*pm_base)[0][1] || mCurMtx[0][2] != (*pm_base)[0][2] ||
|
|
mCurMtx[1][0] != (*pm_base)[1][0] || mCurMtx[1][1] != (*pm_base)[1][1] || mCurMtx[1][2] != (*pm_base)[1][2] ||
|
|
mCurMtx[2][0] != (*pm_base)[2][0] || mCurMtx[2][1] != (*pm_base)[2][1] || mCurMtx[2][2] != (*pm_base)[2][2]) {
|
|
mbNeedsFullTransform = true;
|
|
} else if (mCurMtx[0][3] == (*pm_base)[0][3] && mCurMtx[1][3] == (*pm_base)[1][3] && mCurMtx[2][3] == (*pm_base)[2][3]) {
|
|
mDoMtx_copy(*pm_base, mOldMtx);
|
|
if (!ChkFlush())
|
|
return;
|
|
} else {
|
|
mTransVel.x = (*pm_base)[0][3] - mCurMtx[0][3];
|
|
mTransVel.y = (*pm_base)[1][3] - mCurMtx[1][3];
|
|
mTransVel.z = (*pm_base)[2][3] - mCurMtx[2][3];
|
|
mbNeedsFullTransform = false;
|
|
}
|
|
|
|
if (mMoveCounter >= 0xFF) {
|
|
mMoveCounter = 0;
|
|
} else {
|
|
mMoveCounter++;
|
|
}
|
|
|
|
GlobalVtx();
|
|
}
|
|
|
|
CopyOldMtx();
|
|
CalcPlane();
|
|
ClassifyPlane();
|
|
MakeNodeTree();
|
|
}
|
|
}
|
|
|
|
/* 80249584-80249698 .text RwgShdwDraw__4cBgWFiP13cBgS_ShdwDraw */
|
|
void cBgW::RwgShdwDraw(int index, cBgS_ShdwDraw* shdw) {
|
|
while (true) {
|
|
cBgW_RwgElm* rwg = &pm_rwg[index];
|
|
if (!ChkShdwDrawThrough(index, shdw->GetPolyPassChk())) {
|
|
const cBgD_Tri_t* tri = &pm_bgd->m_t_tbl[index];
|
|
shdw->mCallbackFun(shdw, (cBgD_Vtx_t*)pm_vtx_tbl, tri->vtx0, tri->vtx1, tri->vtx2, &pm_tri[index].m_plane);
|
|
}
|
|
if (rwg->next == 0xFFFF)
|
|
break;
|
|
index = rwg->next;
|
|
JUT_ASSERT(0xbc6, 0 <= index && index < pm_bgd->m_t_num);
|
|
}
|
|
}
|
|
|
|
/* 80249698-80249840 .text ShdwDrawRp__4cBgWFP13cBgS_ShdwDrawi */
|
|
void cBgW::ShdwDrawRp(cBgS_ShdwDraw* shdw, int i) {
|
|
if (!m_nt_tbl[i].Cross(shdw->GetBndP()))
|
|
return;
|
|
|
|
cBgD_Tree_t* tree = &pm_bgd->m_tree_tbl[i];
|
|
if (tree->mFlag & 1) {
|
|
if (pm_blk[tree->mBlock].wall != 0xFFFF)
|
|
RwgShdwDraw(pm_blk[tree->mBlock].wall, shdw);
|
|
if (pm_blk[tree->mBlock].roof != 0xFFFF)
|
|
RwgShdwDraw(pm_blk[tree->mBlock].roof, shdw);
|
|
if (pm_blk[tree->mBlock].ground != 0xFFFF)
|
|
RwgShdwDraw(pm_blk[tree->mBlock].ground, shdw);
|
|
} else {
|
|
if (tree->mChild[0] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[0]);
|
|
if (tree->mChild[1] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[1]);
|
|
if (tree->mChild[2] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[2]);
|
|
if (tree->mChild[3] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[3]);
|
|
if (tree->mChild[4] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[4]);
|
|
if (tree->mChild[5] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[5]);
|
|
if (tree->mChild[6] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[6]);
|
|
if (tree->mChild[7] != 0xFFFF)
|
|
ShdwDrawRp(shdw, tree->mChild[7]);
|
|
}
|
|
}
|
|
|
|
/* 80249840-80249904 .text ShdwDrawGrpRp__4cBgWFP13cBgS_ShdwDrawi */
|
|
void cBgW::ShdwDrawGrpRp(cBgS_ShdwDraw* shdw, int grp_id) {
|
|
if (!pm_grp[grp_id].aab.Cross(shdw->GetBndP()))
|
|
return;
|
|
|
|
u32 tree_idx = pm_bgd->m_g_tbl[grp_id].m_tree_idx;
|
|
if (tree_idx != 0xFFFF) {
|
|
ShdwDrawRp(shdw, tree_idx);
|
|
}
|
|
|
|
s32 child_idx = pm_bgd->m_g_tbl[grp_id].m_first_child;
|
|
while (true) {
|
|
if (child_idx == 0xFFFF)
|
|
break;
|
|
ShdwDrawGrpRp(shdw, child_idx);
|
|
child_idx = pm_bgd->m_g_tbl[child_idx].m_next_sibling;
|
|
}
|
|
}
|
|
|
|
/* 80249904-8024990C .text ChkPolyThrough__4cBgWFiP16cBgS_PolyPassChk */
|
|
bool cBgW::ChkPolyThrough(int, cBgS_PolyPassChk*) {
|
|
return false;
|
|
}
|
|
|
|
/* 8024990C-80249938 .text ChkShdwDrawThrough__4cBgWFiP16cBgS_PolyPassChk */
|
|
bool cBgW::ChkShdwDrawThrough(int param_0, cBgS_PolyPassChk* param_1) {
|
|
return ChkPolyThrough(param_0, param_1);
|
|
}
|
|
|
|
/* 80249938-80249940 .text ChkGrpThrough__4cBgWFiP15cBgS_GrpPassChki */
|
|
bool cBgW::ChkGrpThrough(int, cBgS_GrpPassChk*, int) {
|
|
return false;
|
|
}
|
|
|
|
/* 80249940-80249A18 .text GetGrpToRoomIndex__4cBgWCFi */
|
|
u32 cBgW::GetGrpToRoomIndex(int grp_index) const {
|
|
JUT_ASSERT(0xc77, 0 <= grp_index && grp_index < pm_bgd->m_g_num);
|
|
cBgD_Grp_t * g_tbl = pm_bgd->m_g_tbl;
|
|
if (g_tbl[grp_index].m_parent == 0xFFFF || g_tbl[g_tbl[grp_index].m_parent].m_parent == 0xFFFF)
|
|
return 0xFFFF;
|
|
return g_tbl[g_tbl[g_tbl[grp_index].m_parent].m_parent].m_room_id;
|
|
}
|
|
|
|
/* 80249A18-80249A58 .text GetTrans__4cBgWCFP4cXyz */
|
|
void cBgW::GetTrans(cXyz* dst) const {
|
|
dst->x = (*pm_base)[0][3] - mOldMtx[0][3];
|
|
dst->y = (*pm_base)[1][3] - mOldMtx[1][3];
|
|
dst->z = (*pm_base)[2][3] - mOldMtx[2][3];
|
|
}
|
|
|
|
/* 80249A58-80249B64 .text GetTriPnt__4cBgWCFiP4cXyzP4cXyzP4cXyz */
|
|
void cBgW::GetTriPnt(int i_no, cXyz* p0, cXyz* p1, cXyz* p2) const {
|
|
JUT_ASSERT(0xcb3, pm_bgd != NULL);
|
|
|
|
cBgD_Tri_t * tri = &pm_bgd->m_t_tbl[i_no];
|
|
p0->set(pm_vtx_tbl[tri->vtx0]);
|
|
p1->set(pm_vtx_tbl[tri->vtx1]);
|
|
p2->set(pm_vtx_tbl[tri->vtx2]);
|
|
}
|
|
|
|
/* 80249B64-80249BA0 .text GetTopUnder__4cBgWCFPfPf */
|
|
void cBgW::GetTopUnder(f32* max, f32* min) const {
|
|
*min = pm_grp[m_rootGrpIdx].aab.GetMinP()->y;
|
|
*max = pm_grp[m_rootGrpIdx].aab.GetMaxP()->y;
|
|
}
|