AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Basic CGameAllocator implementation (WIP)

This commit is contained in:
Phillip Stephens 2017-09-12 08:27:48 -07:00
parent c0d5cee8b1
commit 001125429f
21 changed files with 363 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
Runtime/CGameAllocator.cpp Normal file
View File

@ -0,0 +1,61 @@
#include "CGameAllocator.hpp"
namespace urde
{
logvisor::Module AllocLog("urde::CGameAllocator");
std::vector<CGameAllocator::SAllocationDescription> CGameAllocator::m_allocations;
u8* CGameAllocator::Alloc(size_t len)
{
size_t roundedLen = ROUND_UP_64(len + sizeof(SChunkDescription));
for (SAllocationDescription& alloc : m_allocations)
{
/* We need to supply enough room for allocation information */
if (alloc.freeOffset + roundedLen < alloc.allocSize)
{
u8* ptr = alloc.memptr.get() + alloc.freeOffset;
SChunkDescription* chunkInfo = reinterpret_cast<SChunkDescription*>(ptr);
*chunkInfo = SChunkDescription();
chunkInfo->parent = &alloc;
chunkInfo->len = len;
alloc.freeOffset += roundedLen;
return ptr + sizeof(SChunkDescription);
}
}
/* 1MiB minimum allocation to prevent constantly allocating small amounts of memory */
size_t allocSz = len;
if (allocSz < (1 * 1024 * 1024 * 1024))
allocSz = 1 * 1024 * 1024 * 1024;
/* Pad size to allow for allocation information */
allocSz = ROUND_UP_64(allocSz + sizeof(SChunkDescription));
m_allocations.emplace_back();
m_allocations.back().memptr.reset(new u8[allocSz]);
u8* ptr = m_allocations.back().memptr.get();
m_allocations.back().allocSize = allocSz;
m_allocations.back().freeOffset += roundedLen;
SChunkDescription* chunkInfo = reinterpret_cast<SChunkDescription*>(ptr);
*chunkInfo = SChunkDescription();
chunkInfo->parent = &m_allocations.back();
chunkInfo->len = len;
return ptr + sizeof(SChunkDescription);
}
void CGameAllocator::Free(u8* ptr)
{
SChunkDescription* info = reinterpret_cast<SChunkDescription*>(ptr - sizeof(SChunkDescription));
if (info->magic != 0xE8E8E8E8 || info->sentinal != 0xEFEFEFEF)
{
AllocLog.report(logvisor::Fatal, _S("Invalid chunk description, memory corruption!"));
return;
}
SAllocationDescription& alloc = *info->parent;
size_t roundedLen = ROUND_UP_32(info->len + sizeof(SChunkDescription));
alloc.freeOffset -= roundedLen;
/* Invalidate chunk allocation descriptor */
memset(info, 0, ROUND_UP_64(info->len + sizeof(SChunkDescription)));
}
}

34
Runtime/CGameAllocator.hpp Normal file
View File

@ -0,0 +1,34 @@
#ifndef __URDE_CGAMEALLOCATOR_HPP__
#define __URDE_CGAMEALLOCATOR_HPP__
#include "RetroTypes.hpp"
namespace urde
{
class CGameAllocator
{
struct SAllocationDescription
{
std::unique_ptr<u8[]> memptr;
size_t allocSize = 0;
ptrdiff_t freeOffset = 0;
};
struct SChunkDescription
{
u32 magic = 0xE8E8E8E8;
SAllocationDescription* parent;
size_t len = 0;
u32 sentinal = 0xEFEFEFEF;
};
static std::vector<SAllocationDescription> m_allocations;
public:
static u8* Alloc(size_t len);
static void Free(u8* ptr);
};
}
#endif

4
Runtime/CGameOptions.cpp
View File

