vwemirror/firestorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
035af2b10a3ee2abc3663cf1490bf4fefad3152f
firestorm/Gameleap/code/mw4/Libraries/stuff/Matrix.hpp
T
Cyd 2b8ca921cb Initial full mirror of c:\VWE (source + assets + toolchain + outputs) via Git LFS 
Complete disaster-recovery snapshot: engine/game source, game data assets,
VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive.
Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false,
no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
2026-06-24 21:28:16 -05:00

648 lines
17 KiB
C++
Raw Blame History

//===========================================================================//
// File: matrix.hh //
// Project: MUNGA Brick: Math Library //
// Contents: Interface specification for the matrix class //
//---------------------------------------------------------------------------//
// Date Who Modification //
// -------- --- ---------------------------------------------------------- //
// 11/21/94 JMA Initial coding. //
// 12/01/94 JMA Changed Matrix to Matrix4D, based both matrix classes on //
// Matrix44Base //
//---------------------------------------------------------------------------//
// Copyright (C) 1994-1995, Virtual World Entertainment, Inc. //
// All Rights reserved worldwide //
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL //
//===========================================================================//
#pragma once
#include "Stuff.hpp"
#include "Vector3D.hpp"
namespace Stuff {class Matrix4D;}
#if !defined(Spew)
void
Spew(
const char* group,
const Stuff::Matrix4D &matrix
);
#endif
namespace Stuff {
class AffineMatrix4D;
class Origin3D;
class EulerAngles;
class YawPitchRoll;
class Point3D;
class UnitQuaternion;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Matrix4D ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Matrix4D
{
public:
static const Matrix4D
Identity;
Scalar
entries[16];
//
// Constructors
//
Matrix4D()
{}
Matrix4D&
BuildIdentity();
explicit Matrix4D(int)
{BuildIdentity();}
Matrix4D(const Matrix4D &matrix)
{
Check_Pointer(this); Check_Object(&matrix);
memcpy(entries, matrix.entries, sizeof(entries));
}
explicit Matrix4D(const AffineMatrix4D &m)
{*this = m;}
explicit Matrix4D(const Origin3D &p)
{*this = p;}
explicit Matrix4D(const EulerAngles &angles)
{*this = angles;}
explicit Matrix4D(const YawPitchRoll &angles)
{*this = angles;}
explicit Matrix4D(const UnitQuaternion &q)
{*this = q;}
explicit Matrix4D(const Point3D &p)
{*this = p;}
//
// Assignment operators
//
Matrix4D&
operator=(const Matrix4D &m)
{
Check_Pointer(this); Check_Object(&m);
memcpy(entries, m.entries, sizeof(m.entries));
return *this;
}
Matrix4D&
operator=(const AffineMatrix4D &m);
Matrix4D&
operator=(const Origin3D &p);
Matrix4D&
operator=(const EulerAngles &angles);
Matrix4D&
operator=(const YawPitchRoll &angles);
Matrix4D&
operator=(const UnitQuaternion &q);
Matrix4D&
operator=(const Point3D &p);
Matrix4D&
BuildRotation(const EulerAngles &angles);
Matrix4D&
BuildRotation(const YawPitchRoll &angles);
Matrix4D&
BuildRotation(const UnitQuaternion &q);
Matrix4D&
BuildTranslation(const Point3D &p);
//
// Comparison operators
//
friend bool
Close_Enough(
const Matrix4D &m1,
const Matrix4D &m2,
Scalar e=SMALL
);
bool
operator==(const Matrix4D& a) const
{return Close_Enough(*this,a,SMALL);}
bool
operator!=(const Matrix4D& a) const
{return !Close_Enough(*this,a,SMALL);}
//
// Index operators
//
Scalar&
operator ()(size_t row,size_t column)
{
Check_Pointer(this);
Verify(static_cast<unsigned>(row) <= W_Axis);
Verify(static_cast<unsigned>(column) <= W_Axis);
return entries[(column<<2)+row];
}
const Scalar&
operator ()(size_t row,size_t column) const
{
Check_Pointer(this);
Verify(static_cast<unsigned>(row) <= W_Axis);
Verify(static_cast<unsigned>(column) <= W_Axis);
return entries[(column<<2)+row];
}
//
// Matrix4D Multiplication
//
Matrix4D&
Multiply(
const Matrix4D& Source1,
const Matrix4D& Source2
);
Matrix4D&
operator *=(const Matrix4D& m)
{Matrix4D temp(*this); return Multiply(temp,m);}
Matrix4D&
Multiply(
const Matrix4D& Source1,
const AffineMatrix4D &Source2
);
Matrix4D&
operator *=(const AffineMatrix4D& m)
{Matrix4D temp(*this); return Multiply(temp,m);}
inline Matrix4D&
Multiply(
const AffineMatrix4D &Source1,
const Matrix4D& Source2
)
{
Check_Pointer(this);
Check_Object(&Source1);
Check_Object(&Source2);
#if USE_ASSEMBLER_CODE
Scalar *f = entries;
_asm {
mov edx, Source1.entries
push esi
mov esi, Source2.entries
mov eax, f
fld dword ptr [edx] // s1[0][0]
fmul dword ptr [esi] // s2[0][0] M0,1
fld dword ptr [edx+010h] // s1[0][1]
fmul dword ptr [esi+4] // s2[1][0] M0,2
fld dword ptr [edx+020h] // s1[0][2]
fmul dword ptr [esi+8] // s2[2][0] M0,3
fxch st(2)
faddp st(1),st // A0,1
fld dword ptr [edx+4] // s1[1][0]
fmul dword ptr [esi] // s2[0][0] M1,1
fxch st(2)
faddp st(1),st // A0,2
fld dword ptr [edx+14h] // s1[1][1]
fmul dword ptr [esi+4] // s2[1][0] M1,2
fxch st(1)
fstp dword ptr [eax] // [0][0] S0
fld dword ptr [edx+24h] // s1[1][2]
fmul dword ptr [esi+8] // s2[2][0] M1,3
fxch st(2)
faddp st(1),st // A1,1
fld dword ptr [edx+8] // s1[2][0]
fmul dword ptr [esi] // s2[0][0] M2,1
fxch st(2)
faddp st(1),st // A1,2
fld dword ptr [edx+018h] // s1[2][1]
fmul dword ptr [esi+4] // s2[1][0] M2,2
fxch st(1)
fstp dword ptr [eax+4] // [1][0] S1
fld dword ptr [edx+28h] // s1[2][2]
fmul dword ptr [esi+8] // s2[2][0] M2,3
fxch st(2)
faddp st(1),st // A2,1
fld dword ptr [edx+0ch] // s1[3][0]
fmul dword ptr [esi] // s2[0][0] M3,1
fxch st(2)
faddp st(1),st // A2,2
fld dword ptr [edx+1ch] // s1[3][1]
fmul dword ptr [esi+4] // s2[1][0] M3,2
fxch st(1)
fstp dword ptr [eax+8] // [2][0] S2
fld dword ptr [edx+2ch] // s1[3][2]
fmul dword ptr [esi+8] // s2[2][0] M3,3
fxch st(2)
faddp st(1),st // A3,1
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
fld dword ptr [edx] // s1[0][0]
fmul dword ptr [esi+010h] // s2[0][1] M0,1
fxch st(2)
faddp st(1),st // A3,2
fld dword ptr [edx+010h] // s1[0][1]
fmul dword ptr [esi+014h] // s2[1][1] M0,2
fxch st(1)
fadd dword ptr [esi+0Ch] // s2[3][0] A3,3
fld dword ptr [edx+020h] // s1[0][2]
fmul dword ptr [esi+018h] // s2[2][1] M0,3
fxch st(1)
fstp dword ptr [eax+0Ch] // [3][0] S3
//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
fxch st(2)
faddp st(1),st // A0,1
fld dword ptr [edx+4] // s1[1][0]
fmul dword ptr [esi+010h] // s2[0][1] M1,1
fxch st(2)
faddp st(1),st // A0,2
fld dword ptr [edx+014h] // s1[1][1]
fmul dword ptr [esi+014h] // s2[1][1] M1,2
fxch st(1)
fstp dword ptr [eax+010h] // [0][1] S0
fld dword ptr [edx+024h] // s1[1][2]
fmul dword ptr [esi+018h] // s2[2][1] M1,3
fxch st(2)
faddp st(1),st // A1,1
fld dword ptr [edx+8] // s1[2][0]
fmul dword ptr [esi+010h] // s2[0][1] M2,1
fxch st(2)
faddp st(1),st // A1,2
fld dword ptr [edx+018h] // s1[2][1]
fmul dword ptr [esi+014h] // s2[1][1] M2,2
fxch st(1)
fstp dword ptr [eax+014h] // [1][1] S1
fld dword ptr [edx+028h] // s1[2][2]
fmul dword ptr [esi+018h] // s2[2][1] M2,3
fxch st(2)
faddp st(1),st // A2,1
fld dword ptr [edx+0ch] // s1[3][0]
fmul dword ptr [esi+010h] // s2[0][1] M3,1
fxch st(2)
faddp st(1),st // A2,2
fld dword ptr [edx+01ch] // s1[3][1]
fmul dword ptr [esi+014h] // s2[1][1] M3,2
fxch st(1)
fstp dword ptr [eax+018h] // [2][1] S2
fld dword ptr [edx+02ch] // s1[3][2]
fmul dword ptr [esi+018h] // s2[2][1] M3,3
fxch st(2)
faddp st(1),st // A3,1
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
fld dword ptr [edx] // s1[0][0]
fmul dword ptr [esi+020h] // s2[0][2] M0,1
fxch st(2)
faddp st(1),st // A3,2
fld dword ptr [edx+010h] // s1[0][1]
fmul dword ptr [esi+024h] // s2[1][2] M0,2
fxch st(1)
fadd dword ptr [esi+01Ch] // s2[3][1] A3,3
fld dword ptr [edx+020h] // s1[0][2]
fmul dword ptr [esi+028h] // s2[2][2] M0,3
fxch st(1)
fstp dword ptr [eax+01Ch] // [3][1] S3
//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
fxch st(2)
faddp st(1),st // A0,1
fld dword ptr [edx+4] // s1[1][0]
fmul dword ptr [esi+020h] // s2[0][2] M1,1
fxch st(2)
faddp st(1),st // A0,2
fld dword ptr [edx+014h] // s1[1][1]
fmul dword ptr [esi+024h] // s2[1][2] M1,2
fxch st(1)
fstp dword ptr [eax+020h] // [0][2] S0
fld dword ptr [edx+024h] // s1[1][2]
fmul dword ptr [esi+028h] // s2[2][2] M1,3
fxch st(2)
faddp st(1),st // A1,1
fld dword ptr [edx+8] // s1[2][0]
fmul dword ptr [esi+020h] // s2[0][2] M2,1
fxch st(2)
faddp st(1),st // A1,2
fld dword ptr [edx+018h] // s1[2][1]
fmul dword ptr [esi+024h] // s2[1][2] M2,2
fxch st(1)
fstp dword ptr [eax+024h] // [1][2] S1
fld dword ptr [edx+028h] // s1[2][2]
fmul dword ptr [esi+028h] // s2[2][2] M2,3
fxch st(2)
faddp st(1),st // A2,1
fld dword ptr [edx+0ch] // s1[3][0]
fmul dword ptr [esi+020h] // s2[0][2] M3,1
fxch st(2)
faddp st(1),st // A2,2
fld dword ptr [edx+01ch] // s1[3][1]
fmul dword ptr [esi+024h] // s2[1][2] M3,2
fxch st(1)
fstp dword ptr [eax+028h] // [2][2] S2
fld dword ptr [edx+02ch] // s1[3][2]
fmul dword ptr [esi+028h] // s2[2][2] M3,3
fxch st(2)
faddp st(1),st // A3,1
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
fld dword ptr [edx] // s1[0][0]
fmul dword ptr [esi+030h] // s2[0][3] M0,1
fxch st(2)
faddp st(1),st // A3,2
fld dword ptr [edx+010h] // s1[0][1]
fmul dword ptr [esi+034h] // s2[1][3] M0,2
fxch st(1)
fadd dword ptr [esi+02Ch] // s2[3][2] A3,3
fld dword ptr [edx+020h] // s1[0][2]
fmul dword ptr [esi+038h] // s2[2][3] M0,3
fxch st(1)
fstp dword ptr [eax+02Ch] // [3][2] S3
//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
fxch st(2)
faddp st(1),st // A0,1
fld dword ptr [edx+4] // s1[1][0]
fmul dword ptr [esi+030h] // s2[0][3] M1,1
fxch st(2)
faddp st(1),st // A0,2
fld dword ptr [edx+014h] // s1[1][1]
fmul dword ptr [esi+034h] // s2[1][3] M1,2
fxch st(1)
fstp dword ptr [eax+030h] // [0][3] S0
fld dword ptr [edx+024h] // s1[1][2]
fmul dword ptr [esi+038h] // s2[2][3] M1,3
fxch st(2)
faddp st(1),st // A1,1
fld dword ptr [edx+8] // s1[2][0]
fmul dword ptr [esi+030h] // s2[0][3] M2,1
fxch st(2)
faddp st(1),st // A1,2
fld dword ptr [edx+018h] // s1[2][1]
fmul dword ptr [esi+034h] // s2[1][3] M2,2
fxch st(1)
fstp dword ptr [eax+034h] // [1][3] S1
fld dword ptr [edx+028h] // s1[2][2]
fmul dword ptr [esi+038h] // s2[2][3] M2,3
fxch st(2)
faddp st(1),st // A2,1
fld dword ptr [edx+0ch] // s1[3][0]
fmul dword ptr [esi+030h] // s2[0][3] M3,1
fxch st(2)
faddp st(1),st // A2,2
fld dword ptr [edx+01ch] // s1[3][1]
fmul dword ptr [esi+034h] // s2[1][3] M3,2
fxch st(1)
fstp dword ptr [eax+038h] // [2][3] S2
fld dword ptr [edx+02ch] // s1[3][2]
fmul dword ptr [esi+038h] // s2[2][3] M3,3
fxch st(2)
faddp st(1),st // A3,1
faddp st(1),st // A3,2
fadd dword ptr [esi+03Ch] // s2[3][3] A3,3
fstp dword ptr [eax+03Ch] // [3][3] S3
pop esi
}
#else
(*this)(0,0) =
Source1(0,0)*Source2(0,0)
+ Source1(0,1)*Source2(1,0)
+ Source1(0,2)*Source2(2,0);
(*this)(1,0) =
Source1(1,0)*Source2(0,0)
+ Source1(1,1)*Source2(1,0)
+ Source1(1,2)*Source2(2,0);
(*this)(2,0) =
Source1(2,0)*Source2(0,0)
+ Source1(2,1)*Source2(1,0)
+ Source1(2,2)*Source2(2,0);
(*this)(3,0) =
Source1(3,0)*Source2(0,0)
+ Source1(3,1)*Source2(1,0)
+ Source1(3,2)*Source2(2,0)
+ Source2(3,0);
(*this)(0,1) =
Source1(0,0)*Source2(0,1)
+ Source1(0,1)*Source2(1,1)
+ Source1(0,2)*Source2(2,1);
(*this)(1,1) =
Source1(1,0)*Source2(0,1)
+ Source1(1,1)*Source2(1,1)
+ Source1(1,2)*Source2(2,1);
(*this)(2,1) =
Source1(2,0)*Source2(0,1)
+ Source1(2,1)*Source2(1,1)
+ Source1(2,2)*Source2(2,1);
(*this)(3,1) =
Source1(3,0)*Source2(0,1)
+ Source1(3,1)*Source2(1,1)
+ Source1(3,2)*Source2(2,1)
+ Source2(3,1);
(*this)(0,2) =
Source1(0,0)*Source2(0,2)
+ Source1(0,1)*Source2(1,2)
+ Source1(0,2)*Source2(2,2);
(*this)(1,2) =
Source1(1,0)*Source2(0,2)
+ Source1(1,1)*Source2(1,2)
+ Source1(1,2)*Source2(2,2);
(*this)(2,2) =
Source1(2,0)*Source2(0,2)
+ Source1(2,1)*Source2(1,2)
+ Source1(2,2)*Source2(2,2);
(*this)(3,2) =
Source1(3,0)*Source2(0,2)
+ Source1(3,1)*Source2(1,2)
+ Source1(3,2)*Source2(2,2)
+ Source2(3,2);
(*this)(0,3) =
Source1(0,0)*Source2(0,3)
+ Source1(0,1)*Source2(1,3)
+ Source1(0,2)*Source2(2,3);
(*this)(1,3) =
Source1(1,0)*Source2(0,3)
+ Source1(1,1)*Source2(1,3)
+ Source1(1,2)*Source2(2,3);
(*this)(2,3) =
Source1(2,0)*Source2(0,3)
+ Source1(2,1)*Source2(1,3)
+ Source1(2,2)*Source2(2,3);
(*this)(3,3) =
Source1(3,0)*Source2(0,3)
+ Source1(3,1)*Source2(1,3)
+ Source1(3,2)*Source2(2,3)
+ Source2(3,3);
#endif
return *this;
};
Matrix4D&
Multiply(
const AffineMatrix4D &Source1,
const AffineMatrix4D &Source2
);
//
// Matrix4D Inversion
//
#if 0
Matrix4D&
Invert(const Matrix4D& Source);
Matrix4D&
Invert()
{Matrix4D src(*this); return Invert(src);}
#endif
//
// Viewpoint Calculation
//
#if !defined(Spew)
friend void
::Spew(
const char* group,
const Matrix4D &matrix
);
#endif
static bool
TestClass();
void
TestInstance() const
{}
//
// Creating perspective Matrix4D
//
void
SetPerspective(
Scalar near_clip,
Scalar far_clip,
Scalar left_clip,
Scalar right_clip,
Scalar top_clip,
Scalar bottom_clip
);
void
GetPerspective(
Scalar *near_clip,
Scalar *far_clip,
Scalar *left_clip,
Scalar *right_clip,
Scalar *top_clip,
Scalar *bottom_clip
) const;
void
SetPerspective(
Scalar near_clip,
Scalar far_clip,
const Radian &horizontal_fov,
Scalar height_to_width
);
void
GetPerspective(
Scalar *near_clip,
Scalar *far_clip,
Radian *horizontal_fov,
Scalar *height_to_width
) const;
};
}
Reference in New Issue View Git Blame Copy Permalink