Add interface to SkXfermode to return a GrEffect and blend coeffs.

include/core/SkXfermode.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkXfermode_DEFINED
 #define SkXfermode_DEFINED
 
 #include "SkFlattenable.h"
 #include "SkColor.h"
 
+class GrContext;
+class GrEffectRef;
 class SkString;
 
 /** \class SkXfermode
 
     SkXfermode is the base class for objects that are called to implement custom
     "transfer-modes" in the drawing pipeline. The static function Create(Modes)
     can be called to return an instance of any of the predefined subclasses as
     specified in the Modes enum. When an SkXfermode is assigned to an SkPaint,
     then objects drawn with that paint have the xfermode applied.
 */
@@ skipping 41 matching lines @@
         clear       zero            zero
         src         one             zero
         dst         zero            one
         srcover     one             isa
         dstover     ida             one
      */
     virtual bool asCoeff(Coeff* src, Coeff* dst) const;
 
     /**
      *  The same as calling xfermode->asCoeff(..), except that this also checks
-     *  if the xfermode is NULL, and if so, treats its as kSrcOver_Mode.
+     *  if the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
      */
     static bool AsCoeff(const SkXfermode*, Coeff* src, Coeff* dst);
 
     /** List of predefined xfermodes.
         The algebra for the modes uses the following symbols:
         Sa, Sc  - source alpha and color
         Da, Dc - destination alpha and color (before compositing)
         [a, c] - Resulting (alpha, color) values
         For these equations, the colors are in premultiplied state.
         If no xfermode is specified, kSrcOver is assumed.
@@ skipping 41 matching lines @@
 
     /**
      *  If the xfermode is one of the modes in the Mode enum, then asMode()
      *  returns true and sets (if not null) mode accordingly. Otherwise it
      *  returns false and ignores the mode parameter.
      */
     virtual bool asMode(Mode* mode) const;
 
     /**
      *  The same as calling xfermode->asMode(mode), except that this also checks
-     *  if the xfermode is NULL, and if so, treats its as kSrcOver_Mode.
+     *  if the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
      */
     static bool AsMode(const SkXfermode*, Mode* mode);
 
     /**
      *  Returns true if the xfermode claims to be the specified Mode. This works
      *  correctly even if the xfermode is NULL (which equates to kSrcOver.) Thus
      *  you can say this without checking for a null...
      *
      *  If (SkXfermode::IsMode(paint.getXfermode(),
      *                         SkXfermode::kDstOver_Mode)) {
@@ skipping 24 matching lines @@
      *  not representable as a pair of Coeffs, return false and ignore the
      *  src and dst parameters.
      */
     static bool ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst);
 
     // DEPRECATED: call AsMode(...)
     static bool IsMode(const SkXfermode* xfer, Mode* mode) {
         return AsMode(xfer, mode);
     }
 
+    /** A subclass may implement this factory function to work with the GPU backend. It is legal

[robertphillips, 2013/03/27 18:12:09]

will -> with

[bsalomon, 2013/03/27 18:39:42]

Done.

+        to call this will all but the context param NULL to simply test the return value. effect,
+        src, and dst must all be NULL or all non-NULL. If effect is non-NULL before this function
+        is called then the xfermode may optionally allocate an effect to return and the caller will
+        install it and own a ref to it. If the function returns true then the src and dst coeffs
+        will be applied to the draw.
+     */
+    virtual bool asNewEffect(GrContext*, GrEffectRef** effect, Coeff* src, Coeff* dst) const;
+
+    /**
+     *  The same as calling xfermode->asNewEffect(...), except that this also checks if the xfermode
+     *  is NULL, and if so, treats it as kSrcOver_Mode.
+     */
+    static bool AsNewEffect(SkXfermode*, GrContext*, GrEffectRef** effect, Coeff* src, Coeff* dst);
+
     SkDEVCODE(virtual void toString(SkString* str) const = 0;)
     SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
 protected:
     SkXfermode(SkFlattenableReadBuffer& rb) : SkFlattenable(rb) {}
 
     /** The default implementation of xfer32/xfer16/xferA8 in turn call this
         method, 1 color at a time (upscaled to a SkPMColor). The default
         implmentation of this method just returns dst. If performance is
         important, your subclass should override xfer32/xfer16/xferA8 directly.
 
@@ skipping 42 matching lines @@
         fProc = proc;
     }
 
 private:
     SkXfermodeProc  fProc;
 
     typedef SkXfermode INHERITED;
 };
 
 #endif