src/gpu/glsl/GrGLSLXferProcessor.cpp

   1 /*
   2  * Copyright 2014 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "glsl/GrGLSLXferProcessor.h"
   9
  10 #include "GrShaderCaps.h"
  11 #include "GrXferProcessor.h"
  12 #include "glsl/GrGLSLFragmentShaderBuilder.h"
  13 #include "glsl/GrGLSLProgramDataManager.h"
  14 #include "glsl/GrGLSLUniformHandler.h"
  15
  16 // This is only called for cases where we are doing LCD coverage and not using in shader blending.
  17 // For these cases we assume the the src alpha is 1, thus we can just use the max for the alpha
  18 // coverage since src alpha will always be greater than or equal to dst alpha.
  19 static void adjust_for_lcd_coverage(GrGLSLXPFragmentBuilder* fragBuilder,
  20                                     const char* srcCoverage,
  21                                     const GrXferProcessor& proc) {
  22     if (srcCoverage && proc.isLCD()) {
  23         fragBuilder->codeAppendf("%s.a = max(max(%s.r, %s.g), %s.b);",
  24                                  srcCoverage, srcCoverage, srcCoverage, srcCoverage);
  25     }
  26 }
  27
  28
  29 void GrGLSLXferProcessor::emitCode(const EmitArgs& args) {
  30     if (!args.fXP.willReadDstColor()) {
  31         adjust_for_lcd_coverage(args.fXPFragBuilder, args.fInputCoverage, args.fXP);
  32         this->emitOutputsForBlendState(args);
  33         return;
  34     }
  35
  36     GrGLSLXPFragmentBuilder* fragBuilder = args.fXPFragBuilder;
  37     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
  38     const char* dstColor = fragBuilder->dstColor();
  39
  40     bool needsLocalOutColor = false;
  41
  42     if (args.fDstTextureSamplerHandle.isValid()) {
  43         bool flipY = kBottomLeft_GrSurfaceOrigin == args.fDstTextureOrigin;
  44
  45         if (args.fInputCoverage) {
  46             // We don't think any shaders actually output negative coverage, but just as a safety
  47             // check for floating point precision errors we compare with <= here
  48             fragBuilder->codeAppendf("if (all(lessThanEqual(%s, vec4(0)))) {"
  49                                      "    discard;"
  50                                      "}", args.fInputCoverage);
  51         }
  52
  53         const char* dstTopLeftName;
  54         const char* dstCoordScaleName;
  55
  56         fDstTopLeftUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
  57                                                     kVec2f_GrSLType,
  58                                                     kDefault_GrSLPrecision,
  59                                                     "DstTextureUpperLeft",
  60                                                     &dstTopLeftName);
  61         fDstScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
  62                                                   kVec2f_GrSLType,
  63                                                   kDefault_GrSLPrecision,
  64                                                   "DstTextureCoordScale",
  65                                                   &dstCoordScaleName);
  66
  67         fragBuilder->codeAppend("// Read color from copy of the destination.\n");
  68         fragBuilder->codeAppendf("vec2 _dstTexCoord = (sk_FragCoord.xy - %s) * %s;",
  69                                  dstTopLeftName, dstCoordScaleName);
  70
  71         if (flipY) {
  72             fragBuilder->codeAppend("_dstTexCoord.y = 1.0 - _dstTexCoord.y;");
  73         }
  74
  75         fragBuilder->codeAppendf("vec4 %s = ", dstColor);
  76         fragBuilder->appendTextureLookup(args.fDstTextureSamplerHandle, "_dstTexCoord",
  77                                          kVec2f_GrSLType);
  78         fragBuilder->codeAppend(";");
  79     } else {
  80         needsLocalOutColor = args.fShaderCaps->requiresLocalOutputColorForFBFetch();
  81     }
  82
  83     const char* outColor = "_localColorOut";
  84     if (!needsLocalOutColor) {
  85         outColor = args.fOutputPrimary;
  86     } else {
  87         fragBuilder->codeAppendf("vec4 %s;", outColor);
  88     }
  89
  90     this->emitBlendCodeForDstRead(fragBuilder,
  91                                   uniformHandler,
  92                                   args.fInputColor,
  93                                   args.fInputCoverage,
  94                                   dstColor,
  95                                   outColor,
  96                                   args.fOutputSecondary,
  97                                   args.fXP);
  98     if (needsLocalOutColor) {
  99         fragBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, outColor);
 100     }
 101 }
 102
 103 void GrGLSLXferProcessor::setData(const GrGLSLProgramDataManager& pdm, const GrXferProcessor& xp,
 104                                   const GrTexture* dstTexture, const SkIPoint& dstTextureOffset) {
 105     if (dstTexture) {
 106         if (fDstTopLeftUni.isValid()) {
 107             pdm.set2f(fDstTopLeftUni, static_cast<float>(dstTextureOffset.fX),
 108                       static_cast<float>(dstTextureOffset.fY));
 109             pdm.set2f(fDstScaleUni, 1.f / dstTexture->width(), 1.f / dstTexture->height());
 110         } else {
 111             SkASSERT(!fDstScaleUni.isValid());
 112         }
 113     } else {
 114         SkASSERT(!fDstTopLeftUni.isValid());
 115         SkASSERT(!fDstScaleUni.isValid());
 116     }
 117     this->onSetData(pdm, xp);
 118 }
 119
 120 void GrGLSLXferProcessor::DefaultCoverageModulation(GrGLSLXPFragmentBuilder* fragBuilder,
 121                                                     const char* srcCoverage,
 122                                                     const char* dstColor,
 123                                                     const char* outColor,
 124                                                     const char* outColorSecondary,
 125                                                     const GrXferProcessor& proc) {
 126     if (proc.dstReadUsesMixedSamples()) {
 127         if (srcCoverage) {
 128             SkASSERT(!proc.isLCD());
 129             fragBuilder->codeAppendf("%s *= %s;", outColor, srcCoverage);
 130             fragBuilder->codeAppendf("%s = %s;", outColorSecondary, srcCoverage);
 131         } else {
 132             fragBuilder->codeAppendf("%s = vec4(1.0);", outColorSecondary);
 133         }
 134     } else if (srcCoverage) {
 135         if (proc.isLCD()) {
 136             fragBuilder->codeAppendf("float lerpRed = mix(%s.a, %s.a, %s.r);",
 137                                      dstColor, outColor, srcCoverage);
 138             fragBuilder->codeAppendf("float lerpBlue = mix(%s.a, %s.a, %s.g);",
 139                                      dstColor, outColor, srcCoverage);
 140             fragBuilder->codeAppendf("float lerpGreen = mix(%s.a, %s.a, %s.b);",
 141                                      dstColor, outColor, srcCoverage);
 142         }
 143         fragBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
 144                                  outColor, srcCoverage, outColor, srcCoverage, dstColor);
 145         if (proc.isLCD()) {
 146             fragBuilder->codeAppendf("%s.a = max(max(lerpRed, lerpBlue), lerpGreen);", outColor);
 147         }
 148     }
 149 }
 150