@ -67,7 +67,7 @@ CPersistentOptions::CPersistentOptions(CBitStreamReader& stream)
xc0_frozenFpsCount = stream.ReadEncoded(2);
xc4_frozenBallCount = stream.ReadEncoded(2);
xc8_ = stream.ReadEncoded(1);
xc8_powerBombAmmoCount = stream.ReadEncoded(1);
xcc_logScanPercent = stream.ReadEncoded(7);
xd0_24_fusionLinked = stream.ReadEncoded(1);
xd0_25_normalModeBeat = stream.ReadEncoded(1);
@ -113,7 +113,7 @@ void CPersistentOptions::PutTo(CBitStreamWriter& w) const
w.WriteEncoded(xc0_frozenFpsCount, 2);
w.WriteEncoded(xc4_frozenBallCount, 2);
w.WriteEncoded(xc8_, 1);
w.WriteEncoded(xc8_powerBombAmmoCount, 1);
w.WriteEncoded(xcc_logScanPercent, 7);
w.WriteEncoded(xd0_24_fusionLinked, 1);
w.WriteEncoded(xd0_25_normalModeBeat, 1);

8
Runtime/CGameOptions.hpp
View File

@ -61,7 +61,7 @@ class CPersistentOptions
u32 xbc_autoMapperKeyState = 0;
u32 xc0_frozenFpsCount = 0;
u32 xc4_frozenBallCount = 0;
u32 xc8_ = 0;
u32 xc8_powerBombAmmoCount = 0;
u32 xcc_logScanPercent = 0;
union
@ -104,6 +104,12 @@ public:
bool GetShowFrozenFpsMessage() const { return xc0_frozenFpsCount != 3; }
void IncrementFrozenBallCount() { xc4_frozenBallCount = std::min(int(xc4_frozenBallCount + 1), 3); }
bool GetShowFrozenBallMessage() const { return xc4_frozenBallCount != 3; }
bool GetShowPowerBombAmmoMessage() const { return xc8_powerBombAmmoCount != 1; }
void IncrementPowerBombAmmoCount()
{
xc8_powerBombAmmoCount = std::min<u32>(1, xc8_powerBombAmmoCount + 1);
}
void PutTo(CBitStreamWriter& w) const;
u8* GetNESState() { return x0_; }

1
Runtime/CMakeLists.txt
View File

