SkGpuDevice.h revision 8a0b0291ae4260ef2a46f4341c18a702c0ce3f8b 
1
2/*
3 * Copyright 2010 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
11#ifndef SkGpuDevice_DEFINED
12#define SkGpuDevice_DEFINED
13
14#include "SkGr.h"
15#include "SkBitmap.h"
16#include "SkDevice.h"
17#include "SkRegion.h"
18#include "GrContext.h"
19
20struct SkDrawProcs;
21struct GrSkDrawProcs;
22class GrTextContext;
23
24/**
25 *  Subclass of SkDevice, which directs all drawing to the GrGpu owned by the
26 *  canvas.
27 */
28class SK_API SkGpuDevice : public SkDevice {
29public:
30    /**
31     *  New device that will create an offscreen renderTarget based on the
32     *  config, width, height.
33     *
34     *  usage is a special flag that should only be set by SkCanvas
35     *  internally.
36     */
37    SkGpuDevice(GrContext*, SkBitmap::Config,
38                int width, int height,
39                SkDevice::Usage usage = SkDevice::kGeneral_Usage);
40
41    /**
42     *  New device that will render to the specified renderTarget.
43     */
44    SkGpuDevice(GrContext*, GrRenderTarget*);
45
46    /**
47     *  New device that will render to the texture (as a rendertarget).
48     *  The GrTexture's asRenderTarget() must be non-NULL or device will not
49     *  function.
50     */
51    SkGpuDevice(GrContext*, GrTexture*);
52
53    virtual ~SkGpuDevice();
54
55    GrContext* context() const { return fContext; }
56
57    /**
58     *  Override from SkGpuDevice, so we can set our FBO to be the render target
59     *  The canvas parameter must be a SkGpuCanvas
60     */
61    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&,
62                           const SkClipStack& clipStack);
63
64    virtual SkGpuRenderTarget* accessRenderTarget() {
65        return (SkGpuRenderTarget*)fRenderTarget;
66    }
67
68    // overrides from SkDevice
69
70    virtual void clear(SkColor color);
71    virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);
72    virtual void writePixels(const SkBitmap& bitmap, int x, int y);
73
74    virtual void setMatrixClip(const SkMatrix& matrix, const SkRegion& clip,
75                               const SkClipStack&);
76
77    virtual void drawPaint(const SkDraw&, const SkPaint& paint);
78    virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
79                            const SkPoint[], const SkPaint& paint);
80    virtual void drawRect(const SkDraw&, const SkRect& r,
81                          const SkPaint& paint);
82    virtual void drawPath(const SkDraw&, const SkPath& path,
83                          const SkPaint& paint, const SkMatrix* prePathMatrix,
84                          bool pathIsMutable);
85    virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
86                            const SkIRect* srcRectOrNull,
87                            const SkMatrix& matrix, const SkPaint& paint);
88    virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
89                            int x, int y, const SkPaint& paint);
90    virtual void drawText(const SkDraw&, const void* text, size_t len,
91                          SkScalar x, SkScalar y, const SkPaint& paint);
92    virtual void drawPosText(const SkDraw&, const void* text, size_t len,
93                             const SkScalar pos[], SkScalar constY,
94                             int scalarsPerPos, const SkPaint& paint);
95    virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
96                                const SkPath& path, const SkMatrix* matrix,
97                                const SkPaint& paint);
98    virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
99                              const SkPoint verts[], const SkPoint texs[],
100                              const SkColor colors[], SkXfermode* xmode,
101                              const uint16_t indices[], int indexCount,
102                              const SkPaint& paint);
103    virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
104                            const SkPaint&);
105    virtual bool filterTextFlags(const SkPaint& paint, TextFlags*);
106
107    virtual void flush() { fContext->flush(false); }
108
109    /**
110     * Make's this device's rendertarget current in the underlying 3D API.
111     * Also implicitly flushes.
112     */
113    virtual void makeRenderTargetCurrent();
114
115protected:
116    typedef GrContext::TextureCacheEntry TexCache;
117    enum TexType {
118        kBitmap_TexType,
119        kDeviceRenderTarget_TexType,
120        kSaveLayerDeviceRenderTarget_TexType
121    };
122    TexCache lockCachedTexture(const SkBitmap& bitmap,
123                               const GrSamplerState& sampler,
124                               TexType type = kBitmap_TexType);
125    void unlockCachedTexture(TexCache);
126
127    class SkAutoCachedTexture {
128    public:
129        SkAutoCachedTexture();
130        SkAutoCachedTexture(SkGpuDevice* device,
131                            const SkBitmap& bitmap,
132                            const GrSamplerState& sampler,
133                            GrTexture** texture);
134        ~SkAutoCachedTexture();
135
136        GrTexture* set(SkGpuDevice*, const SkBitmap&, const GrSamplerState&);
137
138    private:
139        SkGpuDevice*    fDevice;
140        TexCache        fTex;
141    };
142    friend class SkAutoTexCache;
143
144private:
145    GrContext*      fContext;
146
147    GrSkDrawProcs*  fDrawProcs;
148
149    // state for our offscreen render-target
150    TexCache            fCache;
151    GrTexture*          fTexture;
152    GrRenderTarget*     fRenderTarget;
153    bool                fNeedClear;
154    bool                fNeedPrepareRenderTarget;
155
156    // called from rt and tex cons
157    void initFromRenderTarget(GrContext*, GrRenderTarget*);
158
159    // doesn't set the texture/sampler/matrix state
160    // caller needs to null out GrPaint's texture if
161    // non-textured drawing is desired.
162    // Set constantColor to true if a constant color
163    // will be used.  This is an optimization, and can
164    // always be set to false. constantColor should
165    // never be true if justAlpha is true.
166    bool skPaint2GrPaintNoShader(const SkPaint& skPaint,
167                                 bool justAlpha,
168                                 GrPaint* grPaint,
169                                 bool constantColor);
170
171    // uses the SkShader to setup paint, act used to
172    // hold lock on cached texture and free it when
173    // destroyed.
174    // If there is no shader, constantColor will
175    // be passed to skPaint2GrPaintNoShader.  Otherwise
176    // it is ignored.
177    bool skPaint2GrPaintShader(const SkPaint& skPaint,
178                               SkAutoCachedTexture* act,
179                               const SkMatrix& ctm,
180                               GrPaint* grPaint,
181                               bool constantColor);
182
183    // override from SkDevice
184    virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
185                                               int width, int height,
186                                               bool isOpaque,
187                                               Usage usage);
188
189    SkDrawProcs* initDrawForText(GrTextContext*);
190    bool bindDeviceAsTexture(GrPaint* paint);
191
192    void prepareRenderTarget(const SkDraw&);
193    void internalDrawBitmap(const SkDraw&, const SkBitmap&,
194                            const SkIRect&, const SkMatrix&, GrPaint* grPaint);
195
196    typedef SkDevice INHERITED;
197};
198
199#endif
200
201