PrimeDecomp
/
prime
mirror of https://github.com/PrimeDecomp/prime.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Migrate s32->int, u32->uint; fix dolphin/types.h 

Former-commit-id: 7eb08b6ee8
This commit is contained in:
Luke Street 2022-09-05 00:01:13 -04:00
parent 5726400667
commit 0f25a3c8d4
73 changed files with 413 additions and 410 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
include/Kyoto/Alloc/IAllocator.hpp
View File

@ -19,44 +19,44 @@ public:
enum EType { kTP_Unk0 };
struct SMetrics {
u32 x0_heapSize;
u32 x4_;
u32 x8_;
u32 xc_;
u32 x10_;
u32 x14_heapSize2; // Remaining heap size?
u32 x18_;
u32 x1c_;
u32 x20_;
u32 x24_;
u32 x28_;
u32 x2c_smallNumAllocs;
u32 x30_smallAllocatedSize;
u32 x34_smallRemainingSize;
u32 x38_mediumNumAllocs;
u32 x3c_mediumAllocatedSize;
u32 x40_mediumBlocksAvailable;
u32 x44_;
u32 x48_;
u32 x4c_;
u32 x50_mediumTotalAllocated;
u32 x54_fakeStatics;
SMetrics(u32 heapSize, u32 unk1, u32 unk2, u32 unk3, u32 unk4, u32 heapSize2, u32 unk5, u32 unk6, u32 unk7, u32 unk8, u32 unk9,
u32 smallAllocNumAllocs, u32 smallAllocAllocatedSize, u32 smallAllocRemainingSize, u32 mediumAllocNumAllocs,
u32 mediumAllocAllocatedSize, u32 mediumAllocBlocksAvailable, u32 unk10, u32 unk11, u32 unk12, u32 mediumAllocTotalAllocated,
u32 fakeStatics);
uint x0_heapSize;
uint x4_;
uint x8_;
uint xc_;
uint x10_;
uint x14_heapSize2; // Remaining heap size?
uint x18_;
uint x1c_;
uint x20_;
uint x24_;
uint x28_;
uint x2c_smallNumAllocs;
uint x30_smallAllocatedSize;
uint x34_smallRemainingSize;
uint x38_mediumNumAllocs;
uint x3c_mediumAllocatedSize;
uint x40_mediumBlocksAvailable;
uint x44_;
uint x48_;
uint x4c_;
uint x50_mediumTotalAllocated;
uint x54_fakeStatics;
SMetrics(uint heapSize, uint unk1, uint unk2, uint unk3, uint unk4, uint heapSize2, uint unk5, uint unk6, uint unk7, uint unk8, uint unk9,
uint smallAllocNumAllocs, uint smallAllocAllocatedSize, uint smallAllocRemainingSize, uint mediumAllocNumAllocs,
uint mediumAllocAllocatedSize, uint mediumAllocBlocksAvailable, uint unk10, uint unk11, uint unk12, uint mediumAllocTotalAllocated,
uint fakeStatics);
};
struct SAllocInfo {
void* x0_infoPtr;
u32 x4_len;
uint x4_len;
bool x8_hasPrevious;
bool x9_;
const char* xc_fileAndLne;
const char* x10_type;
};
typedef const bool (*FOutOfMemoryCb)(void*, u32);
typedef const bool (*FOutOfMemoryCb)(void*, uint);
typedef const bool (*FEnumAllocationsCb)(const SAllocInfo& info, const void* ptr);
virtual ~IAllocator();
@ -71,7 +71,7 @@ public:
virtual void SetOutOfMemoryCallback(FOutOfMemoryCb cb, const void* data) = 0;
virtual void EnumAllocations(FEnumAllocationsCb func, const void* ptr, bool b) const = 0;
virtual SAllocInfo GetAllocInfo(const void* ptr) const = 0;
virtual void OffsetFakeStatics(s32 offset) = 0;
virtual void OffsetFakeStatics(int offset) = 0;
virtual SMetrics GetMetrics() const = 0;
};

4
include/Kyoto/Audio/CSfxHandle.hpp
View File

@ -6,7 +6,7 @@
class CSfxHandle {
public:
CSfxHandle() : value(0) {}
CSfxHandle(u32 value) : value(value) {}
CSfxHandle(uint value) : value(value) {}
// GetIndex__10CSfxHandleCFv
// NullHandle__10CSfxHandleFv
@ -16,7 +16,7 @@ public:
operator bool() const { return value != 0; }
private:
u32 value;
uint value;
};
CHECK_SIZEOF(CSfxHandle, 0x4)

2
include/Kyoto/CCrc32.hpp
View File

@ -4,7 +4,7 @@
class CCRC32 {
public:
static u32 Calculate(const void* data, u32 length);
static uint Calculate(const void* data, uint length);
};
#endif // __CCRC32_HPP__

8
include/Kyoto/CPakFile.hpp
View File

@ -26,13 +26,13 @@ private:
int x2c_asyncLoadPhase; // EAsyncPhase
rstl::auto_ptr< void > x30_dvdReq; // IDvdRequest
rstl::vector< u8 > x38_headerData;
u32 x48_resTableOffset;
u32 x4c_resTableCount;
s32 x50_aramBase;
uint x48_resTableOffset;
uint x4c_resTableCount;
int x50_aramBase;
rstl::vector< rstl::pair< rstl::string, SObjectTag > > x54_nameList;
rstl::vector< CAssetId > x64_depList;
rstl::vector< SResInfo > x74_resList;
mutable s32 x84_currentSeek;
mutable int x84_currentSeek;
};
#endif

10
include/Kyoto/CRandom16.hpp
View File

@ -21,14 +21,14 @@ class CRandom16 {
static void _SetRandomNumber(CRandom16* rnd);
public:
static CRandom16* GetRandomNumber();
CRandom16(u32 seed = 99);
void SetSeed(u32 seed);
s32 Range(s32 min, s32 max);
CRandom16(uint seed = 99);
void SetSeed(uint seed);
int Range(int min, int max);
float Range(float min, float max);
s32 Next();
int Next();
float Float();
private:
u32 mSeed;
uint mSeed;
};
#endif // __CRANDOM16_HPP__

16
include/Kyoto/CResFactory.hpp
View File

@ -12,20 +12,20 @@ class CResFactory {
public:
virtual ~CResFactory() {}
void AsyncIdle(u32 time);
void AsyncIdle(uint time);
CResLoader& GetResLoader() { return x4_resLoader; }
private:
CResLoader x4_resLoader;
CFactoryMgr x5c_factoryMgr;
u32 x94_;
u32 x98_;
u32 x9c_;
u32 xa0_;
u32 xa4_;
u32 xa8_;
u32 xac_;
uint x94_;
uint x98_;
uint x9c_;
uint xa0_;
uint xa4_;
uint xa8_;
uint xac_;
rstl::list< void > xb0_;
};

6
include/Kyoto/CResLoader.hpp
View File