@ -65,6 +65,7 @@ add_library(RuntimeCommon
${WEAPON_SOURCES}
ITweak.hpp
IMain.hpp
CGameAllocator.hpp CGameAllocator.cpp
CMemoryCardSys.hpp CMemoryCardSys.cpp
CScannableObjectInfo.hpp CScannableObjectInfo.cpp
CSaveWorld.hpp CSaveWorld.cpp

50
Runtime/CPlayerState.cpp
View File

@ -167,18 +167,18 @@ u32 CPlayerState::CalculateItemCollectionRate() const
total += GetItemCapacity(EItemType::GravitySuit);
total += GetItemCapacity(EItemType::VariaSuit);
total += GetItemCapacity(EItemType::EnergyTanks);
total += GetItemCapacity(EItemType::ArtifactOfTruth);
total += GetItemCapacity(EItemType::ArtifactOfStrength);
total += GetItemCapacity(EItemType::ArtifactOfElder);
total += GetItemCapacity(EItemType::ArtifactOfWild);
total += GetItemCapacity(EItemType::ArtifactOfLifegiver);
total += GetItemCapacity(EItemType::ArtifactOfWarrior);
total += GetItemCapacity(EItemType::ArtifactOfChozo);
total += GetItemCapacity(EItemType::ArtifactOfNature);
total += GetItemCapacity(EItemType::ArtifactOfSun);
total += GetItemCapacity(EItemType::ArtifactOfWorld);
total += GetItemCapacity(EItemType::ArtifactOfSpirit);
total += GetItemCapacity(EItemType::ArtifactOfNewborn);
total += GetItemCapacity(EItemType::Truth);
total += GetItemCapacity(EItemType::Strength);
total += GetItemCapacity(EItemType::Elder);
total += GetItemCapacity(EItemType::Wild);
total += GetItemCapacity(EItemType::Lifegiver);
total += GetItemCapacity(EItemType::Warrior);
total += GetItemCapacity(EItemType::Chozo);
total += GetItemCapacity(EItemType::Nature);
total += GetItemCapacity(EItemType::Sun);
total += GetItemCapacity(EItemType::World);
total += GetItemCapacity(EItemType::Spirit);
total += GetItemCapacity(EItemType::Newborn);
return total + GetItemCapacity(EItemType::Wavebuster);
}
@ -332,7 +332,7 @@ u32 CPlayerState::GetItemAmount(CPlayerState::EItemType type) const
type == EItemType::Flamethrower ||
type == EItemType::EnergyTanks ||
type == EItemType::Missiles ||
(type >= EItemType::ArtifactOfTruth && type <= EItemType::ArtifactOfNewborn))
(type >= EItemType::Truth && type <= EItemType::Newborn))
{
return x24_powerups[u32(type)].x0_amount;
}
@ -364,18 +364,18 @@ void CPlayerState::IncrPickup(EItemType type, s32 amount)
case EItemType::ChargeBeam:
case EItemType::SpaceJumpBoots:
case EItemType::EnergyTanks:
case EItemType::ArtifactOfTruth:
case EItemType::ArtifactOfStrength:
case EItemType::ArtifactOfElder:
case EItemType::ArtifactOfWild:
case EItemType::ArtifactOfLifegiver:
case EItemType::ArtifactOfWarrior:
case EItemType::ArtifactOfChozo:
case EItemType::ArtifactOfNature:
case EItemType::ArtifactOfSun:
case EItemType::ArtifactOfWorld:
case EItemType::ArtifactOfSpirit:
case EItemType::ArtifactOfNewborn:
case EItemType::Truth:
case EItemType::Strength:
case EItemType::Elder:
case EItemType::Wild:
case EItemType::Lifegiver:
case EItemType::Warrior:
case EItemType::Chozo:
case EItemType::Nature:
case EItemType::Sun:
case EItemType::World:
case EItemType::Spirit:
case EItemType::Newborn:
{
CPowerUp& pup = x24_powerups[u32(type)];
pup.x0_amount = std::min(pup.x0_amount + amount, pup.x4_capacity);

24
Runtime/CPlayerState.hpp
View File

@ -47,18 +47,18 @@ public:
HealthRefill = 26,
UnknownItem2 = 27,
Wavebuster = 28,
ArtifactOfTruth = 29,
ArtifactOfStrength = 30,
ArtifactOfElder = 31,
ArtifactOfWild = 32,
ArtifactOfLifegiver = 33,
ArtifactOfWarrior = 34,
ArtifactOfChozo = 35,
ArtifactOfNature = 36,
ArtifactOfSun = 37,
ArtifactOfWorld = 38,
ArtifactOfSpirit = 39,
ArtifactOfNewborn = 40,
Truth = 29,
Strength = 30,
Elder = 31,
Wild = 32,
Lifegiver = 33,
Warrior = 34,
Chozo = 35,
Nature = 36,
Sun = 37,
World = 38,
Spirit = 39,
Newborn = 40,
/* This must remain at the end of the list */
Max

7
Runtime/CStateManager.hpp
View File

@ -380,6 +380,7 @@ public:
TUniqueId GetSkipCinematicSpecialFunction() const { return xf38_skipCineSpecialFunc; }
void SetSkipCinematicSpecialFunction(TUniqueId id) { xf38_skipCineSpecialFunc = id; }
float GetHUDMessageTime() const { return xf78_hudMessageTime; }
u32 GetHUDMessageFrameCount() const { return xf80_hudMessageFrameCount; }
CAssetId GetPauseHUDMessage() const { return xf08_pauseHudMessage; }
void IncrementHUDMessageFrameCounter() { ++xf80_hudMessageFrameCount; }
bool ShouldQuitGame() const { return xf94_25_quitGame; }
@ -441,6 +442,12 @@ public:
void SetThermalColdScale2(float s) { xf28_thermColdScale2 = s; }
float IntegrateVisorFog(float f) const;
u32 GetUpdateFrameIndex() const { return x8d8_updateFrameIdx; }
void sub_80043F2C(u32 frameCount, CAssetId msg, float f1)
{
xf84_ = frameCount;
xf88_ = msg;
xf8c_ = f1;
}
static float g_EscapeShakeCountdown;
static bool g_EscapeShakeCountdownInit;

2
Runtime/MP1/CArtifactDoll.cpp
View File

@ -66,7 +66,7 @@ int CArtifactDoll::GetArtifactHeadScanIndex(CAssetId scanId)
CAssetId CArtifactDoll::GetArtifactHeadScanFromItemType(CPlayerState::EItemType item)
{
if (item < CPlayerState::EItemType::ArtifactOfTruth || item > CPlayerState::EItemType::ArtifactOfNewborn)
if (item < CPlayerState::EItemType::Truth || item > CPlayerState::EItemType::Newborn)
return -1;
return g_ResFactory->TranslateOriginalToNew(ArtifactHeadScans[int(item) - 29]);
}

5
Runtime/World/CExplosion.cpp
View File

@ -1,4 +1,5 @@
#include "CExplosion.hpp"
#include "TCastTo.hpp"
namespace urde
{
@ -22,4 +23,8 @@ CExplosion::CExplosion(const TLockedToken<CGenDescription>& particle, TUniqueId
xe8_particleGen->SetModulationColor(color);
}
void CExplosion::Accept(IVisitor& visitor)
{
visitor.Visit(this);
}
}

2
Runtime/World/CExplosion.hpp
View File

@ -22,6 +22,8 @@ public:
CExplosion(const TLockedToken<CGenDescription>& particle, TUniqueId uid, bool active,
const CEntityInfo& info, const std::string& name, const zeus::CTransform& xf,
u32, const zeus::CVector3f& scale, const zeus::CColor& color);
void Accept(IVisitor&);
};
}

