Line data    Source code

       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           0 : void GrGLSLXferProcessor::emitCode(const EmitArgs& args) {
      17           0 :     if (!args.fXP.willReadDstColor()) {
      18           0 :         this->emitOutputsForBlendState(args);
      19           0 :         return;
      20             :     }
      21             : 
      22           0 :     GrGLSLXPFragmentBuilder* fragBuilder = args.fXPFragBuilder;
      23           0 :     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
      24           0 :     const char* dstColor = fragBuilder->dstColor();
      25             : 
      26           0 :     bool needsLocalOutColor = false;
      27             : 
      28           0 :     if (args.fDstTextureSamplerHandle.isValid()) {
      29           0 :         bool flipY = kBottomLeft_GrSurfaceOrigin == args.fDstTextureOrigin;
      30             : 
      31           0 :         if (args.fInputCoverage) {
      32             :             // We don't think any shaders actually output negative coverage, but just as a safety
      33             :             // check for floating point precision errors we compare with <= here
      34           0 :             fragBuilder->codeAppendf("if (all(lessThanEqual(%s, vec4(0)))) {"
      35             :                                      "    discard;"
      36           0 :                                      "}", args.fInputCoverage);
      37             :         }
      38             : 
      39             :         const char* dstTopLeftName;
      40             :         const char* dstCoordScaleName;
      41             : 
      42             :         fDstTopLeftUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
      43             :                                                     kVec2f_GrSLType,
      44             :                                                     kDefault_GrSLPrecision,
      45             :                                                     "DstTextureUpperLeft",
      46           0 :                                                     &dstTopLeftName);
      47             :         fDstScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
      48             :                                                   kVec2f_GrSLType,
      49             :                                                   kDefault_GrSLPrecision,
      50             :                                                   "DstTextureCoordScale",
      51           0 :                                                   &dstCoordScaleName);
      52             : 
      53           0 :         fragBuilder->codeAppend("// Read color from copy of the destination.\n");
      54           0 :         fragBuilder->codeAppendf("vec2 _dstTexCoord = (sk_FragCoord.xy - %s) * %s;",
      55           0 :                                  dstTopLeftName, dstCoordScaleName);
      56             : 
      57           0 :         if (flipY) {
      58           0 :             fragBuilder->codeAppend("_dstTexCoord.y = 1.0 - _dstTexCoord.y;");
      59             :         }
      60             : 
      61           0 :         fragBuilder->codeAppendf("vec4 %s = ", dstColor);
      62           0 :         fragBuilder->appendTextureLookup(args.fDstTextureSamplerHandle, "_dstTexCoord",
      63           0 :                                          kVec2f_GrSLType);
      64           0 :         fragBuilder->codeAppend(";");
      65             :     } else {
      66           0 :         needsLocalOutColor = args.fShaderCaps->requiresLocalOutputColorForFBFetch();
      67             :     }
      68             : 
      69           0 :     const char* outColor = "_localColorOut";
      70           0 :     if (!needsLocalOutColor) {
      71           0 :         outColor = args.fOutputPrimary;
      72             :     } else {
      73           0 :         fragBuilder->codeAppendf("vec4 %s;", outColor);
      74             :     }
      75             : 
      76           0 :     this->emitBlendCodeForDstRead(fragBuilder,
      77             :                                   uniformHandler,
      78           0 :                                   args.fInputColor,
      79           0 :                                   args.fInputCoverage,
      80             :                                   dstColor,
      81             :                                   outColor,
      82           0 :                                   args.fOutputSecondary,
      83           0 :                                   args.fXP);
      84           0 :     if (needsLocalOutColor) {
      85           0 :         fragBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, outColor);
      86             :     }
      87             : }
      88             : 
      89           0 : void GrGLSLXferProcessor::setData(const GrGLSLProgramDataManager& pdm, const GrXferProcessor& xp,
      90             :                                   const GrTexture* dstTexture, const SkIPoint& dstTextureOffset) {
      91           0 :     if (dstTexture) {
      92           0 :         if (fDstTopLeftUni.isValid()) {
      93           0 :             pdm.set2f(fDstTopLeftUni, static_cast<float>(dstTextureOffset.fX),
      94           0 :                       static_cast<float>(dstTextureOffset.fY));
      95           0 :             pdm.set2f(fDstScaleUni, 1.f / dstTexture->width(), 1.f / dstTexture->height());
      96             :         } else {
      97           0 :             SkASSERT(!fDstScaleUni.isValid());
      98             :         }
      99             :     } else {
     100           0 :         SkASSERT(!fDstTopLeftUni.isValid());
     101           0 :         SkASSERT(!fDstScaleUni.isValid());
     102             :     }
     103           0 :     this->onSetData(pdm, xp);
     104           0 : }
     105             : 
     106           0 : void GrGLSLXferProcessor::DefaultCoverageModulation(GrGLSLXPFragmentBuilder* fragBuilder,
     107             :                                                     const char* srcCoverage,
     108             :                                                     const char* dstColor,
     109             :                                                     const char* outColor,
     110             :                                                     const char* outColorSecondary,
     111             :                                                     const GrXferProcessor& proc) {
     112           0 :     if (proc.dstReadUsesMixedSamples()) {
     113           0 :         if (srcCoverage) {
     114           0 :             fragBuilder->codeAppendf("%s *= %s;", outColor, srcCoverage);
     115           0 :             fragBuilder->codeAppendf("%s = %s;", outColorSecondary, srcCoverage);
     116             :         } else {
     117           0 :             fragBuilder->codeAppendf("%s = vec4(1.0);", outColorSecondary);
     118             :         }
     119           0 :     } else if (srcCoverage) {
     120           0 :         fragBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
     121           0 :                                  outColor, srcCoverage, outColor, srcCoverage, dstColor);
     122             :     }
     123           0 : }