Files
wowdecomp/Engine/Source/Tempest/C44Matrix.cpp
T
SatyandClaude Opus 5.5 6a3666e4b6 Port run-83 hit stand-ins and fix phantom terrain walls blocking movement
- Fix CMap::GetChunkFacets: impassable test uses the chunk MapObjFlag
  (MAPOBJ_FLAG_IMPASSABLE at +0xC) like 12340, not MCNK header flag 0x40
  (vertex colours). Most chunks got 32000-high wall facets, so the player
  could jump but not walk.
- Ship paths: GetPosition, path time, accel/decel distance, roll/pitch.
- Transports: Transport::UpdateMovement, CollideWithTransport, owner matrix.
- Map objects: IsAllLoaded, footprints, TriData query chain (QueryTris,
  GetTrisTerrain/Chunk, GetTriSubchunk, QueryTrisMapObjDefs),
  QueryIntersectingModels.
- Water ripples, projected-texture shadow drawing (shadow.cpp).
- World states, LFG best random dungeon, quest POI, ComSat session lookup,
  blood record, virtual items, guild roster query.
- Logout path: tradeskill close, LCD, DBCache_ClearPending, chat/macro/
  saved-variable/account-data saving, tracked quests/achievements/
  tutorials, UnloadAddOns, SaveAddOnEnableState, ~CGWorldFrame,
  SmartScreenRectShutdown.
- Fixes: TriData batch heights stored as float* (was truncating uint32 on
  x64), TimeInRange is a ShipPath member, ComSat lookup takes the session
  type, roll/pitch names swapped in MapObjTransport::UpdateMovement,
  removed windows.h from Object/Passenger.h.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-10-01 15:33:24 +02:00

719 lines
20 KiB
C++

