mirror/ss
1
0
Fork 0
mirror of https://github.com/zeldaret/ss synced 2026-09-12 12:25:34 -04:00
Code Issues Packages Projects Releases Wiki Activity

Updated CC collision (#80)

Browse Source 
* c_cc_d soooo close

* d_cc_shape_colliders -> d_cc_d

* ported over changes from #43

* Oops, didnt save

* use better collision functions in bombf

* bombf fixes

* bombf actorPostCreate matching

* fix

* small fix for cCcD_UnkAttr Set function

* more cleanup(?) for c_cc_d

* d_cc_mass_s OK

* Initial d_cc_s setup

* some easy funcs

---------

Co-authored-by: robojumper <robojumper@gmail.com>
This commit is contained in:
Elijah Thomas
2024-11-01 17:07:16 -04:00
committed by GitHub
parent 1d17e35316
commit 8a3710824b
74 changed files with 4523 additions and 1963 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/REL/d/a/d_a_bombf.cpp
+218 -1
View File
@@ -1,9 +1,226 @@
#include "d/a/d_a_bombf.h"
#include "common.h"
#include "d/a/d_a_player.h"
#include "d/col/bg/d_bg_s.h"
#include "d/col/bg/d_bg_s_lin_chk.h"
#include "d/flag/sceneflag_manager.h"
#include "m/m_mtx.h"
#include "m/m_vec.h"
#include "toBeSorted/time_area_mgr.h"
SPECIAL_ACTOR_PROFILE(BOMBF, dAcBombf_c, fProfile::BOMBF, 0x129, 0, 4099);
STATE_DEFINE(dAcBombf_c, Wait);
bool dAcBombf_c::createHeap() {
nw4r::g3d::ResFile resFile = getOarcResFile("FlowerBomb");
nw4r::g3d::ResMdl resMdl = resFile.GetResMdl("LeafBomb");
return mModel.create(resMdl, &heap_allocator, 0x120, 1, nullptr);
}
int dAcBombf_c::actorCreate() {
mDespawnSceneFlag = (params >> 8) & 0xFF;
field_0x3D4 = (params >> 16) & 0xF;
if (SceneflagManager::sInstance->checkBoolFlag(roomid, mDespawnSceneFlag)) {
return FAILED;
}
CREATE_ALLOCATOR(dAcBombf_c);
field_0x3D2 = (params >> 4) & 0xF;
field_0x3D0 = field_0x3D2 == 1;
if (field_0x3D0) {
mModel.setPriorityDraw(0x82, 0x7F);
}
mStts.SetDefaultRank();
forwardAccel = -2.0f;
forwardMaxSpeed = -80.0f;
mStateMgr.changeState(StateID_Wait);
boundingBox.Set(mVec3_c(-80.0, -50.0f, -80.0f), mVec3_c(80.0, 60.0f, 80.0f));
angle = rotation;
if (mDespawnSceneFlag < 0xFF) {
actor_properties = (actor_properties & ~1) | 4;
}
return SUCCEEDED;
}
int dAcBombf_c::actorPostCreate() {
// Preamble problem
mMtx_c mtx;
mtx.ZXYrotS(rotation.x, rotation.y, rotation.z);
mVec3_c v;
PSMTXMultVecSR(mtx, mVec3_c::Ey, v);
mVec3_c v3 = position + v * 10.0f;
mVec3_c v4 = position - v * 10.0f;
if (dBgS_ObjLinChk::LineCross(&v3, &v4, this)) {
position = dBgS_ObjLinChk::GetInstance().GetLinEnd();
if (rotation.x == 0 && rotation.z == 0 && dBgS_ObjLinChk::ChkGround()) {
cM3dGPla pla;
dBgS::GetInstance()->GetTriPla(dBgS_ObjLinChk::GetInstance(), &pla);
rotation.x = pla.GetAngle(rotation.y);
rotation.z = pla.GetAngle(rotation.y - 0x4000);
}
if (dBgS::GetInstance()->ChkMoveBG(dBgS_ObjLinChk::GetInstance(), false)) {
field_0x398.SetPolyInfo(dBgS_ObjLinChk::GetInstance());
actor_properties = (actor_properties & ~1) | 4;
}
mLightingInfo.mLightingCode = dBgS::GetInstance()->GetLightingCode(dBgS_ObjLinChk::GetInstance());
}
if (field_0x3D2 == 0 || field_0x3D2 == 2) {
bool b = dTimeAreaMgr_c::sInstance->fn_800B9B60(roomid, position);
if (b) {
mTimeAreaStruct.field_0x00 = 1.0f;
}
if ((b && field_0x3D2 == 2) || (!b && field_0x3D2 == 0)) {
mModel.setScale(0.0001f, 0.0001f, 0.0001f);
if (mBombRef.get() != nullptr) {
mBombRef.get()->mField_0xA50 = 0.0001f;
}
}
}
updateMatrix();
mModel.setLocalMtx(mWorldMtx);
regrowBomb();
if (mBombRef.get() != nullptr) {
mBombRef.get()->mScale.set(0.95f, 0.95f, 0.95f);
}
return SUCCEEDED;
}
int dAcBombf_c::doDelete() {
return SUCCEEDED;
}
int dAcBombf_c::actorExecute() {
if (field_0x3D3 != 0) {
mMtx_c &mtx = mWorldMtx;
mtx.getTranslation(position);
dAcBomb_c *bomb = mBombRef.get();
if (bomb != nullptr) {
bomb->setTransformFromFlower(mtx);
}
mModel.setLocalMtx(mWorldMtx);
poscopy2 = position;
poscopy3 = position;
field_0x3D3 = 0;
} else {
if (dBgS::GetInstance()->ChkMoveBG(field_0x398, true)) {
dBgS::GetInstance()->MoveBgTransPos(field_0x398, true, &position, &angle, &rotation);
updateMatrix();
dAcBomb_c *bomb = mBombRef.get();
if (bomb != nullptr) {
bomb->setTransformFromFlower(mWorldMtx);
}
mModel.setLocalMtx(mWorldMtx);
poscopy2 = position;
poscopy3 = position;
}
}
mStateMgr.executeState();
return SUCCEEDED;
}
int dAcBombf_c::draw() {
if (field_0x3D0 != 0 && (dAcPy_c::LINK->mActionFlagsCont & 0x400000) == 0) {
return SUCCEEDED;
}
drawModelType1(&mModel);
return SUCCEEDED;
}
void dAcBombf_c::regrowBomb() {
// These params are hell
s8 viewclip_idx = (actor_properties & 1) != 0 ? viewclip_index : -1;
u32 actorParams1;
actorParams1 = 1;
if (field_0x3D0) {
actorParams1 = 2;
}
dAcObjBase_c *ac = dAcObjBase_c::create(
"Bomb", roomid, actorParams1, &position, nullptr, nullptr, 0xFFFFFFFF, 0xFFFF, viewclip_idx
);
mBombRef.link(static_cast<dAcBomb_c *>(ac));
dAcBomb_c *bomb = mBombRef.get();
if (bomb != nullptr) {
field_0x394 = 0x3C;
bomb->setTransformFromFlower(mWorldMtx);
if ((actor_properties & 1) != 0) {
bomb->actor_properties |= 1;
}
if (field_0x3D4 == 0) {
bomb->mField_0xA44 *= 1.5f;
}
}
}
void dAcBombf_c::initializeState_Wait() {}
void dAcBombf_c::executeState_Wait() {}
extern "C" void fn_800298B0(u16, mVec3_c *, mVec3_c *, u32, u32, u32, u32, u32);
extern "C" u16 lbl_8057A750;
void dAcBombf_c::executeState_Wait() {
// Stack problems
if (SceneflagManager::sInstance->checkBoolFlag(roomid, mDespawnSceneFlag)) {
deleteRequest();
dAcBomb_c *bomb = mBombRef.get();
if (bomb != nullptr) {
bomb->deleteRequest();
bomb->mEffect1.remove(true);
bomb->mEffect2.remove(true);
}
return;
}
f32 scaleFactor = mScale.x;
if (field_0x3D2 == 0 || field_0x3D2 == 2) {
mVec3_c m;
PSMTXMultVecSR(mWorldMtx, mVec3_c::Ey, m);
mVec3_c m3 = position + (m * 30.0f);
if (mTimeAreaStruct.check(roomid, m3, 0, 30.0f, 0.1f) && field_0x3D4 != 1) {
if (mTimeAreaStruct.field_0x04 == 1) {
playSound(0xC0A);
} else {
playSound(0xC0B);
}
fn_800298B0(lbl_8057A750, &position, nullptr, 0, 0, 0, 0, 0);
}
scaleFactor *= mTimeAreaStruct.field_0x00;
if (field_0x3D2 == 2) {
scaleFactor = 1.0f - scaleFactor;
}
scaleFactor = nw4r::ut::Max(scaleFactor, 0.0001f);
mModel.setScale(scaleFactor, scaleFactor, scaleFactor);
}
dAcBomb_c *bomb = mBombRef.get();
if (bomb != nullptr) {
if (!bomb->mStateMgr.isState(dAcBomb_c::StateID_FlowerWait) && field_0x3D0 == 0) {
mBombRef.unlink();
field_0x394 = 0x3C;
}
} else {
if (field_0x394 != 0) {
field_0x394--;
} else if (field_0x3D0 == 0 || dAcPy_c::LINK->getSquareDistanceTo(position) > 22500.0f) {
regrowBomb();
}
}
bomb = mBombRef.get();
if (bomb != nullptr) {
bomb->mField_0xA50 = scaleFactor;
}
}
void dAcBombf_c::finalizeState_Wait() {}
src/REL/d/a/obj/d_a_obj_mole_soil.cpp
-5
View File
@@ -2,7 +2,6 @@
#include "s/s_Math.h"
SPECIAL_ACTOR_PROFILE(OBJ_MOLE_SOIL, dAcOmoleSoil_c, fProfile::OBJ_MOLE_SOIL, 0x008B, 0, 6);
STATE_DEFINE(dAcOmoleSoil_c, Wait);
@@ -24,10 +23,6 @@ bool dAcOmoleSoil_c::createHeap() {
return true;
}
bool intToBool(int a) {
return a;
}
int dAcOmoleSoil_c::create() {
CREATE_ALLOCATOR(dAcOmoleSoil_c);
src/REL/d/a/obj/d_a_obj_pool_cock.cpp
+1 -1
View File
@@ -50,7 +50,7 @@ int dAcOPoolCock_c::actorExecute() {
mStateMgr.executeState();
calcVelocity();
position += velocity;
position += mCCdStruct.posIncrements;
position += mStts.mCcMove;
updateMatrix();
mMtx_c mdl1Transform;
mMtx_c mdl2Transform;
src/REL/d/a/obj/d_a_obj_ring.cpp
+1 -1
View File
@@ -39,7 +39,7 @@ int dAcOring_c::actorExecute() {
mStateMgr.executeState();
calcVelocity();
position += velocity;
position += mCCdStruct.posIncrements;
position += mStts.mCcMove;
updateMatrix();
mModel.setLocalMtx(mWorldMtx);
return SUCCEEDED;
src/REL/d/a/obj/d_a_obj_spike.cpp
+11 -12
View File
@@ -1,14 +1,13 @@
#include "d/a/obj/d_a_obj_spike.h"
#include "d/col/cc/d_cc_mgr.h"
#include "d/col/cc/d_cc_s.h"
SPECIAL_ACTOR_PROFILE(OBJ_SPIKE, dAcOspike_c, fProfile::OBJ_SPIKE, 0x1D9, 0, 2);
// clang-format off
dCcD_SrcAabb dAcOspike_c::sCcSrc = {
{{{0x400}, 0x2003F, 0, 1, 0, 0, 0, 0, 0},
{{0xFEB77DFF}, 0x111, 0x06, 0x407, 0, 0},
dCcD_SrcUnk dAcOspike_c::sCcSrc = {
{{0x400, 0x2003F, {0, 0, 0}, 1, 0, 0, 0, 0},
{0xFEB77DFF, 0x111, 0x06, 0x407, 0, },
{0}},
{-1.0f, -246.0f, -472.0f, 73.0f, 255.0f, 482.0f}};
// clang-format on
@@ -30,15 +29,15 @@ int dAcOspike_c::create() {
return FAILED;
}
mCCdStruct.setField0x38ToMagicValue();
mCollision.init(sCcSrc);
mCollision.initUnk(mCCdStruct);
mStts.SetDefaultRank();
mCollision.Set(sCcSrc);
mCollision.SetStts(mStts);
updateMatrix();
mMdl.setLocalMtx(mWorldMtx);
mVec3_c tmp;
PSMTXMultVecSR(mWorldMtx.m, mVec3_c::Ex, tmp);
mCollision.setAtVec(tmp);
mCollision.SetAtVec(tmp);
mMtx_c mtx;
mtx.XrotS(rotation.x);
@@ -63,7 +62,7 @@ int dAcOspike_c::create() {
tmp3.z = copy;
}
mCollision.Set(tmp2, tmp3);
mCollision.cM3dGUnk::Set(tmp2, tmp3);
mStateMgr.changeState(StateID_Wait);
boundingBox.Set(mVec3_c(-10.0f, -250.0f, -480.0f), mVec3_c(80.0f, 260.0f, 490.0f));
return SUCCEEDED;
@@ -75,8 +74,8 @@ int dAcOspike_c::doDelete() {
int dAcOspike_c::actorExecute() {
mStateMgr.executeState();
mCollision.Set(position, rotation.y);
ColliderManager::getColliderManager()->addCollider(&mCollision);
mCollision.cM3dGUnk::Set(position, rotation.y);
dCcS::GetInstance()->Set(&mCollision);
return 1;
}
src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp
+43 -15
View File
@@ -1,13 +1,12 @@
#include "d/a/obj/d_a_obj_toD3_stone_figure.h"
#include "d/col/cc/d_cc_mgr.h"
#include "d/col/cc/d_cc_s.h"
#include "d/flag/storyflag_manager.h"
#include "toBeSorted/attention.h"
#include "toBeSorted/event.h"
#include "toBeSorted/event_manager.h"
#include "d/flag/storyflag_manager.h"
#include "toBeSorted/scgame.h"
SPECIAL_ACTOR_PROFILE(OBJ_TOD3_STONE, dAcOtoD3StoneFigure_c, fProfile::OBJ_TOD3_STONE, 0x1B3, 0, 0);
STATE_DEFINE(dAcOtoD3StoneFigure_c, OneEye);
@@ -18,10 +17,40 @@ f32 dAcOtoD3StoneFigure_c::sHeight = 290.0f;
// clang-format off
dCcD_SrcCyl dAcOtoD3StoneFigure_c::sCcSrc = {
{{{0}, 0, 0, 0, 0, 0, 0, 0, 0},
{{0xFEB77DFF}, 0x1000111, 0x06, 0x407, 0, 0},
{0xE9}},
{dAcOtoD3StoneFigure_c::sRadius, dAcOtoD3StoneFigure_c::sHeight}
{
{
0,
0,
{
0,
0,
0
},
0,
0,
0,
0,
0,
0
},
{
0xFEB77DFF,
0x1000111,
{
0x06,
0x407
},
0,
0
},
{
0xE9
}
},
{
dAcOtoD3StoneFigure_c::sRadius,
dAcOtoD3StoneFigure_c::sHeight
}
};
// clang-format on
@@ -42,16 +71,15 @@ int dAcOtoD3StoneFigure_c::create() {
}
mMdl.setLocalMtx(mWorldMtx);
mCCdStruct.setField0x38ToMagicValue();
mCollision.init(sCcSrc);
mCollision.initUnk(mCCdStruct);
mStts.SetDefaultRank();
mCollision.Set(sCcSrc);
mCollision.SetStts(mStts);
int zero = 0;
mCollision.SetC(position);
mCollision.SetR(dAcOtoD3StoneFigure_c::sRadius + zero);
mCollision.SetH(dAcOtoD3StoneFigure_c::sHeight + zero);
ColliderManager::getColliderManager()->addCollider(&mCollision);
// mCollision.clearCoFlag();
mCollision.setTgCoFlag(1);
dCcS::GetInstance()->Set(&mCollision);
mCollision.OnTgCoFlag(1);
// ???
f32 a, b, c;
@@ -66,7 +94,7 @@ int dAcOtoD3StoneFigure_c::create() {
poscopy3.y = b;
poscopy3.z = c;
// poscopy3 = poscopy2;
mCollision.setSomeDefendValue(0x2000);
mCollision.SetTg_0x4C(0x2000);
if (!mIsSkyKeepAlreadyOpen) {
mStateMgr.changeState(StateID_OneEye);
@@ -83,7 +111,7 @@ int dAcOtoD3StoneFigure_c::doDelete() {
int dAcOtoD3StoneFigure_c::actorExecute() {
mStateMgr.executeState();
ColliderManager::getColliderManager()->addCollider(&mCollision);
dCcS::GetInstance()->Set(&mCollision);
return SUCCEEDED;
}
src/REL/d/a/obj/d_a_obj_triforce.cpp
+9 -10
View File
@@ -1,16 +1,15 @@
#include "d/a/obj/d_a_obj_triforce.h"
#include "c/c_math.h"
#include "d/col/cc/d_cc_mgr.h"
#include "d/col/cc/d_cc_s.h"
#include "m/m_vec.h"
SPECIAL_ACTOR_PROFILE(OBJ_TRIFORCE, dAcOtriforce_c, fProfile::OBJ_TRIFORCE, 0x15D, 0, 4);
// clang-format off
dCcD_SrcSph dAcOtriforce_c::sCcSrc = {
{{{0}, 0, 0, 0, 0, 0, 0, 0, 0},
{{0xFEB77DFF}, 0x111, 0x06, 0x407, 0, 0},
{{0, 0, 0, 0, 0, 0, 0, 0, 0},
{0xFEB77DFF, 0x111, 0x06, 0x407, 0, 0},
{0xE9}},
{150.0f}};
// clang-format on
@@ -36,13 +35,13 @@ int dAcOtriforce_c::create() {
return FAILED;
}
mCCdStruct.setField0x38ToMagicValue();
mCollision.init(sCcSrc);
mCollision.initUnk(mCCdStruct);
mCollision.clearCoFlag();
mStts.SetDefaultRank();
mCollision.Set(sCcSrc);
mCollision.SetStts(mStts);
mCollision.ClrCoSet();
mStartingOffset = cM::rndInt(sStartingOffsetRange);
mEffects.init(this);
mCollision.setSomeDefendValue(0x2000);
mCollision.SetTg_0x4C(0x2000);
updateMatrix();
mScale.x = sScale;
mScale.y = sScale;
@@ -66,7 +65,7 @@ int dAcOtriforce_c::actorExecute() {
mCollision.SetC(position.x, position.y + 90.0f + zero, position.z);
ColliderManager::getColliderManager()->addCollider(&mCollision);
dCcS::GetInstance()->Set(&mCollision);
updateMatrix();
Mtx m;
PSMTXScale(m, mScale.x, mScale.y, mScale.z);
src/REL/d/t/d_t_reaction.cpp
+33 -31
View File
@@ -4,10 +4,9 @@
#include "c/c_math.h"
#include "d/a/d_a_player.h"
#include "d/a/obj/d_a_obj_item.h"
#include "d/col/cc/d_cc_mgr.h"
#include "d/col/cc/d_cc_s.h"
#include "d/flag/sceneflag_manager.h"
SPECIAL_ACTOR_PROFILE(TAG_REACTION, dTgReaction_c, fProfile::TAG_REACTION, 0x0151, 0, 0);
STATE_DEFINE(dTgReaction_c, Wait);
@@ -19,8 +18,8 @@ const f32 dTgReaction_c::sHeight = 100.0f;
// clang-format off
dCcD_SrcCyl dTgReaction_c::sCcSrc = {
{{{0}, 0, 0, 0, 0, 0, 0, 0, 0},
{{0x10000}, 0x213, 0, 0x8, 0x8, 0},
{{0, 0, 0, 0, 0, 0, 0, 0, 0},
{0x10000, 0x213, 0, 0x8, 0x8,},
{0xE8}},
{dTgReaction_c::sRadius, dTgReaction_c::sHeight}
};
@@ -43,7 +42,7 @@ int dTgReaction_c::create() {
return FAILED;
}
if (getReactType() != REACT_GUST_BELLOWS) {
if (getReactType() != REACT_UNDERWATER) {
if (getSceneFlag() >= 0xFF) {
return FAILED;
}
@@ -74,29 +73,31 @@ int dTgReaction_c::create() {
}
}
mCCdStruct.setField0x38(0);
mCollision.init(sCcSrc);
mCollision.initUnk(mCCdStruct);
mStts.SetRank(0);
mCollision.Set(sCcSrc);
mCollision.SetStts(mStts);
switch (getReactType()) {
case REACT_BONK:
mCollision.setTgFlag(0x80);
mCollision.setTgField0x0A(0);
mCollision.SetR(sCcSrc.mCylAttr.mRadius * mScale.x);
mCollision.SetH(mScale.y * sCcSrc.mCylAttr.mHeight);
break;
case REACT_SLINGSHOT:
mCollision.setTgFlag(0x10000);
mCollision.setTgField0x0A(8);
mCollision.SetR(sCcSrc.mCylAttr.mRadius * mScale.x);
mCollision.SetH(mScale.y * sCcSrc.mCylAttr.mHeight);
mCollision.SetTgFlag(0x80);
mCollision.SetTgFlag_0xA(0);
mCollision.SetR(sCcSrc.mCylInf.mRadius * mScale.x);
mCollision.SetH(sCcSrc.mCylInf.mHeight * mScale.y);
break;
case REACT_GUST_BELLOWS:
mCollision.setTgFlag(0x100000);
mCollision.setTgField0x0A(0);
mCollision.SetR(sCcSrc.mCylAttr.mRadius * mScale.x);
mCollision.SetH(mScale.y * sCcSrc.mCylAttr.mHeight);
mCollision.SetTgFlag(0x10000);
mCollision.SetTgFlag_0xA(8);
mCollision.SetR(sCcSrc.mCylInf.mRadius * mScale.x);
mCollision.SetH(sCcSrc.mCylInf.mHeight * mScale.y);
break;
case REACT_UNDERWATER:
mCollision.SetTgFlag(0x100000);
mCollision.SetTgFlag_0xA(0);
mCollision.SetR(sCcSrc.mCylInf.mRadius * mScale.x);
mCollision.SetH(sCcSrc.mCylInf.mHeight * mScale.y);
break;
case REACT_BONK:
case REACT_4: break;
}
int item = getParam0x10();
@@ -111,8 +112,8 @@ int dTgReaction_c::create() {
}
mVec3_c dwsOffset;
if (!getParam0x14()) {
field_0x4E4 = mScale.y * sCcSrc.mCylAttr.mHeight * 0.5f;
dwsOffset = mVec3_c(0.0f, 0.5f * sCcSrc.mCylAttr.mHeight, 0.0f);
field_0x4E4 = mScale.y * sCcSrc.mCylInf.mHeight * 0.5f;
dwsOffset = mVec3_c(0.0f, sCcSrc.mCylInf.mHeight * 0.5f, 0.0f);
} else {
dwsOffset = mVec3_c::Zero;
}
@@ -210,14 +211,14 @@ void dTgReaction_c::checkForBonkItem() {
}
void dTgReaction_c::checkForBubble() {
if (mCollision.someInteractCheck() && mCollision.CheckCollidedMask(0x100000)) {
if (mCollision.ChkTgHit() && mCollision.ChkTgAtHitType(0x100000)) {
if (dAcPy_c::LINK != nullptr && dAcPy_c::LINK->checkFlags0x350(0x40)) {
mVec3_c spawnPos = position;
dAcObjBase_c::create(fProfile::OBJ_BUBBLE, roomid, 0x4, &spawnPos, nullptr, nullptr, 0xFFFFFFFF);
}
}
mCollision.SetC(position);
ColliderManager::getColliderManager()->addCollider(&mCollision);
dCcS::GetInstance()->Set(&mCollision);
}
// TODO move this somewhere
@@ -230,14 +231,15 @@ T rndRange(T min, T max) {
}
void dTgReaction_c::checkForSlingBellowsItem() {
if (mCollision.someInteractCheck()) {
if (mCollision.ChkTgHit()) {
u8 p = getParam0x08();
u32 uVar3;
// mVec3_c pos = position;
int p = getParam0x08();
if (p == 0) {
uVar3 = 6;
} else if (uVar3 == 0xFF) {
uVar3 = 5;
} else {
uVar3 = p == 0xFF ? 5 : 6;
uVar3 = 6;
}
mVec3_c spawnPos = position;
spawnPos.y += field_0x4E4;
@@ -248,7 +250,7 @@ void dTgReaction_c::checkForSlingBellowsItem() {
onDelete();
}
mCollision.SetC(position);
ColliderManager::getColliderManager()->addCollider(&mCollision);
dCcS::GetInstance()->Set(&mCollision);
}
void dTgReaction_c::onDelete() {
src/REL/d/t/d_t_sound_area.cpp
+1 -1
View File
@@ -149,7 +149,7 @@ bool dTgSndAr_c::checkAlg3(const mVec3_c &pos) {
unk.Set(b, c, mScale.x * 100.0f);
f32 d;
if (cM3d_Len3dSqPntAndSegLine(&unk, &a, &q, &d, nullptr)) {
if (cM3d_Len3dSqPntAndSegLine(unk, a, q, &d, nullptr)) {
// At the cylindrical part of the capsule, just check the distance to
// the line
return d < radius;
src/d/a/d_a_base.cpp
+1 -1
View File
@@ -424,7 +424,7 @@ f32 dAcBase_c::getSquareDistToPlayer() {
// Some weirdness with the float registers being used
// 8002d4b0
void dAcBase_c::updateRoomId(f32 yOffset) {
if (getConnectParent()->profile_name != 701 /* fProfile::PROFILE_NAME_e::ROOM */) {
if (getConnectParent()->profile_name != fProfile::ROOM) {
mVec3_c actorPos(position.x, position.y + yOffset, position.z);
if (checkCollision(&actorPos)) {
src/d/a/obj/d_a_obj_arrow.cpp
+131
View File
@@ -0,0 +1,131 @@
#include "d/a/obj/d_a_obj_arrow.h"
#include "c/c_math.h"
#include "d/a/d_a_player.h"
#include "d/col/c/c_cc_d.h"
SPECIAL_ACTOR_PROFILE(ARROW, dAcArrow_c, fProfile::ARROW, 0x126, 0, 0x80);
STATE_DEFINE(dAcArrow_c, Wait);
STATE_DEFINE(dAcArrow_c, Move);
STATE_DEFINE(dAcArrow_c, ActorStop);
STATE_DEFINE(dAcArrow_c, BgStop);
STATE_DEFINE(dAcArrow_c, Bound);
// clang-format off
cCcD_SrcGObj dAcArrow_c::sCcSrcInf = {
{0x2000, 0x8BB, 0x15000000, 0, 0, 0, 0, 0, 0},
{0xFEB75C7F, 0x210, 0, 0x407, 0, 0},
{0},
};
dCcD_SrcCps dAcArrow_c::sCc1 = {
dAcArrow_c::sCcSrcInf,
{5.0f},
};
const dCcD_SrcSph dAcArrow_c::sCc2 = {
{{0x0, 0x0, 0x0, 0, 0, 0, 0, 0, 0},
{0x2, 0x211, 0, 0x407, 0, 0},
{0xC28}},
{100.0f},
};
// clang-format on
bool hitCallback(dAcObjBase_c *i_actorA, cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB) {
static_cast<dAcArrow_c *>(i_actorA)->hitCallback(i_objInfA, i_actorB, i_objInfB);
return true;
}
bool dAcArrow_c::createHeap() {
mResFile = getOarcResFile("Alink");
nw4r::g3d::ResMdl mdl(nullptr);
if ((mSubType & 0x10) != 0) {
mdl = mResFile.GetResMdl("EquipPachinkoBullet");
} else {
mdl = mResFile.GetResMdl("EquipArrow");
}
// ?
bool ok = mModel.create(mdl, &heap_allocator, 0x120);
if (!ok) {
ok = false;
}
return ok;
}
extern "C" void fn_8025E5E0(void *);
int dAcArrow_c::create() {
mSubType = params & 0xFF;
CREATE_ALLOCATOR(dAcArrow_c);
field_0x67C |= 4;
mStts.SetRank(2);
mCcCps.Set(sCc1);
mCcCps.SetStts(mStts);
mCcCps.SetAtFlag(0x2000);
mCcCps.SetAtCallback(::hitCallback);
mCcSph.Set(sCc2);
mCcSph.SetStts(mStts);
if (mSubType == 0x11) {
mStateMgr.changeState(StateID_Move);
} else {
mStateMgr.changeState(StateID_Wait);
}
boundingBox.Set(mVec3_c(-6.0f, -6.0f, 0.0f), mVec3_c(6.0f, 6.0f, 110.0f));
field_0x684 = -1;
field_0x68A = 300;
f32 rnd = cM::rndF(20.0f);
field_0x688 = 50.0f - rnd;
field_0x6A8 = 80.0f;
mDespawnTimer = 10;
fn_8025E5E0(this);
return SUCCEEDED;
}
dAcArrow_c::~dAcArrow_c() {}
void dAcArrow_c::hitCallback(cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB) {}
int dAcArrow_c::doDelete() {
// TODO
return SUCCEEDED;
}
int dAcArrow_c::actorExecute() {
mStateMgr.executeState();
// TODO
return SUCCEEDED;
}
int dAcArrow_c::draw() {
return SUCCEEDED;
}
void dAcArrow_c::initializeState_Wait() {}
void dAcArrow_c::executeState_Wait() {}
void dAcArrow_c::finalizeState_Wait() {}
void dAcArrow_c::initializeState_Move() {}
void dAcArrow_c::executeState_Move() {}
void dAcArrow_c::finalizeState_Move() {}
void dAcArrow_c::initializeState_ActorStop() {}
void dAcArrow_c::executeState_ActorStop() {}
void dAcArrow_c::finalizeState_ActorStop() {}
void dAcArrow_c::initializeState_BgStop() {}
void dAcArrow_c::executeState_BgStop() {}
void dAcArrow_c::finalizeState_BgStop() {}
void dAcArrow_c::initializeState_Bound() {}
void dAcArrow_c::executeState_Bound() {}
void dAcArrow_c::finalizeState_Bound() {}
src/d/a/obj/d_a_obj_bomb.cpp
+20
View File
@@ -0,0 +1,20 @@
#include "d/a/obj/d_a_obj_bomb.h"
#include "f/f_base.h"
#include "f/f_profile.h"
#include "f/f_profile_name.h"
#include "s/s_State.hpp"
SPECIAL_ACTOR_PROFILE(BOMB, dAcBomb_c, fProfile::BOMB, 0x128, 0, 2);
STATE_DEFINE(dAcBomb_c, Wait);
STATE_DEFINE(dAcBomb_c, FlowerWait);
STATE_DEFINE(dAcBomb_c, Explode);
STATE_DEFINE(dAcBomb_c, Carry);
STATE_DEFINE(dAcBomb_c, WindCarry);
bool dAcBomb_c::createHeap() {}
int dAcBomb_c::create() {
return SUCCEEDED;
}
src/d/a/obj/d_a_obj_fairy.cpp
+4 -5
View File
@@ -2,7 +2,6 @@
#include "d/a/d_a_player.h"
SPECIAL_ACTOR_PROFILE(OBJ_FAIRY, dAcObjFairy_c, fProfile::OBJ_FAIRY, 0x166, 0, 2);
STATE_DEFINE(dAcObjFairy_c, Wait);
@@ -53,7 +52,8 @@ int dAcObjFairy_c::draw() {
if (!isCuring()) {
static mQuat_c rot(0.0f, 0.0f, 0.0f, 10.0f);
drawShadow(mShadow, nullptr, mWorldMtx, &rot, -1, -1, -1, -1, -1, position.y - field_0x4B0);
f32 f = field_0x4B0;
drawShadow(mShadow, nullptr, mWorldMtx, &rot, -1, -1, -1, -1, -1, position.y - f);
}
}
@@ -96,14 +96,13 @@ void dAcObjFairy_c::executeState_CatchDemo() {
}
void dAcObjFairy_c::finalizeState_CatchDemo() {
field_0xB89 = 0;
// TODO collision
mObjectActorFlags &= ~0x00000200;
}
bool dAcObjFairy_c::shouldAvoidLink() const {
// TODO shuffles
if (dAcPy_c::LINK->isUsingBugnet()) {
const mVec3_c &bugNetPos = dAcPy_c::LINK->getBugNetPos();
const mVec3_c dist = bugNetPos - position;
mVec3_c dist = dAcPy_c::LINK->getBugNetPos() - position;
bool isClose = false;
if (dist.mag() < 100.0f && velocity.dot(dist) > 0.0f) {
isClose = true;
src/d/a/obj/d_a_obj_switch.cpp
+4 -4
View File
@@ -68,13 +68,13 @@ bool dAcOsw_c::createHeap() {
nw4r::g3d::ResMdl resMdl = resFile.GetResMdl(SWITCH_TYPES[mSwitchType]);
TRY_CREATE(mModel.create(resMdl, &heap_allocator, 0x20, 1, nullptr));
field_0x5E8 = mScale.x *
(resMdl.GetResNode("base").mNode.ref().VEC3_0x50.x - resMdl.GetResNode("base").mNode.ref().VEC3_0x44.x);
field_0x5E8 = mScale.x * (resMdl.GetResNode("base").mNode.ref().VEC3_0x50.x -
resMdl.GetResNode("base").mNode.ref().VEC3_0x44.x);
cBgD_t *dbzData = (cBgD_t *)getOarcDZB(SWITCH_TYPES[mSwitchType], SWITCH_TYPES[mSwitchType]);
PLC *plcData = (PLC *)getOarcPLC(SWITCH_TYPES[mSwitchType], SWITCH_TYPES[mSwitchType]);
mScale.set(1.0f, 0.8f, 1.0f);
updateMatrix();
field_0x5B8.set(mWorldMtx);
field_0x5B8.copyFrom(mWorldMtx);
mModel.setLocalMtx(mWorldMtx);
bool set = mCollision.Set(dbzData, plcData, cBgW::MOVE_BG_e, &field_0x5B8, &mScale);
@@ -180,7 +180,7 @@ int dAcOsw_c::actorExecute() {
}
updateMatrix();
field_0x5B8.set(mWorldMtx);
field_0x5B8.copyFrom(mWorldMtx);
mMtx_c tmp;
PSMTXTrans(tmp, 0.0f, mButtonCtrl.mElevation, 0.0f);
PSMTXConcat(field_0x5B8, tmp, field_0x5B8);
src/d/col/bg/d_bg_w.cpp
+2 -2
View File
@@ -492,8 +492,8 @@ void cBgW::RwgLineCheck(int polyIdx, cBgS_LinChk *pLine) {
cBgD_Vtx_t *vtxTbl = mpVtxTbl;
mVec3_c cross_pos;
if (cM3d_Cross_LinTri(
&pLine->mLin, &vtxTbl[triTbl[polyIdx].mVtxIdx0], &vtxTbl[triTbl[polyIdx].mVtxIdx1],
&vtxTbl[triTbl[polyIdx].mVtxIdx2], &mpTri[polyIdx], &cross_pos, pLine->ChkFrontFlag(),
pLine->mLin, vtxTbl[triTbl[polyIdx].mVtxIdx0], vtxTbl[triTbl[polyIdx].mVtxIdx1],
vtxTbl[triTbl[polyIdx].mVtxIdx2], &mpTri[polyIdx], cross_pos, pLine->ChkFrontFlag(),
pLine->ChkBackFlag()
)) {
dBgPc pc = *mpPolyCodes.GetDBgPc(mpBgd->mTriTbl[polyIdx].mId);
src/d/col/bg/d_bg_w_time.cpp
+1 -1
View File
@@ -101,7 +101,7 @@ bool dBgWTime::LineCheck(cBgS_LinChk *pLine) {
lin.Set(linStart, linEnd);
mVec3_c vec0;
mVec3_c vec1;
if (!cM3d_Cross_CylLin(&mCyl, &lin, vec0, vec1)) {
if (!cM3d_Cross_CylLin(mCyl, lin, vec0, vec1)) {
return false;
}
if (!fn_803537a0(&vec0, pLine)) {
src/d/col/c/c_cc_d.cpp
+1494
View File
File diff suppressed because it is too large Load Diff
src/d/col/c/c_m3d.cpp
+36 -13
View File
@@ -14,6 +14,7 @@
#include "math.h"
#include "nw4r/math/math_types.h"
#include "rvl/MTX.h" // IWYU pragma: export
#include "rvl/MTX/vec.h"
using namespace nw4r::math;
using namespace EGG;
@@ -145,38 +146,40 @@ bool cM3d_Cross_LinSph_CrossPos(const cM3dGSph &, const cM3dGLin &, VEC3 *, VEC3
// TODO - returns false to satisfy warning
return false;
}
bool cM3d_Cross_CylSph(const cM3dGCyl *, const cM3dGSph *, f32 *) {
bool cM3d_Cross_CylSph(const cM3dGCyl &, const cM3dGSph &, f32 *) {
// TODO - returns false to satisfy warning
return false;
}
bool cM3d_Cross_CylSph(const cM3dGCyl *, const cM3dGSph *, VEC3 *, f32 *) {
bool cM3d_Cross_CylSph(const cM3dGCyl &, const cM3dGSph &, VEC3 *, f32 *) {
// TODO - returns false to satisfy warning
return false;
}
bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, f32 *) {
bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, f32 *) {
// TODO - returns false to satisfy warning
return false;
}
bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, f32 *, f32 *) {
bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, f32 *, f32 *) {
// TODO - returns false to satisfy warning
return false;
}
bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, VEC3 *) {
bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, VEC3 *) {
// TODO - returns false to satisfy warning
return false;
}
void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph *pSph, const cM3dGTri *pTri, VEC3 *pPnt) {
void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph &pSph, const cM3dGTri &pTri, VEC3 *pPnt) {
VEC3 scale, add;
PSVECAdd(pTri->mA, pTri->mB, add);
PSVECAdd(pTri.mA, pTri.mB, add);
PSVECScale(add, scale, 0.5f);
f32 mag = VEC3DistSq(&scale, &pSph->GetC());
const f32 mag = VEC3DistSq(&scale, &pSph.GetC());
if (cM3d_IsZero(mag)) {
*pPnt = pSph->GetC();
*pPnt = pSph.GetC();
return;
}
f32 a = pSph->GetR() / mag;
cM3d_InDivPos2(&pSph->GetC(), &scale, a, pPnt);
const f32 rad = pSph.GetR();
f32 a = rad / mag;
cM3d_InDivPos2(&pSph.GetC(), &scale, a, pPnt);
}
bool cM3d_Cross_SphTri(const cM3dGSph *, const cM3dGTri *, VEC3 *, f32 *, VEC3 *) {
// TODO - returns false to satisfy warning
@@ -218,7 +221,7 @@ bool cM3d_Cross_TriTri(const cM3dGTri &, const cM3dGTri &, VEC3 *) {
// TODO - returns false to satisfy warning
return false;
}
bool cM3d_Cross_CpsTri(const cM3dGCps &, cM3dGTri, VEC3 *) {
bool cM3d_Cross_CpsTri(const cM3dGCps &, const cM3dGTri &, VEC3 *) {
// TODO - returns false to satisfy warning
return false;
}
@@ -232,7 +235,7 @@ bool cM3d_3PlaneCrossPos(const cM3dGPla &, const cM3dGPla &, const cM3dGPla &, V
// TODO - returns false to satisfy warning
return false;
}
f32 cM3d_lineVsPosSuisenCross(const cM3dGLin *, const VEC3 *, VEC3 *) {
f32 cM3d_lineVsPosSuisenCross(const cM3dGLin &, const VEC3 &, VEC3 *) {
// TODO - returns 0.0f to satisfy warning
return 0.0f;
}
@@ -240,3 +243,23 @@ f32 cM3d_lineVsPosSuisenCross(const VEC3 &, const VEC3 &, const VEC3 &, VEC3 *)
// TODO - returns 0.0f to satisfy warning
return 0.0f;
}
bool cM3d_Normalize(nw4r::math::VEC3 *pPnt) {
f32 mag = PSVECMag(*pPnt);
if (cM3d_IsZero(mag)) {
return true;
}
mag = 1.f / mag;
pPnt->x *= mag;
pPnt->y *= mag;
pPnt->z *= mag;
return false;
}
void cM3d_Normalize_Ex(nw4r::math::VEC3 *pPnt) {
if (cM3d_Normalize(pPnt)) {
pPnt->x = 1.0f;
pPnt->y = 0.0f;
pPnt->z = 0.0f;
}
}
src/d/col/c/c_m3d_g_cps.cpp
+3 -3
View File
@@ -26,8 +26,8 @@ void cM3dGCps::Set(const mVec3_c &start, const mVec3_c &end, f32 r) {
SetR(r);
}
bool cM3dGCps::fn_80337f30(cM3dGUnk *unk, mVec3_c *vec) {
return fn_80336d90(this, unk, vec);
bool cM3dGCps::Cross(cM3dGUnk &unk, mVec3_c *vec) {
return cM3d_Cross_CpsUnk(*this, unk, vec);
}
bool cM3dGCps::fn_80337f40(const mVec3_c &v) const {
@@ -40,7 +40,7 @@ bool cM3dGCps::fn_80337f40(const mVec3_c &v) const {
}
f32 tmp;
mVec3_c tmpv;
if (cM3d_Len3dSqPntAndSegLine(this, v, tmpv, &tmp, nullptr) && tmp <= r2) {
if (cM3d_Len3dSqPntAndSegLine(*this, v, tmpv, &tmp, nullptr) && tmp <= r2) {
return true;
}
return false;
src/d/col/c/c_m3d_g_cyl.cpp
+4 -4
View File
@@ -27,12 +27,12 @@ void cM3dGCyl::SetR(f32 r) {
mRadius = r;
}
bool cM3dGCyl::fn_803380e0(cM3dGUnk *unk, mVec3_c *vec) {
return fn_80336110(this, unk, vec);
bool cM3dGCyl::Cross(cM3dGUnk &unk, mVec3_c *vec) {
return cM3d_Cross_CylUnk(*this, unk, vec);
}
bool cM3dGCyl::fn_803380f0(cM3dGUnk *unk, f32 *vec) {
return fn_803364e0(this, unk, vec);
bool cM3dGCyl::Cross(cM3dGUnk &unk, f32 *vec) {
return cM3d_Cross_CylUnk(*this, unk, vec);
}
bool cM3dGCyl::Cross(const mVec3_c &pnt) const {
src/d/col/c/c_m3d_g_pla.cpp
+6 -4
View File
@@ -2,6 +2,8 @@
#include "d/col/c/c_m3d_g_pla.h"
#include "d/col/c/c_m3d.h"
#include "m/m_angle.h"
#include "m/m_vec.h"
bool cM3dGPla::CrossInfLin(const mVec3_c &start, const mVec3_c &end, mVec3_c &out) const {
f32 tmp1 = getPlaneFunc(start);
@@ -27,11 +29,11 @@ bool cM3dGPla::getCrossYLessD(const mVec3_c &point, f32 *out) const {
}
mAng cM3dGPla::GetAngle(mAng ang) const {
mAng angleY = GetAngleY();
// Regswap
mAng angleY = mNormal.getAngleY();
angleY = angleY - ang;
f32 dist = GetXZDist() * angleY.cos();
return cM::atan2s(dist, mNormal.y);
return cM::atan2s(GetXZDist() * angleY.cos(), mNormal.y);
}
mAng cM3dGPla::GetNegativeAngle(mAng ang) const {
src/d/col/c/c_m3d_g_sph.cpp
+5 -5
View File
@@ -27,12 +27,12 @@ void cM3dGSph::SetC(f32 x, f32 y, f32 z) {
SetC(&c);
}
bool cM3dGSph::fn_80338750(cM3dGUnk *pUnk, mVec3_c *pOut) {
return fn_80337690(pUnk, this, pOut);
bool cM3dGSph::Cross(cM3dGUnk &pUnk, mVec3_c *pOut) {
return cM3d_Cross_UnkSph(pUnk, *this, pOut);
}
bool cM3dGSph::fn_80338760(cM3dGUnk *pUnk, f32 *pOut) {
return fn_80337780(pUnk, this, pOut);
bool cM3dGSph::Cross(cM3dGUnk &pUnk, f32 *pOut) {
return cM3d_Cross_UnkSph(pUnk, *this, pOut);
}
f32 cM3dGSph::GetYDist(f32 r) const {
@@ -44,7 +44,7 @@ f32 cM3dGSph::GetYDist(f32 r) const {
}
bool cM3dGSph::Cross(const cM3dGTri *pTri, f32 *p2, mVec3_c *p3) {
return cM3d_Cross_SphTri(this, pTri, nullptr, p2, p3);
return cM3d_Cross_SphTri(*this, *pTri, nullptr, p2, p3);
}
void cM3dGSph::Clamp(const mVec3_c &in, mVec3_c &out) const {
src/d/col/c/c_m3d_g_unk.cpp
+27 -25
View File
@@ -2,12 +2,14 @@
#include "d/col/c/c_m3d.h"
#include "d/col/c/c_m3d_g_aab.h"
#include "m/m_vec.h"
#include "nw4r/types_nw4r.h"
cM3dGUnk::cM3dGUnk() {
mMin.set(0.0f, 0.0f, 0.0f);
mMax.set(0.0f, 0.0f, 0.0f);
mField_0x78.set(0.0f, 0.0f, 0.0f);
mField_0x84.set(0.0f, 0.0f, 0.0f);
mLin.GetStart().set(0.0f, 0.0f, 0.0f);
mLin.GetEnd().set(0.0f, 0.0f, 0.0f);
mField_0x90.set(0.0f, 0.0f, 0.0f);
mField_0x9C.set(0.0f, 0.0f, 0.0f);
mField_0xA8.set(0.0f, 0.0f, 0.0f);
@@ -22,9 +24,9 @@ void cM3dGUnk::Set(const mVec3_c &vA, const mVec3_c &vB) {
mMin = vA;
mMax = vB;
mField_0x84 = (mMin + mMax) * 0.5f;
mField_0x90 = mMin - mField_0x84;
mField_0x9C = mMax - mField_0x84;
mLin.GetEnd() = (mMin + mMax) * 0.5f;
mField_0x90 = mMin - mLin.GetEnd();
mField_0x9C = mMax - mLin.GetEnd();
mField_0xA8 = (mMax - mMin) * 0.5f;
Update();
@@ -34,9 +36,9 @@ void cM3dGUnk::Update() {
mVec3_c a, b;
PSMTXMultVec(mMtx, mMin, a);
PSMTXMultVec(mMtx, mMax, b);
mField_0x78.x = (a.x + b.x) * 0.5f;
mField_0x78.y = (a.y + b.y) * 0.5f;
mField_0x78.z = (a.z + b.z) * 0.5f;
mLin.GetStart().x = (a.x + b.x) * 0.5f;
mLin.GetStart().y = (a.y + b.y) * 0.5f;
mLin.GetStart().z = (a.z + b.z) * 0.5f;
if (!PSMTXInverse(mMtx, mInvMtx)) {
PSMTXIdentity(mInvMtx);
}
@@ -47,41 +49,41 @@ void cM3dGUnk::GetStartEnd(mVec3_c &start, mVec3_c &end) {
end = mMax;
}
void cM3dGUnk::fn_80338c30(cM3dGCps *pCps, mVec3_c *pVec) {
fn_80336d90(pCps, this, pVec);
bool cM3dGUnk::Cross(cM3dGCps &pCps, mVec3_c *pVec) {
return cM3d_Cross_CpsUnk(pCps, *this, pVec);
}
bool cM3dGUnk::fn_80338c40(cM3dGUnk *pUnk, mVec3_c *pVec) {
bool cM3dGUnk::Cross(cM3dGTri &pUnk, mVec3_c *pVec) {
nw4r::math::VEC3 tmp;
if (fn_803354e0(this, pUnk, &tmp)) {
if (cM3d_Cross_UnkTri(*this, pUnk, &tmp)) {
*pVec = tmp;
return true;
}
return false;
}
bool cM3dGUnk::fn_80338ca0() {
bool cM3dGUnk::Cross(cM3dGUnk &pUnk, mVec3_c *pVec) {
return false;
}
bool cM3dGUnk::fn_80338cb0(cM3dGCyl *pCyl, mVec3_c *pVec) {
return fn_80336110(pCyl, this, pVec);
bool cM3dGUnk::Cross(cM3dGCyl &pCyl, mVec3_c *pVec) {
return cM3d_Cross_CylUnk(pCyl, *this, pVec);
}
bool cM3dGUnk::fn_80338cc0(cM3dGCyl *pCyl, f32 *pF) {
return fn_803364e0(pCyl, this, pF);
bool cM3dGUnk::Cross(cM3dGCyl &pCyl, f32 *pF) {
return cM3d_Cross_CylUnk(pCyl, *this, pF);
}
bool cM3dGUnk::fn_80338cd0(cM3dGSph *pSph, mVec3_c *pVec) {
return fn_80337690(this, pSph, pVec);
bool cM3dGUnk::Cross(cM3dGSph &pSph, mVec3_c *pVec) {
return cM3d_Cross_UnkSph(*this, pSph, pVec);
}
bool cM3dGUnk::fn_80338ce0(cM3dGSph *pSph, f32 *pF) {
return fn_80337780(this, pSph, pF);
bool cM3dGUnk::Cross(cM3dGSph &pSph, f32 *pF) {
return cM3d_Cross_UnkSph(*this, pSph, pF);
}
void cM3dGUnk::Set(const mMtx_c &mtx) {
mMtx.set(mtx);
mMtx.copyFrom(mtx);
Update();
}
@@ -89,7 +91,7 @@ void cM3dGUnk::Set(const mVec3_c &vec, const mAng &ang) {
mMtx_c mtx;
PSMTXIdentity(mtx);
mtx.YrotS(ang);
mtx.SetTranslation(vec);
mtx.setTranslation(vec);
Set(mtx);
}
@@ -127,7 +129,7 @@ void cM3dGUnk::Clamp(const mVec3_c &in, mVec3_c &out) {
}
void cM3dGUnk::fn_80338f30(f32 f0, f32 f1) {
mMtx.xw += f0;
mMtx.zw += f1;
mMtx(0, 3) += f0;
mMtx(2, 3) += f1;
Update();
}
src/d/col/cc/d_cc_d.cpp
+55 -336
View File
@@ -1,373 +1,92 @@
#include "d/col/cc/d_cc_d.h"
#include "d/a/d_a_base.h"
#include "f/f_base_id.h"
#include "d/col/c/c_cc_d.h"
#include "m/m_vec.h"
dCcD_Cps::dCcD_Cps() {}
dCcD_Cps::~dCcD_Cps() {}
inline bool cM3d_IsZero(f32 f);
mVec3_c dCcD_ShapeAttr::m_virtual_center = mVec3_c::Zero;
dCcD_DivideInfo::dCcD_DivideInfo() {}
dCcD_DivideInfo::~dCcD_DivideInfo() {}
dCcD_DivideArea::dCcD_DivideArea() {}
dCcD_DivideArea::~dCcD_DivideArea() {}
void d_cc_d_float_order() {
1.0f / 32.0f;
1.0f;
0.0f;
FLT_EPSILON;
1.0f / 3.0f;
1.0e9f;
-1.0e9f;
-1.0f;
0.5f;
void dCcD_Cps::Set(const dCcD_SrcCps &src) {
cCcD_Obj::Set(src.mObjInf);
cCcD_CpsAttr::Set(src.mCpsInf);
}
// Very certain
void dCcD_DivideArea::SetArea(cM3dGAab const &aab) {
Set(aab.mMin, aab.mMax);
mScaledXDiff = 1.0f / 32.0f * (mMax.x - mMin.x);
mXDiffIsZero = cM3d_IsZero(mScaledXDiff);
if (!mXDiffIsZero) {
mInvScaledXDiff = 1.0f / mScaledXDiff;
}
mScaledYDiff = 1.0f / 32.0f * (mMax.y - mMin.y);
mYDiffIsZero = cM3d_IsZero(mScaledYDiff);
if (!mYDiffIsZero) {
mInvScaledYDiff = 1.0f / mScaledYDiff;
}
mScaledZDiff = 1.0f / 32.0f * (mMax.z - mMin.z);
mZDiffIsZero = cM3d_IsZero(mScaledZDiff);
if (!mZDiffIsZero) {
mInvScaledZDiff = 1.0f / mScaledZDiff;
}
cCcD_ShapeAttr *dCcD_Cps::GetShapeAttr() {
return this;
}
inline bool cM3d_IsZero(f32 f) {
return fabsf(f) < FLT_EPSILON;
void dCcD_Cps::unknownCalc() {
PSVECSubtract(mEnd, mStart, mAt.mVec);
}
static u32 const l_base[32] = {
0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF,
};
dCcD_Tri::dCcD_Tri() {}
dCcD_Tri::~dCcD_Tri() {}
// TODO
UnkCCDStruct::UnkCCDStruct(dAcBase_c *arg) : field_0x00(0), field_0x04(0), field_0x08(0), field_0x0C(0) {
field_0x38 = 0;
field_0x34 = arg;
reset();
void dCcD_Tri::Set(const dCcD_SrcTri &src) {
cCcD_Obj::Set(src.mObjInf);
}
void UnkCCDStruct::postExecute() {
field_0x04 = field_0x00;
field_0x00 = 0;
field_0x0C = field_0x08;
field_0x08 = 0;
cCcD_ShapeAttr *dCcD_Tri::GetShapeAttr() {
return this;
}
void UnkCCDStruct::reset() {
field_0x10 = mVec3_c::Zero;
field_0x1C = mVec3_c::Zero;
posIncrements = mVec3_c::Zero;
dCcD_Cyl::dCcD_Cyl() {}
dCcD_Cyl::~dCcD_Cyl() {}
void dCcD_Cyl::Set(const dCcD_SrcCyl &src) {
cCcD_Obj::Set(src.mObjInf);
cCcD_CylAttr::Set(src.mCylInf);
}
fBaseID_e UnkCCDStruct::getId() {
if (field_0x34 != nullptr) {
return field_0x34->unique_ID;
}
return (fBaseID_e)0;
cCcD_ShapeAttr *dCcD_Cyl::GetShapeAttr() {
return this;
}
static u32 const sth[] = {0x4B, 0x5A, 0x64, 0x00};
u32 UnkCCDStruct::getSomething(int arg) {
if (field_0x38 == 0x0D || arg == 0) {
return 0;
}
if (field_0x38 == 0 || arg == 0x0D) {
return 100;
}
if (field_0x38 == arg) {
return 50;
}
if (field_0x38 == 0x0C || arg == 0x01) {
return 0;
}
if (field_0x38 == 1 || arg == 0x0C) {
return 100;
}
arg = arg - field_0x38;
if (arg > 0) {
return sth[(arg <= 3 ? arg : 3) - 1];
} else {
return 100 - sth[(-arg <= 3 ? -arg : 3) - 1];
}
void dCcD_Cyl::setCenter(const mVec3_c &c) {
SetAtVec(mVec3_c::Zero);
SetC(c);
}
dCcD_GAtTgCoCommonBase::dCcD_GAtTgCoCommonBase() : field_0x00(0), field_0x14(0), mEffCounter(0) {}
dCcD_GAtTgCoCommonBase::~dCcD_GAtTgCoCommonBase() {
unlink();
field_0x14 = 0;
unlink();
decreaseCount();
field_0x00 = 0;
void dCcD_Cyl::moveCenter(const mVec3_c &c) {
SetAtVec(c - GetC());
SetC(c);
}
void dCcD_GAtTgCoCommonBase::unlink() {
mActor.unlink();
dCcD_Sph::dCcD_Sph() {}
dCcD_Sph::~dCcD_Sph() {}
void dCcD_Sph::Set(const dCcD_SrcSph &src) {
cCcD_Obj::Set(src.mObjInf);
cCcD_SphAttr::Set(src.mSphInf);
}
void dCcD_GAtTgCoCommonBase::setActor(dAcBase_c *actor) {
field_0x14 |= 1;
mActor.link(actor);
void dCcD_Sph::setCenter(const mVec3_c &c) {
SetAtVec(mVec3_c::Zero);
SetC(&c);
}
dAcBase_c *dCcD_GAtTgCoCommonBase::getActor() {
return mActor.get();
void dCcD_Sph::moveCenter(const mVec3_c &c) {
SetAtVec(c - GetC());
SetC(&c);
}
void dCcD_GAtTgCoCommonBase::decreaseCount() {
if (mEffCounter <= 0) {
return;
}
mEffCounter--;
void dCcD_Sph::setCenterAndAtVec(const mVec3_c &a, const mVec3_c &b) {
SetAtVec(b);
SetC(&a);
}
dCcD_GObjInf::dCcD_GObjInf() {
field_0x104 = nullptr;
field_0x108 = 0;
cCcD_ShapeAttr *dCcD_Sph::GetShapeAttr() {
return this;
}
dCcD_GObjInf::~dCcD_GObjInf() {
field_0x104 = nullptr;
dCcD_Unk::dCcD_Unk() {}
dCcD_Unk::~dCcD_Unk() {}
void dCcD_Unk::Set(const dCcD_SrcUnk &src) {
cCcD_Obj::Set(src.mObjInf);
cCcD_UnkAttr::Set(src.mUnkInf);
}
bool dCcD_GObjInf::weirdConditionCheck(dAcBase_c *ac, u32 arg) {
return ac != nullptr && ac->isActorPlayer() && arg == 2;
cCcD_ShapeAttr *dCcD_Unk::GetShapeAttr() {
return this;
}
void dCcD_GObjInf::clear() {
mGObjAt.clearFlag();
mGObjTg.clearFlag();
mGObjCo.clearFlag();
}
void dCcD_GObjInf::init(const dCcD_SrcGObjInf &src) {
mGObjAt.init(&src.mGObjAt);
mGObjTg.init(&src.mGObjTg);
mGObjCo.init(&src.mGObjCo);
}
void dCcD_GObjInf::ResetAtHit() {
mGObjAt.resetField0x14();
mGObjAt.unlink();
mGObjAt.decreaseCount();
mGObjAt.resetEffCounter();
}
void dCcD_GObjInf::ResetTgHit() {
mGObjTg.resetField0x14();
mGObjTg.unlink();
mGObjTg.decreaseCount();
mGObjTg.resetEffCounter();
}
void dCcD_GObjInf::ResetCoHit() {
mGObjCo.resetField0x14();
mGObjCo.unlink();
mGObjCo.decreaseCount();
mGObjCo.resetEffCounter();
}
mVec3_c *dCcD_GObjInf::GetAtHitPosP() {
return mGObjAt.GetHitPosP();
}
mVec3_c *dCcD_GObjInf::GetAtHitPosP2() {
return mGObjAt.GetHitPosP();
}
void dCcD_GObjInf::dCcD_GObjInf_0x10() {}
dAcBase_c *dCcD_GObjInf::GetAtActor() {
return mGObjAt.getActor();
}
bool dCcD_GObjInf::CheckCollidedMask(u32 mask) {
return (mGObjTg.get0x58() & mask);
}
dAcBase_c *dCcD_GObjInf::GetTgActor() {
return mGObjTg.getActor();
}
dAcBase_c *dCcD_GObjInf::GetCoActor() {
return mGObjCo.getActor();
}
void dCcD_GObjInf::adjustHitPos(f32 dx, f32 dz) {
mGObjAt.adjustHitPos(dx, dz);
mGObjTg.adjustHitPos(dx, dz);
mGObjCo.adjustHitPos(dx, dz);
}
/**
*
* Geometric shape colliders
*
*/
dCcD_ShapeAttr::dCcD_ShapeAttr() {}
dCcD_ShapeAttr::~dCcD_ShapeAttr() {}
mVec3_c *dCcD_ShapeAttr::getVirtualCenter() {
return &m_virtual_center;
}
dCcD_ShapeAttr2::dCcD_ShapeAttr2() {}
dCcD_ShapeAttr2::~dCcD_ShapeAttr2() {}
dCcD_ShapeAttr5::dCcD_ShapeAttr5() {}
dCcD_ShapeAttr5::~dCcD_ShapeAttr5() {}
void dCcD_ShapeAttr5::init(const dCcD_SrcAabbAttr &src) {
Set(mVec3_c(src.minX, src.minY, src.minZ), mVec3_c(src.maxX, src.maxY, src.maxZ));
}
mVec3_c *dCcD_ShapeAttr5::getVirtualCenter() {
return &mVirtCenter;
}
dCcD_ShapeAttr1::dCcD_ShapeAttr1() {}
dCcD_ShapeAttr1::~dCcD_ShapeAttr1() {}
mVec3_c *dCcD_ShapeAttr1::getVirtualCenter() {
return &mVirtualCenter;
}
dCcD_ShapeAttr3::dCcD_ShapeAttr3() {}
dCcD_ShapeAttr3::~dCcD_ShapeAttr3() {}
void dCcD_ShapeAttr3::init(const dCcD_SrcCylAttr &src) {
SetR(src.mRadius);
SetH(src.mHeight);
mVec3_c v;
v.z = 0.0f;
v.y = 0.0f;
v.x = 0.0f;
SetC(v);
}
mVec3_c *dCcD_ShapeAttr3::getVirtualCenter() {
return &mCenter;
}
dCcD_ShapeAttr4::dCcD_ShapeAttr4() {}
dCcD_ShapeAttr4::~dCcD_ShapeAttr4() {}
void dCcD_ShapeAttr4::init(const dCcD_SrcSphAttr &src) {
SetR(src.mRadius);
mVec3_c v;
v.z = 0.0f;
v.y = 0.0f;
v.x = 0.0f;
SetC(v);
}
mVec3_c *dCcD_ShapeAttr4::getVirtualCenter() {
return &mCenter;
}
/**
*
* At/Tg/Co collider
*
*/
dCcD_GObjAt::dCcD_GObjAt() {
field_0x58 = 0;
}
dCcD_GObjAt::~dCcD_GObjAt() {}
void dCcD_GObjAt::init(const dCcD_SrcGObjAt *src) {
mEffCounter = 0;
mSrc = *src;
mHitPos = mVec3_c::Zero;
}
void dCcD_GObjAt::setSomeAtFlags(u32 flags) {
mSrc.field_0x04 = mSrc.field_0x04 & 0xFFFFFFC1 | flags;
}
void dCcD_GObjAt::adjustHitPos(f32 dx, f32 dz) {
mHitPos.x += dx;
mHitPos.z += dz;
}
dCcD_GObjTg::dCcD_GObjTg() {
field_0x44 = 0;
field_0x4A = 0;
field_0x4B = 0;
field_0x4C = 0;
field_0x50 = 0;
field_0x54 = 0;
field_0x6C.x = 0.0f;
field_0x6C.y = 0.0f;
field_0x6C.z = 0.0f;
field_0x78 = 0;
}
dCcD_GObjTg::~dCcD_GObjTg() {}
void dCcD_GObjTg::init(const dCcD_SrcGObjTg *src) {
mEffCounter = 0;
mSrc = *src;
field_0x4C = 0;
mHitPos = mVec3_c::Zero;
field_0x44 = 0;
field_0x48 = 0x4000;
}
void dCcD_GObjTg::adjustHitPos(f32 dx, f32 dz) {
mHitPos.x += dx;
mHitPos.z += dz;
field_0x6C.x += dx;
field_0x6C.z += dz;
}
dCcD_GObjCo::dCcD_GObjCo() {
field_0x20 = 0;
field_0x28 = 0;
}
dCcD_GObjCo::~dCcD_GObjCo() {}
void dCcD_GObjCo::init(const dCcD_SrcGObjCo *src) {
mEffCounter = 0;
mSrc = *src;
setSomeAtFlags(src->mBase.mGFlag & 0x1E0);
}
void dCcD_GObjCo::setSomeAtFlags(u32 flags) {}
void dCcD_GObjCo::adjustHitPos(f32 dx, f32 dz) {}
src/d/col/cc/d_cc_mass_s.cpp
+276
View File
@@ -0,0 +1,276 @@
#include "d/col/cc/d_cc_mass_s.h"
#include "common.h"
#include "m/m_vec.h"
#include "rvl/MTX/vec.h"
///////////////////////////////////////////////////////////////////////////////
// Obj
///////////////////////////////////////////////////////////////////////////////
dCcMassS_Obj::dCcMassS_Obj() {}
dCcMassS_Obj::~dCcMassS_Obj() {}
void dCcMassS_Obj::Set(cCcD_Obj *p_obj, u8 priority, dCcMassS_ObjCallback callback) {
mpObj = p_obj;
mPriority = priority;
mpCallback = callback;
}
void dCcMassS_Obj::Clear() {
mpObj = nullptr;
mPriority = 5;
mpCallback = nullptr;
mDivideInfo.Set(0, 0, 0);
}
///////////////////////////////////////////////////////////////////////////////
// Hit Info
///////////////////////////////////////////////////////////////////////////////
dCcMassS_HitInf::dCcMassS_HitInf() {}
dCcMassS_HitInf::~dCcMassS_HitInf() {}
void dCcMassS_HitInf::ClearPointer() {
mpArea = nullptr;
mpAtObj = nullptr;
mpCoObj = nullptr;
mCoHitLen = 0.0f;
}
///////////////////////////////////////////////////////////////////////////////
// Manager
///////////////////////////////////////////////////////////////////////////////
dCcMassS_Mng::dCcMassS_Mng() {
Ct();
}
dCcMassS_Mng ::~dCcMassS_Mng() {}
void dCcMassS_Mng::Ct() {
field_0x3AA = 0;
mResultCam = 0;
mCamTopPos.x = 0.0f;
mCamTopPos.y = -1000000000.0f;
mCamTopPos.z = 0.0f;
mCamBottomPos.x = 0.0f;
mCamBottomPos.y = -1000000000.0f;
mCamBottomPos.z = 0.0f;
Clear();
}
void dCcMassS_Mng::SetAttr(f32 radius, f32 height, u8 param_2, u8 param_3) {
mCylAttr.SetR(radius);
mCylAttr.SetH(height);
field_0x3A8 = param_2;
field_0x3A9 = param_3;
}
void dCcMassS_Mng::Prepare() {
cM3dGAab aab;
aab.ClearForMinMax();
for (dCcMassS_Obj *pObj = mMassObjs; pObj < mMassObjs + mMassObjCount; ++pObj) {
cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
objShape->CalcAabBox();
aab.SetMinMax(objShape->GetWorkAab());
}
for (dCcMassS_Obj *pObj = mMassAreas; pObj < mMassAreas + mMassAreaCount; ++pObj) {
cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
objShape->CalcAabBox();
aab.SetMinMax(objShape->GetWorkAab());
}
if (field_0x3AA & 1) {
mCpsAttr.CalcAabBox();
aab.SetMinMax(mCpsAttr.GetWorkAab());
}
mDivideArea.SetArea(aab);
for (dCcMassS_Obj *pObj = mMassObjs; pObj < mMassObjs + mMassObjCount; ++pObj) {
cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
cCcD_DivideInfo *divideInfo = &pObj->GetDivideInfo();
mDivideArea.CalcDivideInfo(divideInfo, objShape->GetWorkAab());
}
for (dCcMassS_Obj *pObj = mMassAreas; pObj < mMassAreas + mMassAreaCount; ++pObj) {
cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
cCcD_DivideInfo *divideInfo = &pObj->GetDivideInfo();
mDivideArea.CalcDivideInfo(divideInfo, objShape->GetWorkAab());
}
if (field_0x3AA & 1) {
mDivideArea.CalcDivideInfo(&mDivideInfo, mCpsAttr.GetWorkAab());
}
mCamTopPos.x = 0.0f;
mCamTopPos.y = -1000000000.0f;
mCamTopPos.z = 0.0f;
mCamTopDist = 1000000000.0f;
mCamBottomPos.x = 0.0f;
mCamBottomPos.y = -1000000000.0f;
mCamBottomPos.z = 0.0f;
mCamBottomDist = 1000000000.0f;
}
u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p_hitInf) {
cCcD_DivideInfo divideInfo;
u32 flagsMaybe = 0;
*p_actor = NULL;
mCylAttr.SetC(*p_xyz);
mCylAttr.CalcAabBox();
mDivideArea.CalcDivideInfoOverArea(&divideInfo, mCylAttr.GetWorkAab());
p_hitInf->ClearPointer();
if (field_0x3A8 & 8) {
for (dCcMassS_Obj *massObj = mMassAreas; massObj < mMassAreas + mMassAreaCount; ++massObj) {
if (massObj->GetDivideInfo().Chk(divideInfo)) {
cCcD_Obj *obj = massObj->GetObj();
cCcD_ShapeAttr *objShape = obj->GetShapeAttr();
f32 f;
if (obj->ChkCoSet() && mCylAttr.CrossCo(*objShape, &f)) {
flagsMaybe |= 4;
*p_actor = obj->GetStts()->GetAc();
if (p_hitInf != NULL) {
p_hitInf->SetAreaHitObj(obj);
}
if (massObj->GetCallback() != NULL) {
massObj->GetCallback()(obj->GetStts()->GetAc(), p_xyz, field_0x3A9);
}
}
}
}
}
for (dCcMassS_Obj *massObj = mMassObjs; massObj < mMassObjs + mMassObjCount; ++massObj) {
if (massObj->GetDivideInfo().Chk(divideInfo)) {
cCcD_Obj *obj = massObj->GetObj();
cCcD_ShapeAttr *objShape = obj->GetShapeAttr();
mVec3_c unusedVec;
if (obj->ChkAtSet() && !obj->ChkAtNoMass() && (field_0x3A8 & 1)) {
*p_actor = obj->GetStts()->GetAc();
}
if (obj->ChkAtSet() && !obj->ChkAtNoMass() && mCylAttr.CrossAtTg(*objShape, &unusedVec) &&
(field_0x3A8 & 1)) {
flagsMaybe |= 1;
*p_actor = obj->GetStts()->GetAc();
if (p_hitInf != NULL) {
p_hitInf->SetAtHitObj(obj);
}
}
f32 f;
if (obj->ChkCoSet() && mCylAttr.CrossCo(*objShape, &f) && (field_0x3A8 & 2)) {
flagsMaybe |= 2;
*p_actor = obj->GetStts()->GetAc();
if (field_0x3A8 & 0x10) {
mVec3_c vec;
PSVECSubtract((*p_actor)->GetPostion(), *p_xyz, vec);
vec.y = 0;
f32 vecMag = PSVECMag(vec);
if (cM3d_IsZero(vecMag)) {
vec.x = 1;
} else {
PSVECScale(vec, vec, f / vecMag);
}
obj->GetStts()->PlusCcMove(vec.x, vec.y, vec.z);
}
if (p_hitInf != NULL) {
p_hitInf->SetCoHitObj(obj);
p_hitInf->SetCoHitLen(f);
}
}
}
}
f32 f;
if ((field_0x3AA & 1) && mDivideInfo.Chk(divideInfo) && mCylAttr.CrossCo(mCpsAttr, &f)) {
mResultCam |= 1;
mResultCam |= 1 << (field_0x3A9 + 1);
if ((mResultCam & 2) || (mResultCam & 8)) {
Vec tmpVec;
f32 plusH = p_xyz->y + mCylAttr.GetH();
tmpVec.x = p_xyz->x;
tmpVec.y = plusH;
tmpVec.z = p_xyz->z;
if (mCamTopPos.y < (20.0f + plusH)) {
f32 newCamTopDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetStartP());
if (mCamTopDist > newCamTopDist) {
mCamTopDist = newCamTopDist;
mCamTopPos = tmpVec;
}
}
if (mCamBottomPos.y < (20.0f + plusH)) {
f32 newCamBottomDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetEndP());
if (mCamBottomDist > newCamBottomDist) {
mCamBottomDist = newCamBottomDist;
mCamBottomPos = tmpVec;
}
}
}
}
return flagsMaybe;
}
void dCcMassS_Mng::Clear() {
mMassObjCount = 0;
mMassAreaCount = 0;
for (int i = 0; i < (s32)ARRAY_LENGTH(mMassObjs); ++i) {
mMassObjs[i].Clear();
}
for (int i = 0; i < (s32)ARRAY_LENGTH(mMassAreas); ++i) {
mMassAreas[i].Clear();
}
mCylAttr.SetR(0.0f);
mCylAttr.SetH(0.0f);
field_0x3A8 = 0;
field_0x3A9 = 4;
}
void dCcMassS_Mng::SetObj(cCcD_Obj *p_obj, u8 priority) {
if (mMassObjCount >= (s32)ARRAY_LENGTH(mMassObjs)) {
for (int i = 0; i < (s32)ARRAY_LENGTH(mMassObjs); ++i) {
int prevPrio = mMassObjs[i].GetPriority();
if (prevPrio > priority || (prevPrio == priority)) {
mMassObjs[i].Set(p_obj, priority, nullptr);
break;
}
}
} else {
mMassObjs[mMassObjCount].Set(p_obj, priority, nullptr);
mMassObjCount++;
}
}
void dCcMassS_Mng::SetArea(cCcD_Obj *p_obj, u8 priority, dCcMassS_ObjCallback callback) {
if (mMassAreaCount >= (s32)ARRAY_LENGTH(mMassAreas)) {
for (int i = 0; i < (s32)ARRAY_LENGTH(mMassAreas); ++i) {
if (mMassAreas[i].GetPriority() > priority) {
mMassAreas[i].Set(p_obj, priority, callback);
break;
}
}
} else {
mMassAreas[mMassAreaCount].Set(p_obj, priority, callback);
mMassAreaCount++;
}
}
src/d/col/cc/d_cc_s.cpp
+180
View File
@@ -0,0 +1,180 @@
#include "d/col/cc/d_cc_s.h"
#include "common.h"
#include "d/a/obj/d_a_obj_base.h"
#include "d/col/c/c_cc_d.h"
#include "d/col/c/c_m3d_g_aab.h"
#include "f/f_base.h"
#include "rvl/MTX/mtx.h"
dCcS *dCcS::sInstance;
dCcS *dCcS::GetInstance() {
return sInstance;
}
void dCcS::Ct_cCcS() {
for (cCcD_Obj **end = mpObjAt + ARRAY_LENGTH(mpObjAt), **obj = mpObjAt; obj < end; ++obj) {
*obj = nullptr;
}
mObjAtCount = 0;
for (cCcD_Obj **end = mpObjTg + ARRAY_LENGTH(mpObjTg), **obj = mpObjTg; obj < end; ++obj) {
*obj = nullptr;
}
mObjTgCount = 0;
for (cCcD_Obj **end = mpObjCo + ARRAY_LENGTH(mpObjCo), **obj = mpObjCo; obj < end; ++obj) {
*obj = nullptr;
}
mObjCoCount = 0;
for (cCcD_Obj **end = mpObj + ARRAY_LENGTH(mpObj), **obj = mpObj; obj < end; ++obj) {
*obj = nullptr;
}
mObjCount = 0;
for (UNKTYPE **end = mpUnk + ARRAY_LENGTH(mpUnk), **obj = mpUnk; obj < end; ++obj) {
*obj = nullptr;
}
mUnkCount = 0;
}
dCcS::dCcS() {
sInstance = this;
}
dCcS::~dCcS() {
sInstance = nullptr;
}
void dCcS::Ct() {
Ct_cCcS();
mMassMng.Ct();
ClearArea();
}
void dCcS::Dt() {
Ct_cCcS();
ClearArea();
}
bool dCcS::ChkRemoveActor(dAcObjBase_c *pActor) {
bool ret = false;
if (pActor && (pActor->delete_request || pActor->lifecycle_state == fBase_c::TO_BE_DELETED)) {
ret = true;
}
return ret;
}
bool dCcS::ChkNoHitAtTg(cCcD_Obj *, cCcD_Obj *) {}
bool dCcS::ChkAtTgCommonHitInf(cCcD_Obj *, cCcD_Obj *) {}
void dCcS::ChkAtTg() {}
bool dCcS::ChkNoHitCo(cCcD_Obj *, cCcD_Obj *) {}
void dCcS::SetCoCommonHitInf(cCcD_Obj *, mVec3_c *, cCcD_Obj *, mVec3_c *, f32) {}
void dCcS::ChkCo() {}
bool dCcS::ChkSheildFrontRange(cCcD_Obj *, cCcD_Obj *) {}
bool dCcS::ChkShield(cCcD_Obj *, cCcD_Obj *, cCcD_ShieldChkCallback *) {}
bool dCcS::ChkAtTgHitAfterCross(bool, bool, cCcD_Obj *, cCcD_Obj *) {}
void dCcS::SetCoObjInf(bool, bool, cCcD_Obj *, cCcD_Obj *) {}
void dCcS::SetPosCorrect(cCcD_Obj *, mVec3_c *, cCcD_Obj *, mVec3_c *, f32) {}
void dCcS::CalcParticleAngle(cCcD_Obj *, cCcD_Obj *, mAng3_c *, bool) {}
void dCcS::fn_80356fd0(mVec3_c *, cCcD_Obj *, cCcD_Obj *) {}
u32 dCcS::ProcAtTgHitmark(cCcD_Obj *, cCcD_Obj *, mVec3_c *, u32, mVec3_c *) {}
void dCcS::SetAtTgObjInf(bool, bool, cCcD_Obj *, cCcD_Obj *, mVec3_c *, bool) {}
bool dCcS::ChkCamera(mVec3_c &, mVec3_c &, dAcObjBase_c *, dAcObjBase_c *, dAcObjBase_c *, f32) {}
bool dCcS::ChkCameraPoint(
const mVec3_c &, const mVec3_c &, mVec3_c &, dAcObjBase_c *, dAcObjBase_c *, dAcObjBase_c *, f32
) {}
bool dCcS::ChkCo(const mVec3_c &, dAcObjBase_c *) {}
bool dCcS::fn_80357c90(const mVec3_c &, const mVec3_c &, u32, UNKTYPE **) {}
void dCcS::Set(cCcD_Obj *) {}
void dCcS::MoveAfterCheck() {}
void dCcS::RemoveDeadObj() {}
void dCcS::CalcArea() {
if (mbAreaSet) {
return;
}
cM3dGAab aab;
aab.ClearForMinMax();
for (cCcD_Obj **obj = mpObj; obj < mpObj + mObjCount; ++obj) {
cCcD_ShapeAttr *attr = (*obj)->GetShapeAttr();
attr->CalcAabBox();
aab.SetMinMax(attr->GetWorkAab());
}
// TODO
}
void dCcS::Move() {
RemoveDeadObj();
CalcArea();
ChkAtTg();
ChkCo();
for (int i = 0; i < mObjTgCount; ++i) {
mpObjTg[i]->SetTg_0x4B(0);
}
MoveAfterCheck();
AdjustHitPos();
mObjAtCount = 0;
mObjTgCount = 0;
mObjCoCount = 0;
mObjCount = 0;
mUnkCount = 0;
mbAreaSet = false;
ClearArea();
}
void dCcS::MassClear() {
mMassMng.Clear();
}
void dCcS::SetArea(mMtx_c *pMtx) {
if (mAreaCount >= 16) {
return;
}
// non-match: Huh
mAreas[mAreaCount].mInv = mAreas[mAreaCount].mMtx = *pMtx;
PSMTXInverse(mAreas[mAreaCount].mInv, mAreas[mAreaCount].mInv);
mAreaCount++;
}
void dCcS::ClearArea() {
mAreaCount = 0;
}
extern "C" void *STAGE_MANAGER;
extern "C" bool fn_8019A7A0(void *stg, f32 *, f32 *);
void dCcS::AdjustHitPos() {
f32 x, z;
if (STAGE_MANAGER && fn_8019A7A0(STAGE_MANAGER, &x, &z)) {
for (cCcD_Obj **obj = mpObj; obj < mpObj + mObjCount; ++obj) {
(*obj)->AdjustHitPos(x, z);
(*obj)->GetShapeAttr()->TranslateXZ(x, z);
}
}
}
src/d/col/cc/d_cc_shape_colliders.cpp
-108
View File
@@ -1,108 +0,0 @@
#include "d/col/cc/d_cc_shape_colliders.h"
#include "d/col/cc/d_cc_d.h"
#include "m/m_vec.h"
dCcD_Unk1::dCcD_Unk1() {}
dCcD_Unk1::~dCcD_Unk1() {}
void dCcD_Unk1::init(const dCcD_SrcUnk &src) {
dCcD_GObjInf::init(src.mObjInf);
dCcD_ShapeAttr1::init(src.mUnk1Inf);
}
void *dCcD_Unk1::dCcD_GObjInf_0x0C() {
if (this != nullptr) {
return &UNK_0x00;
}
return this;
}
void dCcD_Unk1::unknownCalc() {
PSVECSubtract(mCps.mEnd, mCps.mStart, *getAtVec());
}
dCcD_Empty::dCcD_Empty() {}
dCcD_Empty::~dCcD_Empty() {}
void dCcD_Empty::init(const dCcD_SrcEmpty &src) {
dCcD_GObjInf::init(src.mObjInf);
}
void *dCcD_Empty::dCcD_GObjInf_0x0C() {
if (this != nullptr) {
return &UNK_0x00;
}
return this;
}
dCcD_Cyl::dCcD_Cyl() {}
dCcD_Cyl::~dCcD_Cyl() {}
void dCcD_Cyl::init(const dCcD_SrcCyl &src) {
dCcD_GObjInf::init(src.mObjInf);
dCcD_ShapeAttr3::init(src.mCylAttr);
}
void *dCcD_Cyl::dCcD_GObjInf_0x0C() {
if (this != nullptr) {
return &UNK_0x00;
}
return this;
}
void dCcD_Cyl::setCenter(const mVec3_c &c) {
setAtVec(mVec3_c::Zero);
SetC(c);
}
void dCcD_Cyl::moveCenter(const mVec3_c &c) {
setAtVec(c - GetC());
SetC(c);
}
dCcD_Sph::dCcD_Sph() {}
dCcD_Sph::~dCcD_Sph() {}
void dCcD_Sph::init(const dCcD_SrcSph &src) {
dCcD_GObjInf::init(src.mObjInf);
dCcD_ShapeAttr4::init(src.mSphAttr);
}
void dCcD_Sph::setCenter(const mVec3_c &c) {
setAtVec(mVec3_c::Zero);
SetC(&c);
}
void dCcD_Sph::moveCenter(const mVec3_c &c) {
setAtVec(c - GetC());
SetC(&c);
}
void dCcD_Sph::setCenterAndAtVec(const mVec3_c &a, const mVec3_c &b) {
setAtVec(b);
SetC(&a);
}
void *dCcD_Sph::dCcD_GObjInf_0x0C() {
if (this != nullptr) {
return &UNK_0x00;
}
return this;
}
dCcD_Aabb::dCcD_Aabb() {}
dCcD_Aabb::~dCcD_Aabb() {}
void dCcD_Aabb::init(const dCcD_SrcAabb &src) {
dCcD_GObjInf::init(src.mObjInf);
dCcD_ShapeAttr5::init(src.mAabbAttr);
}
void *dCcD_Aabb::dCcD_GObjInf_0x0C() {
if (this != nullptr) {
return &UNK_0x00;
}
return this;
}
src/m/m3d/m_shadow.cpp
+3 -4
View File
@@ -10,7 +10,6 @@
#include "nw4r/g3d/g3d_scnmdlsmpl.h"
#include "nw4r/g3d/g3d_state.h"
// All of this is completely made up, as we don't have symbols for this TU
// (contrary to the rest of m3d and most of nw4r::g3d)
@@ -362,7 +361,7 @@ void mShadow_c::drawAllShadows() {
GXSetCullMode(GX_CULL_BACK);
GXSetDither(0);
GXSetClipMode(GX_CLIP_DISABLE);
GXLoadPosMtxImm(mMtx_c::Identity.m, 0);
GXLoadPosMtxImm(mMtx_c::Identity, 0);
GXSetCurrentMtx(0);
Mtx44 mtx;
C_MTXOrtho(mtx, 0.0f, wid, 0.0f, wid, 0.0f, 1.0f);
@@ -484,7 +483,7 @@ bool mShadowChild_c::addMdl(scnLeaf_c &mdl, const mQuat_c &quat) {
if (mdl.getType() == 0) {
mdl.getLocalMtx(mtx);
} else {
mtx.set(static_cast<mCustomShadow_c &>(mdl).mMtx);
mtx.copyFrom(static_cast<mCustomShadow_c &>(mdl).mMtx);
}
// TODO this copy is a bit weird (reads members in a different order)
@@ -614,7 +613,7 @@ void mCustomShadow_c::calc(mMtx_c mtx, mMtx_c &mtx2) {
// TODO some shuffles
mVec3_c trans;
mtx2.set(mMtx);
mtx2.copyFrom(mMtx);
mVec3_c offset(0.0f, 0.0f, 0.0f);
offset.y = field_0x48;
PSMTXMultVec(mtx2, offset, trans);
src/m/m_angle.cpp
+1
View File
@@ -1,4 +1,5 @@
#include "m/m_angle.h"
#include "math.h"
/** 80575c08 */