4#ifndef OPENVDB_MATH_MAT4_H_HAS_BEEN_INCLUDED 
    5#define OPENVDB_MATH_MAT4_H_HAS_BEEN_INCLUDED 
   24template<
typename T> 
class Vec4;
 
   50    template<
typename Source>
 
   53        for (
int i = 0; i < 16; i++) {
 
 
   65    template<
typename Source>
 
   66    Mat4(Source a, Source b, Source c, Source d,
 
   67         Source e, Source f, Source g, Source h,
 
   68         Source i, Source j, Source k, Source l,
 
   69         Source m, Source n, Source o, Source p)
 
 
   94    template<
typename Source>
 
  106    template<
typename Source>
 
  111        for (
int i=0; i<16; ++i) {
 
 
  153        return Vec4<T>((*
this)(i,0), (*
this)(i,1), (*
this)(i,2), (*
this)(i,3));
 
 
  170        return Vec4<T>((*
this)(0,j), (*
this)(1,j), (*
this)(2,j), (*
this)(3,j));
 
 
  292        for (
int i = 0; i < 3; i++)
 
  293            for (
int j=0; j < 3; j++)
 
 
  301        for (
int i = 0; i < 3; i++)
 
  302            for (
int j = 0; j < 3; j++)
 
 
  322    template<
typename Source>
 
  333    bool eq(
const Mat4 &m, T eps=1.0e-8)
 const 
  335        for (
int i = 0; i < 16; i++) {
 
 
  354    template <
typename S>
 
  380    template <
typename S>
 
  409    template <
typename S>
 
  438    template <
typename S>
 
  446        for (
int i = 0; i < 4; i++) {
 
  448            MyBase::mm[i4+0] = 
static_cast<T
>(s0[i4+0] * s1[ 0] +
 
  453            MyBase::mm[i4+1] = 
static_cast<T
>(s0[i4+0] * s1[ 1] +
 
  458            MyBase::mm[i4+2] = 
static_cast<T
>(s0[i4+0] * s1[ 2] +
 
  463            MyBase::mm[i4+3] = 
static_cast<T
>(s0[i4+0] * s1[ 3] +
 
 
  508        T m0011 = m[0][0] * m[1][1];
 
  509        T m0012 = m[0][0] * m[1][2];
 
  510        T m0110 = m[0][1] * m[1][0];
 
  511        T m0210 = m[0][2] * m[1][0];
 
  512        T m0120 = m[0][1] * m[2][0];
 
  513        T m0220 = m[0][2] * m[2][0];
 
  515        T detA = m0011 * m[2][2] - m0012 * m[2][1] - m0110 * m[2][2]
 
  516               + m0210 * m[2][1] + m0120 * m[1][2] - m0220 * m[1][1];
 
  518        bool hasPerspective =
 
  525        if (hasPerspective) {
 
  526            det = m[0][3] * det3(m, 1,2,3, 0,2,1)
 
  527                + m[1][3] * det3(m, 2,0,3, 0,2,1)
 
  528                + m[2][3] * det3(m, 3,0,1, 0,2,1)
 
  531            det = detA * m[3][3];
 
  542            invertible = m.invert(inv, tolerance);
 
  551            inv[0][0] = detA * ( m[1][1] * m[2][2] - m[1][2] * m[2][1]);
 
  552            inv[0][1] = detA * (-m[0][1] * m[2][2] + m[0][2] * m[2][1]);
 
  553            inv[0][2] = detA * ( m[0][1] * m[1][2] - m[0][2] * m[1][1]);
 
  555            inv[1][0] = detA * (-m[1][0] * m[2][2] + m[1][2] * m[2][0]);
 
  556            inv[1][1] = detA * ( m[0][0] * m[2][2] - m0220);
 
  557            inv[1][2] = detA * ( m0210   - m0012);
 
  559            inv[2][0] = detA * ( m[1][0] * m[2][1] - m[1][1] * m[2][0]);
 
  560            inv[2][1] = detA * ( m0120 - m[0][0] * m[2][1]);
 
  561            inv[2][2] = detA * ( m0011 - m0110);
 
  563            if (hasPerspective) {
 
  568                r[0] = m[3][0] * inv[0][0] + m[3][1] * inv[1][0]
 
  569                     + m[3][2] * inv[2][0];
 
  570                r[1] = m[3][0] * inv[0][1] + m[3][1] * inv[1][1]
 
  571                     + m[3][2] * inv[2][1];
 
  572                r[2] = m[3][0] * inv[0][2] + m[3][1] * inv[1][2]
 
  573                     + m[3][2] * inv[2][2];
 
  576                p[0] = inv[0][0] * m[0][3] + inv[0][1] * m[1][3]
 
  577                     + inv[0][2] * m[2][3];
 
  578                p[1] = inv[1][0] * m[0][3] + inv[1][1] * m[1][3]
 
  579                     + inv[1][2] * m[2][3];
 
  580                p[2] = inv[2][0] * m[0][3] + inv[2][1] * m[1][3]
 
  581                     + inv[2][2] * m[2][3];
 
  583                T h = m[3][3] - p.
dot(
Vec3<T>(m[3][0],m[3][1],m[3][2]));
 
  594                    inv[3][0] = -h * r[0];
 
  595                    inv[3][1] = -h * r[1];
 
  596                    inv[3][2] = -h * r[2];
 
  598                    inv[0][3] = -h * p[0];
 
  599                    inv[1][3] = -h * p[1];
 
  600                    inv[2][3] = -h * p[2];
 
  606                    inv[0][0] += p[0] * r[0];
 
  607                    inv[0][1] += p[0] * r[1];
 
  608                    inv[0][2] += p[0] * r[2];
 
  609                    inv[1][0] += p[1] * r[0];
 
  610                    inv[1][1] += p[1] * r[1];
 
  611                    inv[1][2] += p[1] * r[2];
 
  612                    inv[2][0] += p[2] * r[0];
 
  613                    inv[2][1] += p[2] * r[1];
 
  614                    inv[2][2] += p[2] * r[2];
 
  618                inv[3][0] = - (m[3][0] * inv[0][0] + m[3][1] * inv[1][0]
 
  619                                + m[3][2] * inv[2][0]);
 
  620                inv[3][1] = - (m[3][0] * inv[0][1] + m[3][1] * inv[1][1]
 
  621                                + m[3][2] * inv[2][1]);
 
  622                inv[3][2] = - (m[3][0] * inv[0][2] + m[3][1] * inv[1][2]
 
  623                                + m[3][2] * inv[2][2]);
 
 
  647        for (i = 0; i < 4; i++) {
 
  650            for (j = 0; j < 4; j++) {
 
  651                for (k = 0; k < 4; k++) {
 
  652                    if ((k != i) && (j != 0)) {
 
 
  670            T(1),     T(0),    T(0),     T(0),
 
  671            T(0),     T(1),    T(0),     T(0),
 
  672            T(0),     T(0),    T(1),     T(0),
 
  673            T(v.
x()), T(v.
y()),T(v.
z()), T(1));
 
 
  677    template <
typename T0>
 
  702    template <
typename T0>
 
  708        *
this =  Tr * (*this);
 
 
  713    template <
typename T0>
 
  719        *
this = (*this) * Tr;
 
 
  725    template <
typename T0>
 
  735    template <
typename T0>
 
  757    template <
typename T0>
 
  801        T c = 
static_cast<T
>(cos(
angle));
 
  802        T s = -
static_cast<T
>(sin(
angle)); 
 
 
  882        T c = 
static_cast<T
>(cos(
angle));
 
  883        T s = -
static_cast<T
>(sin(
angle)); 
 
 
  971        int index0 = 
static_cast<int>(axis0);
 
  972        int index1 = 
static_cast<int>(axis1);
 
 
  986        int index0 = 
static_cast<int>(axis0);
 
  987        int index1 = 
static_cast<int>(axis1);
 
 
  998    template<
typename T0>
 
 1001        return static_cast< Vec4<T0> >(v * *
this);
 
 
 1005    template<
typename T0>
 
 1008        return static_cast< Vec3<T0> >(v * *
this);
 
 
 1012    template<
typename T0>
 
 1015        return static_cast< Vec4<T0> >(*
this * v);
 
 
 1019    template<
typename T0>
 
 1022        return static_cast< Vec3<T0> >(*
this * v);
 
 
 1026    template<
typename T0>
 
 1048    template<
typename T0>
 
 1069    template<
typename T0>
 
 1080    bool invert(
Mat4<T> &inverse, T tolerance) 
const;
 
 1082    T det2(
const Mat4<T> &a, 
int i0, 
int i1, 
int j0, 
int j1)
 const {
 
 1085        return a.
mm[i0row+j0]*a.
mm[i1row+j1] - a.
mm[i0row+j1]*a.
mm[i1row+j0];
 
 1088    T det3(
const Mat4<T> &a, 
int i0, 
int i1, 
int i2,
 
 1089           int j0, 
int j1, 
int j2)
 const {
 
 1091        return a.mm[i0row+j0]*det2(a, i1,i2, j1,j2) +
 
 1092            a.mm[i0row+j1]*det2(a, i1,i2, j2,j0) +
 
 1093            a.mm[i0row+j2]*det2(a, i1,i2, j0,j1);
 
 
 1100template <
typename T0, 
typename T1>
 
 1106    for (
int i=0; i<16; ++i) 
if (!
isExactlyEqual(t0[i], t1[i])) 
return false;
 
 
 1112template <
typename T0, 
typename T1>
 
 1117template <
typename S, 
typename T>
 
 1125template <
typename S, 
typename T>
 
 1135template<
typename T, 
typename MT>
 
 1142        _v[0]*m[0]  + _v[1]*m[1]  + _v[2]*m[2]  + _v[3]*m[3],
 
 1143        _v[0]*m[4]  + _v[1]*m[5]  + _v[2]*m[6]  + _v[3]*m[7],
 
 1144        _v[0]*m[8]  + _v[1]*m[9]  + _v[2]*m[10] + _v[3]*m[11],
 
 1145        _v[0]*m[12] + _v[1]*m[13] + _v[2]*m[14] + _v[3]*m[15]);
 
 
 1150template<
typename T, 
typename MT>
 
 1157        _v[0]*m[0] + _v[1]*m[4] + _v[2]*m[8]  + _v[3]*m[12],
 
 1158        _v[0]*m[1] + _v[1]*m[5] + _v[2]*m[9]  + _v[3]*m[13],
 
 1159        _v[0]*m[2] + _v[1]*m[6] + _v[2]*m[10] + _v[3]*m[14],
 
 1160        _v[0]*m[3] + _v[1]*m[7] + _v[2]*m[11] + _v[3]*m[15]);
 
 
 1165template<
typename T, 
typename MT>
 
 1171        _v[0]*m[0] + _v[1]*m[1] + _v[2]*m[2]  + m[3],
 
 1172        _v[0]*m[4] + _v[1]*m[5] + _v[2]*m[6]  + m[7],
 
 1173        _v[0]*m[8] + _v[1]*m[9] + _v[2]*m[10] + m[11]);
 
 
 1178template<
typename T, 
typename MT>
 
 1184        _v[0]*m[0] + _v[1]*m[4] + _v[2]*m[8]  + m[12],
 
 1185        _v[0]*m[1] + _v[1]*m[5] + _v[2]*m[9]  + m[13],
 
 1186        _v[0]*m[2] + _v[1]*m[6] + _v[2]*m[10] + m[14]);
 
 
 1191template <
typename T0, 
typename T1>
 
 1202template <
typename T0, 
typename T1>
 
 1213template <
typename T0, 
typename T1>
 
 1226template<
typename T0, 
typename T1>
 
 1230        static_cast<T1
>(m[0][0]*n[0] + m[0][1]*n[1] + m[0][2]*n[2]),
 
 1231        static_cast<T1
>(m[1][0]*n[0] + m[1][1]*n[1] + m[1][2]*n[2]),
 
 1232        static_cast<T1
>(m[2][0]*n[0] + m[2][1]*n[1] + m[2][2]*n[2]));
 
 
 1238bool Mat4<T>::invert(Mat4<T> &inverse, T tolerance)
 const 
 1240    Mat4<T> temp(*
this);
 
 1241    inverse.setIdentity();
 
 1245    for (
int i = 0; i < 4; ++i) {
 
 1247        double max = fabs(temp[i][i]);
 
 1249        for (
int k = i+1; k < 4; ++k) {
 
 1250            if (fabs(temp[k][i]) > max) {
 
 1252                max = fabs(temp[k][i]);
 
 1256        if (isExactlyEqual(max, 0.0)) 
return false;
 
 1261            for (
int k = 0; k < 4; ++k) {
 
 1262                std::swap(temp[row][k], temp[i][k]);
 
 1263                std::swap(inverse[row][k], inverse[i][k]);
 
 1267        double pivot = temp[i][i];
 
 1271        for (
int k = 0; k < 4; ++k) {
 
 1272            temp[i][k] /= 
pivot;
 
 1273            inverse[i][k] /= 
pivot;
 
 1277        for (
int j = i+1; j < 4; ++j) {
 
 1278            double t = temp[j][i];
 
 1281                for (
int k = 0; k < 4; ++k) {
 
 1282                    temp[j][k] -= temp[i][k] * t;
 
 1283                    inverse[j][k] -= inverse[i][k] * t;
 
 1290    for (
int i = 3; i > 0; --i) {
 
 1291        for (
int j = 0; j < i; ++j) {
 
 1292            double t = temp[j][i];
 
 1295                for (
int k = 0; k < 4; ++k) {
 
 1296                    inverse[j][k] -= inverse[i][k]*t;
 
 1301    return det*det >= tolerance*tolerance;
 
 1304template <
typename T>
 
 1309template <
typename T>
 
 1321    for (
unsigned i = 0; i < 16; ++i, ++op, ++ip) *op = 
math::Abs(*ip);
 
 
 1325template<
typename Type1, 
typename Type2>
 
 1332    for (
unsigned i = 0; i < 16; ++i, ++op, ++ip) {
 
 
#define OPENVDB_ASSERT(X)
Definition Assert.h:41
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
#define OPENVDB_IS_POD(Type)
Definition Math.h:56
Definition Exceptions.h:56
3x3 matrix class.
Definition Mat3.h:29
T det() const
Determinant of matrix.
Definition Mat3.h:479
4x4 -matrix class.
Definition Mat4.h:31
void postTranslate(const Vec3< T0 > &tr)
Right multiplies by the specified translation matrix, i.e. (*this) * Trans.
Definition Mat4.h:714
void preScale(const Vec3< T0 > &v)
Definition Mat4.h:736
Mat4< typename promote< T0, T1 >::type > operator+(const Mat4< T0 > &m0, const Mat4< T1 > &m1)
Add corresponding elements of m0 and m1 and return the result.
Definition Mat4.h:1193
const Mat4< T > & operator*=(const Mat4< S > &m1)
Multiply this matrix by the given matrix.
Definition Mat4.h:439
Vec3< T > getTranslation() const
Return the translation component.
Definition Mat4.h:309
Mat4(const Mat4< Source > &m)
Conversion constructor.
Definition Mat4.h:107
void preTranslate(const Vec3< T0 > &tr)
Left multiples by the specified translation, i.e. Trans * (*this)
Definition Mat4.h:703
void postRotate(Axis axis, T angle)
Right multiplies by a rotation clock-wiseabout the given axis into this matrix.
Definition Mat4.h:880
void setIdentity()
Set this matrix to identity.
Definition Mat4.h:265
Mat4< typename promote< S, T >::type > operator*(const Mat4< T > &m, S scalar)
Multiply each element of the given matrix by scalar and return the result.
Definition Mat4.h:1126
Vec4< typename promote< T, MT >::type > operator*(const Vec4< T > &_v, const Mat4< MT > &_m)
Multiply _v by _m and return the resulting vector.
Definition Mat4.h:1152
void setToRotation(const Vec3< T > &axis, T angle)
Sets the matrix to a rotation about an arbitrary axis.
Definition Mat4.h:788
void setRows(const Vec4< Real > &v1, const Vec4< Real > &v2, const Vec4< Real > &v3, const Vec4< Real > &v4)
Definition Mat4.h:194
void setZero()
Definition Mat4.h:244
void setToScale(const Vec3< T0 > &v)
Sets the matrix to a matrix that scales by v.
Definition Mat4.h:726
Mat4 inverse(T tolerance=0) const
Definition Mat4.h:485
static Mat4 translation(const Vec3d &v)
Sets the matrix to a matrix that translates by v.
Definition Mat4.h:667
void preRotate(Axis axis, T angle)
Left multiplies by a rotation clock-wiseabout the given axis into this matrix.
Definition Mat4.h:797
Mat3< T > getMat3() const
Definition Mat4.h:297
Vec4< T > col(int j) const
Get jth column, e.g. Vec4f v = m.col(0);.
Definition Mat4.h:167
static const Mat4< T > & identity()
Predefined constant for identity matrix.
Definition Mat4.h:117
bool eq(const Mat4 &m, T eps=1.0e-8) const
Return true if this matrix is equivalent to m within a tolerance of eps.
Definition Mat4.h:333
void setToShear(Axis axis0, Axis axis1, T shearby)
Sets the matrix to a shear along axis0 by a fraction of axis1.
Definition Mat4.h:961
Vec3< T0 > pretransform(const Vec3< T0 > &v) const
Transform a Vec3 by pre-multiplication, without homogenous division.
Definition Mat4.h:1020
Mat4 transpose() const
Definition Mat4.h:472
void postShear(Axis axis0, Axis axis1, T shear)
Right multiplies a shearing transformation into the matrix.
Definition Mat4.h:984
bool operator==(const Mat4< T0 > &m0, const Mat4< T1 > &m1)
Equality operator, does exact floating point comparisons.
Definition Mat4.h:1101
void setToRotation(Axis axis, T angle)
Sets the matrix to a rotation about the given axis.
Definition Mat4.h:783
void setCol(int j, const Vec4< T > &v)
Set jth column to vector v.
Definition Mat4.h:157
Vec3< typename promote< T, MT >::type > operator*(const Mat4< MT > &_m, const Vec3< T > &_v)
Multiply _m by _v and return the resulting vector.
Definition Mat4.h:1167
Vec3< typename promote< T, MT >::type > operator*(const Vec3< T > &_v, const Mat4< MT > &_m)
Multiply _v by _m and return the resulting vector.
Definition Mat4.h:1180
Vec4< T0 > transform(const Vec4< T0 > &v) const
Transform a Vec4 by post-multiplication.
Definition Mat4.h:999
void preShear(Axis axis0, Axis axis1, T shear)
Left multiplies a shearing transformation into the matrix.
Definition Mat4.h:969
void setColumns(const Vec4< Real > &v1, const Vec4< Real > &v2, const Vec4< Real > &v3, const Vec4< Real > &v4)
Definition Mat4.h:219
Mat< 4, Real > MyBase
Definition Mat4.h:36
static const Mat4< T > & zero()
Predefined constant for zero matrix.
Definition Mat4.h:128
Vec3< T0 > transform3x3(const Vec3< T0 > &v) const
Transform a Vec3 by post-multiplication, without translation.
Definition Mat4.h:1070
Mat4(const Vec4< Source > &v1, const Vec4< Source > &v2, const Vec4< Source > &v3, const Vec4< Source > &v4, bool rows=true)
Definition Mat4.h:95
void setTranslation(const Vec3< T > &t)
Definition Mat4.h:314
Vec3< T0 > pretransformH(const Vec3< T0 > &p) const
Transform a Vec3 by pre-multiplication, doing homogenous division.
Definition Mat4.h:1049
void setToRotation(const Vec3< T > &v1, const Vec3< T > &v2)
Sets the matrix to a rotation that maps v1 onto v2 about the cross product of v1 and v2.
Definition Mat4.h:792
void setToTranslation(const Vec3< T0 > &v)
Sets the matrix to a matrix that translates by v.
Definition Mat4.h:678
Real det() const
Definition Mat4.h:637
Mat4< typename promote< S, T >::type > operator*(S scalar, const Mat4< T > &m)
Multiply each element of the given matrix by scalar and return the result.
Definition Mat4.h:1118
Vec4< T > row(int i) const
Get ith row, e.g. Vec4f v = m.row(1);.
Definition Mat4.h:150
const Mat4< T > & operator+=(const Mat4< S > &m1)
Add each element of the given matrix to the corresponding element of this matrix.
Definition Mat4.h:381
Mat4< typename promote< T0, T1 >::type > operator-(const Mat4< T0 > &m0, const Mat4< T1 > &m1)
Subtract corresponding elements of m0 and m1 and return the result.
Definition Mat4.h:1204
Mat4(Source *a)
Constructor given array of elements, the ordering is in row major form:
Definition Mat4.h:51
bool operator!=(const Mat4< T0 > &m0, const Mat4< T1 > &m1)
Inequality operator, does exact floating point comparisons.
Definition Mat4.h:1113
T & operator()(int i, int j)
Definition Mat4.h:176
void setRow(int i, const Vec4< T > &v)
Set ith row to vector v.
Definition Mat4.h:139
Mat4(Source a, Source b, Source c, Source d, Source e, Source f, Source g, Source h, Source i, Source j, Source k, Source l, Source m, Source n, Source o, Source p)
Constructor given array of elements, the ordering is in row major form:
Definition Mat4.h:66
void postScale(const Vec3< T0 > &v)
Definition Mat4.h:758
Vec3< T0 > transform(const Vec3< T0 > &v) const
Transform a Vec3 by post-multiplication, without homogenous division.
Definition Mat4.h:1006
Mat4< typename promote< T0, T1 >::type > operator*(const Mat4< T0 > &m0, const Mat4< T1 > &m1)
Multiply m0 by m1 and return the resulting matrix.
Definition Mat4.h:1215
T operator()(int i, int j) const
Definition Mat4.h:186
const Mat4< T > & operator-=(const Mat4< S > &m1)
Subtract each element of the given matrix from the corresponding element of this matrix.
Definition Mat4.h:410
Vec3< T0 > transformH(const Vec3< T0 > &p) const
Transform a Vec3 by post-multiplication, doing homogenous divison.
Definition Mat4.h:1027
void setMat3(const Mat3< T > &m)
Set upper left to a Mat3.
Definition Mat4.h:290
Vec4< T0 > pretransform(const Vec4< T0 > &v) const
Transform a Vec4 by pre-multiplication.
Definition Mat4.h:1013
const Mat4 & operator=(const Mat4< Source > &m)
Assignment operator.
Definition Mat4.h:323
const Mat4< T > & operator*=(S scalar)
Multiply each element of this matrix by scalar.
Definition Mat4.h:355
Real ValueType
Definition Mat4.h:35
Vec4< typename promote< T, MT >::type > operator*(const Mat4< MT > &_m, const Vec4< T > &_v)
Multiply _m by _v and return the resulting vector.
Definition Mat4.h:1137
Real value_type
Definition Mat4.h:34
Mat4< T > operator-() const
Negation operator, for e.g. m1 = -m2;.
Definition Mat4.h:343
T mm[SIZE *SIZE]
Definition Mat.h:160
T * asPointer()
Direct access to the internal data.
Definition Mat.h:101
static unsigned numElements()
Definition Mat.h:41
T & x()
Reference to the component, e.g. v.x() = 4.5f;.
Definition Vec3.h:86
T dot(const Vec3< T > &v) const
Dot product.
Definition Vec3.h:192
T & y()
Definition Vec3.h:87
T & z()
Definition Vec3.h:88
void pivot(int i, int j, Mat3< T > &S, Vec3< T > &D, Mat3< T > &Q)
Definition Mat3.h:668
Vec3< T1 > transformNormal(const Mat4< T0 > &m, const Vec3< T1 > &n)
Definition Mat4.h:1227
bool hasTranslation(const Mat4< T > &m)
Definition Mat4.h:1310
Mat4< float > Mat4s
Definition Mat4.h:1354
bool cwiseLessThan(const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1)
Definition Mat.h:1015
Mat4d Mat4f
Definition Mat4.h:1356
bool isApproxEqual(const Type &a, const Type &b, const Type &tolerance)
Return true if a is equal to b to within the given tolerance.
Definition Math.h:406
Vec3< double > Vec3d
Definition Vec3.h:665
bool isAffine(const Mat4< T > &m)
Definition Mat4.h:1305
MatType rotation(const Quat< typename MatType::value_type > &q, typename MatType::value_type eps=static_cast< typename MatType::value_type >(1.0e-8))
Return the rotation matrix specified by the given quaternion.
Definition Mat.h:172
auto cwiseAdd(const math::Vec3< math::half > &v, const float s)
Definition Types.h:694
Coord Abs(const Coord &xyz)
Definition Coord.h:518
Mat4< double > Mat4d
Definition Mat4.h:1355
T angle(const Vec2< T > &v1, const Vec2< T > &v2)
Definition Vec2.h:446
bool isExactlyEqual(const T0 &a, const T1 &b)
Return true if a is exactly equal to b.
Definition Math.h:443
MatType shear(Axis axis0, Axis axis1, typename MatType::value_type shear)
Set the matrix to a shear along axis0 by a fraction of axis1.
Definition Mat.h:688
Axis
Definition Math.h:901
@ Z_AXIS
Definition Math.h:904
@ X_AXIS
Definition Math.h:902
@ Y_AXIS
Definition Math.h:903
bool cwiseGreaterThan(const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1)
Definition Mat.h:1029
constexpr T zeroVal()
Return the value of type T that corresponds to zero.
Definition Math.h:70
Definition Exceptions.h:13
#define OPENVDB_THROW(exception, message)
Definition Exceptions.h:74
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition version.h.in:121
#define OPENVDB_USE_VERSION_NAMESPACE
Definition version.h.in:218