#include <cmath>
#include "Engine/Source/Tempest/C33Matrix.h"
#include "Engine/Source/Tempest/C34Matrix.h"
#include "Engine/Source/Tempest/C44Matrix.h"
#include "Engine/Source/Tempest/C4Quaternion.h"
// VERIFY: cbb36d4b auto
// OFFSET: 0x004E26F0
C44Matrix::C44Matrix(float scale) {
this->a0 = scale;
this->a1 = 0.0f;
this->a2 = 0.0f;
this->a3 = 0.0f;
this->b0 = 0.0f;
this->b1 = scale;
this->b2 = 0.0f;
this->b3 = 0.0f;
this->c0 = 0.0f;
this->c1 = 0.0f;
this->c2 = scale;
this->c3 = 0.0f;
this->d0 = 0.0f;
this->d1 = 0.0f;
this->d2 = 0.0f;
this->d3 = 1.0f;
}
// INLINED
C44Matrix::C44Matrix(float a0, float a1, float a2, float a3, float b0, float b1, float b2, float b3, float c0, float c1, float c2, float c3, float d0, float d1, float d2, float d3) {
this->a0 = a0;
this->a1 = a1;
this->a2 = a2;
this->a3 = a3;
this->b0 = b0;
this->b1 = b1;
this->b2 = b2;
this->b3 = b3;
this->c0 = c0;
this->c1 = c1;
this->c2 = c2;
this->c3 = c3;
this->d0 = d0;
this->d1 = d1;
this->d2 = d2;
this->d3 = d3;
}
// VERIFY: bcc62f69 auto
// OFFSET: 0x0057C2A0
void C44Matrix::Identity() {
this->d3 = 1.0f;
this->c2 = 1.0f;
this->b1 = 1.0f;
this->a0 = 1.0f;
this->d2 = 0.0f;
this->d1 = 0.0f;
this->d0 = 0.0f;
this->c3 = 0.0f;
this->c1 = 0.0f;
this->c0 = 0.0f;
this->b3 = 0.0f;
this->b2 = 0.0f;
this->b0 = 0.0f;
this->a3 = 0.0f;
this->a2 = 0.0f;
this->a1 = 0.0f;
}
// VERIFY: b9812d24 manual
// OFFSET: 0x00407F40
C44Matrix::C44Matrix() {
this->a0 = 1.0f;
this->a1 = 0.0f;
this->a2 = 0.0f;
this->a3 = 0.0f;
this->b0 = 0.0f;
this->b2 = 0.0f;
this->b3 = 0.0f;
this->c0 = 0.0f;
this->c1 = 0.0f;
this->c3 = 0.0f;
this->d0 = 0.0f;
this->d1 = 0.0f;
this->d2 = 0.0f;
this->b1 = 1.0f;
this->c2 = 1.0f;
this->d3 = 1.0f;
}
// VERIFY: d44fd3fc manual
// OFFSET: 0x00407F80
C44Matrix& C44Matrix::operator=(const C44Matrix& m) {
this->a0 = m.a0;
this->a1 = m.a1;
this->a2 = m.a2;
this->a3 = m.a3;
this->b0 = m.b0;
this->b1 = m.b1;
this->b2 = m.b2;
this->b3 = m.b3;
this->c0 = m.c0;
this->c1 = m.c1;
this->c2 = m.c2;
this->c3 = m.c3;
this->d0 = m.d0;
this->d1 = m.d1;
this->d2 = m.d2;
this->d3 = m.d3;
return *this;
}
// VERIFY: 0d73c48d manual
// OFFSET: 0x004C1830
bool operator!=(const C44Matrix& l, const C44Matrix& r) {
return r.a0 != l.a0 || r.a1 != l.a1 || r.a2 != l.a2 || r.a3 != l.a3 || r.b0 != l.b0 || r.b1 != l.b1 || r.b2 != l.b2 || r.b3 != l.b3 || r.c0 != l.c0 || r.c1 != l.c1 || r.c2 != l.c2 || r.c3 != l.c3 || r.d0 != l.d0 || r.d1 != l.d1 || r.d2 != l.d2 || r.d3 != l.d3;
}
// VERIFY: 32c45e98 auto
// OFFSET: 0x004C1930
float C44Matrix::Determinant() const {
float b0 = this->b0;
float b1 = this->b1;
float b2 = this->b2;
float b3 = this->b3;
float c0 = this->c0;
float c1 = this->c1;
float c2 = this->c2;
float c3 = this->c3;
float d0 = this->d0;
float d1 = this->d1;
float d2 = this->d2;
float d3 = this->d3;
float result = (b1 * c2 * d3 + c3 * b2 * d1 + b3 * c1 * d2 - c2 * b3 * d1 - d3 * (c1 * b2) - b1 * c3 * d2) * this->a0
- (c2 * b0 * d3 + c3 * b2 * d0 + b3 * c0 * d2 - b3 * c2 * d0 - d3 * (c0 * b2) - b0 * c3 * d2) * this->a1
+ (c1 * b0 * d3 + c3 * b1 * d0 + b3 * c0 * d1 - b3 * c1 * d0 - d3 * (c0 * b1) - b0 * c3 * d1) * this->a2;
return result - (c1 * b0 * d2 + c2 * b1 * d0 + b2 * c0 * d1 - b2 * c1 * d0 - d2 * (c0 * b1) - b0 * c2 * d1) * this->a3;
}
// VERIFY: 52341b0c auto
// OFFSET: 0x004C1B30
void C44Matrix::Translate(const C3Vector& move) {
this->d0 = this->c0 * move.z + this->b0 * move.y + move.x * this->a0 + this->d0;
this->d1 = this->c1 * move.z + this->b1 * move.y + this->a1 * move.x + this->d1;
this->d2 = this->c2 * move.z + this->b2 * move.y + this->a2 * move.x + this->d2;
}
// VERIFY: 29a51461 auto
// OFFSET: 0x004C1B90
void C44Matrix::Scale(const C3Vector& scale) {
this->a0 = scale.x * this->a0;
this->a1 = this->a1 * scale.x;
this->a2 = this->a2 * scale.x;
this->b0 = this->b0 * scale.y;
this->b1 = scale.y * this->b1;
this->b2 = scale.y * this->b2;
this->c0 = scale.z * this->c0;
this->c1 = this->c1 * scale.z;
this->c2 = this->c2 * scale.z;
}
// VERIFY: 3c164388 auto
// OFFSET: 0x004C1BF0
void C44Matrix::Scale(float scale) {
this->a0 = this->a0 * scale;
this->a1 = this->a1 * scale;
this->a2 = this->a2 * scale;
this->b0 = this->b0 * scale;
this->b1 = this->b1 * scale;
this->b2 = this->b2 * scale;
this->c0 = this->c0 * scale;
this->c1 = this->c1 * scale;
this->c2 = scale * this->c2;
}
// VERIFY: e67f98ba auto
// OFFSET: 0x004C1C40
void C44Matrix::FromQuaternion(const C4Quaternion& q, C44Matrix& m) {
float x2 = q.x * 2.0f;
float y2 = q.y * 2.0f;
float z2 = 2.0f * q.z;
float wx = q.w * x2;
float wy = q.w * y2;
float wz = q.w * z2;
float xx = x2 * q.x;
float xy = q.x * y2;
float xz = q.x * z2;
float yy = y2 * q.y;
float yz = q.y * z2;
float zz = z2 * q.z;
m.a0 = 1.0f - (zz + yy);
m.a1 = xy + wz;
m.a2 = xz - wy;
m.b0 = xy - wz;
m.b1 = 1.0f - (zz + xx);
m.b2 = yz + wx;
m.c0 = wy + xz;
m.c1 = yz - wx;
m.c2 = 1.0f - (xx + yy);
}
// VERIFY: 9230ed60 manual
// OFFSET: 0x004C1D80
C44Matrix::C44Matrix(const C33Matrix& m) {
this->a0 = m.a0;
this->a1 = m.a1;
this->a2 = m.a2;
this->a3 = 0.0f;
this->b0 = m.b0;
this->b1 = m.b1;
this->b2 = m.b2;
this->b3 = 0.0f;
this->c0 = m.c0;
this->c1 = m.c1;
this->c2 = m.c2;
this->c3 = 0.0f;
this->d0 = 0.0f;
this->d1 = 0.0f;
this->d2 = 0.0f;
this->d3 = 1.0f;
}
// VERIFY: 639b5ec2 manual
// OFFSET: 0x004C1DE0
C44Matrix::C44Matrix(const C4Quaternion& q) {
this->a3 = 0.0f;
this->b3 = 0.0f;
this->c3 = 0.0f;
this->d0 = 0.0f;
this->d1 = 0.0f;
this->d2 = 0.0f;
this->d3 = 1.0f;
FromQuaternion(q, *this);
}
// VERIFY: 16753655 manual
// OFFSET: 0x004C1E60
C44Matrix operator+(const C44Matrix& l, const C44Matrix& r) {
C44Matrix result;
result.a0 = l.a0 + r.a0;
result.a1 = l.a1 + r.a1;
result.a2 = l.a2 + r.a2;
result.a3 = l.a3 + r.a3;
result.b0 = l.b0 + r.b0;
result.b1 = l.b1 + r.b1;
result.b2 = l.b2 + r.b2;
result.b3 = l.b3 + r.b3;
result.c0 = l.c0 + r.c0;
result.c1 = l.c1 + r.c1;
result.c2 = l.c2 + r.c2;
result.c3 = l.c3 + r.c3;
result.d0 = l.d0 + r.d0;
result.d1 = l.d1 + r.d1;
result.d2 = l.d2 + r.d2;
result.d3 = l.d3 + r.d3;
return result;
}
// VERIFY: 11dc36b4 auto
// OFFSET: 0x004C1F00
C44Matrix operator*(const C44Matrix& l, const C44Matrix& r) {
C44Matrix result;
result.a0 = r.c0 * l.a2 + l.a1 * r.b0 + l.a3 * r.d0 + l.a0 * r.a0;
result.a1 = r.c1 * l.a2 + l.a1 * r.b1 + r.a1 * l.a0 + r.d1 * l.a3;
result.a2 = l.a1 * r.b2 + l.a3 * r.d2 + r.a2 * l.a0 + l.a2 * r.c2;
result.a3 = r.c3 * l.a2 + r.a3 * l.a0 + l.a1 * r.b3 + r.d3 * l.a3;
result.b0 = l.b1 * r.b0 + r.c0 * l.b2 + l.b3 * r.d0 + l.b0 * r.a0;
result.b1 = l.b1 * r.b1 + r.c1 * l.b2 + r.d1 * l.b3 + l.b0 * r.a1;
result.b2 = r.d2 * l.b3 + l.b2 * r.c2 + l.b1 * r.b2 + l.b0 * r.a2;
result.b3 = l.b1 * r.b3 + r.d3 * l.b3 + r.c3 * l.b2 + l.b0 * r.a3;
result.c0 = l.c1 * r.b0 + r.c0 * l.c2 + l.c3 * r.d0 + l.c0 * r.a0;
result.c1 = l.c1 * r.b1 + r.d1 * l.c3 + r.c1 * l.c2 + l.c0 * r.a1;
result.c2 = l.c3 * r.d2 + l.c2 * r.c2 + l.c1 * r.b2 + l.c0 * r.a2;
result.c3 = l.c1 * r.b3 + r.d3 * l.c3 + r.c3 * l.c2 + l.c0 * r.a3;
result.d0 = l.d1 * r.b0 + r.c0 * l.d2 + l.d3 * r.d0 + l.d0 * r.a0;
result.d1 = l.d1 * r.b1 + r.d1 * l.d3 + r.c1 * l.d2 + l.d0 * r.a1;
result.d2 = l.d3 * r.d2 + l.d2 * r.c2 + l.d1 * r.b2 + l.d0 * r.a2;
result.d3 = l.d1 * r.b3 + r.d3 * l.d3 + r.c3 * l.d2 + l.d0 * r.a3;
return result;
}
// VERIFY: 007e753f auto
// OFFSET: 0x004C2120
C44Matrix operator*(const C44Matrix& l, float s) {
C44Matrix result;
result.a0 = l.a0 * s;
result.a1 = l.a1 * s;
result.a2 = l.a2 * s;
result.a3 = l.a3 * s;
result.b0 = l.b0 * s;
result.b1 = l.b1 * s;
result.b2 = l.b2 * s;
result.b3 = l.b3 * s;
result.c0 = l.c0 * s;
result.c1 = l.c1 * s;
result.c2 = l.c2 * s;
result.c3 = l.c3 * s;
result.d0 = l.d0 * s;
result.d1 = l.d1 * s;
result.d2 = l.d2 * s;
result.d3 = s * l.d3;
return result;
}
// VERIFY: 2f00be7c auto
// OFFSET: 0x004C21B0
C3Vector operator*(const C3Vector& v, const C44Matrix& m) {
C3Vector result;
result.x = m.c0 * v.z + m.b0 * v.y + v.x * m.a0 + m.d0;
result.y = m.c1 * v.z + m.b1 * v.y + m.a1 * v.x + m.d1;
result.z = m.c2 * v.z + m.b2 * v.y + m.a2 * v.x + m.d2;
return result;
}
// VERIFY: 3c76980d auto
// OFFSET: 0x004C2270
C4Vector operator*(const C4Vector& v, const C44Matrix& m) {
C4Vector result;
result.x = m.d0 * v.w + m.b0 * v.y + m.c0 * v.z + v.x * m.a0;
result.y = m.d1 * v.w + m.b1 * v.y + m.a1 * v.x + m.c1 * v.z;
result.z = m.d2 * v.w + m.b2 * v.y + m.a2 * v.x + m.c2 * v.z;
result.w = m.d3 * v.w + m.b3 * v.y + m.a3 * v.x + m.c3 * v.z;
return result;
}
// VERIFY: ea7afa9a manual
// OFFSET: 0x004C2300
C3Vector operator*=(C3Vector& v, const C44Matrix& m) {
float y = m.c1 * v.z + m.b1 * v.y + m.a1 * v.x + m.d1;
float z = m.c2 * v.z + m.b2 * v.y + m.a2 * v.x + m.d2;
v.x = m.c0 * v.z + m.b0 * v.y + v.x * m.a0 + m.d0;
v.y = y;
v.z = z;
return v;
}
// VERIFY: 09407440 auto
// OFFSET: 0x004C2370
C44Matrix& C44Matrix::operator*=(const C44Matrix& m) {
*this = *this * m;
return *this;
}
// VERIFY: 00776b33 auto
// OFFSET: 0x004C23A0
C44Matrix& C44Matrix::operator*=(float s) {
*this = *this * s;
return *this;
}
// VERIFY: 606764cd manual
// OFFSET: 0x004C23D0
C44Matrix C44Matrix::Transpose() const {
C44Matrix result;
result.a0 = this->a0;
result.a1 = this->b0;
result.a2 = this->c0;
result.a3 = this->d0;
result.b0 = this->a1;
result.b1 = this->b1;
result.b2 = this->c1;
result.b3 = this->d1;
result.c0 = this->a2;
result.c1 = this->b2;
result.c2 = this->c2;
result.c3 = this->d2;
result.d0 = this->a3;
result.d1 = this->b3;
result.d2 = this->c3;
result.d3 = this->d3;
return result;
}
// VERIFY: 1a5a19b8 manual
// OFFSET: 0x004C2440
C44Matrix C44Matrix::Adjoint() const {
float a0 = this->a0;
float a1 = this->a1;
float a2 = this->a2;
float a3 = this->a3;
float b0 = this->b0;
float b1 = this->b1;
float b2 = this->b2;
float b3 = this->b3;
float c0 = this->c0;
float c1 = this->c1;
float c2 = this->c2;
float c3 = this->c3;
float d0 = this->d0;
float d1 = this->d1;
float d2 = this->d2;
float d3 = this->d3;
C44Matrix result;
result.a0 = b2 * c3 * d1 + b3 * c1 * d2 + b1 * c2 * d3 - b3 * c2 * d1 - b2 * c1 * d3 - b1 * c3 * d2;
result.a1 = -(a2 * c3 * d1 + a3 * c1 * d2 + a1 * c2 * d3 - a3 * c2 * d1 - a2 * c1 * d3 - a1 * c3 * d2);
result.a2 = a1 * b2 * d3 + a2 * b3 * d1 + a3 * b1 * d2 - a3 * b2 * d1 - a2 * b1 * d3 - a1 * b3 * d2;
result.a3 = -(a2 * b3 * c1 + a3 * b1 * c2 + a1 * b2 * c3 - a3 * b2 * c1 - a2 * b1 * c3 - a1 * b3 * c2);
result.b0 = -(b3 * c0 * d2 + b0 * c2 * d3 + b2 * c3 * d0 - b3 * c2 * d0 - b2 * c0 * d3 - b0 * c3 * d2);
result.b1 = a2 * c3 * d0 + a3 * c0 * d2 + a0 * c2 * d3 - a3 * c2 * d0 - a2 * c0 * d3 - a0 * c3 * d2;
result.b2 = -(a2 * b3 * d0 + a3 * b0 * d2 + a0 * b2 * d3 - a3 * b2 * d0 - a2 * b0 * d3 - a0 * b3 * d2);
result.b3 = a2 * b3 * c0 + a3 * b0 * c2 + a0 * b2 * c3 - a3 * b2 * c0 - a2 * b0 * c3 - a0 * b3 * c2;
result.c0 = b1 * c3 * d0 + b3 * c0 * d1 + b0 * c1 * d3 - b3 * c1 * d0 - b1 * c0 * d3 - b0 * c3 * d1;
result.c1 = -(a1 * c3 * d0 + a3 * c0 * d1 + a0 * c1 * d3 - a3 * c1 * d0 - a1 * c0 * d3 - a0 * c3 * d1);
result.c2 = a1 * b3 * d0 + a3 * b0 * d1 + a0 * b1 * d3 - a3 * b1 * d0 - a1 * b0 * d3 - a0 * b3 * d1;
result.c3 = -(a1 * b3 * c0 + a3 * b0 * c1 + a0 * b1 * c3 - a3 * b1 * c0 - a1 * b0 * c3 - a0 * b3 * c1);
result.d0 = -(b2 * c0 * d1 + b0 * c1 * d2 + b1 * c2 * d0 - b2 * c1 * d0 - b1 * c0 * d2 - b0 * c2 * d1);
result.d1 = a1 * c2 * d0 + a2 * c0 * d1 + a0 * c1 * d2 - a2 * c1 * d0 - a1 * c0 * d2 - a0 * c2 * d1;
result.d2 = -(a1 * b2 * d0 + a2 * b0 * d1 + a0 * b1 * d2 - a2 * b1 * d0 - a1 * b0 * d2 - a0 * b2 * d1);
result.d3 = a0 * b1 * c2 + a1 * b2 * c0 + a2 * b0 * c1 - b1 * a2 * c0 - c2 * (b0 * a1) - a0 * b2 * c1;
return result;
}
// VERIFY: 0cf132bb auto
// OFFSET: 0x004C2F90
C44Matrix C44Matrix::Inverse(float determinant) const {
return this->Adjoint() * (1.0f / determinant);
}
// VERIFY: 8fbe6bb9 manual
// OFFSET: 0x004C2FC0
C44Matrix C44Matrix::AffineInverse() const {
C33Matrix rotation(*this);
C44Matrix result;
result.a0 = rotation.a0;
result.a1 = rotation.b0;
result.a2 = rotation.c0;
result.a3 = 0.0f;
result.b3 = 0.0f;
result.b0 = rotation.a1;
result.b1 = rotation.b1;
result.b2 = rotation.c1;
result.c0 = rotation.a2;
result.c1 = rotation.b2;
result.c2 = rotation.c2;
result.c3 = 0.0f;
result.d3 = 1.0f;
float x = -this->d0;
float y = -this->d1;
float z = -this->d2;
result.d0 = rotation.a0 * x + rotation.a1 * y + rotation.a2 * z;
result.d1 = rotation.b0 * x + rotation.b2 * z + y * rotation.b1;
result.d2 = z * rotation.c2 + y * rotation.c1 + x * rotation.c0;
return result;
}
// VERIFY: 61be4e70 manual
// OFFSET: 0x004C30A0
C44Matrix C44Matrix::AffineInverse(float scale) const {
if (fabs(scale - 1.0f) < 0.00000095367432f) {
return this->AffineInverse();
}
C33Matrix rotation(*this);
C33Matrix transposed;
transposed.a0 = rotation.a0;
transposed.a1 = rotation.b0;
transposed.a2 = rotation.c0;
transposed.b0 = rotation.a1;
transposed.b1 = rotation.b1;
transposed.b2 = rotation.c1;
transposed.c0 = rotation.a2;
transposed.c1 = rotation.b2;
transposed.c2 = rotation.c2;
C44Matrix result(transposed);
float s = 1.0f / (scale * scale);
result.a0 = result.a0 * s;
result.a1 = result.a1 * s;
result.a2 = result.a2 * s;
result.b0 = result.b0 * s;
result.b1 = result.b1 * s;
result.b2 = result.b2 * s;
result.c0 = result.c0 * s;
result.c1 = result.c1 * s;
result.c2 = s * result.c2;
C3Vector move;
move.x = -this->d0;
move.y = -this->d1;
move.z = -this->d2;
result.Translate(move);
return result;
}
// VERIFY: 1b98d34d manual
// OFFSET: 0x004C31B0
C44Matrix C44Matrix::RotationAroundX(float angle) {
float c = cos(angle);
float s = sin(angle);
C44Matrix result;
result.a0 = 1.0f;
result.a1 = 0.0f;
result.a2 = 0.0f;
result.a3 = 0.0f;
result.b0 = 0.0f;
result.b1 = c;
result.b2 = s;
result.b3 = 0.0f;
result.c0 = 0.0f;
result.c1 = -s;
result.c2 = c;
result.c3 = 0.0f;
result.d0 = 0.0f;
result.d1 = 0.0f;
result.d2 = 0.0f;
result.d3 = 1.0f;
return result;
}
// VERIFY: ce7b26fe manual
// OFFSET: 0x004C3220
C44Matrix C44Matrix::RotationAroundY(float angle) {
float c = cos(angle);
float s = sin(angle);
C44Matrix result;
result.a0 = c;
result.a1 = 0.0f;
result.a2 = -s;
result.a3 = 0.0f;
result.b0 = 0.0f;
result.b1 = 1.0f;
result.d3 = 1.0f;
result.b2 = 0.0f;
result.b3 = 0.0f;
result.c1 = 0.0f;
result.c3 = 0.0f;
result.d0 = 0.0f;
result.d1 = 0.0f;
result.d2 = 0.0f;
result.c0 = s;
result.c2 = c;
return result;
}
// VERIFY: 8c65162a manual
// OFFSET: 0x004C3290
C44Matrix C44Matrix::RotationAroundZ(float angle) {
float c = cos(angle);
float s = sin(angle);
C44Matrix result;
result.a0 = c;
result.a1 = s;
result.a2 = 0.0f;
result.a3 = 0.0f;
result.b0 = -s;
result.b1 = c;
result.b2 = 0.0f;
result.b3 = 0.0f;
result.c0 = 0.0f;
result.c1 = 0.0f;
result.c2 = 1.0f;
result.d3 = 1.0f;
result.c3 = 0.0f;
result.d0 = 0.0f;
result.d1 = 0.0f;
result.d2 = 0.0f;
return result;
}
// VERIFY: 598de8c7 auto
// OFFSET: 0x004C3300
void C44Matrix::RotateAroundX(float angle) {
*this = RotationAroundX(angle) * *this;
}
// VERIFY: a0038923 auto
// OFFSET: 0x004C3340
void C44Matrix::RotateAroundY(float angle) {
*this = RotationAroundY(angle) * *this;
}
// VERIFY: dac14547 auto
// OFFSET: 0x004C3380
void C44Matrix::RotateAroundZ(float angle) {
*this = RotationAroundZ(angle) * *this;
}
// VERIFY: 3b81b419 auto
// OFFSET: 0x004C33C0
void C44Matrix::Rotate(const C4Quaternion& q) {
*this = C44Matrix(q) * *this;
}
// VERIFY: a7b7706e manual
// OFFSET: 0x004C3460
C44Matrix C44Matrix::Rotation(float angle, const C3Vector& axis, bool normalized) {
float x = axis.x;
float y = axis.y;
float z = axis.z;
if (!normalized) {
float scale = 1.0f / sqrt(z * z + y * y + x * x);
x = x * scale;
y = y * scale;
z = z * scale;
}
float c = cos(angle);
float s = sin(angle);
float t = 1.0f - c;
C44Matrix result;
result.a0 = x * x * t + c;
result.a1 = y * x * t + s * z;
result.a2 = z * x * t - y * s;
result.a3 = 0.0f;
result.b0 = y * x * t - s * z;
result.b1 = y * y * t + c;
result.b2 = t * (z * y) + x * s;
result.b3 = 0.0f;
result.c0 = z * x * t + y * s;
result.c1 = t * (z * y) - x * s;
result.c2 = c + t * (z * z);
result.c3 = 0.0f;
result.d0 = 0.0f;
result.d1 = 0.0f;
result.d2 = 0.0f;
result.d3 = 1.0f;
return result;
}
// VERIFY: 9912ac4c auto
// OFFSET: 0x0057C2E0
C3Vector TransformDirection(const C3Vector& v, const C44Matrix& m) {
C3Vector result;
result.x = m.c0 * v.z + m.b0 * v.y + v.x * m.a0;
result.y = m.c1 * v.z + m.b1 * v.y + m.a1 * v.x;
result.z = m.c2 * v.z + m.b2 * v.y + m.a2 * v.x;
return result;
}
// VERIFY: 80d7997d auto
// OFFSET: 0x006A43A0
C44Matrix C44Matrix::Inverse() const {
return this->Inverse(this->Determinant());
}
// VERIFY: 158e48ed auto
// OFFSET: 0x004C1730
bool operator==(const C44Matrix& l, const C44Matrix& r) {
return r.a0 == l.a0 && r.a1 == l.a1 && r.a2 == l.a2 && r.a3 == l.a3 && r.b0 == l.b0 && r.b1 == l.b1 && r.b2 == l.b2 && r.b3 == l.b3 && r.c0 == l.c0 && r.c1 == l.c1 && r.c2 == l.c2 && r.c3 == l.c3 && r.d0 == l.d0 && r.d1 == l.d1 && r.d2 == l.d2 && r.d3 == l.d3;
}
// VERIFY: 0dc594ff auto
// OFFSET: 0x004C1E20
C44Matrix& C44Matrix::operator=(const C4Quaternion& q) {
FromQuaternion(q, *this);
this->a3 = 0.0f;
this->b3 = 0.0f;
this->c3 = 0.0f;
this->d0 = 0.0f;
this->d1 = 0.0f;
this->d2 = 0.0f;
this->d3 = 1.0f;
return *this;
}
// VERIFY: 12861045 auto
// OFFSET: 0x004C2210
C3Vector operator*(const C44Matrix& m, const C3Vector& v) {
C3Vector result;
result.x = m.a2 * v.z + m.a1 * v.y + m.a0 * v.x + m.a3;
result.y = m.b2 * v.z + m.b0 * v.x + m.b1 * v.y + m.b3;
result.z = m.c2 * v.z + m.c0 * v.x + m.c1 * v.y + m.c3;
return result;
}
// VERIFY: 124d7460 auto
// OFFSET: 0x004C3680
C44Matrix::C44Matrix(const C34Matrix& m) {
this->a0 = m.a0;
this->a1 = m.a1;
this->a2 = m.a2;
this->a3 = 0.0f;
this->b0 = m.b0;
this->b1 = m.b1;
this->b2 = m.b2;
this->b3 = 0.0f;
this->c0 = m.c0;
this->c1 = m.c1;
this->c2 = m.c2;
this->c3 = 0.0f;
this->d0 = m.d0;
this->d1 = m.d1;
this->d2 = m.d2;
this->d3 = 1.0f;
}
// VERIFY: d0f80fc6 auto
// OFFSET: 0x0078FBD0
C44Matrix::C44Matrix(const C3Vector& x, const C3Vector& y, const C3Vector& z, const C3Vector& w) {
this->a0 = x.x;
this->a1 = x.y;
this->a2 = x.z;
this->a3 = 0.0f;
this->b0 = y.x;
this->b1 = y.y;
this->b2 = y.z;
this->b3 = 0.0f;
this->c0 = z.x;
this->c1 = z.y;
this->c2 = z.z;
this->c3 = 0.0f;
this->d0 = w.x;
this->d1 = w.y;
this->d2 = w.z;
this->d3 = 1.0f;
}