13
Runtime/World/CGameArea.cpp
View File

@ -480,9 +480,18 @@ float CGameArea::GetXRayFogDistance() const
return 1.f;
}
bool CGameArea::DoesAreaNeedEnvFx() const
EEnvFxType CGameArea::DoesAreaNeedEnvFx() const
{
return false;
const CPostConstructed* postConstructed = GetPostConstructed();
if (!postConstructed)
return EEnvFxType::None;
const CScriptAreaAttributes* attrs = postConstructed->x10d8_areaAttributes;
if (attrs)
return EEnvFxType::None;
if (postConstructed->x10dc_occlusionState == EOcclusionState::Occluded)
return EEnvFxType::None;
return attrs->GetEnvFxType();
}
bool CGameArea::DoesAreaNeedSkyNow() const

3
Runtime/World/CGameArea.hpp
View File

@ -17,6 +17,7 @@
#include "Graphics/CModel.hpp"
#include "CPathFindArea.hpp"
#include "Editor/ProjectResourceFactoryBase.hpp"
#include "World/CEnvFxManager.hpp"
namespace urde
{
@ -311,7 +312,7 @@ public:
const CAreaFog* GetAreaFog() const { return GetPostConstructed()->x10c4_areaFog.get(); }
CAreaFog* AreaFog() { return const_cast<CAreaFog*>(GetAreaFog()); }
float GetXRayFogDistance() const;
bool DoesAreaNeedEnvFx() const;
EEnvFxType DoesAreaNeedEnvFx() const;
bool DoesAreaNeedSkyNow() const;
bool OtherAreaOcclusionChanged();
void PingOcclusionState();

2
Runtime/World/CScriptAreaAttributes.hpp
View File

@ -28,6 +28,8 @@ public:
bool GetNeedsSky() const { return x34_24_showSkybox; }
bool GetNeedsEnvFx() const { return x38_envFx != EEnvFxType::None; }
CAssetId GetSkyModel() const { return x4c_skybox; }
EEnvFxType GetEnvFxType() const { return x38_envFx; }
float GetEnvFxDensity() const { return x3c_envFxDensity; }
float GetThermalHeat() const { return x40_thermalHeat; }
float GetXRayFogDistance() const { return x44_xrayFogDistance; }

111
Runtime/World/CScriptPickup.cpp
View File

@ -1,19 +1,120 @@
#include "CScriptPickup.hpp"
#include "Particle/CGenDescription.hpp"
#include "GameGlobalObjects.hpp"
#include "MP1/CArtifactDoll.hpp"
#include "CExplosion.hpp"
#include "CSimplePool.hpp"
#include "TCastTo.hpp"
#include "CPlayer.hpp"
#include "CGameState.hpp"
#include "CGameOptions.hpp"
#include "MP1/CSamusHud.hpp"
#include "GuiSys/CStringTable.hpp"
namespace urde
{
CScriptPickup::CScriptPickup(TUniqueId uid, const std::string& name, const CEntityInfo& info,
const zeus::CTransform& xf, CModelData&& mData, const CActorParameters& aParams,
const zeus::CAABox& aabb, s32, s32, s32, s32, float, float, float, float, bool active)
: CPhysicsActor(uid, active, name, info, xf, std::move(mData), CMaterialList(), aabb, SMoverData(1.f), aParams,
0.3f, 0.1f)
const zeus::CAABox& aabb, CPlayerState::EItemType itemType, s32 amount, s32 capacity,
CAssetId explosionEffect, float possibility, float f2, float f3, float f4, bool active)
: CPhysicsActor(uid, active, name, info, xf, std::move(mData), CMaterialList(), aabb, SMoverData(1.f), aParams, 0.3f,
0.1f)
, x258_itemType(itemType)
, x25c_amount(amount)
, x260_capacity(capacity)
, x264_possibility(possibility)
, x268_(f3)
, x26c_(f2)
, x278_(f4)
, x28c_24_(false)
, x28c_25_(false)
, x28c_26_(false)
{
if (explosionEffect.IsValid())
x27c_explosionDesc = g_SimplePool->GetObj({SBIG('PART'), explosionEffect});
if (x64_modelData && x64_modelData->AnimationData())
x64_modelData->AnimationData()->SetAnimation(CAnimPlaybackParms(0, -1, 1.f, true), false);
if (x278_ != 0.f)
{
xb4_drawFlags = CModelFlags(5, 0, 3, zeus::CColor(1.f, 1.f, 1.f, 0.f));
xb4_drawFlags.x2_flags &= 0xFFFC;
xb4_drawFlags.x2_flags |= 1;
}
}
void CScriptPickup::Accept(IVisitor& visitor)
void CScriptPickup::Accept(IVisitor& visitor) { visitor.Visit(this); }
void CScriptPickup::Think(float dt, CStateManager& mgr)
{
visitor.Visit(this);
if (!GetActive())
return;
if (x278_ >= 0.f)
{
CPhysicsActor::Stop();
x278_ -= dt;
}
else
{
x270_ += dt;
if (x28c_25_)
{
}
}
}
void CScriptPickup::Touch(CActor& act, CStateManager& mgr)
{
if (GetActive() && x278_ < 0.f && TCastToPtr<CPlayer>(act))
{
if (x258_itemType >= CPlayerState::EItemType::Truth && x258_itemType <= CPlayerState::EItemType::Newborn)
{
CAssetId id = MP1::CArtifactDoll::GetArtifactHeadScanFromItemType(x258_itemType);
if (id.IsValid())
mgr.GetPlayerState()->SetScanTime(id, 0.5f);
}
if (x27c_explosionDesc)
{
if (mgr.GetPlayerState()->GetActiveVisor(mgr) != CPlayerState::EPlayerVisor::Thermal)
{
mgr.AddObject(new CExplosion(
x27c_explosionDesc, mgr.AllocateUniqueId(), true,
CEntityInfo(GetAreaIdAlways(), CEntity::NullConnectionList, kInvalidEditorId),
"Explosion - Pickup Effect", x34_transform, 0, zeus::CVector3f::skOne, zeus::CColor::skWhite));
}
}
mgr.GetPlayerState()->InitializePowerUp(x258_itemType, x260_capacity);
mgr.GetPlayerState()->IncrPickup(x258_itemType, x25c_amount);
mgr.FreeScriptObject(GetUniqueId());
SendScriptMsgs(EScriptObjectState::Arrived, mgr, EScriptObjectMessage::None);
if (x260_capacity > 0)
{
u32 total = mgr.GetPlayerState()->GetPickupTotal();
u32 colRate = mgr.GetPlayerState()->CalculateItemCollectionRate();
if (total == colRate)
{
CPersistentOptions& opts = g_GameState->SystemOptions();
mgr.sub_80043F2C(mgr.GetHUDMessageFrameCount() + 1,
g_ResFactory->GetResourceIdByName(opts.GetAllItemsCollected() ?
"STRG_AllPickupsFound_2" :
"STRG_AllPickupsFound_1")->id, 0.f);
opts.SetAllItemsCollected(true);
}
}
if (x258_itemType == CPlayerState::EItemType::PowerBombs &&
g_GameState->SystemOptions().GetShowPowerBombAmmoMessage())
{
g_GameState->SystemOptions().IncrementPowerBombAmmoCount();
MP1::CSamusHud::DisplayHudMemo(g_MainStringTable->GetString(109), {0.5f, true, false, false});
}
}
}
}

