/////////////////////////////////////////////////////////////////////////////// // Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). // All rights reserved. // // This software and its documentation and related materials are owned by // the Alliance. The software may only be incorporated into application // programs owned by members of the Alliance, subject to a signed // Membership Agreement and Supplemental Software License Agreement with the // Alliance. The structure and organization of this software are the valuable // trade secrets of the Alliance and its suppliers. The software is also // protected by copyright law and international treaty provisions. Application // programs incorporating this software must include the following statement // with their copyright notices: // // This application incorporates Open Design Alliance software pursuant to a license // agreement with Open Design Alliance. // Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. // All rights reserved. // // By use of this software, its documentation or related materials, you // acknowledge and accept the above terms. /////////////////////////////////////////////////////////////////////////////// // Vector definition #ifndef ODTRVISVECTOR #define ODTRVISVECTOR #include "TD_PackPush.h" #include "Ge/GePoint2d.h" #include "Ge/GeVector2d.h" #include "Ge/GePoint3d.h" #include "Ge/GeVector3d.h" /** \details Library: Source code provided. */ template struct OdTrVisMiniVec2d { DataType x, y; typedef DataType EntryType; static bool eqTol(float val , float eps = 1.e-8f) { return (val < eps) && (val > -eps); } static bool eqTol(double val, double eps = 1.e-10) { return (val < eps) && (val > -eps); } // Constructors OdTrVisMiniVec2d() { } OdTrVisMiniVec2d(DataType _e) : x(_e), y(_e) { } OdTrVisMiniVec2d(DataType _x, DataType _y) : x(_x), y(_y) { } explicit OdTrVisMiniVec2d(const DataType *v) : x(v[0]), y(v[1]) { } OdTrVisMiniVec2d(const OdTrVisMiniVec2d &vec) = default; OdTrVisMiniVec2d(OdTrVisMiniVec2d &&vec) = default; template OdTrVisMiniVec2d(const VecType &vec) : x((DataType)vec.x), y((DataType)vec.y) { } // Setters OdTrVisMiniVec2d &set(DataType _e) { x = _e; y = _e; return *this; } OdTrVisMiniVec2d &set(DataType _x, DataType _y) { x = _x; y = _y; return *this; } OdTrVisMiniVec2d &set(const DataType *v) { x = v[0]; y = v[1]; return *this; } template OdTrVisMiniVec2d &set(const VecType &vec) { x = (DataType)vec.x; y = (DataType)vec.y; return *this; } OdTrVisMiniVec2d &operator =(const OdTrVisMiniVec2d &vec) = default; OdTrVisMiniVec2d &operator =(OdTrVisMiniVec2d &&vec) = default; // Getters DataType operator [](int nAxis) const { return (!nAxis) ? x : y; } DataType &operator [](int nAxis) { return (!nAxis) ? x : y; } const DataType *asArray() const { return &x; } DataType *asArray() { return &x; } // Comparators bool operator ==(const OdTrVisMiniVec2d &vec) const { return eqTol(x - vec.x) && eqTol(y - vec.y); } bool operator !=(const OdTrVisMiniVec2d &vec) const { return !eqTol(x - vec.x) || !eqTol(y - vec.y); } // Converters operator OdGePoint2d() const { return OdGePoint2d(x, y); } operator OdGeVector2d() const { return OdGeVector2d(x, y); } // Basic math operators OdTrVisMiniVec2d operator +(const OdTrVisMiniVec2d &vec) const { return OdTrVisMiniVec2d(x + vec.x, y + vec.y); } OdTrVisMiniVec2d &operator +=(const OdTrVisMiniVec2d &vec) { x += vec.x; y += vec.y; return *this; } OdTrVisMiniVec2d operator -(const OdTrVisMiniVec2d &vec) const { return OdTrVisMiniVec2d(x - vec.x, y - vec.y); } OdTrVisMiniVec2d &operator -=(const OdTrVisMiniVec2d &vec) { x -= vec.x; y -= vec.y; return *this; } // Dot/cross product DataType operator *(const OdTrVisMiniVec2d &vec) const { return x * vec.x + y * vec.y; } DataType operator ^(const OdTrVisMiniVec2d &vec) const { return x * vec.y - y * vec.x; } // Scale operators friend OdTrVisMiniVec2d operator *(const OdTrVisMiniVec2d &vec, DataType val) { return OdTrVisMiniVec2d(vec.x * val, vec.y * val); } friend OdTrVisMiniVec2d operator *(DataType val, const OdTrVisMiniVec2d &vec) { return OdTrVisMiniVec2d(val * vec.x, val * vec.y); } OdTrVisMiniVec2d &operator *=(DataType val) { x *= val; y *= val; return *this; } friend OdTrVisMiniVec2d operator /(const OdTrVisMiniVec2d &vec, DataType val) { const DataType invVal = DataType(1) / val; return OdTrVisMiniVec2d(vec.x * invVal, vec.y * invVal); } friend OdTrVisMiniVec2d operator /(DataType val, const OdTrVisMiniVec2d &vec) { return OdTrVisMiniVec2d(val / vec.x, val / vec.y); } OdTrVisMiniVec2d &operator /=(DataType val) { const DataType invVal = DataType(1) / val; x *= invVal; y *= invVal; return *this; } // Negate operator OdTrVisMiniVec2d operator -() const { return OdTrVisMiniVec2d(-x, -y); } OdTrVisMiniVec2d &negate() { x = -x; y = -y; return *this; } // Component-wise operators OdTrVisMiniVec2d mul(const OdTrVisMiniVec2d &vec) const { return OdTrVisMiniVec2d(x * vec.x, y * vec.y); } OdTrVisMiniVec2d &setMul(const OdTrVisMiniVec2d &vec) const { x *= vec.x; y *= vec.y; return *this; } OdTrVisMiniVec2d div(const OdTrVisMiniVec2d &vec) const { return OdTrVisMiniVec2d(x / vec.x, y / vec.y); } OdTrVisMiniVec2d &setDiv(const OdTrVisMiniVec2d &vec) const { x /= vec.x; y /= vec.y; return *this; } // Null operator OdTrVisMiniVec2d &setNull() { x = y = 0.0f; return *this; } bool isNull(DataType eps = 1.e-8f) const { return eqTol(x, eps) && eqTol(y, eps); } // Length operator DataType length2() const { return x * x + y * y; } DataType length() const { return (DataType)sqrt(length2()); } // Normalization OdTrVisMiniVec2d operator ~() const { return OdTrVisMiniVec2d(*this).normalize(); } OdTrVisMiniVec2d &normalize(DataType eps = 1.e-8f) { const DataType rd = length(); if (eqTol(rd, eps)) setNull(); else *this /= rd; return *this; } DataType normalizeLength(DataType eps = 1.e-8f) { const DataType rd = length(); if (eqTol(rd, eps)) { setNull(); return 0.0f; } *this /= rd; return rd; } // Min/max operators DataType minimum() const { return odmin(x, y); } DataType maximum() const { return odmax(x, y); } // Perpendicular OdTrVisMiniVec2d perp() const { return OdTrVisMiniVec2d(-y, x); } void perp(OdTrVisMiniVec2d &v) const { v.set(-y, x); } // Rotation OdTrVisMiniVec2d rotate(DataType angle) const { const DataType cosA = cos(angle), sinA = sin(angle); return OdTrVisMiniVec2d(x * cosA - y * sinA, x * sinA + y * cosA); } }; /** \details Library: Source code provided. */ template struct OdTrVisMiniVec3d : public OdTrVisMiniVec2d { DataType z; typedef OdTrVisMiniVec2d BaseVec; // Constructors OdTrVisMiniVec3d() { } OdTrVisMiniVec3d(DataType _e) : OdTrVisMiniVec2d(_e), z(_e) { } OdTrVisMiniVec3d(DataType _x, DataType _y, DataType _z = 0.0f) : OdTrVisMiniVec2d(_x, _y), z(_z) { } OdTrVisMiniVec3d(const BaseVec &xy, DataType _z = 0.0f) : OdTrVisMiniVec2d(xy), z(_z) { } explicit OdTrVisMiniVec3d(const DataType *v) : OdTrVisMiniVec2d(v[0], v[1]), z(v[2]) { } OdTrVisMiniVec3d(const OdTrVisMiniVec3d &vec) = default; OdTrVisMiniVec3d(OdTrVisMiniVec3d &&vec) = default; template OdTrVisMiniVec3d(const VecType &vec) : OdTrVisMiniVec2d((DataType)vec.x, (DataType)vec.y), z((DataType)vec.z) { } // Setters OdTrVisMiniVec3d &set(DataType _e) { BaseVec::x = _e; BaseVec::y = _e; z = _e; return *this; } OdTrVisMiniVec3d &set(DataType _x, DataType _y, DataType _z = 0.0f) { BaseVec::x = _x; BaseVec::y = _y; z = _z; return *this; } OdTrVisMiniVec3d &set(const BaseVec &xy, DataType _z) { BaseVec::x = xy.x; BaseVec::y = xy.y; z = _z; return *this; } OdTrVisMiniVec3d &set(const DataType *v) { BaseVec::x = v[0]; BaseVec::y = v[1]; z = v[2]; return *this; } template OdTrVisMiniVec3d &set(const VecType &vec) { BaseVec::x = (DataType)vec.x; BaseVec::y = (DataType)vec.y; z = (DataType)vec.z; return *this; } OdTrVisMiniVec3d &operator =(const OdTrVisMiniVec3d &vec) = default; OdTrVisMiniVec3d &operator =(OdTrVisMiniVec3d &&vec) = default; // Getters DataType operator [](int nAxis) const { return (!nAxis) ? BaseVec::x : ((nAxis > 1) ? z : BaseVec::y); } DataType &operator [](int nAxis) { return (!nAxis) ? BaseVec::x : ((nAxis > 1) ? z : BaseVec::y); } // Comparators bool operator ==(const OdTrVisMiniVec3d &vec) const { return BaseVec::eqTol(BaseVec::x - vec.x) && BaseVec::eqTol(BaseVec::y - vec.y) && BaseVec::eqTol(z - vec.z); } bool operator !=(const OdTrVisMiniVec3d &vec) const { return !BaseVec::eqTol(BaseVec::x - vec.x) || !BaseVec::eqTol(BaseVec::y - vec.y) || !BaseVec::eqTol(z - vec.z); } // Converters operator OdGePoint3d() const { return OdGePoint3d(BaseVec::x, BaseVec::y, z); } operator OdGeVector3d() const { return OdGeVector3d(BaseVec::x, BaseVec::y, z); } BaseVec &as2d() { return *this; } const BaseVec &as2d() const { return *this; } // Basic math operators OdTrVisMiniVec3d operator +(const OdTrVisMiniVec3d &vec) const { return OdTrVisMiniVec3d(BaseVec::x + vec.x, BaseVec::y + vec.y, z + vec.z); } OdTrVisMiniVec3d &operator +=(const OdTrVisMiniVec3d &vec) { BaseVec::x += vec.x; BaseVec::y += vec.y; z += vec.z; return *this; } OdTrVisMiniVec3d operator -(const OdTrVisMiniVec3d &vec) const { return OdTrVisMiniVec3d(BaseVec::x - vec.x, BaseVec::y - vec.y, z - vec.z); } OdTrVisMiniVec3d &operator -=(const OdTrVisMiniVec3d &vec) { BaseVec::x -= vec.x; BaseVec::y -= vec.y; z -= vec.z; return *this; } // Dot/cross product DataType operator *(const OdTrVisMiniVec3d &vec) const { return BaseVec::x * vec.x + BaseVec::y * vec.y + z * vec.z; } OdTrVisMiniVec3d operator ^(const OdTrVisMiniVec3d &vec) const { return OdTrVisMiniVec3d(BaseVec::y * vec.z - z * vec.y, z * vec.x - BaseVec::x * vec.z, BaseVec::x * vec.y - BaseVec::y * vec.x); } // Scale operators friend OdTrVisMiniVec3d operator *(const OdTrVisMiniVec3d &vec, DataType val) { return OdTrVisMiniVec3d(vec.x * val, vec.y * val, vec.z * val); } friend OdTrVisMiniVec3d operator *(DataType val, const OdTrVisMiniVec3d &vec) { return OdTrVisMiniVec3d(val * vec.x, val * vec.y, val * vec.z); } OdTrVisMiniVec3d &operator *=(DataType val) { BaseVec::x *= val; BaseVec::y *= val; z *= val; return *this; } friend OdTrVisMiniVec3d operator /(const OdTrVisMiniVec3d &vec, DataType val) { const DataType invVal = DataType(1) / val; return OdTrVisMiniVec3d(vec.x * invVal, vec.y * invVal, vec.z * invVal); } friend OdTrVisMiniVec3d operator /(DataType val, const OdTrVisMiniVec3d &vec) { return OdTrVisMiniVec3d(val / vec.x, val / vec.y, val / vec.z); } OdTrVisMiniVec3d &operator /=(DataType val) { const DataType invVal = DataType(1) / val; BaseVec::x *= invVal; BaseVec::y *= invVal; z *= invVal; return *this; } // Negate operator OdTrVisMiniVec3d operator -() const { return OdTrVisMiniVec3d(-BaseVec::x, -BaseVec::y, -z); } OdTrVisMiniVec3d &negate() { BaseVec::x = -BaseVec::x; BaseVec::y = -BaseVec::y; z = -z; return *this; } // Component-wise operators OdTrVisMiniVec3d mul(const OdTrVisMiniVec3d &vec) const { return OdTrVisMiniVec3d(BaseVec::x * vec.x, BaseVec::y * vec.y, z * vec.z); } OdTrVisMiniVec3d &setMul(const OdTrVisMiniVec3d &vec) const { BaseVec::x *= vec.x; BaseVec::y *= vec.y; z *= vec.z; return *this; } OdTrVisMiniVec3d div(const OdTrVisMiniVec3d &vec) const { return OdTrVisMiniVec3d(BaseVec::x / vec.x, BaseVec::y / vec.y, z / vec.z); } OdTrVisMiniVec3d &setDiv(const OdTrVisMiniVec3d &vec) const { BaseVec::x /= vec.x; BaseVec::y /= vec.y; z /= vec.z; return *this; } // Null operator OdTrVisMiniVec3d &setNull() { BaseVec::x = BaseVec::y = z = 0.0f; return *this; } bool isNull(DataType eps = 1.e-8f) const { return BaseVec::eqTol(BaseVec::x, eps) && BaseVec::eqTol(BaseVec::y, eps) && BaseVec::eqTol(z, eps); } // Length operator DataType length2() const { return BaseVec::x * BaseVec::x + BaseVec::y * BaseVec::y + z * z; } DataType length() const { return (DataType)sqrt(length2()); } // Normalization OdTrVisMiniVec3d operator ~() const { return OdTrVisMiniVec3d(*this).normalize(); } OdTrVisMiniVec3d &normalize(DataType eps = 1.e-8f) { const DataType rd = length(); if (BaseVec::eqTol(rd, eps)) setNull(); else *this /= rd; return *this; } DataType normalizeLength(DataType eps = 1.e-8f) { const DataType rd = length(); if (BaseVec::eqTol(rd, eps)) { setNull(); return 0.0f; } *this /= rd; return rd; } // Min/max operators DataType minimum() const { return odmin(BaseVec::x, odmin(BaseVec::y, z)); } DataType maximum() const { return odmax(BaseVec::x, odmax(BaseVec::y, z)); } // Perpendicular OdTrVisMiniVec3d perp() const { struct eps { static float val(float) { return -0.9999999f; } static double val(double) { return -1.e-10; } }; // frisvad method if (z < eps::val(z)) // Handle the singularity return OdTrVisMiniVec3d(0.0f, -1.0f, 0.0f); const DataType a = DataType(1.0f) / (DataType(1.0f) + z); return OdTrVisMiniVec3d(DataType(1.0f) - BaseVec::x * BaseVec::x * a, -BaseVec::x * BaseVec::y * a, -BaseVec::x); } void perp(OdTrVisMiniVec3d &v1, OdTrVisMiniVec3d &v2) const { struct eps { static float val(float) { return -0.9999999f; } static double val(double) { return -1.e-10; } }; // frisvad method if (z < eps::val(z)) { // Handle the singularity v1.set(0.0f, -1.0f, 0.0f); v2.set(-1.0f, 0.0f, 0.0f); return; } const DataType a = DataType(1.0f) / (DataType(1.0f) + z); const DataType b = -BaseVec::x * BaseVec::y * a; v1.set(DataType(1.0f) - BaseVec::x * BaseVec::x * a, b, -BaseVec::x); v2.set(b, DataType(1.0f) - BaseVec::y * BaseVec::y * a, -BaseVec::y); } // Rotation OdTrVisMiniVec3d rotate(DataType angle, const OdTrVisMiniVec3d &n) const { const DataType cosA = cos(angle), sinA = sin(angle); return *this * cosA + ((n ^ *this) * sinA) + n * ((n * *this) * (1 - cosA)); } // Reflection vector OdTrVisMiniVec3d &reflect(const OdTrVisMiniVec3d &n) //{ return *this = (*this * (-2.0f * (*this * n))).mul(n) + *this; } { return *this = *this - (2.0f * (*this * n) * n); } // Refraction vector bool refract(const OdTrVisMiniVec3d &n, DataType eta, DataType eps = 1.e-8f) { const DataType idot = *this * n; const DataType k = DataType(1.0) - eta * eta * odmax(DataType(0.0), DataType(1.0) - idot * idot); if (k < eps) { //setNull(); return false; } *this = *this * eta - (n * (eta * idot + (DataType)sqrt(k))); return true; } // Faceforward implementation OdTrVisMiniVec3d &faceforward(const OdTrVisMiniVec3d &i, const OdTrVisMiniVec3d &ng) { return ((i * ng) < 0.0f) ? *this : negate(); } OdTrVisMiniVec3d &faceforward(bool bIsFrontFace) { return (bIsFrontFace) ? *this : negate(); } }; /** \details Library: Source code provided. */ template struct OdTrVisMiniVec4d : public OdTrVisMiniVec3d { DataType w; typedef OdTrVisMiniVec3d BaseVec; typedef OD_TYPENAME BaseVec::BaseVec BaseOfBaseVec; OdTrVisMiniVec4d() { } OdTrVisMiniVec4d(DataType _e) : OdTrVisMiniVec3d(_e), w(_e) { } OdTrVisMiniVec4d(DataType _x, DataType _y, DataType _z = 0.0f, DataType _w = 0.0f) : OdTrVisMiniVec3d(_x, _y, _z), w(_w) { } OdTrVisMiniVec4d(const BaseVec &xyz, DataType _w = 0.0f) : OdTrVisMiniVec3d(xyz), w(_w) { } OdTrVisMiniVec4d(const BaseOfBaseVec &xy, DataType _z = 0.0f, DataType _w = 0.0f) : OdTrVisMiniVec3d(xy, _z), w(_w) { } OdTrVisMiniVec4d(const BaseOfBaseVec &xy, const BaseOfBaseVec &zw) : OdTrVisMiniVec3d(xy, zw.x), w(zw.y) { } explicit OdTrVisMiniVec4d(const DataType *v) : OdTrVisMiniVec3d(v[0], v[1], v[2]), w(v[3]) { } OdTrVisMiniVec4d(const OdTrVisMiniVec4d &vec) = default; OdTrVisMiniVec4d(OdTrVisMiniVec4d &&vec) = default; template OdTrVisMiniVec4d(const VecType &vec) : OdTrVisMiniVec3d((DataType)vec.x, (DataType)vec.y, (DataType)vec.z), w((DataType)vec.w) { } // Setters OdTrVisMiniVec4d &set(DataType _e) { BaseOfBaseVec::x = _e; BaseOfBaseVec::y = _e; BaseVec::z = _e; w = _e; return *this; } OdTrVisMiniVec4d &set(DataType _x, DataType _y, DataType _z = 0.0f, DataType _w = 0.0f) { BaseOfBaseVec::x = _x; BaseOfBaseVec::y = _y; BaseVec::z = _z; w = _w; return *this; } OdTrVisMiniVec4d &set(const BaseVec &xyz, DataType _w = 0.0f) { BaseOfBaseVec::x = xyz.x; BaseOfBaseVec::y = xyz.y; BaseVec::z = xyz.z; w = _w; return *this; } OdTrVisMiniVec4d &set(const BaseOfBaseVec &xy, DataType _z = 0.0f, DataType _w = 0.0f) { BaseOfBaseVec::x = xy.x; BaseOfBaseVec::y = xy.y; BaseVec::z = _z; w = _w; return *this; } OdTrVisMiniVec4d &set(const DataType *v) { BaseOfBaseVec::x = v[0]; BaseOfBaseVec::y = v[1]; BaseVec::z = v[2]; w = v[3]; return *this; } template OdTrVisMiniVec4d &set(const VecType &vec) { BaseOfBaseVec::x = (DataType)vec.x; BaseOfBaseVec::y = (DataType)vec.y; BaseVec::z = (DataType)vec.z; w = (DataType)vec.w; return *this; } OdTrVisMiniVec4d &operator =(const OdTrVisMiniVec4d &vec) = default; OdTrVisMiniVec4d &operator =(OdTrVisMiniVec4d &&vec) = default; // Getters DataType operator [](int nAxis) const { switch (nAxis) { case 0: return BaseOfBaseVec::x; case 1: return BaseOfBaseVec::y; case 2: return BaseVec::z; default: return w; } } DataType &operator [](int nAxis) { switch (nAxis) { case 0: return BaseOfBaseVec::x; case 1: return BaseOfBaseVec::y; case 2: return BaseVec::z; default: return w; } } // Comparators bool operator ==(const OdTrVisMiniVec4d &vec) const { return BaseOfBaseVec::eqTol(BaseOfBaseVec::x - vec.x) && BaseOfBaseVec::eqTol(BaseOfBaseVec::y - vec.y) && BaseOfBaseVec::eqTol(BaseVec::z - vec.z) && BaseOfBaseVec::eqTol(w - vec.w); } bool operator !=(const OdTrVisMiniVec4d &vec) const { return !BaseOfBaseVec::eqTol(BaseOfBaseVec::x - vec.x) || !BaseOfBaseVec::eqTol(BaseOfBaseVec::y - vec.y) || !BaseOfBaseVec::eqTol(BaseVec::z - vec.z) || !BaseOfBaseVec::eqTol(w - vec.w); } // Converters BaseVec &as3d() { return *this; } const BaseVec &as3d() const { return *this; } // Basic math operators OdTrVisMiniVec4d operator +(const OdTrVisMiniVec4d &vec) const { return OdTrVisMiniVec4d(BaseOfBaseVec::x + vec.x, BaseOfBaseVec::y + vec.y, BaseVec::z + vec.z, w + vec.w); } OdTrVisMiniVec4d &operator +=(const OdTrVisMiniVec4d &vec) { BaseOfBaseVec::x += vec.x; BaseOfBaseVec::y += vec.y; BaseVec::z -= vec.z; w += vec.w; return *this; } OdTrVisMiniVec4d operator -(const OdTrVisMiniVec4d &vec) const { return OdTrVisMiniVec4d(BaseOfBaseVec::x - vec.x, BaseOfBaseVec::y - vec.y, BaseVec::z - vec.z, w - vec.w); } OdTrVisMiniVec4d &operator -=(const OdTrVisMiniVec4d &vec) { BaseOfBaseVec::x -= vec.x; BaseOfBaseVec::y -= vec.y; BaseVec::z -= vec.z; w -= vec.w; return *this; } // Scale operators friend OdTrVisMiniVec4d operator *(const OdTrVisMiniVec4d &vec, DataType val) { return OdTrVisMiniVec4d(vec.x * val, vec.y * val, vec.z * val, vec.w * val); } friend OdTrVisMiniVec4d operator *(DataType val, const OdTrVisMiniVec4d &vec) { return OdTrVisMiniVec4d(val * vec.x, val * vec.y, val * vec.z, val * vec.w); } OdTrVisMiniVec4d &operator *=(DataType val) { BaseOfBaseVec::x *= val; BaseOfBaseVec::y *= val; BaseVec::z *= val; w *= val; return *this; } friend OdTrVisMiniVec4d operator /(const OdTrVisMiniVec4d &vec, DataType val) { const DataType invVal = DataType(1) / val; return OdTrVisMiniVec4d(vec.x * invVal, vec.y * invVal, vec.z * invVal, vec.w * invVal); } friend OdTrVisMiniVec4d operator /(DataType val, const OdTrVisMiniVec4d &vec) { return OdTrVisMiniVec4d(val / vec.x, val / vec.y, val / vec.z, val / vec.w); } OdTrVisMiniVec4d &operator /=(DataType val) { const DataType invVal = DataType(1) / val; BaseOfBaseVec::x *= invVal; BaseOfBaseVec::y *= invVal; BaseVec::z *= invVal; w *= invVal; return *this; } // Negate operator OdTrVisMiniVec4d operator -() const { return OdTrVisMiniVec4d(-BaseOfBaseVec::x, -BaseOfBaseVec::y, -BaseVec::z, -w); } OdTrVisMiniVec4d &negate() { BaseOfBaseVec::x = -BaseOfBaseVec::x; BaseOfBaseVec::y = -BaseOfBaseVec::y; BaseVec::z = -BaseVec::z; w = -w; return *this; } // Component-wise operators OdTrVisMiniVec4d mul(const OdTrVisMiniVec4d &vec) const { return OdTrVisMiniVec4d(BaseOfBaseVec::x * vec.x, BaseOfBaseVec::y * vec.y, BaseVec::z * vec.z, w * vec.w); } OdTrVisMiniVec4d &setMul(const OdTrVisMiniVec4d &vec) const { BaseOfBaseVec::x *= vec.x; BaseOfBaseVec::y *= vec.y; BaseVec::z *= vec.z; w *= vec.w; return *this; } OdTrVisMiniVec4d div(const OdTrVisMiniVec4d &vec) const { return OdTrVisMiniVec4d(BaseOfBaseVec::x / vec.x, BaseOfBaseVec::y / vec.y, BaseVec::z / vec.z, w / vec.w); } OdTrVisMiniVec4d &setDiv(const OdTrVisMiniVec4d &vec) const { BaseOfBaseVec::x /= vec.x; BaseOfBaseVec::y /= vec.y; BaseVec::z /= vec.z; w /= vec.w; return *this; } // Null operator OdTrVisMiniVec4d &setNull() { BaseOfBaseVec::x = BaseOfBaseVec::y = BaseVec::z = w = 0.0f; return *this; } bool isNull(DataType eps = 1.e-8f) const { return BaseOfBaseVec::eqTol(BaseOfBaseVec::x, eps) && BaseOfBaseVec::eqTol(BaseOfBaseVec::y, eps) && BaseOfBaseVec::eqTol(BaseVec::z, eps) && BaseOfBaseVec::eqTol(w, eps); } // Identity vector OdTrVisMiniVec4d &setIdentity() { BaseOfBaseVec::x = BaseOfBaseVec::y = BaseVec::z = 0.0f; w = 1.0f; return *this; } // Min/max operators DataType minimum() const { return odmin(odmin(BaseOfBaseVec::x, BaseOfBaseVec::y), odmin(BaseVec::z, w)); } DataType maximum() const { return odmax(odmax(BaseOfBaseVec::x, BaseOfBaseVec::y), odmax(BaseVec::z, w)); } }; // Type definitions. typedef OdTrVisMiniVec2d OdTrVisVector2df; typedef OdTrVisMiniVec2d OdTrVisVector2dd; typedef OdTrVisMiniVec3d OdTrVisVector3df; typedef OdTrVisMiniVec3d OdTrVisVector3dd; typedef OdTrVisMiniVec4d OdTrVisVector4df; typedef OdTrVisMiniVec4d OdTrVisVector4dd; // Current main matrix definition. typedef OdTrVisVector2df OdTrVisVector2d; typedef OdTrVisVector3df OdTrVisVector; #include "TD_PackPop.h" #endif // ODTRVISVECTOR