1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8
9 #include "GrGpuGL.h"
10 #include "GrGLStencilBuffer.h"
11 #include "GrGLPath.h"
12 #include "GrGLShaderBuilder.h"
13 #include "GrTemplates.h"
14 #include "GrTypes.h"
15 #include "SkTemplates.h"
16
17 static const GrGLuint GR_MAX_GLUINT = ~0U;
18 static const GrGLint GR_INVAL_GLINT = ~0;
19
20 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
21 #define GL_CALL_RET(RET, X) GR_GL_CALL_RET(this->glInterface(), RET, X)
22
23 // we use a spare texture unit to avoid
24 // mucking with the state of any of the stages.
25 static const int SPARE_TEX_UNIT = GrDrawState::kNumStages;
26
27 #define SKIP_CACHE_CHECK true
28
29 #if GR_GL_CHECK_ALLOC_WITH_GET_ERROR
30 #define CLEAR_ERROR_BEFORE_ALLOC(iface) GrGLClearErr(iface)
31 #define GL_ALLOC_CALL(iface, call) GR_GL_CALL_NOERRCHECK(iface, call)
32 #define CHECK_ALLOC_ERROR(iface) GR_GL_GET_ERROR(iface)
33 #else
34 #define CLEAR_ERROR_BEFORE_ALLOC(iface)
35 #define GL_ALLOC_CALL(iface, call) GR_GL_CALL(iface, call)
36 #define CHECK_ALLOC_ERROR(iface) GR_GL_NO_ERROR
37 #endif
38
39
40 ///////////////////////////////////////////////////////////////////////////////
41
42 static const GrGLenum gXfermodeCoeff2Blend[] = {
43 GR_GL_ZERO,
44 GR_GL_ONE,
45 GR_GL_SRC_COLOR,
46 GR_GL_ONE_MINUS_SRC_COLOR,
47 GR_GL_DST_COLOR,
48 GR_GL_ONE_MINUS_DST_COLOR,
49 GR_GL_SRC_ALPHA,
50 GR_GL_ONE_MINUS_SRC_ALPHA,
51 GR_GL_DST_ALPHA,
52 GR_GL_ONE_MINUS_DST_ALPHA,
53 GR_GL_CONSTANT_COLOR,
54 GR_GL_ONE_MINUS_CONSTANT_COLOR,
55 GR_GL_CONSTANT_ALPHA,
56 GR_GL_ONE_MINUS_CONSTANT_ALPHA,
57
58 // extended blend coeffs
59 GR_GL_SRC1_COLOR,
60 GR_GL_ONE_MINUS_SRC1_COLOR,
61 GR_GL_SRC1_ALPHA,
62 GR_GL_ONE_MINUS_SRC1_ALPHA,
63 };
64
BlendCoeffReferencesConstant(GrBlendCoeff coeff)65 bool GrGpuGL::BlendCoeffReferencesConstant(GrBlendCoeff coeff) {
66 static const bool gCoeffReferencesBlendConst[] = {
67 false,
68 false,
69 false,
70 false,
71 false,
72 false,
73 false,
74 false,
75 false,
76 false,
77 true,
78 true,
79 true,
80 true,
81
82 // extended blend coeffs
83 false,
84 false,
85 false,
86 false,
87 };
88 return gCoeffReferencesBlendConst[coeff];
89 GR_STATIC_ASSERT(kTotalGrBlendCoeffCount ==
90 GR_ARRAY_COUNT(gCoeffReferencesBlendConst));
91
92 GR_STATIC_ASSERT(0 == kZero_GrBlendCoeff);
93 GR_STATIC_ASSERT(1 == kOne_GrBlendCoeff);
94 GR_STATIC_ASSERT(2 == kSC_GrBlendCoeff);
95 GR_STATIC_ASSERT(3 == kISC_GrBlendCoeff);
96 GR_STATIC_ASSERT(4 == kDC_GrBlendCoeff);
97 GR_STATIC_ASSERT(5 == kIDC_GrBlendCoeff);
98 GR_STATIC_ASSERT(6 == kSA_GrBlendCoeff);
99 GR_STATIC_ASSERT(7 == kISA_GrBlendCoeff);
100 GR_STATIC_ASSERT(8 == kDA_GrBlendCoeff);
101 GR_STATIC_ASSERT(9 == kIDA_GrBlendCoeff);
102 GR_STATIC_ASSERT(10 == kConstC_GrBlendCoeff);
103 GR_STATIC_ASSERT(11 == kIConstC_GrBlendCoeff);
104 GR_STATIC_ASSERT(12 == kConstA_GrBlendCoeff);
105 GR_STATIC_ASSERT(13 == kIConstA_GrBlendCoeff);
106
107 GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff);
108 GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
109 GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
110 GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
111
112 // assertion for gXfermodeCoeff2Blend have to be in GrGpu scope
113 GR_STATIC_ASSERT(kTotalGrBlendCoeffCount ==
114 GR_ARRAY_COUNT(gXfermodeCoeff2Blend));
115 }
116
117 ///////////////////////////////////////////////////////////////////////////////
118
119 static bool gPrintStartupSpew;
120
fbo_test(const GrGLInterface * gl,int w,int h)121 static bool fbo_test(const GrGLInterface* gl, int w, int h) {
122
123 GR_GL_CALL(gl, ActiveTexture(GR_GL_TEXTURE0 + SPARE_TEX_UNIT));
124
125 GrGLuint testFBO;
126 GR_GL_CALL(gl, GenFramebuffers(1, &testFBO));
127 GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, testFBO));
128 GrGLuint testRTTex;
129 GR_GL_CALL(gl, GenTextures(1, &testRTTex));
130 GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, testRTTex));
131 // some implementations require texture to be mip-map complete before
132 // FBO with level 0 bound as color attachment will be framebuffer complete.
133 GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D,
134 GR_GL_TEXTURE_MIN_FILTER,
135 GR_GL_NEAREST));
136 GR_GL_CALL(gl, TexImage2D(GR_GL_TEXTURE_2D, 0, GR_GL_RGBA, w, h,
137 0, GR_GL_RGBA, GR_GL_UNSIGNED_BYTE, NULL));
138 GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
139 GR_GL_CALL(gl, FramebufferTexture2D(GR_GL_FRAMEBUFFER,
140 GR_GL_COLOR_ATTACHMENT0,
141 GR_GL_TEXTURE_2D, testRTTex, 0));
142 GrGLenum status;
143 GR_GL_CALL_RET(gl, status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
144 GR_GL_CALL(gl, DeleteFramebuffers(1, &testFBO));
145 GR_GL_CALL(gl, DeleteTextures(1, &testRTTex));
146
147 return status == GR_GL_FRAMEBUFFER_COMPLETE;
148 }
149
GrGpuGL(const GrGLContextInfo & ctxInfo)150 GrGpuGL::GrGpuGL(const GrGLContextInfo& ctxInfo) : fGLContextInfo(ctxInfo) {
151
152 GrAssert(ctxInfo.isInitialized());
153
154 fillInConfigRenderableTable();
155
156 fPrintedCaps = false;
157
158 GrGLClearErr(fGLContextInfo.interface());
159
160 if (gPrintStartupSpew) {
161 const GrGLubyte* ext;
162 GL_CALL_RET(ext, GetString(GR_GL_EXTENSIONS));
163 const GrGLubyte* vendor;
164 const GrGLubyte* renderer;
165 const GrGLubyte* version;
166 GL_CALL_RET(vendor, GetString(GR_GL_VENDOR));
167 GL_CALL_RET(renderer, GetString(GR_GL_RENDERER));
168 GL_CALL_RET(version, GetString(GR_GL_VERSION));
169 GrPrintf("------------------------- create GrGpuGL %p --------------\n",
170 this);
171 GrPrintf("------ VENDOR %s\n", vendor);
172 GrPrintf("------ RENDERER %s\n", renderer);
173 GrPrintf("------ VERSION %s\n", version);
174 GrPrintf("------ EXTENSIONS\n %s \n", ext);
175 }
176
177 this->initCaps();
178
179 fProgramCache = SkNEW_ARGS(ProgramCache, (this->glContextInfo()));
180
181 fLastSuccessfulStencilFmtIdx = 0;
182 if (false) { // avoid bit rot, suppress warning
183 fbo_test(this->glInterface(), 0, 0);
184 }
185 }
186
~GrGpuGL()187 GrGpuGL::~GrGpuGL() {
188 if (0 != fHWProgramID) {
189 // detach the current program so there is no confusion on OpenGL's part
190 // that we want it to be deleted
191 GrAssert(fHWProgramID == fCurrentProgram->fProgramID);
192 GL_CALL(UseProgram(0));
193 }
194
195 delete fProgramCache;
196
197 // This must be called by before the GrDrawTarget destructor
198 this->releaseGeometry();
199 // This subclass must do this before the base class destructor runs
200 // since we will unref the GrGLInterface.
201 this->releaseResources();
202 }
203
204 ///////////////////////////////////////////////////////////////////////////////
205
initCaps()206 void GrGpuGL::initCaps() {
207 GrGLint maxTextureUnits;
208 // check FS and fixed-function texture unit limits
209 // we only use textures in the fragment stage currently.
210 // checks are > to make sure we have a spare unit.
211 const GrGLInterface* gl = this->glInterface();
212 GR_GL_GetIntegerv(gl, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
213 GrAssert(maxTextureUnits > GrDrawState::kNumStages);
214
215 CapsInternals* caps = this->capsInternals();
216
217 GrGLint numFormats;
218 GR_GL_GetIntegerv(gl, GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
219 SkAutoSTMalloc<10, GrGLint> formats(numFormats);
220 GR_GL_GetIntegerv(gl, GR_GL_COMPRESSED_TEXTURE_FORMATS, formats);
221 for (int i = 0; i < numFormats; ++i) {
222 if (formats[i] == GR_GL_PALETTE8_RGBA8) {
223 caps->f8BitPaletteSupport = true;
224 break;
225 }
226 }
227
228 if (kDesktop_GrGLBinding == this->glBinding()) {
229 // we could also look for GL_ATI_separate_stencil extension or
230 // GL_EXT_stencil_two_side but they use different function signatures
231 // than GL2.0+ (and than each other).
232 caps->fTwoSidedStencilSupport = (this->glVersion() >= GR_GL_VER(2,0));
233 // supported on GL 1.4 and higher or by extension
234 caps->fStencilWrapOpsSupport = (this->glVersion() >= GR_GL_VER(1,4)) ||
235 this->hasExtension("GL_EXT_stencil_wrap");
236 } else {
237 // ES 2 has two sided stencil and stencil wrap
238 caps->fTwoSidedStencilSupport = true;
239 caps->fStencilWrapOpsSupport = true;
240 }
241
242 if (kDesktop_GrGLBinding == this->glBinding()) {
243 caps->fBufferLockSupport = true; // we require VBO support and the desktop VBO
244 // extension includes glMapBuffer.
245 } else {
246 caps->fBufferLockSupport = this->hasExtension("GL_OES_mapbuffer");
247 }
248
249 if (kDesktop_GrGLBinding == this->glBinding()) {
250 if (this->glVersion() >= GR_GL_VER(2,0) ||
251 this->hasExtension("GL_ARB_texture_non_power_of_two")) {
252 caps->fNPOTTextureTileSupport = true;
253 } else {
254 caps->fNPOTTextureTileSupport = false;
255 }
256 } else {
257 // Unextended ES2 supports NPOT textures with clamp_to_edge and non-mip filters only
258 caps->fNPOTTextureTileSupport = this->hasExtension("GL_OES_texture_npot");
259 }
260
261 caps->fHWAALineSupport = (kDesktop_GrGLBinding == this->glBinding());
262
263 GR_GL_GetIntegerv(gl, GR_GL_MAX_TEXTURE_SIZE, &caps->fMaxTextureSize);
264 GR_GL_GetIntegerv(gl, GR_GL_MAX_RENDERBUFFER_SIZE, &caps->fMaxRenderTargetSize);
265 // Our render targets are always created with textures as the color
266 // attachment, hence this min:
267 caps->fMaxRenderTargetSize = GrMin(caps->fMaxTextureSize, caps->fMaxRenderTargetSize);
268
269 caps->fFSAASupport = GrGLCaps::kNone_MSFBOType != this->glCaps().msFBOType();
270 caps->fPathStencilingSupport = GR_GL_USE_NV_PATH_RENDERING &&
271 this->hasExtension("GL_NV_path_rendering");
272
273 // Enable supported shader-related caps
274 if (kDesktop_GrGLBinding == this->glBinding()) {
275 caps->fDualSourceBlendingSupport =
276 this->glVersion() >= GR_GL_VER(3,3) ||
277 this->hasExtension("GL_ARB_blend_func_extended");
278 caps->fShaderDerivativeSupport = true;
279 // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
280 caps->fGeometryShaderSupport =
281 this->glVersion() >= GR_GL_VER(3,2) &&
282 this->glslGeneration() >= k150_GrGLSLGeneration;
283 } else {
284 caps->fShaderDerivativeSupport =
285 this->hasExtension("GL_OES_standard_derivatives");
286 }
287 }
288
fillInConfigRenderableTable()289 void GrGpuGL::fillInConfigRenderableTable() {
290
291 // OpenGL < 3.0
292 // no support for render targets unless the GL_ARB_framebuffer_object
293 // extension is supported (in which case we get ALPHA, RED, RG, RGB,
294 // RGBA (ALPHA8, RGBA4, RGBA8) for OpenGL > 1.1). Note that we
295 // probably don't get R8 in this case.
296
297 // OpenGL 3.0
298 // base color renderable: ALPHA, RED, RG, RGB, and RGBA
299 // sized derivatives: ALPHA8, R8, RGBA4, RGBA8
300
301 // >= OpenGL 3.1
302 // base color renderable: RED, RG, RGB, and RGBA
303 // sized derivatives: R8, RGBA4, RGBA8
304 // if the GL_ARB_compatibility extension is supported then we get back
305 // support for GL_ALPHA and ALPHA8
306
307 // GL_EXT_bgra adds BGRA render targets to any version
308
309 // ES 2.0
310 // color renderable: RGBA4, RGB5_A1, RGB565
311 // GL_EXT_texture_rg adds support for R8 as a color render target
312 // GL_OES_rgb8_rgba8 and/or GL_ARM_rgba8 adds support for RGBA8
313 // GL_EXT_texture_format_BGRA8888 and/or GL_APPLE_texture_format_BGRA8888
314 // added BGRA support
315
316 if (kDesktop_GrGLBinding == this->glBinding()) {
317 // Post 3.0 we will get R8
318 // Prior to 3.0 we will get ALPHA8 (with GL_ARB_framebuffer_object)
319 if (this->glVersion() >= GR_GL_VER(3,0) ||
320 this->hasExtension("GL_ARB_framebuffer_object")) {
321 fConfigRenderSupport[kAlpha_8_GrPixelConfig] = true;
322 }
323 } else {
324 // On ES we can only hope for R8
325 fConfigRenderSupport[kAlpha_8_GrPixelConfig] =
326 this->glCaps().textureRedSupport();
327 }
328
329 if (kDesktop_GrGLBinding != this->glBinding()) {
330 // only available in ES
331 fConfigRenderSupport[kRGB_565_GrPixelConfig] = true;
332 }
333
334 // Pre 3.0, Ganesh relies on either GL_ARB_framebuffer_object or
335 // GL_EXT_framebuffer_object for FBO support. Both of these
336 // allow RGBA4 render targets so this is always supported.
337 fConfigRenderSupport[kRGBA_4444_GrPixelConfig] = true;
338
339 if (this->glCaps().rgba8RenderbufferSupport()) {
340 fConfigRenderSupport[kRGBA_8888_GrPixelConfig] = true;
341 }
342
343 if (this->glCaps().bgraFormatSupport()) {
344 fConfigRenderSupport[kBGRA_8888_GrPixelConfig] = true;
345 }
346 }
347
preferredReadPixelsConfig(GrPixelConfig config) const348 GrPixelConfig GrGpuGL::preferredReadPixelsConfig(GrPixelConfig config) const {
349 if (GR_GL_RGBA_8888_PIXEL_OPS_SLOW && GrPixelConfigIsRGBA8888(config)) {
350 return GrPixelConfigSwapRAndB(config);
351 } else {
352 return config;
353 }
354 }
355
preferredWritePixelsConfig(GrPixelConfig config) const356 GrPixelConfig GrGpuGL::preferredWritePixelsConfig(GrPixelConfig config) const {
357 if (GR_GL_RGBA_8888_PIXEL_OPS_SLOW && GrPixelConfigIsRGBA8888(config)) {
358 return GrPixelConfigSwapRAndB(config);
359 } else {
360 return config;
361 }
362 }
363
fullReadPixelsIsFasterThanPartial() const364 bool GrGpuGL::fullReadPixelsIsFasterThanPartial() const {
365 return SkToBool(GR_GL_FULL_READPIXELS_FASTER_THAN_PARTIAL);
366 }
367
onResetContext()368 void GrGpuGL::onResetContext() {
369 if (gPrintStartupSpew && !fPrintedCaps) {
370 fPrintedCaps = true;
371 this->getCaps().print();
372 this->glCaps().print();
373 }
374
375 // we don't use the zb at all
376 GL_CALL(Disable(GR_GL_DEPTH_TEST));
377 GL_CALL(DepthMask(GR_GL_FALSE));
378
379 fHWDrawFace = GrDrawState::kInvalid_DrawFace;
380 fHWDitherEnabled = kUnknown_TriState;
381
382 if (kDesktop_GrGLBinding == this->glBinding()) {
383 // Desktop-only state that we never change
384 GL_CALL(Disable(GR_GL_POINT_SMOOTH));
385 GL_CALL(Disable(GR_GL_LINE_SMOOTH));
386 GL_CALL(Disable(GR_GL_POLYGON_SMOOTH));
387 GL_CALL(Disable(GR_GL_POLYGON_STIPPLE));
388 GL_CALL(Disable(GR_GL_COLOR_LOGIC_OP));
389 if (this->glCaps().imagingSupport()) {
390 GL_CALL(Disable(GR_GL_COLOR_TABLE));
391 }
392 GL_CALL(Disable(GR_GL_INDEX_LOGIC_OP));
393 GL_CALL(Disable(GR_GL_POLYGON_OFFSET_FILL));
394 // Since ES doesn't support glPointSize at all we always use the VS to
395 // set the point size
396 GL_CALL(Enable(GR_GL_VERTEX_PROGRAM_POINT_SIZE));
397
398 // We should set glPolygonMode(FRONT_AND_BACK,FILL) here, too. It isn't
399 // currently part of our gl interface. There are probably others as
400 // well.
401 }
402 fHWAAState.invalidate();
403 fHWWriteToColor = kUnknown_TriState;
404
405 // we only ever use lines in hairline mode
406 GL_CALL(LineWidth(1));
407
408 // invalid
409 fHWActiveTextureUnitIdx = -1;
410
411 fHWBlendState.invalidate();
412
413 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
414 fHWBoundTextures[s] = NULL;
415 }
416
417 fHWScissorSettings.invalidate();
418
419 fHWViewport.invalidate();
420
421 fHWStencilSettings.invalidate();
422 fHWStencilTestEnabled = kUnknown_TriState;
423
424 fHWGeometryState.fIndexBuffer = NULL;
425 fHWGeometryState.fVertexBuffer = NULL;
426
427 fHWGeometryState.fArrayPtrsDirty = true;
428
429 fHWBoundRenderTarget = NULL;
430
431 fHWPathMatrixState.invalidate();
432 if (fCaps.pathStencilingSupport()) {
433 // we don't use the model view matrix.
434 GL_CALL(MatrixMode(GR_GL_MODELVIEW));
435 GL_CALL(LoadIdentity());
436 }
437
438 // we assume these values
439 if (this->glCaps().unpackRowLengthSupport()) {
440 GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
441 }
442 if (this->glCaps().packRowLengthSupport()) {
443 GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
444 }
445 if (this->glCaps().unpackFlipYSupport()) {
446 GL_CALL(PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_FALSE));
447 }
448 if (this->glCaps().packFlipYSupport()) {
449 GL_CALL(PixelStorei(GR_GL_PACK_REVERSE_ROW_ORDER, GR_GL_FALSE));
450 }
451
452 fHWGeometryState.fVertexOffset = ~0U;
453
454 // Third party GL code may have left vertex attributes enabled. Some GL
455 // implementations (osmesa) may read vetex attributes that are not required
456 // by the current shader. Therefore, we have to ensure that only the
457 // attributes we require for the current draw are enabled or we may cause an
458 // invalid read.
459
460 // Disable all vertex layout bits so that next flush will assume all
461 // optional vertex attributes are disabled.
462 fHWGeometryState.fVertexLayout = 0;
463
464 // We always use the this attribute and assume it is always enabled.
465 int posAttrIdx = GrGLProgram::PositionAttributeIdx();
466 GL_CALL(EnableVertexAttribArray(posAttrIdx));
467 // Disable all other vertex attributes.
468 for (int va = 0; va < this->glCaps().maxVertexAttributes(); ++va) {
469 if (va != posAttrIdx) {
470 GL_CALL(DisableVertexAttribArray(va));
471 }
472 }
473
474 fHWProgramID = 0;
475 fHWConstAttribColor = GrColor_ILLEGAL;
476 fHWConstAttribCoverage = GrColor_ILLEGAL;
477 }
478
onWrapBackendTexture(const GrBackendTextureDesc & desc)479 GrTexture* GrGpuGL::onWrapBackendTexture(const GrBackendTextureDesc& desc) {
480 if (!this->configToGLFormats(desc.fConfig, false, NULL, NULL, NULL)) {
481 return NULL;
482 }
483
484 if (0 == desc.fTextureHandle) {
485 return NULL;
486 }
487
488 // FIXME: add support for TopLeft RT's by flipping all draws.
489 if (desc.fFlags & kRenderTarget_GrBackendTextureFlag &&
490 kBottomLeft_GrSurfaceOrigin != desc.fOrigin) {
491 return NULL;
492 }
493
494 int maxSize = this->getCaps().maxTextureSize();
495 if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
496 return NULL;
497 }
498
499 GrGLTexture::Desc glTexDesc;
500 // next line relies on GrBackendTextureDesc's flags matching GrTexture's
501 glTexDesc.fFlags = (GrTextureFlags) desc.fFlags;
502 glTexDesc.fWidth = desc.fWidth;
503 glTexDesc.fHeight = desc.fHeight;
504 glTexDesc.fConfig = desc.fConfig;
505 glTexDesc.fSampleCnt = desc.fSampleCnt;
506 glTexDesc.fTextureID = static_cast<GrGLuint>(desc.fTextureHandle);
507 glTexDesc.fIsWrapped = true;
508 glTexDesc.fOrigin = desc.fOrigin;
509
510 GrGLTexture* texture = NULL;
511 if (desc.fFlags & kRenderTarget_GrBackendTextureFlag) {
512 GrGLRenderTarget::Desc glRTDesc;
513 glRTDesc.fRTFBOID = 0;
514 glRTDesc.fTexFBOID = 0;
515 glRTDesc.fMSColorRenderbufferID = 0;
516 glRTDesc.fConfig = desc.fConfig;
517 glRTDesc.fSampleCnt = desc.fSampleCnt;
518 if (!this->createRenderTargetObjects(glTexDesc.fWidth,
519 glTexDesc.fHeight,
520 glTexDesc.fTextureID,
521 &glRTDesc)) {
522 return NULL;
523 }
524 texture = SkNEW_ARGS(GrGLTexture, (this, glTexDesc, glRTDesc));
525 } else {
526 texture = SkNEW_ARGS(GrGLTexture, (this, glTexDesc));
527 }
528 if (NULL == texture) {
529 return NULL;
530 }
531
532 this->setSpareTextureUnit();
533 return texture;
534 }
535
onWrapBackendRenderTarget(const GrBackendRenderTargetDesc & desc)536 GrRenderTarget* GrGpuGL::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc) {
537 GrGLRenderTarget::Desc glDesc;
538 glDesc.fConfig = desc.fConfig;
539 glDesc.fRTFBOID = static_cast<GrGLuint>(desc.fRenderTargetHandle);
540 glDesc.fMSColorRenderbufferID = 0;
541 glDesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID;
542 glDesc.fSampleCnt = desc.fSampleCnt;
543 glDesc.fIsWrapped = true;
544 GrGLIRect viewport;
545 viewport.fLeft = 0;
546 viewport.fBottom = 0;
547 viewport.fWidth = desc.fWidth;
548 viewport.fHeight = desc.fHeight;
549
550 GrRenderTarget* tgt = SkNEW_ARGS(GrGLRenderTarget,
551 (this, glDesc, viewport));
552 if (desc.fStencilBits) {
553 GrGLStencilBuffer::Format format;
554 format.fInternalFormat = GrGLStencilBuffer::kUnknownInternalFormat;
555 format.fPacked = false;
556 format.fStencilBits = desc.fStencilBits;
557 format.fTotalBits = desc.fStencilBits;
558 static const bool kIsSBWrapped = false;
559 GrGLStencilBuffer* sb = SkNEW_ARGS(GrGLStencilBuffer,
560 (this,
561 kIsSBWrapped,
562 0,
563 desc.fWidth,
564 desc.fHeight,
565 desc.fSampleCnt,
566 format));
567 tgt->setStencilBuffer(sb);
568 sb->unref();
569 }
570 return tgt;
571 }
572
573 ////////////////////////////////////////////////////////////////////////////////
574
onWriteTexturePixels(GrTexture * texture,int left,int top,int width,int height,GrPixelConfig config,const void * buffer,size_t rowBytes)575 void GrGpuGL::onWriteTexturePixels(GrTexture* texture,
576 int left, int top, int width, int height,
577 GrPixelConfig config, const void* buffer,
578 size_t rowBytes) {
579 if (NULL == buffer) {
580 return;
581 }
582 GrGLTexture* glTex = static_cast<GrGLTexture*>(texture);
583
584 this->setSpareTextureUnit();
585 GL_CALL(BindTexture(GR_GL_TEXTURE_2D, glTex->textureID()));
586 GrGLTexture::Desc desc;
587 desc.fFlags = glTex->desc().fFlags;
588 desc.fWidth = glTex->width();
589 desc.fHeight = glTex->height();
590 desc.fConfig = glTex->config();
591 desc.fSampleCnt = glTex->desc().fSampleCnt;
592 desc.fTextureID = glTex->textureID();
593 desc.fOrigin = glTex->origin();
594
595 this->uploadTexData(desc, false,
596 left, top, width, height,
597 config, buffer, rowBytes);
598 }
599
600 namespace {
adjust_pixel_ops_params(int surfaceWidth,int surfaceHeight,size_t bpp,int * left,int * top,int * width,int * height,const void ** data,size_t * rowBytes)601 bool adjust_pixel_ops_params(int surfaceWidth,
602 int surfaceHeight,
603 size_t bpp,
604 int* left, int* top, int* width, int* height,
605 const void** data,
606 size_t* rowBytes) {
607 if (!*rowBytes) {
608 *rowBytes = *width * bpp;
609 }
610
611 GrIRect subRect = GrIRect::MakeXYWH(*left, *top, *width, *height);
612 GrIRect bounds = GrIRect::MakeWH(surfaceWidth, surfaceHeight);
613
614 if (!subRect.intersect(bounds)) {
615 return false;
616 }
617 *data = reinterpret_cast<const void*>(reinterpret_cast<intptr_t>(*data) +
618 (subRect.fTop - *top) * *rowBytes + (subRect.fLeft - *left) * bpp);
619
620 *left = subRect.fLeft;
621 *top = subRect.fTop;
622 *width = subRect.width();
623 *height = subRect.height();
624 return true;
625 }
626 }
627
uploadTexData(const GrGLTexture::Desc & desc,bool isNewTexture,int left,int top,int width,int height,GrPixelConfig dataConfig,const void * data,size_t rowBytes)628 bool GrGpuGL::uploadTexData(const GrGLTexture::Desc& desc,
629 bool isNewTexture,
630 int left, int top, int width, int height,
631 GrPixelConfig dataConfig,
632 const void* data,
633 size_t rowBytes) {
634 GrAssert(NULL != data || isNewTexture);
635
636 size_t bpp = GrBytesPerPixel(dataConfig);
637 if (!adjust_pixel_ops_params(desc.fWidth, desc.fHeight, bpp, &left, &top,
638 &width, &height, &data, &rowBytes)) {
639 return false;
640 }
641 size_t trimRowBytes = width * bpp;
642
643 // in case we need a temporary, trimmed copy of the src pixels
644 SkAutoSMalloc<128 * 128> tempStorage;
645
646 // paletted textures cannot be partially updated
647 bool useTexStorage = isNewTexture &&
648 desc.fConfig != kIndex_8_GrPixelConfig &&
649 this->glCaps().texStorageSupport();
650
651 if (useTexStorage && kDesktop_GrGLBinding == this->glBinding()) {
652 // 565 is not a sized internal format on desktop GL. So on desktop with
653 // 565 we always use an unsized internal format to let the system pick
654 // the best sized format to convert the 565 data to. Since TexStorage
655 // only allows sized internal formats we will instead use TexImage2D.
656 useTexStorage = desc.fConfig != kRGB_565_GrPixelConfig;
657 }
658
659 GrGLenum internalFormat;
660 GrGLenum externalFormat;
661 GrGLenum externalType;
662 // glTexStorage requires sized internal formats on both desktop and ES. ES
663 // glTexImage requires an unsized format.
664 if (!this->configToGLFormats(dataConfig, useTexStorage, &internalFormat,
665 &externalFormat, &externalType)) {
666 return false;
667 }
668
669 if (!isNewTexture && GR_GL_PALETTE8_RGBA8 == internalFormat) {
670 // paletted textures cannot be updated
671 return false;
672 }
673
674 /*
675 * check whether to allocate a temporary buffer for flipping y or
676 * because our srcData has extra bytes past each row. If so, we need
677 * to trim those off here, since GL ES may not let us specify
678 * GL_UNPACK_ROW_LENGTH.
679 */
680 bool restoreGLRowLength = false;
681 bool swFlipY = false;
682 bool glFlipY = false;
683 if (NULL != data) {
684 if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
685 if (this->glCaps().unpackFlipYSupport()) {
686 glFlipY = true;
687 } else {
688 swFlipY = true;
689 }
690 }
691 if (this->glCaps().unpackRowLengthSupport() && !swFlipY) {
692 // can't use this for flipping, only non-neg values allowed. :(
693 if (rowBytes != trimRowBytes) {
694 GrGLint rowLength = static_cast<GrGLint>(rowBytes / bpp);
695 GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, rowLength));
696 restoreGLRowLength = true;
697 }
698 } else {
699 if (trimRowBytes != rowBytes || swFlipY) {
700 // copy data into our new storage, skipping the trailing bytes
701 size_t trimSize = height * trimRowBytes;
702 const char* src = (const char*)data;
703 if (swFlipY) {
704 src += (height - 1) * rowBytes;
705 }
706 char* dst = (char*)tempStorage.reset(trimSize);
707 for (int y = 0; y < height; y++) {
708 memcpy(dst, src, trimRowBytes);
709 if (swFlipY) {
710 src -= rowBytes;
711 } else {
712 src += rowBytes;
713 }
714 dst += trimRowBytes;
715 }
716 // now point data to our copied version
717 data = tempStorage.get();
718 }
719 }
720 if (glFlipY) {
721 GL_CALL(PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_TRUE));
722 }
723 GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, static_cast<GrGLint>(bpp)));
724 }
725 bool succeeded = true;
726 if (isNewTexture &&
727 0 == left && 0 == top &&
728 desc.fWidth == width && desc.fHeight == height) {
729 CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
730 if (useTexStorage) {
731 // We never resize or change formats of textures. We don't use
732 // mipmaps currently.
733 GL_ALLOC_CALL(this->glInterface(),
734 TexStorage2D(GR_GL_TEXTURE_2D,
735 1, // levels
736 internalFormat,
737 desc.fWidth, desc.fHeight));
738 } else {
739 if (GR_GL_PALETTE8_RGBA8 == internalFormat) {
740 GrGLsizei imageSize = desc.fWidth * desc.fHeight +
741 kGrColorTableSize;
742 GL_ALLOC_CALL(this->glInterface(),
743 CompressedTexImage2D(GR_GL_TEXTURE_2D,
744 0, // level
745 internalFormat,
746 desc.fWidth, desc.fHeight,
747 0, // border
748 imageSize,
749 data));
750 } else {
751 GL_ALLOC_CALL(this->glInterface(),
752 TexImage2D(GR_GL_TEXTURE_2D,
753 0, // level
754 internalFormat,
755 desc.fWidth, desc.fHeight,
756 0, // border
757 externalFormat, externalType,
758 data));
759 }
760 }
761 GrGLenum error = CHECK_ALLOC_ERROR(this->glInterface());
762 if (error != GR_GL_NO_ERROR) {
763 succeeded = false;
764 } else {
765 // if we have data and we used TexStorage to create the texture, we
766 // now upload with TexSubImage.
767 if (NULL != data && useTexStorage) {
768 GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
769 0, // level
770 left, top,
771 width, height,
772 externalFormat, externalType,
773 data));
774 }
775 }
776 } else {
777 if (swFlipY || glFlipY) {
778 top = desc.fHeight - (top + height);
779 }
780 GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
781 0, // level
782 left, top,
783 width, height,
784 externalFormat, externalType, data));
785 }
786
787 if (restoreGLRowLength) {
788 GrAssert(this->glCaps().unpackRowLengthSupport());
789 GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
790 }
791 if (glFlipY) {
792 GL_CALL(PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_FALSE));
793 }
794 return succeeded;
795 }
796
797 namespace {
renderbuffer_storage_msaa(GrGLContextInfo & ctxInfo,int sampleCount,GrGLenum format,int width,int height)798 bool renderbuffer_storage_msaa(GrGLContextInfo& ctxInfo,
799 int sampleCount,
800 GrGLenum format,
801 int width, int height) {
802 CLEAR_ERROR_BEFORE_ALLOC(ctxInfo.interface());
803 GrAssert(GrGLCaps::kNone_MSFBOType != ctxInfo.caps().msFBOType());
804 bool created = false;
805 if (GrGLCaps::kNVDesktop_CoverageAAType ==
806 ctxInfo.caps().coverageAAType()) {
807 const GrGLCaps::MSAACoverageMode& mode =
808 ctxInfo.caps().getMSAACoverageMode(sampleCount);
809 GL_ALLOC_CALL(ctxInfo.interface(),
810 RenderbufferStorageMultisampleCoverage(GR_GL_RENDERBUFFER,
811 mode.fCoverageSampleCnt,
812 mode.fColorSampleCnt,
813 format,
814 width, height));
815 created = (GR_GL_NO_ERROR == CHECK_ALLOC_ERROR(ctxInfo.interface()));
816 }
817 if (!created) {
818 // glRBMS will fail if requested samples is > max samples.
819 sampleCount = GrMin(sampleCount, ctxInfo.caps().maxSampleCount());
820 GL_ALLOC_CALL(ctxInfo.interface(),
821 RenderbufferStorageMultisample(GR_GL_RENDERBUFFER,
822 sampleCount,
823 format,
824 width, height));
825 created = (GR_GL_NO_ERROR == CHECK_ALLOC_ERROR(ctxInfo.interface()));
826 }
827 return created;
828 }
829 }
830
createRenderTargetObjects(int width,int height,GrGLuint texID,GrGLRenderTarget::Desc * desc)831 bool GrGpuGL::createRenderTargetObjects(int width, int height,
832 GrGLuint texID,
833 GrGLRenderTarget::Desc* desc) {
834 desc->fMSColorRenderbufferID = 0;
835 desc->fRTFBOID = 0;
836 desc->fTexFBOID = 0;
837 desc->fIsWrapped = false;
838
839 GrGLenum status;
840
841 GrGLenum msColorFormat = 0; // suppress warning
842
843 GL_CALL(GenFramebuffers(1, &desc->fTexFBOID));
844 if (!desc->fTexFBOID) {
845 goto FAILED;
846 }
847
848
849 // If we are using multisampling we will create two FBOS. We render
850 // to one and then resolve to the texture bound to the other.
851 if (desc->fSampleCnt > 0) {
852 if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType()) {
853 goto FAILED;
854 }
855 GL_CALL(GenFramebuffers(1, &desc->fRTFBOID));
856 GL_CALL(GenRenderbuffers(1, &desc->fMSColorRenderbufferID));
857 if (!desc->fRTFBOID ||
858 !desc->fMSColorRenderbufferID ||
859 !this->configToGLFormats(desc->fConfig,
860 // GLES requires sized internal formats
861 kES2_GrGLBinding == this->glBinding(),
862 &msColorFormat, NULL, NULL)) {
863 goto FAILED;
864 }
865 } else {
866 desc->fRTFBOID = desc->fTexFBOID;
867 }
868
869 // below here we may bind the FBO
870 fHWBoundRenderTarget = NULL;
871 if (desc->fRTFBOID != desc->fTexFBOID) {
872 GrAssert(desc->fSampleCnt > 0);
873 GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER,
874 desc->fMSColorRenderbufferID));
875 if (!renderbuffer_storage_msaa(fGLContextInfo,
876 desc->fSampleCnt,
877 msColorFormat,
878 width, height)) {
879 goto FAILED;
880 }
881 GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, desc->fRTFBOID));
882 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
883 GR_GL_COLOR_ATTACHMENT0,
884 GR_GL_RENDERBUFFER,
885 desc->fMSColorRenderbufferID));
886 if (!this->glCaps().isConfigVerifiedColorAttachment(desc->fConfig)) {
887 GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
888 if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
889 goto FAILED;
890 }
891 fGLContextInfo.caps().markConfigAsValidColorAttachment(
892 desc->fConfig);
893 }
894 }
895 GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, desc->fTexFBOID));
896
897 GL_CALL(FramebufferTexture2D(GR_GL_FRAMEBUFFER,
898 GR_GL_COLOR_ATTACHMENT0,
899 GR_GL_TEXTURE_2D,
900 texID, 0));
901 if (!this->glCaps().isConfigVerifiedColorAttachment(desc->fConfig)) {
902 GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
903 if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
904 goto FAILED;
905 }
906 fGLContextInfo.caps().markConfigAsValidColorAttachment(desc->fConfig);
907 }
908
909 return true;
910
911 FAILED:
912 if (desc->fMSColorRenderbufferID) {
913 GL_CALL(DeleteRenderbuffers(1, &desc->fMSColorRenderbufferID));
914 }
915 if (desc->fRTFBOID != desc->fTexFBOID) {
916 GL_CALL(DeleteFramebuffers(1, &desc->fRTFBOID));
917 }
918 if (desc->fTexFBOID) {
919 GL_CALL(DeleteFramebuffers(1, &desc->fTexFBOID));
920 }
921 return false;
922 }
923
924 // good to set a break-point here to know when createTexture fails
return_null_texture()925 static GrTexture* return_null_texture() {
926 // GrAssert(!"null texture");
927 return NULL;
928 }
929
930 #if 0 && GR_DEBUG
931 static size_t as_size_t(int x) {
932 return x;
933 }
934 #endif
935
onCreateTexture(const GrTextureDesc & desc,const void * srcData,size_t rowBytes)936 GrTexture* GrGpuGL::onCreateTexture(const GrTextureDesc& desc,
937 const void* srcData,
938 size_t rowBytes) {
939
940 GrGLTexture::Desc glTexDesc;
941 GrGLRenderTarget::Desc glRTDesc;
942
943 // Attempt to catch un- or wrongly initialized sample counts;
944 GrAssert(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
945
946 glTexDesc.fFlags = desc.fFlags;
947 glTexDesc.fWidth = desc.fWidth;
948 glTexDesc.fHeight = desc.fHeight;
949 glTexDesc.fConfig = desc.fConfig;
950 glTexDesc.fSampleCnt = desc.fSampleCnt;
951 glTexDesc.fIsWrapped = false;
952
953 glRTDesc.fMSColorRenderbufferID = 0;
954 glRTDesc.fRTFBOID = 0;
955 glRTDesc.fTexFBOID = 0;
956 glRTDesc.fIsWrapped = false;
957 glRTDesc.fConfig = glTexDesc.fConfig;
958
959 bool renderTarget = 0 != (desc.fFlags & kRenderTarget_GrTextureFlagBit);
960
961 const Caps& caps = this->getCaps();
962
963 // We keep GrRenderTargets in GL's normal orientation so that they
964 // can be drawn to by the outside world without the client having
965 // to render upside down.
966 glTexDesc.fOrigin = renderTarget ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
967
968 glRTDesc.fSampleCnt = desc.fSampleCnt;
969 if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType() &&
970 desc.fSampleCnt) {
971 //GrPrintf("MSAA RT requested but not supported on this platform.");
972 return return_null_texture();
973 }
974
975 if (renderTarget) {
976 if (glTexDesc.fWidth > caps.maxRenderTargetSize() ||
977 glTexDesc.fHeight > caps.maxRenderTargetSize()) {
978 return return_null_texture();
979 }
980 }
981
982 GL_CALL(GenTextures(1, &glTexDesc.fTextureID));
983 if (renderTarget && this->glCaps().textureUsageSupport()) {
984 // provides a hint about how this texture will be used
985 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
986 GR_GL_TEXTURE_USAGE,
987 GR_GL_FRAMEBUFFER_ATTACHMENT));
988 }
989 if (!glTexDesc.fTextureID) {
990 return return_null_texture();
991 }
992
993 this->setSpareTextureUnit();
994 GL_CALL(BindTexture(GR_GL_TEXTURE_2D, glTexDesc.fTextureID));
995
996 // Some drivers like to know filter/wrap before seeing glTexImage2D. Some
997 // drivers have a bug where an FBO won't be complete if it includes a
998 // texture that is not mipmap complete (considering the filter in use).
999 GrGLTexture::TexParams initialTexParams;
1000 // we only set a subset here so invalidate first
1001 initialTexParams.invalidate();
1002 initialTexParams.fFilter = GR_GL_NEAREST;
1003 initialTexParams.fWrapS = GR_GL_CLAMP_TO_EDGE;
1004 initialTexParams.fWrapT = GR_GL_CLAMP_TO_EDGE;
1005 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
1006 GR_GL_TEXTURE_MAG_FILTER,
1007 initialTexParams.fFilter));
1008 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
1009 GR_GL_TEXTURE_MIN_FILTER,
1010 initialTexParams.fFilter));
1011 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
1012 GR_GL_TEXTURE_WRAP_S,
1013 initialTexParams.fWrapS));
1014 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
1015 GR_GL_TEXTURE_WRAP_T,
1016 initialTexParams.fWrapT));
1017 if (!this->uploadTexData(glTexDesc, true, 0, 0,
1018 glTexDesc.fWidth, glTexDesc.fHeight,
1019 desc.fConfig, srcData, rowBytes)) {
1020 GL_CALL(DeleteTextures(1, &glTexDesc.fTextureID));
1021 return return_null_texture();
1022 }
1023
1024 GrGLTexture* tex;
1025 if (renderTarget) {
1026 // unbind the texture from the texture unit before binding it to the frame buffer
1027 GL_CALL(BindTexture(GR_GL_TEXTURE_2D, 0));
1028
1029 if (!this->createRenderTargetObjects(glTexDesc.fWidth,
1030 glTexDesc.fHeight,
1031 glTexDesc.fTextureID,
1032 &glRTDesc)) {
1033 GL_CALL(DeleteTextures(1, &glTexDesc.fTextureID));
1034 return return_null_texture();
1035 }
1036 tex = SkNEW_ARGS(GrGLTexture, (this, glTexDesc, glRTDesc));
1037 } else {
1038 tex = SkNEW_ARGS(GrGLTexture, (this, glTexDesc));
1039 }
1040 tex->setCachedTexParams(initialTexParams, this->getResetTimestamp());
1041 #ifdef TRACE_TEXTURE_CREATION
1042 GrPrintf("--- new texture [%d] size=(%d %d) config=%d\n",
1043 glTexDesc.fTextureID, desc.fWidth, desc.fHeight, desc.fConfig);
1044 #endif
1045 return tex;
1046 }
1047
1048 namespace {
1049
1050 const GrGLuint kUnknownBitCount = GrGLStencilBuffer::kUnknownBitCount;
1051
get_stencil_rb_sizes(const GrGLInterface * gl,GrGLuint rb,GrGLStencilBuffer::Format * format)1052 void inline get_stencil_rb_sizes(const GrGLInterface* gl,
1053 GrGLuint rb,
1054 GrGLStencilBuffer::Format* format) {
1055 // we shouldn't ever know one size and not the other
1056 GrAssert((kUnknownBitCount == format->fStencilBits) ==
1057 (kUnknownBitCount == format->fTotalBits));
1058 if (kUnknownBitCount == format->fStencilBits) {
1059 GR_GL_GetRenderbufferParameteriv(gl, GR_GL_RENDERBUFFER,
1060 GR_GL_RENDERBUFFER_STENCIL_SIZE,
1061 (GrGLint*)&format->fStencilBits);
1062 if (format->fPacked) {
1063 GR_GL_GetRenderbufferParameteriv(gl, GR_GL_RENDERBUFFER,
1064 GR_GL_RENDERBUFFER_DEPTH_SIZE,
1065 (GrGLint*)&format->fTotalBits);
1066 format->fTotalBits += format->fStencilBits;
1067 } else {
1068 format->fTotalBits = format->fStencilBits;
1069 }
1070 }
1071 }
1072 }
1073
createStencilBufferForRenderTarget(GrRenderTarget * rt,int width,int height)1074 bool GrGpuGL::createStencilBufferForRenderTarget(GrRenderTarget* rt,
1075 int width, int height) {
1076
1077 // All internally created RTs are also textures. We don't create
1078 // SBs for a client's standalone RT (that is a RT that isn't also a texture).
1079 GrAssert(rt->asTexture());
1080 GrAssert(width >= rt->width());
1081 GrAssert(height >= rt->height());
1082
1083 int samples = rt->numSamples();
1084 GrGLuint sbID;
1085 GL_CALL(GenRenderbuffers(1, &sbID));
1086 if (!sbID) {
1087 return false;
1088 }
1089
1090 int stencilFmtCnt = this->glCaps().stencilFormats().count();
1091 for (int i = 0; i < stencilFmtCnt; ++i) {
1092 GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, sbID));
1093 // we start with the last stencil format that succeeded in hopes
1094 // that we won't go through this loop more than once after the
1095 // first (painful) stencil creation.
1096 int sIdx = (i + fLastSuccessfulStencilFmtIdx) % stencilFmtCnt;
1097 const GrGLCaps::StencilFormat& sFmt =
1098 this->glCaps().stencilFormats()[sIdx];
1099 CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
1100 // we do this "if" so that we don't call the multisample
1101 // version on a GL that doesn't have an MSAA extension.
1102 bool created;
1103 if (samples > 0) {
1104 created = renderbuffer_storage_msaa(fGLContextInfo,
1105 samples,
1106 sFmt.fInternalFormat,
1107 width, height);
1108 } else {
1109 GL_ALLOC_CALL(this->glInterface(),
1110 RenderbufferStorage(GR_GL_RENDERBUFFER,
1111 sFmt.fInternalFormat,
1112 width, height));
1113 created =
1114 (GR_GL_NO_ERROR == CHECK_ALLOC_ERROR(this->glInterface()));
1115 }
1116 if (created) {
1117 // After sized formats we attempt an unsized format and take
1118 // whatever sizes GL gives us. In that case we query for the size.
1119 GrGLStencilBuffer::Format format = sFmt;
1120 get_stencil_rb_sizes(this->glInterface(), sbID, &format);
1121 static const bool kIsWrapped = false;
1122 SkAutoTUnref<GrStencilBuffer> sb(SkNEW_ARGS(GrGLStencilBuffer,
1123 (this, kIsWrapped, sbID, width, height,
1124 samples, format)));
1125 if (this->attachStencilBufferToRenderTarget(sb, rt)) {
1126 fLastSuccessfulStencilFmtIdx = sIdx;
1127 sb->transferToCache();
1128 rt->setStencilBuffer(sb);
1129 return true;
1130 }
1131 sb->abandon(); // otherwise we lose sbID
1132 }
1133 }
1134 GL_CALL(DeleteRenderbuffers(1, &sbID));
1135 return false;
1136 }
1137
attachStencilBufferToRenderTarget(GrStencilBuffer * sb,GrRenderTarget * rt)1138 bool GrGpuGL::attachStencilBufferToRenderTarget(GrStencilBuffer* sb,
1139 GrRenderTarget* rt) {
1140 GrGLRenderTarget* glrt = (GrGLRenderTarget*) rt;
1141
1142 GrGLuint fbo = glrt->renderFBOID();
1143
1144 if (NULL == sb) {
1145 if (NULL != rt->getStencilBuffer()) {
1146 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
1147 GR_GL_STENCIL_ATTACHMENT,
1148 GR_GL_RENDERBUFFER, 0));
1149 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
1150 GR_GL_DEPTH_ATTACHMENT,
1151 GR_GL_RENDERBUFFER, 0));
1152 #if GR_DEBUG
1153 GrGLenum status;
1154 GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
1155 GrAssert(GR_GL_FRAMEBUFFER_COMPLETE == status);
1156 #endif
1157 }
1158 return true;
1159 } else {
1160 GrGLStencilBuffer* glsb = (GrGLStencilBuffer*) sb;
1161 GrGLuint rb = glsb->renderbufferID();
1162
1163 fHWBoundRenderTarget = NULL;
1164 GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, fbo));
1165 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
1166 GR_GL_STENCIL_ATTACHMENT,
1167 GR_GL_RENDERBUFFER, rb));
1168 if (glsb->format().fPacked) {
1169 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
1170 GR_GL_DEPTH_ATTACHMENT,
1171 GR_GL_RENDERBUFFER, rb));
1172 } else {
1173 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
1174 GR_GL_DEPTH_ATTACHMENT,
1175 GR_GL_RENDERBUFFER, 0));
1176 }
1177
1178 GrGLenum status;
1179 if (!this->glCaps().isColorConfigAndStencilFormatVerified(rt->config(),
1180 glsb->format())) {
1181 GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
1182 if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
1183 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
1184 GR_GL_STENCIL_ATTACHMENT,
1185 GR_GL_RENDERBUFFER, 0));
1186 if (glsb->format().fPacked) {
1187 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
1188 GR_GL_DEPTH_ATTACHMENT,
1189 GR_GL_RENDERBUFFER, 0));
1190 }
1191 return false;
1192 } else {
1193 fGLContextInfo.caps().markColorConfigAndStencilFormatAsVerified(
1194 rt->config(),
1195 glsb->format());
1196 }
1197 }
1198 return true;
1199 }
1200 }
1201
1202 ////////////////////////////////////////////////////////////////////////////////
1203
onCreateVertexBuffer(uint32_t size,bool dynamic)1204 GrVertexBuffer* GrGpuGL::onCreateVertexBuffer(uint32_t size, bool dynamic) {
1205 GrGLuint id;
1206 GL_CALL(GenBuffers(1, &id));
1207 if (id) {
1208 GL_CALL(BindBuffer(GR_GL_ARRAY_BUFFER, id));
1209 fHWGeometryState.fArrayPtrsDirty = true;
1210 CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
1211 // make sure driver can allocate memory for this buffer
1212 GL_ALLOC_CALL(this->glInterface(),
1213 BufferData(GR_GL_ARRAY_BUFFER,
1214 size,
1215 NULL, // data ptr
1216 dynamic ? GR_GL_DYNAMIC_DRAW :
1217 GR_GL_STATIC_DRAW));
1218 if (CHECK_ALLOC_ERROR(this->glInterface()) != GR_GL_NO_ERROR) {
1219 GL_CALL(DeleteBuffers(1, &id));
1220 // deleting bound buffer does implicit bind to 0
1221 fHWGeometryState.fVertexBuffer = NULL;
1222 return NULL;
1223 }
1224 static const bool kIsWrapped = false;
1225 GrGLVertexBuffer* vertexBuffer = SkNEW_ARGS(GrGLVertexBuffer,
1226 (this, kIsWrapped, id,
1227 size, dynamic));
1228 fHWGeometryState.fVertexBuffer = vertexBuffer;
1229 return vertexBuffer;
1230 }
1231 return NULL;
1232 }
1233
onCreateIndexBuffer(uint32_t size,bool dynamic)1234 GrIndexBuffer* GrGpuGL::onCreateIndexBuffer(uint32_t size, bool dynamic) {
1235 GrGLuint id;
1236 GL_CALL(GenBuffers(1, &id));
1237 if (id) {
1238 GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, id));
1239 CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
1240 // make sure driver can allocate memory for this buffer
1241 GL_ALLOC_CALL(this->glInterface(),
1242 BufferData(GR_GL_ELEMENT_ARRAY_BUFFER,
1243 size,
1244 NULL, // data ptr
1245 dynamic ? GR_GL_DYNAMIC_DRAW :
1246 GR_GL_STATIC_DRAW));
1247 if (CHECK_ALLOC_ERROR(this->glInterface()) != GR_GL_NO_ERROR) {
1248 GL_CALL(DeleteBuffers(1, &id));
1249 // deleting bound buffer does implicit bind to 0
1250 fHWGeometryState.fIndexBuffer = NULL;
1251 return NULL;
1252 }
1253 static const bool kIsWrapped = false;
1254 GrIndexBuffer* indexBuffer = SkNEW_ARGS(GrGLIndexBuffer,
1255 (this, kIsWrapped, id, size, dynamic));
1256 fHWGeometryState.fIndexBuffer = indexBuffer;
1257 return indexBuffer;
1258 }
1259 return NULL;
1260 }
1261
onCreatePath(const SkPath & inPath)1262 GrPath* GrGpuGL::onCreatePath(const SkPath& inPath) {
1263 GrAssert(fCaps.pathStencilingSupport());
1264 return SkNEW_ARGS(GrGLPath, (this, inPath));
1265 }
1266
flushScissor()1267 void GrGpuGL::flushScissor() {
1268 const GrDrawState& drawState = this->getDrawState();
1269 const GrGLRenderTarget* rt =
1270 static_cast<const GrGLRenderTarget*>(drawState.getRenderTarget());
1271
1272 GrAssert(NULL != rt);
1273 const GrGLIRect& vp = rt->getViewport();
1274
1275 if (fScissorState.fEnabled) {
1276 GrGLIRect scissor;
1277 scissor.setRelativeTo(vp,
1278 fScissorState.fRect.fLeft,
1279 fScissorState.fRect.fTop,
1280 fScissorState.fRect.width(),
1281 fScissorState.fRect.height());
1282 // if the scissor fully contains the viewport then we fall through and
1283 // disable the scissor test.
1284 if (!scissor.contains(vp)) {
1285 if (fHWScissorSettings.fRect != scissor) {
1286 scissor.pushToGLScissor(this->glInterface());
1287 fHWScissorSettings.fRect = scissor;
1288 }
1289 if (kYes_TriState != fHWScissorSettings.fEnabled) {
1290 GL_CALL(Enable(GR_GL_SCISSOR_TEST));
1291 fHWScissorSettings.fEnabled = kYes_TriState;
1292 }
1293 return;
1294 }
1295 }
1296 if (kNo_TriState != fHWScissorSettings.fEnabled) {
1297 GL_CALL(Disable(GR_GL_SCISSOR_TEST));
1298 fHWScissorSettings.fEnabled = kNo_TriState;
1299 return;
1300 }
1301 }
1302
onClear(const GrIRect * rect,GrColor color)1303 void GrGpuGL::onClear(const GrIRect* rect, GrColor color) {
1304 const GrDrawState& drawState = this->getDrawState();
1305 const GrRenderTarget* rt = drawState.getRenderTarget();
1306 // parent class should never let us get here with no RT
1307 GrAssert(NULL != rt);
1308
1309 GrIRect clippedRect;
1310 if (NULL != rect) {
1311 // flushScissor expects rect to be clipped to the target.
1312 clippedRect = *rect;
1313 GrIRect rtRect = SkIRect::MakeWH(rt->width(), rt->height());
1314 if (clippedRect.intersect(rtRect)) {
1315 rect = &clippedRect;
1316 } else {
1317 return;
1318 }
1319 }
1320 this->flushRenderTarget(rect);
1321 GrAutoTRestore<ScissorState> asr(&fScissorState);
1322 fScissorState.fEnabled = (NULL != rect);
1323 if (fScissorState.fEnabled) {
1324 fScissorState.fRect = *rect;
1325 }
1326 this->flushScissor();
1327
1328 GrGLfloat r, g, b, a;
1329 static const GrGLfloat scale255 = 1.f / 255.f;
1330 a = GrColorUnpackA(color) * scale255;
1331 GrGLfloat scaleRGB = scale255;
1332 r = GrColorUnpackR(color) * scaleRGB;
1333 g = GrColorUnpackG(color) * scaleRGB;
1334 b = GrColorUnpackB(color) * scaleRGB;
1335
1336 GL_CALL(ColorMask(GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE));
1337 fHWWriteToColor = kYes_TriState;
1338 GL_CALL(ClearColor(r, g, b, a));
1339 GL_CALL(Clear(GR_GL_COLOR_BUFFER_BIT));
1340 }
1341
clearStencil()1342 void GrGpuGL::clearStencil() {
1343 if (NULL == this->getDrawState().getRenderTarget()) {
1344 return;
1345 }
1346
1347 this->flushRenderTarget(&GrIRect::EmptyIRect());
1348
1349 GrAutoTRestore<ScissorState> asr(&fScissorState);
1350 fScissorState.fEnabled = false;
1351 this->flushScissor();
1352
1353 GL_CALL(StencilMask(0xffffffff));
1354 GL_CALL(ClearStencil(0));
1355 GL_CALL(Clear(GR_GL_STENCIL_BUFFER_BIT));
1356 fHWStencilSettings.invalidate();
1357 }
1358
clearStencilClip(const GrIRect & rect,bool insideClip)1359 void GrGpuGL::clearStencilClip(const GrIRect& rect, bool insideClip) {
1360 const GrDrawState& drawState = this->getDrawState();
1361 const GrRenderTarget* rt = drawState.getRenderTarget();
1362 GrAssert(NULL != rt);
1363
1364 // this should only be called internally when we know we have a
1365 // stencil buffer.
1366 GrAssert(NULL != rt->getStencilBuffer());
1367 GrGLint stencilBitCount = rt->getStencilBuffer()->bits();
1368 #if 0
1369 GrAssert(stencilBitCount > 0);
1370 GrGLint clipStencilMask = (1 << (stencilBitCount - 1));
1371 #else
1372 // we could just clear the clip bit but when we go through
1373 // ANGLE a partial stencil mask will cause clears to be
1374 // turned into draws. Our contract on GrDrawTarget says that
1375 // changing the clip between stencil passes may or may not
1376 // zero the client's clip bits. So we just clear the whole thing.
1377 static const GrGLint clipStencilMask = ~0;
1378 #endif
1379 GrGLint value;
1380 if (insideClip) {
1381 value = (1 << (stencilBitCount - 1));
1382 } else {
1383 value = 0;
1384 }
1385 this->flushRenderTarget(&GrIRect::EmptyIRect());
1386
1387 GrAutoTRestore<ScissorState> asr(&fScissorState);
1388 fScissorState.fEnabled = true;
1389 fScissorState.fRect = rect;
1390 this->flushScissor();
1391
1392 GL_CALL(StencilMask((uint32_t) clipStencilMask));
1393 GL_CALL(ClearStencil(value));
1394 GL_CALL(Clear(GR_GL_STENCIL_BUFFER_BIT));
1395 fHWStencilSettings.invalidate();
1396 }
1397
onForceRenderTargetFlush()1398 void GrGpuGL::onForceRenderTargetFlush() {
1399 this->flushRenderTarget(&GrIRect::EmptyIRect());
1400 }
1401
readPixelsWillPayForYFlip(GrRenderTarget * renderTarget,int left,int top,int width,int height,GrPixelConfig config,size_t rowBytes) const1402 bool GrGpuGL::readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
1403 int left, int top,
1404 int width, int height,
1405 GrPixelConfig config,
1406 size_t rowBytes) const {
1407 // if GL can do the flip then we'll never pay for it.
1408 if (this->glCaps().packFlipYSupport()) {
1409 return false;
1410 }
1411
1412 // If we have to do memcpy to handle non-trim rowBytes then we
1413 // get the flip for free. Otherwise it costs.
1414 if (this->glCaps().packRowLengthSupport()) {
1415 return true;
1416 }
1417 // If we have to do memcpys to handle rowBytes then y-flip is free
1418 // Note the rowBytes might be tight to the passed in data, but if data
1419 // gets clipped in x to the target the rowBytes will no longer be tight.
1420 if (left >= 0 && (left + width) < renderTarget->width()) {
1421 return 0 == rowBytes ||
1422 GrBytesPerPixel(config) * width == rowBytes;
1423 } else {
1424 return false;
1425 }
1426 }
1427
onReadPixels(GrRenderTarget * target,int left,int top,int width,int height,GrPixelConfig config,void * buffer,size_t rowBytes,bool invertY)1428 bool GrGpuGL::onReadPixels(GrRenderTarget* target,
1429 int left, int top,
1430 int width, int height,
1431 GrPixelConfig config,
1432 void* buffer,
1433 size_t rowBytes,
1434 bool invertY) {
1435 GrGLenum format;
1436 GrGLenum type;
1437 if (!this->configToGLFormats(config, false, NULL, &format, &type)) {
1438 return false;
1439 }
1440 size_t bpp = GrBytesPerPixel(config);
1441 if (!adjust_pixel_ops_params(target->width(), target->height(), bpp,
1442 &left, &top, &width, &height,
1443 const_cast<const void**>(&buffer),
1444 &rowBytes)) {
1445 return false;
1446 }
1447
1448 // resolve the render target if necessary
1449 GrGLRenderTarget* tgt = static_cast<GrGLRenderTarget*>(target);
1450 GrDrawState::AutoRenderTargetRestore artr;
1451 switch (tgt->getResolveType()) {
1452 case GrGLRenderTarget::kCantResolve_ResolveType:
1453 return false;
1454 case GrGLRenderTarget::kAutoResolves_ResolveType:
1455 artr.set(this->drawState(), target);
1456 this->flushRenderTarget(&GrIRect::EmptyIRect());
1457 break;
1458 case GrGLRenderTarget::kCanResolve_ResolveType:
1459 this->onResolveRenderTarget(tgt);
1460 // we don't track the state of the READ FBO ID.
1461 GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER,
1462 tgt->textureFBOID()));
1463 break;
1464 default:
1465 GrCrash("Unknown resolve type");
1466 }
1467
1468 const GrGLIRect& glvp = tgt->getViewport();
1469
1470 // the read rect is viewport-relative
1471 GrGLIRect readRect;
1472 readRect.setRelativeTo(glvp, left, top, width, height);
1473
1474 size_t tightRowBytes = bpp * width;
1475 if (0 == rowBytes) {
1476 rowBytes = tightRowBytes;
1477 }
1478 size_t readDstRowBytes = tightRowBytes;
1479 void* readDst = buffer;
1480
1481 // determine if GL can read using the passed rowBytes or if we need
1482 // a scratch buffer.
1483 SkAutoSMalloc<32 * sizeof(GrColor)> scratch;
1484 if (rowBytes != tightRowBytes) {
1485 if (this->glCaps().packRowLengthSupport()) {
1486 GrAssert(!(rowBytes % sizeof(GrColor)));
1487 GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, rowBytes / sizeof(GrColor)));
1488 readDstRowBytes = rowBytes;
1489 } else {
1490 scratch.reset(tightRowBytes * height);
1491 readDst = scratch.get();
1492 }
1493 }
1494 if (!invertY && this->glCaps().packFlipYSupport()) {
1495 GL_CALL(PixelStorei(GR_GL_PACK_REVERSE_ROW_ORDER, 1));
1496 }
1497 GL_CALL(ReadPixels(readRect.fLeft, readRect.fBottom,
1498 readRect.fWidth, readRect.fHeight,
1499 format, type, readDst));
1500 if (readDstRowBytes != tightRowBytes) {
1501 GrAssert(this->glCaps().packRowLengthSupport());
1502 GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
1503 }
1504 if (!invertY && this->glCaps().packFlipYSupport()) {
1505 GL_CALL(PixelStorei(GR_GL_PACK_REVERSE_ROW_ORDER, 0));
1506 invertY = true;
1507 }
1508
1509 // now reverse the order of the rows, since GL's are bottom-to-top, but our
1510 // API presents top-to-bottom. We must preserve the padding contents. Note
1511 // that the above readPixels did not overwrite the padding.
1512 if (readDst == buffer) {
1513 GrAssert(rowBytes == readDstRowBytes);
1514 if (!invertY) {
1515 scratch.reset(tightRowBytes);
1516 void* tmpRow = scratch.get();
1517 // flip y in-place by rows
1518 const int halfY = height >> 1;
1519 char* top = reinterpret_cast<char*>(buffer);
1520 char* bottom = top + (height - 1) * rowBytes;
1521 for (int y = 0; y < halfY; y++) {
1522 memcpy(tmpRow, top, tightRowBytes);
1523 memcpy(top, bottom, tightRowBytes);
1524 memcpy(bottom, tmpRow, tightRowBytes);
1525 top += rowBytes;
1526 bottom -= rowBytes;
1527 }
1528 }
1529 } else {
1530 GrAssert(readDst != buffer); GrAssert(rowBytes != tightRowBytes);
1531 // copy from readDst to buffer while flipping y
1532 // const int halfY = height >> 1;
1533 const char* src = reinterpret_cast<const char*>(readDst);
1534 char* dst = reinterpret_cast<char*>(buffer);
1535 if (!invertY) {
1536 dst += (height-1) * rowBytes;
1537 }
1538 for (int y = 0; y < height; y++) {
1539 memcpy(dst, src, tightRowBytes);
1540 src += readDstRowBytes;
1541 if (invertY) {
1542 dst += rowBytes;
1543 } else {
1544 dst -= rowBytes;
1545 }
1546 }
1547 }
1548 return true;
1549 }
1550
flushRenderTarget(const GrIRect * bound)1551 void GrGpuGL::flushRenderTarget(const GrIRect* bound) {
1552
1553 GrGLRenderTarget* rt =
1554 static_cast<GrGLRenderTarget*>(this->drawState()->getRenderTarget());
1555 GrAssert(NULL != rt);
1556
1557 if (fHWBoundRenderTarget != rt) {
1558 GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, rt->renderFBOID()));
1559 #if GR_DEBUG
1560 GrGLenum status;
1561 GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
1562 if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
1563 GrPrintf("GrGpuGL::flushRenderTarget glCheckFramebufferStatus %x\n", status);
1564 }
1565 #endif
1566 fHWBoundRenderTarget = rt;
1567 const GrGLIRect& vp = rt->getViewport();
1568 if (fHWViewport != vp) {
1569 vp.pushToGLViewport(this->glInterface());
1570 fHWViewport = vp;
1571 }
1572 }
1573 if (NULL == bound || !bound->isEmpty()) {
1574 rt->flagAsNeedingResolve(bound);
1575 }
1576 }
1577
1578 GrGLenum gPrimitiveType2GLMode[] = {
1579 GR_GL_TRIANGLES,
1580 GR_GL_TRIANGLE_STRIP,
1581 GR_GL_TRIANGLE_FAN,
1582 GR_GL_POINTS,
1583 GR_GL_LINES,
1584 GR_GL_LINE_STRIP
1585 };
1586
1587 #define SWAP_PER_DRAW 0
1588
1589 #if SWAP_PER_DRAW
1590 #if GR_MAC_BUILD
1591 #include <AGL/agl.h>
1592 #elif GR_WIN32_BUILD
1593 #include <gl/GL.h>
SwapBuf()1594 void SwapBuf() {
1595 DWORD procID = GetCurrentProcessId();
1596 HWND hwnd = GetTopWindow(GetDesktopWindow());
1597 while(hwnd) {
1598 DWORD wndProcID = 0;
1599 GetWindowThreadProcessId(hwnd, &wndProcID);
1600 if(wndProcID == procID) {
1601 SwapBuffers(GetDC(hwnd));
1602 }
1603 hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
1604 }
1605 }
1606 #endif
1607 #endif
1608
onGpuDraw(const DrawInfo & info)1609 void GrGpuGL::onGpuDraw(const DrawInfo& info) {
1610 int extraStartIndexOffset;
1611 this->setupGeometry(info, &extraStartIndexOffset);
1612
1613 GrAssert((size_t)info.primitiveType() < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
1614 GrAssert(NULL != fHWGeometryState.fVertexBuffer);
1615
1616 if (info.isIndexed()) {
1617 GrAssert(NULL != fHWGeometryState.fIndexBuffer);
1618 GrGLvoid* indices = (GrGLvoid*)(sizeof(uint16_t) * (info.startIndex() +
1619 extraStartIndexOffset));
1620 // info.startVertex() was accounted for by setupGeometry.
1621 GL_CALL(DrawElements(gPrimitiveType2GLMode[info.primitiveType()],
1622 info.indexCount(),
1623 GR_GL_UNSIGNED_SHORT,
1624 indices));
1625 } else {
1626 // Pass 0 for parameter first. We have to adjust glVertexAttribPointer() to account for
1627 // startVertex in the DrawElements case. So we always rely on setupGeometry to have
1628 // accounted for startVertex.
1629 GL_CALL(DrawArrays(gPrimitiveType2GLMode[info.primitiveType()], 0, info.vertexCount()));
1630 }
1631 #if SWAP_PER_DRAW
1632 glFlush();
1633 #if GR_MAC_BUILD
1634 aglSwapBuffers(aglGetCurrentContext());
1635 int set_a_break_pt_here = 9;
1636 aglSwapBuffers(aglGetCurrentContext());
1637 #elif GR_WIN32_BUILD
1638 SwapBuf();
1639 int set_a_break_pt_here = 9;
1640 SwapBuf();
1641 #endif
1642 #endif
1643 }
1644
1645 namespace {
1646
1647 static const uint16_t kOnes16 = static_cast<uint16_t>(~0);
winding_nv_path_stencil_settings()1648 const GrStencilSettings& winding_nv_path_stencil_settings() {
1649 GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
1650 kIncClamp_StencilOp,
1651 kIncClamp_StencilOp,
1652 kAlwaysIfInClip_StencilFunc,
1653 kOnes16, kOnes16, kOnes16);
1654 return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
1655 }
even_odd_nv_path_stencil_settings()1656 const GrStencilSettings& even_odd_nv_path_stencil_settings() {
1657 GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
1658 kInvert_StencilOp,
1659 kInvert_StencilOp,
1660 kAlwaysIfInClip_StencilFunc,
1661 kOnes16, kOnes16, kOnes16);
1662 return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
1663 }
1664 }
1665
setStencilPathSettings(const GrPath &,SkPath::FillType fill,GrStencilSettings * settings)1666 void GrGpuGL::setStencilPathSettings(const GrPath&,
1667 SkPath::FillType fill,
1668 GrStencilSettings* settings) {
1669 switch (fill) {
1670 case SkPath::kEvenOdd_FillType:
1671 *settings = even_odd_nv_path_stencil_settings();
1672 return;
1673 case SkPath::kWinding_FillType:
1674 *settings = winding_nv_path_stencil_settings();
1675 return;
1676 default:
1677 GrCrash("Unexpected path fill.");
1678 }
1679 }
1680
onGpuStencilPath(const GrPath * path,SkPath::FillType fill)1681 void GrGpuGL::onGpuStencilPath(const GrPath* path, SkPath::FillType fill) {
1682 GrAssert(fCaps.pathStencilingSupport());
1683
1684 GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
1685 GrDrawState* drawState = this->drawState();
1686 GrAssert(NULL != drawState->getRenderTarget());
1687 if (NULL == drawState->getRenderTarget()->getStencilBuffer()) {
1688 return;
1689 }
1690
1691 // Decide how to manipulate the stencil buffer based on the fill rule.
1692 // Also, assert that the stencil settings we set in setStencilPathSettings
1693 // are present.
1694 GrAssert(!fStencilSettings.isTwoSided());
1695 GrGLenum fillMode;
1696 switch (fill) {
1697 case SkPath::kWinding_FillType:
1698 fillMode = GR_GL_COUNT_UP;
1699 GrAssert(kIncClamp_StencilOp ==
1700 fStencilSettings.passOp(GrStencilSettings::kFront_Face));
1701 GrAssert(kIncClamp_StencilOp ==
1702 fStencilSettings.failOp(GrStencilSettings::kFront_Face));
1703 break;
1704 case SkPath::kEvenOdd_FillType:
1705 fillMode = GR_GL_INVERT;
1706 GrAssert(kInvert_StencilOp ==
1707 fStencilSettings.passOp(GrStencilSettings::kFront_Face));
1708 GrAssert(kInvert_StencilOp ==
1709 fStencilSettings.failOp(GrStencilSettings::kFront_Face));
1710 break;
1711 default:
1712 // Only the above two fill rules are allowed.
1713 GrCrash("Unexpected path fill.");
1714 return; // suppress unused var warning.
1715 }
1716 GrGLint writeMask = fStencilSettings.writeMask(GrStencilSettings::kFront_Face);
1717 GL_CALL(StencilFillPath(id, fillMode, writeMask));
1718 }
1719
onResolveRenderTarget(GrRenderTarget * target)1720 void GrGpuGL::onResolveRenderTarget(GrRenderTarget* target) {
1721
1722 GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
1723
1724 if (rt->needsResolve()) {
1725 GrAssert(GrGLCaps::kNone_MSFBOType != this->glCaps().msFBOType());
1726 GrAssert(rt->textureFBOID() != rt->renderFBOID());
1727 GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER,
1728 rt->renderFBOID()));
1729 GL_CALL(BindFramebuffer(GR_GL_DRAW_FRAMEBUFFER,
1730 rt->textureFBOID()));
1731 // make sure we go through flushRenderTarget() since we've modified
1732 // the bound DRAW FBO ID.
1733 fHWBoundRenderTarget = NULL;
1734 const GrGLIRect& vp = rt->getViewport();
1735 const GrIRect dirtyRect = rt->getResolveRect();
1736 GrGLIRect r;
1737 r.setRelativeTo(vp, dirtyRect.fLeft, dirtyRect.fTop,
1738 dirtyRect.width(), dirtyRect.height());
1739
1740 GrAutoTRestore<ScissorState> asr;
1741 if (GrGLCaps::kAppleES_MSFBOType == this->glCaps().msFBOType()) {
1742 // Apple's extension uses the scissor as the blit bounds.
1743 asr.reset(&fScissorState);
1744 fScissorState.fEnabled = true;
1745 fScissorState.fRect = dirtyRect;
1746 this->flushScissor();
1747 GL_CALL(ResolveMultisampleFramebuffer());
1748 } else {
1749 if (GrGLCaps::kDesktopARB_MSFBOType != this->glCaps().msFBOType()) {
1750 // this respects the scissor during the blit, so disable it.
1751 GrAssert(GrGLCaps::kDesktopEXT_MSFBOType ==
1752 this->glCaps().msFBOType());
1753 asr.reset(&fScissorState);
1754 fScissorState.fEnabled = false;
1755 this->flushScissor();
1756 }
1757 int right = r.fLeft + r.fWidth;
1758 int top = r.fBottom + r.fHeight;
1759 GL_CALL(BlitFramebuffer(r.fLeft, r.fBottom, right, top,
1760 r.fLeft, r.fBottom, right, top,
1761 GR_GL_COLOR_BUFFER_BIT, GR_GL_NEAREST));
1762 }
1763 rt->flagAsResolved();
1764 }
1765 }
1766
1767 namespace {
1768
gr_to_gl_stencil_func(GrStencilFunc basicFunc)1769 GrGLenum gr_to_gl_stencil_func(GrStencilFunc basicFunc) {
1770 static const GrGLenum gTable[] = {
1771 GR_GL_ALWAYS, // kAlways_StencilFunc
1772 GR_GL_NEVER, // kNever_StencilFunc
1773 GR_GL_GREATER, // kGreater_StencilFunc
1774 GR_GL_GEQUAL, // kGEqual_StencilFunc
1775 GR_GL_LESS, // kLess_StencilFunc
1776 GR_GL_LEQUAL, // kLEqual_StencilFunc,
1777 GR_GL_EQUAL, // kEqual_StencilFunc,
1778 GR_GL_NOTEQUAL, // kNotEqual_StencilFunc,
1779 };
1780 GR_STATIC_ASSERT(GR_ARRAY_COUNT(gTable) == kBasicStencilFuncCount);
1781 GR_STATIC_ASSERT(0 == kAlways_StencilFunc);
1782 GR_STATIC_ASSERT(1 == kNever_StencilFunc);
1783 GR_STATIC_ASSERT(2 == kGreater_StencilFunc);
1784 GR_STATIC_ASSERT(3 == kGEqual_StencilFunc);
1785 GR_STATIC_ASSERT(4 == kLess_StencilFunc);
1786 GR_STATIC_ASSERT(5 == kLEqual_StencilFunc);
1787 GR_STATIC_ASSERT(6 == kEqual_StencilFunc);
1788 GR_STATIC_ASSERT(7 == kNotEqual_StencilFunc);
1789 GrAssert((unsigned) basicFunc < kBasicStencilFuncCount);
1790
1791 return gTable[basicFunc];
1792 }
1793
gr_to_gl_stencil_op(GrStencilOp op)1794 GrGLenum gr_to_gl_stencil_op(GrStencilOp op) {
1795 static const GrGLenum gTable[] = {
1796 GR_GL_KEEP, // kKeep_StencilOp
1797 GR_GL_REPLACE, // kReplace_StencilOp
1798 GR_GL_INCR_WRAP, // kIncWrap_StencilOp
1799 GR_GL_INCR, // kIncClamp_StencilOp
1800 GR_GL_DECR_WRAP, // kDecWrap_StencilOp
1801 GR_GL_DECR, // kDecClamp_StencilOp
1802 GR_GL_ZERO, // kZero_StencilOp
1803 GR_GL_INVERT, // kInvert_StencilOp
1804 };
1805 GR_STATIC_ASSERT(GR_ARRAY_COUNT(gTable) == kStencilOpCount);
1806 GR_STATIC_ASSERT(0 == kKeep_StencilOp);
1807 GR_STATIC_ASSERT(1 == kReplace_StencilOp);
1808 GR_STATIC_ASSERT(2 == kIncWrap_StencilOp);
1809 GR_STATIC_ASSERT(3 == kIncClamp_StencilOp);
1810 GR_STATIC_ASSERT(4 == kDecWrap_StencilOp);
1811 GR_STATIC_ASSERT(5 == kDecClamp_StencilOp);
1812 GR_STATIC_ASSERT(6 == kZero_StencilOp);
1813 GR_STATIC_ASSERT(7 == kInvert_StencilOp);
1814 GrAssert((unsigned) op < kStencilOpCount);
1815 return gTable[op];
1816 }
1817
set_gl_stencil(const GrGLInterface * gl,const GrStencilSettings & settings,GrGLenum glFace,GrStencilSettings::Face grFace)1818 void set_gl_stencil(const GrGLInterface* gl,
1819 const GrStencilSettings& settings,
1820 GrGLenum glFace,
1821 GrStencilSettings::Face grFace) {
1822 GrGLenum glFunc = gr_to_gl_stencil_func(settings.func(grFace));
1823 GrGLenum glFailOp = gr_to_gl_stencil_op(settings.failOp(grFace));
1824 GrGLenum glPassOp = gr_to_gl_stencil_op(settings.passOp(grFace));
1825
1826 GrGLint ref = settings.funcRef(grFace);
1827 GrGLint mask = settings.funcMask(grFace);
1828 GrGLint writeMask = settings.writeMask(grFace);
1829
1830 if (GR_GL_FRONT_AND_BACK == glFace) {
1831 // we call the combined func just in case separate stencil is not
1832 // supported.
1833 GR_GL_CALL(gl, StencilFunc(glFunc, ref, mask));
1834 GR_GL_CALL(gl, StencilMask(writeMask));
1835 GR_GL_CALL(gl, StencilOp(glFailOp, glPassOp, glPassOp));
1836 } else {
1837 GR_GL_CALL(gl, StencilFuncSeparate(glFace, glFunc, ref, mask));
1838 GR_GL_CALL(gl, StencilMaskSeparate(glFace, writeMask));
1839 GR_GL_CALL(gl, StencilOpSeparate(glFace, glFailOp, glPassOp, glPassOp));
1840 }
1841 }
1842 }
1843
flushStencil(DrawType type)1844 void GrGpuGL::flushStencil(DrawType type) {
1845 if (kStencilPath_DrawType == type) {
1846 GrAssert(!fStencilSettings.isTwoSided());
1847 // Just the func, ref, and mask is set here. The op and write mask are params to the call
1848 // that draws the path to the SB (glStencilFillPath)
1849 GrGLenum func =
1850 gr_to_gl_stencil_func(fStencilSettings.func(GrStencilSettings::kFront_Face));
1851 GL_CALL(PathStencilFunc(func,
1852 fStencilSettings.funcRef(GrStencilSettings::kFront_Face),
1853 fStencilSettings.funcMask(GrStencilSettings::kFront_Face)));
1854 } else if (fHWStencilSettings != fStencilSettings) {
1855 if (fStencilSettings.isDisabled()) {
1856 if (kNo_TriState != fHWStencilTestEnabled) {
1857 GL_CALL(Disable(GR_GL_STENCIL_TEST));
1858 fHWStencilTestEnabled = kNo_TriState;
1859 }
1860 } else {
1861 if (kYes_TriState != fHWStencilTestEnabled) {
1862 GL_CALL(Enable(GR_GL_STENCIL_TEST));
1863 fHWStencilTestEnabled = kYes_TriState;
1864 }
1865 }
1866 if (!fStencilSettings.isDisabled()) {
1867 if (this->getCaps().twoSidedStencilSupport()) {
1868 set_gl_stencil(this->glInterface(),
1869 fStencilSettings,
1870 GR_GL_FRONT,
1871 GrStencilSettings::kFront_Face);
1872 set_gl_stencil(this->glInterface(),
1873 fStencilSettings,
1874 GR_GL_BACK,
1875 GrStencilSettings::kBack_Face);
1876 } else {
1877 set_gl_stencil(this->glInterface(),
1878 fStencilSettings,
1879 GR_GL_FRONT_AND_BACK,
1880 GrStencilSettings::kFront_Face);
1881 }
1882 }
1883 fHWStencilSettings = fStencilSettings;
1884 }
1885 }
1886
flushAAState(DrawType type)1887 void GrGpuGL::flushAAState(DrawType type) {
1888 const GrRenderTarget* rt = this->getDrawState().getRenderTarget();
1889 if (kDesktop_GrGLBinding == this->glBinding()) {
1890 // ES doesn't support toggling GL_MULTISAMPLE and doesn't have
1891 // smooth lines.
1892 // we prefer smooth lines over multisampled lines
1893 bool smoothLines = false;
1894
1895 if (kDrawLines_DrawType == type) {
1896 smoothLines = this->willUseHWAALines();
1897 if (smoothLines) {
1898 if (kYes_TriState != fHWAAState.fSmoothLineEnabled) {
1899 GL_CALL(Enable(GR_GL_LINE_SMOOTH));
1900 fHWAAState.fSmoothLineEnabled = kYes_TriState;
1901 // must disable msaa to use line smoothing
1902 if (rt->isMultisampled() &&
1903 kNo_TriState != fHWAAState.fMSAAEnabled) {
1904 GL_CALL(Disable(GR_GL_MULTISAMPLE));
1905 fHWAAState.fMSAAEnabled = kNo_TriState;
1906 }
1907 }
1908 } else {
1909 if (kNo_TriState != fHWAAState.fSmoothLineEnabled) {
1910 GL_CALL(Disable(GR_GL_LINE_SMOOTH));
1911 fHWAAState.fSmoothLineEnabled = kNo_TriState;
1912 }
1913 }
1914 }
1915 if (!smoothLines && rt->isMultisampled()) {
1916 // FIXME: GL_NV_pr doesn't seem to like MSAA disabled. The paths
1917 // convex hulls of each segment appear to get filled.
1918 bool enableMSAA = kStencilPath_DrawType == type ||
1919 this->getDrawState().isHWAntialiasState();
1920 if (enableMSAA) {
1921 if (kYes_TriState != fHWAAState.fMSAAEnabled) {
1922 GL_CALL(Enable(GR_GL_MULTISAMPLE));
1923 fHWAAState.fMSAAEnabled = kYes_TriState;
1924 }
1925 } else {
1926 if (kNo_TriState != fHWAAState.fMSAAEnabled) {
1927 GL_CALL(Disable(GR_GL_MULTISAMPLE));
1928 fHWAAState.fMSAAEnabled = kNo_TriState;
1929 }
1930 }
1931 }
1932 }
1933 }
1934
flushBlend(bool isLines,GrBlendCoeff srcCoeff,GrBlendCoeff dstCoeff)1935 void GrGpuGL::flushBlend(bool isLines,
1936 GrBlendCoeff srcCoeff,
1937 GrBlendCoeff dstCoeff) {
1938 if (isLines && this->willUseHWAALines()) {
1939 if (kYes_TriState != fHWBlendState.fEnabled) {
1940 GL_CALL(Enable(GR_GL_BLEND));
1941 fHWBlendState.fEnabled = kYes_TriState;
1942 }
1943 if (kSA_GrBlendCoeff != fHWBlendState.fSrcCoeff ||
1944 kISA_GrBlendCoeff != fHWBlendState.fDstCoeff) {
1945 GL_CALL(BlendFunc(gXfermodeCoeff2Blend[kSA_GrBlendCoeff],
1946 gXfermodeCoeff2Blend[kISA_GrBlendCoeff]));
1947 fHWBlendState.fSrcCoeff = kSA_GrBlendCoeff;
1948 fHWBlendState.fDstCoeff = kISA_GrBlendCoeff;
1949 }
1950 } else {
1951 // any optimization to disable blending should
1952 // have already been applied and tweaked the coeffs
1953 // to (1, 0).
1954 bool blendOff = kOne_GrBlendCoeff == srcCoeff &&
1955 kZero_GrBlendCoeff == dstCoeff;
1956 if (blendOff) {
1957 if (kNo_TriState != fHWBlendState.fEnabled) {
1958 GL_CALL(Disable(GR_GL_BLEND));
1959 fHWBlendState.fEnabled = kNo_TriState;
1960 }
1961 } else {
1962 if (kYes_TriState != fHWBlendState.fEnabled) {
1963 GL_CALL(Enable(GR_GL_BLEND));
1964 fHWBlendState.fEnabled = kYes_TriState;
1965 }
1966 if (fHWBlendState.fSrcCoeff != srcCoeff ||
1967 fHWBlendState.fDstCoeff != dstCoeff) {
1968 GL_CALL(BlendFunc(gXfermodeCoeff2Blend[srcCoeff],
1969 gXfermodeCoeff2Blend[dstCoeff]));
1970 fHWBlendState.fSrcCoeff = srcCoeff;
1971 fHWBlendState.fDstCoeff = dstCoeff;
1972 }
1973 GrColor blendConst = this->getDrawState().getBlendConstant();
1974 if ((BlendCoeffReferencesConstant(srcCoeff) ||
1975 BlendCoeffReferencesConstant(dstCoeff)) &&
1976 (!fHWBlendState.fConstColorValid ||
1977 fHWBlendState.fConstColor != blendConst)) {
1978 GrGLfloat c[4];
1979 GrColorToRGBAFloat(blendConst, c);
1980 GL_CALL(BlendColor(c[0], c[1], c[2], c[3]));
1981 fHWBlendState.fConstColor = blendConst;
1982 fHWBlendState.fConstColorValid = true;
1983 }
1984 }
1985 }
1986 }
1987 namespace {
1988
set_tex_swizzle(GrGLenum swizzle[4],const GrGLInterface * gl)1989 inline void set_tex_swizzle(GrGLenum swizzle[4], const GrGLInterface* gl) {
1990 GR_GL_CALL(gl, TexParameteriv(GR_GL_TEXTURE_2D,
1991 GR_GL_TEXTURE_SWIZZLE_RGBA,
1992 reinterpret_cast<const GrGLint*>(swizzle)));
1993 }
1994
tile_to_gl_wrap(SkShader::TileMode tm)1995 inline GrGLenum tile_to_gl_wrap(SkShader::TileMode tm) {
1996 static const GrGLenum gWrapModes[] = {
1997 GR_GL_CLAMP_TO_EDGE,
1998 GR_GL_REPEAT,
1999 GR_GL_MIRRORED_REPEAT
2000 };
2001 GrAssert((unsigned) tm <= SK_ARRAY_COUNT(gWrapModes));
2002 GR_STATIC_ASSERT(0 == SkShader::kClamp_TileMode);
2003 GR_STATIC_ASSERT(1 == SkShader::kRepeat_TileMode);
2004 GR_STATIC_ASSERT(2 == SkShader::kMirror_TileMode);
2005 return gWrapModes[tm];
2006 }
2007
2008 }
2009
bindTexture(int unitIdx,const GrTextureParams & params,GrGLTexture * texture)2010 void GrGpuGL::bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture) {
2011 GrAssert(NULL != texture);
2012
2013 // If we created a rt/tex and rendered to it without using a texture and now we're texturing
2014 // from the rt it will still be the last bound texture, but it needs resolving. So keep this
2015 // out of the "last != next" check.
2016 GrGLRenderTarget* texRT = static_cast<GrGLRenderTarget*>(texture->asRenderTarget());
2017 if (NULL != texRT) {
2018 this->onResolveRenderTarget(texRT);
2019 }
2020
2021 if (fHWBoundTextures[unitIdx] != texture) {
2022 this->setTextureUnit(unitIdx);
2023 GL_CALL(BindTexture(GR_GL_TEXTURE_2D, texture->textureID()));
2024 fHWBoundTextures[unitIdx] = texture;
2025 }
2026
2027 ResetTimestamp timestamp;
2028 const GrGLTexture::TexParams& oldTexParams = texture->getCachedTexParams(×tamp);
2029 bool setAll = timestamp < this->getResetTimestamp();
2030 GrGLTexture::TexParams newTexParams;
2031
2032 newTexParams.fFilter = params.isBilerp() ? GR_GL_LINEAR : GR_GL_NEAREST;
2033
2034 newTexParams.fWrapS = tile_to_gl_wrap(params.getTileModeX());
2035 newTexParams.fWrapT = tile_to_gl_wrap(params.getTileModeY());
2036 memcpy(newTexParams.fSwizzleRGBA,
2037 GrGLShaderBuilder::GetTexParamSwizzle(texture->config(), this->glCaps()),
2038 sizeof(newTexParams.fSwizzleRGBA));
2039 if (setAll || newTexParams.fFilter != oldTexParams.fFilter) {
2040 this->setTextureUnit(unitIdx);
2041 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
2042 GR_GL_TEXTURE_MAG_FILTER,
2043 newTexParams.fFilter));
2044 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
2045 GR_GL_TEXTURE_MIN_FILTER,
2046 newTexParams.fFilter));
2047 }
2048 if (setAll || newTexParams.fWrapS != oldTexParams.fWrapS) {
2049 this->setTextureUnit(unitIdx);
2050 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
2051 GR_GL_TEXTURE_WRAP_S,
2052 newTexParams.fWrapS));
2053 }
2054 if (setAll || newTexParams.fWrapT != oldTexParams.fWrapT) {
2055 this->setTextureUnit(unitIdx);
2056 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
2057 GR_GL_TEXTURE_WRAP_T,
2058 newTexParams.fWrapT));
2059 }
2060 if (this->glCaps().textureSwizzleSupport() &&
2061 (setAll || memcmp(newTexParams.fSwizzleRGBA,
2062 oldTexParams.fSwizzleRGBA,
2063 sizeof(newTexParams.fSwizzleRGBA)))) {
2064 this->setTextureUnit(unitIdx);
2065 set_tex_swizzle(newTexParams.fSwizzleRGBA,
2066 this->glInterface());
2067 }
2068 texture->setCachedTexParams(newTexParams, this->getResetTimestamp());
2069 }
2070
flushMiscFixedFunctionState()2071 void GrGpuGL::flushMiscFixedFunctionState() {
2072
2073 const GrDrawState& drawState = this->getDrawState();
2074
2075 if (drawState.isDitherState()) {
2076 if (kYes_TriState != fHWDitherEnabled) {
2077 GL_CALL(Enable(GR_GL_DITHER));
2078 fHWDitherEnabled = kYes_TriState;
2079 }
2080 } else {
2081 if (kNo_TriState != fHWDitherEnabled) {
2082 GL_CALL(Disable(GR_GL_DITHER));
2083 fHWDitherEnabled = kNo_TriState;
2084 }
2085 }
2086
2087 if (drawState.isColorWriteDisabled()) {
2088 if (kNo_TriState != fHWWriteToColor) {
2089 GL_CALL(ColorMask(GR_GL_FALSE, GR_GL_FALSE,
2090 GR_GL_FALSE, GR_GL_FALSE));
2091 fHWWriteToColor = kNo_TriState;
2092 }
2093 } else {
2094 if (kYes_TriState != fHWWriteToColor) {
2095 GL_CALL(ColorMask(GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE));
2096 fHWWriteToColor = kYes_TriState;
2097 }
2098 }
2099
2100 if (fHWDrawFace != drawState.getDrawFace()) {
2101 switch (this->getDrawState().getDrawFace()) {
2102 case GrDrawState::kCCW_DrawFace:
2103 GL_CALL(Enable(GR_GL_CULL_FACE));
2104 GL_CALL(CullFace(GR_GL_BACK));
2105 break;
2106 case GrDrawState::kCW_DrawFace:
2107 GL_CALL(Enable(GR_GL_CULL_FACE));
2108 GL_CALL(CullFace(GR_GL_FRONT));
2109 break;
2110 case GrDrawState::kBoth_DrawFace:
2111 GL_CALL(Disable(GR_GL_CULL_FACE));
2112 break;
2113 default:
2114 GrCrash("Unknown draw face.");
2115 }
2116 fHWDrawFace = drawState.getDrawFace();
2117 }
2118 }
2119
notifyVertexBufferBind(const GrGLVertexBuffer * buffer)2120 void GrGpuGL::notifyVertexBufferBind(const GrGLVertexBuffer* buffer) {
2121 if (fHWGeometryState.fVertexBuffer != buffer) {
2122 fHWGeometryState.fArrayPtrsDirty = true;
2123 fHWGeometryState.fVertexBuffer = buffer;
2124 }
2125 }
2126
notifyVertexBufferDelete(const GrGLVertexBuffer * buffer)2127 void GrGpuGL::notifyVertexBufferDelete(const GrGLVertexBuffer* buffer) {
2128 if (fHWGeometryState.fVertexBuffer == buffer) {
2129 // deleting bound buffer does implied bind to 0
2130 fHWGeometryState.fVertexBuffer = NULL;
2131 fHWGeometryState.fArrayPtrsDirty = true;
2132 }
2133 }
2134
notifyIndexBufferBind(const GrGLIndexBuffer * buffer)2135 void GrGpuGL::notifyIndexBufferBind(const GrGLIndexBuffer* buffer) {
2136 fHWGeometryState.fIndexBuffer = buffer;
2137 }
2138
notifyIndexBufferDelete(const GrGLIndexBuffer * buffer)2139 void GrGpuGL::notifyIndexBufferDelete(const GrGLIndexBuffer* buffer) {
2140 if (fHWGeometryState.fIndexBuffer == buffer) {
2141 // deleting bound buffer does implied bind to 0
2142 fHWGeometryState.fIndexBuffer = NULL;
2143 }
2144 }
2145
notifyRenderTargetDelete(GrRenderTarget * renderTarget)2146 void GrGpuGL::notifyRenderTargetDelete(GrRenderTarget* renderTarget) {
2147 GrAssert(NULL != renderTarget);
2148 if (fHWBoundRenderTarget == renderTarget) {
2149 fHWBoundRenderTarget = NULL;
2150 }
2151 }
2152
notifyTextureDelete(GrGLTexture * texture)2153 void GrGpuGL::notifyTextureDelete(GrGLTexture* texture) {
2154 for (int s = 0; s < GrDrawState::kNumStages; ++s) {
2155 if (fHWBoundTextures[s] == texture) {
2156 // deleting bound texture does implied bind to 0
2157 fHWBoundTextures[s] = NULL;
2158 }
2159 }
2160 }
2161
configToGLFormats(GrPixelConfig config,bool getSizedInternalFormat,GrGLenum * internalFormat,GrGLenum * externalFormat,GrGLenum * externalType)2162 bool GrGpuGL::configToGLFormats(GrPixelConfig config,
2163 bool getSizedInternalFormat,
2164 GrGLenum* internalFormat,
2165 GrGLenum* externalFormat,
2166 GrGLenum* externalType) {
2167 GrGLenum dontCare;
2168 if (NULL == internalFormat) {
2169 internalFormat = &dontCare;
2170 }
2171 if (NULL == externalFormat) {
2172 externalFormat = &dontCare;
2173 }
2174 if (NULL == externalType) {
2175 externalType = &dontCare;
2176 }
2177
2178 switch (config) {
2179 case kRGBA_8888_GrPixelConfig:
2180 *internalFormat = GR_GL_RGBA;
2181 *externalFormat = GR_GL_RGBA;
2182 if (getSizedInternalFormat) {
2183 *internalFormat = GR_GL_RGBA8;
2184 } else {
2185 *internalFormat = GR_GL_RGBA;
2186 }
2187 *externalType = GR_GL_UNSIGNED_BYTE;
2188 break;
2189 case kBGRA_8888_GrPixelConfig:
2190 if (!this->glCaps().bgraFormatSupport()) {
2191 return false;
2192 }
2193 if (this->glCaps().bgraIsInternalFormat()) {
2194 if (getSizedInternalFormat) {
2195 *internalFormat = GR_GL_BGRA8;
2196 } else {
2197 *internalFormat = GR_GL_BGRA;
2198 }
2199 } else {
2200 if (getSizedInternalFormat) {
2201 *internalFormat = GR_GL_RGBA8;
2202 } else {
2203 *internalFormat = GR_GL_RGBA;
2204 }
2205 }
2206 *externalFormat = GR_GL_BGRA;
2207 *externalType = GR_GL_UNSIGNED_BYTE;
2208 break;
2209 case kRGB_565_GrPixelConfig:
2210 *internalFormat = GR_GL_RGB;
2211 *externalFormat = GR_GL_RGB;
2212 if (getSizedInternalFormat) {
2213 if (this->glBinding() == kDesktop_GrGLBinding) {
2214 return false;
2215 } else {
2216 *internalFormat = GR_GL_RGB565;
2217 }
2218 } else {
2219 *internalFormat = GR_GL_RGB;
2220 }
2221 *externalType = GR_GL_UNSIGNED_SHORT_5_6_5;
2222 break;
2223 case kRGBA_4444_GrPixelConfig:
2224 *internalFormat = GR_GL_RGBA;
2225 *externalFormat = GR_GL_RGBA;
2226 if (getSizedInternalFormat) {
2227 *internalFormat = GR_GL_RGBA4;
2228 } else {
2229 *internalFormat = GR_GL_RGBA;
2230 }
2231 *externalType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
2232 break;
2233 case kIndex_8_GrPixelConfig:
2234 if (this->getCaps().eightBitPaletteSupport()) {
2235 *internalFormat = GR_GL_PALETTE8_RGBA8;
2236 // glCompressedTexImage doesn't take external params
2237 *externalFormat = GR_GL_PALETTE8_RGBA8;
2238 // no sized/unsized internal format distinction here
2239 *internalFormat = GR_GL_PALETTE8_RGBA8;
2240 // unused with CompressedTexImage
2241 *externalType = GR_GL_UNSIGNED_BYTE;
2242 } else {
2243 return false;
2244 }
2245 break;
2246 case kAlpha_8_GrPixelConfig:
2247 if (this->glCaps().textureRedSupport()) {
2248 *internalFormat = GR_GL_RED;
2249 *externalFormat = GR_GL_RED;
2250 if (getSizedInternalFormat) {
2251 *internalFormat = GR_GL_R8;
2252 } else {
2253 *internalFormat = GR_GL_RED;
2254 }
2255 *externalType = GR_GL_UNSIGNED_BYTE;
2256 } else {
2257 *internalFormat = GR_GL_ALPHA;
2258 *externalFormat = GR_GL_ALPHA;
2259 if (getSizedInternalFormat) {
2260 *internalFormat = GR_GL_ALPHA8;
2261 } else {
2262 *internalFormat = GR_GL_ALPHA;
2263 }
2264 *externalType = GR_GL_UNSIGNED_BYTE;
2265 }
2266 break;
2267 default:
2268 return false;
2269 }
2270 return true;
2271 }
2272
setTextureUnit(int unit)2273 void GrGpuGL::setTextureUnit(int unit) {
2274 GrAssert(unit >= 0 && unit < GrDrawState::kNumStages);
2275 if (fHWActiveTextureUnitIdx != unit) {
2276 GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + unit));
2277 fHWActiveTextureUnitIdx = unit;
2278 }
2279 }
2280
setSpareTextureUnit()2281 void GrGpuGL::setSpareTextureUnit() {
2282 if (fHWActiveTextureUnitIdx != (GR_GL_TEXTURE0 + SPARE_TEX_UNIT)) {
2283 GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + SPARE_TEX_UNIT));
2284 fHWActiveTextureUnitIdx = SPARE_TEX_UNIT;
2285 }
2286 }
2287
setBuffers(bool indexed,int * extraVertexOffset,int * extraIndexOffset)2288 void GrGpuGL::setBuffers(bool indexed,
2289 int* extraVertexOffset,
2290 int* extraIndexOffset) {
2291
2292 GrAssert(NULL != extraVertexOffset);
2293
2294 const GeometryPoolState& geoPoolState = this->getGeomPoolState();
2295
2296 GrGLVertexBuffer* vbuf;
2297 switch (this->getGeomSrc().fVertexSrc) {
2298 case kBuffer_GeometrySrcType:
2299 *extraVertexOffset = 0;
2300 vbuf = (GrGLVertexBuffer*) this->getGeomSrc().fVertexBuffer;
2301 break;
2302 case kArray_GeometrySrcType:
2303 case kReserved_GeometrySrcType:
2304 this->finalizeReservedVertices();
2305 *extraVertexOffset = geoPoolState.fPoolStartVertex;
2306 vbuf = (GrGLVertexBuffer*) geoPoolState.fPoolVertexBuffer;
2307 break;
2308 default:
2309 vbuf = NULL; // suppress warning
2310 GrCrash("Unknown geometry src type!");
2311 }
2312
2313 GrAssert(NULL != vbuf);
2314 GrAssert(!vbuf->isLocked());
2315 if (fHWGeometryState.fVertexBuffer != vbuf) {
2316 GL_CALL(BindBuffer(GR_GL_ARRAY_BUFFER, vbuf->bufferID()));
2317 fHWGeometryState.fArrayPtrsDirty = true;
2318 fHWGeometryState.fVertexBuffer = vbuf;
2319 }
2320
2321 if (indexed) {
2322 GrAssert(NULL != extraIndexOffset);
2323
2324 GrGLIndexBuffer* ibuf;
2325 switch (this->getGeomSrc().fIndexSrc) {
2326 case kBuffer_GeometrySrcType:
2327 *extraIndexOffset = 0;
2328 ibuf = (GrGLIndexBuffer*)this->getGeomSrc().fIndexBuffer;
2329 break;
2330 case kArray_GeometrySrcType:
2331 case kReserved_GeometrySrcType:
2332 this->finalizeReservedIndices();
2333 *extraIndexOffset = geoPoolState.fPoolStartIndex;
2334 ibuf = (GrGLIndexBuffer*) geoPoolState.fPoolIndexBuffer;
2335 break;
2336 default:
2337 ibuf = NULL; // suppress warning
2338 GrCrash("Unknown geometry src type!");
2339 }
2340
2341 GrAssert(NULL != ibuf);
2342 GrAssert(!ibuf->isLocked());
2343 if (fHWGeometryState.fIndexBuffer != ibuf) {
2344 GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, ibuf->bufferID()));
2345 fHWGeometryState.fIndexBuffer = ibuf;
2346 }
2347 }
2348 }
2349