SkM44 Class Reference

#include <SkM44.h>

Public Types
enum	Uninitialized_Constructor { kUninitialized_Constructor }
enum	NaN_Constructor { kNaN_Constructor }

Public Member Functions
	SkM44 (const SkM44 &src)=default
SkM44 &	operator= (const SkM44 &src)=default
constexpr	SkM44 ()
	SkM44 (const SkM44 &a, const SkM44 &b)
	SkM44 (Uninitialized_Constructor)
constexpr	SkM44 (NaN_Constructor)
constexpr	SkM44 (SkScalar m0, SkScalar m4, SkScalar m8, SkScalar m12, SkScalar m1, SkScalar m5, SkScalar m9, SkScalar m13, SkScalar m2, SkScalar m6, SkScalar m10, SkScalar m14, SkScalar m3, SkScalar m7, SkScalar m11, SkScalar m15)
bool	operator== (const SkM44 &other) const
bool	operator!= (const SkM44 &other) const
void	getColMajor (SkScalar v[]) const
void	getRowMajor (SkScalar v[]) const
SkScalar	rc (int r, int c) const
void	setRC (int r, int c, SkScalar value)
SkV4	row (int i) const
SkV4	col (int i) const
void	setRow (int i, const SkV4 &v)
void	setCol (int i, const SkV4 &v)
SkM44 &	setIdentity ()
SkM44 &	setTranslate (SkScalar x, SkScalar y, SkScalar z=0)
SkM44 &	setScale (SkScalar x, SkScalar y, SkScalar z=1)
SkM44 &	setRotateUnitSinCos (SkV3 axis, SkScalar sinAngle, SkScalar cosAngle)
SkM44 &	setRotateUnit (SkV3 axis, SkScalar radians)
SkM44 &	setRotate (SkV3 axis, SkScalar radians)
SkM44 &	setConcat (const SkM44 &a, const SkM44 &b)
SkM44 &	preConcat (const SkM44 &m)
SkM44 &	postConcat (const SkM44 &m)
void	normalizePerspective ()
bool	isFinite () const
bool	invert (SkM44 *inverse) const
SkM44	transpose () const
void	dump () const
SkV4	map (float x, float y, float z, float w) const
SkV4	operator* (const SkV4 &v) const
SkV3	operator* (SkV3 v) const
SkMatrix	asM33 () const
	SkM44 (const SkMatrix &src)
SkM44 &	preTranslate (SkScalar x, SkScalar y, SkScalar z=0)
SkM44 &	postTranslate (SkScalar x, SkScalar y, SkScalar z=0)
SkM44 &	preScale (SkScalar x, SkScalar y)
SkM44 &	preScale (SkScalar x, SkScalar y, SkScalar z)
SkM44 &	preConcat (const SkMatrix &)

Static Public Member Functions
static SkM44	Rows (const SkV4 &r0, const SkV4 &r1, const SkV4 &r2, const SkV4 &r3)
static SkM44	Cols (const SkV4 &c0, const SkV4 &c1, const SkV4 &c2, const SkV4 &c3)
static SkM44	RowMajor (const SkScalar r[16])
static SkM44	ColMajor (const SkScalar c[16])
static SkM44	Translate (SkScalar x, SkScalar y, SkScalar z=0)
static SkM44	Scale (SkScalar x, SkScalar y, SkScalar z=1)
static SkM44	Rotate (SkV3 axis, SkScalar radians)
static SkM44	RectToRect (const SkRect &src, const SkRect &dst)
static SkM44	LookAt (const SkV3 &eye, const SkV3 &center, const SkV3 &up)
static SkM44	Perspective (float near, float far, float angle)

Friends
class	SkMatrixPriv
SkM44	operator* (const SkM44 &a, const SkM44 &b)

Detailed Description

4x4 matrix used by SkCanvas and other parts of Skia.

Skia assumes a right-handed coordinate system: +X goes to the right +Y goes down +Z goes into the screen (away from the viewer)

Definition at line 150 of file SkM44.h.

Member Enumeration Documentation

