1
2/*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9#ifndef GrPathRenderer_DEFINED
10#define GrPathRenderer_DEFINED
11
12#include "GrDrawTarget.h"
13#include "GrPathRendererChain.h"
14#include "GrStencil.h"
15
16#include "SkDrawProcs.h"
17#include "SkStrokeRec.h"
18#include "SkTArray.h"
19
20class SkPath;
21
22struct GrPoint;
23
24/**
25 *  Base class for drawing paths into a GrDrawTarget.
26 *
27 *  Derived classes can use stages GrPaint::kTotalStages through GrDrawState::kNumStages-1. The
28 *  stages before GrPaint::kTotalStages are reserved for setting up the draw (i.e., textures and
29 *  filter masks).
30 */
31class SK_API GrPathRenderer : public SkRefCnt {
32public:
33    SK_DECLARE_INST_COUNT(GrPathRenderer)
34
35    /**
36     * This is called to install custom path renderers in every GrContext at create time. The
37     * default implementation in GrCreatePathRenderer_none.cpp does not add any additional
38     * renderers. Link against another implementation to install your own. The first added is the
39     * most preferred path renderer, second is second most preferred, etc.
40     *
41     * @param context   the context that will use the path renderer
42     * @param prChain   the chain to add path renderers to.
43     */
44    static void AddPathRenderers(GrContext* context, GrPathRendererChain* prChain);
45
46
47    GrPathRenderer();
48
49    /**
50     * A caller may wish to use a path renderer to draw a path into the stencil buffer. However,
51     * the path renderer itself may require use of the stencil buffer. Also a path renderer may
52     * use a GrEffect coverage stage that sets coverage to zero to eliminate pixels that are covered
53     * by bounding geometry but outside the path. These exterior pixels would still be rendered into
54     * the stencil.
55     *
56     * A GrPathRenderer can provide three levels of support for stenciling paths:
57     * 1) kNoRestriction: This is the most general. The caller sets up the GrDrawState on the target
58     *                    and calls drawPath(). The path is rendered exactly as the draw state
59     *                    indicates including support for simultaneous color and stenciling with
60     *                    arbitrary stenciling rules. Pixels partially covered by AA paths are
61     *                    affected by the stencil settings.
62     * 2) kStencilOnly: The path renderer cannot apply arbitrary stencil rules nor shade and stencil
63     *                  simultaneously. The path renderer does support the stencilPath() function
64     *                  which performs no color writes and writes a non-zero stencil value to pixels
65     *                  covered by the path.
66     * 3) kNoSupport: This path renderer cannot be used to stencil the path.
67     */
68    typedef GrPathRendererChain::StencilSupport StencilSupport;
69    static const StencilSupport kNoSupport_StencilSupport =
70        GrPathRendererChain::kNoSupport_StencilSupport;
71    static const StencilSupport kStencilOnly_StencilSupport =
72        GrPathRendererChain::kStencilOnly_StencilSupport;
73    static const StencilSupport kNoRestriction_StencilSupport =
74        GrPathRendererChain::kNoRestriction_StencilSupport;
75
76    /**
77     * This function is to get the stencil support for a particular path. The path's fill must
78     * not be an inverse type.
79     *
80     * @param target    target that the path will be rendered to
81     * @param path      the path that will be drawn
82     * @param stroke    the stroke information (width, join, cap).
83     */
84    StencilSupport getStencilSupport(const SkPath& path,
85                                     const SkStrokeRec& stroke,
86                                     const GrDrawTarget* target) const {
87        SkASSERT(!path.isInverseFillType());
88        return this->onGetStencilSupport(path, stroke, target);
89    }
90
91    /**
92     * Returns true if this path renderer is able to render the path. Returning false allows the
93     * caller to fallback to another path renderer This function is called when searching for a path
94     * renderer capable of rendering a path.
95     *
96     * @param path       The path to draw
97     * @param stroke     The stroke information (width, join, cap)
98     * @param target     The target that the path will be rendered to
99     * @param antiAlias  True if anti-aliasing is required.
100     *
101     * @return  true if the path can be drawn by this object, false otherwise.
102     */
103    virtual bool canDrawPath(const SkPath& path,
104                             const SkStrokeRec& rec,
105                             const GrDrawTarget* target,
106                             bool antiAlias) const = 0;
107    /**
108     * Draws the path into the draw target. If getStencilSupport() would return kNoRestriction then
109     * the subclass must respect the stencil settings of the target's draw state.
110     *
111     * @param path                  the path to draw.
112     * @param stroke                the stroke information (width, join, cap)
113     * @param target                target that the path will be rendered to
114     * @param antiAlias             true if anti-aliasing is required.
115     */
116    bool drawPath(const SkPath& path,
117                  const SkStrokeRec& stroke,
118                  GrDrawTarget* target,
119                  bool antiAlias) {
120        SkASSERT(!path.isEmpty());
121        SkASSERT(this->canDrawPath(path, stroke, target, antiAlias));
122        SkASSERT(target->drawState()->getStencil().isDisabled() ||
123                 kNoRestriction_StencilSupport == this->getStencilSupport(path, stroke, target));
124        return this->onDrawPath(path, stroke, target, antiAlias);
125    }
126
127    /**
128     * Draws the path to the stencil buffer. Assume the writable stencil bits are already
129     * initialized to zero. The pixels inside the path will have non-zero stencil values afterwards.
130     *
131     * @param path                  the path to draw.
132     * @param stroke                the stroke information (width, join, cap)
133     * @param target                target that the path will be rendered to
134     */
135    void stencilPath(const SkPath& path, const SkStrokeRec& stroke, GrDrawTarget* target) {
136        SkASSERT(!path.isEmpty());
137        SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(path, stroke, target));
138        this->onStencilPath(path, stroke, target);
139    }
140
141    // Helper for determining if we can treat a thin stroke as a hairline w/ coverage.
142    // If we can, we draw lots faster (raster device does this same test).
143    static bool IsStrokeHairlineOrEquivalent(const SkStrokeRec& stroke, const SkMatrix& matrix,
144                                             SkScalar* outCoverage) {
145        if (stroke.isHairlineStyle()) {
146            if (NULL != outCoverage) {
147                *outCoverage = SK_Scalar1;
148            }
149            return true;
150        }
151        return stroke.getStyle() == SkStrokeRec::kStroke_Style &&
152            SkDrawTreatAAStrokeAsHairline(stroke.getWidth(), matrix, outCoverage);
153    }
154
155protected:
156    /**
157     * Subclass overrides if it has any limitations of stenciling support.
158     */
159    virtual StencilSupport onGetStencilSupport(const SkPath&,
160                                               const SkStrokeRec&,
161                                               const GrDrawTarget*) const {
162        return kNoRestriction_StencilSupport;
163    }
164
165    /**
166     * Subclass implementation of drawPath()
167     */
168    virtual bool onDrawPath(const SkPath& path,
169                            const SkStrokeRec& stroke,
170                            GrDrawTarget* target,
171                            bool antiAlias) = 0;
172
173    /**
174     * Subclass implementation of stencilPath(). Subclass must override iff it ever returns
175     * kStencilOnly in onGetStencilSupport().
176     */
177    virtual void onStencilPath(const SkPath& path,  const SkStrokeRec& stroke, GrDrawTarget* target) {
178        GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
179        GrDrawState* drawState = target->drawState();
180        GR_STATIC_CONST_SAME_STENCIL(kIncrementStencil,
181                                     kReplace_StencilOp,
182                                     kReplace_StencilOp,
183                                     kAlways_StencilFunc,
184                                     0xffff,
185                                     0xffff,
186                                     0xffff);
187        drawState->setStencil(kIncrementStencil);
188        drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
189        this->drawPath(path, stroke, target, false);
190    }
191
192    // Helper for getting the device bounds of a path. Inverse filled paths will have bounds set
193    // by devSize. Non-inverse path bounds will not necessarily be clipped to devSize.
194    static void GetPathDevBounds(const SkPath& path,
195                                 int devW,
196                                 int devH,
197                                 const SkMatrix& matrix,
198                                 SkRect* bounds);
199
200    // Helper version that gets the dev width and height from a GrSurface.
201    static void GetPathDevBounds(const SkPath& path,
202                                 const GrSurface* device,
203                                 const SkMatrix& matrix,
204                                 SkRect* bounds) {
205        GetPathDevBounds(path, device->width(), device->height(), matrix, bounds);
206    }
207
208private:
209
210    typedef SkRefCnt INHERITED;
211};
212
213#endif
214