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

More CModel RE, removed the separated normal types hack

This commit is contained in:
Phillip Stephens 2022-02-03 07:24:41 -08:00
parent a6106b6c42
commit 9461fe0563
Signed by: Antidote
GPG Key ID: F8BEE4C83DACA60D
2 changed files with 114 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
Runtime/Graphics/CCubeModel.cpp
View File

@ -2,7 +2,7 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include "Runtime/CSimplePool.hpp"
//TODO Remove WIP once we've transitioned to this
// TODO Remove WIP once we've transitioned to this
namespace metaforce::WIP {
#pragma region CModel
u32 CModel::sTotalMemory = 0;
@ -61,10 +61,11 @@ CModel::CModel(std::unique_ptr<u8[]> in, u32 dataLen, IObjectStore* store)
for (u32 i = 0; i < numNormals; ++i) {
if ((flags & 2) == 0) {
const auto* norm = reinterpret_cast<const float*>(normals + (i * (sizeof(float) * 3)));
m_floatNormals.emplace_back(hecl::SBig(norm[0]), hecl::SBig(norm[1]), hecl::SBig(norm[2]));
m_normals.emplace_back(hecl::SBig(norm[0]), hecl::SBig(norm[1]), hecl::SBig(norm[2]));
} else {
const auto* norm = reinterpret_cast<const s16*>(normals + (i * (sizeof(s16) * 3)));
m_shortNormals.emplace_back(std::array{hecl::SBig(norm[0]), hecl::SBig(norm[1]), hecl::SBig(norm[2])});
m_normals.emplace_back(hecl::SBig(norm[0]) / 32676.f, hecl::SBig(norm[1]) / 32676.f,
hecl::SBig(norm[2]) / 32676.f);
}
}
u32 numColors = hecl::SBig(*secSizeCur) / (sizeof(int));
@ -102,17 +103,18 @@ CModel::CModel(std::unique_ptr<u8[]> in, u32 dataLen, IObjectStore* store)
x8_surfaces.reserve(x8_surfaces.capacity() * 2);
}
x8_surfaces.emplace_back(MemoryFromPartData(dataCur, secSizeCur));
x8_surfaces.emplace_back(std::make_unique<CCubeSurface>(MemoryFromPartData(dataCur, secSizeCur)));
}
const float* bounds = reinterpret_cast<float*>(data + 12);
m_aabox.min = {hecl::SBig(bounds[0]), hecl::SBig(bounds[1]), hecl::SBig(bounds[2])};
m_aabox.max = {hecl::SBig(bounds[3]), hecl::SBig(bounds[4]), hecl::SBig(bounds[5])};
zeus::CAABox aabox = zeus::skNullBox;
aabox.min = {hecl::SBig(bounds[0]), hecl::SBig(bounds[1]), hecl::SBig(bounds[2])};
aabox.max = {hecl::SBig(bounds[3]), hecl::SBig(bounds[4]), hecl::SBig(bounds[5])};
/* This constructor has been changed from the original to take into account platform differences */
x28_modelInst = std::make_unique<CCubeModel>(&x8_surfaces, &x18_matSets[0].x0_textures, x18_matSets[0].x10_data,
&m_positions, &m_floatNormals, &m_shortNormals, &m_colors, &m_floatUVs,
&m_shortUVs, &m_aabox, flags, true, -1);
x28_modelInst =
std::make_unique<CCubeModel>(&x8_surfaces, &x18_matSets[0].x0_textures, x18_matSets[0].x10_data, &m_positions,
&m_colors, &m_normals, &m_floatUVs, &m_shortUVs, aabox, flags, true, -1);
sThisFrameList = this;
if (x34_next != nullptr) {
@ -187,6 +189,23 @@ void CModel::DisableTextureTimeout() { sIsTextureTimeoutEnabled = false; }
#pragma region CCubeModel
CCubeModel::CCubeModel(const std::vector<std::unique_ptr<CCubeSurface>>* surfaces,
const std::vector<TCachedToken<CTexture>>* textures, const u8* materialData,
const std::vector<zeus::CVector3f>* positions, const std::vector<zeus::CColor>* colors,
const std::vector<zeus::CVector3f>* normals, const std::vector<zeus::CVector2f>* texCoords,
const std::vector<std::array<s16, 2>>* packedTexCoords, const zeus::CAABox& aabox, u8 flags,
bool b1, u32 idx)
: x0_modelInstance(surfaces, materialData, positions, colors, normals, texCoords, packedTexCoords)
, x1c_textures(textures)
, x20_worldAABB(aabox)
, x40_24_(!b1)
, x41_visorFlags(flags)
, x44_idx(idx) {
for (const auto& surf : x0_modelInstance.Surfaces()) {
surf->SetParent(this);
}
}
void CCubeModel::UnlockTextures() {}
void CCubeModel::MakeTexturesFromMats(const u8* ptr, std::vector<TCachedToken<CTexture>>& texture, bool b1) {}
@ -194,7 +213,19 @@ void CCubeModel::MakeTexturesFromMats(const u8* ptr, std::vector<TCachedToken<CT
#pragma endregion
#pragma region CCubeSurface
CCubeSurface::CCubeSurface(u8* ptr) {}
CCubeSurface::CCubeSurface(u8* ptr) {
CMemoryInStream mem(ptr, 64);
x0_center.readBig(mem);
xc_materialIndex = mem.readUint32Big();
x10_displayListSize = mem.readUint32Big();
x14_parent = reinterpret_cast<CCubeModel*>(mem.readUint32Big());
x18_nextSurface = reinterpret_cast<CCubeSurface*>(mem.readUint32Big());
x1c_extraSize = mem.readUint32Big();
x20_normal.readBig(mem);
if (x1c_extraSize > 0) {
x2c_bounds = zeus::CAABox::ReadBoundingBoxBig(mem);
}
}
#pragma endregion
CFactoryFnReturn FModelFactory(const metaforce::SObjectTag& tag, std::unique_ptr<u8[]>&& in, u32 len,
@ -204,4 +235,4 @@ CFactoryFnReturn FModelFactory(const metaforce::SObjectTag& tag, std::unique_ptr
return ret;
}
} // namespace metaforce
} // namespace metaforce::WIP

99
Runtime/Graphics/CCubeModel.hpp
View File

@ -34,7 +34,7 @@ private:
std::unique_ptr<u8[]> x0_data;
u32 x4_dataLen;
std::vector<CCubeSurface> x8_surfaces;
std::vector<std::unique_ptr<CCubeSurface>> x8_surfaces; // Was a vector of void*
std::vector<SShader> x18_matSets;
std::unique_ptr<CCubeModel> x28_modelInst = nullptr;
u16 x2c_ = 0;
@ -43,10 +43,8 @@ private:
CModel* x34_next;
u32 x38_lastFrame;
/* Resident copies of maintained data */
zeus::CAABox m_aabox;
std::vector<zeus::CVector3f> m_positions;
std::vector<zeus::CVector3f> m_floatNormals;
std::vector<std::array<s16, 3>> m_shortNormals;
std::vector<zeus::CVector3f> m_normals;
std::vector<zeus::CColor> m_colors;
std::vector<zeus::CVector2f> m_floatUVs;
std::vector<std::array<s16, 2>> m_shortUVs;
@ -67,15 +65,60 @@ public:
#pragma region CCubeModel
class CCubeModel {
private:
class ModelInstance {
const std::vector<std::unique_ptr<CCubeSurface>>* x0_surfacePtrs; // was a pointer to vector of void
const u8* x4_materialData;
const std::vector<zeus::CVector3f>* x8_positions; // was a pointer to void
const std::vector<zeus::CVector3f>* xc_normals; // was a pointer to void
const std::vector<zeus::CColor>* x10_colors; // was a pointer to void
const std::vector<zeus::CVector2f>* x14_texCoords; // was a pointer to void
const std::vector<std::array<s16, 2>>* x18_packedTexCoords; // was a pointer to void
public:
ModelInstance(const std::vector<std::unique_ptr<CCubeSurface>>* surfaces, const u8* material,
const std::vector<zeus::CVector3f>* positions, const std::vector<zeus::CColor>* colors,
const std::vector<zeus::CVector3f>* normals, const std::vector<zeus::CVector2f>* texCoords,
const std::vector<std::array<s16, 2>>* packedTexCoords)
: x0_surfacePtrs(surfaces)
, x4_materialData(material)
, x8_positions(positions)
, xc_normals(normals)
, x10_colors(colors)
, x14_texCoords(texCoords)
, x18_packedTexCoords(packedTexCoords) {}
/* These functions have been slightly modified from their original to return the actual vector instead of a raw
* pointer
*/
[[nodiscard]] const std::vector<std::unique_ptr<CCubeSurface>>& Surfaces() const { return *x0_surfacePtrs; }
[[nodiscard]] const u8* GetMaterialPointer() const { return x4_materialData; }
void SetMaterialPointer(const u8* mat) { x4_materialData = mat; }
[[nodiscard]] const std::vector<zeus::CVector3f>& GetVertexPointer() const { return *x8_positions; }
[[nodiscard]] const std::vector<zeus::CVector3f>& GetNormalPointer() const { return *xc_normals; }
[[nodiscard]] const std::vector<zeus::CColor>& GetColorPointer() const { return *x10_colors; }
[[nodiscard]] const std::vector<zeus::CVector2f>& GetTCPointer() const { return *x14_texCoords; }
[[nodiscard]] const std::vector<std::array<s16, 2>>& GetPackedTCPointer() const { return *x18_packedTexCoords; }
};
ModelInstance x0_modelInstance;
const std::vector<TCachedToken<CTexture>>* x1c_textures;
zeus::CAABox x20_worldAABB;
CCubeSurface* x38_firstUnsortedSurf = nullptr;
CCubeSurface* x3c_firstSortedSurf = nullptr;
bool x40_24_;
u8 x41_visorFlags;
u32 x44_idx;
public:
CCubeModel(const std::vector<CCubeSurface>* surfaces, const std::vector<TCachedToken<CTexture>>* textures,
const u8* materialData, const std::vector<zeus::CVector3f>* positions,
const std::vector<zeus::CVector3f>* floatNormals, const std::vector<std::array<s16, 3>>* shortNormals,
const std::vector<zeus::CColor>* vtxColors, const std::vector<zeus::CVector2f>* floatUvs,
const std::vector<std::array<s16, 2>>* shortUVs, const zeus::CAABox* aabox, u8 flags, bool b1, u32 w1) {}
CCubeModel(const std::vector<std::unique_ptr<CCubeSurface>>* surfaces,
const std::vector<TCachedToken<CTexture>>* textures, const u8* materialData,
const std::vector<zeus::CVector3f>* positions, const std::vector<zeus::CColor>* colors,
const std::vector<zeus::CVector3f>* normals, const std::vector<zeus::CVector2f>* texCoords,
const std::vector<std::array<s16, 2>>* packedTexCoords, const zeus::CAABox& aabox, u8 flags, bool b1,
u32 idx);
void UnlockTextures();
static void MakeTexturesFromMats(const u8* ptr, std::vector<TCachedToken<CTexture>>& texture, bool b1);
};
#pragma endregion
@ -83,29 +126,31 @@ public:
#pragma region CCubeSurface
class CCubeSurface {
static constexpr zeus::CVector3f skDefaultNormal{1.f, 0.f, 0.f};
public:
enum class ECookie {
};
zeus::CVector3f x0_center;
u32 xc_materialIndex;
u32 x10_displayListSize;
CCubeModel* x14_parent;
CCubeSurface* x18_nextSurface;
u32 x1c_extraSize;
zeus::CVector3f x20_normal;
zeus::CAABox x2c_bounds;
public:
CCubeSurface(u8* ptr);
bool IsValid() const;
static CCubeSurface* FromCookieValue(u32 value);
void GetCookie(ECookie cookie);
void SetCookie(ECookie cookie, u32 value);
u32 GetCookieValue() const;
s32 GetMaterialIndex() const;
s32 GetDisplayListSize() const;
u8* GetDisplayList() const;
u32 GetSurfaceHeaderSize() const;
zeus::CVector3f GetCenter() const;
u32 GetNormalHint() const;
zeus::CAABox GetBounds() const;
void SetParent(CCubeModel* parent) { x14_parent = parent; }
[[nodiscard]] u32 GetMaterialIndex() const { return xc_materialIndex; }
[[nodiscard]] u32 GetDisplayListSize() const { return x10_displayListSize & 0x7fffffff; }
[[nodiscard]] u32 GetNormalHint() const { return (x10_displayListSize >> 31) & 1; }
[[nodiscard]] u8* GetDisplayList() const;
// u32 GetSurfaceHeaderSize() const { }
[[nodiscard]] zeus::CVector3f GetCenter() const { return x0_center; }
[[nodiscard]] zeus::CAABox GetBounds() const {
return x1c_extraSize != 0 ? x2c_bounds : zeus::CAABox{x0_center, x0_center};
}
};
#pragma endregion
CFactoryFnReturn FModelFactory(const metaforce::SObjectTag& tag, std::unique_ptr<u8[]>&& in, u32 len,
const metaforce::CVParamTransfer& vparms, CObjectReference* selfRef);
} // namespace metaforce
} // namespace metaforce::WIP