NaN_Constructor

enum SkM44::NaN_Constructor

Enumerator
kNaN_Constructor

Definition at line 171 of file SkM44.h.

                         {
        kNaN_Constructor
    };

Uninitialized_Constructor

enum SkM44::Uninitialized_Constructor

Enumerator
kUninitialized_Constructor

Definition at line 166 of file SkM44.h.

                                   {
        kUninitialized_Constructor
    };

Constructor & Destructor Documentation

SkM44() [1/7]

SkM44::SkM44 ( const SkM44 &  src )

default

SkM44() [2/7]

constexpr SkM44::SkM44 ( )

inlineconstexpr

Definition at line 155 of file SkM44.h.

        : fMat{1, 0, 0, 0,
               0, 1, 0, 0,
               0, 0, 1, 0,
               0, 0, 0, 1}
        {}

SkM44() [3/7]

SkM44::SkM44 ( const SkM44 &  a, const SkM44 &  b  )

inline

Definition at line 162 of file SkM44.h.

                                          {
        this->setConcat(a, b);
    }

SkM44() [4/7]

SkM44::SkM44 ( Uninitialized_Constructor  )

inline

Definition at line 169 of file SkM44.h.

{}

SkM44() [5/7]

constexpr SkM44::SkM44 ( NaN_Constructor  )

inlineconstexpr

Definition at line 174 of file SkM44.h.

        : fMat{SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN,
               SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN,
               SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN,
               SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN}
    {}

SkM44() [6/7]

constexpr SkM44::SkM44 ( SkScalar  m0, SkScalar  m4, SkScalar  m8, SkScalar  m12, SkScalar  m1, SkScalar  m5, SkScalar  m9, SkScalar  m13, SkScalar  m2, SkScalar  m6, SkScalar  m10, SkScalar  m14, SkScalar  m3, SkScalar  m7, SkScalar  m11, SkScalar  m15  )

inlineconstexpr

The constructor parameters are in row-major order.

Definition at line 184 of file SkM44.h.

        : fMat{m0,  m1,  m2,  m3,
               m4,  m5,  m6,  m7,
               m8,  m9,  m10, m11,
               m12, m13, m14, m15}
    {}

SkM44() [7/7]

SkM44::SkM44 ( const SkMatrix &  src )

inlineexplicit

Definition at line 415 of file SkM44.h.

    : SkM44(src[SkMatrix::kMScaleX], src[SkMatrix::kMSkewX],  0, src[SkMatrix::kMTransX],
            src[SkMatrix::kMSkewY],  src[SkMatrix::kMScaleY], 0, src[SkMatrix::kMTransY],
            0,                       0,                       1, 0,
            src[SkMatrix::kMPersp0], src[SkMatrix::kMPersp1], 0, src[SkMatrix::kMPersp2])
    {}

Member Function Documentation

asM33()

SkMatrix SkM44::asM33 ( ) const

inline

Definition at line 409 of file SkM44.h.

                           {
        return SkMatrix::MakeAll(fMat[0], fMat[4], fMat[12],
                                 fMat[1], fMat[5], fMat[13],
                                 fMat[3], fMat[7], fMat[15]);
    }

col()

SkV4 SkM44::col ( int  i ) const

inline

Definition at line 276 of file SkM44.h.

                          {
        SkASSERT(i >= 0 && i <= 3);
        return {fMat[i*4 + 0], fMat[i*4 + 1], fMat[i*4 + 2], fMat[i*4 + 3]};
    }

ColMajor()

static SkM44 SkM44::ColMajor ( const SkScalar  c[16] )

inlinestatic

Definition at line 218 of file SkM44.h.

                                                {
        return SkM44(c[0], c[4], c[ 8], c[12],
                     c[1], c[5], c[ 9], c[13],
                     c[2], c[6], c[10], c[14],
                     c[3], c[7], c[11], c[15]);
    }

Cols()

static SkM44 SkM44::Cols ( const SkV4 &  c0, const SkV4 &  c1, const SkV4 &  c2, const SkV4 &  c3  )

