DNC - JSON of flattenables, with field names.

src/effects/SkLightingImageFilter.cpp

 /*
  * Copyright 2012 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 "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 308 matching lines @@
     point.fX = buffer.readScalar();
     point.fY = buffer.readScalar();
     point.fZ = buffer.readScalar();
     buffer.validate(SkScalarIsFinite(point.fX) &&
                     SkScalarIsFinite(point.fY) &&
                     SkScalarIsFinite(point.fZ));
     return point;
 };
 
 void writePoint3(const SkPoint3& point, SkWriteBuffer& buffer) {
-    buffer.writeScalar(point.fX);
-    buffer.writeScalar(point.fY);
-    buffer.writeScalar(point.fZ);
+    buffer.writeScalar("fX", point.fX);
+    buffer.writeScalar("fY", point.fY);
+    buffer.writeScalar("fZ", point.fZ);
 };
 
 enum BoundaryMode {
     kTopLeft_BoundaryMode,
     kTop_BoundaryMode,
     kTopRight_BoundaryMode,
     kLeft_BoundaryMode,
     kInterior_BoundaryMode,
     kRight_BoundaryMode,
     kBottomLeft_BoundaryMode,
@@ skipping 680 matching lines @@
        fSpecularExponent(specularExponent),
        fCosOuterConeAngle(cosOuterConeAngle),
        fCosInnerConeAngle(cosInnerConeAngle),
        fConeScale(coneScale),
        fS(s)
     {
     }
     void onFlattenLight(SkWriteBuffer& buffer) const override {
         writePoint3(fLocation, buffer);
         writePoint3(fTarget, buffer);
-        buffer.writeScalar(fSpecularExponent);
-        buffer.writeScalar(fCosOuterConeAngle);
-        buffer.writeScalar(fCosInnerConeAngle);
-        buffer.writeScalar(fConeScale);
+        buffer.writeScalar("fSpecularExponent", fSpecularExponent);
+        buffer.writeScalar("fCosOuterConeAngle", fCosOuterConeAngle);
+        buffer.writeScalar("fCosInnerConeAngle", fCosInnerConeAngle);
+        buffer.writeScalar("fConeScale", fConeScale);
         writePoint3(fS, buffer);
     }
 
     bool isEqual(const SkImageFilterLight& other) const override {
         if (other.type() != kSpot_LightType) {
             return false;
         }
 
         const SkSpotLight& o = static_cast<const SkSpotLight&>(other);
         return INHERITED::isEqual(other) &&
@@ skipping 20 matching lines @@
 
 // According to the spec, the specular term should be in the range [1, 128] :
 // http://www.w3.org/TR/SVG/filters.html#feSpecularLightingSpecularExponentAttribute
 const SkScalar SkSpotLight::kSpecularExponentMin = 1.0f;
 const SkScalar SkSpotLight::kSpecularExponentMax = 128.0f;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkImageFilterLight::flattenLight(SkWriteBuffer& buffer) const {
     // Write type first, then baseclass, then subclass.
-    buffer.writeInt(this->type());
+    buffer.writeInt("type", this->type());
     writePoint3(fColor, buffer);
     this->onFlattenLight(buffer);
 }
 
 /*static*/ SkImageFilterLight* SkImageFilterLight::UnflattenLight(SkReadBuffer& buffer) {
     // Read type first.
     const SkImageFilterLight::LightType type = (SkImageFilterLight::LightType)buffer.readInt();
     switch (type) {
         // Each of these constructors must first call SkLight's, so we'll read the baseclass
         // then subclass, same order as flattenLight.
@@ skipping 94 matching lines @@
                                                                 const CropRect* cropRect) {
     sk_sp<SkImageFilterLight> light(
             new SkSpotLight(location, target, specularExponent, cutoffAngle, lightColor));
     return SkSpecularLightingImageFilter::Make(std::move(light), surfaceScale, ks, shine,
                                                std::move(input), cropRect);
 }
 
 void SkLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     fLight->flattenLight(buffer);
-    buffer.writeScalar(fSurfaceScale * 255);
+    buffer.writeScalar("fSurfaceScale", fSurfaceScale * 255);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkImageFilter> SkDiffuseLightingImageFilter::Make(sk_sp<SkImageFilterLight> light,
                                                         SkScalar surfaceScale,
                                                         SkScalar kd,
                                                         sk_sp<SkImageFilter> input,
                                                         const CropRect* cropRect) {
     if (!light) {
@@ skipping 23 matching lines @@
 sk_sp<SkFlattenable> SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     sk_sp<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar kd = buffer.readScalar();
     return Make(std::move(light), surfaceScale, kd, common.getInput(0), &common.cropRect());
 }
 
 void SkDiffuseLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
-    buffer.writeScalar(fKD);
+    buffer.writeScalar("fKD", fKD);
 }
 
 sk_sp<SkSpecialImage> SkDiffuseLightingImageFilter::onFilterImage(SkSpecialImage* source,
                                                                   const Context& ctx,
                                                                   SkIPoint* offset) const {
     SkIPoint inputOffset = SkIPoint::Make(0, 0);
     sk_sp<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset));
     if (!input) {
         return nullptr;
     }
@@ skipping 143 matching lines @@
     sk_sp<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar ks = buffer.readScalar();
     SkScalar shine = buffer.readScalar();
     return Make(std::move(light), surfaceScale, ks, shine, common.getInput(0),
                 &common.cropRect());
 }
 
 void SkSpecularLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
-    buffer.writeScalar(fKS);
-    buffer.writeScalar(fShininess);
+    buffer.writeScalar("fKS", fKS);
+    buffer.writeScalar("fShininess", fShininess);
 }
 
 sk_sp<SkSpecialImage> SkSpecularLightingImageFilter::onFilterImage(SkSpecialImage* source,
                                                                    const Context& ctx,
                                                                    SkIPoint* offset) const {
     SkIPoint inputOffset = SkIPoint::Make(0, 0);
     sk_sp<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset));
     if (!input) {
         return nullptr;
     }
@@ skipping 760 matching lines @@
 
     fragBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END