SkValue: SkXfermode

src/effects/SkToFromValue.cpp

+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkArithmeticMode.h"
+#include "SkLerpXfermode.h"
+#include "SkMatrix.h"
+#include "SkPixelXorXfermode.h"
+#include "SkToFromValue.h"
+#include "SkValueKeys.h"
+#include "SkXfermode.h"
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define REQUIRE(cond) do { if (!(cond)) { SkASSERT(false); return false; } } while (false)
+
+#define OPTIONAL_KEY(VAL, KEY, PTR)            \

[mtklein, 2016/01/21 17:46:19]

Update the spacing now that you've added _KEY?

[hal.canary, 2016/01/21 18:35:21]

done.

+    do {                                   \
+        if (auto v = (VAL).get(KEY)) {     \
+            REQUIRE(SkFromValue(*v, PTR)); \
+        }                                  \
+    } while (false)
+
+#define MANDATORY_KEY(VAL, KEY, PTR)            \
+    do {                                    \
+        auto v = (VAL).get(KEY);            \
+        REQUIRE(v && SkFromValue(*v, PTR)); \
+    } while (false)
+
+template<> bool SkFromValue<float>(const SkValue& val, float* f) {
+    REQUIRE(val.type() == SkValue::F32);
+    *f = val.f32();
+    return true;
+}
+
+template<> bool SkFromValue<int32_t>(const SkValue& val, int32_t* x) {
+    REQUIRE(val.type() == SkValue::S32);
+    *x = val.s32();
+    return true;
+}
+
+template<> bool SkFromValue<uint32_t>(const SkValue& val, uint32_t* x) {
+    REQUIRE(val.type() == SkValue::U32);
+    *x = val.u32();
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template<> SkValue SkToValue<SkMatrix>(const SkMatrix& mat) {
+    auto val = SkValue::Object(SkValue::Matrix);
+    for (int i = 0; i < 9; ++i) {
+        if (mat[i] != SkMatrix::I()[i]) {
+            val.set(i, SkValue::FromF32(mat[i]));
+        }
+    }
+    return val;
+}
+
+template<> bool SkFromValue<SkMatrix>(const SkValue& val, SkMatrix* m){
+    REQUIRE(val.type() == SkValue::Matrix);
+    *m = SkMatrix::I();
+    for (int i = 0; i < 9; i++) {
+        OPTIONAL_KEY(val, i, &(*m)[i]);
+    }
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template<> SkValue SkToValue<SkXfermode>(const SkXfermode* x) {
+    return x ? x->asValue() : SkValue::Object(SkValue::DefaultXfermode);
+}
+
+template<> bool SkFromValue< SkAutoTUnref<SkXfermode> >(
+        const SkValue& val, SkAutoTUnref<SkXfermode>* dst) {
+    SkXfermode* mode;
+    REQUIRE(SkFromValue(val, &mode));
+    dst->reset(mode);
+    return true;
+}
+
+template<> bool SkFromValue<SkXfermode*>(const SkValue& val, SkXfermode** dst) {
+    switch (val.type()) {

[mtklein, 2016/01/21 17:46:19]

I think we'll be happier in the long term if we split apart the type switch and
hide the logic of how to parse each type in a little static function (where we
can using namespace the appropriate keys).

switch (val.type()) {
    case SkValue::   DefaultXfermode: return    from_DefaultXfermode(val, dst);
    case SkValue::ArithmeticXfermode: return from_ArithmeticXfermode(val, dst);
    ...
    default: REQUIRE(false);
}

[hal.canary, 2016/01/21 18:35:21]

I was considering that, but never got around to it.

Done.

+        case SkValue::DefaultXfermode:
+            *dst = nullptr;
+            return true;
+        case SkValue::ArithmeticXfermode: {
+            float k[4] = {0.0f, 0.0f, 0.0f, 0.0f};

[mtklein, 2016/01/21 17:46:19]

There's no need to initialize mandatory things, right?

[hal.canary, 2016/01/21 18:35:21]

right.  that was leftover.

+            int32_t enforce = true;
+            MANDATORY_KEY(val, SkValueKeys::ArithmeticXfermode::kK0, &k[0]);
+            MANDATORY_KEY(val, SkValueKeys::ArithmeticXfermode::kK1, &k[1]);
+            MANDATORY_KEY(val, SkValueKeys::ArithmeticXfermode::kK2, &k[2]);
+            MANDATORY_KEY(val, SkValueKeys::ArithmeticXfermode::kK3, &k[3]);
+            OPTIONAL_KEY(val, SkValueKeys::ArithmeticXfermode::kEnforcePMColor, &enforce);
+            *dst = SkArithmeticMode::Create(
+                    k[0], k[1], k[2], k[3], SkToBool(enforce));
+            return true;
+        }
+        case SkValue::LerpXfermode: {
+            float scale = 0;
+            MANDATORY_KEY(val, SkValueKeys::LerpXfermode::kScale, &scale);
+            *dst = SkLerpXfermode::Create(scale);
+            return true;
+        }
+        case SkValue::PixelXorXfermode: {
+            uint32_t opColor = 0;
+            MANDATORY_KEY(val, SkValueKeys::PixelXorXfermode::kOpColor, &opColor);
+            *dst = SkPixelXorXfermode::Create(opColor);
+            return true;
+        }
+        case SkValue::ProcCoeffXfermode: {
+            uint32_t mode = 0;
+            MANDATORY_KEY(val, SkValueKeys::ProcCoeffXfermode::kMode, &mode);
+            *dst = SkXfermode::Create((SkXfermode::Mode)mode);
+            return true;
+        }
+        default:
+            SkASSERT(false);
+            return false;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#undef REQUIRE
+#undef OPTIONAL_KEY
+#undef MANDATORY_KEY
+