inlinestatic

Definition at line 203 of file SkM44.h.

                                                                                      {
        SkM44 m(kUninitialized_Constructor);
        m.setCol(0, c0);
        m.setCol(1, c1);
        m.setCol(2, c2);
        m.setCol(3, c3);
        return m;
    }

dump()

void SkM44::dump

(

)

const

Definition at line 291 of file SkM44.cpp.

                       {
    SkDebugf("|%g %g %g %g|\n"
             "|%g %g %g %g|\n"
             "|%g %g %g %g|\n"
             "|%g %g %g %g|\n",
             fMat[0], fMat[4], fMat[8],  fMat[12],
             fMat[1], fMat[5], fMat[9],  fMat[13],
             fMat[2], fMat[6], fMat[10], fMat[14],
             fMat[3], fMat[7], fMat[11], fMat[15]);
}

getColMajor()

void SkM44::getColMajor ( SkScalar  v[] ) const

inline

Definition at line 256 of file SkM44.h.

                                         {
        memcpy(v, fMat, sizeof(fMat));
    }

getRowMajor()

void SkM44::getRowMajor

(

SkScalar

v[]

)

const

Definition at line 44 of file SkM44.cpp.

                                          {
    transpose_arrays(v, fMat);
}

invert()

bool SkM44::invert

(

SkM44 *

inverse

)

const

If this is invertible, return that in inverse and return true. If it is not invertible, return false and leave the inverse parameter unchanged.

We always perform the calculation in doubles, to avoid prematurely losing precision along the way. This relies on the compiler automatically promoting our SkScalar values to double (if needed).

Definition at line 247 of file SkM44.cpp.

                                       {
    SkScalar tmp[16];
    if (SkInvert4x4Matrix(fMat, tmp) == 0.0f) {
        return false;
    }
    memcpy(inverse->fMat, tmp, sizeof(tmp));
    return true;
}

isFinite()

bool SkM44::isFinite ( ) const

inline

Returns true if all elements of the matrix are finite. Returns false if any element is infinity, or NaN.

Returns

true if matrix has only finite elements

Definition at line 378 of file SkM44.h.

{ return SkIsFinite(fMat, 16); }

LookAt()

SkM44 SkM44::LookAt ( const SkV3 &  eye, const SkV3 &  center, const SkV3 &  up  )

static

Definition at line 331 of file SkM44.cpp.

                                                                       {
    SkV3 f = normalize(center - eye);
    SkV3 u = normalize(up);
    SkV3 s = normalize(f.cross(u));
 
    SkM44 m(SkM44::kUninitialized_Constructor);
    if (!SkM44::Cols(v4(s, 0), v4(s.cross(f), 0), v4(-f, 0), v4(eye, 1)).invert(&m)) {
        m.setIdentity();
    }
    return m;
}

map()

SkV4 SkM44::map	(	float	x,
		float	y,
		float	z,
		float	w
	)		const

Definition at line 129 of file SkM44.cpp.

                                                        {
    auto c0 = skvx::float4::Load(fMat +  0);
    auto c1 = skvx::float4::Load(fMat +  4);
    auto c2 = skvx::float4::Load(fMat +  8);
    auto c3 = skvx::float4::Load(fMat + 12);
 
    SkV4 v;
    (c0*x + (c1*y + (c2*z + c3*w))).store(&v.x);
    return v;
}

normalizePerspective()

void SkM44::normalizePerspective

(

)

A matrix is categorized as 'perspective' if the bottom row is not [0, 0, 0, 1]. For most uses, a bottom row of [0, 0, 0, X] behaves like a non-perspective matrix, though it will be categorized as perspective. Calling normalizePerspective() will change the matrix such that, if its bottom row was [0, 0, 0, X], it will be changed to [0, 0, 0, 1] by scaling the rest of the matrix by 1/X.

| A B C D | | A/X B/X C/X D/X | | E F G H | -> | E/X F/X G/X H/X | for X != 0 | I J K L | | I/X J/X K/X L/X | | 0 0 0 X | | 0 0 0 1 |

