SkDebugCanvas.h revision 945ec3a2bec668ca845071a65df8ec55e8f43819 
1
2/*
3 * Copyright 2012 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
10#ifndef SKDEBUGCANVAS_H_
11#define SKDEBUGCANVAS_H_
12
13#include "SkCanvas.h"
14#include "SkDrawCommand.h"
15#include "SkPicture.h"
16#include "SkTArray.h"
17#include "SkString.h"
18
19class SkTexOverrideFilter;
20
21class SK_API SkDebugCanvas : public SkCanvas {
22public:
23    SkDebugCanvas(int width, int height);
24    virtual ~SkDebugCanvas();
25
26    void toggleFilter(bool toggle) { fFilter = toggle; }
27
28    void setMegaVizMode(bool megaVizMode) { fMegaVizMode = megaVizMode; }
29    bool getMegaVizMode() const { return fMegaVizMode; }
30
31    /**
32     * Enable or disable overdraw visualization
33     */
34    void setOverdrawViz(bool overdrawViz) { fOverdrawViz = overdrawViz; }
35    bool getOverdrawViz() const { return fOverdrawViz; }
36
37    void setOutstandingSaveCount(int saveCount) { fOutstandingSaveCount = saveCount; }
38    int getOutstandingSaveCount() const { return fOutstandingSaveCount; }
39
40    void setPicture(SkPicture* picture) { fPicture = picture; }
41
42    /**
43     * Enable or disable texure filtering override
44     */
45    void overrideTexFiltering(bool overrideTexFiltering, SkPaint::FilterLevel level);
46
47    /**
48        Executes all draw calls to the canvas.
49        @param canvas  The canvas being drawn to
50     */
51    void draw(SkCanvas* canvas);
52
53    /**
54        Executes the draw calls up to the specified index.
55        @param canvas  The canvas being drawn to
56        @param index  The index of the final command being executed
57     */
58    void drawTo(SkCanvas* canvas, int index);
59
60    /**
61        Returns the most recently calculated transformation matrix
62     */
63    const SkMatrix& getCurrentMatrix() {
64        return fMatrix;
65    }
66
67    /**
68        Returns the most recently calculated clip
69     */
70    const SkIRect& getCurrentClip() {
71        return fClip;
72    }
73
74    /**
75        Returns the index of the last draw command to write to the pixel at (x,y)
76     */
77    int getCommandAtPoint(int x, int y, int index);
78
79    /**
80        Removes the command at the specified index
81        @param index  The index of the command to delete
82     */
83    void deleteDrawCommandAt(int index);
84
85    /**
86        Returns the draw command at the given index.
87        @param index  The index of the command
88     */
89    SkDrawCommand* getDrawCommandAt(int index);
90
91    /**
92        Sets the draw command for a given index.
93        @param index  The index to overwrite
94        @param command The new command
95     */
96    void setDrawCommandAt(int index, SkDrawCommand* command);
97
98    /**
99        Returns information about the command at the given index.
100        @param index  The index of the command
101     */
102    SkTDArray<SkString*>* getCommandInfo(int index);
103
104    /**
105        Returns the visibility of the command at the given index.
106        @param index  The index of the command
107     */
108    bool getDrawCommandVisibilityAt(int index);
109
110    /**
111        Returns the vector of draw commands
112     */
113    SK_ATTR_DEPRECATED("please use getDrawCommandAt and getSize instead")
114    const SkTDArray<SkDrawCommand*>& getDrawCommands() const;
115
116    /**
117        Returns the vector of draw commands. Do not use this entry
118        point - it is going away!
119     */
120    SkTDArray<SkDrawCommand*>& getDrawCommands();
121
122    /**
123     * Returns the string vector of draw commands
124     */
125    SkTArray<SkString>* getDrawCommandsAsStrings() const;
126
127    /**
128     * Returns an array containing an offset (in the SkPicture) for each command
129     */
130    SkTDArray<size_t>* getDrawCommandOffsets() const;
131
132    /**
133        Returns length of draw command vector.
134     */
135    int getSize() const {
136        return fCommandVector.count();
137    }
138
139    /**
140        Toggles the visibility / execution of the draw command at index i with
141        the value of toggle.
142     */
143    void toggleCommand(int index, bool toggle);
144
145    void setBounds(int width, int height) {
146        fWidth = width;
147        fHeight = height;
148    }
149
150    void setUserMatrix(SkMatrix matrix) {
151        fUserMatrix = matrix;
152    }
153
154////////////////////////////////////////////////////////////////////////////////
155// Inherited from SkCanvas
156////////////////////////////////////////////////////////////////////////////////
157
158    virtual void clear(SkColor) SK_OVERRIDE;
159
160    virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
161                            const SkPaint*) SK_OVERRIDE;
162
163    virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
164                                      const SkRect& dst, const SkPaint* paint,
165                                      DrawBitmapRectFlags flags) SK_OVERRIDE;
166
167    virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
168                                  const SkPaint*) SK_OVERRIDE;
169
170    virtual void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
171                                const SkRect& dst, const SkPaint*) SK_OVERRIDE;
172
173    virtual void drawData(const void*, size_t) SK_OVERRIDE;
174
175    virtual void beginCommentGroup(const char* description) SK_OVERRIDE;
176
177    virtual void addComment(const char* kywd, const char* value) SK_OVERRIDE;
178
179    virtual void endCommentGroup() SK_OVERRIDE;
180
181    virtual void drawOval(const SkRect& oval, const SkPaint&) SK_OVERRIDE;
182
183    virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
184
185    virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE;
186
187    virtual void drawPicture(SkPicture& picture) SK_OVERRIDE;
188
189    virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
190                            const SkPaint&) SK_OVERRIDE;
191
192    virtual void drawPosText(const void* text, size_t byteLength,
193                             const SkPoint pos[], const SkPaint&) SK_OVERRIDE;
194
195    virtual void drawPosTextH(const void* text, size_t byteLength,
196                              const SkScalar xpos[], SkScalar constY,
197                              const SkPaint&) SK_OVERRIDE;
198
199    virtual void drawRect(const SkRect& rect, const SkPaint&) SK_OVERRIDE;
200
201    virtual void drawRRect(const SkRRect& rrect, const SkPaint& paint) SK_OVERRIDE;
202
203    virtual void drawSprite(const SkBitmap&, int left, int top,
204                            const SkPaint*) SK_OVERRIDE;
205
206    virtual void drawText(const void* text, size_t byteLength, SkScalar x,
207                          SkScalar y, const SkPaint&) SK_OVERRIDE;
208
209    virtual void drawTextOnPath(const void* text, size_t byteLength,
210                                const SkPath& path, const SkMatrix* matrix,
211                                const SkPaint&) SK_OVERRIDE;
212
213    virtual void drawVertices(VertexMode, int vertexCount,
214                              const SkPoint vertices[], const SkPoint texs[],
215                              const SkColor colors[], SkXfermode*,
216                              const uint16_t indices[], int indexCount,
217                              const SkPaint&) SK_OVERRIDE;
218
219    static const int kVizImageHeight = 256;
220    static const int kVizImageWidth = 256;
221
222    virtual bool isClipEmpty() const SK_OVERRIDE { return false; }
223    virtual bool isClipRect() const SK_OVERRIDE { return true; }
224#ifdef SK_SUPPORT_LEGACY_GETCLIPTYPE
225    virtual ClipType getClipType() const SK_OVERRIDE {
226        return kRect_ClipType;
227    }
228#endif
229    virtual bool getClipBounds(SkRect* bounds) const SK_OVERRIDE {
230        if (NULL != bounds) {
231            bounds->setXYWH(0, 0,
232                            SkIntToScalar(this->imageInfo().fWidth),
233                            SkIntToScalar(this->imageInfo().fHeight));
234        }
235        return true;
236    }
237    virtual bool getClipDeviceBounds(SkIRect* bounds) const SK_OVERRIDE {
238        if (NULL != bounds) {
239            bounds->setLargest();
240        }
241        return true;
242    }
243
244protected:
245    virtual void willSave(SaveFlags) SK_OVERRIDE;
246    virtual SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
247    virtual void willRestore() SK_OVERRIDE;
248
249    virtual void didConcat(const SkMatrix&) SK_OVERRIDE;
250    virtual void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
251
252    virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
253    virtual void onPushCull(const SkRect& cullRect) SK_OVERRIDE;
254    virtual void onPopCull() SK_OVERRIDE;
255
256    virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
257    virtual void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
258    virtual void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
259    virtual void onClipRegion(const SkRegion& region, SkRegion::Op) SK_OVERRIDE;
260
261    void markActiveCommands(int index);
262
263private:
264    SkTDArray<SkDrawCommand*> fCommandVector;
265    SkPicture* fPicture;
266    int fWidth;
267    int fHeight;
268    bool fFilter;
269    bool fMegaVizMode;
270    int fIndex;
271    SkMatrix fUserMatrix;
272    SkMatrix fMatrix;
273    SkIRect fClip;
274
275    bool fOverdrawViz;
276    SkDrawFilter* fOverdrawFilter;
277
278    bool fOverrideTexFiltering;
279    SkTexOverrideFilter* fTexOverrideFilter;
280
281    /**
282        Number of unmatched save() calls at any point during a draw.
283        If there are any saveLayer() calls outstanding, we need to resolve
284        all of them, which in practice means resolving all save() calls,
285        to avoid corruption of our canvas.
286    */
287    int fOutstandingSaveCount;
288
289    /**
290        The active saveLayer commands at a given point in the renderering.
291        Only used when "mega" visualization is enabled.
292    */
293    SkTDArray<SkDrawCommand*> fActiveLayers;
294
295    /**
296        The active cull commands at a given point in the rendering.
297        Only used when "mega" visualization is enabled.
298    */
299    SkTDArray<SkDrawCommand*> fActiveCulls;
300
301    /**
302        Adds the command to the classes vector of commands.
303        @param command  The draw command for execution
304     */
305    void addDrawCommand(SkDrawCommand* command);
306
307    /**
308        Applies any panning and zooming the user has specified before
309        drawing anything else into the canvas.
310     */
311    void applyUserTransform(SkCanvas* canvas);
312
313    size_t getOpID() const {
314        if (NULL != fPicture) {
315            return fPicture->EXPERIMENTAL_curOpID();
316        }
317        return 0;
318    }
319
320    typedef SkCanvas INHERITED;
321};
322
323#endif
324