23
Runtime/World/CScriptPickup.hpp
View File

@ -2,16 +2,37 @@
#define __URDE_CSCRIPTPICKUP_HPP__
#include "CPhysicsActor.hpp"
#include "CPlayerState.hpp"
namespace urde
{
class CScriptPickup : public CPhysicsActor
{
CPlayerState::EItemType x258_itemType;
u32 x25c_amount;
u32 x260_capacity;
float x264_possibility;
float x268_;
float x26c_;
float x270_ = 0.f;
float x274_;
float x278_;
TLockedToken<CGenDescription> x27c_explosionDesc;
u8 x28c_24_ : 1;
u8 x28c_25_ : 1;
u8 x28c_26_ : 1;
public:
CScriptPickup(TUniqueId, const std::string&, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const zeus::CAABox&, s32, s32, s32, s32, float, float, float, float, bool);
const CActorParameters&, const zeus::CAABox&, CPlayerState::EItemType, s32, s32, CAssetId, float,
float, float, float, bool);
void Accept(IVisitor& visitor);
void Think(float, CStateManager&);
void Touch(CActor &, CStateManager &);
float GetPossibility() const { return x264_possibility; }
CPlayerState::EItemType GetItem() { return x258_itemType; }
};
}

13
Runtime/World/CTeamAiMgr.hpp
View File