Definition at line 226 of file SkM44.cpp.

                                 {
    // If the bottom row of the matrix is [0, 0, 0, not_one], we will treat the matrix as if it
    // is in perspective, even though it stills behaves like its affine. If we divide everything
    // by the not_one value, then it will behave the same, but will be treated as affine,
    // and therefore faster (e.g. clients can forward-difference calculations).
    if (fMat[15] != 1 && fMat[15] != 0 && fMat[3] == 0 && fMat[7] == 0 && fMat[11] == 0) {
        double inv = 1.0 / fMat[15];
        (skvx::float4::Load(fMat +  0) * inv).store(fMat +  0);
        (skvx::float4::Load(fMat +  4) * inv).store(fMat +  4);
        (skvx::float4::Load(fMat +  8) * inv).store(fMat +  8);
        (skvx::float4::Load(fMat + 12) * inv).store(fMat + 12);
        fMat[15] = 1.0f;
    }
}

operator!=()

bool SkM44::operator!= ( const SkM44 &  other ) const

inline

Definition at line 252 of file SkM44.h.

                                              {
        return !(other == *this);
    }

operator*() [1/2]

SkV4 SkM44::operator* ( const SkV4 &  v ) const

inline

Definition at line 392 of file SkM44.h.

                                        {
        return this->map(v.x, v.y, v.z, v.w);
    }

operator*() [2/2]

SkV3 SkM44::operator* ( SkV3  v ) const

inline

Definition at line 395 of file SkM44.h.

                                 {
        auto v4 = this->map(v.x, v.y, v.z, 0);
        return {v4.x, v4.y, v4.z};
    }

operator=()

SkM44 & SkM44::operator= ( const SkM44 &  src )

default

operator==()

bool SkM44::operator==

(

const SkM44 &

other

)

const

Definition at line 18 of file SkM44.cpp.

                                               {
    if (this == &other) {
        return true;
    }
 
    auto a0 = skvx::float4::Load(fMat +  0);
    auto a1 = skvx::float4::Load(fMat +  4);
    auto a2 = skvx::float4::Load(fMat +  8);
    auto a3 = skvx::float4::Load(fMat + 12);
 
    auto b0 = skvx::float4::Load(other.fMat +  0);
    auto b1 = skvx::float4::Load(other.fMat +  4);
    auto b2 = skvx::float4::Load(other.fMat +  8);
    auto b3 = skvx::float4::Load(other.fMat + 12);
 
    auto eq = (a0 == b0) & (a1 == b1) & (a2 == b2) & (a3 == b3);
    return (eq[0] & eq[1] & eq[2] & eq[3]) == ~0;
}

Perspective()

SkM44 SkM44::Perspective ( float  near, float  far, float  angle  )

static

Definition at line 343 of file SkM44.cpp.

                                                           {
    SkASSERT(far > near);
 
    float denomInv = sk_ieee_float_divide(1, far - near);
    float halfAngle = angle * 0.5f;
    SkASSERT(halfAngle != 0);
    float cot = sk_ieee_float_divide(1, std::tan(halfAngle));
 
    SkM44 m;
    m.setRC(0, 0, cot);
    m.setRC(1, 1, cot);
    m.setRC(2, 2, (far + near) * denomInv);
    m.setRC(2, 3, 2 * far * near * denomInv);
    m.setRC(3, 2, -1);
    return m;
}

postConcat()

SkM44 & SkM44::postConcat ( const SkM44 &  m )

inline

Definition at line 355 of file SkM44.h.

                                      {
        return this->setConcat(m, *this);
    }

postTranslate()

SkM44 & SkM44::postTranslate	(	SkScalar	x,
		SkScalar	y,
		SkScalar	z = 0
	)

Definition at line 100 of file SkM44.cpp.

                                                              {
    skvx::float4 t = { x, y, z, 0 };
    (t * fMat[ 3] + skvx::float4::Load(fMat +  0)).store(fMat +  0);
    (t * fMat[ 7] + skvx::float4::Load(fMat +  4)).store(fMat +  4);
    (t * fMat[11] + skvx::float4::Load(fMat +  8)).store(fMat +  8);
    (t * fMat[15] + skvx::float4::Load(fMat + 12)).store(fMat + 12);
    return *this;
}

