yyc12345/libcmo21
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
af6a50c2f9
libcmo21/LibCmo/VxMath/VxTypes.cpp

530 lines
15 KiB
C++
Raw Normal View History

refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
#include "VxTypes.hpp"
#include <cmath>
namespace LibCmo::VxMath {
#pragma region VxVector2
VxVector2::VxVector2() :x(0.0f), y(0.0f) {}
VxVector2::VxVector2(CKFLOAT _x, CKFLOAT _y) : x(_x), y(_y) {}
CKFLOAT& VxVector2::operator[](size_t i) {
switch (i) {
case 0: return x;
case 1: return y;
default: throw LogicException("Invalid index for VxVector2::operator[].");
}
}
const CKFLOAT& VxVector2::operator[](size_t i) const {
switch (i) {
case 0: return x;
case 1: return y;
default: throw LogicException("Invalid index for VxVector2::operator[].");
}
}
bool VxVector2::operator==(const VxVector2& rhs) const {
return (x == rhs.x && y == rhs.y);
}
auto VxVector2::operator<=>(const VxVector2& rhs) const {
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
return y <=> rhs.y;
}
VxVector2 VxVector2::operator+() const {
return *this;
}
VxVector2 VxVector2::operator-() const {
return VxVector2(-x, -y);
}
VxVector2& VxVector2::operator+=(const VxVector2& rhs) {
x += rhs.x;
y += rhs.y;
return *this;
}
VxVector2 operator+(const VxVector2& lhs, const VxVector2& rhs) {
return VxVector2(lhs.x + rhs.x, lhs.y + rhs.y);
}
VxVector2& VxVector2::operator-=(const VxVector2& rhs) {
x -= rhs.x;
y -= rhs.y;
return *this;
}
VxVector2 operator-(const VxVector2& lhs, const VxVector2& rhs) {
return VxVector2(lhs.x - rhs.x, lhs.y - rhs.y);
}
VxVector2& VxVector2::operator*=(CKFLOAT rhs) {
x *= rhs;
y *= rhs;
return *this;
}
VxVector2 operator*(const VxVector2& lhs, CKFLOAT rhs) {
return VxVector2(lhs.x * rhs, lhs.y * rhs);
}
VxVector2 operator*(CKFLOAT lhs, const VxVector2& rhs) {
return VxVector2(lhs * rhs.x, lhs * rhs.y);
}
CKFLOAT operator*(const VxVector2& lhs, const VxVector2& rhs) {
return (lhs.x * rhs.x + lhs.y * rhs.y);
}
VxVector2& VxVector2::operator/=(CKFLOAT rhs) {
if (rhs == 0.0f) return *this;
x /= rhs;
y /= rhs;
return *this;
}
VxVector2 operator/(const VxVector2& lhs, CKFLOAT rhs) {
if (rhs == 0.0f) return VxVector2();
else return VxVector2(lhs.x / rhs, lhs.y / rhs);
}
CKFLOAT VxVector2::SquaredLength() const {
return (x * x + y * y);
}
CKFLOAT VxVector2::Length() const {
return std::sqrt(SquaredLength());
}
void VxVector2::Normalized() {
CKFLOAT len = Length();
if (len == 0.0f) return;
x /= len;
y /= len;
}
VxVector2 VxVector2::Normalize() const {
CKFLOAT len = Length();
if (len == 0.0f) return VxVector2();
else return VxVector2(x / len, y / len);
}
/* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */
#pragma endregion
#pragma region VxVector3
VxVector3::VxVector3() :x(0.0f), y(0.0f), z(0.0f) {}
VxVector3::VxVector3(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z) : x(_x), y(_y), z(_z) {}
CKFLOAT& VxVector3::operator[](size_t i) {
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
default: throw LogicException("Invalid index for VxVector3::operator[].");
}
}
const CKFLOAT& VxVector3::operator[](size_t i) const {
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
default: throw LogicException("Invalid index for VxVector3::operator[].");
}
}
bool VxVector3::operator==(const VxVector3& rhs) const {
return (x == rhs.x && y == rhs.y && z == rhs.z);
}
auto VxVector3::operator<=>(const VxVector3& rhs) const {
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
if (auto cmp = y <=> rhs.y; cmp != 0) return cmp;
return z <=> rhs.z;
}
VxVector3 VxVector3::operator+() const {
return *this;
}
VxVector3 VxVector3::operator-() const {
return VxVector3(-x, -y, -z);
}
VxVector3& VxVector3::operator+=(const VxVector3& rhs) {
x += rhs.x;
y += rhs.y;
z += rhs.z;
return *this;
}
VxVector3 operator+(const VxVector3& lhs, const VxVector3& rhs) {
return VxVector3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z);
}
VxVector3& VxVector3::operator-=(const VxVector3& rhs) {
x -= rhs.x;
y -= rhs.y;
z -= rhs.z;
return *this;
}
VxVector3 operator-(const VxVector3& lhs, const VxVector3& rhs) {
return VxVector3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);
}
VxVector3& VxVector3::operator*=(CKFLOAT rhs) {
x *= rhs;
y *= rhs;
z *= rhs;
return *this;
}
VxVector3 operator*(const VxVector3& lhs, CKFLOAT rhs) {
return VxVector3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs);
}
VxVector3 operator*(CKFLOAT lhs, const VxVector3& rhs) {
return VxVector3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
}
CKFLOAT operator*(const VxVector3& lhs, const VxVector3& rhs) {
return (lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z);
}
VxVector3& VxVector3::operator/=(CKFLOAT rhs) {
if (rhs == 0.0f) return *this;
x /= rhs;
y /= rhs;
z /= rhs;
return *this;
}
VxVector3 operator/(const VxVector3& lhs, CKFLOAT rhs) {
if (rhs == 0.0f) return VxVector3();
else return VxVector3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs);
}
CKFLOAT VxVector3::SquaredLength() const {
return (x * x + y * y + z * z);
}
CKFLOAT VxVector3::Length() const {
return std::sqrt(SquaredLength());
}
void VxVector3::Normalized() {
CKFLOAT len = Length();
if (len == 0.0f) return;
x /= len;
y /= len;
z /= len;
}
VxVector3 VxVector3::Normalize() const {
CKFLOAT len = Length();
if (len == 0.0f) return VxVector3();
else return VxVector3(x / len, y / len, z / len);
}
/* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */
#pragma endregion
#pragma region VxVector4
VxVector4::VxVector4() :x(0.0f), y(0.0f), z(0.0f), w(0.0f) {}
VxVector4::VxVector4(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {}
CKFLOAT& VxVector4::operator[](size_t i) {
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return w;
default: throw LogicException("Invalid index for VxVector4::operator[].");
}
}
const CKFLOAT& VxVector4::operator[](size_t i) const {
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return w;
default: throw LogicException("Invalid index for VxVector4::operator[].");
}
}
bool VxVector4::operator==(const VxVector4& rhs) const {
return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w);
}
auto VxVector4::operator<=>(const VxVector4& rhs) const {
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
if (auto cmp = y <=> rhs.y; cmp != 0) return cmp;
if (auto cmp = z <=> rhs.z; cmp != 0) return cmp;
return w <=> rhs.w;
}
VxVector4 VxVector4::operator+() const {
return *this;
}
VxVector4 VxVector4::operator-() const {
return VxVector4(-x, -y, -z, -w);
}
VxVector4& VxVector4::operator+=(const VxVector4& rhs) {
x += rhs.x;
y += rhs.y;
z += rhs.z;
w += rhs.w;
return *this;
}
VxVector4 operator+(const VxVector4& lhs, const VxVector4& rhs) {
return VxVector4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w);
}
VxVector4& VxVector4::operator-=(const VxVector4& rhs) {
x -= rhs.x;
y -= rhs.y;
z -= rhs.z;
w -= rhs.w;
return *this;
}
VxVector4 operator-(const VxVector4& lhs, const VxVector4& rhs) {
return VxVector4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w);
}
VxVector4& VxVector4::operator*=(CKFLOAT rhs) {
x *= rhs;
y *= rhs;
z *= rhs;
w *= rhs;
return *this;
}
VxVector4 operator*(const VxVector4& lhs, CKFLOAT rhs) {
return VxVector4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs);
}
VxVector4 operator*(CKFLOAT lhs, const VxVector4& rhs) {
return VxVector4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w);
}
CKFLOAT operator*(const VxVector4& lhs, const VxVector4& rhs) {
return (lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z + lhs.w * rhs.w);
}
VxVector4& VxVector4::operator/=(CKFLOAT rhs) {
if (rhs == 0.0f) return *this;
x /= rhs;
y /= rhs;
z /= rhs;
w /= rhs;
return *this;
}
VxVector4 operator/(const VxVector4& lhs, CKFLOAT rhs) {
if (rhs == 0.0f) return VxVector4();
else return VxVector4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs);
}
CKFLOAT VxVector4::SquaredLength() const {
return (x * x + y * y + z * z + w * w);
}
CKFLOAT VxVector4::Length() const {
return std::sqrt(SquaredLength());
}
void VxVector4::Normalized() {
CKFLOAT len = Length();
if (len == 0.0f) return;
x /= len;
y /= len;
z /= len;
w /= len;
}
VxVector4 VxVector4::Normalize() const {
CKFLOAT len = Length();
if (len == 0.0f) return VxVector4();
else return VxVector4(x / len, y / len, z / len, w / len);
}
/* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */
#pragma endregion
#pragma region VxQuaternion
VxQuaternion::VxQuaternion() :x(0.0f), y(0.0f), z(0.0f), w(1.0f) {} // SET YOUR CUSTOM INIT
VxQuaternion::VxQuaternion(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {}
CKFLOAT& VxQuaternion::operator[](size_t i) {
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return w;
default: throw LogicException("Invalid index for VxQuaternion::operator[].");
}
}
const CKFLOAT& VxQuaternion::operator[](size_t i) const {
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return w;
default: throw LogicException("Invalid index for VxQuaternion::operator[].");
}
}
bool VxQuaternion::operator==(const VxQuaternion& rhs) const {
return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w);
}
auto VxQuaternion::operator<=>(const VxQuaternion& rhs) const {
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
if (auto cmp = y <=> rhs.y; cmp != 0) return cmp;
if (auto cmp = z <=> rhs.z; cmp != 0) return cmp;
return w <=> rhs.w;
}
/* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */
#pragma endregion
#pragma region VxColor
VxColor::VxColor() :r(0.0f), g(0.0f), b(0.0f), a(1.0f) {} // SET YOUR CUSTOM INIT
VxColor::VxColor(CKFLOAT _r, CKFLOAT _g, CKFLOAT _b, CKFLOAT _a) : r(_r), g(_g), b(_b), a(_a) {}
CKFLOAT& VxColor::operator[](size_t i) {
switch (i) {
case 0: return r;
case 1: return g;
case 2: return b;
case 3: return a;
default: throw LogicException("Invalid index for VxColor::operator[].");
}
}
const CKFLOAT& VxColor::operator[](size_t i) const {
switch (i) {
case 0: return r;
case 1: return g;
case 2: return b;
case 3: return a;
default: throw LogicException("Invalid index for VxColor::operator[].");
}
}
bool VxColor::operator==(const VxColor& rhs) const {
return (r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a);
}
auto VxColor::operator<=>(const VxColor& rhs) const {
if (auto cmp = r <=> rhs.r; cmp != 0) return cmp;
if (auto cmp = g <=> rhs.g; cmp != 0) return cmp;
if (auto cmp = b <=> rhs.b; cmp != 0) return cmp;
return a <=> rhs.a;
}
/* ===== BEGIN USER CUSTOM ===== */
VxColor::VxColor(CKDWORD argb) { FromARGB(argb); }
VxColor::VxColor(CKFLOAT _r, CKFLOAT _g, CKFLOAT _b) : r(_r), g(_g), b(_b), a(1.0f) {}
void VxColor::FromARGB(CKDWORD argb) {
a = ((argb & 0xFF000000) >> 24) / 255.0f;
r = ((argb & 0x00FF0000) >> 16) / 255.0f;
g = ((argb & 0x0000FF00) >> 8) / 255.0f;
b = ((argb & 0x000000FF) >> 0) / 255.0f;
}
CKDWORD VxColor::ToARGB() const {
CKDWORD argb = 0;
argb |= static_cast<CKDWORD>(a * 255.0f);
argb <<= 8;
argb |= static_cast<CKDWORD>(r * 255.0f);
argb <<= 8;
argb |= static_cast<CKDWORD>(g * 255.0f);
argb <<= 8;
argb |= static_cast<CKDWORD>(b * 255.0f);
return argb;
}
void VxColor::Regulate() {
if (r > 1.0f) r = 1.0f;
else if (r < 0.0f) r = 0.0f;
if (g > 1.0f) g = 1.0f;
else if (g < 0.0f) g = 0.0f;
if (b > 1.0f) b = 1.0f;
else if (b < 0.0f) b = 0.0f;
if (a > 1.0f) a = 1.0f;
else if (a < 0.0f) a = 0.0f;
}
/* ===== END USER CUSTOM ===== */
#pragma endregion
#pragma region VxMatrix
VxMatrix::VxMatrix() : m_Data() { SetIdentity(); }
VxMatrix::VxMatrix(CKFLOAT m[4][4]) : m_Data() { std::memcpy(m_Data, m, sizeof(m_Data)); }
VxVector4& VxMatrix::operator[](size_t i) {
if (i >= 4) throw LogicException("Invalid index for VxMatrix::operator[].");
return *(reinterpret_cast<VxVector4*>(m_Data) + i);
}
const VxVector4& VxMatrix::operator[](size_t i) const {
if (i >= 4) throw LogicException("Invalid index for VxMatrix::operator[].");
return *(reinterpret_cast<const VxVector4*>(m_Data) + i);
}
bool VxMatrix::operator==(const VxMatrix& rhs) const {
return ((*this)[0] == rhs[0] && (*this)[1] == rhs[1] && (*this)[2] == rhs[2] && (*this)[3] == rhs[3]);
}
auto VxMatrix::operator<=>(const VxMatrix& rhs) const {
if (auto cmp = (*this)[0] <=> rhs[0]; cmp != 0) return cmp;
if (auto cmp = (*this)[1] <=> rhs[1]; cmp != 0) return cmp;
if (auto cmp = (*this)[2] <=> rhs[2]; cmp != 0) return cmp;
return (*this)[3] <=> rhs[3];
}
/* ===== BEGIN USER CUSTOM ===== */
void VxMatrix::Clear() {
std::memset(m_Data, 0, sizeof(m_Data));
}
void VxMatrix::SetIdentity() {
Clear();
m_Data[0][0] = m_Data[1][1] = m_Data[2][2] = m_Data[3][3] = 1.0f;
}
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
void VxMatrix::Perspective(CKFLOAT Fov, CKFLOAT Aspect, CKFLOAT Near_plane, CKFLOAT Far_plane) {
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
Clear();
fix: fix linux build issue - use std::cos and std::sin instead of std::cosf and std::sinf. it seems that some linux environment do not have these 2 functions in std namespace.
2024-12-31 18:25:44 +08:00
m_Data[0][0] = std::cos(Fov * 0.5f) / std::sin(Fov * 0.5f);
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
m_Data[1][1] = m_Data[0][0] * Aspect;
m_Data[2][2] = Far_plane / (Far_plane - Near_plane);
m_Data[3][2] = -m_Data[2][2] * Near_plane;
m_Data[2][3] = 1;
}
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
void VxMatrix::PerspectiveRect(CKFLOAT Left, CKFLOAT Right, CKFLOAT Top, CKFLOAT Bottom, CKFLOAT Near_plane, CKFLOAT Far_plane) {
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
Clear();
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
CKFLOAT RL = 1.0f / (Right - Left);
CKFLOAT TB = 1.0f / (Top - Bottom);
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
m_Data[0][0] = 2.0f * Near_plane * RL;
m_Data[1][1] = 2.0f * Near_plane * TB;
m_Data[2][0] = -(Right + Left) * RL;
m_Data[2][1] = -(Top + Bottom) * TB;
m_Data[2][2] = Far_plane / (Far_plane - Near_plane);
m_Data[3][2] = -m_Data[2][2] * Near_plane;
m_Data[2][3] = 1;
}
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
void VxMatrix::Orthographic(CKFLOAT Zoom, CKFLOAT Aspect, CKFLOAT Near_plane, CKFLOAT Far_plane) {
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
Clear();
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
CKFLOAT iz = 1.0f / (Far_plane - Near_plane);
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
m_Data[0][0] = Zoom;
m_Data[1][1] = Zoom * Aspect;
m_Data[2][2] = iz;
m_Data[3][2] = -Near_plane * iz;
m_Data[3][3] = 1.0f;
}
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
void VxMatrix::OrthographicRect(CKFLOAT Left, CKFLOAT Right, CKFLOAT Top, CKFLOAT Bottom, CKFLOAT Near_plane, CKFLOAT Far_plane) {
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
Clear();
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
CKFLOAT ix = 1.0f / (Right - Left);
CKFLOAT iy = 1.0f / (Top - Bottom);
CKFLOAT iz = 1.0f / (Far_plane - Near_plane);
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
m_Data[0][0] = 2.0f * ix;
m_Data[1][1] = -2.0f * iy;
m_Data[2][2] = iz;
m_Data[3][0] = -(Left + Right) * ix;
m_Data[3][1] = (Top + Bottom) * iy;
m_Data[3][2] = -Near_plane * iz;
m_Data[3][3] = 1.0f;
}
/* ===== END USER CUSTOM ===== */
#pragma endregion
#pragma region Patched
namespace NSVxVector {
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
CKFLOAT DotProduct(const VxVector2& lhs, const VxVector2& rhs) {
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
return lhs * rhs;
}
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
CKFLOAT DotProduct(const VxVector3& lhs, const VxVector3& rhs) {
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
return lhs * rhs;
}
fix: fix 2 issues - rename float to CKFLOAT in VxMatrix. - move CKLightData struct to CKDefine.hpp because it not a private struct used by CKLight, but a CKRasterizer struct.
2024-12-25 08:28:42 +08:00
CKFLOAT DotProduct(const VxVector4& lhs, const VxVector4& rhs) {
refactor: refactor VxVector and its generator. - refactor VxVector-like struct. split their declaration and implementatio because their implementation is too long. and occupy too much space in header. - refactor VxVector struct generator. use jinja2 template engine, rather ran hand-written format string to make it is easy to read (although it still tough when first reading). - add unary operator overloading for VxVector-like struct. - add some VxMatrix functions which are essential to CKCamera. - rename VxMatrix::ResetToIdentity to VxMatrix::SetIdentity to make it same as original Virtools SDK. - the spaceship overloading with auto return value still may have bugs. please watch it carefully.
2024-12-24 16:49:34 +08:00
return lhs * rhs;
}
VxVector3 CrossProduct(const VxVector3& lhs, const VxVector3& rhs) {
return VxVector3(
lhs.y * rhs.z - lhs.z * rhs.y,
lhs.z * rhs.x - lhs.x * rhs.z,
lhs.x * rhs.y - lhs.y * rhs.x
);
}
void Absolute(VxVector3& lhs) {
lhs.x = std::fabs(lhs.x);
lhs.y = std::fabs(lhs.y);
lhs.z = std::fabs(lhs.z);
}
}
namespace NSVxMatrix {
}
#pragma endregion
}
Reference in New Issue Copy Permalink