SkMatrix44 clarifications and clean-ups

include/core/SkMatrix44.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkMatrix44_DEFINED
 #define SkMatrix44_DEFINED
 
@@ skipping 118 matching lines @@
 class SK_API SkMatrix44 {
 public:
 
     enum Uninitialized_Constructor {
         kUninitialized_Constructor
     };
     enum Identity_Constructor {
         kIdentity_Constructor
     };
 
-    SkMatrix44(Uninitialized_Constructor) { }
-    SkMatrix44(Identity_Constructor) { this->setIdentity(); }
+    SkMatrix44(Uninitialized_Constructor) {}
+
+    constexpr SkMatrix44(Identity_Constructor)
+        : fMat{{ 1, 0, 0, 0, },
+               { 0, 1, 0, 0, },
+               { 0, 0, 1, 0, },
+               { 0, 0, 0, 1, }}
+        , fTypeMask(kIdentity_Mask)
+    {}
 
     SK_ATTR_DEPRECATED("use the constructors that take an enum")
     SkMatrix44() { this->setIdentity(); }
 
     SkMatrix44(const SkMatrix44& src) {
         memcpy(fMat, src.fMat, sizeof(fMat));
         fTypeMask = src.fTypeMask;
     }
 
     SkMatrix44(const SkMatrix44& a, const SkMatrix44& b) {
@@ skipping 123 matching lines @@
         return SkMScalarToFloat(this->get(row, col));
     }
     inline void setFloat(int row, int col, float value) {
         this->set(row, col, SkFloatToMScalar(value));
     }
 
     /** These methods allow one to efficiently read matrix entries into an
      *  array. The given array must have room for exactly 16 entries. Whenever
      *  possible, they will try to use memcpy rather than an entry-by-entry
      *  copy.
+     *
+     *  Col major indicates that consecutive elements of columns will be stored
+     *  contiguously in memory.  Row major indicates that consecutive elements
+     *  of rows will be stored contiguously in memory.
      */
     void asColMajorf(float[]) const;
     void asColMajord(double[]) const;
     void asRowMajorf(float[]) const;
     void asRowMajord(double[]) const;
 
     /** These methods allow one to efficiently set all matrix entries from an
      *  array. The given array must have room for exactly 16 entries. Whenever
      *  possible, they will try to use memcpy rather than an entry-by-entry
      *  copy.
+     *
+     *  Col major indicates that input memory will be treated as if consecutive
+     *  elements of columns are stored contiguously in memory.  Row major
+     *  indicates that input memory will be treated as if consecutive elements
+     *  of rows are stored contiguously in memory.
      */
     void setColMajorf(const float[]);
     void setColMajord(const double[]);
     void setRowMajorf(const float[]);
     void setRowMajord(const double[]);
 
 #ifdef SK_MSCALAR_IS_FLOAT
     void setColMajor(const SkMScalar data[]) { this->setColMajorf(data); }
     void setRowMajor(const SkMScalar data[]) { this->setRowMajorf(data); }
 #else
     void setColMajor(const SkMScalar data[]) { this->setColMajord(data); }
     void setRowMajor(const SkMScalar data[]) { this->setRowMajord(data); }
 #endif
 
     /* This sets the top-left of the matrix and clears the translation and
-     * perspective components (with [3][3] set to 1). */
+     * perspective components (with [3][3] set to 1).  mXY is interpreted
+     * as the matrix entry at col = X, row = Y. */
     void set3x3(SkMScalar m00, SkMScalar m01, SkMScalar m02,
                 SkMScalar m10, SkMScalar m11, SkMScalar m12,
                 SkMScalar m20, SkMScalar m21, SkMScalar m22);
-    void set3x3ColMajorf(const float[]);
+    void set3x3RowMajorf(const float[]);
 
     void setTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz);
     void preTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz);
     void postTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz);
 
     void setScale(SkMScalar sx, SkMScalar sy, SkMScalar sz);
     void preScale(SkMScalar sx, SkMScalar sy, SkMScalar sz);
     void postScale(SkMScalar sx, SkMScalar sy, SkMScalar sz);
 
     inline void setScale(SkMScalar scale) {
@@ skipping 99 matching lines @@
         a 90-degree rotation can still end up with 10^-17 of
         "non-axis-aligned" result.
      */
     bool preserves2dAxisAlignment(SkMScalar epsilon = SK_ScalarNearlyZero) const;
 
     void dump() const;
 
     double determinant() const;
 
 private:
+    /* This is indexed by [col][row]. */
     SkMScalar           fMat[4][4];
     mutable unsigned    fTypeMask;
 
     enum {
         kUnknown_Mask = 0x80,
 
         kAllPublic_Masks = 0xF
     };
 
-    /** Efficiently reads 12 matrix entries, ignoring the last col.
-     *  This is typically useful when we know the last col is (0, 0, 0, 1).
-     */
     void as4x3ColMajorf(float[]) const;
-
-    /* This sets the top-left of the matrix and clears the
-     * perspective components (with [3][3] set to 1). */
     void set4x3ColMajorf(const float[]);
 
     SkMScalar transX() const { return fMat[3][0]; }
     SkMScalar transY() const { return fMat[3][1]; }
     SkMScalar transZ() const { return fMat[3][2]; }
 
     SkMScalar scaleX() const { return fMat[0][0]; }
     SkMScalar scaleY() const { return fMat[1][1]; }
     SkMScalar scaleZ() const { return fMat[2][2]; }
 
@@ skipping 17 matching lines @@
      *  we already know that this matrix is identity.
      */
     inline bool isTriviallyIdentity() const {
         return 0 == fTypeMask;
     }
 
     friend class SkColorSpace;
 };
 
 #endif