preConcat() [1/2]

SkM44 & SkM44::preConcat ( const SkM44 &  m )

inline

Definition at line 351 of file SkM44.h.

                                     {
        return this->setConcat(*this, m);
    }

preConcat() [2/2]

SkM44 & SkM44::preConcat

(

const SkMatrix &

b

)

Definition at line 70 of file SkM44.cpp.

                                         {
    auto c0 = skvx::float4::Load(fMat +  0);
    auto c1 = skvx::float4::Load(fMat +  4);
    auto c3 = skvx::float4::Load(fMat + 12);
 
    auto compute = [&](float r0, float r1, float r3) {
        return (c0*r0 + (c1*r1 + c3*r3));
    };
 
    auto m0 = compute(b[0], b[3], b[6]);
    auto m1 = compute(b[1], b[4], b[7]);
    auto m3 = compute(b[2], b[5], b[8]);
 
    m0.store(fMat +  0);
    m1.store(fMat +  4);
    m3.store(fMat + 12);
    return *this;
}

preScale() [1/2]

SkM44 & SkM44::preScale	(	SkScalar	x,
		SkScalar	y
	)

Definition at line 109 of file SkM44.cpp.

                                             {
    auto c0 = skvx::float4::Load(fMat +  0);
    auto c1 = skvx::float4::Load(fMat +  4);
 
    (c0 * x).store(fMat + 0);
    (c1 * y).store(fMat + 4);
    return *this;
}

preScale() [2/2]

SkM44 & SkM44::preScale	(	SkScalar	x,
		SkScalar	y,
		SkScalar	z
	)

Definition at line 118 of file SkM44.cpp.

                                                         {
    auto c0 = skvx::float4::Load(fMat +  0);
    auto c1 = skvx::float4::Load(fMat +  4);
    auto c2 = skvx::float4::Load(fMat +  8);
 
    (c0 * x).store(fMat + 0);
    (c1 * y).store(fMat + 4);
    (c2 * z).store(fMat + 8);
    return *this;
}

preTranslate()

SkM44 & SkM44::preTranslate	(	SkScalar	x,
		SkScalar	y,
		SkScalar	z = 0
	)

Definition at line 89 of file SkM44.cpp.

                                                             {
    auto c0 = skvx::float4::Load(fMat +  0);
    auto c1 = skvx::float4::Load(fMat +  4);
    auto c2 = skvx::float4::Load(fMat +  8);
    auto c3 = skvx::float4::Load(fMat + 12);
 
    // only need to update the last column
    (c0*x + (c1*y + (c2*z + c3))).store(fMat + 12);
    return *this;
}

rc()

SkScalar SkM44::rc ( int  r, int  c  ) const

inline

Definition at line 261 of file SkM44.h.

                                    {
        SkASSERT(r >= 0 && r <= 3);
        SkASSERT(c >= 0 && c <= 3);
        return fMat[c*4 + r];
    }

RectToRect()

SkM44 SkM44::RectToRect ( const SkRect &  src, const SkRect &  dst  )

static

Definition at line 304 of file SkM44.cpp.

                                                            {
        if (src.isEmpty()) {
        return SkM44();
    } else if (dst.isEmpty()) {
        return SkM44::Scale(0.f, 0.f, 0.f);
    }
 
    float sx = dst.width()  / src.width();
    float sy = dst.height() / src.height();
 
    float tx = dst.fLeft - sx * src.fLeft;
    float ty = dst.fTop  - sy * src.fTop;
 
    return SkM44{sx,  0.f, 0.f, tx,
                 0.f, sy,  0.f, ty,
                 0.f, 0.f, 1.f, 0.f,
                 0.f, 0.f, 0.f, 1.f};
}

Rotate()

static SkM44 SkM44::Rotate ( SkV3  axis, SkScalar  radians  )

