700 lines
20 KiB
C++
700 lines
20 KiB
C++
#pragma once
|
|
|
|
#include "../VTUtils.hpp"
|
|
#include "../CK2/CKTypes.hpp"
|
|
#include "VxEnums.hpp"
|
|
#include <string>
|
|
#include <vector>
|
|
#include <cstring>
|
|
#include <cinttypes>
|
|
#include <cmath>
|
|
|
|
/**
|
|
* @brief The VxMath part of LibCmo.
|
|
* These classes are prefixed with Vx in original Virtools SDK.
|
|
*/
|
|
namespace LibCmo::VxMath {
|
|
|
|
// ========== Type Definition ==========
|
|
|
|
|
|
// ========== Class List ==========
|
|
// Important classes
|
|
|
|
class VxMemoryMappedFile;
|
|
|
|
// Misc
|
|
|
|
/**
|
|
* @brief The representation of a Vector in 2 dimensions.
|
|
* @see VxVector3
|
|
*/
|
|
struct VxVector2 {
|
|
CKFLOAT x, y;
|
|
VxVector2() : x(0.0f), y(0.0f) {}
|
|
VxVector2(CKFLOAT _x, CKFLOAT _y) : x(_x), y(_y) {}
|
|
YYCC_DEF_CLS_COPY_MOVE(VxVector2);
|
|
CKFLOAT& operator[](size_t i) {
|
|
switch (i) {
|
|
case 0: return x;
|
|
case 1: return y;
|
|
default: throw LogicException("Invalid index for VxVector2::operator[].");
|
|
}
|
|
}
|
|
const CKFLOAT& operator[](size_t i) const {
|
|
switch (i) {
|
|
case 0: return x;
|
|
case 1: return y;
|
|
default: throw LogicException("Invalid index for VxVector2::operator[].");
|
|
}
|
|
}
|
|
VxVector2& operator+=(const VxVector2& rhs) {
|
|
x += rhs.x;
|
|
y += rhs.y;
|
|
return *this;
|
|
}
|
|
friend VxVector2 operator+(const VxVector2& lhs, const VxVector2& rhs) {
|
|
return VxVector2(lhs.x + rhs.x, lhs.y + rhs.y);
|
|
}
|
|
VxVector2& operator-=(const VxVector2& rhs) {
|
|
x -= rhs.x;
|
|
y -= rhs.y;
|
|
return *this;
|
|
}
|
|
friend VxVector2 operator-(const VxVector2& lhs, const VxVector2& rhs) {
|
|
return VxVector2(lhs.x - rhs.x, lhs.y - rhs.y);
|
|
}
|
|
VxVector2& operator*=(CKFLOAT rhs) {
|
|
x *= rhs;
|
|
y *= rhs;
|
|
return *this;
|
|
}
|
|
friend VxVector2 operator*(const VxVector2& lhs, CKFLOAT rhs) {
|
|
return VxVector2(lhs.x * rhs, lhs.y * rhs);
|
|
}
|
|
friend VxVector2 operator*(CKFLOAT lhs, const VxVector2& rhs) {
|
|
return VxVector2(lhs * rhs.x, lhs * rhs.y);
|
|
}
|
|
friend CKFLOAT operator*(const VxVector2& lhs, const VxVector2& rhs) {
|
|
return (lhs.x * rhs.x + lhs.y * rhs.y);
|
|
}
|
|
VxVector2& operator/=(CKFLOAT rhs) {
|
|
if (rhs == 0.0f) return *this;
|
|
x /= rhs;
|
|
y /= rhs;
|
|
return *this;
|
|
}
|
|
friend VxVector2 operator/(const VxVector2& lhs, CKFLOAT rhs) {
|
|
if (rhs == 0.0f) return VxVector2(0.0f, 0.0f);
|
|
return VxVector2(lhs.x / rhs, lhs.y / rhs);
|
|
}
|
|
bool operator==(const VxVector2& rhs) const {
|
|
return (x == rhs.x && y == rhs.y);
|
|
}
|
|
auto operator<=>(const VxVector2& rhs) const {
|
|
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
|
|
return y <=> rhs.y;
|
|
}
|
|
CKFLOAT SquaredLength() const {
|
|
return (x * x + y * y);
|
|
}
|
|
CKFLOAT Length() const {
|
|
return std::sqrt(SquaredLength());
|
|
}
|
|
void Normalized() {
|
|
CKFLOAT len = Length();
|
|
if (len == 0.0f) return;
|
|
x /= len;
|
|
y /= len;
|
|
}
|
|
VxVector2 Normalize() const {
|
|
CKFLOAT len = Length();
|
|
if (len == 0.0f) return VxVector2();
|
|
return VxVector2(x / len, y / len);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief The representation of a Vector in 3 dimensions
|
|
*/
|
|
struct VxVector3 {
|
|
CKFLOAT x, y, z;
|
|
VxVector3() : x(0.0f), y(0.0f), z(0.0f) {}
|
|
VxVector3(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z) : x(_x), y(_y), z(_z) {}
|
|
YYCC_DEF_CLS_COPY_MOVE(VxVector3);
|
|
CKFLOAT& 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& 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[].");
|
|
}
|
|
}
|
|
VxVector3& operator+=(const VxVector3& rhs) {
|
|
x += rhs.x;
|
|
y += rhs.y;
|
|
z += rhs.z;
|
|
return *this;
|
|
}
|
|
friend VxVector3 operator+(const VxVector3& lhs, const VxVector3& rhs) {
|
|
return VxVector3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z);
|
|
}
|
|
VxVector3& operator-=(const VxVector3& rhs) {
|
|
x -= rhs.x;
|
|
y -= rhs.y;
|
|
z -= rhs.z;
|
|
return *this;
|
|
}
|
|
friend VxVector3 operator-(const VxVector3& lhs, const VxVector3& rhs) {
|
|
return VxVector3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);
|
|
}
|
|
VxVector3& operator*=(CKFLOAT rhs) {
|
|
x *= rhs;
|
|
y *= rhs;
|
|
z *= rhs;
|
|
return *this;
|
|
}
|
|
friend VxVector3 operator*(const VxVector3& lhs, CKFLOAT rhs) {
|
|
return VxVector3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs);
|
|
}
|
|
friend VxVector3 operator*(CKFLOAT lhs, const VxVector3& rhs) {
|
|
return VxVector3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
|
|
}
|
|
friend CKFLOAT operator*(const VxVector3& lhs, const VxVector3& rhs) {
|
|
return (lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z);
|
|
}
|
|
VxVector3& operator/=(CKFLOAT rhs) {
|
|
if (rhs == 0.0f) return *this;
|
|
x /= rhs;
|
|
y /= rhs;
|
|
z /= rhs;
|
|
return *this;
|
|
}
|
|
friend VxVector3 operator/(const VxVector3& lhs, CKFLOAT rhs) {
|
|
if (rhs == 0.0f) return VxVector3(0.0f, 0.0f, 0.0f);
|
|
return VxVector3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs);
|
|
}
|
|
bool operator==(const VxVector3& rhs) const {
|
|
return (x == rhs.x && y == rhs.y && z == rhs.z);
|
|
}
|
|
auto 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;
|
|
}
|
|
CKFLOAT SquaredLength() const {
|
|
return (x * x + y * y + z * z);
|
|
}
|
|
CKFLOAT Length() const {
|
|
return std::sqrt(SquaredLength());
|
|
}
|
|
void Normalized() {
|
|
CKFLOAT len = Length();
|
|
if (len == 0.0f) return;
|
|
x /= len;
|
|
y /= len;
|
|
z /= len;
|
|
}
|
|
VxVector3 Normalize() const {
|
|
CKFLOAT len = Length();
|
|
if (len == 0.0f) return VxVector3();
|
|
return VxVector3(x / len, y / len, z / len);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief The representation of a Vector of 4 elements (x, y, z, w)
|
|
* @details
|
|
* VxVector4 is used for 3D transformation when the w component is used for perspective information.
|
|
* Most of the methods available for a VxVector3 are also implemented for the VxVector4.
|
|
* @see VxVector3
|
|
*/
|
|
struct VxVector4 {
|
|
CKFLOAT x, y, z, w;
|
|
VxVector4() : x(0.0f), y(0.0f), z(0.0f), w(0.0f) {}
|
|
VxVector4(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {}
|
|
YYCC_DEF_CLS_COPY_MOVE(VxVector4);
|
|
CKFLOAT& 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& 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[].");
|
|
}
|
|
}
|
|
VxVector4& operator+=(const VxVector4& rhs) {
|
|
x += rhs.x;
|
|
y += rhs.y;
|
|
z += rhs.z;
|
|
w += rhs.w;
|
|
return *this;
|
|
}
|
|
friend 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& operator-=(const VxVector4& rhs) {
|
|
x -= rhs.x;
|
|
y -= rhs.y;
|
|
z -= rhs.z;
|
|
w -= rhs.w;
|
|
return *this;
|
|
}
|
|
friend 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& operator*=(CKFLOAT rhs) {
|
|
x *= rhs;
|
|
y *= rhs;
|
|
z *= rhs;
|
|
w *= rhs;
|
|
return *this;
|
|
}
|
|
friend VxVector4 operator*(const VxVector4& lhs, CKFLOAT rhs) {
|
|
return VxVector4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs);
|
|
}
|
|
friend VxVector4 operator*(CKFLOAT lhs, const VxVector4& rhs) {
|
|
return VxVector4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w);
|
|
}
|
|
friend 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& operator/=(CKFLOAT rhs) {
|
|
if (rhs == 0.0f) return *this;
|
|
x /= rhs;
|
|
y /= rhs;
|
|
z /= rhs;
|
|
w /= rhs;
|
|
return *this;
|
|
}
|
|
friend VxVector4 operator/(const VxVector4& lhs, CKFLOAT rhs) {
|
|
if (rhs == 0.0f) return VxVector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
return VxVector4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs);
|
|
}
|
|
bool operator==(const VxVector4& rhs) const {
|
|
return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w);
|
|
}
|
|
auto 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;
|
|
}
|
|
CKFLOAT SquaredLength() const {
|
|
return (x * x + y * y + z * z + w * w);
|
|
}
|
|
CKFLOAT Length() const {
|
|
return std::sqrt(SquaredLength());
|
|
}
|
|
void Normalized() {
|
|
CKFLOAT len = Length();
|
|
if (len == 0.0f) return;
|
|
x /= len;
|
|
y /= len;
|
|
z /= len;
|
|
w /= len;
|
|
}
|
|
VxVector4 Normalize() const {
|
|
CKFLOAT len = Length();
|
|
if (len == 0.0f) return VxVector4();
|
|
return VxVector4(x / len, y / len, z / len, w / len);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief The representation of a quaternion.
|
|
* @details
|
|
* A Quaternion is defined by 4 floats and is used to represents an orientation in space.
|
|
* Its common usage is for interpolation between two orientations through the Slerp() method.
|
|
*
|
|
* Quaternions can be converted to VxMatrix or Euler Angles.
|
|
* @see VxMatrix, VxVector3
|
|
*/
|
|
struct VxQuaternion {
|
|
CKFLOAT x, y, z, w;
|
|
VxQuaternion() : x(0.0f), y(0.0f), z(0.0f), w(1.0f) {} // set your custom init.
|
|
VxQuaternion(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {}
|
|
YYCC_DEF_CLS_COPY_MOVE(VxQuaternion);
|
|
CKFLOAT& 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& 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 operator==(const VxQuaternion& rhs) const {
|
|
return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w);
|
|
}
|
|
auto 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;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief The representation of a color through 4 floats.
|
|
* @details
|
|
* Structure describing a color through 4 floats for each component Red, Green, Blue and Alpha.
|
|
* And each factor should be clamped between \c 0.0f and \c 1.0f.
|
|
*
|
|
* Most methods are used to construct a VxColor or to convert it to a 32 bit ARGB format.
|
|
*/
|
|
struct VxColor {
|
|
CKFLOAT r, g, b, a;
|
|
VxColor() : r(0.0f), g(0.0f), b(0.0f), a(1.0f) {} // set your custom init.
|
|
VxColor(CKFLOAT _r, CKFLOAT _g, CKFLOAT _b, CKFLOAT _a) : r(_r), g(_g), b(_b), a(_a) {}
|
|
VxColor(CKDWORD argb) { FromARGB(argb); }
|
|
YYCC_DEF_CLS_COPY_MOVE(VxColor);
|
|
void 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 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 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;
|
|
}
|
|
CKFLOAT& 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& 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 operator==(const VxColor& rhs) const {
|
|
return (r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a);
|
|
}
|
|
auto 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;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief The representation of 4x4 matrix.
|
|
* @details
|
|
* A 4x4 matrix is defined by 4x4 floats and is used to represents the transformation in space.
|
|
* @see VxVector4, VxQuaternion
|
|
*/
|
|
struct VxMatrix {
|
|
private:
|
|
CKFLOAT m_Data[4][4];
|
|
public:
|
|
VxMatrix() : m_Data() { ResetToIdentity(); }
|
|
VxMatrix(CKFLOAT m[4][4]) : m_Data() { std::memcpy(m_Data, m, sizeof(m_Data)); }
|
|
YYCC_DEF_CLS_COPY_MOVE(VxMatrix);
|
|
void ResetToIdentity() {
|
|
std::memset(m_Data, 0, sizeof(m_Data));
|
|
m_Data[0][0] = m_Data[1][1] = m_Data[2][2] = m_Data[3][3] = 1.0f;
|
|
}
|
|
VxVector4& operator[](size_t i) {
|
|
if (i >= 4) throw LogicException("Invalid index for VxMatrix::operator[].");
|
|
return *(reinterpret_cast<VxVector4*>(m_Data) + i);
|
|
}
|
|
const VxVector4& operator[](size_t i) const {
|
|
if (i >= 4) throw LogicException("Invalid index for VxMatrix::operator[].");
|
|
return *(reinterpret_cast<const VxVector4*>(m_Data) + i);
|
|
}
|
|
bool operator==(const VxMatrix& rhs) const {
|
|
return std::memcmp(m_Data, rhs.m_Data, sizeof(m_Data)) == 0;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Structure for storage of strided data.
|
|
* @tparam _Ty The data pointer type this class stored.
|
|
*/
|
|
template<class _Ty, std::enable_if_t<std::is_pointer_v<_Ty>, int> = 0>
|
|
class VxStridedData {
|
|
public:
|
|
/**
|
|
* @brief Create a new viewer for strided data.
|
|
* @param[in] ptr The pointer to first data. nullptr is allowed but not suggested.
|
|
* @param[in] stride The stride between 2 adjacent data.
|
|
* If you set stride to the size of underlying type of pointer,
|
|
* this class will degenerate to the visitor of a plain data array.
|
|
*/
|
|
VxStridedData(_Ty ptr, CKDWORD stride) :
|
|
m_Ptr(reinterpret_cast<CKBYTE*>(ptr)),
|
|
m_Stride(stride) {}
|
|
~VxStridedData() {}
|
|
|
|
/**
|
|
* @brief Visitr n-th data with given stride.
|
|
* @param[in] idx N-th
|
|
* @return The pointer to n-th data.
|
|
*/
|
|
_Ty operator[](size_t idx) {
|
|
return reinterpret_cast<_Ty>(m_Ptr + (m_Stride * idx));
|
|
}
|
|
|
|
private:
|
|
CKBYTE* m_Ptr; /**< The pointer to first data. */
|
|
CKDWORD m_Stride; /**< The stride between adjacent data. */
|
|
};
|
|
|
|
/**
|
|
* @brief The description of image.
|
|
* @details
|
|
* VxImageDescEx describe the height, width, and etc for image.
|
|
* Also it hold a pointer to raw image data.
|
|
* The image data must be 32bit ARGB8888 format.
|
|
* Thus the size of Image must be 4 * Width * Height.
|
|
* And the image buffer must be in B, G, R, A order because little endian.
|
|
*/
|
|
class VxImageDescEx {
|
|
public:
|
|
static constexpr CKDWORD ColorFactorSize = 1u; /**< Single color factor (one of ARGB) occpied size in byte. */
|
|
static constexpr CKDWORD PixelSize = ColorFactorSize * 4u; /**< Single pixel occpied size in byte. */
|
|
public:
|
|
/**
|
|
* @brief Create a blank (invalid) image.
|
|
*/
|
|
VxImageDescEx() :
|
|
m_Width(0), m_Height(0), m_Image(nullptr) {}
|
|
/**
|
|
* @brief Create a image with given width and height.
|
|
* @param[in] width The width of image.
|
|
* @param[in] height The height of image.
|
|
*/
|
|
VxImageDescEx(CKDWORD width, CKDWORD height) :
|
|
m_Width(width), m_Height(height), m_Image(nullptr) {
|
|
CreateImage(width, height);
|
|
}
|
|
VxImageDescEx(const VxImageDescEx& rhs) :
|
|
m_Width(rhs.m_Width), m_Height(rhs.m_Height), m_Image(nullptr) {
|
|
// copy image
|
|
if (rhs.m_Image != nullptr) {
|
|
CreateImage(rhs.m_Width, rhs.m_Height, rhs.m_Image);
|
|
}
|
|
}
|
|
VxImageDescEx(VxImageDescEx&& rhs) :
|
|
m_Width(rhs.m_Width), m_Height(rhs.m_Height), m_Image(rhs.m_Image) {
|
|
// move image
|
|
rhs.m_Height = 0;
|
|
rhs.m_Width = 0;
|
|
rhs.m_Image = nullptr;
|
|
}
|
|
VxImageDescEx& operator=(const VxImageDescEx& rhs) {
|
|
FreeImage();
|
|
|
|
m_Width = rhs.m_Width;
|
|
m_Height = rhs.m_Height;
|
|
if (rhs.m_Image != nullptr) {
|
|
CreateImage(rhs.m_Width, rhs.m_Height, rhs.m_Image);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
VxImageDescEx& operator=(VxImageDescEx&& rhs) {
|
|
FreeImage();
|
|
|
|
m_Height = rhs.m_Height;
|
|
m_Width = rhs.m_Width;
|
|
m_Image = rhs.m_Image;
|
|
rhs.m_Height = 0;
|
|
rhs.m_Width = 0;
|
|
rhs.m_Image = nullptr;
|
|
|
|
return *this;
|
|
}
|
|
~VxImageDescEx() {
|
|
FreeImage();
|
|
}
|
|
|
|
/**
|
|
* @brief Create image with given width and height
|
|
* @param[in] Width The width of image.
|
|
* @param[in] Height The height of image.
|
|
* @remarks
|
|
* \li There is no initialization (fill with zero) for this new created image.
|
|
* \li Old image will be free first before creating.
|
|
*/
|
|
void CreateImage(CKDWORD Width, CKDWORD Height) {
|
|
FreeImage();
|
|
m_Width = Width;
|
|
m_Height = Height;
|
|
m_Image = new CKBYTE[GetImageSize()];
|
|
}
|
|
/**
|
|
* @brief Create image with given width, height and data.
|
|
* @param[in] Width The width of image.
|
|
* @param[in] Height The height of image.
|
|
* @param[in] dataptr The pointer to image data.
|
|
* @warning
|
|
* If the data length pointed by given image pointer is shorter than this image occupied,
|
|
* an undefined behavior is raised.
|
|
* @remarks Old image will be free first before creating.
|
|
*/
|
|
void CreateImage(CKDWORD Width, CKDWORD Height, const void* dataptr) {
|
|
CreateImage(Width, Height);
|
|
std::memcpy(m_Image, dataptr, GetImageSize());
|
|
}
|
|
/**
|
|
* @brief Free current image. Reset this to invalid status.
|
|
*/
|
|
void FreeImage() {
|
|
m_Width = 0;
|
|
m_Height = 0;
|
|
if (m_Image != nullptr) {
|
|
delete[] m_Image;
|
|
m_Image = nullptr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Get the allocated memory size of image.
|
|
* @return The allocated memory size of image.
|
|
* Basically it is image width * height * (single pixel size).
|
|
*/
|
|
CKDWORD GetImageSize() const {
|
|
return static_cast<CKDWORD>(PixelSize * m_Width * m_Height);
|
|
}
|
|
/**
|
|
* @brief Get a constant pointer to image in memory unit for viewing.
|
|
* @return A constant pointer to image in memory unit.
|
|
*/
|
|
const CKBYTE* GetImage() const {
|
|
return m_Image;
|
|
}
|
|
/**
|
|
* @brief Get a mutable pointer to image in memory unit for modifying.
|
|
* @return A mutable pointer to image in memory uint.
|
|
*/
|
|
CKBYTE* GetMutableImage() {
|
|
return m_Image;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the full count of pixel in image.
|
|
* @return The count of image. Basically it is image width * height.
|
|
*/
|
|
CKDWORD GetPixelCount() const {
|
|
return static_cast<CKDWORD>(m_Width * m_Height);
|
|
}
|
|
/**
|
|
* @brief Get a constant pointer to image in pixel unit for viewing.
|
|
* @return A constant pointer to image in pixel unit.
|
|
*/
|
|
const CKDWORD* GetPixels() const {
|
|
return reinterpret_cast<CKDWORD*>(m_Image);
|
|
}
|
|
/**
|
|
* @brief Get a mutable pointer to image in pixel uint for modifying.
|
|
* @return A mutable pointer to image in pixel uint.
|
|
*/
|
|
CKDWORD* GetMutablePixels() {
|
|
return reinterpret_cast<CKDWORD*>(m_Image);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the width of this image in pixel.
|
|
* @return The width of this image in pixel.
|
|
*/
|
|
CKDWORD GetWidth() const { return m_Width; }
|
|
/**
|
|
* @brief Get the height of this image in pixel.
|
|
* @return The height of this image in pixel.
|
|
*/
|
|
CKDWORD GetHeight() const { return m_Height; }
|
|
|
|
/**
|
|
* @brief Check whether this image is valid image for using.
|
|
* @details If one of width and height is zero, or underlying image pointer, this image is invalid.
|
|
* @return True if it is, otherwise false.
|
|
*/
|
|
bool IsValid() const {
|
|
return (m_Width != 0u && m_Height != 0u && m_Image != nullptr);
|
|
}
|
|
/**
|
|
* @brief Check whether the width and height of this image are equal to another image.
|
|
* @param[in] rhs Another image for comparing.
|
|
* @return True if their width and height are equal, otherwise false.
|
|
*/
|
|
bool IsHWEqual(const VxImageDescEx& rhs) const {
|
|
return (m_Width == rhs.m_Width && m_Height == rhs.m_Height);
|
|
}
|
|
// bool IsMaskEqual(const VxImageDescEx& rhs) const {
|
|
// return (
|
|
// m_RedMask == rhs.m_RedMask &&
|
|
// m_GreenMask == rhs.m_GreenMask &&
|
|
// m_BlueMask == rhs.m_BlueMask &&
|
|
// m_AlphaMask == rhs.m_AlphaMask
|
|
// );
|
|
// }
|
|
|
|
//public:
|
|
// CKDWORD m_RedMask;
|
|
// CKDWORD m_GreenMask;
|
|
// CKDWORD m_BlueMask;
|
|
// CKDWORD m_AlphaMask;
|
|
|
|
protected:
|
|
CKDWORD m_Width; /**< Width in pixel of the image */
|
|
CKDWORD m_Height; /**< Height in pixel of the image */
|
|
CKBYTE* m_Image; /**< A pointer points to current image in memory */
|
|
};
|
|
|
|
}
|