Style Change: NULL->nullptr

src/core/SkLightingShader.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapProcState.h"
 #include "SkColor.h"
@@ skipping 158 matching lines @@
             fLightColor.fX = 0.0f;
             fAmbientColor.fX = 0.0f;
             fInvNormRotation.set(0.0f, 0.0f);
         }
 
         void emitCode(EmitArgs& args) override {
 
             GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder();
 
             // add uniforms
-            const char* lightDirUniName = NULL;
+            const char* lightDirUniName = nullptr;
             fLightDirUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                      kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                      "LightDir", &lightDirUniName);
 
-            const char* lightColorUniName = NULL;
+            const char* lightColorUniName = nullptr;
             fLightColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                        kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                        "LightColor", &lightColorUniName);
 
-            const char* ambientColorUniName = NULL;
+            const char* ambientColorUniName = nullptr;
             fAmbientColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                          kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                          "AmbientColor", &ambientColorUniName);
 
-            const char* xformUniName = NULL;
+            const char* xformUniName = nullptr;
             fXformUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                   kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                   "Xform", &xformUniName);
 
             fpb->codeAppend("vec4 diffuseColor = ");
             fpb->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0], 
                                                 args.fCoords[0].c_str(), 
                                                 args.fCoords[0].getType());
             fpb->codeAppend(";");
 
@@ skipping 366 matching lines @@
     SkMatrix normLocalM;
     bool hasNormLocalM = buf.readBool();
     if (hasNormLocalM) {
         buf.readMatrix(&normLocalM);
     } else {
         normLocalM.reset();
     }
 
     SkBitmap diffuse;
     if (!buf.readBitmap(&diffuse)) {
-        return NULL;
+        return nullptr;
     }
     diffuse.setImmutable();
 
     SkBitmap normal;
     if (!buf.readBitmap(&normal)) {
-        return NULL;
+        return nullptr;
     }
     normal.setImmutable();
 
     int numLights = buf.readInt();
 
     SkLightingShader::Lights::Builder builder;
 
     for (int l = 0; l < numLights; ++l) {
         bool isAmbient = buf.readBool();
 
         SkColor3f color;
         if (!buf.readScalarArray(&color.fX, 3)) {
-            return NULL;
+            return nullptr;
         }
 
         if (isAmbient) {
             builder.add(SkLight(color));
         } else {
             SkVector3 dir;
             if (!buf.readScalarArray(&dir.fX, 3)) {
-                return NULL;
+                return nullptr;
             }
             builder.add(SkLight(color, dir));        
         }
     }
 
     SkAutoTUnref<const SkLightingShader::Lights> lights(builder.finish());
 
     return new SkLightingShaderImpl(diffuse, normal, lights, SkVector::Make(1.0f, 0.0f),
                                     &diffLocalM, &normLocalM);
 }
@@ skipping 39 matching lines @@
 
 SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
                                                          void* storage) const {
 
     SkMatrix diffTotalInv;
     // computeTotalInverse was called in SkShader::createContext so we know it will succeed
     SkAssertResult(this->computeTotalInverse(rec, &diffTotalInv));
 
     SkMatrix normTotalInv;
     if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
-        return NULL;
+        return nullptr;
     }
 
     void* diffuseStateStorage = (char*)storage + sizeof(LightingShaderContext);
     SkBitmapProcState* diffuseState = new (diffuseStateStorage) SkBitmapProcState;
     SkASSERT(diffuseState);
 
     diffuseState->fTileModeX = SkShader::kClamp_TileMode;
     diffuseState->fTileModeY = SkShader::kClamp_TileMode;
     diffuseState->fOrigBitmap = fDiffuseMap;
     if (!diffuseState->chooseProcs(diffTotalInv, *rec.fPaint)) {
         diffuseState->~SkBitmapProcState();
-        return NULL;
+        return nullptr;
     }
 
     void* normalStateStorage = (char*)storage + sizeof(LightingShaderContext) + sizeof(SkBitmapProcState);
     SkBitmapProcState* normalState = new (normalStateStorage) SkBitmapProcState;
     SkASSERT(normalState);
 
     normalState->fTileModeX = SkShader::kClamp_TileMode;
     normalState->fTileModeY = SkShader::kClamp_TileMode;
     normalState->fOrigBitmap = fNormalMap;
     if (!normalState->chooseProcs(normTotalInv, *rec.fPaint)) {
         diffuseState->~SkBitmapProcState();
         normalState->~SkBitmapProcState();
-        return NULL;
+        return nullptr;
     }
 
     return new (storage) LightingShaderContext(*this, rec, diffuseState, normalState);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool bitmap_is_too_big(const SkBitmap& bm) {
     // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it
     // communicates between its matrix-proc and its sampler-proc. Until we can
@@ skipping 21 matching lines @@
                                     normLocalM);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////