Common: Move Matrix classes out of MathUtil into their own files and make their interface more friendly.
This commit is contained in:
parent
3b4486bad3
commit
b9a00a40a9
|
@ -24,6 +24,7 @@ add_library(common
|
|||
JitRegister.cpp
|
||||
Logging/LogManager.cpp
|
||||
MathUtil.cpp
|
||||
Matrix.cpp
|
||||
MD5.cpp
|
||||
MemArena.cpp
|
||||
MemoryUtil.cpp
|
||||
|
|
|
@ -134,6 +134,7 @@
|
|||
<ClInclude Include="LdrWatcher.h" />
|
||||
<ClInclude Include="LinearDiskCache.h" />
|
||||
<ClInclude Include="MathUtil.h" />
|
||||
<ClInclude Include="Matrix.h" />
|
||||
<ClInclude Include="MD5.h" />
|
||||
<ClInclude Include="MemArena.h" />
|
||||
<ClInclude Include="MemoryUtil.h" />
|
||||
|
@ -201,6 +202,7 @@
|
|||
<ClCompile Include="LdrWatcher.cpp" />
|
||||
<ClCompile Include="Logging\ConsoleListenerWin.cpp" />
|
||||
<ClCompile Include="MathUtil.cpp" />
|
||||
<ClCompile Include="Matrix.cpp" />
|
||||
<ClCompile Include="MD5.cpp" />
|
||||
<ClCompile Include="MemArena.cpp" />
|
||||
<ClCompile Include="MemoryUtil.cpp" />
|
||||
|
@ -256,4 +258,4 @@
|
|||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
</Project>
|
||||
|
|
|
@ -56,6 +56,7 @@
|
|||
<ClInclude Include="IniFile.h" />
|
||||
<ClInclude Include="LinearDiskCache.h" />
|
||||
<ClInclude Include="MathUtil.h" />
|
||||
<ClInclude Include="Matrix.h" />
|
||||
<ClInclude Include="MemArena.h" />
|
||||
<ClInclude Include="MemoryUtil.h" />
|
||||
<ClInclude Include="MsgHandler.h" />
|
||||
|
@ -291,6 +292,7 @@
|
|||
<ClCompile Include="Image.cpp" />
|
||||
<ClCompile Include="IniFile.cpp" />
|
||||
<ClCompile Include="MathUtil.cpp" />
|
||||
<ClCompile Include="Matrix.cpp" />
|
||||
<ClCompile Include="MemArena.cpp" />
|
||||
<ClCompile Include="MemoryUtil.cpp" />
|
||||
<ClCompile Include="MsgHandler.cpp" />
|
||||
|
@ -362,4 +364,4 @@
|
|||
<ItemGroup>
|
||||
<Natvis Include="BitField.natvis" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
</Project>
|
||||
|
|
|
@ -2,136 +2,12 @@
|
|||
// Licensed under GPLv2+
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <limits>
|
||||
#include <numeric>
|
||||
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Common/MathUtil.h"
|
||||
|
||||
inline void MatrixMul(int n, const float* a, const float* b, float* result)
|
||||
{
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
for (int j = 0; j < n; ++j)
|
||||
{
|
||||
float temp = 0;
|
||||
for (int k = 0; k < n; ++k)
|
||||
{
|
||||
temp += a[i * n + k] * b[k * n + j];
|
||||
}
|
||||
result[i * n + j] = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
#include <numeric>
|
||||
|
||||
// Calculate sum of a float list
|
||||
float MathFloatVectorSum(const std::vector<float>& Vec)
|
||||
{
|
||||
return std::accumulate(Vec.begin(), Vec.end(), 0.0f);
|
||||
}
|
||||
|
||||
void Matrix33::LoadIdentity(Matrix33& mtx)
|
||||
{
|
||||
memset(mtx.data, 0, sizeof(mtx.data));
|
||||
mtx.data[0] = 1.0f;
|
||||
mtx.data[4] = 1.0f;
|
||||
mtx.data[8] = 1.0f;
|
||||
}
|
||||
|
||||
void Matrix33::RotateX(Matrix33& mtx, float rad)
|
||||
{
|
||||
float s = sin(rad);
|
||||
float c = cos(rad);
|
||||
memset(mtx.data, 0, sizeof(mtx.data));
|
||||
mtx.data[0] = 1;
|
||||
mtx.data[4] = c;
|
||||
mtx.data[5] = -s;
|
||||
mtx.data[7] = s;
|
||||
mtx.data[8] = c;
|
||||
}
|
||||
void Matrix33::RotateY(Matrix33& mtx, float rad)
|
||||
{
|
||||
float s = sin(rad);
|
||||
float c = cos(rad);
|
||||
memset(mtx.data, 0, sizeof(mtx.data));
|
||||
mtx.data[0] = c;
|
||||
mtx.data[2] = s;
|
||||
mtx.data[4] = 1;
|
||||
mtx.data[6] = -s;
|
||||
mtx.data[8] = c;
|
||||
}
|
||||
|
||||
void Matrix33::Multiply(const Matrix33& a, const Matrix33& b, Matrix33& result)
|
||||
{
|
||||
MatrixMul(3, a.data, b.data, result.data);
|
||||
}
|
||||
|
||||
void Matrix33::Multiply(const Matrix33& a, const float vec[3], float result[3])
|
||||
{
|
||||
for (int i = 0; i < 3; ++i)
|
||||
{
|
||||
result[i] = 0;
|
||||
|
||||
for (int k = 0; k < 3; ++k)
|
||||
{
|
||||
result[i] += a.data[i * 3 + k] * vec[k];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Matrix44::LoadIdentity(Matrix44& mtx)
|
||||
{
|
||||
memset(mtx.data, 0, sizeof(mtx.data));
|
||||
mtx.data[0] = 1.0f;
|
||||
mtx.data[5] = 1.0f;
|
||||
mtx.data[10] = 1.0f;
|
||||
mtx.data[15] = 1.0f;
|
||||
}
|
||||
|
||||
void Matrix44::LoadMatrix33(Matrix44& mtx, const Matrix33& m33)
|
||||
{
|
||||
for (int i = 0; i < 3; ++i)
|
||||
{
|
||||
for (int j = 0; j < 3; ++j)
|
||||
{
|
||||
mtx.data[i * 4 + j] = m33.data[i * 3 + j];
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 3; ++i)
|
||||
{
|
||||
mtx.data[i * 4 + 3] = 0;
|
||||
mtx.data[i + 12] = 0;
|
||||
}
|
||||
mtx.data[15] = 1.0f;
|
||||
}
|
||||
|
||||
void Matrix44::Set(Matrix44& mtx, const float mtxArray[16])
|
||||
{
|
||||
for (int i = 0; i < 16; ++i)
|
||||
{
|
||||
mtx.data[i] = mtxArray[i];
|
||||
}
|
||||
}
|
||||
|
||||
void Matrix44::Translate(Matrix44& mtx, const float vec[3])
|
||||
{
|
||||
LoadIdentity(mtx);
|
||||
mtx.data[3] = vec[0];
|
||||
mtx.data[7] = vec[1];
|
||||
mtx.data[11] = vec[2];
|
||||
}
|
||||
|
||||
void Matrix44::Shear(Matrix44& mtx, const float a, const float b)
|
||||
{
|
||||
LoadIdentity(mtx);
|
||||
mtx.data[2] = a;
|
||||
mtx.data[6] = b;
|
||||
}
|
||||
|
||||
void Matrix44::Multiply(const Matrix44& a, const Matrix44& b, Matrix44& result)
|
||||
{
|
||||
MatrixMul(4, a.data, b.data, result.data);
|
||||
}
|
||||
|
|
|
@ -5,8 +5,6 @@
|
|||
#pragma once
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
|
||||
#include "Common/CommonTypes.h"
|
||||
|
@ -113,38 +111,3 @@ inline int IntLog2(u64 val)
|
|||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
// Tiny matrix/vector library.
|
||||
// Used for things like Free-Look in the gfx backend.
|
||||
|
||||
class Matrix33
|
||||
{
|
||||
public:
|
||||
static void LoadIdentity(Matrix33& mtx);
|
||||
|
||||
// set mtx to be a rotation matrix around the x axis
|
||||
static void RotateX(Matrix33& mtx, float rad);
|
||||
// set mtx to be a rotation matrix around the y axis
|
||||
static void RotateY(Matrix33& mtx, float rad);
|
||||
|
||||
// set result = a x b
|
||||
static void Multiply(const Matrix33& a, const Matrix33& b, Matrix33& result);
|
||||
static void Multiply(const Matrix33& a, const float vec[3], float result[3]);
|
||||
|
||||
float data[9];
|
||||
};
|
||||
|
||||
class Matrix44
|
||||
{
|
||||
public:
|
||||
static void LoadIdentity(Matrix44& mtx);
|
||||
static void LoadMatrix33(Matrix44& mtx, const Matrix33& m33);
|
||||
static void Set(Matrix44& mtx, const float mtxArray[16]);
|
||||
|
||||
static void Translate(Matrix44& mtx, const float vec[3]);
|
||||
static void Shear(Matrix44& mtx, const float a, const float b = 0);
|
||||
|
||||
static void Multiply(const Matrix44& a, const Matrix44& b, Matrix44& result);
|
||||
|
||||
float data[16];
|
||||
};
|
||||
|
|
|
@ -0,0 +1,158 @@
|
|||
// Copyright 2019 Dolphin Emulator Project
|
||||
// Licensed under GPLv2+
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include "Common/Matrix.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
|
||||
inline void MatrixMul(int n, const float* a, const float* b, float* result)
|
||||
{
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
for (int j = 0; j < n; ++j)
|
||||
{
|
||||
float temp = 0;
|
||||
for (int k = 0; k < n; ++k)
|
||||
{
|
||||
temp += a[i * n + k] * b[k * n + j];
|
||||
}
|
||||
result[i * n + j] = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Matrix33 Matrix33::Identity()
|
||||
{
|
||||
Matrix33 mtx = {};
|
||||
mtx.data[0] = 1.0f;
|
||||
mtx.data[4] = 1.0f;
|
||||
mtx.data[8] = 1.0f;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix33 Matrix33::RotateX(float rad)
|
||||
{
|
||||
float s = sin(rad);
|
||||
float c = cos(rad);
|
||||
Matrix33 mtx = {};
|
||||
mtx.data[0] = 1;
|
||||
mtx.data[4] = c;
|
||||
mtx.data[5] = -s;
|
||||
mtx.data[7] = s;
|
||||
mtx.data[8] = c;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix33 Matrix33::RotateY(float rad)
|
||||
{
|
||||
float s = sin(rad);
|
||||
float c = cos(rad);
|
||||
Matrix33 mtx = {};
|
||||
mtx.data[0] = c;
|
||||
mtx.data[2] = s;
|
||||
mtx.data[4] = 1;
|
||||
mtx.data[6] = -s;
|
||||
mtx.data[8] = c;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix33 Matrix33::RotateZ(float rad)
|
||||
{
|
||||
float s = sin(rad);
|
||||
float c = cos(rad);
|
||||
Matrix33 mtx = {};
|
||||
mtx.data[0] = c;
|
||||
mtx.data[1] = -s;
|
||||
mtx.data[3] = s;
|
||||
mtx.data[4] = c;
|
||||
mtx.data[8] = 1;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix33 Matrix33::Scale(const Vec3& vec)
|
||||
{
|
||||
Matrix33 mtx = {};
|
||||
mtx.data[0] = vec.x;
|
||||
mtx.data[4] = vec.y;
|
||||
mtx.data[8] = vec.z;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
void Matrix33::Multiply(const Matrix33& a, const Matrix33& b, Matrix33* result)
|
||||
{
|
||||
MatrixMul(3, a.data.data(), b.data.data(), result->data.data());
|
||||
}
|
||||
|
||||
void Matrix33::Multiply(const Matrix33& a, const Vec3& vec, Vec3* result)
|
||||
{
|
||||
for (int i = 0; i < 3; ++i)
|
||||
{
|
||||
result->data[i] = 0;
|
||||
|
||||
for (int k = 0; k < 3; ++k)
|
||||
{
|
||||
result->data[i] += a.data[i * 3 + k] * vec.data[k];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Matrix44 Matrix44::Identity()
|
||||
{
|
||||
Matrix44 mtx = {};
|
||||
mtx.data[0] = 1.0f;
|
||||
mtx.data[5] = 1.0f;
|
||||
mtx.data[10] = 1.0f;
|
||||
mtx.data[15] = 1.0f;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix44 Matrix44::FromMatrix33(const Matrix33& m33)
|
||||
{
|
||||
Matrix44 mtx;
|
||||
for (int i = 0; i < 3; ++i)
|
||||
{
|
||||
for (int j = 0; j < 3; ++j)
|
||||
{
|
||||
mtx.data[i * 4 + j] = m33.data[i * 3 + j];
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 3; ++i)
|
||||
{
|
||||
mtx.data[i * 4 + 3] = 0;
|
||||
mtx.data[i + 12] = 0;
|
||||
}
|
||||
mtx.data[15] = 1.0f;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix44 Matrix44::FromArray(const float mtxArray[16])
|
||||
{
|
||||
Matrix44 mtx;
|
||||
std::copy_n(mtxArray, 16, std::begin(mtx.data));
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix44 Matrix44::Translate(const Vec3& vec)
|
||||
{
|
||||
Matrix44 mtx = Matrix44::Identity();
|
||||
mtx.data[3] = vec.x;
|
||||
mtx.data[7] = vec.y;
|
||||
mtx.data[11] = vec.y;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
Matrix44 Matrix44::Shear(const float a, const float b)
|
||||
{
|
||||
Matrix44 mtx = Matrix44::Identity();
|
||||
mtx.data[2] = a;
|
||||
mtx.data[6] = b;
|
||||
return mtx;
|
||||
}
|
||||
|
||||
void Matrix44::Multiply(const Matrix44& a, const Matrix44& b, Matrix44& result)
|
||||
{
|
||||
MatrixMul(4, a.data.data(), b.data.data(), result.data.data());
|
||||
}
|
|
@ -0,0 +1,88 @@
|
|||
// Copyright 2019 Dolphin Emulator Project
|
||||
// Licensed under GPLv2+
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
|
||||
// Tiny matrix/vector library.
|
||||
// Used for things like Free-Look in the gfx backend.
|
||||
|
||||
union Vec3
|
||||
{
|
||||
Vec3() {}
|
||||
Vec3(float _x, float _y, float _z) : data{_x, _y, _z} {}
|
||||
|
||||
std::array<float, 3> data = {};
|
||||
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
};
|
||||
};
|
||||
|
||||
class Matrix33
|
||||
{
|
||||
public:
|
||||
static Matrix33 Identity();
|
||||
|
||||
// Return a rotation matrix around the x,y,z axis
|
||||
static Matrix33 RotateX(float rad);
|
||||
static Matrix33 RotateY(float rad);
|
||||
static Matrix33 RotateZ(float rad);
|
||||
|
||||
static Matrix33 Scale(const Vec3& vec);
|
||||
|
||||
// set result = a x b
|
||||
static void Multiply(const Matrix33& a, const Matrix33& b, Matrix33* result);
|
||||
static void Multiply(const Matrix33& a, const Vec3& vec, Vec3* result);
|
||||
|
||||
Matrix33& operator*=(const Matrix33& rhs)
|
||||
{
|
||||
Multiply(Matrix33(*this), rhs, this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
std::array<float, 9> data;
|
||||
};
|
||||
|
||||
inline Matrix33 operator*(Matrix33 lhs, const Matrix33& rhs)
|
||||
{
|
||||
return lhs *= rhs;
|
||||
}
|
||||
|
||||
inline Vec3 operator*(const Matrix33& lhs, const Vec3& rhs)
|
||||
{
|
||||
Vec3 result;
|
||||
Matrix33::Multiply(lhs, rhs, &result);
|
||||
return result;
|
||||
}
|
||||
|
||||
class Matrix44
|
||||
{
|
||||
public:
|
||||
static Matrix44 Identity();
|
||||
static Matrix44 FromMatrix33(const Matrix33& m33);
|
||||
static Matrix44 FromArray(const float mtxArray[16]);
|
||||
|
||||
static Matrix44 Translate(const Vec3& vec);
|
||||
static Matrix44 Shear(const float a, const float b = 0);
|
||||
|
||||
static void Multiply(const Matrix44& a, const Matrix44& b, Matrix44& result);
|
||||
|
||||
Matrix44& operator*=(const Matrix44& rhs)
|
||||
{
|
||||
Multiply(Matrix44(*this), rhs, *this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
std::array<float, 16> data;
|
||||
};
|
||||
|
||||
inline Matrix44 operator*(Matrix44 lhs, const Matrix44& rhs)
|
||||
{
|
||||
return lhs *= rhs;
|
||||
}
|
|
@ -13,7 +13,7 @@
|
|||
#include "Common/CommonFuncs.h"
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Common/Logging/Log.h"
|
||||
#include "Common/MathUtil.h"
|
||||
#include "Common/Matrix.h"
|
||||
#include "Core/ConfigManager.h"
|
||||
#include "Core/Core.h"
|
||||
#include "VideoCommon/BPFunctions.h"
|
||||
|
@ -86,7 +86,7 @@ static void ViewportCorrectionMatrix(Matrix44& result)
|
|||
float Wd = (X + intendedWd <= EFB_WIDTH) ? intendedWd : (EFB_WIDTH - X);
|
||||
float Ht = (Y + intendedHt <= EFB_HEIGHT) ? intendedHt : (EFB_HEIGHT - Y);
|
||||
|
||||
Matrix44::LoadIdentity(result);
|
||||
result = Matrix44::Identity();
|
||||
if (Wd == 0 || Ht == 0)
|
||||
return;
|
||||
|
||||
|
@ -121,7 +121,7 @@ void VertexShaderManager::Init()
|
|||
ResetView();
|
||||
|
||||
// TODO: should these go inside ResetView()?
|
||||
Matrix44::LoadIdentity(s_viewportCorrection);
|
||||
s_viewportCorrection = Matrix44::Identity();
|
||||
memset(g_fProjectionMatrix, 0, sizeof(g_fProjectionMatrix));
|
||||
for (int i = 0; i < 4; ++i)
|
||||
g_fProjectionMatrix[i * 5] = 1.0f;
|
||||
|
@ -454,26 +454,19 @@ void VertexShaderManager::SetConstants()
|
|||
|
||||
if (g_ActiveConfig.bFreeLook && xfmem.projection.type == GX_PERSPECTIVE)
|
||||
{
|
||||
Matrix44 mtxA;
|
||||
Matrix44 mtxB;
|
||||
Matrix44 viewMtx;
|
||||
auto mtxA = Matrix44::Translate(s_fViewTranslationVector);
|
||||
auto mtxB = Matrix44::FromMatrix33(s_viewRotationMatrix);
|
||||
const auto viewMtx = mtxB * mtxA; // view = rotation x translation
|
||||
|
||||
Matrix44::Translate(mtxA, s_fViewTranslationVector);
|
||||
Matrix44::LoadMatrix33(mtxB, s_viewRotationMatrix);
|
||||
Matrix44::Multiply(mtxB, mtxA, viewMtx); // view = rotation x translation
|
||||
Matrix44::Set(mtxB, g_fProjectionMatrix);
|
||||
Matrix44::Multiply(mtxB, viewMtx, mtxA); // mtxA = projection x view
|
||||
Matrix44::Multiply(s_viewportCorrection, mtxA, mtxB); // mtxB = viewportCorrection x mtxA
|
||||
memcpy(constants.projection.data(), mtxB.data, 4 * sizeof(float4));
|
||||
mtxA = Matrix44::FromArray(g_fProjectionMatrix) * viewMtx; // mtxA = projection x view
|
||||
mtxB = s_viewportCorrection * mtxA; // mtxB = viewportCorrection x mtxA
|
||||
memcpy(constants.projection.data(), mtxB.data.data(), 4 * sizeof(float4));
|
||||
}
|
||||
else
|
||||
{
|
||||
Matrix44 projMtx;
|
||||
Matrix44::Set(projMtx, g_fProjectionMatrix);
|
||||
|
||||
Matrix44 correctedMtx;
|
||||
Matrix44::Multiply(s_viewportCorrection, projMtx, correctedMtx);
|
||||
memcpy(constants.projection.data(), correctedMtx.data, 4 * sizeof(float4));
|
||||
const auto projMtx = Matrix44::FromArray(g_fProjectionMatrix);
|
||||
const auto correctedMtx = s_viewportCorrection * projMtx;
|
||||
memcpy(constants.projection.data(), correctedMtx.data.data(), 4 * sizeof(float4));
|
||||
}
|
||||
|
||||
dirty = true;
|
||||
|
@ -677,16 +670,12 @@ void VertexShaderManager::RotateView(float x, float y)
|
|||
s_fViewRotation[0] += x;
|
||||
s_fViewRotation[1] += y;
|
||||
|
||||
Matrix33 mx;
|
||||
Matrix33 my;
|
||||
Matrix33::RotateX(mx, s_fViewRotation[1]);
|
||||
Matrix33::RotateY(my, s_fViewRotation[0]);
|
||||
Matrix33::Multiply(mx, my, s_viewRotationMatrix);
|
||||
s_viewRotationMatrix =
|
||||
Matrix33::RotateX(s_fViewRotation[1]) * Matrix33::RotateY(s_fViewRotation[0]);
|
||||
|
||||
// reverse rotation
|
||||
Matrix33::RotateX(mx, -s_fViewRotation[1]);
|
||||
Matrix33::RotateY(my, -s_fViewRotation[0]);
|
||||
Matrix33::Multiply(my, mx, s_viewInvRotationMatrix);
|
||||
s_viewInvRotationMatrix =
|
||||
Matrix33::RotateY(-s_fViewRotation[0]) * Matrix33::RotateX(-s_fViewRotation[1]);
|
||||
|
||||
bProjectionChanged = true;
|
||||
}
|
||||
|
@ -694,8 +683,8 @@ void VertexShaderManager::RotateView(float x, float y)
|
|||
void VertexShaderManager::ResetView()
|
||||
{
|
||||
memset(s_fViewTranslationVector, 0, sizeof(s_fViewTranslationVector));
|
||||
Matrix33::LoadIdentity(s_viewRotationMatrix);
|
||||
Matrix33::LoadIdentity(s_viewInvRotationMatrix);
|
||||
s_viewRotationMatrix = Matrix33::Identity();
|
||||
s_viewInvRotationMatrix = Matrix33::Identity();
|
||||
s_fViewRotation[0] = s_fViewRotation[1] = 0.0f;
|
||||
|
||||
bProjectionChanged = true;
|
||||
|
|
Loading…
Reference in New Issue