isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-01-12 10:41:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'isle/master'

Browse Source
This commit is contained in:
Christian Semmler 2025-05-23 09:34:57 -07:00
commit a75e3a4377
No known key found for this signature in database
GPG Key ID: 086DAA1360BEEE5C
34 changed files with 522 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
LEGO1/lego/legoomni/src/actors/act2actor.cpp
View File

@ -611,8 +611,8 @@ MxU32 Act2Actor::FUN_10019700(MxFloat p_param)
MxMatrix matrix = m_roi->GetLocal2World();
matrix[3][1] += 1.0f;
brickstrROI->FUN_100a58f0(matrix);
brickstrROI->VTable0x14();
brickstrROI->SetLocal2World(matrix);
brickstrROI->WrappedUpdateWorldData();
Vector3 col0(matrix[0]);
Vector3 col1(matrix[1]);

8
LEGO1/lego/legoomni/src/actors/act3actors.cpp
View File

@ -139,8 +139,8 @@ MxU32 Act3Actor::VTable0x90(float p_time, Matrix4& p_transform)
m_unk0x1c = 0;
positionRef -= g_unk0x10104ef0;
m_roi->FUN_100a58f0(p_transform);
m_roi->VTable0x14();
m_roi->SetLocal2World(p_transform);
m_roi->WrappedUpdateWorldData();
return TRUE;
}
}
@ -164,8 +164,8 @@ MxResult Act3Actor::HitActor(LegoPathActor* p_actor, MxBool p_bool)
Vector3(local2world[3]) += g_unk0x10104ef0;
roi->FUN_100a58f0(local2world);
roi->VTable0x14();
roi->SetLocal2World(local2world);
roi->WrappedUpdateWorldData();
p_actor->SetActorState(c_two | c_noCollide);
}

12
LEGO1/lego/legoomni/src/actors/act3ammo.cpp
View File

@ -271,8 +271,8 @@ void Act3Ammo::Animate(float p_time)
positionRef.Clear();
transform.RotateX(0.6);
positionRef = position;
m_roi->FUN_100a58f0(transform);
m_roi->VTable0x14();
m_roi->SetLocal2World(transform);
m_roi->WrappedUpdateWorldData();
return;
}
else {
@ -280,8 +280,8 @@ void Act3Ammo::Animate(float p_time)
m_unk0x158 = 0;
positionRef -= g_unk0x10104f08;
m_roi->FUN_100a58f0(transform);
m_roi->VTable0x14();
m_roi->SetLocal2World(transform);
m_roi->WrappedUpdateWorldData();
return;
}
}
@ -363,8 +363,8 @@ void Act3Ammo::Animate(float p_time)
MxMatrix localb0(local104);
local104.Product(local60, localb0);
m_roi->FUN_100a58f0(local104);
m_roi->VTable0x14();
m_roi->SetLocal2World(local104);
m_roi->WrappedUpdateWorldData();
if (m_BADuration <= m_unk0x7c) {
m_worldSpeed = 0.0f;

16
LEGO1/lego/legoomni/src/actors/doors.cpp
View File

@ -90,24 +90,24 @@ void Doors::Animate(float p_time)
local10.Clear();
local58.RotateY(-local8);
local10 = m_ltDoorLocal[3];
m_ltDoor->FUN_100a58f0(local58);
m_ltDoor->VTable0x14();
m_ltDoor->SetLocal2World(local58);
m_ltDoor->WrappedUpdateWorldData();
local58 = m_rtDoorLocal;
local10.Clear();
local58.RotateY(local8);
local10 = m_rtDoorLocal[3];
m_rtDoor->FUN_100a58f0(local58);
m_rtDoor->VTable0x14();
m_rtDoor->SetLocal2World(local58);
m_rtDoor->WrappedUpdateWorldData();
m_unk0x1f4 = local8;
}
if (m_unk0x158 + g_unk0x100d8e84 < p_time) {
m_ltDoor->FUN_100a58f0(m_ltDoorLocal);
m_rtDoor->FUN_100a58f0(m_rtDoorLocal);
m_ltDoor->VTable0x14();
m_rtDoor->VTable0x14();
m_ltDoor->SetLocal2World(m_ltDoorLocal);
m_rtDoor->SetLocal2World(m_rtDoorLocal);
m_ltDoor->WrappedUpdateWorldData();
m_rtDoor->WrappedUpdateWorldData();
m_unk0x154 = 1;
m_actorState = c_initial;
m_unk0x1f4 = 0;

4
LEGO1/lego/legoomni/src/actors/helicopter.cpp
View File

@ -391,8 +391,8 @@ void Helicopter::VTable0x74(Matrix4& p_transform)
FUN_10010c30();
}
else {
m_roi->FUN_100a58f0(p_transform);
m_roi->VTable0x14();
m_roi->SetLocal2World(p_transform);
m_roi->WrappedUpdateWorldData();
if (m_cameraFlag) {
FUN_10010c30();
}

6
LEGO1/lego/legoomni/src/actors/islepathactor.cpp
View File

@ -630,7 +630,7 @@ void IslePathActor::VTable0xec(MxMatrix p_transform, LegoPathBoundary* p_boundar
m_world->Add(this);
}
m_roi->FUN_100a58f0(p_transform);
m_roi->SetLocal2World(p_transform);
if (m_cameraFlag) {
FUN_1003eda0();
FUN_10010c30();
@ -648,6 +648,6 @@ void IslePathActor::FUN_1001b660()
up *= -1.0f;
position.EqualsCross(direction, up);
m_roi->FUN_100a58f0(transform);
m_roi->VTable0x14();
m_roi->SetLocal2World(transform);
m_roi->WrappedUpdateWorldData();
}

4
LEGO1/lego/legoomni/src/build/legocarbuild.cpp
View File

@ -321,7 +321,7 @@ void LegoCarBuild::FUN_10022f30()
void LegoCarBuild::VTable0x6c()
{
m_unk0x178 = m_unk0x1c0;
m_unk0x110->WrappedSetLocalTransform(m_unk0x178);
m_unk0x110->WrappedSetLocal2WorldWithWorldDataUpdate(m_unk0x178);
m_unk0x2a4 = Vector4(m_unk0x110->GetWorldPosition());
VTable0x70();
@ -409,7 +409,7 @@ void LegoCarBuild::FUN_10023130(MxLong p_x, MxLong p_y)
local78[3][2] = m_unk0x178[3][2] + local18[2];
local78[3][3] = 1.0;
m_unk0x110->WrappedSetLocalTransform(local78);
m_unk0x110->WrappedSetLocal2WorldWithWorldDataUpdate(local78);
}
}
}

2
LEGO1/lego/legoomni/src/build/legocarbuildpresenter.cpp
View File

@ -269,7 +269,7 @@ void LegoCarBuildAnimPresenter::StreamingTickle()
CalcLocalTransform(cameraPosition, dirVec, upVec, localTransform);
videoManagerROI->WrappedSetLocalTransform(localTransform);
videoManagerROI->WrappedSetLocal2WorldWithWorldDataUpdate(localTransform);
lego3dview->Moved(*videoManagerROI);
videoManager->Get3DManager()->SetFrustrum(fov, 0.1, 250.0);

4
LEGO1/lego/legoomni/src/common/legoanimationmanager.cpp
View File