@ -0,0 +1,13 @@
#ifndef __URDE_CTEAMAIMGR_HPP__
#define __URDE_CTEAMAIMGR_HPP__
namespace urde
{
class CTeamAiMgr
{
};
}
#endif // __URDE_CTEAMAIMGR_HPP__

48
Runtime/World/CWorld.cpp
View File

@ -5,6 +5,7 @@
#include "Audio/CAudioGroupSet.hpp"
#include "CGameState.hpp"
#include "Graphics/CBooRenderer.hpp"
#include "World/CScriptAreaAttributes.hpp"
namespace urde
{
@ -355,8 +356,8 @@ bool CWorld::CheckWorldComplete(CStateManager* mgr, TAreaId id, CAssetId mreaId)
}
case Phase::LoadingSkyBox:
{
x70_26_ = true;
x70_27_ = false;
x70_26_skyboxOverridden = true;
x70_27_needsSky = false;
if (!x94_skybox.IsLoaded())
return false;
@ -560,7 +561,48 @@ void CWorld::PropogateAreaChain(CGameArea::EOcclusionState occlusionState, CGame
void CWorld::Update(float dt)
{
xc4_neededFx = EEnvFxType::None;
CAssetId skyModel;
bool needsSky = false;
CGameArea::EOcclusionState occlusionState = CGameArea::EOcclusionState::Occluded;
u32 r26 = 0;
for (CGameArea* head = x4c_chainHeads[3] ;
head != skGlobalNonConstEnd ;
head = head->x130_next, ++r26)
{
head->AliveUpdate(dt);
if (head->DoesAreaNeedSkyNow())
{
const CScriptAreaAttributes* attrs = head->GetPostConstructed()->x10d8_areaAttributes;
if (attrs && attrs->GetSkyModel().IsValid())
skyModel = attrs->GetSkyModel();
needsSky = true;
occlusionState = (head->IsPostConstructed()
? head->GetPostConstructed()->x10dc_occlusionState
: CGameArea::EOcclusionState::Occluded);
}
EEnvFxType envFxType = head->DoesAreaNeedEnvFx();
if (envFxType != EEnvFxType::None)
xc4_neededFx = envFxType;
}
if (r26 == 0)
return;
if (skyModel.IsValid() && needsSky)
{
x70_26_skyboxOverridden = true;
x70_27_needsSky = needsSky;
TToken<CModel> skybox = g_SimplePool->GetObj({SBIG('CMDL'), skyModel});
/* TODO: Finish */
}
}
void CWorld::PreRender()
@ -593,7 +635,7 @@ void CWorld::DrawSky(const zeus::CTransform& xf) const
else
return;
if (!x70_27_)
if (!x70_27_needsSky)
return;
CGraphics::DisableAllLights();

4
Runtime/World/CWorld.hpp
View File

@ -137,8 +137,8 @@ private:
{
bool x70_24_currentAreaNeedsAllocation : 1;
bool x70_25_paused : 1;
bool x70_26_ : 1;
bool x70_27_ : 1;
bool x70_26_skyboxOverridden : 1;
bool x70_27_needsSky : 1;
};
u16 dummy = 0;
};

6
Runtime/World/ScriptLoader.cpp
View File

@ -891,7 +891,7 @@ CEntity* ScriptLoader::LoadPickup(CStateManager& mgr, CInputStream& in, int prop
SScaledActorHead head = LoadScaledActorHead(in, mgr);
zeus::CVector3f extent = zeus::CVector3f::ReadBig(in);
zeus::CVector3f offset = zeus::CVector3f::ReadBig(in);
u32 w1 = in.readUint32Big();
CPlayerState::EItemType w1 = CPlayerState::EItemType(in.readUint32Big());
u32 w2 = in.readUint32Big();
u32 w3 = in.readUint32Big();
float f1 = in.readFloatBig();
@ -902,7 +902,7 @@ CEntity* ScriptLoader::LoadPickup(CStateManager& mgr, CInputStream& in, int prop
CActorParameters actorParms = LoadActorParameters(in);
bool active = in.readBool();
float f4 = in.readFloatBig();
u32 w5 = in.readUint32Big();
CAssetId w4(in);
FourCC acsType = g_ResFactory->GetResourceTypeById(animParms.GetACSFile());
if (g_ResFactory->GetResourceTypeById(staticModel) == 0 && acsType == 0)
@ -922,7 +922,7 @@ CEntity* ScriptLoader::LoadPickup(CStateManager& mgr, CInputStream& in, int prop
aabb = data.GetBounds(head.x10_transform.getRotation());
return new CScriptPickup(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(data),
actorParms, aabb, w1, w3, w2, w5, f1, f2, f3, f4, active);
actorParms, aabb, w1, w3, w2, w4, f1, f2, f3, f4, active);
}
CEntity* ScriptLoader::LoadMemoryRelay(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)

1
Runtime/World/ScriptObjectSupport.hpp
View File

@ -227,7 +227,6 @@ enum class EScriptObjectMessage
RemovePhazonPoolInhabitant = 47,
InternalMessage26 = 48
};
}
#endif // __SCRIPT_OBJECT_SUPPORT_HPP__