inlinestatic

Definition at line 239 of file SkM44.h.

                                                     {
        SkM44 m(kUninitialized_Constructor);
        m.setRotate(axis, radians);
        return m;
    }

row()

SkV4 SkM44::row ( int  i ) const

inline

Definition at line 272 of file SkM44.h.

                          {
        SkASSERT(i >= 0 && i <= 3);
        return {fMat[i + 0], fMat[i + 4], fMat[i + 8], fMat[i + 12]};
    }

RowMajor()

static SkM44 SkM44::RowMajor ( const SkScalar  r[16] )

inlinestatic

Definition at line 212 of file SkM44.h.

                                                {
        return SkM44(r[ 0], r[ 1], r[ 2], r[ 3],
                     r[ 4], r[ 5], r[ 6], r[ 7],
                     r[ 8], r[ 9], r[10], r[11],
                     r[12], r[13], r[14], r[15]);
    }

Rows()

static SkM44 SkM44::Rows ( const SkV4 &  r0, const SkV4 &  r1, const SkV4 &  r2, const SkV4 &  r3  )

inlinestatic

Definition at line 195 of file SkM44.h.

                                                                                      {
        SkM44 m(kUninitialized_Constructor);
        m.setRow(0, r0);
        m.setRow(1, r1);
        m.setRow(2, r2);
        m.setRow(3, r3);
        return m;
    }

Scale()

static SkM44 SkM44::Scale ( SkScalar  x, SkScalar  y, SkScalar  z = 1  )

inlinestatic

Definition at line 232 of file SkM44.h.

                                                               {
        return SkM44(x, 0, 0, 0,
                     0, y, 0, 0,
                     0, 0, z, 0,
                     0, 0, 0, 1);
    }

setCol()

void SkM44::setCol ( int  i, const SkV4 &  v  )

inline

Definition at line 288 of file SkM44.h.

                                      {
        SkASSERT(i >= 0 && i <= 3);
        memcpy(&fMat[i*4], v.ptr(), sizeof(v));
    }

setConcat()

SkM44 & SkM44::setConcat	(	const SkM44 &	a,
		const SkM44 &	b
	)

Definition at line 48 of file SkM44.cpp.

                                                      {
    auto c0 = skvx::float4::Load(a.fMat +  0);
    auto c1 = skvx::float4::Load(a.fMat +  4);
    auto c2 = skvx::float4::Load(a.fMat +  8);
    auto c3 = skvx::float4::Load(a.fMat + 12);
 
    auto compute = [&](skvx::float4 r) {
        return c0*r[0] + (c1*r[1] + (c2*r[2] + c3*r[3]));
    };
 
    auto m0 = compute(skvx::float4::Load(b.fMat +  0));
    auto m1 = compute(skvx::float4::Load(b.fMat +  4));
    auto m2 = compute(skvx::float4::Load(b.fMat +  8));
    auto m3 = compute(skvx::float4::Load(b.fMat + 12));
 
    m0.store(fMat +  0);
    m1.store(fMat +  4);
    m2.store(fMat +  8);
    m3.store(fMat + 12);
    return *this;
}

setIdentity()

SkM44 & SkM44::setIdentity ( )

inline

Definition at line 293 of file SkM44.h.

                         {
        *this = { 1, 0, 0, 0,
                  0, 1, 0, 0,
                  0, 0, 1, 0,
                  0, 0, 0, 1 };
        return *this;
    }

setRC()

void SkM44::setRC ( int  r, int  c, SkScalar  value  )

inline

Definition at line 266 of file SkM44.h.

                                             {
        SkASSERT(r >= 0 && r <= 3);
        SkASSERT(c >= 0 && c <= 3);
        fMat[c*4 + r] = value;
    }

setRotate()

SkM44 & SkM44::setRotate	(	SkV3	axis,
		SkScalar	radians
	)

Set this matrix to rotate about the specified axis vector, by an angle specified in radians.

Note: axis is not assumed to be unit-length, so it will be normalized internally. If axis is already unit-length, call setRotateAboutUnitRadians() instead.