@ -2812,7 +2812,7 @@ void LegoAnimationManager::FUN_100648f0(LegoTranInfo* p_tranInfo, MxLong p_unk0x
Mx3DPointFloat vec;
vec.Clear();
viewROI->FUN_100a5a30(vec);
viewROI->SetWorldVelocity(vec);
}
}
@ -2845,7 +2845,7 @@ void LegoAnimationManager::FUN_10064b50(MxLong p_time)
LegoROI* viewROI = VideoManager()->GetViewROI();
viewROI->WrappedSetLocalTransform(mat);
viewROI->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
VideoManager()->Get3DManager()->Moved(*viewROI);
SoundManager()->UpdateListener(
viewROI->GetWorldPosition(),

4
LEGO1/lego/legoomni/src/common/legoanimmmpresenter.cpp
View File

@ -364,7 +364,7 @@ MxBool LegoAnimMMPresenter::FUN_1004b5b0(MxLong p_time)
LegoROI* roi = m_roiMap[i];
if (roi != NULL) {
roi->WrappedSetLocalTransform(m_unk0x68[i]);
roi->WrappedSetLocal2WorldWithWorldDataUpdate(m_unk0x68[i]);
}
}
}
@ -450,7 +450,7 @@ MxBool LegoAnimMMPresenter::FUN_1004b6d0(MxLong p_time)
}
if (und != 0) {
viewROI->WrappedSetLocalTransform(m_tranInfo->m_unk0x2c);
viewROI->WrappedSetLocal2WorldWithWorldDataUpdate(m_tranInfo->m_unk0x2c);
VideoManager()->Get3DManager()->Moved(*viewROI);
m_world->PlaceActor(actor);
}

6
LEGO1/lego/legoomni/src/common/legocharactermanager.cpp
View File

@ -553,7 +553,7 @@ LegoROI* LegoCharacterManager::CreateActorROI(const char* p_key)
Mx3DPointFloat(g_actorLODs[i + 1].m_up),
mat
);
childROI->WrappedSetLocalTransform(mat);
childROI->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
if (g_actorLODs[i + 1].m_flags & LegoActorLOD::c_flag1 && (i != 0 || part.m_unk0x00[part.m_unk0x08] != 0)) {
@ -579,7 +579,7 @@ LegoROI* LegoCharacterManager::CreateActorROI(const char* p_key)
Mx3DPointFloat(g_actorLODs[c_topLOD].m_up),
mat
);
roi->WrappedSetLocalTransform(mat);
roi->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
info->m_roi = roi;
success = TRUE;
@ -1068,7 +1068,7 @@ MxResult LegoCharacterManager::FUN_10085870(LegoROI* p_roi)
p_roi->SetUnknown0x80(boundingBox);
p_roi->VTable0x14();
p_roi->WrappedUpdateWorldData();
result = SUCCESS;
}

2
LEGO1/lego/legoomni/src/common/legogamestate.cpp
View File

@ -217,7 +217,7 @@ void LegoGameState::SetActor(MxU8 p_actorId)
newActor->SetROI(roi, FALSE, FALSE);
if (oldActor) {
newActor->GetROI()->FUN_100a58f0(oldActor->GetROI()->GetLocal2World());
newActor->GetROI()->SetLocal2World(oldActor->GetROI()->GetLocal2World());
newActor->SetBoundary(oldActor->GetBoundary());
delete oldActor;
}

4
LEGO1/lego/legoomni/src/common/legoplantmanager.cpp
View File

@ -667,8 +667,8 @@ MxResult LegoPlantManager::Tickle()
SET3(locald8[3], localec);
entry->m_roi->FUN_100a58f0(locald8);
entry->m_roi->VTable0x14();
entry->m_roi->SetLocal2World(locald8);
entry->m_roi->WrappedUpdateWorldData();
if (entry->m_time < time) {
LegoPlantInfo* info = GetInfo(entry->m_entity);

6
LEGO1/lego/legoomni/src/common/legoutils.cpp
View File

@ -91,7 +91,7 @@ void RotateY(LegoROI* p_roi, MxFloat p_angle)
mat[i][2] = (local2world[i][2] * fcos) - (local2world[i][0] * fsin);
}
p_roi->WrappedSetLocalTransform(mat);
p_roi->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
}
// FUNCTION: LEGO1 0x1003de80
@ -223,7 +223,7 @@ void FUN_1003e050(LegoAnimPresenter* p_presenter)
LegoROI* roi = video->GetViewROI();
Lego3DView* view = video->Get3DManager()->GetLego3DView();
roi->WrappedSetLocalTransform(viewMatrix);
roi->WrappedSetLocal2WorldWithWorldDataUpdate(viewMatrix);
view->Moved(*roi);
FUN_1003eda0();
video->Get3DManager()->SetFrustrum(cam, 0.1, 250.0);
@ -486,7 +486,7 @@ void FUN_1003eda0()
LegoROI* viewROI = VideoManager()->GetViewROI();
if (viewROI) {
viewROI->FUN_100a5a30(vec);
viewROI->SetWorldVelocity(vec);
SoundManager()->UpdateListener(
viewROI->GetWorldPosition(),
viewROI->GetWorldDirection(),

8
LEGO1/lego/legoomni/src/entity/act2brick.cpp
View File

@ -108,8 +108,8 @@ void Act2Brick::FUN_1007a670(MxMatrix& p_param1, MxMatrix& p_param2, LegoPathBou
p_boundary->AddActor(this);
SetActorState(c_disabled);
m_roi->FUN_100a58f0(p_param1);
m_roi->VTable0x14();
m_roi->SetLocal2World(p_param1);
m_roi->WrappedUpdateWorldData();
m_roi->SetVisibility(TRUE);
}
@ -147,8 +147,8 @@ MxResult Act2Brick::Tickle()
VPV3(local2world[3], local2world[3], m_unk0x168);
}
m_roi->FUN_100a58f0(local2world);
m_roi->VTable0x14();
m_roi->SetLocal2World(local2world);
m_roi->WrappedUpdateWorldData();
return SUCCESS;
}

2
LEGO1/lego/legoomni/src/entity/legocameracontroller.cpp
View File

