src/third_party/skia/src/gpu/effects/GrConvexPolyEffect.h

   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 #ifndef GrConvexPolyEffect_DEFINED
   9 #define GrConvexPolyEffect_DEFINED
  10
  11 #include "GrDrawTargetCaps.h"
  12 #include "GrProcessor.h"
  13 #include "GrTypesPriv.h"
  14
  15 class GrGLConvexPolyEffect;
  16 class SkPath;
  17
  18 /**
  19  * An effect that renders a convex polygon. It is intended to be used as a coverage effect.
  20  * Bounding geometry is rendered and the effect computes coverage based on the fragment's
  21  * position relative to the polygon.
  22  */
  23 class GrConvexPolyEffect : public GrFragmentProcessor {
  24 public:
  25     enum {
  26         kMaxEdges = 8,
  27     };
  28
  29     /**
  30      * edges is a set of n edge equations where n is limited to kMaxEdges. It contains 3*n values.
  31      * The edges should form a convex polygon. The positive half-plane is considered to be the
  32      * inside. The equations should be normalized such that the first two coefficients are a unit
  33      * 2d vector.
  34      *
  35      * Currently the edges are specified in device space. In the future we may prefer to specify
  36      * them in src space. There are a number of ways this could be accomplished but we'd probably
  37      * have to modify the effect/shaderbuilder interface to make it possible (e.g. give access
  38      * to the view matrix or untransformed positions in the fragment shader).
  39      */
  40     static GrFragmentProcessor* Create(GrPrimitiveEdgeType edgeType, int n,
  41                                        const SkScalar edges[]) {
  42         if (n <= 0 || n > kMaxEdges || kHairlineAA_GrProcessorEdgeType == edgeType) {
  43             return NULL;
  44         }
  45         return SkNEW_ARGS(GrConvexPolyEffect, (edgeType, n, edges));
  46     }
  47
  48     /**
  49      * Creates an effect that clips against the path. If the path is not a convex polygon, is
  50      * inverse filled, or has too many edges, this will return NULL. If offset is non-NULL, then
  51      * the path is translated by the vector.
  52      */
  53     static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPath&,
  54                                        const SkVector* offset = NULL);
  55
  56     /**
  57      * Creates an effect that fills inside the rect with AA edges..
  58      */
  59     static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRect&);
  60
  61     virtual ~GrConvexPolyEffect();
  62
  63     static const char* Name() { return "ConvexPoly"; }
  64
  65     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
  66
  67     int getEdgeCount() const { return fEdgeCount; }
  68
  69     const SkScalar* getEdges() const { return fEdges; }
  70
  71     typedef GrGLConvexPolyEffect GLProcessor;
  72
  73     virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
  74
  75 private:
  76     GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[]);
  77
  78     virtual bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE;
  79
  80     virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
  81
  82     GrPrimitiveEdgeType    fEdgeType;
  83     int                    fEdgeCount;
  84     SkScalar               fEdges[3 * kMaxEdges];
  85
  86     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
  87
  88     typedef GrFragmentProcessor INHERITED;
  89 };
  90
  91
  92 #endif