Adjustments to "decomp" language

2025-10-25 01:14:19 +00:00 · 2023-11-28 09:00:57 -05:00
parent 3d48cdede1
commit 1ba3b7f0a7
394 changed files with 1946 additions and 1944 deletions
--- a/LEGO1/realtime/matrix.cpp
+++ b/LEGO1/realtime/matrix.cpp
@@ -10,61 +10,61 @@ DECOMP_SIZE_ASSERT(Matrix4, 0x40);
 DECOMP_SIZE_ASSERT(Matrix4Impl, 0x8);
 DECOMP_SIZE_ASSERT(Matrix4Data, 0x48);

-// OFFSET: LEGO1 0x10002320
+// FUNCTION: LEGO1 0x10002320
 void Matrix4Impl::EqualsMatrixData(const Matrix4& p_matrix)
 {
 	*m_data = p_matrix;
 }

-// OFFSET: LEGO1 0x10002340
+// FUNCTION: LEGO1 0x10002340
 void Matrix4Impl::EqualsMatrixImpl(const Matrix4Impl* p_other)
 {
 	*m_data = *p_other->m_data;
 }

-// OFFSET: LEGO1 0x10002360
+// FUNCTION: LEGO1 0x10002360
 void Matrix4Impl::AnotherSetData(Matrix4& p_data)
 {
 	m_data = &p_data;
 }

-// OFFSET: LEGO1 0x10002370
+// FUNCTION: LEGO1 0x10002370
 void Matrix4Impl::SetData(Matrix4& p_data)
 {
 	m_data = &p_data;
 }

-// OFFSET: LEGO1 0x10002380
+// FUNCTION: LEGO1 0x10002380
 const Matrix4* Matrix4Impl::GetData() const
 {
 	return m_data;
 }

-// OFFSET: LEGO1 0x10002390
+// FUNCTION: LEGO1 0x10002390
 Matrix4* Matrix4Impl::GetData()
 {
 	return m_data;
 }

-// OFFSET: LEGO1 0x100023a0
+// FUNCTION: LEGO1 0x100023a0
 const float* Matrix4Impl::Element(int p_row, int p_col) const
 {
 	return &(*m_data)[p_row][p_col];
 }

-// OFFSET: LEGO1 0x100023c0
+// FUNCTION: LEGO1 0x100023c0
 float* Matrix4Impl::Element(int p_row, int p_col)
 {
 	return &(*m_data)[p_row][p_col];
 }

-// OFFSET: LEGO1 0x100023e0
+// FUNCTION: LEGO1 0x100023e0
 void Matrix4Impl::Clear()
 {
 	memset(m_data, 0, 16 * sizeof(float));
 }

-// OFFSET: LEGO1 0x100023f0
+// FUNCTION: LEGO1 0x100023f0
 void Matrix4Impl::SetIdentity()
 {
 	Clear();
@@ -74,7 +74,7 @@ void Matrix4Impl::SetIdentity()
 	(*m_data)[3][3] = 1.0f;
 }