@ -172,7 +172,7 @@ void LegoCameraController::FUN_100123e0(const Matrix4& p_transform, MxU32 p_und)
}
((TimeROI*) pov)->FUN_100a9b40(mat, Timer()->GetTime());
pov->WrappedSetLocalTransform(mat);
pov->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
m_lego3DView->Moved(*pov);
SoundManager()->UpdateListener(

16
LEGO1/lego/legoomni/src/entity/legonavcontroller.cpp
View File

@ -450,8 +450,8 @@ MxResult LegoNavController::UpdateLocation(const char* p_location)
Mx3DPointFloat vec;
vec.Clear();
viewROI->FUN_100a5a30(vec);
viewROI->WrappedSetLocalTransform(mat);
viewROI->SetWorldVelocity(vec);
viewROI->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
VideoManager()->Get3DManager()->Moved(*viewROI);
SoundManager()->UpdateListener(
@ -488,8 +488,8 @@ MxResult LegoNavController::UpdateLocation(MxU32 p_location)
Mx3DPointFloat vec;
vec.Clear();
viewROI->FUN_100a5a30(vec);
viewROI->WrappedSetLocalTransform(mat);
viewROI->SetWorldVelocity(vec);
viewROI->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
VideoManager()->Get3DManager()->Moved(*viewROI);
SoundManager()->UpdateListener(
@ -936,7 +936,7 @@ MxLong LegoNavController::Notify(MxParam& p_param)
MxMatrix mat;
mat.SetIdentity();
mat.RotateX(0.2618f);
roi->WrappedVTable0x24(mat);
roi->WrappedUpdateWorldDataWithTransform(mat);
break;
}
case SDLK_J: {
@ -944,7 +944,7 @@ MxLong LegoNavController::Notify(MxParam& p_param)
MxMatrix mat;
mat.SetIdentity();
mat.RotateZ(0.2618f);
roi->WrappedVTable0x24(mat);
roi->WrappedUpdateWorldDataWithTransform(mat);
break;
}
case SDLK_K: {
@ -952,7 +952,7 @@ MxLong LegoNavController::Notify(MxParam& p_param)
LegoROI* roi = LegoOmni::GetInstance()->GetVideoManager()->GetViewROI();
mat.SetIdentity();
mat.RotateZ(-0.2618f);
roi->WrappedVTable0x24(mat);
roi->WrappedUpdateWorldDataWithTransform(mat);
break;
}
case SDLK_L:
@ -963,7 +963,7 @@ MxLong LegoNavController::Notify(MxParam& p_param)
MxMatrix mat;
mat.SetIdentity();
mat.RotateX(-0.2618f);
roi->WrappedVTable0x24(mat);
roi->WrappedUpdateWorldDataWithTransform(mat);
break;
}
case SDLK_N:

6
LEGO1/lego/legoomni/src/entity/legopovcontroller.cpp
View File

@ -154,7 +154,7 @@ MxResult LegoPointOfViewController::Tickle()
CalcLocalTransform(newPos, newDir, pov->GetWorldUp(), mat);
((TimeROI*) pov)->FUN_100a9b40(mat, Timer()->GetTime());
pov->WrappedSetLocalTransform(mat);
pov->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
m_lego3DView->Moved(*pov);
SoundManager()->UpdateListener(
@ -171,7 +171,7 @@ MxResult LegoPointOfViewController::Tickle()
Mx3DPointFloat vel;
vel.Clear();
pov->FUN_100a5a30(vel);
pov->SetWorldVelocity(vel);
SoundManager()->UpdateListener(
pov->GetWorldPosition(),
@ -210,7 +210,7 @@ void LegoPointOfViewController::SetEntity(LegoEntity* p_entity)
mat
);
pov->WrappedSetLocalTransform(mat);
pov->WrappedSetLocal2WorldWithWorldDataUpdate(mat);
}
else {
TickleManager()->RegisterClient(this, 10);

10
LEGO1/lego/legoomni/src/paths/legoextraactor.cpp
View File

@ -98,7 +98,7 @@ MxU32 LegoExtraActor::VTable0x90(float p_time, Matrix4& p_transform)
m_actorState = c_initial;
m_scheduledTime = 0.0f;
positionRef -= g_unk0x10104c18;
m_roi->FUN_100a58f0(p_transform);
m_roi->SetLocal2World(p_transform);
return TRUE;
}
}
@ -229,8 +229,8 @@ MxResult LegoExtraActor::HitActor(LegoPathActor* p_actor, MxBool p_bool)
}
if (!b) {
m_roi->FUN_100a58f0(matrix2);
m_roi->VTable0x14();
m_roi->SetLocal2World(matrix2);
m_roi->WrappedUpdateWorldData();
FUN_1002ad8a();
assert(m_roi);
assert(SoundManager()->GetCacheSoundManager());
@ -254,7 +254,7 @@ MxResult LegoExtraActor::HitActor(LegoPathActor* p_actor, MxBool p_bool)
MxMatrix matrix3 = MxMatrix(roi->GetLocal2World());
Vector3 positionRef(matrix3[3]);
positionRef += g_unk0x10104c18;
roi->FUN_100a58f0(matrix3);
roi->SetLocal2World(matrix3);
float dotX = dir.Dot(dir, Mx3DPointFloat(1.0f, 0, 0));
float dotZ = dir.Dot(dir, Mx3DPointFloat(0, 0, 1.0f));
@ -346,7 +346,7 @@ void LegoExtraActor::Animate(float p_time)
m_whichAnim = 0;
m_actorState = c_initial;
SetWorldSpeed(m_prevWorldSpeed);
m_roi->FUN_100a58f0(m_unk0x18);
m_roi->SetLocal2World(m_unk0x18);
m_lastTime = p_time;
break;
}

12
LEGO1/lego/legoomni/src/paths/legopathactor.cpp
View File

@ -382,12 +382,12 @@ MxS32 LegoPathActor::VTable0x8c(float p_time, Matrix4& p_transform)
void LegoPathActor::VTable0x74(Matrix4& p_transform)
{
if (m_userNavFlag) {
m_roi->WrappedSetLocalTransform(p_transform);
m_roi->WrappedSetLocal2WorldWithWorldDataUpdate(p_transform);
FUN_10010c30();
}
else {
m_roi->WrappedSetLocalTransform(p_transform);
m_roi->VTable0x14();
m_roi->WrappedSetLocal2WorldWithWorldDataUpdate(p_transform);
m_roi->WrappedUpdateWorldData();
if (m_cameraFlag) {
FUN_10010c30();
@ -731,11 +731,11 @@ void LegoPathActor::VTable0xa4(MxBool& p_und1, MxS32& p_und2)
void LegoPathActor::VTable0xa8()
{
m_lastTime = Timer()->GetTime();
m_roi->FUN_100a58f0(m_unk0xec);
m_roi->VTable0x14();
m_roi->SetLocal2World(m_unk0xec);
m_roi->WrappedUpdateWorldData();
if (m_userNavFlag) {
m_roi->WrappedSetLocalTransform(m_unk0xec);
m_roi->WrappedSetLocal2WorldWithWorldDataUpdate(m_unk0xec);
FUN_10010c30();
}
}

4
LEGO1/lego/legoomni/src/race/legoraceactor.cpp
View File

@ -84,7 +84,7 @@ MxU32 LegoRaceActor::VTable0x90(float p_time, Matrix4& p_transform)
m_unk0x08 = 0;
positionRef -= g_unk0x10102b08;
m_roi->FUN_100a58f0(p_transform);
m_roi->SetLocal2World(p_transform);
return TRUE;
}
}
@ -109,7 +109,7 @@ MxResult LegoRaceActor::HitActor(LegoPathActor* p_actor, MxBool p_bool)
Vector3(matr[3]) += g_unk0x10102b08;
roi->FUN_100a58f0(matr);
roi->SetLocal2World(matr);
p_actor->SetActorState(c_two);
}

6
LEGO1/lego/legoomni/src/race/legoracers.cpp
View File

@ -346,7 +346,7 @@ void LegoRaceCar::FUN_10012ff0(float p_param)
r->GetCameraController()->FUN_100123e0(transformationMatrix, 0);
}
m_roi->FUN_100a58f0(transformationMatrix);
m_roi->SetLocal2World(transformationMatrix);
}
}
}
@ -472,7 +472,7 @@ MxResult LegoRaceCar::HitActor(LegoPathActor* p_actor, MxBool p_bool)
matr = roi->GetLocal2World();
Vector3(matr[3]) += g_unk0x10102af0;
roi->FUN_100a58f0(matr);
roi->SetLocal2World(matr);
p_actor->SetActorState(c_two);
}
@ -686,7 +686,7 @@ MxResult LegoJetski::HitActor(LegoPathActor* p_actor, MxBool p_bool)
matr = roi->GetLocal2World();
Vector3(matr[3]) += g_unk0x10102af0;
roi->FUN_100a58f0(matr);
roi->SetLocal2World(matr);
p_actor->SetActorState(c_two);
}

6
LEGO1/lego/legoomni/src/video/legoanimpresenter.cpp
View File

@ -662,8 +662,8 @@ void LegoAnimPresenter::PutFrame()
dir *= dirsqr;
up *= upsqr;
m_unk0x8c[i]->FUN_100a58f0(mat);
m_unk0x8c[i]->VTable0x14();
m_unk0x8c[i]->SetLocal2World(mat);
m_unk0x8c[i]->WrappedUpdateWorldData();
}
}
}
@ -692,7 +692,7 @@ MxResult LegoAnimPresenter::FUN_1006afc0(MxMatrix*& p_matrix, float p_und)
if (m_roiMap[i] != NULL) {
mat = p_matrix[i];
p_matrix[i] = m_roiMap[i]->GetLocal2World();
m_roiMap[i]->FUN_100a58f0(mat);
m_roiMap[i]->SetLocal2World(mat);
}
}

4
LEGO1/lego/legoomni/src/video/legoloopinganimpresenter.cpp
View File

@ -75,8 +75,8 @@ void LegoLoopingAnimPresenter::PutFrame()
dir *= dirsqr;
up *= upsqr;
m_unk0x8c[i]->FUN_100a58f0(mat);
m_unk0x8c[i]->VTable0x14();
m_unk0x8c[i]->SetLocal2World(mat);
m_unk0x8c[i]->WrappedUpdateWorldData();
}
}
}

2
LEGO1/lego/legoomni/src/video/legovideomanager.cpp
View File

@ -211,7 +211,7 @@ MxResult LegoVideoManager::Create(MxVideoParam& p_videoParam, MxU32 p_frequencyM
pLODList->Release();
CalcLocalTransform(posVec, dirVec, upVec, outMatrix);
m_viewROI->WrappedSetLocalTransform(outMatrix);
m_viewROI->WrappedSetLocal2WorldWithWorldDataUpdate(outMatrix);
m_3dManager->Add(*m_viewROI);
m_3dManager->SetPointOfView(*m_viewROI);

24
LEGO1/lego/legoomni/src/worlds/legoact2.cpp
View File

@ -502,8 +502,8 @@ void LegoAct2::ReadyWorld()
MxMatrix local2world = roi->GetLocal2World();
local2world[3][0] -= 1.5;
roi->FUN_100a58f0(local2world);
roi->VTable0x14();
roi->SetLocal2World(local2world);
roi->WrappedUpdateWorldData();
roi = FindROI("Block02");
sphere = roi->GetBoundingSphere();
@ -688,8 +688,8 @@ void LegoAct2::FUN_100517b0()
local2world[3][1] += 1.5;
LegoROI* roi = brick.GetROI();
roi->FUN_100a58f0(local2world);
roi->VTable0x14();
roi->SetLocal2World(local2world);
roi->WrappedUpdateWorldData();
brick.PlayWhistleSound();
m_nextBrick++;
}
@ -828,9 +828,9 @@ void LegoAct2::SpawnBricks()
}
SET3(local2world[3], location);
roi->FUN_100a58f0(local2world);
roi->SetLocal2World(local2world);
roi->SetVisibility(TRUE);
roi->VTable0x14();
roi->WrappedUpdateWorldData();
entity = roi->GetEntity();
brick->PlayWhistleSound();
m_nextBrick++;
@ -852,9 +852,9 @@ void LegoAct2::SpawnBricks()
}
SET3(local2world[3], location);
roi->FUN_100a58f0(local2world);
roi->SetLocal2World(local2world);
roi->SetVisibility(TRUE);
roi->VTable0x14();
roi->WrappedUpdateWorldData();
entity = roi->GetEntity();
brick->PlayWhistleSound();
m_nextBrick++;
@ -876,9 +876,9 @@ void LegoAct2::SpawnBricks()
}
SET3(local2world[3], location);
roi->FUN_100a58f0(local2world);
roi->SetLocal2World(local2world);
roi->SetVisibility(TRUE);
roi->VTable0x14();
roi->WrappedUpdateWorldData();
entity = roi->GetEntity();
brick->PlayWhistleSound();
m_nextBrick++;
@ -914,9 +914,9 @@ void LegoAct2::SpawnBricks()
}
SET3(local2world[3], location);
roi->FUN_100a58f0(local2world);
roi->SetLocal2World(local2world);
roi->SetVisibility(TRUE);
roi->VTable0x14();
roi->WrappedUpdateWorldData();
entity = roi->GetEntity();
brick->PlayWhistleSound();
m_nextBrick++;

6
LEGO1/lego/sources/roi/legoroi.cpp
View File

@ -394,7 +394,7 @@ LegoResult LegoROI::FUN_100a8da0(LegoTreeNode* p_node, const Matrix4& p_matrix,
if (roi != NULL) {
FUN_100a8cb0(data, p_time, mat);
roi->m_local2world.Product(mat, p_matrix);
roi->VTable0x1c();
roi->UpdateWorldData();
LegoBool und = data->FUN_100a0990(p_time);
roi->SetVisibility(und);
@ -422,7 +422,7 @@ void LegoROI::FUN_100a8e80(LegoTreeNode* p_node, Matrix4& p_matrix, LegoTime p_t
LegoROI* roi = p_roiMap[data->GetUnknown0x20()];
if (roi != NULL) {
roi->m_local2world.Product(mat, p_matrix);
roi->VTable0x1c();
roi->UpdateWorldData();
LegoBool und = data->FUN_100a0990(p_time);
roi->SetVisibility(und);
@ -751,7 +751,7 @@ void TimeROI::FUN_100a9b40(Matrix4& p_matrix, LegoTime p_time)
targetPosition -= vec;
targetPosition /= time / 1000.0;
FUN_100a5a30(targetPosition);
SetWorldVelocity(targetPosition);
}
}

30
LEGO1/realtime/orientableroi.cpp
View File

@ -17,15 +17,15 @@ OrientableROI::OrientableROI()
IDENTMAT4(m_local2world);
m_parentROI = NULL;
ToggleUnknown0xd8(TRUE);
SetNeedsWorldDataUpdate(TRUE);
}
// Maybe an overload based on MxMatrix type
// FUNCTION: LEGO1 0x100a46a0
// FUNCTION: BETA10 0x10165268
void OrientableROI::WrappedSetLocalTransform(const Matrix4& p_transform)
void OrientableROI::WrappedSetLocal2WorldWithWorldDataUpdate(const Matrix4& p_local2world)
{
SetLocalTransform(p_transform);
SetLocal2WorldWithWorldDataUpdate(p_local2world);
}
// FUNCTION: LEGO1 0x100a46b0
@ -57,14 +57,14 @@ void OrientableROI::UpdateTransformationRelativeToParent(const Matrix4& p_transf
}
}
UpdateWorldData(mat);
UpdateWorldDataWithTransformAndChildren(mat);
}
// Maybe an overload based on MxMatrix type
// FUNCTION: LEGO1 0x100a5090
void OrientableROI::WrappedVTable0x24(const Matrix4& p_transform)
void OrientableROI::WrappedUpdateWorldDataWithTransform(const Matrix4& p_transform)
{
VTable0x24(p_transform);
UpdateWorldDataWithTransform(p_transform);
}
// FUNCTION: LEGO1 0x100a50a0
@ -101,21 +101,21 @@ void OrientableROI::GetLocalTransform(Matrix4& p_transform)
// FUNCTION: LEGO1 0x100a58f0
// FUNCTION: BETA10 0x10167b77
void OrientableROI::FUN_100a58f0(const Matrix4& p_transform)
void OrientableROI::SetLocal2World(const Matrix4& p_local2world)
{
m_local2world = p_transform;
ToggleUnknown0xd8(TRUE);
m_local2world = p_local2world;
SetNeedsWorldDataUpdate(TRUE);
}
// FUNCTION: LEGO1 0x100a5910
void OrientableROI::VTable0x1c()
void OrientableROI::UpdateWorldData()
{
UpdateWorldBoundingVolumes();
UpdateWorldVelocity();
}
// FUNCTION: LEGO1 0x100a5930
void OrientableROI::SetLocalTransform(const Matrix4& p_transform)
void OrientableROI::SetLocal2WorldWithWorldDataUpdate(const Matrix4& p_transform)
{
m_local2world = p_transform;
UpdateWorldBoundingVolumes();
@ -123,7 +123,7 @@ void OrientableROI::SetLocalTransform(const Matrix4& p_transform)
}
// FUNCTION: LEGO1 0x100a5960
void OrientableROI::VTable0x24(const Matrix4& p_transform)
void OrientableROI::UpdateWorldDataWithTransform(const Matrix4& p_transform)
{
MxMatrix l_matrix(m_local2world);
m_local2world.Product(p_transform, l_matrix);
@ -132,7 +132,7 @@ void OrientableROI::VTable0x24(const Matrix4& p_transform)
}
// FUNCTION: LEGO1 0x100a59b0
void OrientableROI::UpdateWorldData(const Matrix4& p_transform)
void OrientableROI::UpdateWorldDataWithTransformAndChildren(const Matrix4& p_transform)
{
MxMatrix l_matrix(m_local2world);
m_local2world.Product(l_matrix, p_transform);
@ -143,13 +143,13 @@ void OrientableROI::UpdateWorldData(const Matrix4& p_transform)
if (comp) {
for (CompoundObject::iterator iter = comp->begin(); !(iter == comp->end()); iter++) {
ROI* child = *iter;
static_cast<OrientableROI*>(child)->UpdateWorldData(p_transform);
static_cast<OrientableROI*>(child)->UpdateWorldDataWithTransformAndChildren(p_transform);
}
}
}
// FUNCTION: LEGO1 0x100a5a30
void OrientableROI::FUN_100a5a30(const Vector3& p_world_velocity)
void OrientableROI::SetWorldVelocity(const Vector3& p_world_velocity)
{
m_world_velocity = p_world_velocity;
}

