Changed "Profile" to "Cube" in ColorCube

src/effects/SkColorCubeFilter.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorCubeFilter.h"
 #include "SkColorPriv.h"
 #include "SkOnce.h"
 #include "SkReadBuffer.h"
 #include "SkUnPreMultiply.h"
 #include "SkWriteBuffer.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "GrTBackendProcessorFactory.h"
 #include "GrTexturePriv.h"
 #include "SkGr.h"
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace {
 
-int32_t SkNextColorProfileUniqueID() {
-    static int32_t gColorProfileUniqueID;
+int32_t SkNextColorCubeUniqueID() {
+    static int32_t gColorCubeUniqueID;
     // do a loop in case our global wraps around, as we never want to return a 0
     int32_t genID;
     do {
-        genID = sk_atomic_inc(&gColorProfileUniqueID) + 1;
+        genID = sk_atomic_inc(&gColorCubeUniqueID) + 1;
     } while (0 == genID);
     return genID;
 }
 
 } // end namespace
 
 static const int MIN_CUBE_SIZE = 4;
 static const int MAX_CUBE_SIZE = 64;
 
 static bool is_valid_3D_lut(SkData* cubeData, int cubeDimension) {
     size_t minMemorySize = sizeof(uint8_t) * 4 * cubeDimension * cubeDimension * cubeDimension;
     return (cubeDimension >= MIN_CUBE_SIZE) && (cubeDimension <= MAX_CUBE_SIZE) &&
            (NULL != cubeData) && (cubeData->size() >= minMemorySize);
 }
 
 SkColorFilter* SkColorCubeFilter::Create(SkData* cubeData, int cubeDimension) {
     if (!is_valid_3D_lut(cubeData, cubeDimension)) {
         return NULL;
     }
 
     return SkNEW_ARGS(SkColorCubeFilter, (cubeData, cubeDimension));
 }
 
 SkColorCubeFilter::SkColorCubeFilter(SkData* cubeData, int cubeDimension)
   : fCubeData(SkRef(cubeData))
-  , fUniqueID(SkNextColorProfileUniqueID())
+  , fUniqueID(SkNextColorCubeUniqueID())
   , fCache(cubeDimension) {
 }
 
 uint32_t SkColorCubeFilter::getFlags() const {
     return this->INHERITED::getFlags() | kAlphaUnchanged_Flag;
 }
 
 SkColorCubeFilter::ColorCubeProcesingCache::ColorCubeProcesingCache(int cubeDimension)
   : fCubeDimension(cubeDimension)
   , fLutsInited(false) {
@@ skipping 89 matching lines @@
             SkScalarRoundToInt(gOut * aOut),
             SkScalarRoundToInt(bOut * aOut));
     }
 }
 
 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
 SkColorCubeFilter::SkColorCubeFilter(SkReadBuffer& buffer)
   : fCache(buffer.readInt()) {
     fCubeData.reset(buffer.readByteArrayAsData());
     buffer.validate(is_valid_3D_lut(fCubeData, fCache.cubeDimension()));
-    fUniqueID = SkNextColorProfileUniqueID();
+    fUniqueID = SkNextColorCubeUniqueID();
 }
 #endif
 
 SkFlattenable* SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) {
     int cubeDimension = buffer.readInt();
     SkAutoDataUnref cubeData(buffer.readByteArrayAsData());
     if (!buffer.validate(is_valid_3D_lut(cubeData, cubeDimension))) {
         return NULL;
     }
     return Create(cubeData, cubeDimension);
 }
 
 void SkColorCubeFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt(fCache.cubeDimension());
     buffer.writeDataAsByteArray(fCubeData);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkColorCubeFilter::toString(SkString* str) const {
     str->append("SkColorCubeFilter ");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 #if SK_SUPPORT_GPU
-class GrColorProfileEffect : public GrFragmentProcessor {
+class GrColorCubeEffect : public GrFragmentProcessor {
 public:
     static GrFragmentProcessor* Create(GrTexture* colorCube) {
-        return (NULL != colorCube) ? SkNEW_ARGS(GrColorProfileEffect, (colorCube)) : NULL;
+        return (NULL != colorCube) ? SkNEW_ARGS(GrColorCubeEffect, (colorCube)) : NULL;
     }
 
-    virtual ~GrColorProfileEffect();
+    virtual ~GrColorCubeEffect();
 
     virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
     int colorCubeSize() const { return fColorCubeAccess.getTexture()->width(); }
 
-    static const char* Name() { return "ColorProfile"; }
+    static const char* Name() { return "ColorCube"; }
 
     virtual void onComputeInvariantOutput(GrProcessor::InvariantOutput*) const SK_OVERRIDE;
 
     class GLProcessor : public GrGLFragmentProcessor {
     public:
         GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&);
         virtual ~GLProcessor();
 
         virtual void emitCode(GrGLFPBuilder*,
                               const GrFragmentProcessor&,
@@ skipping 10 matching lines @@
     private:
         GrGLProgramDataManager::UniformHandle fColorCubeSizeUni;
         GrGLProgramDataManager::UniformHandle fColorCubeInvSizeUni;
 
         typedef GrGLFragmentProcessor INHERITED;
     };
 
 private:
     virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
 
-    GrColorProfileEffect(GrTexture* colorCube);
+    GrColorCubeEffect(GrTexture* colorCube);
 
     GrCoordTransform    fColorCubeTransform;
     GrTextureAccess     fColorCubeAccess;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrColorProfileEffect::GrColorProfileEffect(GrTexture* colorCube)
+GrColorCubeEffect::GrColorCubeEffect(GrTexture* colorCube)
     : fColorCubeTransform(kLocal_GrCoordSet, colorCube)
     , fColorCubeAccess(colorCube, "bgra", GrTextureParams::kBilerp_FilterMode) {
     this->addCoordTransform(&fColorCubeTransform);
     this->addTextureAccess(&fColorCubeAccess);
 }
 
-GrColorProfileEffect::~GrColorProfileEffect() {
+GrColorCubeEffect::~GrColorCubeEffect() {
 }
 
-bool GrColorProfileEffect::onIsEqual(const GrProcessor& sBase) const {
-    const GrColorProfileEffect& s = sBase.cast<GrColorProfileEffect>();
+bool GrColorCubeEffect::onIsEqual(const GrProcessor& sBase) const {
+    const GrColorCubeEffect& s = sBase.cast<GrColorCubeEffect>();
     return fColorCubeAccess.getTexture() == s.fColorCubeAccess.getTexture();
 }
 
-const GrBackendFragmentProcessorFactory& GrColorProfileEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<GrColorProfileEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& GrColorCubeEffect::getFactory() const {
+    return GrTBackendFragmentProcessorFactory<GrColorCubeEffect>::getInstance();
 }
 
-void GrColorProfileEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
+void GrColorCubeEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
     inout->setToUnknown();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrColorProfileEffect::GLProcessor::GLProcessor(const GrBackendProcessorFactory& factory,
-                                               const GrProcessor&)
+GrColorCubeEffect::GLProcessor::GLProcessor(const GrBackendProcessorFactory& factory,
+                                            const GrProcessor&)
     : INHERITED(factory) {
 }
 
-GrColorProfileEffect::GLProcessor::~GLProcessor() {
+GrColorCubeEffect::GLProcessor::~GLProcessor() {
 }
 
-void GrColorProfileEffect::GLProcessor::emitCode(GrGLFPBuilder* builder,
-                                                 const GrFragmentProcessor&,
-                                                 const GrProcessorKey&,
-                                                 const char* outputColor,
-                                                 const char* inputColor,
-                                                 const TransformedCoordsArray& coords,
-                                                 const TextureSamplerArray& samplers) {
+void GrColorCubeEffect::GLProcessor::emitCode(GrGLFPBuilder* builder,
+                                              const GrFragmentProcessor&,
+                                              const GrProcessorKey&,
+                                              const char* outputColor,
+                                              const char* inputColor,
+                                              const TransformedCoordsArray& coords,
+                                              const TextureSamplerArray& samplers) {
     if (NULL == inputColor) {
         inputColor = "vec4(1)";
     }
 
     fColorCubeSizeUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kFloat_GrSLType, "Size");
     const char* colorCubeSizeUni = builder->getUniformCStr(fColorCubeSizeUni);
     fColorCubeInvSizeUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                kFloat_GrSLType, "InvSize");
     const char* colorCubeInvSizeUni = builder->getUniformCStr(fColorCubeInvSizeUni);
@@ skipping 30 matching lines @@
     fsBuilder->codeAppendf("%s = vec4(mix(", outputColor);
     fsBuilder->appendTextureLookup(samplers[0], cCoords1, coords[0].getType());
     fsBuilder->codeAppend(".rgb, ");
     fsBuilder->appendTextureLookup(samplers[0], cCoords2, coords[0].getType());
 
     // Premultiply color by alpha. Note that the input alpha is not modified by this shader.
     fsBuilder->codeAppendf(".rgb, fract(%s.b)) * vec3(%s), %s.a);\n",
                            cubeIdx, nonZeroAlpha, inputColor);
 }
 
-void GrColorProfileEffect::GLProcessor::setData(const GrGLProgramDataManager& pdman,
-                                                const GrProcessor& proc) {
-    const GrColorProfileEffect& colorProfile = proc.cast<GrColorProfileEffect>();
-    SkScalar size = SkIntToScalar(colorProfile.colorCubeSize());
+void GrColorCubeEffect::GLProcessor::setData(const GrGLProgramDataManager& pdman,
+                                             const GrProcessor& proc) {
+    const GrColorCubeEffect& colorCube = proc.cast<GrColorCubeEffect>();
+    SkScalar size = SkIntToScalar(colorCube.colorCubeSize());
     pdman.set1f(fColorCubeSizeUni, SkScalarToFloat(size));
     pdman.set1f(fColorCubeInvSizeUni, SkScalarToFloat(SkScalarInvert(size)));
 }
 
-void GrColorProfileEffect::GLProcessor::GenKey(const GrProcessor& proc,
-                                               const GrGLCaps&, GrProcessorKeyBuilder* b) {
+void GrColorCubeEffect::GLProcessor::GenKey(const GrProcessor& proc,
+                                            const GrGLCaps&, GrProcessorKeyBuilder* b) {
     b->add32(1); // Always same shader for now
 }
 
 GrFragmentProcessor* SkColorCubeFilter::asFragmentProcessor(GrContext* context) const {
     static const GrCacheID::Domain gCubeDomain = GrCacheID::GenerateDomain();
 
     GrCacheID::Key key;
     key.fData32[0] = fUniqueID;
     key.fData32[1] = fCache.cubeDimension();
     key.fData64[1] = 0;
     GrCacheID cacheID(gCubeDomain, key);
 
     GrTextureDesc desc;
     desc.fWidth = fCache.cubeDimension();
     desc.fHeight = fCache.cubeDimension() * fCache.cubeDimension();
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
     SkAutoTUnref<GrTexture> textureCube(
         static_cast<GrTexture*>(context->findAndRefCachedResource(
             GrTexturePriv::ComputeKey(context->getGpu(), NULL, desc, cacheID))));
 
     if (!textureCube) {
         textureCube.reset(context->createTexture(NULL, desc, cacheID, fCubeData->data(), 0));
     }
 
-    return textureCube ? GrColorProfileEffect::Create(textureCube) : NULL;
+    return textureCube ? GrColorCubeEffect::Create(textureCube) : NULL;
 }
 #endif