1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGpuGL_DEFINED
#define GrGpuGL_DEFINED
#include "GrBinHashKey.h"
#include "GrDrawState.h"
#include "GrGpu.h"
#include "GrGLContextInfo.h"
#include "GrGLIndexBuffer.h"
#include "GrGLIRect.h"
#include "GrGLProgram.h"
#include "GrGLStencilBuffer.h"
#include "GrGLTexture.h"
#include "GrGLVertexBuffer.h"
#include "../GrTHashCache.h"
class GrGpuGL : public GrGpu {
public:
GrGpuGL(const GrGLContextInfo& ctxInfo);
virtual ~GrGpuGL();
const GrGLInterface* glInterface() const {
return fGLContextInfo.interface();
}
GrGLBinding glBinding() const { return fGLContextInfo.binding(); }
GrGLVersion glVersion() const { return fGLContextInfo.version(); }
GrGLSLGeneration glslGeneration() const {
return fGLContextInfo.glslGeneration();
}
// GrGpu overrides
virtual GrPixelConfig preferredReadPixelsConfig(GrPixelConfig config)
const SK_OVERRIDE;
virtual GrPixelConfig preferredWritePixelsConfig(GrPixelConfig config)
const SK_OVERRIDE;
virtual bool readPixelsWillPayForYFlip(
GrRenderTarget* renderTarget,
int left, int top,
int width, int height,
GrPixelConfig config,
size_t rowBytes) const SK_OVERRIDE;
virtual bool fullReadPixelsIsFasterThanPartial() const SK_OVERRIDE;
virtual bool canPreserveReadWriteUnpremulPixels() SK_OVERRIDE;
virtual void abandonResources() SK_OVERRIDE;
bool programUnitTest();
protected:
// GrGpu overrides
virtual void onResetContext() SK_OVERRIDE;
virtual GrTexture* onCreateTexture(const GrTextureDesc& desc,
const void* srcData,
size_t rowBytes) SK_OVERRIDE;
virtual GrVertexBuffer* onCreateVertexBuffer(uint32_t size,
bool dynamic) SK_OVERRIDE;
virtual GrIndexBuffer* onCreateIndexBuffer(uint32_t size,
bool dynamic) SK_OVERRIDE;
virtual GrPath* onCreatePath(const SkPath&) SK_OVERRIDE;
virtual GrTexture* onCreatePlatformTexture(
const GrPlatformTextureDesc& desc) SK_OVERRIDE;
virtual GrRenderTarget* onCreatePlatformRenderTarget(
const GrPlatformRenderTargetDesc& desc) SK_OVERRIDE;
virtual bool createStencilBufferForRenderTarget(GrRenderTarget* rt,
int width,
int height) SK_OVERRIDE;
virtual bool attachStencilBufferToRenderTarget(
GrStencilBuffer* sb,
GrRenderTarget* rt) SK_OVERRIDE;
virtual void onClear(const GrIRect* rect, GrColor color) SK_OVERRIDE;
virtual void onForceRenderTargetFlush() SK_OVERRIDE;
virtual bool onReadPixels(GrRenderTarget* target,
int left, int top,
int width, int height,
GrPixelConfig,
void* buffer,
size_t rowBytes,
bool invertY) SK_OVERRIDE;
virtual void onWriteTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) SK_OVERRIDE;
virtual void onResolveRenderTarget(GrRenderTarget* target) SK_OVERRIDE;
virtual void onGpuDrawIndexed(GrPrimitiveType type,
uint32_t startVertex,
uint32_t startIndex,
uint32_t vertexCount,
uint32_t indexCount) SK_OVERRIDE;
virtual void onGpuDrawNonIndexed(GrPrimitiveType type,
uint32_t vertexCount,
uint32_t numVertices) SK_OVERRIDE;
virtual void onGpuStencilPath(const GrPath&, GrPathFill) SK_OVERRIDE;
virtual void enableScissoring(const GrIRect& rect) SK_OVERRIDE;
virtual void disableScissor() SK_OVERRIDE;
virtual void clearStencil() SK_OVERRIDE;
virtual void clearStencilClip(const GrIRect& rect,
bool insideClip) SK_OVERRIDE;
virtual bool flushGraphicsState(DrawType) SK_OVERRIDE;
virtual void setupGeometry(int* startVertex,
int* startIndex,
int vertexCount,
int indexCount) SK_OVERRIDE;
private:
const GrGLCaps& glCaps() const { return fGLContextInfo.caps(); }
// binds texture unit in GL
void setTextureUnit(int unitIdx);
// binds appropriate vertex and index buffers, also returns any extra
// extra verts or indices to offset by.
void setBuffers(bool indexed,
int* extraVertexOffset,
int* extraIndexOffset);
// Subclasses should call this to flush the blend state.
// The params should be the final coeffecients to apply
// (after any blending optimizations or dual source blending considerations
// have been accounted for).
void flushBlend(bool isLines,
GrBlendCoeff srcCoeff,
GrBlendCoeff dstCoeff);
bool hasExtension(const char* ext) const {
return fGLContextInfo.hasExtension(ext);
}
const GrGLContextInfo& glContextInfo() const { return fGLContextInfo; }
// adjusts texture matrix to account for orientation
static void AdjustTextureMatrix(const GrGLTexture* texture,
GrMatrix* matrix);
// subclass may try to take advantage of identity tex matrices.
// This helper determines if matrix will be identity after all
// adjustments are applied.
static bool TextureMatrixIsIdentity(const GrGLTexture* texture,
const GrSamplerState& sampler);
static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
// for readability of function impls
typedef GrGLProgram::ProgramDesc ProgramDesc;
typedef ProgramDesc::StageDesc StageDesc;
typedef GrGLProgram::CachedData CachedData;
class ProgramCache : public ::GrNoncopyable {
public:
ProgramCache(const GrGLContextInfo& gl);
~ProgramCache();
void abandon();
CachedData* getProgramData(const GrGLProgram& desc,
GrCustomStage** stages);
private:
enum {
kKeySize = GrGLProgram::kProgramKeySize,
// We may actually have kMaxEntries+1 shaders in the GL context
// because we create a new shader before evicting from the cache.
kMaxEntries = 32
};
class Entry;
typedef GrBinHashKey<Entry, kKeySize> ProgramHashKey;
class Entry : public ::GrNoncopyable {
public:
Entry() {}
void copyAndTakeOwnership(Entry& entry);
int compare(const ProgramHashKey& key) const {
return fKey.compare(key);
}
public:
CachedData fProgramData;
ProgramHashKey fKey;
unsigned int fLRUStamp;
};
GrTHashTable<Entry, ProgramHashKey, 8> fHashCache;
Entry fEntries[kMaxEntries];
int fCount;
unsigned int fCurrLRUStamp;
const GrGLContextInfo& fGL;
};
// binds the texture and sets its texture params
void flushBoundTextureAndParams(int stage);
// sets the texture matrix and domain for the currently bound program
void flushTextureMatrixAndDomain(int stage);
// sets the color specified by GrDrawState::setColor()
void flushColor(GrColor color);
// sets the color specified by GrDrawState::setCoverage()
void flushCoverage(GrColor color);
// sets the MVP matrix uniform for currently bound program
void flushViewMatrix();
// flushes the parameters to two point radial gradient
void flushRadial2(int stage);
// flushes the parameters for convolution
void flushConvolution(int stage);
// flushes the color matrix
void flushColorMatrix();
// flushes dithering, color-mask, and face culling stat
void flushMiscFixedFunctionState();
static void DeleteProgram(const GrGLInterface* gl,
CachedData* programData);
void buildProgram(bool isPoints,
BlendOptFlags blendOpts,
GrBlendCoeff dstCoeff,
GrCustomStage** customStages);
// Inits GrDrawTarget::Caps, sublcass may enable additional caps.
void initCaps();
void initFSAASupport();
// determines valid stencil formats
void initStencilFormats();
// notify callbacks to update state tracking when related
// objects are bound to GL or deleted outside of the class
void notifyVertexBufferBind(const GrGLVertexBuffer* buffer);
void notifyVertexBufferDelete(const GrGLVertexBuffer* buffer);
void notifyIndexBufferBind(const GrGLIndexBuffer* buffer);
void notifyIndexBufferDelete(const GrGLIndexBuffer* buffer);
void notifyTextureDelete(GrGLTexture* texture);
void notifyRenderTargetDelete(GrRenderTarget* renderTarget);
void setSpareTextureUnit();
// bound is region that may be modified and therefore has to be resolved.
// NULL means whole target. Can be an empty rect.
void flushRenderTarget(const GrIRect* bound);
void flushStencil();
void flushAAState(bool isLines);
bool configToGLFormats(GrPixelConfig config,
bool getSizedInternal,
GrGLenum* internalFormat,
GrGLenum* externalFormat,
GrGLenum* externalType);
// helper for onCreateTexture and writeTexturePixels
bool uploadTexData(const GrGLTexture::Desc& desc,
bool isNewTexture,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const void* data,
size_t rowBytes);
bool createRenderTargetObjects(int width, int height,
GrGLuint texID,
GrGLRenderTarget::Desc* desc);
void fillInConfigRenderableTable();
friend class GrGLVertexBuffer;
friend class GrGLIndexBuffer;
friend class GrGLTexture;
friend class GrGLRenderTarget;
GrGLContextInfo fGLContextInfo;
// GL program-related state
ProgramCache* fProgramCache;
CachedData* fProgramData;
GrGLProgram fCurrentProgram;
///////////////////////////////////////////////////////////////////////////
///@name Caching of GL State
///@{
int fHWActiveTextureUnitIdx;
GrGLuint fHWProgramID;
GrColor fHWConstAttribColor;
GrColor fHWConstAttribCoverage;
// last scissor / viewport scissor state seen by the GL.
struct {
bool fScissorEnabled;
GrGLIRect fScissorRect;
GrGLIRect fViewportRect;
} fHWBounds;
enum TriState {
kNo_TriState,
kYes_TriState,
kUnknown_TriState
};
struct {
size_t fVertexOffset;
GrVertexLayout fVertexLayout;
const GrVertexBuffer* fVertexBuffer;
const GrIndexBuffer* fIndexBuffer;
bool fArrayPtrsDirty;
} fHWGeometryState;
struct {
GrBlendCoeff fSrcCoeff;
GrBlendCoeff fDstCoeff;
GrColor fConstColor;
bool fConstColorValid;
TriState fEnabled;
void invalidate() {
fSrcCoeff = kInvalid_GrBlendCoeff;
fDstCoeff = kInvalid_GrBlendCoeff;
fConstColorValid = false;
fEnabled = kUnknown_TriState;
}
} fHWBlendState;
struct {
TriState fMSAAEnabled;
TriState fSmoothLineEnabled;
void invalidate() {
fMSAAEnabled = kUnknown_TriState;
fSmoothLineEnabled = kUnknown_TriState;
}
} fHWAAState;
GrClipMaskManager::StencilClipMode fHWStencilClipMode;
GrStencilSettings fHWStencilSettings;
GrDrawState::DrawFace fHWDrawFace;
TriState fHWWriteToColor;
TriState fHWDitherEnabled;
GrRenderTarget* fHWBoundRenderTarget;
GrTexture* fHWBoundTextures[GrDrawState::kNumStages];
///@}
// we record what stencil format worked last time to hopefully exit early
// from our loop that tries stencil formats and calls check fb status.
int fLastSuccessfulStencilFmtIdx;
enum UnpremulConversion {
kUpOnWrite_DownOnRead_UnpremulConversion,
kDownOnWrite_UpOnRead_UnpremulConversion
} fUnpremulConversion;
enum CanPreserveUnpremulRoundtrip {
kUnknown_CanPreserveUnpremulRoundtrip,
kNo_CanPreserveUnpremulRoundtrip,
kYes_CanPreserveUnpremulRoundtrip,
} fCanPreserveUnpremulRoundtrip;
bool fPrintedCaps;
typedef GrGpu INHERITED;
};
#endif
|