26
LEGO1/realtime/orientableroi.h
View File

@ -27,21 +27,21 @@ class OrientableROI : public ROI {
const BoundingSphere& GetWorldBoundingSphere() const override; // vtable+0x10
// FUNCTION: LEGO1 0x100a5db0
virtual void VTable0x14() { VTable0x1c(); } // vtable+0x14
virtual void WrappedUpdateWorldData() { UpdateWorldData(); } // vtable+0x14
virtual void UpdateWorldBoundingVolumes() = 0; // vtable+0x18
virtual void VTable0x1c(); // vtable+0x1c
virtual void SetLocalTransform(const Matrix4& p_transform); // vtable+0x20
virtual void VTable0x24(const Matrix4& p_transform); // vtable+0x24
virtual void UpdateWorldData(const Matrix4& p_transform); // vtable+0x28
virtual void UpdateWorldVelocity(); // vtable+0x2c
virtual void UpdateWorldBoundingVolumes() = 0; // vtable+0x18
virtual void UpdateWorldData(); // vtable+0x1c
virtual void SetLocal2WorldWithWorldDataUpdate(const Matrix4& p_local2world); // vtable+0x20
virtual void UpdateWorldDataWithTransform(const Matrix4& p_transform); // vtable+0x24
virtual void UpdateWorldDataWithTransformAndChildren(const Matrix4& p_transform); // vtable+0x28
virtual void UpdateWorldVelocity(); // vtable+0x2c
void WrappedSetLocalTransform(const Matrix4& p_transform);
void WrappedSetLocal2WorldWithWorldDataUpdate(const Matrix4& p_local2world);
void UpdateTransformationRelativeToParent(const Matrix4& p_transform);
void WrappedVTable0x24(const Matrix4& p_transform);
void WrappedUpdateWorldDataWithTransform(const Matrix4& p_transform);
void GetLocalTransform(Matrix4& p_transform);
void FUN_100a58f0(const Matrix4& p_transform);
void FUN_100a5a30(const Vector3& p_world_velocity);
void SetLocal2World(const Matrix4& p_local2world);
void SetWorldVelocity(const Vector3& p_world_velocity);
// FUNCTION: BETA10 0x1000fbf0
const Matrix4& GetLocal2World() const { return m_local2world; }
@ -61,9 +61,9 @@ class OrientableROI : public ROI {
void SetParentROI(OrientableROI* p_parentROI) { m_parentROI = p_parentROI; }
// FUNCTION: BETA10 0x10168800
void ToggleUnknown0xd8(BOOL p_enable)
void SetNeedsWorldDataUpdate(BOOL p_needsWorldDataUpdate)
{
if (p_enable) {
if (p_needsWorldDataUpdate) {
m_unk0xd8 |= c_bit1 | c_bit2;
}
else {

332
LEGO1/tgl/d3drm/group.cpp
View File

@ -1,6 +1,6 @@
#include "impl.h"
#include <SDL3/SDL_log.h>
#include <assert.h>
using namespace TglImpl;
@ -11,168 +11,293 @@ void* GroupImpl::ImplementationDataPtr()
return reinterpret_cast<void*>(&m_data);
}
// FUNCTION: LEGO1 0x100a31e0
Result GroupImpl::SetTransformation(FloatMatrix4& matrix)
// FUNCTION: BETA10 0x1016c340
inline Result GroupSetTransformation(IDirect3DRMFrame2* pGroup, FloatMatrix4& matrix)
{
D3DRMMATRIX4D helper;
D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper);
return ResultVal(m_data->AddTransform(D3DRMCOMBINE_REPLACE, *d3dMatrix));
return ResultVal(pGroup->AddTransform(D3DRMCOMBINE_REPLACE, *d3dMatrix));
}
// FUNCTION: LEGO1 0x100a31e0
// FUNCTION: BETA10 0x1016a4d0
Result GroupImpl::SetTransformation(FloatMatrix4& matrix)
{
assert(m_data);
return GroupSetTransformation(m_data, matrix);
}
// FUNCTION: BETA10 0x1016c400
inline Result GroupSetColor(IDirect3DRMFrame2* pGroup, float r, float g, float b, float a)
{
if (a > 0) {
D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a);
return ResultVal(pGroup->SetColor(color));
}
else {
return ResultVal(pGroup->SetColorRGB(r, g, b));
}
}
// FUNCTION: LEGO1 0x100a3240
// FUNCTION: BETA10 0x1016a530
Result GroupImpl::SetColor(float r, float g, float b, float a)
{
// The first instruction makes no sense here:
// cmp dword ptr [esp + 0x10], 0
// This compares a, which we know is a float because it immediately
// gets passed into D3DRMCreateColorRGBA, but does the comparison
// as though it's an int??
if (*reinterpret_cast<int*>(&a) > 0) {
D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a);
return ResultVal(m_data->SetColor(color));
}
else {
return ResultVal(m_data->SetColorRGB(r, a, b));
}
assert(m_data);
return GroupSetColor(m_data, r, g, b, a);
}
// FUNCTION: BETA10 0x1016c5a0
inline Result GroupSetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture* pD3DTexture)
{
return ResultVal(pGroup->SetTexture(pD3DTexture));
}
// FUNCTION: BETA10 0x1016bcc0
inline Result GroupImpl::SetTexture(const TextureImpl* pTexture)
{
assert(m_data);
assert(!pTexture || pTexture->ImplementationData());
IDirect3DRMTexture* pD3DTexture = pTexture ? pTexture->ImplementationData() : NULL;
return GroupSetTexture(m_data, pD3DTexture);
}
// FUNCTION: LEGO1 0x100a32b0
// FUNCTION: BETA10 0x1016a5a0
Result GroupImpl::SetTexture(const Texture* pTexture)
{
IDirect3DRMTexture* pD3DTexture = pTexture ? static_cast<const TextureImpl*>(pTexture)->ImplementationData() : NULL;
return ResultVal(m_data->SetTexture(pD3DTexture));
assert(m_data);
return SetTexture(static_cast<const TextureImpl*>(pTexture));
}
// FUNCTION: BETA10 0x1016c640
inline Result GroupGetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture** pD3DTexture)
{
return ResultVal(pGroup->GetTexture(pD3DTexture));
}
// FUNCTION: BETA10 0x1016beb0
inline Result GroupImpl::GetTexture(TextureImpl** ppTexture)
{
assert(m_data);
assert(ppTexture);
TextureImpl* pTextureImpl = new TextureImpl();
assert(pTextureImpl);
// TODO: This helps retail match, but it adds to the stack
IDirect3DRMTexture* tex;
Result result = GroupGetTexture(m_data, &tex);
#ifndef BETA10
if (Succeeded(result)) {
result =
ResultVal(tex->QueryInterface(IID_IDirect3DRMTexture2, (LPVOID*) (&pTextureImpl->ImplementationData())));
}
#endif
*ppTexture = pTextureImpl;
return result;
}
// FUNCTION: LEGO1 0x100a32e0
// FUNCTION: BETA10 0x1016a600
Result GroupImpl::GetTexture(Texture*& pTexture)
{
IDirect3DRMTexture* pD3DTexture;
TextureImpl* holder = new TextureImpl();
Result result = ResultVal(m_data->GetTexture(&pD3DTexture));
if (result) {
// Seems to actually call the first virtual method of holder here
// but that doesn't make any sense since it passes three arguments
// to the method (self + string constant? + an offset?).
assert(m_data);
// This line makes the start of the function match and is what I
// would expect to see there but it clearly isn't what's actually
// there.
holder->SetImplementation(pD3DTexture);
}
pTexture = holder;
return Success;
return GetTexture(reinterpret_cast<TextureImpl**>(&pTexture));
}
// FUNCTION: BETA10 0x1016c500
inline Result GroupSetMaterialMode(IDirect3DRMFrame2* pGroup, MaterialMode mode)
{
D3DRMMATERIALMODE d3dMode = Translate(mode);
return ResultVal(pGroup->SetMaterialMode(d3dMode));
}
// FUNCTION: LEGO1 0x100a33c0
// FUNCTION: BETA10 0x1016a660
Result GroupImpl::SetMaterialMode(MaterialMode mode)
{
D3DRMMATERIALMODE d3dMode;
switch (mode) {
case FromParent:
d3dMode = D3DRMMATERIAL_FROMPARENT;
break;
case FromFrame:
d3dMode = D3DRMMATERIAL_FROMFRAME;
break;
case FromMesh:
d3dMode = D3DRMMATERIAL_FROMMESH;
break;
}
return ResultVal(m_data->SetMaterialMode(d3dMode));
assert(m_data);
return GroupSetMaterialMode(m_data, mode);
}
// FUNCTION: BETA10 0x1016c670
inline Result GroupAddGroup(IDirect3DRMFrame2* pGroup, const IDirect3DRMFrame* pChildGroup)
{
return ResultVal(pGroup->AddVisual(const_cast<IDirect3DRMFrame*>(pChildGroup)));
}
// FUNCTION: BETA10 0x1016c090
inline Result GroupImpl::Add(const GroupImpl& rGroup)
{
assert(m_data);
assert(rGroup.ImplementationData());
return GroupAddGroup(m_data, rGroup.ImplementationData());
}
// FUNCTION: LEGO1 0x100a3410
// FUNCTION: BETA10 0x1016a6c0
Result GroupImpl::Add(const Group* pGroup)
{
const GroupImpl* pGroupImpl = static_cast<const GroupImpl*>(pGroup);
return ResultVal(m_data->AddVisual(pGroupImpl->m_data));
assert(m_data);
assert(pGroup);
return Add(*static_cast<const GroupImpl*>(pGroup));
}
// FUNCTION: BETA10 0x1016c700
inline Result GroupAddMeshBuilder(IDirect3DRMFrame2* pGroup, const IDirect3DRMMesh* pMesh)
{
return ResultVal(pGroup->AddVisual(const_cast<IDirect3DRMMesh*>(pMesh)));
}
// FUNCTION: BETA10 0x1016bff0
inline Result GroupImpl::Add(const MeshBuilderImpl& rMesh)
{
assert(m_data);
assert(rMesh.ImplementationData());
return GroupAddMeshBuilder(m_data, rMesh.ImplementationData());
}
// FUNCTION: LEGO1 0x100a3430
// FUNCTION: BETA10 0x1016a740
Result GroupImpl::Add(const MeshBuilder* pMeshBuilder)
{
const MeshBuilderImpl* pMeshBuilderImpl = dynamic_cast<const MeshBuilderImpl*>(pMeshBuilder);
if (!pMeshBuilderImpl) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Invalid mesh builder");
return Result::Error;
}
return ResultVal(m_data->AddVisual(pMeshBuilderImpl->ImplementationData()));
assert(m_data);
assert(pMeshBuilder);
return Add(*static_cast<const MeshBuilderImpl*>(pMeshBuilder));
}
// FUNCTION: BETA10 0x1016c7b0
inline Result GroupRemoveMeshBuilder(IDirect3DRMFrame2* pGroup, const IDirect3DRMMesh* pMesh)
{
return ResultVal(pGroup->DeleteVisual(const_cast<IDirect3DRMMesh*>(pMesh)));
}
// FUNCTION: BETA10 0x1016c130
inline Result GroupImpl::Remove(const MeshBuilderImpl& rMesh)
{
assert(m_data);
assert(rMesh.ImplementationData());
return GroupRemoveMeshBuilder(m_data, rMesh.ImplementationData());
}
// FUNCTION: LEGO1 0x100a3450
// FUNCTION: BETA10 0x1016a7c0
Result GroupImpl::Remove(const MeshBuilder* pMeshBuilder)
{
const MeshBuilderImpl* pMeshBuilderImpl = static_cast<const MeshBuilderImpl*>(pMeshBuilder);
return ResultVal(m_data->DeleteVisual(pMeshBuilderImpl->ImplementationData()));
assert(m_data);
assert(pMeshBuilder);
return Remove(*static_cast<const MeshBuilderImpl*>(pMeshBuilder));
}
// FUNCTION: BETA10 0x1016c730
inline Result GroupRemoveGroup(IDirect3DRMFrame2* pGroup, const IDirect3DRMFrame* pChildGroup)
{
return ResultVal(pGroup->DeleteVisual(const_cast<IDirect3DRMFrame*>(pChildGroup)));
}
// FUNCTION: BETA10 0x1016c1d0
inline Result GroupImpl::Remove(const GroupImpl& rGroup)
{
assert(m_data);
assert(rGroup.ImplementationData());
return GroupRemoveGroup(m_data, rGroup.ImplementationData());
}
// FUNCTION: LEGO1 0x100a3480
// FUNCTION: BETA10 0x1016a840
Result GroupImpl::Remove(const Group* pGroup)
{
const GroupImpl* pGroupImpl = static_cast<const GroupImpl*>(pGroup);
return ResultVal(m_data->DeleteVisual(pGroupImpl->m_data));
assert(m_data);
assert(pGroup);
return Remove(*static_cast<const GroupImpl*>(pGroup));
}
// FUNCTION: LEGO1 0x100a34b0
Result GroupImpl::RemoveAll()
// FUNCTION: BETA10 0x1016c850
inline Result GroupRemoveAll(IDirect3DRMFrame2* pFrame)
{
IDirect3DRMVisualArray* visuals;
IDirect3DRMFrame2* frame = m_data;
Result result = (Result) SUCCEEDED(frame->GetVisuals(&visuals));
int refCount;
if (result == Success) {
Result result = ResultVal(pFrame->GetVisuals(&visuals));
assert(Succeeded(result));
if (Succeeded(result)) {
for (int i = 0; i < (int) visuals->GetSize(); i++) {
IDirect3DRMVisual* visual;
result = (Result) SUCCEEDED(visuals->GetElement(i, &visual));
frame->DeleteVisual(visual);
visual->Release();
result = ResultVal(visuals->GetElement(i, &visual));
assert(Succeeded(result));
result = ResultVal(pFrame->DeleteVisual(visual));
assert(Succeeded(result));
refCount = visual->Release();
}
visuals->Release();
refCount = visuals->Release();
assert(refCount == 0);
}
return result;
}
// FUNCTION: LEGO1 0x100a3540
Result GroupImpl::Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max)
// FUNCTION: LEGO1 0x100a34b0
// FUNCTION: BETA10 0x1016a8c0
Result GroupImpl::RemoveAll()
{
assert(m_data);
return GroupRemoveAll(m_data);
}
// FUNCTION: BETA10 0x1016cb70
inline Result GroupBounds(IDirect3DRMFrame2* pFrame, D3DVECTOR* p_min, D3DVECTOR* p_max)
{
D3DRMBOX size;
IDirect3DRMFrame2* frame = m_data;
int refCount;
size.min.x = 88888.f;
size.min.y = 88888.f;
size.min.z = 88888.f;
size.max.x = -88888.f;
size.max.y = -88888.f;
size.max.z = -88888.f;
size.min.x = size.min.y = size.min.z = 88888.f;
size.max.x = size.max.y = size.max.z = -88888.f;
IDirect3DRMVisualArray* visuals;
Result result = (Result) SUCCEEDED(frame->GetVisuals(&visuals));
Result result = ResultVal(pFrame->GetVisuals(&visuals));
assert(Succeeded(result));
if (result == Success) {
int i;
for (i = 0; i < (int) visuals->GetSize(); i++) {
if (Succeeded(result)) {
for (int i = 0; i < (int) visuals->GetSize(); i++) {
IDirect3DRMVisual* visual;
visuals->GetElement(i, &visual);
IDirect3DRMMesh* mesh;
result = ResultVal(visuals->GetElement(i, &visual));
assert(Succeeded(result));
/*
* BUG: should be:
* visual->QueryInterface(IID_IDirect3DRMMesh, (void**)&mesh));
*/
result = (Result) SUCCEEDED(visual->QueryInterface(IID_IDirect3DRMMeshBuilder, (void**) &mesh));
IDirect3DRMMesh* mesh;
result = ResultVal(visual->QueryInterface(IID_IDirect3DRMMeshBuilder, (void**) &mesh));
if (result == Success) {
if (Succeeded(result)) {
D3DRMBOX box;
result = (Result) SUCCEEDED(mesh->GetBox(&box));
result = ResultVal(mesh->GetBox(&box));
assert(Succeeded(result));
if (size.max.y < box.max.y) {
size.max.y = box.max.y;
}
if (size.max.z < box.max.z) {
size.max.z = box.max.z;
}
if (box.min.x < size.min.x) {
size.min.x = box.min.x;
}
@ -185,17 +310,36 @@ Result GroupImpl::Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max)
if (size.max.x < box.max.x) {
size.max.x = box.max.x;
}
if (size.max.y < box.max.y) {
size.max.y = box.max.y;
}
if (size.max.z < box.max.z) {
size.max.z = box.max.z;
}
mesh->Release();
}
visual->Release();
refCount = visual->Release();
}
visuals->Release();
refCount = visuals->Release();
}
*p_min = size.min;
*p_max = size.max;
p_min->x = size.min.x;
p_min->y = size.min.y;
p_min->z = size.min.z;
p_max->x = size.max.x;
p_max->y = size.max.y;
p_max->z = size.max.z;
return result;
}
// FUNCTION: LEGO1 0x100a3540
// FUNCTION: BETA10 0x1016a920
Result GroupImpl::Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max)
{
assert(m_data);
return GroupBounds(m_data, p_min, p_max);
}

44
LEGO1/tgl/d3drm/impl.h
View File

@ -437,6 +437,9 @@ class MeshImpl : public Mesh {
inline void Destroy();
inline Mesh* DeepClone(const MeshBuilderImpl& rMesh);
inline Result GetTexture(TextureImpl** ppTexture);
inline Result SetTexture(const TextureImpl* pTexture);
inline Mesh* ShallowClone(const MeshBuilderImpl& rMesh);
friend class RendererImpl;
@ -499,6 +502,12 @@ class GroupImpl : public Group {
GroupDataType& ImplementationData() { return m_data; }
inline void Destroy();
inline Result SetTexture(const TextureImpl* pTexture);
inline Result GetTexture(TextureImpl** ppTexture);
inline Result Add(const GroupImpl& rGroup);
inline Result Add(const MeshBuilderImpl& rMesh);
inline Result Remove(const GroupImpl& rGroup);
inline Result Remove(const MeshBuilderImpl& rMesh);
friend class RendererImpl;
@ -678,6 +687,18 @@ void TextureImpl::Destroy()
}
}
// Used by both Mesh and MeshBuilder
// FUNCTION: BETA10 0x10170270
inline Result MeshSetTextureMappingMode(MeshImpl::MeshData* pMesh, TextureMappingMode mode)
{
if (mode == PerspectiveCorrect) {
return ResultVal(pMesh->groupMesh->SetGroupMapping(pMesh->groupIndex, D3DRMMAP_PERSPCORRECT));
}
else {
return ResultVal(pMesh->groupMesh->SetGroupMapping(pMesh->groupIndex, 0));
}
}
// Translation helpers
// FUNCTION: BETA10 0x1016fc40
inline D3DRMRENDERQUALITY Translate(ShadingModel tglShadingModel)
@ -729,6 +750,7 @@ inline D3DRMPROJECTIONTYPE Translate(ProjectionType tglProjectionType)
// Yes this function serves no purpose, originally they intended it to
// convert from doubles to floats but ended up using floats throughout
// the software stack.
// FUNCTION: BETA10 0x1016fa10
inline D3DRMMATRIX4D* Translate(FloatMatrix4& tglMatrix4x4, D3DRMMATRIX4D& rD3DRMMatrix4x4)
{
for (int i = 0; i < (sizeof(rD3DRMMatrix4x4) / sizeof(rD3DRMMatrix4x4[0])); i++) {
@ -779,6 +801,26 @@ inline D3DRMLIGHTTYPE Translate(LightType tglLightType)
return lightType;
}
// FUNCTION: BETA10 0x101702e0
inline D3DRMMATERIALMODE Translate(MaterialMode mode)
{
D3DRMMATERIALMODE d3dMode;
switch (mode) {
case FromParent:
d3dMode = D3DRMMATERIAL_FROMPARENT;
break;
case FromFrame:
d3dMode = D3DRMMATERIAL_FROMFRAME;
break;
case FromMesh:
d3dMode = D3DRMMATERIAL_FROMMESH;
break;
}
return d3dMode;
}
} /* namespace TglImpl */
// SYNTHETIC: LEGO1 0x100a16d0
// SYNTHETIC: BETA10 0x10169aa0
// TglImpl::RendererImpl::`scalar deleting destructor'
@ -821,6 +863,4 @@ inline D3DRMLIGHTTYPE Translate(LightType tglLightType)
// GLOBAL: LEGO1 0x100dd1e0
// IID_IDirect3DRMMeshBuilder
} /* namespace TglImpl */
#endif

