SkGpuDevice.h revision 1a8ddf0a35bfb6c21a1184f81d2fdd50053acf31 
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 void writePixels(const SkBitmap& bitmap, int x, int y);
72
73    virtual void setMatrixClip(const SkMatrix& matrix, const SkRegion& clip,
74                               const SkClipStack&);
75
76    virtual void drawPaint(const SkDraw&, const SkPaint& paint);
77    virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
78                            const SkPoint[], const SkPaint& paint);
79    virtual void drawRect(const SkDraw&, const SkRect& r,
80                          const SkPaint& paint);
81    virtual void drawPath(const SkDraw&, const SkPath& path,
82                          const SkPaint& paint, const SkMatrix* prePathMatrix,
83                          bool pathIsMutable);
84    virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
85                            const SkIRect* srcRectOrNull,
86                            const SkMatrix& matrix, const SkPaint& paint);
87    virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
88                            int x, int y, const SkPaint& paint);
89    virtual void drawText(const SkDraw&, const void* text, size_t len,
90                          SkScalar x, SkScalar y, const SkPaint& paint);
91    virtual void drawPosText(const SkDraw&, const void* text, size_t len,
92                             const SkScalar pos[], SkScalar constY,
93                             int scalarsPerPos, const SkPaint& paint);
94    virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
95                                const SkPath& path, const SkMatrix* matrix,
96                                const SkPaint& paint);
97    virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
98                              const SkPoint verts[], const SkPoint texs[],
99                              const SkColor colors[], SkXfermode* xmode,
100                              const uint16_t indices[], int indexCount,
101                              const SkPaint& paint);
102    virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
103                            const SkPaint&);
104    virtual bool filterTextFlags(const SkPaint& paint, TextFlags*);
105
106    virtual void flush() { fContext->flush(false); }
107
108    /**
109     * Make's this device's rendertarget current in the underlying 3D API.
110     * Also implicitly flushes.
111     */
112    virtual void makeRenderTargetCurrent();
113
114protected:
115    typedef GrContext::TextureCacheEntry TexCache;
116    enum TexType {
117        kBitmap_TexType,
118        kDeviceRenderTarget_TexType,
119        kSaveLayerDeviceRenderTarget_TexType
120    };
121    TexCache lockCachedTexture(const SkBitmap& bitmap,
122                               const GrSamplerState& sampler,
123                               TexType type = kBitmap_TexType);
124    void unlockCachedTexture(TexCache);
125
126    class SkAutoCachedTexture {
127    public:
128        SkAutoCachedTexture();
129        SkAutoCachedTexture(SkGpuDevice* device,
130                            const SkBitmap& bitmap,
131                            const GrSamplerState& sampler,
132                            GrTexture** texture);
133        ~SkAutoCachedTexture();
134
135        GrTexture* set(SkGpuDevice*, const SkBitmap&, const GrSamplerState&);
136
137    private:
138        SkGpuDevice*    fDevice;
139        TexCache        fTex;
140    };
141    friend class SkAutoTexCache;
142
143    // overrides from SkDevice
144    virtual bool onReadPixels(const SkBitmap* bitmap,
145                              int x, int y) SK_OVERRIDE;
146
147
148private:
149    GrContext*      fContext;
150
151    GrSkDrawProcs*  fDrawProcs;
152
153    // state for our offscreen render-target
154    TexCache            fCache;
155    GrTexture*          fTexture;
156    GrRenderTarget*     fRenderTarget;
157    bool                fNeedClear;
158    bool                fNeedPrepareRenderTarget;
159
160    // called from rt and tex cons
161    void initFromRenderTarget(GrContext*, GrRenderTarget*);
162
163    // doesn't set the texture/sampler/matrix state
164    // caller needs to null out GrPaint's texture if
165    // non-textured drawing is desired.
166    // Set constantColor to true if a constant color
167    // will be used.  This is an optimization, and can
168    // always be set to false. constantColor should
169    // never be true if justAlpha is true.
170    bool skPaint2GrPaintNoShader(const SkPaint& skPaint,
171                                 bool justAlpha,
172                                 GrPaint* grPaint,
173                                 bool constantColor);
174
175    // uses the SkShader to setup paint, act used to
176    // hold lock on cached texture and free it when
177    // destroyed.
178    // If there is no shader, constantColor will
179    // be passed to skPaint2GrPaintNoShader.  Otherwise
180    // it is ignored.
181    bool skPaint2GrPaintShader(const SkPaint& skPaint,
182                               SkAutoCachedTexture* act,
183                               const SkMatrix& ctm,
184                               GrPaint* grPaint,
185                               bool constantColor);
186
187    // override from SkDevice
188    virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
189                                               int width, int height,
190                                               bool isOpaque,
191                                               Usage usage);
192
193    SkDrawProcs* initDrawForText(GrTextContext*);
194    bool bindDeviceAsTexture(GrPaint* paint);
195
196    void prepareRenderTarget(const SkDraw&);
197    void internalDrawBitmap(const SkDraw&, const SkBitmap&,
198                            const SkIRect&, const SkMatrix&, GrPaint* grPaint);
199
200    typedef SkDevice INHERITED;
201};
202
203#endif
204
205