-// OFFSET: LEGO1 0x10002430
+// FUNCTION: LEGO1 0x10002430
 Matrix4Impl* Matrix4Impl::operator+=(const Matrix4& p_matrix)
 {
 	for (int i = 0; i < 16; ++i)
@@ -84,7 +84,7 @@ Matrix4Impl* Matrix4Impl::operator+=(const Matrix4& p_matrix)

 // Matches but instructions are significantly out of order. Probably not wrong
 // code given that the very similar SetTranslation does match.
-// OFFSET: LEGO1 0x10002460
+// FUNCTION: LEGO1 0x10002460
 void Matrix4Impl::TranslateBy(const float* p_x, const float* p_y, const float* p_z)
 {
 	((float*) m_data)[12] += *p_x;
@@ -92,7 +92,7 @@ void Matrix4Impl::TranslateBy(const float* p_x, const float* p_y, const float* p
 	((float*) m_data)[14] += *p_z;
 }

-// OFFSET: LEGO1 0x100024a0
+// FUNCTION: LEGO1 0x100024a0
 void Matrix4Impl::SetTranslation(const float* p_x, const float* p_y, const float* p_z)
 {
 	(*m_data)[3][0] = *p_x;
@@ -100,7 +100,7 @@ void Matrix4Impl::SetTranslation(const float* p_x, const float* p_y, const float
 	(*m_data)[3][2] = *p_z;
 }

-// OFFSET: LEGO1 0x100024d0
+// FUNCTION: LEGO1 0x100024d0
 void Matrix4Impl::EqualsDataProduct(const Matrix4& p_a, const Matrix4& p_b)
 {
 	float* cur = (float*) m_data;
@@ -115,7 +115,7 @@ void Matrix4Impl::EqualsDataProduct(const Matrix4& p_a, const Matrix4& p_b)
 	}
 }

-// OFFSET: LEGO1 0x10002530
+// FUNCTION: LEGO1 0x10002530
 void Matrix4Impl::EqualsMxProduct(const Matrix4Impl* p_a, const Matrix4Impl* p_b)
 {
 	EqualsDataProduct(*p_a->m_data, *p_b->m_data);
@@ -124,7 +124,7 @@ void Matrix4Impl::EqualsMxProduct(const Matrix4Impl* p_a, const Matrix4Impl* p_b
 // Not close, Ghidra struggles understinging this method so it will have to
 // be manually worked out. Included since I at least figured out what it was
 // doing with rotateIndex and what overall operation it's trying to do.
-// OFFSET: LEGO1 0x10002550 STUB
+// FUNCTION: LEGO1 0x10002550 STUB
 void Matrix4Impl::ToQuaternion(Vector4Impl* p_outQuat)
 {
 	/*
@@ -167,19 +167,19 @@ void Matrix4Impl::ToQuaternion(Vector4Impl* p_outQuat)

 // No idea what this function is doing and it will be hard to tell until
 // we have a confirmed usage site.
-// OFFSET: LEGO1 0x10002710 STUB
+// FUNCTION: LEGO1 0x10002710 STUB
 int Matrix4Impl::FUN_10002710(const Vector3Impl* p_vec)
 {
 	return -1;
 }

-// OFFSET: LEGO1 0x10002850
+// FUNCTION: LEGO1 0x10002850
 void Matrix4Impl::operator=(const Matrix4Impl& p_other)
 {
 	EqualsMatrixImpl(&p_other);
 }

-// OFFSET: LEGO1 0x10002860
+// FUNCTION: LEGO1 0x10002860
 void Matrix4Data::operator=(const Matrix4Data& p_other)
 {
 	EqualsMatrixImpl(&p_other);
--- a/LEGO1/realtime/matrix.h
+++ b/LEGO1/realtime/matrix.h
@@ -31,7 +31,7 @@ public:
 	float* operator[](long i) { return rows[i]; }
 };

-// VTABLE 0x100d4350
+// VTABLE: LEGO1 0x100d4350
 // SIZE 0x8
 class Matrix4Impl {
 public:
@@ -72,7 +72,7 @@ protected:
 	Matrix4* m_data;
 };

-// VTABLE 0x100d4300
+// VTABLE: LEGO1 0x100d4300
 // SIZE 0x48
 class Matrix4Data : public Matrix4Impl {
 public:
--- a/LEGO1/realtime/orientableroi.cpp
+++ b/LEGO1/realtime/orientableroi.cpp
@@ -4,14 +4,14 @@

 DECOMP_SIZE_ASSERT(OrientableROI, 0xdc)

-// OFFSET: LEGO1 0x100a5910
+// FUNCTION: LEGO1 0x100a5910
 void OrientableROI::VTable0x1c()
 {
 	UpdateWorldBoundingVolumes();
 	UpdateWorldVelocity();
 }

-// OFFSET: LEGO1 0x100a5930
+// FUNCTION: LEGO1 0x100a5930
 void OrientableROI::SetLocalTransform(const Matrix4Impl& p_transform)
 {
 	reinterpret_cast<Matrix4Impl&>(m_local2world) = p_transform;
@@ -19,7 +19,7 @@ void OrientableROI::SetLocalTransform(const Matrix4Impl& p_transform)
 	UpdateWorldVelocity();
 }

-// OFFSET: LEGO1 0x100a5960
+// FUNCTION: LEGO1 0x100a5960
 void OrientableROI::VTable0x24(const Matrix4Data& p_transform)
 {
 	Matrix4Data l_matrix(m_local2world);
@@ -28,7 +28,7 @@ void OrientableROI::VTable0x24(const Matrix4Data& p_transform)
 	UpdateWorldVelocity();
 }

-// OFFSET: LEGO1 0x100a59b0
+// FUNCTION: LEGO1 0x100a59b0
 void OrientableROI::UpdateWorldData(const Matrix4Data& p_transform)
 {
 	Matrix4Data l_matrix(m_local2world);
@@ -44,24 +44,24 @@ void OrientableROI::UpdateWorldData(const Matrix4Data& p_transform)
 		}
 }

-// OFFSET: LEGO1 0x100a5a50
+// FUNCTION: LEGO1 0x100a5a50
 void OrientableROI::UpdateWorldVelocity()
 {
 }

-// OFFSET: LEGO1 0x100a5d80
+// FUNCTION: LEGO1 0x100a5d80
 const Vector3& OrientableROI::GetWorldVelocity() const
 {
 	return (Vector3&) *m_world_velocity.GetData();
 }

-// OFFSET: LEGO1 0x100a5d90
+// FUNCTION: LEGO1 0x100a5d90
 const BoundingBox& OrientableROI::GetWorldBoundingBox() const
 {
 	return m_world_bounding_box;
 }

-// OFFSET: LEGO1 0x100a5da0
+// FUNCTION: LEGO1 0x100a5da0
 const BoundingSphere& OrientableROI::GetWorldBoundingSphere() const
 {
 	return m_world_bounding_sphere;
--- a/LEGO1/realtime/orientableroi.h
+++ b/LEGO1/realtime/orientableroi.h
@@ -6,7 +6,7 @@

 class OrientableROI : public ROI {
 public:
-	// OFFSET: LEGO1 0x100a4420
+	// FUNCTION: LEGO1 0x100a4420
 	OrientableROI()
 	{
 		FILLVEC3(m_world_bounding_box.Min(), 888888.8);
@@ -16,7 +16,7 @@ public:
 		ZEROVEC3(m_world_velocity);
 		IDENTMAT4(m_local2world.GetMatrix());
 	}
-	// OFFSET: LEGO1 0x100a4630 TEMPLATE
+	// FUNCTION: LEGO1 0x100a4630 SYNTHETIC
 	// OrientableROI::`scalar deleting destructor'

 	virtual const Vector3& GetWorldVelocity() const;
--- a/LEGO1/realtime/realtime.cpp
+++ b/LEGO1/realtime/realtime.cpp
@@ -1,6 +1,6 @@
 #include "realtime.h"

-// OFFSET: LEGO1 0x100a5b40
+// FUNCTION: LEGO1 0x100a5b40
 void CalcLocalTransform(
 	const Vector3Impl& p_posVec,
 	const Vector3Impl& p_dirVec,
--- a/LEGO1/realtime/realtimeview.cpp
+++ b/LEGO1/realtime/realtimeview.cpp
@@ -14,33 +14,33 @@ float g_userMaxLod = 3.6f;
 // 0x1010104c
 float g_partsThreshold = 1000.0f;

-// OFFSET: LEGO1 0x100a5de0
+// FUNCTION: LEGO1 0x100a5de0
 void RealtimeView::SetUserMaxLOD(float p_lod)
 {
 	g_userMaxLod = p_lod;
 	UpdateMaxLOD();
 }

-// OFFSET: LEGO1 0x100a5df0
+// FUNCTION: LEGO1 0x100a5df0
 void RealtimeView::SetPartsThreshold(float p_threshold)
 {
 	g_partsThreshold = p_threshold;
 }

-// OFFSET: LEGO1 0x100a5e00
+// FUNCTION: LEGO1 0x100a5e00
 float RealtimeView::GetUserMaxLOD()
 {
 	// TODO
 	return 0;
 }

-// OFFSET: LEGO1 0x100a5e10
+// FUNCTION: LEGO1 0x100a5e10
 float RealtimeView::GetPartsThreshold()
 {
 	return g_partsThreshold;
 }

-// OFFSET: LEGO1 0x100a5e20
+// FUNCTION: LEGO1 0x100a5e20
 void RealtimeView::UpdateMaxLOD()
 {
 	g_userMaxLodPower = pow(g_userMaxBase, -g_userMaxLod);
--- a/LEGO1/realtime/vector.cpp
+++ b/LEGO1/realtime/vector.cpp
@@ -12,58 +12,58 @@ DECOMP_SIZE_ASSERT(Vector4Impl, 0x8);
 DECOMP_SIZE_ASSERT(Vector3Data, 0x14);
 DECOMP_SIZE_ASSERT(Vector4Data, 0x18);

-// OFFSET: LEGO1 0x10001f80
+// FUNCTION: LEGO1 0x10001f80
 void Vector2Impl::AddVectorImpl(float* p_value)
 {
 	m_data[0] += p_value[0];
 	m_data[1] += p_value[1];
 }

-// OFFSET: LEGO1 0x10001fa0
+// FUNCTION: LEGO1 0x10001fa0
 void Vector2Impl::AddScalarImpl(float p_value)
 {
 	m_data[0] += p_value;
 	m_data[1] += p_value;
 }

-// OFFSET: LEGO1 0x10001fc0
+// FUNCTION: LEGO1 0x10001fc0
 void Vector2Impl::SubVectorImpl(float* p_value)
 {
 	m_data[0] -= p_value[0];
 	m_data[1] -= p_value[1];
 }

-// OFFSET: LEGO1 0x10001fe0
+// FUNCTION: LEGO1 0x10001fe0
 void Vector2Impl::MullVectorImpl(float* p_value)
 {
 	m_data[0] *= p_value[0];
 	m_data[1] *= p_value[1];
 }

-// OFFSET: LEGO1 0x10002000
+// FUNCTION: LEGO1 0x10002000
 void Vector2Impl::MullScalarImpl(float* p_value)
 {
 	m_data[0] *= *p_value;
 	m_data[1] *= *p_value;
 }

-// OFFSET: LEGO1 0x10002020
+// FUNCTION: LEGO1 0x10002020
 void Vector2Impl::DivScalarImpl(float* p_value)
 {
 	m_data[0] /= *p_value;
 	m_data[1] /= *p_value;
 }

-// OFFSET: LEGO1 0x10002040
+// FUNCTION: LEGO1 0x10002040
 float Vector2Impl::DotImpl(float* p_a, float* p_b) const
 {
 	return p_b[0] * p_a[0] + p_b[1] * p_a[1];
 }

-// OFFSET: LEGO1 0x10002060 TEMPLATE
+// FUNCTION: LEGO1 0x10002060 SYNTHETIC
 // Vector2Impl::SetData

-// OFFSET: LEGO1 0x10002070
+// FUNCTION: LEGO1 0x10002070
 void Vector2Impl::EqualsImpl(float* p_data)
 {
 	float* vec = m_data;
@@ -71,19 +71,19 @@ void Vector2Impl::EqualsImpl(float* p_data)
 	vec[1] = p_data[1];
 }

-// OFFSET: LEGO1 0x10002090
+// FUNCTION: LEGO1 0x10002090
 float* Vector2Impl::GetData()
 {
 	return m_data;
 }

-// OFFSET: LEGO1 0x100020a0
+// FUNCTION: LEGO1 0x100020a0
 const float* Vector2Impl::GetData() const
 {
 	return m_data;
 }

-// OFFSET: LEGO1 0x100020b0
+// FUNCTION: LEGO1 0x100020b0
 void Vector2Impl::Clear()
 {
 	float* vec = m_data;
@@ -91,37 +91,37 @@ void Vector2Impl::Clear()
 	vec[1] = 0.0f;
 }

-// OFFSET: LEGO1 0x100020d0
+// FUNCTION: LEGO1 0x100020d0
 float Vector2Impl::Dot(float* p_a, float* p_b) const
 {
 	return DotImpl(p_a, p_b);
 }

-// OFFSET: LEGO1 0x100020f0
+// FUNCTION: LEGO1 0x100020f0
 float Vector2Impl::Dot(Vector2Impl* p_a, Vector2Impl* p_b) const
 {
 	return DotImpl(p_a->m_data, p_b->m_data);
 }

-// OFFSET: LEGO1 0x10002110
+// FUNCTION: LEGO1 0x10002110
 float Vector2Impl::Dot(float* p_a, Vector2Impl* p_b) const
 {
 	return DotImpl(p_a, p_b->m_data);
 }

-// OFFSET: LEGO1 0x10002130
+// FUNCTION: LEGO1 0x10002130
 float Vector2Impl::Dot(Vector2Impl* p_a, float* p_b) const
 {
 	return DotImpl(p_a->m_data, p_b);
 }

-// OFFSET: LEGO1 0x10002150
+// FUNCTION: LEGO1 0x10002150
 float Vector2Impl::LenSquared() const
 {
 	return m_data[0] * m_data[0] + m_data[1] * m_data[1];
 }

-// OFFSET: LEGO1 0x10002160
+// FUNCTION: LEGO1 0x10002160
 int Vector2Impl::Unitize()
 {
 	float sq = LenSquared();
@@ -135,73 +135,73 @@ int Vector2Impl::Unitize()
 	return -1;
 }

-// OFFSET: LEGO1 0x100021c0
+// FUNCTION: LEGO1 0x100021c0
 void Vector2Impl::AddScalar(float p_value)
 {
 	AddScalarImpl(p_value);
 }

-// OFFSET: LEGO1 0x100021d0
+// FUNCTION: LEGO1 0x100021d0
 void Vector2Impl::AddVector(float* p_other)
 {
 	AddVectorImpl(p_other);
 }

-// OFFSET: LEGO1 0x100021e0
+// FUNCTION: LEGO1 0x100021e0
 void Vector2Impl::AddVector(Vector2Impl* p_other)
 {
 	AddVectorImpl(p_other->m_data);
 }

-// OFFSET: LEGO1 0x100021f0
+// FUNCTION: LEGO1 0x100021f0
 void Vector2Impl::SubVector(float* p_other)
 {
 	SubVectorImpl(p_other);
 }

-// OFFSET: LEGO1 0x10002200
+// FUNCTION: LEGO1 0x10002200
 void Vector2Impl::SubVector(Vector2Impl* p_other)
 {
 	SubVectorImpl(p_other->m_data);
 }

-// OFFSET: LEGO1 0x10002210
+// FUNCTION: LEGO1 0x10002210
 void Vector2Impl::MullVector(float* p_other)
 {
 	MullVectorImpl(p_other);
 }

-// OFFSET: LEGO1 0x10002220
+// FUNCTION: LEGO1 0x10002220
 void Vector2Impl::MullVector(Vector2Impl* p_other)
 {
 	MullVectorImpl(p_other->m_data);
 }

-// OFFSET: LEGO1 0x10002230
+// FUNCTION: LEGO1 0x10002230
 void Vector2Impl::MullScalar(float* p_value)
 {
 	MullScalarImpl(p_value);
 }

-// OFFSET: LEGO1 0x10002240
+// FUNCTION: LEGO1 0x10002240
 void Vector2Impl::DivScalar(float* p_value)
 {
 	DivScalarImpl(p_value);
 }

-// OFFSET: LEGO1 0x10002250
+// FUNCTION: LEGO1 0x10002250
 void Vector2Impl::SetVector(float* p_other)
 {
 	EqualsImpl(p_other);
 }

-// OFFSET: LEGO1 0x10002260
+// FUNCTION: LEGO1 0x10002260
 void Vector2Impl::SetVector(Vector2Impl* p_other)
 {
 	EqualsImpl(p_other->m_data);
 }

-// OFFSET: LEGO1 0x10002270
+// FUNCTION: LEGO1 0x10002270
 void Vector3Impl::EqualsCrossImpl(float* p_a, float* p_b)
 {
 	m_data[0] = p_a[1] * p_b[2] - p_a[2] * p_b[1];
@@ -209,25 +209,25 @@ void Vector3Impl::EqualsCrossImpl(float* p_a, float* p_b)
 	m_data[2] = p_a[0] * p_b[1] - p_a[1] * p_b[0];
 }

-// OFFSET: LEGO1 0x100022c0
+// FUNCTION: LEGO1 0x100022c0
 void Vector3Impl::EqualsCross(Vector3Impl* p_a, Vector3Impl* p_b)
 {
 	EqualsCrossImpl(p_a->m_data, p_b->m_data);
 }

-// OFFSET: LEGO1 0x100022e0
+// FUNCTION: LEGO1 0x100022e0
 void Vector3Impl::EqualsCross(Vector3Impl* p_a, float* p_b)
 {
 	EqualsCrossImpl(p_a->m_data, p_b);
 }

-// OFFSET: LEGO1 0x10002300
+// FUNCTION: LEGO1 0x10002300
 void Vector3Impl::EqualsCross(float* p_a, Vector3Impl* p_b)
 {
 	EqualsCrossImpl(p_a, p_b->m_data);
 }

-// OFFSET: LEGO1 0x10002870
+// FUNCTION: LEGO1 0x10002870
 void Vector4Impl::AddVectorImpl(float* p_value)
 {
 	m_data[0] += p_value[0];
@@ -236,7 +236,7 @@ void Vector4Impl::AddVectorImpl(float* p_value)
 	m_data[3] += p_value[3];
 }

-// OFFSET: LEGO1 0x100028b0
+// FUNCTION: LEGO1 0x100028b0
 void Vector4Impl::AddScalarImpl(float p_value)
 {
 	m_data[0] += p_value;
@@ -245,7 +245,7 @@ void Vector4Impl::AddScalarImpl(float p_value)
 	m_data[3] += p_value;
 }

-// OFFSET: LEGO1 0x100028f0
+// FUNCTION: LEGO1 0x100028f0
 void Vector4Impl::SubVectorImpl(float* p_value)
 {
 	m_data[0] -= p_value[0];
@@ -254,7 +254,7 @@ void Vector4Impl::SubVectorImpl(float* p_value)
 	m_data[3] -= p_value[3];
 }

-// OFFSET: LEGO1 0x10002930
+// FUNCTION: LEGO1 0x10002930
 void Vector4Impl::MullVectorImpl(float* p_value)
 {
 	m_data[0] *= p_value[0];
@@ -263,7 +263,7 @@ void Vector4Impl::MullVectorImpl(float* p_value)
 	m_data[3] *= p_value[3];
 }

-// OFFSET: LEGO1 0x10002970
+// FUNCTION: LEGO1 0x10002970
 void Vector4Impl::MullScalarImpl(float* p_value)
 {
 	m_data[0] *= *p_value;
@@ -272,7 +272,7 @@ void Vector4Impl::MullScalarImpl(float* p_value)
 	m_data[3] *= *p_value;
 }

-// OFFSET: LEGO1 0x100029b0
+// FUNCTION: LEGO1 0x100029b0
 void Vector4Impl::DivScalarImpl(float* p_value)
 {
 	m_data[0] /= *p_value;
@@ -281,13 +281,13 @@ void Vector4Impl::DivScalarImpl(float* p_value)
 	m_data[3] /= *p_value;
 }

-// OFFSET: LEGO1 0x100029f0
+// FUNCTION: LEGO1 0x100029f0
 float Vector4Impl::DotImpl(float* p_a, float* p_b) const
 {
 	return p_a[0] * p_b[0] + p_a[2] * p_b[2] + (p_a[1] * p_b[1] + p_a[3] * p_b[3]);
 }

-// OFFSET: LEGO1 0x10002a20
+// FUNCTION: LEGO1 0x10002a20
 void Vector4Impl::EqualsImpl(float* p_data)
 {
 	float* vec = m_data;
@@ -297,7 +297,7 @@ void Vector4Impl::EqualsImpl(float* p_data)
 	vec[3] = p_data[3];
 }

-// OFFSET: LEGO1 0x10002a40
+// FUNCTION: LEGO1 0x10002a40
 void Vector4Impl::SetMatrixProductImpl(float* p_vec, float* p_mat)
 {
 	m_data[0] = p_vec[0] * p_mat[0] + p_vec[1] * p_mat[4] + p_vec[2] * p_mat[8] + p_vec[3] * p_mat[12];
@@ -306,13 +306,13 @@ void Vector4Impl::SetMatrixProductImpl(float* p_vec, float* p_mat)
 	m_data[3] = p_vec[0] * p_mat[3] + p_vec[1] * p_mat[7] + p_vec[2] * p_mat[11] + p_vec[4] * p_mat[15];
 }

-// OFFSET: LEGO1 0x10002ae0
+// FUNCTION: LEGO1 0x10002ae0
 void Vector4Impl::SetMatrixProduct(Vector4Impl* p_a, float* p_b)
 {
 	SetMatrixProductImpl(p_a->m_data, p_b);
 }

-// OFFSET: LEGO1 0x10002b00
+// FUNCTION: LEGO1 0x10002b00
 void Vector4Impl::Clear()
 {
 	float* vec = m_data;
@@ -322,13 +322,13 @@ void Vector4Impl::Clear()
 	vec[3] = 0.0f;
 }

-// OFFSET: LEGO1 0x10002b20
+// FUNCTION: LEGO1 0x10002b20
 float Vector4Impl::LenSquared() const
 {
 	return m_data[1] * m_data[1] + m_data[0] * m_data[0] + m_data[2] * m_data[2] + m_data[3] * m_data[3];
 }

-// OFFSET: LEGO1 0x10002b40
+// FUNCTION: LEGO1 0x10002b40
 void Vector4Impl::EqualsScalar(float* p_value)
 {
 	m_data[0] = *p_value;
@@ -339,7 +339,7 @@ void Vector4Impl::EqualsScalar(float* p_value)

 // Note close yet, included because I'm at least confident I know what operation
 // it's trying to do.
-// OFFSET: LEGO1 0x10002b70 STUB
+// FUNCTION: LEGO1 0x10002b70 STUB
 int Vector4Impl::NormalizeQuaternion()
 {
 	float* v = m_data;
@@ -357,7 +357,7 @@ int Vector4Impl::NormalizeQuaternion()
 	return -1;
 }

-// OFFSET: LEGO1 0x10002bf0
+// FUNCTION: LEGO1 0x10002bf0
 void Vector4Impl::UnknownQuaternionOp(Vector4Impl* p_a, Vector4Impl* p_b)
 {
 	float* bDat = p_b->m_data;
@@ -373,7 +373,7 @@ void Vector4Impl::UnknownQuaternionOp(Vector4Impl* p_a, Vector4Impl* p_b)
 	m_data[2] = p_b->m_data[2] * p_a->m_data[3] + p_a->m_data[2] * p_b->m_data[3] + m_data[2];
 }

-// OFFSET: LEGO1 0x10003a60
+// FUNCTION: LEGO1 0x10003a60
 void Vector3Impl::AddVectorImpl(float* p_value)
 {
 	m_data[0] += p_value[0];
@@ -381,7 +381,7 @@ void Vector3Impl::AddVectorImpl(float* p_value)
 	m_data[2] += p_value[2];
 }

-// OFFSET: LEGO1 0x10003a90
+// FUNCTION: LEGO1 0x10003a90
 void Vector3Impl::AddScalarImpl(float p_value)
 {
 	m_data[0] += p_value;
@@ -389,7 +389,7 @@ void Vector3Impl::AddScalarImpl(float p_value)
 	m_data[2] += p_value;
 }

-// OFFSET: LEGO1 0x10003ac0
+// FUNCTION: LEGO1 0x10003ac0
 void Vector3Impl::SubVectorImpl(float* p_value)
 {
 	m_data[0] -= p_value[0];
@@ -397,7 +397,7 @@ void Vector3Impl::SubVectorImpl(float* p_value)
 	m_data[2] -= p_value[2];
 }

-// OFFSET: LEGO1 0x10003af0
+// FUNCTION: LEGO1 0x10003af0
 void Vector3Impl::MullVectorImpl(float* p_value)
 {
 	m_data[0] *= p_value[0];
@@ -405,7 +405,7 @@ void Vector3Impl::MullVectorImpl(float* p_value)
 	m_data[2] *= p_value[2];
 }

-// OFFSET: LEGO1 0x10003b20
+// FUNCTION: LEGO1 0x10003b20
 void Vector3Impl::MullScalarImpl(float* p_value)
 {
 	m_data[0] *= *p_value;
@@ -413,7 +413,7 @@ void Vector3Impl::MullScalarImpl(float* p_value)
 	m_data[2] *= *p_value;
 }

-// OFFSET: LEGO1 0x10003b50
+// FUNCTION: LEGO1 0x10003b50
 void Vector3Impl::DivScalarImpl(float* p_value)
 {
 	m_data[0] /= *p_value;
@@ -421,13 +421,13 @@ void Vector3Impl::DivScalarImpl(float* p_value)
 	m_data[2] /= *p_value;
 }

-// OFFSET: LEGO1 0x10003b80
+// FUNCTION: LEGO1 0x10003b80
 float Vector3Impl::DotImpl(float* p_a, float* p_b) const
 {
 	return p_a[0] * p_b[0] + p_a[2] * p_b[2] + p_a[1] * p_b[1];
 }

-// OFFSET: LEGO1 0x10003ba0
+// FUNCTION: LEGO1 0x10003ba0
 void Vector3Impl::EqualsImpl(float* p_data)
 {
 	float* vec = m_data;
@@ -436,7 +436,7 @@ void Vector3Impl::EqualsImpl(float* p_data)
 	vec[2] = p_data[2];
 }

-// OFFSET: LEGO1 0x10003bc0
+// FUNCTION: LEGO1 0x10003bc0
 void Vector3Impl::Clear()
 {
 	float* vec = m_data;
@@ -445,13 +445,13 @@ void Vector3Impl::Clear()
 	vec[2] = 0.0f;
 }

-// OFFSET: LEGO1 0x10003bd0
+// FUNCTION: LEGO1 0x10003bd0
 float Vector3Impl::LenSquared() const
 {
 	return m_data[1] * m_data[1] + m_data[0] * m_data[0] + m_data[2] * m_data[2];
 }

-// OFFSET: LEGO1 0x10003bf0
+// FUNCTION: LEGO1 0x10003bf0
 void Vector3Impl::EqualsScalar(float* p_value)
 {
 	m_data[0] = *p_value;
--- a/LEGO1/realtime/vector.h
+++ b/LEGO1/realtime/vector.h
@@ -4,7 +4,7 @@
 #include <vec.h>

 // TODO: Find proper compilation unit to put this
-// OFFSET: LEGO1 0x1000c0f0 TEMPLATE
+// FUNCTION: LEGO1 0x1000c0f0 SYNTHETIC
 // Vector2Impl::Vector2Impl

 /*
@@ -60,7 +60,7 @@ public:
 	float& operator[](long i) { return elements[i]; }
 };

-// VTABLE 0x100d4288
+// VTABLE: LEGO1 0x100d4288
 // SIZE 0x8
 class Vector2Impl {
 public:
@@ -120,7 +120,7 @@ protected:
 	float* m_data;
 };

-// VTABLE 0x100d4518
+// VTABLE: LEGO1 0x100d4518
 // SIZE 0x8
 class Vector3Impl : public Vector2Impl {
 public:
@@ -152,7 +152,7 @@ public:
 	inline void Fill(float p_value) { EqualsScalar(&p_value); }
 };

-// VTABLE 0x100d45a0
+// VTABLE: LEGO1 0x100d45a0
 // SIZE 0x8
 class Vector4Impl : public Vector3Impl {
 public:
@@ -183,7 +183,7 @@ public:
 	virtual void UnknownQuaternionOp(Vector4Impl* p_a, Vector4Impl* p_b);
 };

-// VTABLE 0x100d4488
+// VTABLE: LEGO1 0x100d4488
 // SIZE 0x14
 class Vector3Data : public Vector3Impl {
 public:
@@ -204,7 +204,7 @@ private:
 	Vector3 m_vector;
 };

-// VTABLE 0x100d41e8
+// VTABLE: LEGO1 0x100d41e8
 // SIZE 0x18
 class Vector4Data : public Vector4Impl {
 public: