Compile-time initialize special SkMatrices.

src/core/SkMatrix.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkFloatBits.h"
-#include "SkLazyPtr.h"
 #include "SkString.h"
 
+#include <stddef.h>

[reed1, 2014/06/02 18:39:50]

is this not already included (directly/indirectly) by SkTypes.h?

[mtklein, 2014/06/02 18:40:31]

Nope.  offsetof wasn't defined until I included this.

+
 // In a few places, we performed the following
 //      a * b + c * d + e
 // as
 //      a * b + (c * d + e)
 //
 // sdot and scross are indended to capture these compound operations into a
 // function, with an eye toward considering upscaling the intermediates to
 // doubles for more precision (as we do in concat and invert).
 //
 // However, these few lines that performed the last add before the "dot", cause
@@ skipping 1530 matching lines @@
         return -1;
     }
 }
 
 bool SkMatrix::getMinMaxScales(SkScalar scaleFactors[2]) const {
     return get_scale_factor<kBoth_MinMaxOrBoth>(this->getType(), fMat, scaleFactors);
 }
 
 namespace {
 
-SkMatrix* create_identity() {
-    SkMatrix* m = SkNEW(SkMatrix);
-    m->reset();
-    return m;
-}
+struct PODMatrix {
+    SkScalar matrix[9];
+    uint32_t typemask;
 
-SkMatrix* create_invalid() {
-    SkMatrix* m = SkNEW(SkMatrix);
-    m->setAll(SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
-              SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
-              SK_ScalarMax, SK_ScalarMax, SK_ScalarMax);
-    m->getType();  // Force the type to be computed.
-    return m;
-}
+    const SkMatrix& asSkMatrix() const { return *reinterpret_cast<const SkMatrix*>(this); }

[bungeman-skia, 2014/06/02 17:46:32]

This cast is implementation defined. Of course, we'd break all over the place if
this didn't work. We already assert that they have the same sizeof, so they
should have the same alignment constraints as well.

+};
+SK_COMPILE_ASSERT(sizeof(PODMatrix) == sizeof(SkMatrix), PODMatrixSizeMismatch);
 
 }  // namespace
 
 const SkMatrix& SkMatrix::I() {
-    SK_DECLARE_STATIC_LAZY_PTR(SkMatrix, identity, create_identity);
-    return *identity.get();
+    SK_COMPILE_ASSERT(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   BadfMat);
+    SK_COMPILE_ASSERT(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), BadfTypeMask);
+
+    static const PODMatrix identity = { {SK_Scalar1, 0, 0,
+                                         0, SK_Scalar1, 0,
+                                         0, 0, SK_Scalar1 },
+                                       kIdentity_Mask | kRectStaysRect_Mask};
+    SkASSERT(identity.asSkMatrix().isIdentity());
+    return identity.asSkMatrix();
 }
 
 const SkMatrix& SkMatrix::InvalidMatrix() {
-    SK_DECLARE_STATIC_LAZY_PTR(SkMatrix, invalid, create_invalid);
-    return *invalid.get();
+    SK_COMPILE_ASSERT(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   BadfMat);
+    SK_COMPILE_ASSERT(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), BadfTypeMask);
+
+    static const PODMatrix invalid =
+        { {SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
+           SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
+           SK_ScalarMax, SK_ScalarMax, SK_ScalarMax },
+         kTranslate_Mask | kScale_Mask | kAffine_Mask | kPerspective_Mask };
+    return invalid.asSkMatrix();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 size_t SkMatrix::writeToMemory(void* buffer) const {
     // TODO write less for simple matrices
     static const size_t sizeInMemory = 9 * sizeof(SkScalar);
     if (buffer) {
         memcpy(buffer, fMat, sizeInMemory);
     }
@@ skipping 174 matching lines @@
         rotation1->fX = cos1;
         rotation1->fY = sin1;
     }
     if (NULL != rotation2) {
         rotation2->fX = cos2;
         rotation2->fY = sin2;
     }
 
     return true;
 }