Definition at line 279 of file SkM44.cpp.

                                                   {
    SkScalar len = axis.length();
    if (len > 0 && SkIsFinite(len)) {
        this->setRotateUnit(axis * (SK_Scalar1 / len), radians);
    } else {
        this->setIdentity();
    }
    return *this;
}

setRotateUnit()

SkM44 & SkM44::setRotateUnit ( SkV3  axis, SkScalar  radians  )

inline

Set this matrix to rotate about the specified unit-length axis vector, by an angle specified in radians.

This does not attempt to verify that axis.length() == 1.

Definition at line 332 of file SkM44.h.

                                                      {
        return this->setRotateUnitSinCos(axis, SkScalarSin(radians), SkScalarCos(radians));
    }

setRotateUnitSinCos()

SkM44 & SkM44::setRotateUnitSinCos	(	SkV3	axis,
		SkScalar	sinAngle,
		SkScalar	cosAngle
	)

Set this matrix to rotate about the specified unit-length axis vector, by an angle specified by its sin() and cos().

This does not attempt to verify that axis.length() == 1 or that the sin,cos values are correct.

Definition at line 262 of file SkM44.cpp.

                                                                                 {
    // Taken from "Essential Mathematics for Games and Interactive Applications"
    //             James M. Van Verth and Lars M. Bishop -- third edition
    SkScalar x = axis.x;
    SkScalar y = axis.y;
    SkScalar z = axis.z;
    SkScalar c = cosAngle;
    SkScalar s = sinAngle;
    SkScalar t = 1 - c;
 
    *this = { t*x*x + c,   t*x*y - s*z, t*x*z + s*y, 0,
              t*x*y + s*z, t*y*y + c,   t*y*z - s*x, 0,
              t*x*z - s*y, t*y*z + s*x, t*z*z + c,   0,
              0,           0,           0,           1 };
    return *this;
}

setRow()

void SkM44::setRow ( int  i, const SkV4 &  v  )

inline

Definition at line 281 of file SkM44.h.

                                      {
        SkASSERT(i >= 0 && i <= 3);
        fMat[i + 0]  = v.x;
        fMat[i + 4]  = v.y;
        fMat[i + 8]  = v.z;
        fMat[i + 12] = v.w;
    }

setScale()

SkM44 & SkM44::setScale ( SkScalar  x, SkScalar  y, SkScalar  z = 1  )

inline

Definition at line 309 of file SkM44.h.

                                                            {
        *this = { x, 0, 0, 0,
                  0, y, 0, 0,
                  0, 0, z, 0,
                  0, 0, 0, 1 };
        return *this;
    }

setTranslate()

SkM44 & SkM44::setTranslate ( SkScalar  x, SkScalar  y, SkScalar  z = 0  )

inline

Definition at line 301 of file SkM44.h.

                                                                {
        *this = { 1, 0, 0, x,
                  0, 1, 0, y,
                  0, 0, 1, z,
                  0, 0, 0, 1 };
        return *this;
    }

Translate()

static SkM44 SkM44::Translate ( SkScalar  x, SkScalar  y, SkScalar  z = 0  )

inlinestatic

Definition at line 225 of file SkM44.h.

                                                                   {
        return SkM44(1, 0, 0, x,
                     0, 1, 0, y,
                     0, 0, 1, z,
                     0, 0, 0, 1);
    }

transpose()

SkM44 SkM44::transpose

(

)

const

Definition at line 256 of file SkM44.cpp.

                             {
    SkM44 trans(SkM44::kUninitialized_Constructor);
    transpose_arrays(trans.fMat, fMat);
    return trans;
}

Friends And Related Function Documentation

operator*

SkM44 operator* ( const SkM44 &  a, const SkM44 &  b  )

friend

Definition at line 347 of file SkM44.h.

                                                           {
        return SkM44(a, b);
    }

SkMatrixPriv

friend class SkMatrixPriv

friend

Definition at line 439 of file SkM44.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/include/core/SkM44.h
• third_party/skia/src/core/SkM44.cpp