Add color gamut xform helpers to GrGLSLShaderBuilder

src/gpu/glsl/GrGLSLShaderBuilder.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 "GrSwizzle.h"
 #include "glsl/GrGLSLShaderBuilder.h"
 #include "glsl/GrGLSLCaps.h"
+#include "glsl/GrGLSLColorSpaceXformHelper.h"
 #include "glsl/GrGLSLShaderVar.h"
 #include "glsl/GrGLSLSampler.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 
 GrGLSLShaderBuilder::GrGLSLShaderBuilder(GrGLSLProgramBuilder* program)
     : fProgramBuilder(program)
     , fInputs(GrGLSLProgramBuilder::kVarsPerBlock)
     , fOutputs(GrGLSLProgramBuilder::kVarsPerBlock)
     , fFeaturesAddedMask(0)
     , fCodeIndex(kCode)
@@ skipping 70 matching lines @@
                      GrGLSLTexture2DFunctionName(varyingType, samplerType, glslCaps->generation()),
                      sampler.getSamplerNameForTexture2D(),
                      coordName);
     }
 
     this->appendTextureSwizzle(out, sampler.config());
 }
 
 void GrGLSLShaderBuilder::appendTextureLookup(SamplerHandle samplerHandle,
                                               const char* coordName,
-                                              GrSLType varyingType) {
-    this->appendTextureLookup(&this->code(), samplerHandle, coordName, varyingType);
+                                              GrSLType varyingType,
+                                              GrGLSLColorSpaceXformHelper* colorXformHelper) {
+    if (colorXformHelper && colorXformHelper->getXformMatrix()) {
+        // With a color gamut transform, we need to wrap the lookup in another function call
+        SkString lookup;
+        this->appendTextureLookup(&lookup, samplerHandle, coordName, varyingType);
+        this->appendColorGamutXform(lookup.c_str(), colorXformHelper);
+    } else {
+        this->appendTextureLookup(&this->code(), samplerHandle, coordName, varyingType);
+    }
 }
 
-void GrGLSLShaderBuilder::appendTextureLookupAndModulate(const char* modulation,
-                                                         SamplerHandle samplerHandle,
-                                                         const char* coordName,
-                                                         GrSLType varyingType) {
+void GrGLSLShaderBuilder::appendTextureLookupAndModulate(
+                                                    const char* modulation,
+                                                    SamplerHandle samplerHandle,
+                                                    const char* coordName,
+                                                    GrSLType varyingType,
+                                                    GrGLSLColorSpaceXformHelper* colorXformHelper) {
     SkString lookup;
     this->appendTextureLookup(&lookup, samplerHandle, coordName, varyingType);
-    this->codeAppend((GrGLSLExpr4(modulation) * GrGLSLExpr4(lookup)).c_str());
+    if (colorXformHelper && colorXformHelper->getXformMatrix()) {
+        SkString xform;
+        this->appendColorGamutXform(&xform, lookup.c_str(), colorXformHelper);
+        this->codeAppend((GrGLSLExpr4(modulation) * GrGLSLExpr4(xform)).c_str());
+    } else {
+        this->codeAppend((GrGLSLExpr4(modulation) * GrGLSLExpr4(lookup)).c_str());
+    }
+}
+
+void GrGLSLShaderBuilder::appendColorGamutXform(SkString* out,
+                                                const char* srcColor,
+                                                GrGLSLColorSpaceXformHelper* colorXformHelper) {
+    // Our color is (r, g, b, a), but we want to multiply (r, g, b, 1) by our matrix, then
+    // re-insert the original alpha. The supplied srcColor is likely to be of the form
+    // "texture(...)", and we don't want to evaluate that twice.
+    //
+    // Worse: We can't do the transformation on premultiplied colors, so if the source is premul,
+    // we need to unpremul, transform, then multiply again. Anyways, we wrap all of the work in a
+    // function.
+    static const GrGLSLShaderVar gColorGamutXformArgs[] = {
+        GrGLSLShaderVar("color", kVec4f_GrSLType),
+        GrGLSLShaderVar("xform", kMat44f_GrSLType),
+    };
+    SkString functionBody;
+    if (kPremul_SkAlphaType == colorXformHelper->alphaType()) {
+        // Unpremultiply
+        functionBody.append("\tfloat nonZeroAlpha = max(color.a, 0.00001);\n"
+                            "\tcolor.rgb = color.rgb / nonZeroAlpha;\n");
+    }
+    // Gamut xform, clamp to destination gamut
+    functionBody.append("\tcolor.rgb = clamp((vec4(color.rgb, 1.0) * xform).rgb, 0.0, 1.0);\n");
+    if (kPremul_SkAlphaType == colorXformHelper->alphaType()) {
+        // Re-multiply by alpha
+        functionBody.append("\tcolor.rgb = color.rgb * nonZeroAlpha;\n");
+    }
+    functionBody.append("\treturn color;");
+    SkString colorGamutXformFuncName;
+    this->emitFunction(kVec4f_GrSLType,
+                       "colorGamutXform",
+                       SK_ARRAY_COUNT(gColorGamutXformArgs),
+                       gColorGamutXformArgs,
+                       functionBody.c_str(),
+                       &colorGamutXformFuncName);
+
+    out->appendf("%s(%s, %s)", colorGamutXformFuncName.c_str(), srcColor,
+                 colorXformHelper->getXformMatrix());
+}
+
+void GrGLSLShaderBuilder::appendColorGamutXform(const char* srcColor,
+                                                GrGLSLColorSpaceXformHelper* colorXformHelper) {
+    SkString xform;
+    this->appendColorGamutXform(&xform, srcColor, colorXformHelper);
+    this->codeAppend(xform.c_str());
 }
 
 void GrGLSLShaderBuilder::appendTexelFetch(SkString* out,
                                            SamplerHandle samplerHandle,
                                            const char* coordExpr) const {
     const GrGLSLSampler& sampler = fProgramBuilder->getSampler(samplerHandle);
     SkASSERT(fProgramBuilder->glslCaps()->texelFetchSupport());
     SkASSERT(GrSLTypeIsCombinedSamplerType(sampler.type()));
 
     out->appendf("texelFetch(%s, %s)", sampler.getSamplerNameForTexelFetch(), coordExpr);
@@ skipping 68 matching lines @@
     // append the 'footer' to code
     this->code().append("}");
 
     for (int i = 0; i <= fCodeIndex; i++) {
         fCompilerStrings[i] = fShaderStrings[i].c_str();
         fCompilerStringLengths[i] = (int)fShaderStrings[i].size();
     }
 
     fFinalized = true;
 }