148
LEGO1/tgl/d3drm/mesh.cpp
View File

@ -16,39 +16,60 @@ void* MeshImpl::ImplementationDataPtr()
return reinterpret_cast<void*>(&m_data);
}
// FUNCTION: LEGO1 0x100a3ee0
Result MeshImpl::SetColor(float r, float g, float b, float a)
// FUNCTION: BETA10 0x10170590
inline Result MeshSetColor(MeshImpl::MeshData* pMesh, float r, float g, float b, float a)
{
// The first instruction makes no sense here:
// cmp dword ptr [esp + 0x10], 0
// This compares a, which we know is a float because it immediately
// gets passed into D3DRMCreateColorRGBA, but does the comparison
// as though it's an int??
if (*reinterpret_cast<int*>(&a) > 0) {
if (a > 0) {
D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a);
return ResultVal(m_data->groupMesh->SetGroupColor(m_data->groupIndex, color));
return ResultVal(pMesh->groupMesh->SetGroupColor(pMesh->groupIndex, color));
}
else {
return ResultVal(m_data->groupMesh->SetGroupColorRGB(m_data->groupIndex, r, g, b));
return ResultVal(pMesh->groupMesh->SetGroupColorRGB(pMesh->groupIndex, r, g, b));
}
}
// FUNCTION: LEGO1 0x100a3ee0
// FUNCTION: BETA10 0x10170520
Result MeshImpl::SetColor(float r, float g, float b, float a)
{
assert(m_data);
return MeshSetColor(m_data, r, g, b, a);
}
// FUNCTION: BETA10 0x10171320
inline Result MeshSetTexture(MeshImpl::MeshData* pMesh, IDirect3DRMTexture* pD3DTexture)
{
Result result = ResultVal(pMesh->groupMesh->SetGroupTexture(pMesh->groupIndex, pD3DTexture));
return result;
}
// FUNCTION: BETA10 0x10171260
inline Result MeshImpl::SetTexture(const TextureImpl* pTexture)
{
assert(m_data);
assert(!pTexture || pTexture->ImplementationData());
IDirect3DRMTexture* pD3DTexture = pTexture ? pTexture->ImplementationData() : NULL;
return MeshSetTexture(m_data, pD3DTexture);
}
// FUNCTION: LEGO1 0x100a3f50
// FUNCTION: BETA10 0x10170630
Result MeshImpl::SetTexture(const Texture* pTexture)
{
IDirect3DRMTexture* texture = pTexture ? static_cast<const TextureImpl*>(pTexture)->ImplementationData() : NULL;
return ResultVal(m_data->groupMesh->SetGroupTexture(m_data->groupIndex, texture));
assert(m_data);
return SetTexture(static_cast<const TextureImpl*>(pTexture));
}
// FUNCTION: LEGO1 0x100a3f80
// FUNCTION: BETA10 0x10170690
Result MeshImpl::SetTextureMappingMode(TextureMappingMode mode)
{
if (mode == PerspectiveCorrect) {
return ResultVal(m_data->groupMesh->SetGroupMapping(m_data->groupIndex, D3DRMMAP_PERSPCORRECT));
}
else {
return ResultVal(m_data->groupMesh->SetGroupMapping(m_data->groupIndex, D3DRMMAP_NONE));
}
assert(m_data);
return MeshSetTextureMappingMode(m_data, mode);
}
// FUNCTION: BETA10 0x10170750
@ -159,39 +180,80 @@ Mesh* MeshImpl::DeepClone(MeshBuilder* pMesh)
return DeepClone(*static_cast<MeshBuilderImpl*>(pMesh));
}
inline Result MeshShallowClone(MeshImpl::MeshData* pSource, MeshImpl::MeshData*& rpTarget, IDirect3DRMMesh* pMesh)
{
Result result = Error;
rpTarget = new MeshImpl::MeshData();
if (rpTarget) {
rpTarget->groupMesh = pMesh;
rpTarget->groupIndex = pSource->groupIndex;
result = Success;
}
return result;
}
inline Mesh* MeshImpl::ShallowClone(const MeshBuilderImpl& rMesh)
{
assert(m_data);
assert(rMesh.ImplementationData());
MeshImpl* clone = new MeshImpl();
assert(!clone->ImplementationData());
if (!MeshShallowClone(m_data, clone->ImplementationData(), rMesh.ImplementationData())) {
delete clone;
clone = NULL;
}
return clone;
}
// FUNCTION: LEGO1 0x100a4240
Mesh* MeshImpl::ShallowClone(MeshBuilder* pMeshBuilder)
{
MeshImpl* newGroup = new MeshImpl();
MeshData* newData = new MeshData();
newGroup->m_data = newData;
if (newData) {
newData->groupIndex = m_data->groupIndex;
newData->groupMesh = static_cast<MeshBuilderImpl*>(pMeshBuilder)->ImplementationData();
assert(m_data);
assert(pMeshBuilder);
return ShallowClone(*static_cast<MeshBuilderImpl*>(pMeshBuilder));
}
// FUNCTION: BETA10 0x10171ac0
inline Result MeshGetTexture(MeshImpl::MeshData* pMesh, IDirect3DRMTexture** pD3DTexture)
{
return ResultVal(pMesh->groupMesh->GetGroupTexture(pMesh->groupIndex, pD3DTexture));
}
// FUNCTION: BETA10 0x10171980
inline Result MeshImpl::GetTexture(TextureImpl** ppTexture)
{
assert(m_data);
assert(ppTexture);
TextureImpl* pTextureImpl = new TextureImpl();
assert(pTextureImpl);
// TODO: This helps retail match, but it adds to the stack
IDirect3DRMTexture* tex;
Result result = MeshGetTexture(m_data, &tex);
#ifndef BETA10
if (Succeeded(result)) {
result =
ResultVal(tex->QueryInterface(IID_IDirect3DRMTexture2, (LPVOID*) (&pTextureImpl->ImplementationData())));
}
else {
delete newGroup;
newGroup = NULL;
}
return newGroup;
#endif
*ppTexture = pTextureImpl;
return result;
}
// FUNCTION: LEGO1 0x100a4330
// FUNCTION: BETA10 0x10170820
Result MeshImpl::GetTexture(Texture*& rpTexture)
{
IDirect3DRMTexture* texture;
TextureImpl* holder = new TextureImpl();
Result result = ResultVal(m_data->groupMesh->GetGroupTexture(m_data->groupIndex, &texture));
if (result) {
// Seems to actually call the first virtual method of holder here
// but that doesn't make any sense since it passes three arguments
// to the method (self + string constant? + an offset?).
assert(m_data);
// This line makes the start of the function match and is what I
// would expect to see there but it clearly isn't what's actually
// there.
holder->SetImplementation(texture);
}
rpTexture = holder;
return Success;
return GetTexture(reinterpret_cast<TextureImpl**>(&rpTexture));
}

16
LEGO1/viewmanager/viewroi.cpp
View File

@ -28,9 +28,9 @@ const Tgl::Group* ViewROI::GetGeometry() const
}
// FUNCTION: LEGO1 0x100a9ee0
void ViewROI::UpdateWorldData(const Matrix4& parent2world)
void ViewROI::UpdateWorldDataWithTransformAndChildren(const Matrix4& parent2world)
{
OrientableROI::UpdateWorldData(parent2world);
OrientableROI::UpdateWorldDataWithTransformAndChildren(parent2world);
if (geometry) {
Tgl::FloatMatrix4 matrix;
@ -42,9 +42,9 @@ void ViewROI::UpdateWorldData(const Matrix4& parent2world)
}
// FUNCTION: LEGO1 0x100a9fc0
void ViewROI::VTable0x24(const Matrix4& p_transform)
void ViewROI::UpdateWorldDataWithTransform(const Matrix4& p_transform)
{
OrientableROI::VTable0x24(p_transform);
OrientableROI::UpdateWorldDataWithTransform(p_transform);
if (geometry) {
Tgl::FloatMatrix4 matrix;
Matrix4 in(matrix);
@ -54,9 +54,9 @@ void ViewROI::VTable0x24(const Matrix4& p_transform)
}
// FUNCTION: LEGO1 0x100aa0a0
void ViewROI::SetLocalTransform(const Matrix4& p_transform)
void ViewROI::SetLocal2WorldWithWorldDataUpdate(const Matrix4& p_transform)
{
OrientableROI::SetLocalTransform(p_transform);
OrientableROI::SetLocal2WorldWithWorldDataUpdate(p_transform);
if (geometry) {
Tgl::FloatMatrix4 matrix;
Matrix4 in(matrix);
@ -66,9 +66,9 @@ void ViewROI::SetLocalTransform(const Matrix4& p_transform)
}
// FUNCTION: LEGO1 0x100aa180
void ViewROI::VTable0x1c()
void ViewROI::UpdateWorldData()
{
OrientableROI::VTable0x1c();
OrientableROI::UpdateWorldData();
if (geometry) {
Tgl::FloatMatrix4 matrix;
Matrix4 in(matrix);

14
LEGO1/viewmanager/viewroi.h
View File

@ -49,12 +49,12 @@ class ViewROI : public OrientableROI {
}
}
float IntrinsicImportance() const override; // vtable+0x04
void VTable0x1c() override; // vtable+0x1c
void SetLocalTransform(const Matrix4& p_transform) override; // vtable+0x20
void VTable0x24(const Matrix4& p_transform) override; // vtable+0x24
virtual Tgl::Group* GetGeometry(); // vtable+0x30
virtual const Tgl::Group* GetGeometry() const; // vtable+0x34
float IntrinsicImportance() const override; // vtable+0x04
void UpdateWorldData() override; // vtable+0x1c
void SetLocal2WorldWithWorldDataUpdate(const Matrix4& p_transform) override; // vtable+0x20
void UpdateWorldDataWithTransform(const Matrix4& p_transform) override; // vtable+0x24
virtual Tgl::Group* GetGeometry(); // vtable+0x30
virtual const Tgl::Group* GetGeometry() const; // vtable+0x34
int GetUnknown0xe0() { return m_unk0xe0; }
void SetUnknown0xe0(int p_unk0xe0) { m_unk0xe0 = p_unk0xe0; }
@ -62,7 +62,7 @@ class ViewROI : public OrientableROI {
static unsigned char SetLightSupport(unsigned char p_lightSupport);
protected:
void UpdateWorldData(const Matrix4& parent2world) override; // vtable+0x28
void UpdateWorldDataWithTransformAndChildren(const Matrix4& parent2world) override; // vtable+0x28
Tgl::Group* geometry; // 0xdc
int m_unk0xe0; // 0xe0