@ -14,13 +14,13 @@ struct SResInfo {
CAssetId x0_id;
bool x4_compressed : 1;
int x4_typeIdx; // CFactoryMgr::ETypeTable
u32 x5_offsetDiv32 : 27;
u32 x7_sizeDiv32 : 27;
uint x5_offsetDiv32 : 27;
uint x7_sizeDiv32 : 27;
};
class CResLoader {
public:
s32 GetPakCount() const;
int GetPakCount() const;
CPakFile& GetPakFile(int idx) const;
void AddPakFileAsync(const rstl::string&, bool, bool);
void AsyncIdlePakLoading();

8
include/Kyoto/Graphics/CColor.hpp
View File

@ -15,7 +15,7 @@ class CInputStream;
class CColor {
public:
CColor() {}
CColor(u32 col) : mRgba(col) {}
CColor(uint col) : mRgba(col) {}
CColor(CInputStream& in);
CColor(f32 r, f32 g, f32 b, f32 a = 1.f);
CColor(u8 r, u8 g, u8 b, u8 a = 255) {
@ -29,7 +29,7 @@ public:
void Get(float& r, float& g, float& b, float& a) const;
void Get(float& r, float& g, float& b) const;
static CColor Lerp(const CColor& a, const CColor& b, float t);
static u32 Lerp(u32 a, u32 b, float t);
static uint Lerp(uint a, uint b, float t);
static CColor Modulate(const CColor& a, const CColor& b);
static CColor Add(const CColor& a, const CColor& b);
f32 GetRed() const { return CCast::ToReal32(mR) * (1/255.f); }
@ -41,7 +41,7 @@ public:
u8 GetBlueu8() const { return mB; }
u8 GetAlphau8() const { return mA; }
u16 ToRGB5A3() const;
GXColor ToGX(u32);
GXColor ToGX(uint);
static const CColor& Black();
static const CColor& White();
@ -61,7 +61,7 @@ private:
u8 mB;
u8 mA;
};
u32 mRgba;
uint mRgba;
};
static const CColor sBlackColor;

2
include/Kyoto/Graphics/CCubeMaterial.hpp
View File

@ -11,7 +11,7 @@ extern CVector3f sPlayerPosition;
class CCubeMaterial {
public:
private:
static void SetupBlendMode(u32 blendFactors, const CModelFlags& flags, bool alphaTest);
static void SetupBlendMode(uint blendFactors, const CModelFlags& flags, bool alphaTest);
static CVector3f sViewingFrom;
};

36
include/Kyoto/Graphics/CGX.hpp
View File

@ -11,12 +11,12 @@
class CGX {
public:
struct STevState {
u32 x0_colorInArgs;
u32 x4_alphaInArgs;
u32 x8_colorOps;
u32 xc_alphaOps;
u32 x10_indFlags;
u32 x14_tevOrderFlags;
uint x0_colorInArgs;
uint x4_alphaInArgs;
uint x8_colorOps;
uint xc_alphaOps;
uint x10_indFlags;
uint x14_tevOrderFlags;
u8 x18_kColorSel;
u8 x19_kAlphaSel;
@ -24,7 +24,7 @@ public:
};
struct STexState {
u32 x0_coordGen;
uint x0_coordGen;
STexState();
};
@ -50,7 +50,7 @@ public:
u16 x34_chanCtrls[2];
GXColor x38_chanAmbColors[2];
GXColor x40_chanMatColors[2];
u32 x48_descList;
uint x48_descList;
union {
u8 x4c_chanFlags;
struct {
@ -71,7 +71,7 @@ public:
GXColor x58_kColors[4];
STevState x68_tevStates[16];
STexState x228_texStates[8];
u32 x248_alphaCompare;
uint x248_alphaCompare;
SFogParams x24c_fogParams;
SGXState();
@ -94,9 +94,9 @@ public:
static void SetTevColorIn(GXTevStageID stageId, GXTevColorArg a, GXTevColorArg b, GXTevColorArg c, GXTevColorArg d);
static void SetTevAlphaIn(GXTevStageID stageId, GXTevAlphaArg a, GXTevAlphaArg b, GXTevAlphaArg c, GXTevAlphaArg d);
static void SetTevColorOp(GXTevStageID stageId, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp, GXTevRegID outReg);
static void SetTevColorOp_Compressed(GXTevStageID stageId, u32 flags);
static void SetTevColorOp_Compressed(GXTevStageID stageId, uint flags);
static void SetTevAlphaOp(GXTevStageID stageId, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp, GXTevRegID outReg);
static void SetTevAlphaOp_Compressed(GXTevStageID stageId, u32 flags);
static void SetTevAlphaOp_Compressed(GXTevStageID stageId, uint flags);
static void SetTevKColorSel(GXTevStageID stageId, GXTevKColorSel sel);
static void SetTevKAlphaSel(GXTevStageID stageId, GXTevKAlphaSel sel);
static void SetTevOrder(GXTevStageID stageId, GXTexCoordID texCoord, GXTexMapID texMap, GXChannelID color);
@ -112,11 +112,11 @@ public:
static void SetFog(GXFogType type, f32 startZ, f32 endZ, f32 nearZ, f32 farZ, const GXColor& color);
static void SetLineWidth(u8 width, GXTexOffset offset);
static void SetIndTexMtxSTPointFive(GXIndTexMtxID id, s8 scaleExp);
static void SetVtxDescv_Compressed(u32 flags);
static void SetVtxDescv_Compressed(uint flags);
static void SetVtxDesc(GXAttr attr, GXAttrType type); // name?
static void ResetVtxDescv(); // name?
static void SetVtxDescv(const GXVtxDescList* list);
static void SetStandardDirectTev_Compressed(GXTevStageID stageId, u32 colorArgs, u32 alphaArgs, u32 colorOps, u32 alphaOps);
static void SetStandardDirectTev_Compressed(GXTevStageID stageId, uint colorArgs, uint alphaArgs, uint colorOps, uint alphaOps);
static void SetStandardTevColorAlphaOp(GXTevStageID stageId);
static void CallDisplayList(const void* ptr, size_t size);
@ -133,17 +133,17 @@ public:
static void GetFog(GXFogType* fogType, f32* fogStartZ, f32* fogEndZ, f32* fogNearZ, f32* fogFarZ, GXColor* fogColor);
static inline bool CompareGXColors(const GXColor& lhs, const GXColor& rhs) {
return *reinterpret_cast< const u32* >(&lhs) == *reinterpret_cast< const u32* >(&rhs);
return *reinterpret_cast< const uint* >(&lhs) == *reinterpret_cast< const uint* >(&rhs);
}
static inline void CopyGXColor(GXColor& dst, const GXColor& src) {
*reinterpret_cast< u32* >(&dst) = *reinterpret_cast< const u32* >(&src);
*reinterpret_cast< uint* >(&dst) = *reinterpret_cast< const uint* >(&src);
}
static inline u32 MaskAndShiftLeft(u32 v, u32 m, u32 s) { return (v & m) << s; }
static inline u32 ShiftRightAndMask(u32 v, u32 m, u32 s) { return (v >> s) & m; }
static inline uint MaskAndShiftLeft(uint v, uint m, uint s) { return (v & m) << s; }
static inline uint ShiftRightAndMask(uint v, uint m, uint s) { return (v >> s) & m; }
private:
static void FlushState();
static void update_fog(u32 flags);
static void update_fog(uint flags);
static void apply_fog() {
static const GXColor black = {0, 0, 0, 0};
GXSetFog(static_cast< GXFogType >(sGXState.x53_fogType), sGXState.x24c_fogParams.x0_fogStartZ, sGXState.x24c_fogParams.x4_fogEndZ,

2
include/Kyoto/Graphics/CGraphicsSys.hpp
View File

@ -8,7 +8,7 @@ public:
~CGraphicsSys();
private:
u32 pad;
uint pad;
};
#endif

12
include/Kyoto/Graphics/CModelFlags.hpp
View File

@ -26,15 +26,15 @@ public:
: x0_blendMode(trans), x1_matSetIdx(0), x2_flags(kF_DepthCompare | kF_DepthUpdate), x4_color(rgba, rgba, rgba, rgba) {}
CModelFlags(ETrans trans, CColor color)
: x0_blendMode(trans), x1_matSetIdx(0), x2_flags(kF_DepthCompare | kF_DepthUpdate), x4_color(color) {}
CModelFlags(const CModelFlags& flags, u32 otherFlags)
CModelFlags(const CModelFlags& flags, uint otherFlags)
: x0_blendMode(flags.x0_blendMode), x1_matSetIdx(flags.x1_matSetIdx), x2_flags(otherFlags), x4_color(flags.x4_color) {}
CModelFlags(const CModelFlags& flags, bool b /* TODO what's this? */, s32 shaderSet)
CModelFlags(const CModelFlags& flags, bool b /* TODO what's this? */, int shaderSet)
: x0_blendMode(flags.x0_blendMode), x1_matSetIdx(shaderSet), x2_flags(flags.x2_flags), x4_color(flags.x4_color) {}
CModelFlags UseShaderSet(s32 matSet) { return CModelFlags(*this, false, matSet); }
CModelFlags UseShaderSet(int matSet) { return CModelFlags(*this, false, matSet); }
CModelFlags DontLoadTextures() { return CModelFlags(*this, GetOtherFlags() | kF_NoTextureLock); }
CModelFlags DepthCompareUpdate(bool compare, bool update) {
u32 flags = GetOtherFlags();
uint flags = GetOtherFlags();
if (compare) {
flags |= kF_DepthCompare;
} else {
@ -50,8 +50,8 @@ public:
CModelFlags DepthBackwards() { return CModelFlags(*this, GetOtherFlags() | kF_DepthGreater); }
ETrans GetTrans() const { return static_cast< ETrans >(x0_blendMode); }
s32 GetShaderSet() const { return x1_matSetIdx; }
u32 GetOtherFlags() const { return x2_flags; }
int GetShaderSet() const { return x1_matSetIdx; }
uint GetOtherFlags() const { return x2_flags; }
CColor GetColor() const { return x4_color; }
static CModelFlags Normal() { return CModelFlags(kT_Opaque, 1.f); }

2
include/Kyoto/Graphics/CTevCombiners.hpp
View File

@ -87,7 +87,7 @@ public:
class CTevPass {
public:
u32 x0_id;
uint x0_id;
ColorPass x4_colorPass;
AlphaPass x14_alphaPass;
CTevOp x24_colorOp;

4
include/Kyoto/IObjectStore.hpp
View File

@ -8,8 +8,8 @@
#define kInvalidAssetId 0xFFFFFFFFu
typedef u32 CAssetId;
typedef u32 FourCC;
typedef uint CAssetId;
typedef uint FourCC;
struct SObjectTag {
FourCC type;

2
include/Kyoto/Math/CMath.hpp
View File

@ -8,7 +8,7 @@ public:
static f32 FastCosR(f32 v);
static f32 FastSinR(f32 v);
static inline f32 FastFmod(f32 x, f32 y) {
s32 v = static_cast<s32>(x * (1.f / y));
int v = static_cast<int>(x * (1.f / y));
return x - v * y;
}
};

4
include/Kyoto/Math/CVector2i.hpp
View File

@ -5,8 +5,8 @@
class CVector2i {
private:
s32 x;
s32 y;
int x;
int y;
};
#endif

4
include/Kyoto/Math/CVector3f.hpp
View File

@ -48,8 +48,8 @@ public:
f32 operator[](EDimY) const { return mY; }
f32 operator[](EDimZ) const { return mZ; }
f32& operator[](s32 i) { return *(&mX + i); }
// f32 operator[](s32 i) const { return *(&mX + i); }
f32& operator[](int i) { return *(&mX + i); }
// f32 operator[](int i) const { return *(&mX + i); }
bool IsNonZero() const { return mX != 0.f || mY != 0.f || mZ != 0.f; }
void DropZ() { mZ = 0.f; }

4
include/Kyoto/Particles/CParticleGen.hpp
View File

@ -32,12 +32,12 @@ public:
virtual float GetGeneratorRate() const { return 1.f; }
virtual bool IsSystemDeletable() const = 0;
virtual CAABox GetBounds() const = 0;
virtual s32 GetParticleCOunt() const = 0;
virtual int GetParticleCOunt() const = 0;
virtual bool SystemHasLight() const = 0;
virtual CLight GetLight() = 0;
virtual void DestroyParticles() = 0;
virtual void AddModifier(CWarp*) = 0;
virtual u32 Get4CharId() const = 0;
virtual uint Get4CharId() const = 0;
};
#endif // _CPARTICLEGEN_HPP

30
include/Kyoto/Streams/CInputStream.hpp
View File

@ -11,19 +11,19 @@ inline T cinput_stream_helper(const TType< T >& type, CInputStream& in);
class CInputStream {
public:
CInputStream(s32 len);
CInputStream(const void* ptr, s32 len, bool owned);
CInputStream(int len);
CInputStream(const void* ptr, int len, bool owned);
virtual ~CInputStream();
virtual u32 Read(void* dest, u32 len) = 0;
virtual uint Read(void* dest, uint len) = 0;
f32 ReadFloat();
u64 ReadLongLong();
u32 ReadLong();
uint ReadLong();
u16 ReadShort();
bool ReadBool();
u8 ReadChar();
u32 ReadBits(u32 len);
u32 ReadBytes(void* dest, unsigned long len);
uint ReadBits(uint len);
uint ReadBytes(void* dest, unsigned long len);
void Get(void* dest, unsigned long len);
template < typename T >
@ -35,26 +35,26 @@ private:
bool GrabAnotherBlock();
bool InternalReadNext();
u32 x4_blockOffset;
u32 x8_blockLen;
u32 xc_len;
uint x4_blockOffset;
uint x8_blockLen;
uint xc_len;
u8* x10_ptr;
bool x14_owned;
u32 x18_readPosition;
u32 x1c_bitWord;
u32 x20_bitOffset;
uint x18_readPosition;
uint x1c_bitWord;
uint x20_bitOffset;
};
template <>
inline s32 cinput_stream_helper(const TType< s32 >& type, CInputStream& in) {
inline int cinput_stream_helper(const TType< int >& type, CInputStream& in) {
return in.ReadLong();
}
template <>
inline u32 cinput_stream_helper(const TType< u32 >& type, CInputStream& in) {
inline uint cinput_stream_helper(const TType< uint >& type, CInputStream& in) {
return in.ReadLong();
}
template <>
inline unsigned int cinput_stream_helper(const TType< unsigned int >& type, CInputStream& in) {
inline unsigned long cinput_stream_helper(const TType< unsigned long >& type, CInputStream& in) {
return in.ReadLong();
}
template <>

2
include/Kyoto/Streams/CMemoryInStream.hpp
View File

@ -13,7 +13,7 @@ public:
CMemoryInStream(const void* ptr, unsigned long len);
CMemoryInStream(const void* ptr, unsigned long len, EOwnerShip ownership);
virtual ~CMemoryInStream() override {}
virtual u32 Read(void* dest, u32 len) override;
virtual uint Read(void* dest, uint len) override;
};
#endif

4
include/Kyoto/TOneStatic.hpp
View File

@ -18,8 +18,8 @@ private:
static u8 sAllocSpace[sizeof(T)];
return &sAllocSpace;
}
static u32& ReferenceCount() {
static u32 sReferenceCount = 0;
static uint& ReferenceCount() {
static uint sReferenceCount = 0;
return sReferenceCount;
}
};

4
include/Kyoto/TReservedAverage.hpp
View File

@ -6,7 +6,7 @@
#include "rstl/optional_object.hpp"
#include "rstl/reserved_vector.hpp"
template < typename T, s32 N >
template < typename T, int N >
class TReservedAverage : rstl::reserved_vector< T, N > {
public:
TReservedAverage(const T& value) {
@ -14,7 +14,7 @@ public:
}
void AddValue(const T& value) {
push_back(value);
for (s32 i = size() - 1; i > 0; --i) {
for (int i = size() - 1; i > 0; --i) {
operator[](i) = operator[](i - 1);
}
operator[](0) = value;

2
include/Kyoto/Text/CStringTable.hpp
View File

@ -8,7 +8,7 @@
#include "Kyoto/Streams/CInputStream.hpp"
class CStringTable {
s32 x0_stringCount;
int x0_stringCount;
rstl::single_ptr< u8 > x4_data;
public:

2
include/MetaRender/CCubeRenderer.hpp
View File

@ -37,7 +37,7 @@ public:
virtual void AddParticleGen1();
virtual void AddParticleGen2();
virtual void AddPlaneObject();
virtual void AddDrawable(const void* obj, const CVector3f& pos, const CAABox& bounds, s32 mode, IRenderer::EDrawableSorting sorting);
virtual void AddDrawable(const void* obj, const CVector3f& pos, const CAABox& bounds, int mode, IRenderer::EDrawableSorting sorting);
virtual void SetDrawableCallback();
virtual void SetWorldViewpoint();
virtual void SetPerspective1();

58
include/MetroidPrime/CActor.hpp
View File

@ -234,13 +234,13 @@ public:
SAdvancementDeltas UpdateAnimation(float dt, CStateManager& mgr, bool advTree);
void ProcessSoundEvent(s32 sfxId, f32 weight, s32 flags, f32 fallOff, f32 maxDist, u8 minVol, u8 maxVol, const CVector3f& toListener,
const CVector3f& position, s32 aid, CStateManager& mgr, bool translateId);
void ProcessSoundEvent(int sfxId, f32 weight, int flags, f32 fallOff, f32 maxDist, u8 minVol, u8 maxVol, const CVector3f& toListener,
const CVector3f& position, int aid, CStateManager& mgr, bool translateId);
void UpdateSfxEmitters();
void RemoveEmitter();
void SetModelData(const CModelData& modelData);
f32 GetAverageAnimVelocity(s32 anim);
f32 GetAverageAnimVelocity(int anim);
void EnsureRendered(const CStateManager& mgr) const;
void EnsureRendered(const CStateManager& mgr, const CVector3f& pos, const CAABox& bounds) const;
void DrawTouchBounds() const;
@ -315,38 +315,38 @@ protected:
CAABox x9c_renderBounds;
CModelFlags xb4_drawFlags;
f32 xbc_time;
u32 xc0_pitchBend;
uint xc0_pitchBend;
TUniqueId xc4_fluidId;
TUniqueId xc6_nextDrawNode;
s32 xc8_drawnToken;
s32 xcc_addedToken;
int xc8_drawnToken;
int xcc_addedToken;
f32 xd0_damageMag;
u8 xd4_maxVol;
rstl::reserved_vector< CSfxHandle, 2 > xd8_nonLoopingSfxHandles;
u32 xe4_24_nextNonLoopingSfxHandle : 3;
u32 xe4_27_notInSortedLists : 1;
u32 xe4_28_transformDirty : 1;
u32 xe4_29_actorLightsDirty : 1;
u32 xe4_30_outOfFrustum : 1;
u32 xe4_31_calculateLighting : 1;
u32 xe5_24_shadowEnabled : 1;
u32 xe5_25_shadowDirty : 1;
u32 xe5_26_muted : 1;
u32 xe5_27_useInSortedLists : 1;
u32 xe5_28_callTouch : 1;
u32 xe5_29_globalTimeProvider : 1;
u32 xe5_30_renderUnsorted : 1;
u32 xe5_31_pointGeneratorParticles : 1;
u32 xe6_24_fluidCounter : 3;
uint xe4_24_nextNonLoopingSfxHandle : 3;
uint xe4_27_notInSortedLists : 1;
uint xe4_28_transformDirty : 1;
uint xe4_29_actorLightsDirty : 1;
uint xe4_30_outOfFrustum : 1;
uint xe4_31_calculateLighting : 1;
uint xe5_24_shadowEnabled : 1;
uint xe5_25_shadowDirty : 1;
uint xe5_26_muted : 1;
uint xe5_27_useInSortedLists : 1;
uint xe5_28_callTouch : 1;
uint xe5_29_globalTimeProvider : 1;
uint xe5_30_renderUnsorted : 1;
uint xe5_31_pointGeneratorParticles : 1;
uint xe6_24_fluidCounter : 3;
EThermalFlags xe6_27_thermalVisorFlags : 2;
u32 xe6_29_renderParticleDBInside : 1;
u32 xe6_30_enablePitchBend : 1;
u32 xe6_31_targetableVisorFlags : 4;
u32 xe7_27_enableRender : 1;
u32 xe7_28_worldLightingDirty : 1;
u32 xe7_29_drawEnabled : 1;
u32 xe7_30_doTargetDistanceTest : 1;
u32 xe7_31_targetable : 1;
uint xe6_29_renderParticleDBInside : 1;
uint xe6_30_enablePitchBend : 1;
uint xe6_31_targetableVisorFlags : 4;
uint xe7_27_enableRender : 1;
uint xe7_28_worldLightingDirty : 1;
uint xe7_29_drawEnabled : 1;
uint xe7_30_doTargetDistanceTest : 1;
uint xe7_31_targetable : 1;
};
CHECK_SIZEOF(CActor, 0xe8)

20
include/MetroidPrime/CActorLights.hpp
View File

@ -31,8 +31,8 @@ private:
f32 x30_angleC;
f32 x34_angleL;
f32 x38_angleQ;
u32 x3c_priority;
u32 x40_lightId;
uint x3c_priority;
uint x40_lightId;
mutable f32 x44_cachedRadius;
mutable f32 x48_cachedIntensity;
mutable bool x4c_24_intensityDirty : 1;
@ -69,19 +69,19 @@ private:
bool x299_25_useBrightLightLag : 1;
bool x299_26_ambientOnly : 1;
bool x29a_findNearestDynamicLights;
s32 x29c_shadowLightArrIdx;
s32 x2a0_shadowLightIdx;
u32 x2a4_lastUpdateFrame;
u32 x2a8_areaUpdateFramePeriod;
int x29c_shadowLightArrIdx;
int x2a0_shadowLightIdx;
uint x2a4_lastUpdateFrame;
uint x2a8_areaUpdateFramePeriod;
CVector3f x2ac_actorPosBias;
s32 x2b8_maxAreaLights;
s32 x2bc_maxDynamicLights;
int x2b8_maxAreaLights;
int x2bc_maxDynamicLights;
CVector3f x2c0_lastActorPos;
f32 x2cc_actorPositionDeltaUpdateThreshold;
f32 x2d0_shadowDynamicRangeThreshold;
f32 x2d4_worldLightingLevel;
s32 x2d8_brightLightIdx;
u32 x2dc_brightLightLag;
int x2d8_brightLightIdx;
uint x2dc_brightLightLag;
};
CHECK_SIZEOF(CActorLights, 0x2e0)

14
include/MetroidPrime/CActorParameters.hpp
View File

@ -41,7 +41,7 @@ public:
const CColor& GetAmbientColor() const { return x18_noLightsAmbient; }
bool ShouldMakeLights() const { return x1c_makeLights; }
s32 GetMaxAreaLights() const { return x3c_maxAreaLights; }
int GetMaxAreaLights() const { return x3c_maxAreaLights; }
rstl::auto_ptr< CActorLights > MakeActorLights() const;
@ -56,10 +56,10 @@ private:
bool x1d_ambientChannelOverflow;
EWorldLightingOptions x20_worldLightingOptions;
ELightRecalculationOptions x24_lightRecalcOpts;
s32 x28_layerIdx;
int x28_layerIdx;
CVector3f x2c_actorPosBias;
s32 x38_maxDynamicLights;
s32 x3c_maxAreaLights;
int x38_maxDynamicLights;
int x3c_maxAreaLights;
};
CHECK_SIZEOF(CLightParameters, 0x40)
@ -90,9 +90,9 @@ public:
static CVisorParameters None();
private:
u32 x0_mask : 4;
u32 x0_4_b1 : 1;
u32 x0_5_scanPassthrough : 1;
uint x0_mask : 4;
uint x0_4_b1 : 1;
uint x0_5_scanPassthrough : 1;
};
CHECK_SIZEOF(CVisorParameters, 0x4)

28
include/MetroidPrime/CAnimData.hpp
View File

@ -36,22 +36,22 @@ public:
x120_particleDB.SetParticleEffectState(name, active, mgr);
}
s32 GetCharacterIndex() const { return x204_charIdx; }
f32 GetAverageVelocity(s32 idx) const;
int GetCharacterIndex() const { return x204_charIdx; }
f32 GetAverageVelocity(int idx) const;
const CBoolPOINode* GetBoolPOIList(s32& count) const {
const CBoolPOINode* GetBoolPOIList(int& count) const {
count = x20c_passedBoolCount;
return mBoolPOINodes.data();
}
const CInt32POINode* GetInt32POIList(s32& count) const {
const CInt32POINode* GetInt32POIList(int& count) const {
count = x210_passedIntCount;
return mInt32POINodes.data();
}
const CParticlePOINode* GetParticlePOIList(s32& count) const {
const CParticlePOINode* GetParticlePOIList(int& count) const {
count = x214_passedParticleCount;
return mParticlePOINodes.data();
}
const CSoundPOINode* GetSoundPOIList(s32& count) const {
const CSoundPOINode* GetSoundPOIList(int& count) const {
count = x218_passedSoundCount;
return mSoundPOINodes.data();
}
@ -171,13 +171,13 @@ private:
rstl::rc_ptr< CAnimTreeNode > x1f8_animRoot;
rstl::rc_ptr< CTransitionManager > x1fc_transMgr;
f32 x200_speedScale;
s32 x204_charIdx;
s32 x208_defaultAnim;
s32 x20c_passedBoolCount;
s32 x210_passedIntCount;
s32 x214_passedParticleCount;
s32 x218_passedSoundCount;
s32 x21c_particleLightIdx;
int x204_charIdx;
int x208_defaultAnim;
int x20c_passedBoolCount;
int x210_passedIntCount;
int x214_passedParticleCount;
int x218_passedSoundCount;
int x21c_particleLightIdx;
bool x220_24_animating : 1;
bool x220_25_loop : 1;
bool x220_26_aligningPos : 1;
@ -189,7 +189,7 @@ private:
CPoseAsTransforms x224_pose;
CHierarchyPoseBuilder x2fc_poseBuilder;
CAnimPlaybackParms x40c_playbackParms;
rstl::reserved_vector< rstl::pair< s32, CAdditiveAnimPlayback >, 8 > x434_additiveAnims;
rstl::reserved_vector< rstl::pair< int, CAdditiveAnimPlayback >, 8 > x434_additiveAnims;
static rstl::reserved_vector< CBoolPOINode, 8 > mBoolPOINodes;
static rstl::reserved_vector< CInt32POINode, 16 > mInt32POINodes;

6
include/MetroidPrime/CAnimPlaybackParms.hpp
View File

@ -9,11 +9,11 @@ class CVector3f;
class CAnimPlaybackParms {
private:
s32 x0_animA;
s32 x4_animB;
int x0_animA;
int x4_animB;
f32 x8_blendWeight;
bool xc_animating;
s32 x10_;
int x10_;
CVector3f* x14_targetPos;
bool x18_useLocator;
CQuaternion* x1c_deltaOrient;

10
include/MetroidPrime/CCharacterInfo.hpp
View File

@ -29,15 +29,15 @@ private:
CAssetId x14_cmdl;
CAssetId x18_cksr;
CAssetId x1c_cinf;
rstl::vector< rstl::pair< s32, rstl::pair< rstl::string, rstl::string > > > x20_animInfo;
rstl::vector< rstl::pair< int, rstl::pair< rstl::string, rstl::string > > > x20_animInfo;
CPASDatabase x30_pasDatabase;
CParticleResData x44_partRes;
u32 x84_unk;
uint x84_unk;
rstl::vector< rstl::pair< rstl::string, CAABox > > x88_aabbs;
rstl::vector< rstl::pair< rstl::string, rstl::vector< CEffectComponent > > > x98_effects;
u32 xa8_cmdlOverlay;
u32 xac_cksrOverlay;
rstl::vector< s32 > xb0_animIdxs;
uint xa8_cmdlOverlay;
uint xac_cksrOverlay;
rstl::vector< int > xb0_animIdxs;
};
CHECK_SIZEOF(CCharacterInfo, 0xc0)

2
include/MetroidPrime/CEffectComponent.hpp
View File

@ -12,7 +12,7 @@ private:
rstl::string x18_boneName;
f32 x28_scale;
CParticleData::EParentedMode x2c_parentedMode;
u32 x30_flags;
uint x30_flags;
};
#endif

2
include/MetroidPrime/CEnvFxManager.hpp
View File

@ -40,7 +40,7 @@ private:
CVector3f x18_focusCellPosition;
bool x24_enableSplash;
f32 x28_firstSnowForce;
s32 x2c_lastBlockedGridIdx;
int x2c_lastBlockedGridIdx;
f32 x30_fxDensity;
f32 x34_targetFxDensity;
f32 x38_maxDensityDeltaSpeed;

18
include/MetroidPrime/CGameArea.hpp
View File

@ -20,12 +20,12 @@ public:
virtual ~IGameArea();
virtual const CTransform4f& IGetTM() const = 0;
virtual CAssetId IGetStringTableAssetId() const = 0;
virtual u32 IGetNumAttachedAreas() const = 0;
virtual uint IGetNumAttachedAreas() const = 0;
virtual TAreaId IGetAttachedAreaId(int) const = 0;
virtual bool IIsActive() const = 0;
virtual CAssetId IGetAreaAssetId() const = 0;
virtual s32 IGetAreaSaveId() const = 0;
virtual rstl::pair< rstl::auto_ptr< u8 >, s32 > IGetScriptingMemoryAlways() const = 0;
virtual int IGetAreaSaveId() const = 0;
virtual rstl::pair< rstl::auto_ptr< u8 >, int > IGetScriptingMemoryAlways() const = 0;
};
class Dock;
@ -37,12 +37,12 @@ public:
~CGameArea();
const CTransform4f& IGetTM() const override;
CAssetId IGetStringTableAssetId() const override;
u32 IGetNumAttachedAreas() const override;
uint IGetNumAttachedAreas() const override;
TAreaId IGetAttachedAreaId(int) const override;
bool IIsActive() const override;
CAssetId IGetAreaAssetId() const override;
s32 IGetAreaSaveId() const override;
rstl::pair< rstl::auto_ptr< u8 >, s32 > IGetScriptingMemoryAlways() const override;
int IGetAreaSaveId() const override;
rstl::pair< rstl::auto_ptr< u8 >, int > IGetScriptingMemoryAlways() const override;
bool IsLoaded() const { return xf0_24_postConstructed; }
bool IsActive() const { return xf0_25_active; }
@ -61,14 +61,14 @@ private:
CTransform4f x3c_invTransform;
CAABox x6c_aabb;
CAssetId x84_mrea;
s32 x88_areaId;
int x88_areaId;
rstl::vector< u16 > x8c_attachedAreaIndices;
rstl::vector< SObjectTag > x9c_deps1;
rstl::vector< SObjectTag > xac_deps2;
rstl::vector< u32 > xbc_layerDepOffsets;
rstl::vector< uint > xbc_layerDepOffsets;
rstl::vector< Dock > xcc_docks;
rstl::vector< CToken > xdc_tokens;
u32 xec_totalResourcesSize;
uint xec_totalResourcesSize;
bool xf0_24_postConstructed : 1;
bool xf0_25_active : 1;
bool xf0_26_tokensReady : 1;

4
include/MetroidPrime/CGameGlobalObjects.hpp
View File

@ -36,9 +36,9 @@ private:
CAiFuncMap x110_aiFuncMap;
CGraphicsSys x130_graphicsSys;
rstl::single_ptr< CGameState > x134_gameState;
u32 x138_;
uint x138_;
rstl::optional_object< TCachedToken< unkptr > > x13c_;
u32 x14c_;
uint x14c_;
rstl::single_ptr< CInGameTweakManager > x150_inGameTweakManager;
TToken< CRasterFont > x154_defaultFont;
};

2
include/MetroidPrime/CHierarchyPoseBuilder.hpp
View File

@ -19,7 +19,7 @@ class TSegIdMap {
private:
CSegId x0_boneCount;
CSegId x1_capacity;
u32 x4_maxCapacity;
uint x4_maxCapacity;
CSegId x8_indirectionMap[200];
T* xd0_nodes;
CSegId xd4_curPrevBone;

4
include/MetroidPrime/CIOWinManager.hpp
View File

@ -12,8 +12,8 @@ public:
inline bool IsEmpty() const { return x4_ == 0 && x0_ == 0; }
private:
u32 x0_;
u32 x4_;
uint x0_;
uint x4_;
rstl::list< unkptr > x8_;
};

8
include/MetroidPrime/CMain.hpp
View File

@ -23,7 +23,7 @@ public:
void StreamNewGameState(CInputStream& in, int saveIdx);
void RefreshGameState();
void AddWorldPaks();
void AsyncIdle(u32 time);
void AsyncIdle(uint time);
int RsMain(int argc, const char* const* argv);
void InitializeSubsystems();
void FillInAssetIDs();
@ -50,9 +50,9 @@ private:
f32 x120_;
f32 x124_;
CGameGlobalObjects* x128_gameGlobalObjects;
u32 x12c_flowState; // EFlowState
rstl::reserved_vector< u32, 10 > x130_frameTimes;
s32 x15c_frameTimeIdx;
uint x12c_flowState; // EFlowState
rstl::reserved_vector< uint, 10 > x130_frameTimes;
int x15c_frameTimeIdx;
bool x160_24_finished : 1;
bool x160_25_mfGameBuilt : 1;
bool x160_26_screenFading : 1;

8
include/MetroidPrime/CObjectList.hpp
View File

@ -37,10 +37,10 @@ public:
const CEntity* GetObjectById() const;
CEntity* GetValidObjectById(TUniqueId uid);
const CEntity* GetValidObjectById(TUniqueId uid) const;
CEntity* operator[](s32 idx);
const CEntity* operator[](s32 idx) const;
const CEntity* GetValidObjectByIndex(s32 idx) const;
s32 size() const { return mCount; }
CEntity* operator[](int idx);
const CEntity* operator[](int idx) const;
const CEntity* GetValidObjectByIndex(int idx) const;
int size() const { return mCount; }
private:
SObjectListEntry mObjects[1024];

8
include/MetroidPrime/CPASAnimState.hpp
View File

@ -47,8 +47,8 @@ public:
kPT_Enum = 4,
};
union UParmValue {
s32 m_int;
u32 m_uint;
int m_int;
uint m_uint;
f32 m_float;
bool m_bool;
};
@ -77,7 +77,7 @@ private:
class CPASAnimInfo {
private:
u32 x0_id;
uint x0_id;
rstl::reserved_vector< CPASAnimParm::UParmValue, 8 > x4_parms;
};
@ -86,7 +86,7 @@ private:
pas::EAnimationState x0_id;
rstl::vector< CPASParmInfo > x4_parms;
rstl::vector< CPASAnimInfo > x14_anims;
rstl::vector< s32 > x24_selectionCache;
rstl::vector< int > x24_selectionCache;
};
CHECK_SIZEOF(CPASAnimState, 0x34)

2
include/MetroidPrime/CPASDatabase.hpp
View File

@ -10,7 +10,7 @@
class CPASDatabase {
private:
rstl::vector< CPASAnimState > x0_states;
s32 x10_defaultState;
int x10_defaultState;
};
CHECK_SIZEOF(CPASDatabase, 0x14)

18
include/MetroidPrime/CPOINode.hpp
View File

@ -27,19 +27,19 @@ public:
EPOIType GetPoiType() const { return static_cast< EPOIType >(x18_type); }
const CCharAnimTime& GetTime() const { return x1c_time; }
f32 GetWeight() const { return x2c_weight; }
s32 GetCharacterIndex() const { return x30_charIdx; }
s32 GetFlags() const { return x34_flags; }
int GetCharacterIndex() const { return x30_charIdx; }
int GetFlags() const { return x34_flags; }
protected:
u16 x4_;
rstl::string x8_name;
u16 x18_type;
CCharAnimTime x1c_time;
s32 x24_index;
int x24_index;
bool x28_unique;
f32 x2c_weight;
s32 x30_charIdx;
s32 x34_flags;
int x30_charIdx;
int x34_flags;
};
CHECK_SIZEOF(CPOINode, 0x38)
@ -60,11 +60,11 @@ public:
// __ct__13CInt32POINodeFQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>UsRC13CCharAnimTimeibfiiiRCQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>
// CopyNodeMinusStartTime__13CInt32POINodeFRC13CInt32POINodeRC13CCharAnimTime
s32 GetValue() const { return x38_val; }
int GetValue() const { return x38_val; }
const rstl::string& GetLocatorName() const { return x3c_lctrName; }
private:
s32 x38_val;
int x38_val;
rstl::string x3c_lctrName;
};
@ -75,12 +75,12 @@ private:
class CSoundPOINode : public CPOINode {
public:
u32 GetSoundId() const { return x38_sfxId; }
uint GetSoundId() const { return x38_sfxId; }
f32 GetFallOff() const { return x3c_falloff; }
f32 GetMaxDistance() const { return x40_maxDist; }
private:
u32 x38_sfxId;
uint x38_sfxId;
f32 x3c_falloff;
f32 x40_maxDist;
};

4
include/MetroidPrime/CParticleData.hpp
View File

@ -17,7 +17,7 @@ public:
};
private:
u32 x0_duration;
uint x0_duration;
SObjectTag x4_particle;
rstl::string xc_boneName;
f32 x1c_scale;
@ -26,7 +26,7 @@ private:
class CAuxiliaryParticleData {
private:
u32 x0_duration;
uint x0_duration;
SObjectTag x4_particle;
CVector3f xc_translation;
f32 x18_scale;

2
include/MetroidPrime/CSortedLists.hpp
View File

@ -21,7 +21,7 @@ CHECK_SIZEOF(SNode, 0x2c);
struct SSortedList {
s16 x0_ids[kMaxObjects];
u32 x800_size;
uint x800_size;
};
CHECK_SIZEOF(SSortedList, 0x804);

2
include/MetroidPrime/CWeaponMgr.hpp
View File

@ -10,7 +10,7 @@
class CWeaponMgr {
private:
rstl::map< TUniqueId, rstl::reserved_vector< s32, 15 > > x0_weapons;
rstl::map< TUniqueId, rstl::reserved_vector< int, 15 > > x0_weapons;
};
CHECK_SIZEOF(CWeaponMgr, 0x14);

10
include/MetroidPrime/CWorld.hpp
View File

@ -25,7 +25,7 @@ public:
virtual TAreaId IGetAreaId(CAssetId id) const = 0;
virtual bool ICheckWorldComplete() = 0;
virtual rstl::string IGetDefaultAudioTrack() const = 0;
virtual s32 IGetAreaCount() const = 0;
virtual int IGetAreaCount() const = 0;
};
class CGameArea;
@ -55,7 +55,7 @@ public:
TAreaId IGetAreaId(CAssetId id) const override;
bool ICheckWorldComplete() override;
rstl::string IGetDefaultAudioTrack() const override;
s32 IGetAreaCount() const override;
int IGetAreaCount() const override;
const CGameArea& GetAreaAlways(TAreaId id) const {
return *x18_areas[id.Value()];
@ -87,13 +87,13 @@ private:
rstl::vector< CRelay > x2c_relays;
rstl::rc_ptr< IDvdRequest > x3c_loadToken;
rstl::single_ptr< u8 > x40_loadBuf;
u32 x44_bufSz;
u32 x48_chainCount;
uint x44_bufSz;
uint x48_chainCount;
CGameArea* x4c_chainHeads[5];
IObjectStore* x60_objectStore;
IFactory* x64_resFactory;
TAreaId x68_curAreaId;
u32 x6c_loadedAudioGrpCount;
uint x6c_loadedAudioGrpCount;
bool x70_24_currentAreaNeedsAllocation : 1;
bool x70_25_loadPaused : 1;
bool x70_26_skyboxActive : 1;

4
include/MetroidPrime/Cameras/CCameraHint.hpp
View File

@ -7,7 +7,7 @@
class CCameraHint {
public:
CCameraHint(u32 overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, f32 minDist, f32 maxDist,
CCameraHint(uint overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, f32 minDist, f32 maxDist,
f32 backwardsDist, const CVector3f& lookAtOffset, const CVector3f& chaseLookAtOffset,
const CVector3f& ballToCam, f32 fov, f32 attitudeRange, f32 azimuthRange,
f32 anglePerSecond, f32 clampVelRange, f32 clampRotRange, f32 elevation, f32 interpolateTime,
@ -15,7 +15,7 @@ public:
virtual ~CCameraHint();
private:
u32 mOverrideFlags;
uint mOverrideFlags;
CBallCamera::EBallCameraBehaviour mBehaviour;
f32 mMinDist;
f32 mMaxDist;

10
include/MetroidPrime/Cameras/CCameraManager.hpp
View File

@ -28,14 +28,14 @@ private:
TUniqueId x0_curCameraId;
rstl::vector< TUniqueId > x4_cineCameras;
rstl::list< CCameraShakeData > x14_shakers;
u32 x2c_lastShakeId;
uint x2c_lastShakeId;
CVector3f x30_shakeOffset;
CAreaFog x3c_fog;
s32 x74_fluidCounter;
int x74_fluidCounter;
TUniqueId x78_fluidId;
CFirstPersonCamera* x7c_fpCamera;
CBallCamera* x80_ballCamera;
s32 x84_rumbleId;
int x84_rumbleId;
CInterpolationCamera* x88_interpCamera;
s16 x8c_;
f32 x90_rumbleCooldown;
@ -48,8 +48,8 @@ private:
TUniqueId xa2_spindleCamId;
TUniqueId xa4_pathCamId;
TUniqueId xa6_camHintId;
s32 xa8_hintPriority;
rstl::reserved_vector< rstl::pair< s32, TUniqueId >, 64 > xac_cameraHints;
int xa8_hintPriority;
rstl::reserved_vector< rstl::pair< int, TUniqueId >, 64 > xac_cameraHints;
rstl::reserved_vector< TUniqueId, 64 > x2b0_inactiveCameraHints;
rstl::reserved_vector< TUniqueId, 64 > x334_activeCameraHints;
bool x3b8_24_ : 1;

4
include/MetroidPrime/Cameras/CCameraShakeData.hpp
View File

@ -34,8 +34,8 @@ private:
CCameraShakerComponent x8_shakerX;
CCameraShakerComponent x44_shakerY;
CCameraShakerComponent x80_shakerZ;
u32 xbc_shakerId;
u32 xc0_flags;
uint xbc_shakerId;
uint xc0_flags;
CVector3f xc4_sfxPos;
f32 xd0_sfxDist;
};

2
include/MetroidPrime/Cameras/CGameCamera.hpp
View File

@ -22,7 +22,7 @@ private:
f32 x160_znear;
f32 x164_zfar;
f32 x168_aspect;
u32 x16c_controllerIdx;
uint x16c_controllerIdx;
mutable bool x170_24_perspDirty : 1;
bool x170_25_disablesInput : 1;
f32 x174_delayTime;

18
include/MetroidPrime/Player/CGameOptions.hpp
View File

@ -19,15 +19,15 @@ public:
private:
rstl::reserved_vector< bool, 64 > x0_;
s32 x44_soundMode; // CAudioSys::ESurroundModes
u32 x48_screenBrightness;
s32 x4c_screenXOffset;
s32 x50_screenYOffset;
s32 x54_screenStretch;
u32 x58_sfxVol;
u32 x5c_musicVol;
u32 x60_hudAlpha;
u32 x64_helmetAlpha;
int x44_soundMode; // CAudioSys::ESurroundModes
uint x48_screenBrightness;
int x4c_screenXOffset;
int x50_screenYOffset;
int x54_screenStretch;
uint x58_sfxVol;
uint x5c_musicVol;
uint x60_hudAlpha;
uint x64_helmetAlpha;
bool x68_24_hudLag : 1;
bool x68_25_invertY : 1;
bool x68_26_rumble : 1;

4
include/MetroidPrime/Player/CGameState.hpp
View File

@ -26,7 +26,7 @@ public:
CSystemOptions& SystemOptions() { return xa8_systemOptions; }
CGameOptions& GameOptions() { return x17c_gameOptions; }
CHintOptions& HintOptions() { return x1f8_hintOptions; }
u32& SaveIdx() { return x20c_saveIdx; }
uint& SaveIdx() { return x20c_saveIdx; }
u64& CardSerial() { return x210_cardSerial; }
rstl::vector< u8 >& BackupBuf() { return x218_backupBuf; }
@ -40,7 +40,7 @@ private:
CSystemOptions xa8_systemOptions;
CGameOptions x17c_gameOptions;
CHintOptions x1f8_hintOptions;
u32 x20c_saveIdx;
uint x20c_saveIdx;
u64 x210_cardSerial;
rstl::vector< u8 > x218_backupBuf;
bool x228_24_hardMode : 1;

12
include/MetroidPrime/TGameTypes.hpp
View File

@ -12,11 +12,11 @@ extern TEditorId kInvalidEditorId;
extern TUniqueId kInvalidUniqueId;
struct TAreaId {
s32 value;
int value;
TAreaId() : value(-1) {}
TAreaId(s32 value) : value(value) {}
s32 Value() const { return value; }
TAreaId(int value) : value(value) {}
int Value() const { return value; }
bool operator==(const TAreaId& other) const { return value == other.value; }
bool operator!=(const TAreaId& other) const { return value != other.value; }
@ -24,11 +24,11 @@ struct TAreaId {
CHECK_SIZEOF(TAreaId, 0x4)
struct TEditorId {
u32 value;
uint value;
TEditorId() : value(-1) {}
TEditorId(u32 value) : value(value) {}
u32 Value() const { return value; }
TEditorId(uint value) : value(value) {}
uint Value() const { return value; }
bool operator==(const TEditorId& other) const { return value == other.value; }
bool operator!=(const TEditorId& other) const { return value != other.value; }

2
include/MetroidPrime/Tweaks/CTweakGame.hpp
View File

@ -10,7 +10,7 @@ public:
const rstl::string& GetWorldPrefix() { return x4_worldPrefix; }
private:
u32 x0_;
uint x0_;
rstl::string x4_worldPrefix;
};

2
include/MetroidPrime/Tweaks/CTweaks.hpp
View File

@ -9,7 +9,7 @@ public:
void RegisterTweaks();
private:
u32 x0_unk;
uint x0_unk;
};
#endif

4
include/dolphin/types.h
View File

@ -14,11 +14,11 @@ typedef uint64_t u64;
#else
typedef signed char s8;
typedef signed short int s16;
typedef signed int s32;
typedef signed long s32;
typedef signed long long int s64;
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned int u32;
typedef unsigned long u32;
typedef unsigned long long int u64;
#endif

14
include/rstl/reserved_vector.hpp
View File

@ -7,9 +7,9 @@
#include "rstl/pointer_iterator.hpp"
namespace rstl {
template < typename T, s32 N >
template < typename T, int N >
class reserved_vector {
s32 x0_count;
int x0_count;
u8 x4_data[N * sizeof(T)];
public:
@ -36,7 +36,7 @@ public:
return *this;
}
void clear() {
for (s32 i = 0; i < x0_count; ++i) {
for (int i = 0; i < x0_count; ++i) {
rstl::destroy(&data()[i]);
}
x0_count = 0;
@ -54,14 +54,14 @@ public:
inline T* data() { return reinterpret_cast< T* >(x4_data); }
inline const T* data() const { return reinterpret_cast< const T* >(x4_data); }
inline s32 size() const { return x0_count; }
inline s32 capacity() const { return N; }
inline int size() const { return x0_count; }
inline int capacity() const { return N; }
inline T& front() { return data()[0]; }
inline const T& front() const { return data()[0]; }
inline T& back() { return data()[x0_count - 1]; }
inline const T& back() const { return data()[x0_count - 1]; }
inline T& operator[](s32 idx) { return data()[idx]; }
inline const T& operator[](s32 idx) const { return data()[idx]; }
inline T& operator[](int idx) { return data()[idx]; }
inline const T& operator[](int idx) const { return data()[idx]; }
};
} // namespace rstl

2
include/rstl/rmemory_allocator.hpp
View File

@ -8,7 +8,7 @@
namespace rstl {
struct rmemory_allocator {
template < typename T >
static void allocate(T*& out, s32 sz) {
static void allocate(T*& out, int sz) {
out = reinterpret_cast< T* >(new u8[sz]);
}
template < typename T >

22
include/rstl/vector.hpp
View File

@ -10,8 +10,8 @@ namespace rstl {
template < typename T, typename Alloc = rmemory_allocator >
class vector {
Alloc x0_allocator;
s32 x4_count;
s32 x8_capacity;
int x4_count;
int x8_capacity;
T* xc_items;
public:
@ -23,14 +23,14 @@ public:
inline iterator end() { return iterator(xc_items + x4_count); }
inline const_iterator end() const { return const_iterator(xc_items + x4_count); }
inline vector() : x4_count(0), x8_capacity(0), xc_items(NULL) {}
inline vector(s32 count) : x4_count(0), x8_capacity(0), xc_items(0) { reserve(count); }
inline vector(int count) : x4_count(0), x8_capacity(0), xc_items(0) { reserve(count); }
vector(const vector& other) {
x4_count = other.x4_count;
x8_capacity = other.x8_capacity;
if (other.x4_count == 0 && other.x8_capacity == 0) {
xc_items = NULL;
} else {
s32 sz = x8_capacity * sizeof(T);
int sz = x8_capacity * sizeof(T);
if (sz == 0) {
xc_items = NULL;
} else {
@ -44,7 +44,7 @@ public:
x0_allocator.deallocate(xc_items);
}
void reserve(s32 size);
void reserve(int size);
void push_back(const T& in) {
if (x4_count >= x8_capacity) {
@ -79,21 +79,21 @@ public:
inline T* data() { return xc_items; }
inline const T* data() const { return xc_items; }
inline s32 size() const { return x4_count; }
inline s32 capacity() const { return x8_capacity; }
inline int size() const { return x4_count; }
inline int capacity() const { return x8_capacity; }
inline T& front() { return xc_items[0]; }
inline const T& front() const { return xc_items[0]; }
inline T& back() { return xc_items[x4_count - 1]; }
inline const T& back() const { return xc_items[x4_count - 1]; }
inline T& operator[](s32 idx) { return xc_items[idx]; }
inline const T& operator[](s32 idx) const { return xc_items[idx]; }
inline T& operator[](int idx) { return xc_items[idx]; }
inline const T& operator[](int idx) const { return xc_items[idx]; }
};
template < typename T, typename Alloc >
void vector< T, Alloc >::reserve(s32 size) {
void vector< T, Alloc >::reserve(int size) {
if (size <= x8_capacity)
return;
s32 sz = size * sizeof(T);
int sz = size * sizeof(T);
T* newData;
if (sz == 0) {
newData = nullptr;

3
include/types.h
View File

@ -9,6 +9,9 @@ extern "C" {
#include <dolphin/types.h>
// Dolphin u32 is unsigned long
typedef unsigned int uint;
// Pointer to unknown, to be determined at a later date.
typedef void* unkptr;

8
src/Kyoto/Alloc/IAllocator.cpp
View File

@ -2,10 +2,10 @@
#include "Kyoto/Basics/COsContext.hpp"
IAllocator::SMetrics::SMetrics(u32 heapSize, u32 unk1, u32 unk2, u32 unk3, u32 unk4, u32 heapSize2, u32 unk5, u32 unk6, u32 unk7, u32 unk8,
u32 unk9, u32 smallAllocNumAllocs, u32 smallAllocAllocatedSize, u32 smallAllocRemainingSize,
u32 mediumAllocNumAllocs, u32 mediumAllocAllocatedSize, u32 mediumAllocBlocksAvailable, u32 unk10, u32 unk11,
u32 unk12, u32 mediumAllocTotalAllocated, u32 fakeStatics)
IAllocator::SMetrics::SMetrics(uint heapSize, uint unk1, uint unk2, uint unk3, uint unk4, uint heapSize2, uint unk5, uint unk6, uint unk7, uint unk8,
uint unk9, uint smallAllocNumAllocs, uint smallAllocAllocatedSize, uint smallAllocRemainingSize,
uint mediumAllocNumAllocs, uint mediumAllocAllocatedSize, uint mediumAllocBlocksAvailable, uint unk10, uint unk11,
uint unk12, uint mediumAllocTotalAllocated, uint fakeStatics)
: x0_heapSize(heapSize)
, x4_(unk1)
, x8_(unk2)

2
src/Kyoto/Basics/CSWDataDolphin.cpp
View File

@ -6,7 +6,7 @@ void CStopwatch::CSWData::Wait(f32 v) const {
OSTime duration = OSSecondsToTicks(v);
OSTime end = OSGetTime() + duration;
volatile OSTime current;
volatile s32 diff;
volatile int diff;
do {
current = OSGetTime();
diff = current - end;

6
src/Kyoto/CCrc32.cpp
View File

@ -1,6 +1,6 @@
#include "Kyoto/CCrc32.hpp"
static const u32 gkCRC32Table[256] = {
static const uint gkCRC32Table[256] = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832,
0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A,
@ -32,8 +32,8 @@ static const u32 gkCRC32Table[256] = {
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,
};
u32 CCRC32::Calculate(const void* data, u32 length) {
u32 checksum = 0xFFFFFFFF;
uint CCRC32::Calculate(const void* data, uint length) {
uint checksum = 0xFFFFFFFF;
const s8* buf = static_cast<const s8*>(data);
while ((length--) > 0) {
checksum = (checksum >> 8) ^ gkCRC32Table[(checksum ^ *(buf++)) & 0xFF];

10
src/Kyoto/CRandom16.cpp
View File

@ -29,20 +29,20 @@ CRandom16* CRandom16::GetRandomNumber() { return gRandomNumber; }
void CRandom16::_SetRandomNumber(CRandom16* rnd) { gRandomNumber = rnd; }
CRandom16::CRandom16(u32 seed) : mSeed(seed) {}
CRandom16::CRandom16(uint seed) : mSeed(seed) {}
void CRandom16::SetSeed(u32 seed) { mSeed = seed; }
void CRandom16::SetSeed(uint seed) { mSeed = seed; }
s32 CRandom16::Range(s32 min, s32 max) { return min + (Next() % ((max - min) + 1)); }
int CRandom16::Range(int min, int max) { return min + (Next() % ((max - min) + 1)); }
float CRandom16::Range(float min, float max) { return ((max - min) * Float()) + min; }
s32 CRandom16::Next() {
int CRandom16::Next() {
mSeed = (mSeed * 0x41c64e6d) + 0x00003039;
return (mSeed >> 16) & 0xffff;
}
f32 CRandom16::Float() {
s32 next = Next();
int next = Next();
return 1.52590222E-5f * next;
}

26
src/Kyoto/Graphics/CCubeMaterial.cpp
View File

@ -7,7 +7,7 @@
#include <dolphin/mtx.h>
inline void CGX::SetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompare comp1, u8 ref1) {
u32 flags = MaskAndShiftLeft(comp0, 7, 0) | MaskAndShiftLeft(ref0, 0xFF, 3) | MaskAndShiftLeft(op, 7, 11) |
uint flags = MaskAndShiftLeft(comp0, 7, 0) | MaskAndShiftLeft(ref0, 0xFF, 3) | MaskAndShiftLeft(op, 7, 11) |
MaskAndShiftLeft(comp1, 7, 14) | MaskAndShiftLeft(ref1, 0xFF, 17);
if (sGXState.x248_alphaCompare != flags) {
sGXState.x248_alphaCompare = flags;
@ -16,7 +16,7 @@ inline void CGX::SetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompa
}
}
inline void CGX::SetBlendMode(GXBlendMode mode, GXBlendFactor srcFac, GXBlendFactor dstFac, GXLogicOp op) {
u32 flags = MaskAndShiftLeft(mode, 3, 0) | MaskAndShiftLeft(srcFac, 7, 2) | MaskAndShiftLeft(dstFac, 7, 5) | MaskAndShiftLeft(op, 0xF, 8);
uint flags = MaskAndShiftLeft(mode, 3, 0) | MaskAndShiftLeft(srcFac, 7, 2) | MaskAndShiftLeft(dstFac, 7, 5) | MaskAndShiftLeft(op, 0xF, 8);
if (flags != sGXState.x56_blendMode) {
update_fog(flags);
sGXState.x56_blendMode = flags;
@ -25,7 +25,7 @@ inline void CGX::SetBlendMode(GXBlendMode mode, GXBlendFactor srcFac, GXBlendFac
}
inline void CGX::SetTevOrder(GXTevStageID stageId, GXTexCoordID texCoord, GXTexMapID texMap, GXChannelID color) {
STevState& state = sGXState.x68_tevStates[stageId];
u32 flags = MaskAndShiftLeft(texCoord, 0xFF, 0) | MaskAndShiftLeft(texMap, 0xFF, 8) | MaskAndShiftLeft(color, 0xFF, 16);
uint flags = MaskAndShiftLeft(texCoord, 0xFF, 0) | MaskAndShiftLeft(texMap, 0xFF, 8) | MaskAndShiftLeft(color, 0xFF, 16);
if (state.x14_tevOrderFlags != flags) {
state.x14_tevOrderFlags = flags;
GXSetTevOrder(stageId, texCoord, texMap, color);
@ -52,7 +52,7 @@ CVector3f sPlayerPosition;
CVector3f CCubeMaterial::sViewingFrom;
static CTransform4f sTextureProjectionTransform = CTransform4f::Identity();
void CCubeMaterial::SetupBlendMode(u32 blendFactors, const CModelFlags& flags, bool alphaTest) {
void CCubeMaterial::SetupBlendMode(uint blendFactors, const CModelFlags& flags, bool alphaTest) {
GXBlendFactor newSrcFactor = static_cast< GXBlendFactor >(blendFactors & 0xFFFF);
GXBlendFactor newDstFactor = static_cast< GXBlendFactor >(blendFactors >> 0x10);
CModelFlags::ETrans blendMode = flags.GetTrans();
@ -73,24 +73,24 @@ void CCubeMaterial::SetupBlendMode(u32 blendFactors, const CModelFlags& flags, b
CGX::SetBlendMode(GX_BM_BLEND, newSrcFactor, newDstFactor, GX_LO_CLEAR);
}
void HandleTev(s32 tevCur, const u32* materialDataCur, const u32* texMapTexCoordFlags, bool shadowMapsEnabled) {
void HandleTev(int tevCur, const uint* materialDataCur, const uint* texMapTexCoordFlags, bool shadowMapsEnabled) {
const GXTevStageID stage = static_cast< GXTevStageID >(tevCur);
const u32 colorArgs = shadowMapsEnabled ? 0x7a04f : SBig(materialDataCur[0]);
const u32 alphaArgs = SBig(materialDataCur[1]);
const u32 colorOps = SBig(materialDataCur[2]);
const u32 alphaOps = SBig(materialDataCur[3]);
const uint colorArgs = shadowMapsEnabled ? 0x7a04f : SBig(materialDataCur[0]);
const uint alphaArgs = SBig(materialDataCur[1]);
const uint colorOps = SBig(materialDataCur[2]);
const uint alphaOps = SBig(materialDataCur[3]);
CGX::SetStandardDirectTev_Compressed(stage, colorArgs, alphaArgs, colorOps, alphaOps);
u32 tmtcFlags = SBig(*texMapTexCoordFlags);
u32 matFlags = SBig(materialDataCur[4]);
uint tmtcFlags = SBig(*texMapTexCoordFlags);
uint matFlags = SBig(materialDataCur[4]);
CGX::SetTevOrder(stage, static_cast< GXTexCoordID >(tmtcFlags & 0xFF), static_cast< GXTexMapID >(tmtcFlags >> 8 & 0xFF),
static_cast< GXChannelID >(matFlags & 0xFF));
CGX::SetTevKColorSel(stage, static_cast< GXTevKColorSel >(matFlags >> 0x8 & 0xFF));
CGX::SetTevKAlphaSel(stage, static_cast< GXTevKAlphaSel >(matFlags >> 0x10 & 0xFF));
}
u32 HandleAnimatedUV(const u32* uvAnim, GXTexMtx texMtx, GXPTTexMtx ptTexMtx) {
uint HandleAnimatedUV(const uint* uvAnim, GXTexMtx texMtx, GXPTTexMtx ptTexMtx) {
static const Mtx postMtx = {
{0.5f, 0.0f, 0.0f, 0.5f},
{0.0f, 0.0f, 0.5f, 0.5f},
@ -101,7 +101,7 @@ u32 HandleAnimatedUV(const u32* uvAnim, GXTexMtx texMtx, GXPTTexMtx ptTexMtx) {
{0.0f, 0.0f, 0.5f, 0.5f},
{0.0f, 0.0f, 0.0f, 1.0f},
};
u32 type = SBig(*uvAnim);
uint type = SBig(*uvAnim);
const f32* params = reinterpret_cast< const f32* >(uvAnim + 1);
switch (type) {
case 0: {

66
src/Kyoto/Graphics/CGX.cpp
View File

@ -48,7 +48,7 @@ void CGX::SetChanCtrl(EChannelId channel, GXBool enable, GXColorSrc ambSrc, GXCo
if (lights == GX_LIGHT_NULL) {
enable = GX_FALSE;
}
u32 flags = MaskAndShiftLeft(enable, 1, 0) | MaskAndShiftLeft(ambSrc, 1, 1) | MaskAndShiftLeft(matSrc, 1, 2) |
uint flags = MaskAndShiftLeft(enable, 1, 0) | MaskAndShiftLeft(ambSrc, 1, 1) | MaskAndShiftLeft(matSrc, 1, 2) |
MaskAndShiftLeft(lights, 0xFF, 3) | MaskAndShiftLeft(diffFn, 3, 11) | MaskAndShiftLeft(attnFn, 3, 13);
state = flags;
sGXState.x4c_chanFlags = ((flags != prevFlags) << (channel + 1)) | (sGXState.x4c_chanFlags & ~(1 << (channel + 1)));
@ -69,7 +69,7 @@ void CGX::SetTevKColor(GXTevKColorID id, const GXColor& color) {
}
void CGX::SetTevColorIn(GXTevStageID stageId, GXTevColorArg a, GXTevColorArg b, GXTevColorArg c, GXTevColorArg d) {
u32 flags = MaskAndShiftLeft(a, 0x1F, 0) | MaskAndShiftLeft(b, 0x1F, 5) | MaskAndShiftLeft(c, 0x1F, 10) | MaskAndShiftLeft(d, 0x1F, 15);
uint flags = MaskAndShiftLeft(a, 0x1F, 0) | MaskAndShiftLeft(b, 0x1F, 5) | MaskAndShiftLeft(c, 0x1F, 10) | MaskAndShiftLeft(d, 0x1F, 15);
STevState& state = sGXState.x68_tevStates[stageId];
if (flags != state.x0_colorInArgs) {
state.x0_colorInArgs = flags;
@ -78,7 +78,7 @@ void CGX::SetTevColorIn(GXTevStageID stageId, GXTevColorArg a, GXTevColorArg b,
}
void CGX::SetTevAlphaIn(GXTevStageID stageId, GXTevAlphaArg a, GXTevAlphaArg b, GXTevAlphaArg c, GXTevAlphaArg d) {
u32 flags = MaskAndShiftLeft(a, 0x1F, 0) | MaskAndShiftLeft(b, 0x1F, 5) | MaskAndShiftLeft(c, 0x1F, 10) | MaskAndShiftLeft(d, 0x1F, 15);
uint flags = MaskAndShiftLeft(a, 0x1F, 0) | MaskAndShiftLeft(b, 0x1F, 5) | MaskAndShiftLeft(c, 0x1F, 10) | MaskAndShiftLeft(d, 0x1F, 15);
STevState& state = sGXState.x68_tevStates[stageId];
if (flags != state.x4_alphaInArgs) {
state.x4_alphaInArgs = flags;
@ -87,7 +87,7 @@ void CGX::SetTevAlphaIn(GXTevStageID stageId, GXTevAlphaArg a, GXTevAlphaArg b,
}
void CGX::SetTevColorOp(GXTevStageID stageId, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp, GXTevRegID outReg) {
u32 flags = MaskAndShiftLeft(op, 0xF, 0) | MaskAndShiftLeft(bias, 3, 4) | MaskAndShiftLeft(scale, 3, 6) | MaskAndShiftLeft(clamp, 1, 8) |
uint flags = MaskAndShiftLeft(op, 0xF, 0) | MaskAndShiftLeft(bias, 3, 4) | MaskAndShiftLeft(scale, 3, 6) | MaskAndShiftLeft(clamp, 1, 8) |
MaskAndShiftLeft(outReg, 3, 9);
STevState& state = sGXState.x68_tevStates[stageId];
if (flags != state.x8_colorOps) {
@ -96,7 +96,7 @@ void CGX::SetTevColorOp(GXTevStageID stageId, GXTevOp op, GXTevBias bias, GXTevS
}
}
void CGX::SetTevColorOp_Compressed(GXTevStageID stageId, u32 flags) {
void CGX::SetTevColorOp_Compressed(GXTevStageID stageId, uint flags) {
STevState& state = sGXState.x68_tevStates[stageId];
if (flags != state.x8_colorOps) {
state.x8_colorOps = flags;
@ -107,7 +107,7 @@ void CGX::SetTevColorOp_Compressed(GXTevStageID stageId, u32 flags) {
}
void CGX::SetTevAlphaOp(GXTevStageID stageId, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp, GXTevRegID outReg) {
u32 flags = MaskAndShiftLeft(op, 0xF, 0) | MaskAndShiftLeft(bias, 3, 4) | MaskAndShiftLeft(scale, 3, 6) | MaskAndShiftLeft(clamp, 1, 8) |
uint flags = MaskAndShiftLeft(op, 0xF, 0) | MaskAndShiftLeft(bias, 3, 4) | MaskAndShiftLeft(scale, 3, 6) | MaskAndShiftLeft(clamp, 1, 8) |
MaskAndShiftLeft(outReg, 3, 9);
STevState& state = sGXState.x68_tevStates[stageId];
if (flags != state.xc_alphaOps) {
@ -116,7 +116,7 @@ void CGX::SetTevAlphaOp(GXTevStageID stageId, GXTevOp op, GXTevBias bias, GXTevS
}
}
void CGX::SetTevAlphaOp_Compressed(GXTevStageID stageId, u32 flags) {
void CGX::SetTevAlphaOp_Compressed(GXTevStageID stageId, uint flags) {
STevState& state = sGXState.x68_tevStates[stageId];
if (flags != state.xc_alphaOps) {
state.xc_alphaOps = flags;
@ -144,7 +144,7 @@ void CGX::SetTevKAlphaSel(GXTevStageID stageId, GXTevKAlphaSel sel) {
void CGX::SetTevOrder(GXTevStageID stageId, GXTexCoordID texCoord, GXTexMapID texMap, GXChannelID color) {
STevState& state = sGXState.x68_tevStates[stageId];
u32 flags = MaskAndShiftLeft(texCoord, 0xFF, 0) | MaskAndShiftLeft(texMap, 0xFF, 8) | MaskAndShiftLeft(color, 0xFF, 16);
uint flags = MaskAndShiftLeft(texCoord, 0xFF, 0) | MaskAndShiftLeft(texMap, 0xFF, 8) | MaskAndShiftLeft(color, 0xFF, 16);
if (state.x14_tevOrderFlags != flags) {
state.x14_tevOrderFlags = flags;
GXSetTevOrder(stageId, texCoord, texMap, color);
@ -152,7 +152,7 @@ void CGX::SetTevOrder(GXTevStageID stageId, GXTexCoordID texCoord, GXTexMapID te
}
void CGX::SetBlendMode(GXBlendMode mode, GXBlendFactor srcFac, GXBlendFactor dstFac, GXLogicOp op) {
u32 flags = MaskAndShiftLeft(mode, 3, 0) | MaskAndShiftLeft(srcFac, 7, 2) | MaskAndShiftLeft(dstFac, 7, 5) | MaskAndShiftLeft(op, 0xF, 8);
uint flags = MaskAndShiftLeft(mode, 3, 0) | MaskAndShiftLeft(srcFac, 7, 2) | MaskAndShiftLeft(dstFac, 7, 5) | MaskAndShiftLeft(op, 0xF, 8);
if (flags != sGXState.x56_blendMode) {
update_fog(flags);
sGXState.x56_blendMode = flags;
@ -170,7 +170,7 @@ void CGX::SetZMode(bool compareEnable, GXCompare func, bool updateEnable) {
}
void CGX::SetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompare comp1, u8 ref1) {
u32 flags = MaskAndShiftLeft(comp0, 7, 0) | MaskAndShiftLeft(ref0, 0xFF, 3) | MaskAndShiftLeft(op, 7, 11) |
uint flags = MaskAndShiftLeft(comp0, 7, 0) | MaskAndShiftLeft(ref0, 0xFF, 3) | MaskAndShiftLeft(op, 7, 11) |
MaskAndShiftLeft(comp1, 7, 14) | MaskAndShiftLeft(ref1, 0xFF, 17);
if (sGXState.x248_alphaCompare != flags) {
sGXState.x248_alphaCompare = flags;
@ -182,7 +182,7 @@ void CGX::SetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompare comp
void CGX::SetTevIndirect(GXTevStageID stageId, GXIndTexStageID indStage, GXIndTexFormat fmt, GXIndTexBiasSel biasSel, GXIndTexMtxID mtxSel,
GXIndTexWrap wrapS, GXIndTexWrap wrapT, GXBool addPrev, GXBool indLod, GXIndTexAlphaSel alphaSel) {
STevState& state = sGXState.x68_tevStates[stageId];
u32 flags = MaskAndShiftLeft(indStage, 3, 0) | MaskAndShiftLeft(fmt, 3, 2) | MaskAndShiftLeft(biasSel, 7, 4) |
uint flags = MaskAndShiftLeft(indStage, 3, 0) | MaskAndShiftLeft(fmt, 3, 2) | MaskAndShiftLeft(biasSel, 7, 4) |
MaskAndShiftLeft(mtxSel, 15, 7) | MaskAndShiftLeft(wrapS, 7, 11) | MaskAndShiftLeft(wrapT, 7, 14) |
MaskAndShiftLeft(addPrev, 1, 17) | MaskAndShiftLeft(indLod, 1, 18) | MaskAndShiftLeft(alphaSel, 3, 19);
if (state.x10_indFlags != flags) {
@ -201,13 +201,13 @@ void CGX::SetTevDirect(GXTevStageID stageId) {
void CGX::SetTexCoordGen(GXTexCoordID dstCoord, GXTexGenType fn, GXTexGenSrc src, GXTexMtx mtx, GXBool normalize, GXPTTexMtx postMtx) {
STexState& state = sGXState.x228_texStates[dstCoord];
u32 vm = (mtx - GX_TEXMTX0) / 3;
u32 vp = postMtx - GX_PTTEXMTX0;
uint vm = (mtx - GX_TEXMTX0) / 3;
uint vp = postMtx - GX_PTTEXMTX0;
#if NONMATCHING
// Similarly to GXTexMtx, this should also be divided by 3
vp /= 3;
#endif
u32 flags = MaskAndShiftLeft(fn, 0xF, 0) | MaskAndShiftLeft(src, 0x1F, 4) | MaskAndShiftLeft(vm, 0x1F, 9) |
uint flags = MaskAndShiftLeft(fn, 0xF, 0) | MaskAndShiftLeft(src, 0x1F, 4) | MaskAndShiftLeft(vm, 0x1F, 9) |
MaskAndShiftLeft(normalize, 1, 14) | MaskAndShiftLeft(vp, 0x3F, 15);
if (state.x0_coordGen != flags) {
state.x0_coordGen = flags;
@ -223,7 +223,7 @@ void CGX::SetNumIndStages(u8 num) {
}
void CGX::SetArray(GXAttr attr, const void* data, u8 stride) {
u32 idx = attr - GX_VA_POS;
uint idx = attr - GX_VA_POS;
if (data == nullptr || sGXState.x0_arrayPtrs[idx] == data) {
return;
}
@ -291,13 +291,13 @@ CGX::SGXState::SGXState()
, x248_alphaCompare(UINT_MAX) {
const GXColor sGXClear = {0, 0, 0, 0};
const GXColor sGXWhite = {255, 255, 255, 255};
for (s32 i = 0; i < 2; ++i) {
for (int i = 0; i < 2; ++i) {
x30_prevChanCtrls[i] = USHRT_MAX;
x34_chanCtrls[i] = USHRT_MAX;
x38_chanAmbColors[i] = sGXClear;
x40_chanMatColors[i] = sGXWhite;
}
for (s32 i = 0; i < 4; ++i) {
for (int i = 0; i < 4; ++i) {
x58_kColors[i] = sGXClear;
}
SetChanCtrl(Channel0, false, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
@ -307,13 +307,13 @@ CGX::SGXState::SGXState()
void CGX::ResetGXStates() {
sGXState.x48_descList = 0;
GXClearVtxDesc();
for (s32 i = 0; i < 12; i++) {
for (int i = 0; i < 12; i++) {
sGXState.x0_arrayPtrs[i] = reinterpret_cast< const void* >(1);
}
for (s32 i = 0; i < 8; i++) {
for (int i = 0; i < 8; i++) {
CTexture::InvalidateTexmap(static_cast< GXTexMapID >(i));
}
for (s32 i = 0; i < 4; i++) {
for (int i = 0; i < 4; i++) {
GXSetTevKColor(static_cast< GXTevKColorID >(i), sGXState.x58_kColors[i]);
}
GXSetTevSwapModeTable(GX_TEV_SWAP1, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_RED);
@ -322,13 +322,13 @@ void CGX::ResetGXStates() {
SetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0);
GXSetCurrentMtx(GX_PNMTX0);
SetNumIndStages(0);
for (s32 i = 0; i < 4; i++) {
for (int i = 0; i < 4; i++) {
GXSetIndTexCoordScale(static_cast< GXIndTexStageID >(i), GX_ITS_1, GX_ITS_1);
}
for (s32 i = 0; i < 16; i++) {
for (int i = 0; i < 16; i++) {
SetTevDirect(static_cast< GXTevStageID >(i));
}
for (s32 i = 0; i < 8; i++) {
for (int i = 0; i < 8; i++) {
GXSetTexCoordScaleManually(static_cast< GXTexCoordID >(i), false, 0, 0);
}
GXSetZTexture(GX_ZT_DISABLE, GX_TF_Z8, 0);
@ -349,7 +349,7 @@ void CGX::FlushState() {
GXBool enable = ShiftRightAndMask(flags, 1, 0);
GXColorSrc ambSrc = static_cast< GXColorSrc >(ShiftRightAndMask(flags, 1, 1));
GXColorSrc matSrc = static_cast< GXColorSrc >(ShiftRightAndMask(flags, 1, 2));
u32 lightMask = ShiftRightAndMask(flags, 0xFF, 3);
uint lightMask = ShiftRightAndMask(flags, 0xFF, 3);
GXDiffuseFn diffFn = static_cast< GXDiffuseFn >(ShiftRightAndMask(flags, 3, 11));
GXAttnFn attnFn = static_cast< GXAttnFn >(ShiftRightAndMask(flags, 3, 13));
GXSetChanCtrl(GX_COLOR0, enable, ambSrc, matSrc, lightMask, diffFn, attnFn);
@ -360,7 +360,7 @@ void CGX::FlushState() {
GXBool enable = ShiftRightAndMask(flags, 1, 0);
GXColorSrc ambSrc = static_cast< GXColorSrc >(ShiftRightAndMask(flags, 1, 1));
GXColorSrc matSrc = static_cast< GXColorSrc >(ShiftRightAndMask(flags, 1, 2));
u32 lightMask = ShiftRightAndMask(flags, 0xFF, 3);
uint lightMask = ShiftRightAndMask(flags, 0xFF, 3);
GXDiffuseFn diffFn = static_cast< GXDiffuseFn >(ShiftRightAndMask(flags, 3, 11));
GXAttnFn attnFn = static_cast< GXAttnFn >(ShiftRightAndMask(flags, 3, 13));
GXSetChanCtrl(GX_COLOR1, enable, ambSrc, matSrc, lightMask, diffFn, attnFn);
@ -377,13 +377,13 @@ void CGX::SetIndTexMtxSTPointFive(GXIndTexMtxID id, s8 scaleExp) {
GXSetIndTexMtx(id, const_cast< f32(*)[3] >(indMtx), scaleExp);
}
void CGX::SetVtxDescv_Compressed(u32 flags) {
void CGX::SetVtxDescv_Compressed(uint flags) {
if (flags == sGXState.x48_descList) {
return;
}
GXVtxDescList* list = sVtxDescList;
for (u32 idx = 0; idx < 11; ++idx) {
u32 shift = idx * 2;
for (uint idx = 0; idx < 11; ++idx) {
uint shift = idx * 2;
if ((flags & 3 << shift) == (sGXState.x48_descList & 3 << shift)) {
continue;
}
@ -398,9 +398,9 @@ void CGX::SetVtxDescv_Compressed(u32 flags) {
}
void CGX::SetVtxDesc(GXAttr attr, GXAttrType type) {
u32 lshift = (attr - GX_VA_POS) * 2;
u32 rshift = 3 << lshift;
u32 flags = type << lshift;
uint lshift = (attr - GX_VA_POS) * 2;
uint rshift = 3 << lshift;
uint flags = type << lshift;
if (flags != (sGXState.x48_descList & rshift)) {
sGXState.x48_descList = flags | (sGXState.x48_descList & ~rshift);
GXSetVtxDesc(attr, type);
@ -416,14 +416,14 @@ void CGX::ResetVtxDescv() {
}
void CGX::SetVtxDescv(const GXVtxDescList* list) {
u32 flags = 0;
uint flags = 0;
for (; list->attr != GX_VA_NULL; ++list) {
flags |= (list->type & 3) << (list->attr - GX_VA_POS) * 2;
}
SetVtxDescv_Compressed(flags);
}
void CGX::SetStandardDirectTev_Compressed(GXTevStageID stageId, u32 colorArgs, u32 alphaArgs, u32 colorOps, u32 alphaOps) {
void CGX::SetStandardDirectTev_Compressed(GXTevStageID stageId, uint colorArgs, uint alphaArgs, uint colorOps, uint alphaOps) {
STevState& state = sGXState.x68_tevStates[stageId];
if (state.x10_indFlags != 0) {
state.x10_indFlags = 0;

28
src/Kyoto/Graphics/DolphinCColor.cpp
View File

@ -44,25 +44,25 @@ CColor CColor::Lerp(const CColor& a, const CColor& b, float t) {
omt * a.GetAlpha() + t * b.GetAlpha());
}
u32 CColor::Lerp(u32 a, u32 b, float t) {
u32 alpha = t * 256.f;
uint CColor::Lerp(uint a, uint b, float t) {
uint alpha = t * 256.f;
u32 dstrb = a & 0xff00ff;
u32 dstag = a >> 8 & 0xff00ff;
uint dstrb = a & 0xff00ff;
uint dstag = a >> 8 & 0xff00ff;
u32 srcrb = b & 0xff00ff;
u32 srcag = b >> 8 & 0xff00ff;
uint srcrb = b & 0xff00ff;
uint srcag = b >> 8 & 0xff00ff;
u32 drb = srcrb - dstrb;
u32 dag = srcag - dstag;
uint drb = srcrb - dstrb;
uint dag = srcag - dstag;
drb *= alpha;
dag *= alpha;
drb >>= 8;
dag >>= 8;
const u32 rb = (drb + dstrb) & 0x00ff00ff;
const u32 ag = (dag + dstag) << 8 & 0xff00ff00;
const uint rb = (drb + dstrb) & 0x00ff00ff;
const uint ag = (dag + dstag) << 8 & 0xff00ff00;
return rb | ag;
}
@ -73,10 +73,10 @@ CColor CColor::Modulate(const CColor& a, const CColor& b) {
}
CColor CColor::Add(const CColor& arg0, const CColor& arg1) {
return CColor((u8)rstl::min_val< u32 >(255, arg0.GetRedu8() + arg1.GetRedu8()),
(u8)rstl::min_val< u32 >(255, arg0.GetGreenu8() + arg1.GetGreenu8()),
(u8)rstl::min_val< u32 >(255, arg0.GetBlueu8() + arg1.GetBlueu8()),
(u8)rstl::min_val< u32 >(255, arg0.GetAlphau8() + arg1.GetAlphau8()));
return CColor((u8)rstl::min_val< uint >(255, arg0.GetRedu8() + arg1.GetRedu8()),
(u8)rstl::min_val< uint >(255, arg0.GetGreenu8() + arg1.GetGreenu8()),
(u8)rstl::min_val< uint >(255, arg0.GetBlueu8() + arg1.GetBlueu8()),
(u8)rstl::min_val< uint >(255, arg0.GetAlphau8() + arg1.GetAlphau8()));
}
u16 CColor::ToRGB5A3() const {

52
src/Kyoto/Streams/CInputStream.cpp
View File

@ -4,7 +4,7 @@
#include "Kyoto/Alloc/CMemory.hpp"
CInputStream::CInputStream(s32 len)
CInputStream::CInputStream(int len)
: x4_blockOffset(0)
, x8_blockLen(0)
, xc_len(len)
@ -14,7 +14,7 @@ CInputStream::CInputStream(s32 len)
, x1c_bitWord(0)
, x20_bitOffset(0) {}
CInputStream::CInputStream(const void* ptr, s32 len, bool owned)
CInputStream::CInputStream(const void* ptr, int len, bool owned)
: x4_blockOffset(0)
, x8_blockLen(len)
, xc_len(len)
@ -39,12 +39,12 @@ bool CInputStream::InternalReadNext() {
bool CInputStream::GrabAnotherBlock() { return InternalReadNext(); }
void CInputStream::Get(void* dest, unsigned long len) {
u32 remain = len;
u32 readCount = 0;
uint remain = len;
uint readCount = 0;
x20_bitOffset = 0;
while (remain != 0) {
u32 blockLen = x8_blockLen - x4_blockOffset;
uint blockLen = x8_blockLen - x4_blockOffset;
blockLen = remain < blockLen ? remain : blockLen;
if (blockLen != 0) {
@ -53,7 +53,7 @@ void CInputStream::Get(void* dest, unsigned long len) {
readCount += blockLen;
x4_blockOffset += blockLen;
} else if (remain > 256) {
u32 readLen = Read(reinterpret_cast< u8* >(dest) + readCount, remain);
uint readLen = Read(reinterpret_cast< u8* >(dest) + readCount, remain);
remain -= readLen;
readCount += readLen;
} else {
@ -64,7 +64,7 @@ void CInputStream::Get(void* dest, unsigned long len) {
x18_readPosition += readCount;
}
u32 CInputStream::ReadBytes(void* dest, unsigned long len) {
uint CInputStream::ReadBytes(void* dest, unsigned long len) {
if (len == 0) {
return 0;
}
@ -73,11 +73,11 @@ u32 CInputStream::ReadBytes(void* dest, unsigned long len) {
GrabAnotherBlock();
}
u32 curLen = len;
u32 curReadLen = 0;
uint curLen = len;
uint curReadLen = 0;
while (curReadLen < len) {
u32 remain = x8_blockLen - x4_blockOffset;
uint remain = x8_blockLen - x4_blockOffset;
if (remain == 0) {
if (InternalReadNext()) {
continue;
@ -86,7 +86,7 @@ u32 CInputStream::ReadBytes(void* dest, unsigned long len) {
}
}
u32 sz = curLen < remain ? curLen : remain;
uint sz = curLen < remain ? curLen : remain;
memcpy(reinterpret_cast< u8* >(dest) + curReadLen, x10_ptr + x4_blockOffset, sz);
curReadLen += sz;
curLen -= sz;
@ -97,41 +97,41 @@ u32 CInputStream::ReadBytes(void* dest, unsigned long len) {
return curReadLen;
}
static inline u32 BitsToBytes(u32 bits) { return (bits / 8) + ((bits % 8) ? 1 : 0); }
static inline uint BitsToBytes(uint bits) { return (bits / 8) + ((bits % 8) ? 1 : 0); }
u32 CInputStream::ReadBits(u32 bitCount) {
uint CInputStream::ReadBits(uint bitCount) {
if (x20_bitOffset >= bitCount) {
u32 mask = 0xffffffff;
u32 bwShift = 32 - bitCount;
uint mask = 0xffffffff;
uint bwShift = 32 - bitCount;
if (bitCount != 0x20) {
mask = (1 << bitCount) - 1;
}
u32 ret = mask & (x1c_bitWord >> bwShift);
uint ret = mask & (x1c_bitWord >> bwShift);
x20_bitOffset -= bitCount;
x1c_bitWord <<= bitCount;
return ret;
}
u32 shiftAmt = bitCount - x20_bitOffset;
uint shiftAmt = bitCount - x20_bitOffset;
u32 ret = 0;
uint ret = 0;
{
u32 mask = 0xffffffff;
u32 bwShift = 32 - x20_bitOffset;
uint mask = 0xffffffff;
uint bwShift = 32 - x20_bitOffset;
if (x20_bitOffset != 0x20) {
mask = (1 << x20_bitOffset) - 1;
}
ret = (mask & (x1c_bitWord >> bwShift)) << shiftAmt;
}
u32 len = BitsToBytes(shiftAmt);
uint len = BitsToBytes(shiftAmt);
x20_bitOffset = 0;
Get(&x1c_bitWord, len);
{
u32 mask = 0xffffffff;
u32 bwShift = 32 - shiftAmt;
uint mask = 0xffffffff;
uint bwShift = 32 - shiftAmt;
if (shiftAmt != 0x20) {
mask = (1 << shiftAmt) - 1;
}
@ -158,9 +158,9 @@ u16 CInputStream::ReadShort() {
return s;
}
u32 CInputStream::ReadLong() {
static u32 l;
Get(&l, sizeof(u32));
uint CInputStream::ReadLong() {
static uint l;
Get(&l, sizeof(uint));
return l;
}

2
src/Kyoto/Streams/CMemoryInStream.cpp
View File

@ -5,4 +5,4 @@ CMemoryInStream::CMemoryInStream(const void* ptr, unsigned long len, EOwnerShip
CMemoryInStream::CMemoryInStream(const void* ptr, unsigned long len) : CInputStream(ptr, len, false) {}
u32 CMemoryInStream::Read(void* dest, u32 len) { return 0; }
uint CMemoryInStream::Read(void* dest, uint len) { return 0; }

22
src/Kyoto/Text/CStringTable.cpp
View File

@ -11,34 +11,34 @@ static const wchar_t skInvalidString[] = L"Invalid";
CStringTable::CStringTable(CInputStream& in) : x0_stringCount(0), x4_data(NULL) {
in.ReadLong();
in.ReadLong();
s32 langCount = in.Get(TType< s32 >());
x0_stringCount = in.Get(TType< u32 >());
rstl::vector< rstl::pair< FourCC, u32 > > langOffsets(langCount);
for (s32 i = 0; i < langCount; ++i) {
langOffsets.push_back(in.Get(TType< rstl::pair< FourCC, u32 > >()));
int langCount = in.Get(TType< int >());
x0_stringCount = in.Get(TType< uint >());
rstl::vector< rstl::pair< FourCC, uint > > langOffsets(langCount);
for (int i = 0; i < langCount; ++i) {
langOffsets.push_back(in.Get(TType< rstl::pair< FourCC, uint > >()));
}
s32 offset = langOffsets.front().second;
for (s32 i = 0; i < langCount; ++i) {
int offset = langOffsets.front().second;
for (int i = 0; i < langCount; ++i) {
if (langOffsets[i].first == mCurrentLanguage) {
offset = langOffsets[i].second;
break;
}
}
for (u32 i = 0; i < offset; ++i) {
for (uint i = 0; i < offset; ++i) {
in.ReadChar();
}
u32 dataLen = in.Get(TType< u32 >());
uint dataLen = in.Get(TType< uint >());
x4_data = new u8[dataLen];
in.ReadBytes(x4_data.get(), dataLen);
}
const wchar_t* CStringTable::GetString(s32 idx) const {
const wchar_t* CStringTable::GetString(int idx) const {
if (idx < 0 || idx >= x0_stringCount) {
return skInvalidString;
}
s32 offset = *(reinterpret_cast< const s32* >(x4_data.get()) + idx);
int offset = *(reinterpret_cast< const int* >(x4_data.get()) + idx);
return reinterpret_cast< const wchar_t* >(x4_data.get() + offset);
}

22
src/MetroidPrime/CActor.cpp
View File

@ -102,7 +102,7 @@ SAdvancementDeltas CActor::UpdateAnimation(float dt, CStateManager& mgr, bool ad
UpdateSfxEmitters();
if (HasAnimation()) {
u16 maxVol = xd4_maxVol;
s32 aid = x4_areaId.Value();
int aid = x4_areaId.Value();
const CGameCamera* camera = mgr.GetCameraManager()->GetCurrentCamera(mgr);
const CVector3f origin = GetTranslation();
@ -112,15 +112,15 @@ SAdvancementDeltas CActor::UpdateAnimation(float dt, CStateManager& mgr, bool ad
const CSoundPOINode* soundNode;
const CParticlePOINode* particleNode;
s32 soundNodeCount = 0;
int soundNodeCount = 0;
if (HasAnimation()) {
soundNode = GetAnimationData()->GetSoundPOIList(soundNodeCount);
} else {
soundNode = nullptr;
}
if (soundNodeCount > 0 && soundNode != nullptr) {
for (s32 i = 0; i < soundNodeCount; ++soundNode, ++i) {
s32 charIdx = soundNode->GetCharacterIndex();
for (int i = 0; i < soundNodeCount; ++soundNode, ++i) {
int charIdx = soundNode->GetCharacterIndex();
if (soundNode->GetPoiType() != kPT_Sound || GetMuted())
continue;
if (charIdx != -1 && GetAnimationData()->GetCharacterIndex() != charIdx)
@ -130,15 +130,15 @@ SAdvancementDeltas CActor::UpdateAnimation(float dt, CStateManager& mgr, bool ad
}
}
s32 intNodeCount = 0;
int intNodeCount = 0;
if (HasAnimation()) {
intNode = GetAnimationData()->GetInt32POIList(intNodeCount);
} else {
intNode = nullptr;
}
if (intNodeCount > 0 && intNode != nullptr) {
for (s32 i = 0; i < intNodeCount; ++intNode, ++i) {
s32 charIdx = intNode->GetCharacterIndex();
for (int i = 0; i < intNodeCount; ++intNode, ++i) {
int charIdx = intNode->GetCharacterIndex();
if (intNode->GetPoiType() == kPT_SoundInt32 && !GetMuted() &&
(charIdx == -1 || GetAnimationData()->GetCharacterIndex() == charIdx)) {
ProcessSoundEvent(intNode->GetValue(), intNode->GetWeight(), intNode->GetFlags(), 0.1f, 150.f, 20, maxVol, toCamera, origin, aid,
@ -149,15 +149,15 @@ SAdvancementDeltas CActor::UpdateAnimation(float dt, CStateManager& mgr, bool ad
}
}
s32 particleNodeCount = 0;
int particleNodeCount = 0;
if (HasAnimation()) {
particleNode = GetAnimationData()->GetParticlePOIList(particleNodeCount);
} else {
particleNode = nullptr;
}
if (particleNodeCount > 0 && particleNode != nullptr) {
for (s32 i = 0; i < particleNodeCount; ++particleNode, ++i) {
s32 charIdx = particleNode->GetCharacterIndex();
for (int i = 0; i < particleNodeCount; ++particleNode, ++i) {
int charIdx = particleNode->GetCharacterIndex();
if (charIdx != -1 && GetAnimationData()->GetCharacterIndex() != charIdx)
continue;
AnimationData()->SetParticleEffectState(particleNode->GetString(), true, mgr);
@ -181,7 +181,7 @@ void CActor::DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUse
}
}
f32 CActor::GetAverageAnimVelocity(s32 anim) { return HasAnimation() ? GetAnimationData()->GetAverageVelocity(anim) : 0.f; }
f32 CActor::GetAverageAnimVelocity(int anim) { return HasAnimation() ? GetAnimationData()->GetAverageVelocity(anim) : 0.f; }
void CActor::CalculateRenderBounds() {
if (HasModelData()) {

8
src/MetroidPrime/CObjectList.cpp
View File

@ -6,7 +6,7 @@ CObjectList::CObjectList(EGameObjectList list)
: mListType(list)
, mFirstId(-1)
, mCount(0) {
for (s32 i = 0; i < kMaxObjects; ++i) {
for (int i = 0; i < kMaxObjects; ++i) {
mObjects[i] = SObjectListEntry();
}
}
@ -39,8 +39,8 @@ CEntity* CObjectList::GetValidObjectById(TUniqueId uid) {}
const CEntity* CObjectList::GetValidObjectById(TUniqueId uid) const {}
CEntity* CObjectList::operator[](s32 idx) {}
CEntity* CObjectList::operator[](int idx) {}
const CEntity* CObjectList::operator[](s32 idx) const {}
const CEntity* CObjectList::operator[](int idx) const {}
const CEntity* CObjectList::GetValidObjectByIndex(s32 idx) const {}
const CEntity* CObjectList::GetValidObjectByIndex(int idx) const {}

2
src/MetroidPrime/Cameras/CCameraHint.cpp
View File

@ -1,7 +1,7 @@
#include "MetroidPrime/Cameras/CCameraHint.hpp"
#include "Kyoto/Alloc/CMemory.hpp"
CCameraHint::CCameraHint(u32 overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, float minDist, float maxDist, float backwardsDist,
CCameraHint::CCameraHint(uint overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, float minDist, float maxDist, float backwardsDist,
CVector3f* lookAtOffset, CVector3f* chaseLookAtOffset, CVector3f* ballToCam, float fov, float attitudeRange,
float azimuthRange, float anglePerSecond, float clampVelRange, float clampRotRange, float elevation,
float InterpolationTime, float clampVelTime, float controlInterpDur)

8
src/MetroidPrime/main.cpp
View File

@ -111,7 +111,7 @@ void CMain::RefreshGameState() {
// 8000487C
void CMain::EnsureWorldPaksReady(void) {
CResLoader& resLoader = gpResourceFactory->GetResLoader();
for (s32 i = 0; i < resLoader.GetPakCount(); ++i) {
for (int i = 0; i < resLoader.GetPakCount(); ++i) {
CPakFile& file = resLoader.GetPakFile(i);
if (file.IsWorldPak()) {
file.EnsureWorldPakReady();
@ -132,9 +132,9 @@ void CMain::AddWorldPaks() {
}
// 80004CE8
void CMain::AsyncIdle(u32 time) {
void CMain::AsyncIdle(uint time) {
if (time < 500) {
u32 total = 0;
uint total = 0;
for (int i = 0; i < x130_frameTimes.capacity(); ++i) {
total += x130_frameTimes[i];
}
@ -233,7 +233,7 @@ int CMain::RsMain(int argc, const char* const* argv) {
x104_.AddValue(t2 / dt);
x11c_ = x104_.GetAverage().data();
u32 idleMicros;
uint idleMicros;
f64 idleTime = (dt - (t1 + t2)) - 0.00075;
if (idleTime > 0)
idleMicros = idleTime * 1000000;