The Tor Browser / file comparison

comparison: gfx/angle/src/libGLESv2/Context.cpp

gfx/angle/src/libGLESv2/Context.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:fb286c4b9f8a
1 #include "precompiled.h"
2 //
3 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
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 // Context.cpp: Implements the gl::Context class, managing all GL state and performing
9 // rendering operations. It is the GLES2 specific implementation of EGLContext.
10
11 #include "libGLESv2/Context.h"
12
13 #include "libGLESv2/main.h"
14 #include "libGLESv2/utilities.h"
15 #include "libGLESv2/Buffer.h"
16 #include "libGLESv2/Fence.h"
17 #include "libGLESv2/Framebuffer.h"
18 #include "libGLESv2/Renderbuffer.h"
19 #include "libGLESv2/Program.h"
20 #include "libGLESv2/ProgramBinary.h"
21 #include "libGLESv2/Query.h"
22 #include "libGLESv2/Texture.h"
23 #include "libGLESv2/ResourceManager.h"
24 #include "libGLESv2/renderer/IndexDataManager.h"
25 #include "libGLESv2/renderer/RenderTarget.h"
26 #include "libGLESv2/renderer/Renderer.h"
27
28 #include "libEGL/Surface.h"
29
30 #undef near
31 #undef far
32
33 namespace gl
34 {
35 static const char* makeStaticString(const std::string& str)
36 {
37 static std::set<std::string> strings;
38 std::set<std::string>::iterator it = strings.find(str);
39 if (it != strings.end())
40 return it->c_str();
41
42 return strings.insert(str).first->c_str();
43 }
44
45 Context::Context(const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess) : mRenderer(renderer)
46 {
47 ASSERT(robustAccess == false); // Unimplemented
48
49 mFenceHandleAllocator.setBaseHandle(0);
50
51 setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
52
53 mState.depthClearValue = 1.0f;
54 mState.stencilClearValue = 0;
55
56 mState.rasterizer.cullFace = false;
57 mState.rasterizer.cullMode = GL_BACK;
58 mState.rasterizer.frontFace = GL_CCW;
59 mState.rasterizer.polygonOffsetFill = false;
60 mState.rasterizer.polygonOffsetFactor = 0.0f;
61 mState.rasterizer.polygonOffsetUnits = 0.0f;
62 mState.rasterizer.pointDrawMode = false;
63 mState.rasterizer.multiSample = false;
64 mState.scissorTest = false;
65 mState.scissor.x = 0;
66 mState.scissor.y = 0;
67 mState.scissor.width = 0;
68 mState.scissor.height = 0;
69
70 mState.blend.blend = false;
71 mState.blend.sourceBlendRGB = GL_ONE;
72 mState.blend.sourceBlendAlpha = GL_ONE;
73 mState.blend.destBlendRGB = GL_ZERO;
74 mState.blend.destBlendAlpha = GL_ZERO;
75 mState.blend.blendEquationRGB = GL_FUNC_ADD;
76 mState.blend.blendEquationAlpha = GL_FUNC_ADD;
77 mState.blend.sampleAlphaToCoverage = false;
78 mState.blend.dither = true;
79
80 mState.blendColor.red = 0;
81 mState.blendColor.green = 0;
82 mState.blendColor.blue = 0;
83 mState.blendColor.alpha = 0;
84
85 mState.depthStencil.depthTest = false;
86 mState.depthStencil.depthFunc = GL_LESS;
87 mState.depthStencil.depthMask = true;
88 mState.depthStencil.stencilTest = false;
89 mState.depthStencil.stencilFunc = GL_ALWAYS;
90 mState.depthStencil.stencilMask = -1;
91 mState.depthStencil.stencilWritemask = -1;
92 mState.depthStencil.stencilBackFunc = GL_ALWAYS;
93 mState.depthStencil.stencilBackMask = - 1;
94 mState.depthStencil.stencilBackWritemask = -1;
95 mState.depthStencil.stencilFail = GL_KEEP;
96 mState.depthStencil.stencilPassDepthFail = GL_KEEP;
97 mState.depthStencil.stencilPassDepthPass = GL_KEEP;
98 mState.depthStencil.stencilBackFail = GL_KEEP;
99 mState.depthStencil.stencilBackPassDepthFail = GL_KEEP;
100 mState.depthStencil.stencilBackPassDepthPass = GL_KEEP;
101
102 mState.stencilRef = 0;
103 mState.stencilBackRef = 0;
104
105 mState.sampleCoverage = false;
106 mState.sampleCoverageValue = 1.0f;
107 mState.sampleCoverageInvert = false;
108 mState.generateMipmapHint = GL_DONT_CARE;
109 mState.fragmentShaderDerivativeHint = GL_DONT_CARE;
110
111 mState.lineWidth = 1.0f;
112
113 mState.viewport.x = 0;
114 mState.viewport.y = 0;
115 mState.viewport.width = 0;
116 mState.viewport.height = 0;
117 mState.zNear = 0.0f;
118 mState.zFar = 1.0f;
119
120 mState.blend.colorMaskRed = true;
121 mState.blend.colorMaskGreen = true;
122 mState.blend.colorMaskBlue = true;
123 mState.blend.colorMaskAlpha = true;
124
125 if (shareContext != NULL)
126 {
127 mResourceManager = shareContext->mResourceManager;
128 mResourceManager->addRef();
129 }
130 else
131 {
132 mResourceManager = new ResourceManager(mRenderer);
133 }
134
135 // [OpenGL ES 2.0.24] section 3.7 page 83:
136 // In the initial state, TEXTURE_2D and TEXTURE_CUBE_MAP have twodimensional
137 // and cube map texture state vectors respectively associated with them.
138 // In order that access to these initial textures not be lost, they are treated as texture
139 // objects all of whose names are 0.
140
141 mTexture2DZero.set(new Texture2D(mRenderer, 0));
142 mTextureCubeMapZero.set(new TextureCubeMap(mRenderer, 0));
143
144 mState.activeSampler = 0;
145 bindArrayBuffer(0);
146 bindElementArrayBuffer(0);
147 bindTextureCubeMap(0);
148 bindTexture2D(0);
149 bindReadFramebuffer(0);
150 bindDrawFramebuffer(0);
151 bindRenderbuffer(0);
152
153 mState.currentProgram = 0;
154 mCurrentProgramBinary.set(NULL);
155
156 mState.packAlignment = 4;
157 mState.unpackAlignment = 4;
158 mState.packReverseRowOrder = false;
159
160 mExtensionString = NULL;
161 mRendererString = NULL;
162
163 mInvalidEnum = false;
164 mInvalidValue = false;
165 mInvalidOperation = false;
166 mOutOfMemory = false;
167 mInvalidFramebufferOperation = false;
168
169 mHasBeenCurrent = false;
170 mContextLost = false;
171 mResetStatus = GL_NO_ERROR;
172 mResetStrategy = (notifyResets ? GL_LOSE_CONTEXT_ON_RESET_EXT : GL_NO_RESET_NOTIFICATION_EXT);
173 mRobustAccess = robustAccess;
174
175 mSupportsBGRATextures = false;
176 mSupportsDXT1Textures = false;
177 mSupportsDXT3Textures = false;
178 mSupportsDXT5Textures = false;
179 mSupportsEventQueries = false;
180 mSupportsOcclusionQueries = false;
181 mNumCompressedTextureFormats = 0;
182 }
183
184 Context::~Context()
185 {
186 if (mState.currentProgram != 0)
187 {
188 Program *programObject = mResourceManager->getProgram(mState.currentProgram);
189 if (programObject)
190 {
191 programObject->release();
192 }
193 mState.currentProgram = 0;
194 }
195 mCurrentProgramBinary.set(NULL);
196
197 while (!mFramebufferMap.empty())
198 {
199 deleteFramebuffer(mFramebufferMap.begin()->first);
200 }
201
202 while (!mFenceMap.empty())
203 {
204 deleteFence(mFenceMap.begin()->first);
205 }
206
207 while (!mQueryMap.empty())
208 {
209 deleteQuery(mQueryMap.begin()->first);
210 }
211
212 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++)
213 {
214 for (int sampler = 0; sampler < IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++)
215 {
216 mState.samplerTexture[type][sampler].set(NULL);
217 }
218 }
219
220 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++)
221 {
222 mIncompleteTextures[type].set(NULL);
223 }
224
225 for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
226 {
227 mState.vertexAttribute[i].mBoundBuffer.set(NULL);
228 }
229
230 for (int i = 0; i < QUERY_TYPE_COUNT; i++)
231 {
232 mState.activeQuery[i].set(NULL);
233 }
234
235 mState.arrayBuffer.set(NULL);
236 mState.elementArrayBuffer.set(NULL);
237 mState.renderbuffer.set(NULL);
238
239 mTexture2DZero.set(NULL);
240 mTextureCubeMapZero.set(NULL);
241
242 mResourceManager->release();
243 }
244
245 void Context::makeCurrent(egl::Surface *surface)
246 {
247 if (!mHasBeenCurrent)
248 {
249 mMajorShaderModel = mRenderer->getMajorShaderModel();
250 mMaximumPointSize = mRenderer->getMaxPointSize();
251 mSupportsVertexTexture = mRenderer->getVertexTextureSupport();
252 mSupportsNonPower2Texture = mRenderer->getNonPower2TextureSupport();
253 mSupportsInstancing = mRenderer->getInstancingSupport();
254
255 mMaxViewportDimension = mRenderer->getMaxViewportDimension();
256 mMaxTextureDimension = std::min(std::min(mRenderer->getMaxTextureWidth(), mRenderer->getMaxTextureHeight()),
257 (int)gl::IMPLEMENTATION_MAX_TEXTURE_SIZE);
258 mMaxCubeTextureDimension = std::min(mMaxTextureDimension, (int)gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE);
259 mMaxRenderbufferDimension = mMaxTextureDimension;
260 mMaxTextureLevel = log2(mMaxTextureDimension) + 1;
261 mMaxTextureAnisotropy = mRenderer->getTextureMaxAnisotropy();
262 TRACE("MaxTextureDimension=%d, MaxCubeTextureDimension=%d, MaxRenderbufferDimension=%d, MaxTextureLevel=%d, MaxTextureAnisotropy=%f",
263 mMaxTextureDimension, mMaxCubeTextureDimension, mMaxRenderbufferDimension, mMaxTextureLevel, mMaxTextureAnisotropy);
264
265 mSupportsEventQueries = mRenderer->getEventQuerySupport();
266 mSupportsOcclusionQueries = mRenderer->getOcclusionQuerySupport();
267 mSupportsBGRATextures = mRenderer->getBGRATextureSupport();
268 mSupportsDXT1Textures = mRenderer->getDXT1TextureSupport();
269 mSupportsDXT3Textures = mRenderer->getDXT3TextureSupport();
270 mSupportsDXT5Textures = mRenderer->getDXT5TextureSupport();
271 mSupportsFloat32Textures = mRenderer->getFloat32TextureSupport(&mSupportsFloat32LinearFilter, &mSupportsFloat32RenderableTextures);
272 mSupportsFloat16Textures = mRenderer->getFloat16TextureSupport(&mSupportsFloat16LinearFilter, &mSupportsFloat16RenderableTextures);
273 mSupportsLuminanceTextures = mRenderer->getLuminanceTextureSupport();
274 mSupportsLuminanceAlphaTextures = mRenderer->getLuminanceAlphaTextureSupport();
275 mSupportsDepthTextures = mRenderer->getDepthTextureSupport();
276 mSupportsTextureFilterAnisotropy = mRenderer->getTextureFilterAnisotropySupport();
277 mSupports32bitIndices = mRenderer->get32BitIndexSupport();
278
279 mNumCompressedTextureFormats = 0;
280 if (supportsDXT1Textures())
281 {
282 mNumCompressedTextureFormats += 2;
283 }
284 if (supportsDXT3Textures())
285 {
286 mNumCompressedTextureFormats += 1;
287 }
288 if (supportsDXT5Textures())
289 {
290 mNumCompressedTextureFormats += 1;
291 }
292
293 initExtensionString();
294 initRendererString();
295
296 mState.viewport.x = 0;
297 mState.viewport.y = 0;
298 mState.viewport.width = surface->getWidth();
299 mState.viewport.height = surface->getHeight();
300
301 mState.scissor.x = 0;
302 mState.scissor.y = 0;
303 mState.scissor.width = surface->getWidth();
304 mState.scissor.height = surface->getHeight();
305
306 mHasBeenCurrent = true;
307 }
308
309 // Wrap the existing swapchain resources into GL objects and assign them to the '0' names
310 rx::SwapChain *swapchain = surface->getSwapChain();
311
312 Colorbuffer *colorbufferZero = new Colorbuffer(mRenderer, swapchain);
313 DepthStencilbuffer *depthStencilbufferZero = new DepthStencilbuffer(mRenderer, swapchain);
314 Framebuffer *framebufferZero = new DefaultFramebuffer(mRenderer, colorbufferZero, depthStencilbufferZero);
315
316 setFramebufferZero(framebufferZero);
317 }
318
319 // NOTE: this function should not assume that this context is current!
320 void Context::markContextLost()
321 {
322 if (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT)
323 mResetStatus = GL_UNKNOWN_CONTEXT_RESET_EXT;
324 mContextLost = true;
325 }
326
327 bool Context::isContextLost()
328 {
329 return mContextLost;
330 }
331
332 void Context::setClearColor(float red, float green, float blue, float alpha)
333 {
334 mState.colorClearValue.red = red;
335 mState.colorClearValue.green = green;
336 mState.colorClearValue.blue = blue;
337 mState.colorClearValue.alpha = alpha;
338 }
339
340 void Context::setClearDepth(float depth)
341 {
342 mState.depthClearValue = depth;
343 }
344
345 void Context::setClearStencil(int stencil)
346 {
347 mState.stencilClearValue = stencil;
348 }
349
350 void Context::setCullFace(bool enabled)
351 {
352 mState.rasterizer.cullFace = enabled;
353 }
354
355 bool Context::isCullFaceEnabled() const
356 {
357 return mState.rasterizer.cullFace;
358 }
359
360 void Context::setCullMode(GLenum mode)
361 {
362 mState.rasterizer.cullMode = mode;
363 }
364
365 void Context::setFrontFace(GLenum front)
366 {
367 mState.rasterizer.frontFace = front;
368 }
369
370 void Context::setDepthTest(bool enabled)
371 {
372 mState.depthStencil.depthTest = enabled;
373 }
374
375 bool Context::isDepthTestEnabled() const
376 {
377 return mState.depthStencil.depthTest;
378 }
379
380 void Context::setDepthFunc(GLenum depthFunc)
381 {
382 mState.depthStencil.depthFunc = depthFunc;
383 }
384
385 void Context::setDepthRange(float zNear, float zFar)
386 {
387 mState.zNear = zNear;
388 mState.zFar = zFar;
389 }
390
391 void Context::setBlend(bool enabled)
392 {
393 mState.blend.blend = enabled;
394 }
395
396 bool Context::isBlendEnabled() const
397 {
398 return mState.blend.blend;
399 }
400
401 void Context::setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha)
402 {
403 mState.blend.sourceBlendRGB = sourceRGB;
404 mState.blend.destBlendRGB = destRGB;
405 mState.blend.sourceBlendAlpha = sourceAlpha;
406 mState.blend.destBlendAlpha = destAlpha;
407 }
408
409 void Context::setBlendColor(float red, float green, float blue, float alpha)
410 {
411 mState.blendColor.red = red;
412 mState.blendColor.green = green;
413 mState.blendColor.blue = blue;
414 mState.blendColor.alpha = alpha;
415 }
416
417 void Context::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
418 {
419 mState.blend.blendEquationRGB = rgbEquation;
420 mState.blend.blendEquationAlpha = alphaEquation;
421 }
422
423 void Context::setStencilTest(bool enabled)
424 {
425 mState.depthStencil.stencilTest = enabled;
426 }
427
428 bool Context::isStencilTestEnabled() const
429 {
430 return mState.depthStencil.stencilTest;
431 }
432
433 void Context::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask)
434 {
435 mState.depthStencil.stencilFunc = stencilFunc;
436 mState.stencilRef = (stencilRef > 0) ? stencilRef : 0;
437 mState.depthStencil.stencilMask = stencilMask;
438 }
439
440 void Context::setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask)
441 {
442 mState.depthStencil.stencilBackFunc = stencilBackFunc;
443 mState.stencilBackRef = (stencilBackRef > 0) ? stencilBackRef : 0;
444 mState.depthStencil.stencilBackMask = stencilBackMask;
445 }
446
447 void Context::setStencilWritemask(GLuint stencilWritemask)
448 {
449 mState.depthStencil.stencilWritemask = stencilWritemask;
450 }
451
452 void Context::setStencilBackWritemask(GLuint stencilBackWritemask)
453 {
454 mState.depthStencil.stencilBackWritemask = stencilBackWritemask;
455 }
456
457 void Context::setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass)
458 {
459 mState.depthStencil.stencilFail = stencilFail;
460 mState.depthStencil.stencilPassDepthFail = stencilPassDepthFail;
461 mState.depthStencil.stencilPassDepthPass = stencilPassDepthPass;
462 }
463
464 void Context::setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass)
465 {
466 mState.depthStencil.stencilBackFail = stencilBackFail;
467 mState.depthStencil.stencilBackPassDepthFail = stencilBackPassDepthFail;
468 mState.depthStencil.stencilBackPassDepthPass = stencilBackPassDepthPass;
469 }
470
471 void Context::setPolygonOffsetFill(bool enabled)
472 {
473 mState.rasterizer.polygonOffsetFill = enabled;
474 }
475
476 bool Context::isPolygonOffsetFillEnabled() const
477 {
478 return mState.rasterizer.polygonOffsetFill;
479 }
480
481 void Context::setPolygonOffsetParams(GLfloat factor, GLfloat units)
482 {
483 // An application can pass NaN values here, so handle this gracefully
484 mState.rasterizer.polygonOffsetFactor = factor != factor ? 0.0f : factor;
485 mState.rasterizer.polygonOffsetUnits = units != units ? 0.0f : units;
486 }
487
488 void Context::setSampleAlphaToCoverage(bool enabled)
489 {
490 mState.blend.sampleAlphaToCoverage = enabled;
491 }
492
493 bool Context::isSampleAlphaToCoverageEnabled() const
494 {
495 return mState.blend.sampleAlphaToCoverage;
496 }
497
498 void Context::setSampleCoverage(bool enabled)
499 {
500 mState.sampleCoverage = enabled;
501 }
502
503 bool Context::isSampleCoverageEnabled() const
504 {
505 return mState.sampleCoverage;
506 }
507
508 void Context::setSampleCoverageParams(GLclampf value, bool invert)
509 {
510 mState.sampleCoverageValue = value;
511 mState.sampleCoverageInvert = invert;
512 }
513
514 void Context::setScissorTest(bool enabled)
515 {
516 mState.scissorTest = enabled;
517 }
518
519 bool Context::isScissorTestEnabled() const
520 {
521 return mState.scissorTest;
522 }
523
524 void Context::setDither(bool enabled)
525 {
526 mState.blend.dither = enabled;
527 }
528
529 bool Context::isDitherEnabled() const
530 {
531 return mState.blend.dither;
532 }
533
534 void Context::setLineWidth(GLfloat width)
535 {
536 mState.lineWidth = width;
537 }
538
539 void Context::setGenerateMipmapHint(GLenum hint)
540 {
541 mState.generateMipmapHint = hint;
542 }
543
544 void Context::setFragmentShaderDerivativeHint(GLenum hint)
545 {
546 mState.fragmentShaderDerivativeHint = hint;
547 // TODO: Propagate the hint to shader translator so we can write
548 // ddx, ddx_coarse, or ddx_fine depending on the hint.
549 // Ignore for now. It is valid for implementations to ignore hint.
550 }
551
552 void Context::setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height)
553 {
554 mState.viewport.x = x;
555 mState.viewport.y = y;
556 mState.viewport.width = width;
557 mState.viewport.height = height;
558 }
559
560 void Context::setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height)
561 {
562 mState.scissor.x = x;
563 mState.scissor.y = y;
564 mState.scissor.width = width;
565 mState.scissor.height = height;
566 }
567
568 void Context::setColorMask(bool red, bool green, bool blue, bool alpha)
569 {
570 mState.blend.colorMaskRed = red;
571 mState.blend.colorMaskGreen = green;
572 mState.blend.colorMaskBlue = blue;
573 mState.blend.colorMaskAlpha = alpha;
574 }
575
576 void Context::setDepthMask(bool mask)
577 {
578 mState.depthStencil.depthMask = mask;
579 }
580
581 void Context::setActiveSampler(unsigned int active)
582 {
583 mState.activeSampler = active;
584 }
585
586 GLuint Context::getReadFramebufferHandle() const
587 {
588 return mState.readFramebuffer;
589 }
590
591 GLuint Context::getDrawFramebufferHandle() const
592 {
593 return mState.drawFramebuffer;
594 }
595
596 GLuint Context::getRenderbufferHandle() const
597 {
598 return mState.renderbuffer.id();
599 }
600
601 GLuint Context::getArrayBufferHandle() const
602 {
603 return mState.arrayBuffer.id();
604 }
605
606 GLuint Context::getActiveQuery(GLenum target) const
607 {
608 Query *queryObject = NULL;
609
610 switch (target)
611 {
612 case GL_ANY_SAMPLES_PASSED_EXT:
613 queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED].get();
614 break;
615 case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
616 queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE].get();
617 break;
618 default:
619 ASSERT(false);
620 }
621
622 if (queryObject)
623 {
624 return queryObject->id();
625 }
626 else
627 {
628 return 0;
629 }
630 }
631
632 void Context::setEnableVertexAttribArray(unsigned int attribNum, bool enabled)
633 {
634 mState.vertexAttribute[attribNum].mArrayEnabled = enabled;
635 }
636
637 const VertexAttribute &Context::getVertexAttribState(unsigned int attribNum)
638 {
639 return mState.vertexAttribute[attribNum];
640 }
641
642 void Context::setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type, bool normalized,
643 GLsizei stride, const void *pointer)
644 {
645 mState.vertexAttribute[attribNum].mBoundBuffer.set(boundBuffer);
646 mState.vertexAttribute[attribNum].mSize = size;
647 mState.vertexAttribute[attribNum].mType = type;
648 mState.vertexAttribute[attribNum].mNormalized = normalized;
649 mState.vertexAttribute[attribNum].mStride = stride;
650 mState.vertexAttribute[attribNum].mPointer = pointer;
651 }
652
653 const void *Context::getVertexAttribPointer(unsigned int attribNum) const
654 {
655 return mState.vertexAttribute[attribNum].mPointer;
656 }
657
658 void Context::setPackAlignment(GLint alignment)
659 {
660 mState.packAlignment = alignment;
661 }
662
663 GLint Context::getPackAlignment() const
664 {
665 return mState.packAlignment;
666 }
667
668 void Context::setUnpackAlignment(GLint alignment)
669 {
670 mState.unpackAlignment = alignment;
671 }
672
673 GLint Context::getUnpackAlignment() const
674 {
675 return mState.unpackAlignment;
676 }
677
678 void Context::setPackReverseRowOrder(bool reverseRowOrder)
679 {
680 mState.packReverseRowOrder = reverseRowOrder;
681 }
682
683 bool Context::getPackReverseRowOrder() const
684 {
685 return mState.packReverseRowOrder;
686 }
687
688 GLuint Context::createBuffer()
689 {
690 return mResourceManager->createBuffer();
691 }
692
693 GLuint Context::createProgram()
694 {
695 return mResourceManager->createProgram();
696 }
697
698 GLuint Context::createShader(GLenum type)
699 {
700 return mResourceManager->createShader(type);
701 }
702
703 GLuint Context::createTexture()
704 {
705 return mResourceManager->createTexture();
706 }
707
708 GLuint Context::createRenderbuffer()
709 {
710 return mResourceManager->createRenderbuffer();
711 }
712
713 // Returns an unused framebuffer name
714 GLuint Context::createFramebuffer()
715 {
716 GLuint handle = mFramebufferHandleAllocator.allocate();
717
718 mFramebufferMap[handle] = NULL;
719
720 return handle;
721 }
722
723 GLuint Context::createFence()
724 {
725 GLuint handle = mFenceHandleAllocator.allocate();
726
727 mFenceMap[handle] = new Fence(mRenderer);
728
729 return handle;
730 }
731
732 // Returns an unused query name
733 GLuint Context::createQuery()
734 {
735 GLuint handle = mQueryHandleAllocator.allocate();
736
737 mQueryMap[handle] = NULL;
738
739 return handle;
740 }
741
742 void Context::deleteBuffer(GLuint buffer)
743 {
744 if (mResourceManager->getBuffer(buffer))
745 {
746 detachBuffer(buffer);
747 }
748
749 mResourceManager->deleteBuffer(buffer);
750 }
751
752 void Context::deleteShader(GLuint shader)
753 {
754 mResourceManager->deleteShader(shader);
755 }
756
757 void Context::deleteProgram(GLuint program)
758 {
759 mResourceManager->deleteProgram(program);
760 }
761
762 void Context::deleteTexture(GLuint texture)
763 {
764 if (mResourceManager->getTexture(texture))
765 {
766 detachTexture(texture);
767 }
768
769 mResourceManager->deleteTexture(texture);
770 }
771
772 void Context::deleteRenderbuffer(GLuint renderbuffer)
773 {
774 if (mResourceManager->getRenderbuffer(renderbuffer))
775 {
776 detachRenderbuffer(renderbuffer);
777 }
778
779 mResourceManager->deleteRenderbuffer(renderbuffer);
780 }
781
782 void Context::deleteFramebuffer(GLuint framebuffer)
783 {
784 FramebufferMap::iterator framebufferObject = mFramebufferMap.find(framebuffer);
785
786 if (framebufferObject != mFramebufferMap.end())
787 {
788 detachFramebuffer(framebuffer);
789
790 mFramebufferHandleAllocator.release(framebufferObject->first);
791 delete framebufferObject->second;
792 mFramebufferMap.erase(framebufferObject);
793 }
794 }
795
796 void Context::deleteFence(GLuint fence)
797 {
798 FenceMap::iterator fenceObject = mFenceMap.find(fence);
799
800 if (fenceObject != mFenceMap.end())
801 {
802 mFenceHandleAllocator.release(fenceObject->first);
803 delete fenceObject->second;
804 mFenceMap.erase(fenceObject);
805 }
806 }
807
808 void Context::deleteQuery(GLuint query)
809 {
810 QueryMap::iterator queryObject = mQueryMap.find(query);
811 if (queryObject != mQueryMap.end())
812 {
813 mQueryHandleAllocator.release(queryObject->first);
814 if (queryObject->second)
815 {
816 queryObject->second->release();
817 }
818 mQueryMap.erase(queryObject);
819 }
820 }
821
822 Buffer *Context::getBuffer(GLuint handle)
823 {
824 return mResourceManager->getBuffer(handle);
825 }
826
827 Shader *Context::getShader(GLuint handle)
828 {
829 return mResourceManager->getShader(handle);
830 }
831
832 Program *Context::getProgram(GLuint handle)
833 {
834 return mResourceManager->getProgram(handle);
835 }
836
837 Texture *Context::getTexture(GLuint handle)
838 {
839 return mResourceManager->getTexture(handle);
840 }
841
842 Renderbuffer *Context::getRenderbuffer(GLuint handle)
843 {
844 return mResourceManager->getRenderbuffer(handle);
845 }
846
847 Framebuffer *Context::getReadFramebuffer()
848 {
849 return getFramebuffer(mState.readFramebuffer);
850 }
851
852 Framebuffer *Context::getDrawFramebuffer()
853 {
854 return mBoundDrawFramebuffer;
855 }
856
857 void Context::bindArrayBuffer(unsigned int buffer)
858 {
859 mResourceManager->checkBufferAllocation(buffer);
860
861 mState.arrayBuffer.set(getBuffer(buffer));
862 }
863
864 void Context::bindElementArrayBuffer(unsigned int buffer)
865 {
866 mResourceManager->checkBufferAllocation(buffer);
867
868 mState.elementArrayBuffer.set(getBuffer(buffer));
869 }
870
871 void Context::bindTexture2D(GLuint texture)
872 {
873 mResourceManager->checkTextureAllocation(texture, TEXTURE_2D);
874
875 mState.samplerTexture[TEXTURE_2D][mState.activeSampler].set(getTexture(texture));
876 }
877
878 void Context::bindTextureCubeMap(GLuint texture)
879 {
880 mResourceManager->checkTextureAllocation(texture, TEXTURE_CUBE);
881
882 mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].set(getTexture(texture));
883 }
884
885 void Context::bindReadFramebuffer(GLuint framebuffer)
886 {
887 if (!getFramebuffer(framebuffer))
888 {
889 mFramebufferMap[framebuffer] = new Framebuffer(mRenderer);
890 }
891
892 mState.readFramebuffer = framebuffer;
893 }
894
895 void Context::bindDrawFramebuffer(GLuint framebuffer)
896 {
897 if (!getFramebuffer(framebuffer))
898 {
899 mFramebufferMap[framebuffer] = new Framebuffer(mRenderer);
900 }
901
902 mState.drawFramebuffer = framebuffer;
903
904 mBoundDrawFramebuffer = getFramebuffer(framebuffer);
905 }
906
907 void Context::bindRenderbuffer(GLuint renderbuffer)
908 {
909 mResourceManager->checkRenderbufferAllocation(renderbuffer);
910
911 mState.renderbuffer.set(getRenderbuffer(renderbuffer));
912 }
913
914 void Context::useProgram(GLuint program)
915 {
916 GLuint priorProgram = mState.currentProgram;
917 mState.currentProgram = program; // Must switch before trying to delete, otherwise it only gets flagged.
918
919 if (priorProgram != program)
920 {
921 Program *newProgram = mResourceManager->getProgram(program);
922 Program *oldProgram = mResourceManager->getProgram(priorProgram);
923 mCurrentProgramBinary.set(NULL);
924
925 if (newProgram)
926 {
927 newProgram->addRef();
928 mCurrentProgramBinary.set(newProgram->getProgramBinary());
929 }
930
931 if (oldProgram)
932 {
933 oldProgram->release();
934 }
935 }
936 }
937
938 void Context::linkProgram(GLuint program)
939 {
940 Program *programObject = mResourceManager->getProgram(program);
941
942 bool linked = programObject->link();
943
944 // if the current program was relinked successfully we
945 // need to install the new executables
946 if (linked && program == mState.currentProgram)
947 {
948 mCurrentProgramBinary.set(programObject->getProgramBinary());
949 }
950 }
951
952 void Context::setProgramBinary(GLuint program, const void *binary, GLint length)
953 {
954 Program *programObject = mResourceManager->getProgram(program);
955
956 bool loaded = programObject->setProgramBinary(binary, length);
957
958 // if the current program was reloaded successfully we
959 // need to install the new executables
960 if (loaded && program == mState.currentProgram)
961 {
962 mCurrentProgramBinary.set(programObject->getProgramBinary());
963 }
964
965 }
966
967 void Context::beginQuery(GLenum target, GLuint query)
968 {
969 // From EXT_occlusion_query_boolean: If BeginQueryEXT is called with an <id>
970 // of zero, if the active query object name for <target> is non-zero (for the
971 // targets ANY_SAMPLES_PASSED_EXT and ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, if
972 // the active query for either target is non-zero), if <id> is the name of an
973 // existing query object whose type does not match <target>, or if <id> is the
974 // active query object name for any query type, the error INVALID_OPERATION is
975 // generated.
976
977 // Ensure no other queries are active
978 // NOTE: If other queries than occlusion are supported, we will need to check
979 // separately that:
980 // a) The query ID passed is not the current active query for any target/type
981 // b) There are no active queries for the requested target (and in the case
982 // of GL_ANY_SAMPLES_PASSED_EXT and GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
983 // no query may be active for either if glBeginQuery targets either.
984 for (int i = 0; i < QUERY_TYPE_COUNT; i++)
985 {
986 if (mState.activeQuery[i].get() != NULL)
987 {
988 return gl::error(GL_INVALID_OPERATION);
989 }
990 }
991
992 QueryType qType;
993 switch (target)
994 {
995 case GL_ANY_SAMPLES_PASSED_EXT:
996 qType = QUERY_ANY_SAMPLES_PASSED;
997 break;
998 case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
999 qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE;
1000 break;
1001 default:
1002 ASSERT(false);
1003 return;
1004 }
1005
1006 Query *queryObject = getQuery(query, true, target);
1007
1008 // check that name was obtained with glGenQueries
1009 if (!queryObject)
1010 {
1011 return gl::error(GL_INVALID_OPERATION);
1012 }
1013
1014 // check for type mismatch
1015 if (queryObject->getType() != target)
1016 {
1017 return gl::error(GL_INVALID_OPERATION);
1018 }
1019
1020 // set query as active for specified target
1021 mState.activeQuery[qType].set(queryObject);
1022
1023 // begin query
1024 queryObject->begin();
1025 }
1026
1027 void Context::endQuery(GLenum target)
1028 {
1029 QueryType qType;
1030
1031 switch (target)
1032 {
1033 case GL_ANY_SAMPLES_PASSED_EXT:
1034 qType = QUERY_ANY_SAMPLES_PASSED;
1035 break;
1036 case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
1037 qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE;
1038 break;
1039 default:
1040 ASSERT(false);
1041 return;
1042 }
1043
1044 Query *queryObject = mState.activeQuery[qType].get();
1045
1046 if (queryObject == NULL)
1047 {
1048 return gl::error(GL_INVALID_OPERATION);
1049 }
1050
1051 queryObject->end();
1052
1053 mState.activeQuery[qType].set(NULL);
1054 }
1055
1056 void Context::setFramebufferZero(Framebuffer *buffer)
1057 {
1058 delete mFramebufferMap[0];
1059 mFramebufferMap[0] = buffer;
1060 if (mState.drawFramebuffer == 0)
1061 {
1062 mBoundDrawFramebuffer = buffer;
1063 }
1064 }
1065
1066 void Context::setRenderbufferStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples)
1067 {
1068 RenderbufferStorage *renderbuffer = NULL;
1069 switch (internalformat)
1070 {
1071 case GL_DEPTH_COMPONENT16:
1072 renderbuffer = new gl::Depthbuffer(mRenderer, width, height, samples);
1073 break;
1074 case GL_RGBA4:
1075 case GL_RGB5_A1:
1076 case GL_RGB565:
1077 case GL_RGB8_OES:
1078 case GL_RGBA8_OES:
1079 renderbuffer = new gl::Colorbuffer(mRenderer,width, height, internalformat, samples);
1080 break;
1081 case GL_STENCIL_INDEX8:
1082 renderbuffer = new gl::Stencilbuffer(mRenderer, width, height, samples);
1083 break;
1084 case GL_DEPTH24_STENCIL8_OES:
1085 renderbuffer = new gl::DepthStencilbuffer(mRenderer, width, height, samples);
1086 break;
1087 default:
1088 UNREACHABLE(); return;
1089 }
1090
1091 Renderbuffer *renderbufferObject = mState.renderbuffer.get();
1092 renderbufferObject->setStorage(renderbuffer);
1093 }
1094
1095 Framebuffer *Context::getFramebuffer(unsigned int handle)
1096 {
1097 FramebufferMap::iterator framebuffer = mFramebufferMap.find(handle);
1098
1099 if (framebuffer == mFramebufferMap.end())
1100 {
1101 return NULL;
1102 }
1103 else
1104 {
1105 return framebuffer->second;
1106 }
1107 }
1108
1109 Fence *Context::getFence(unsigned int handle)
1110 {
1111 FenceMap::iterator fence = mFenceMap.find(handle);
1112
1113 if (fence == mFenceMap.end())
1114 {
1115 return NULL;
1116 }
1117 else
1118 {
1119 return fence->second;
1120 }
1121 }
1122
1123 Query *Context::getQuery(unsigned int handle, bool create, GLenum type)
1124 {
1125 QueryMap::iterator query = mQueryMap.find(handle);
1126
1127 if (query == mQueryMap.end())
1128 {
1129 return NULL;
1130 }
1131 else
1132 {
1133 if (!query->second && create)
1134 {
1135 query->second = new Query(mRenderer, type, handle);
1136 query->second->addRef();
1137 }
1138 return query->second;
1139 }
1140 }
1141
1142 Buffer *Context::getArrayBuffer()
1143 {
1144 return mState.arrayBuffer.get();
1145 }
1146
1147 Buffer *Context::getElementArrayBuffer()
1148 {
1149 return mState.elementArrayBuffer.get();
1150 }
1151
1152 ProgramBinary *Context::getCurrentProgramBinary()
1153 {
1154 return mCurrentProgramBinary.get();
1155 }
1156
1157 Texture2D *Context::getTexture2D()
1158 {
1159 return static_cast<Texture2D*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D));
1160 }
1161
1162 TextureCubeMap *Context::getTextureCubeMap()
1163 {
1164 return static_cast<TextureCubeMap*>(getSamplerTexture(mState.activeSampler, TEXTURE_CUBE));
1165 }
1166
1167 Texture *Context::getSamplerTexture(unsigned int sampler, TextureType type)
1168 {
1169 GLuint texid = mState.samplerTexture[type][sampler].id();
1170
1171 if (texid == 0) // Special case: 0 refers to different initial textures based on the target
1172 {
1173 switch (type)
1174 {
1175 default: UNREACHABLE();
1176 case TEXTURE_2D: return mTexture2DZero.get();
1177 case TEXTURE_CUBE: return mTextureCubeMapZero.get();
1178 }
1179 }
1180
1181 return mState.samplerTexture[type][sampler].get();
1182 }
1183
1184 bool Context::getBooleanv(GLenum pname, GLboolean *params)
1185 {
1186 switch (pname)
1187 {
1188 case GL_SHADER_COMPILER: *params = GL_TRUE; break;
1189 case GL_SAMPLE_COVERAGE_INVERT: *params = mState.sampleCoverageInvert; break;
1190 case GL_DEPTH_WRITEMASK: *params = mState.depthStencil.depthMask; break;
1191 case GL_COLOR_WRITEMASK:
1192 params[0] = mState.blend.colorMaskRed;
1193 params[1] = mState.blend.colorMaskGreen;
1194 params[2] = mState.blend.colorMaskBlue;
1195 params[3] = mState.blend.colorMaskAlpha;
1196 break;
1197 case GL_CULL_FACE: *params = mState.rasterizer.cullFace; break;
1198 case GL_POLYGON_OFFSET_FILL: *params = mState.rasterizer.polygonOffsetFill; break;
1199 case GL_SAMPLE_ALPHA_TO_COVERAGE: *params = mState.blend.sampleAlphaToCoverage; break;
1200 case GL_SAMPLE_COVERAGE: *params = mState.sampleCoverage; break;
1201 case GL_SCISSOR_TEST: *params = mState.scissorTest; break;
1202 case GL_STENCIL_TEST: *params = mState.depthStencil.stencilTest; break;
1203 case GL_DEPTH_TEST: *params = mState.depthStencil.depthTest; break;
1204 case GL_BLEND: *params = mState.blend.blend; break;
1205 case GL_DITHER: *params = mState.blend.dither; break;
1206 case GL_CONTEXT_ROBUST_ACCESS_EXT: *params = mRobustAccess ? GL_TRUE : GL_FALSE; break;
1207 default:
1208 return false;
1209 }
1210
1211 return true;
1212 }
1213
1214 bool Context::getFloatv(GLenum pname, GLfloat *params)
1215 {
1216 // Please note: DEPTH_CLEAR_VALUE is included in our internal getFloatv implementation
1217 // because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1218 // GetIntegerv as its native query function. As it would require conversion in any
1219 // case, this should make no difference to the calling application.
1220 switch (pname)
1221 {
1222 case GL_LINE_WIDTH: *params = mState.lineWidth; break;
1223 case GL_SAMPLE_COVERAGE_VALUE: *params = mState.sampleCoverageValue; break;
1224 case GL_DEPTH_CLEAR_VALUE: *params = mState.depthClearValue; break;
1225 case GL_POLYGON_OFFSET_FACTOR: *params = mState.rasterizer.polygonOffsetFactor; break;
1226 case GL_POLYGON_OFFSET_UNITS: *params = mState.rasterizer.polygonOffsetUnits; break;
1227 case GL_ALIASED_LINE_WIDTH_RANGE:
1228 params[0] = gl::ALIASED_LINE_WIDTH_RANGE_MIN;
1229 params[1] = gl::ALIASED_LINE_WIDTH_RANGE_MAX;
1230 break;
1231 case GL_ALIASED_POINT_SIZE_RANGE:
1232 params[0] = gl::ALIASED_POINT_SIZE_RANGE_MIN;
1233 params[1] = getMaximumPointSize();
1234 break;
1235 case GL_DEPTH_RANGE:
1236 params[0] = mState.zNear;
1237 params[1] = mState.zFar;
1238 break;
1239 case GL_COLOR_CLEAR_VALUE:
1240 params[0] = mState.colorClearValue.red;
1241 params[1] = mState.colorClearValue.green;
1242 params[2] = mState.colorClearValue.blue;
1243 params[3] = mState.colorClearValue.alpha;
1244 break;
1245 case GL_BLEND_COLOR:
1246 params[0] = mState.blendColor.red;
1247 params[1] = mState.blendColor.green;
1248 params[2] = mState.blendColor.blue;
1249 params[3] = mState.blendColor.alpha;
1250 break;
1251 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
1252 if (!supportsTextureFilterAnisotropy())
1253 {
1254 return false;
1255 }
1256 *params = mMaxTextureAnisotropy;
1257 break;
1258 default:
1259 return false;
1260 }
1261
1262 return true;
1263 }
1264
1265 bool Context::getIntegerv(GLenum pname, GLint *params)
1266 {
1267 if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT)
1268 {
1269 unsigned int colorAttachment = (pname - GL_DRAW_BUFFER0_EXT);
1270
1271 if (colorAttachment >= mRenderer->getMaxRenderTargets())
1272 {
1273 // return true to stop further operation in the parent call
1274 return gl::error(GL_INVALID_OPERATION, true);
1275 }
1276
1277 Framebuffer *framebuffer = getDrawFramebuffer();
1278
1279 *params = framebuffer->getDrawBufferState(colorAttachment);
1280 return true;
1281 }
1282
1283 // Please note: DEPTH_CLEAR_VALUE is not included in our internal getIntegerv implementation
1284 // because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1285 // GetIntegerv as its native query function. As it would require conversion in any
1286 // case, this should make no difference to the calling application. You may find it in
1287 // Context::getFloatv.
1288 switch (pname)
1289 {
1290 case GL_MAX_VERTEX_ATTRIBS: *params = gl::MAX_VERTEX_ATTRIBS; break;
1291 case GL_MAX_VERTEX_UNIFORM_VECTORS: *params = mRenderer->getMaxVertexUniformVectors(); break;
1292 case GL_MAX_VARYING_VECTORS: *params = mRenderer->getMaxVaryingVectors(); break;
1293 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: *params = mRenderer->getMaxCombinedTextureImageUnits(); break;
1294 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: *params = mRenderer->getMaxVertexTextureImageUnits(); break;
1295 case GL_MAX_TEXTURE_IMAGE_UNITS: *params = gl::MAX_TEXTURE_IMAGE_UNITS; break;
1296 case GL_MAX_FRAGMENT_UNIFORM_VECTORS: *params = mRenderer->getMaxFragmentUniformVectors(); break;
1297 case GL_MAX_RENDERBUFFER_SIZE: *params = getMaximumRenderbufferDimension(); break;
1298 case GL_MAX_COLOR_ATTACHMENTS_EXT: *params = mRenderer->getMaxRenderTargets(); break;
1299 case GL_MAX_DRAW_BUFFERS_EXT: *params = mRenderer->getMaxRenderTargets(); break;
1300 case GL_NUM_SHADER_BINARY_FORMATS: *params = 0; break;
1301 case GL_SHADER_BINARY_FORMATS: /* no shader binary formats are supported */ break;
1302 case GL_ARRAY_BUFFER_BINDING: *params = mState.arrayBuffer.id(); break;
1303 case GL_ELEMENT_ARRAY_BUFFER_BINDING: *params = mState.elementArrayBuffer.id(); break;
1304 //case GL_FRAMEBUFFER_BINDING: // now equivalent to GL_DRAW_FRAMEBUFFER_BINDING_ANGLE
1305 case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE: *params = mState.drawFramebuffer; break;
1306 case GL_READ_FRAMEBUFFER_BINDING_ANGLE: *params = mState.readFramebuffer; break;
1307 case GL_RENDERBUFFER_BINDING: *params = mState.renderbuffer.id(); break;
1308 case GL_CURRENT_PROGRAM: *params = mState.currentProgram; break;
1309 case GL_PACK_ALIGNMENT: *params = mState.packAlignment; break;
1310 case GL_PACK_REVERSE_ROW_ORDER_ANGLE: *params = mState.packReverseRowOrder; break;
1311 case GL_UNPACK_ALIGNMENT: *params = mState.unpackAlignment; break;
1312 case GL_GENERATE_MIPMAP_HINT: *params = mState.generateMipmapHint; break;
1313 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: *params = mState.fragmentShaderDerivativeHint; break;
1314 case GL_ACTIVE_TEXTURE: *params = (mState.activeSampler + GL_TEXTURE0); break;
1315 case GL_STENCIL_FUNC: *params = mState.depthStencil.stencilFunc; break;
1316 case GL_STENCIL_REF: *params = mState.stencilRef; break;
1317 case GL_STENCIL_VALUE_MASK: *params = mState.depthStencil.stencilMask; break;
1318 case GL_STENCIL_BACK_FUNC: *params = mState.depthStencil.stencilBackFunc; break;
1319 case GL_STENCIL_BACK_REF: *params = mState.stencilBackRef; break;
1320 case GL_STENCIL_BACK_VALUE_MASK: *params = mState.depthStencil.stencilBackMask; break;
1321 case GL_STENCIL_FAIL: *params = mState.depthStencil.stencilFail; break;
1322 case GL_STENCIL_PASS_DEPTH_FAIL: *params = mState.depthStencil.stencilPassDepthFail; break;
1323 case GL_STENCIL_PASS_DEPTH_PASS: *params = mState.depthStencil.stencilPassDepthPass; break;
1324 case GL_STENCIL_BACK_FAIL: *params = mState.depthStencil.stencilBackFail; break;
1325 case GL_STENCIL_BACK_PASS_DEPTH_FAIL: *params = mState.depthStencil.stencilBackPassDepthFail; break;
1326 case GL_STENCIL_BACK_PASS_DEPTH_PASS: *params = mState.depthStencil.stencilBackPassDepthPass; break;
1327 case GL_DEPTH_FUNC: *params = mState.depthStencil.depthFunc; break;
1328 case GL_BLEND_SRC_RGB: *params = mState.blend.sourceBlendRGB; break;
1329 case GL_BLEND_SRC_ALPHA: *params = mState.blend.sourceBlendAlpha; break;
1330 case GL_BLEND_DST_RGB: *params = mState.blend.destBlendRGB; break;
1331 case GL_BLEND_DST_ALPHA: *params = mState.blend.destBlendAlpha; break;
1332 case GL_BLEND_EQUATION_RGB: *params = mState.blend.blendEquationRGB; break;
1333 case GL_BLEND_EQUATION_ALPHA: *params = mState.blend.blendEquationAlpha; break;
1334 case GL_STENCIL_WRITEMASK: *params = mState.depthStencil.stencilWritemask; break;
1335 case GL_STENCIL_BACK_WRITEMASK: *params = mState.depthStencil.stencilBackWritemask; break;
1336 case GL_STENCIL_CLEAR_VALUE: *params = mState.stencilClearValue; break;
1337 case GL_SUBPIXEL_BITS: *params = 4; break;
1338 case GL_MAX_TEXTURE_SIZE: *params = getMaximumTextureDimension(); break;
1339 case GL_MAX_CUBE_MAP_TEXTURE_SIZE: *params = getMaximumCubeTextureDimension(); break;
1340 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1341 params[0] = mNumCompressedTextureFormats;
1342 break;
1343 case GL_MAX_SAMPLES_ANGLE:
1344 {
1345 GLsizei maxSamples = getMaxSupportedSamples();
1346 if (maxSamples != 0)
1347 {
1348 *params = maxSamples;
1349 }
1350 else
1351 {
1352 return false;
1353 }
1354
1355 break;
1356 }
1357 case GL_SAMPLE_BUFFERS:
1358 case GL_SAMPLES:
1359 {
1360 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1361 if (framebuffer->completeness() == GL_FRAMEBUFFER_COMPLETE)
1362 {
1363 switch (pname)
1364 {
1365 case GL_SAMPLE_BUFFERS:
1366 if (framebuffer->getSamples() != 0)
1367 {
1368 *params = 1;
1369 }
1370 else
1371 {
1372 *params = 0;
1373 }
1374 break;
1375 case GL_SAMPLES:
1376 *params = framebuffer->getSamples();
1377 break;
1378 }
1379 }
1380 else
1381 {
1382 *params = 0;
1383 }
1384 }
1385 break;
1386 case GL_IMPLEMENTATION_COLOR_READ_TYPE:
1387 case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
1388 {
1389 GLenum format, type;
1390 if (getCurrentReadFormatType(&format, &type))
1391 {
1392 if (pname == GL_IMPLEMENTATION_COLOR_READ_FORMAT)
1393 *params = format;
1394 else
1395 *params = type;
1396 }
1397 }
1398 break;
1399 case GL_MAX_VIEWPORT_DIMS:
1400 {
1401 params[0] = mMaxViewportDimension;
1402 params[1] = mMaxViewportDimension;
1403 }
1404 break;
1405 case GL_COMPRESSED_TEXTURE_FORMATS:
1406 {
1407 if (supportsDXT1Textures())
1408 {
1409 *params++ = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
1410 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
1411 }
1412 if (supportsDXT3Textures())
1413 {
1414 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE;
1415 }
1416 if (supportsDXT5Textures())
1417 {
1418 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE;
1419 }
1420 }
1421 break;
1422 case GL_VIEWPORT:
1423 params[0] = mState.viewport.x;
1424 params[1] = mState.viewport.y;
1425 params[2] = mState.viewport.width;
1426 params[3] = mState.viewport.height;
1427 break;
1428 case GL_SCISSOR_BOX:
1429 params[0] = mState.scissor.x;
1430 params[1] = mState.scissor.y;
1431 params[2] = mState.scissor.width;
1432 params[3] = mState.scissor.height;
1433 break;
1434 case GL_CULL_FACE_MODE: *params = mState.rasterizer.cullMode; break;
1435 case GL_FRONT_FACE: *params = mState.rasterizer.frontFace; break;
1436 case GL_RED_BITS:
1437 case GL_GREEN_BITS:
1438 case GL_BLUE_BITS:
1439 case GL_ALPHA_BITS:
1440 {
1441 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1442 gl::Renderbuffer *colorbuffer = framebuffer->getFirstColorbuffer();
1443
1444 if (colorbuffer)
1445 {
1446 switch (pname)
1447 {
1448 case GL_RED_BITS: *params = colorbuffer->getRedSize(); break;
1449 case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); break;
1450 case GL_BLUE_BITS: *params = colorbuffer->getBlueSize(); break;
1451 case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); break;
1452 }
1453 }
1454 else
1455 {
1456 *params = 0;
1457 }
1458 }
1459 break;
1460 case GL_DEPTH_BITS:
1461 {
1462 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1463 gl::Renderbuffer *depthbuffer = framebuffer->getDepthbuffer();
1464
1465 if (depthbuffer)
1466 {
1467 *params = depthbuffer->getDepthSize();
1468 }
1469 else
1470 {
1471 *params = 0;
1472 }
1473 }
1474 break;
1475 case GL_STENCIL_BITS:
1476 {
1477 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1478 gl::Renderbuffer *stencilbuffer = framebuffer->getStencilbuffer();
1479
1480 if (stencilbuffer)
1481 {
1482 *params = stencilbuffer->getStencilSize();
1483 }
1484 else
1485 {
1486 *params = 0;
1487 }
1488 }
1489 break;
1490 case GL_TEXTURE_BINDING_2D:
1491 {
1492 if (mState.activeSampler > mRenderer->getMaxCombinedTextureImageUnits() - 1)
1493 {
1494 gl::error(GL_INVALID_OPERATION);
1495 return false;
1496 }
1497
1498 *params = mState.samplerTexture[TEXTURE_2D][mState.activeSampler].id();
1499 }
1500 break;
1501 case GL_TEXTURE_BINDING_CUBE_MAP:
1502 {
1503 if (mState.activeSampler > mRenderer->getMaxCombinedTextureImageUnits() - 1)
1504 {
1505 gl::error(GL_INVALID_OPERATION);
1506 return false;
1507 }
1508
1509 *params = mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].id();
1510 }
1511 break;
1512 case GL_RESET_NOTIFICATION_STRATEGY_EXT:
1513 *params = mResetStrategy;
1514 break;
1515 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
1516 *params = 1;
1517 break;
1518 case GL_PROGRAM_BINARY_FORMATS_OES:
1519 *params = GL_PROGRAM_BINARY_ANGLE;
1520 break;
1521 default:
1522 return false;
1523 }
1524
1525 return true;
1526 }
1527
1528 bool Context::getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams)
1529 {
1530 if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT)
1531 {
1532 *type = GL_INT;
1533 *numParams = 1;
1534 return true;
1535 }
1536
1537 // Please note: the query type returned for DEPTH_CLEAR_VALUE in this implementation
1538 // is FLOAT rather than INT, as would be suggested by the GL ES 2.0 spec. This is due
1539 // to the fact that it is stored internally as a float, and so would require conversion
1540 // if returned from Context::getIntegerv. Since this conversion is already implemented
1541 // in the case that one calls glGetIntegerv to retrieve a float-typed state variable, we
1542 // place DEPTH_CLEAR_VALUE with the floats. This should make no difference to the calling
1543 // application.
1544 switch (pname)
1545 {
1546 case GL_COMPRESSED_TEXTURE_FORMATS:
1547 {
1548 *type = GL_INT;
1549 *numParams = mNumCompressedTextureFormats;
1550 }
1551 break;
1552 case GL_SHADER_BINARY_FORMATS:
1553 {
1554 *type = GL_INT;
1555 *numParams = 0;
1556 }
1557 break;
1558 case GL_MAX_VERTEX_ATTRIBS:
1559 case GL_MAX_VERTEX_UNIFORM_VECTORS:
1560 case GL_MAX_VARYING_VECTORS:
1561 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
1562 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
1563 case GL_MAX_TEXTURE_IMAGE_UNITS:
1564 case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
1565 case GL_MAX_RENDERBUFFER_SIZE:
1566 case GL_MAX_COLOR_ATTACHMENTS_EXT:
1567 case GL_MAX_DRAW_BUFFERS_EXT:
1568 case GL_NUM_SHADER_BINARY_FORMATS:
1569 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1570 case GL_ARRAY_BUFFER_BINDING:
1571 case GL_FRAMEBUFFER_BINDING:
1572 case GL_RENDERBUFFER_BINDING:
1573 case GL_CURRENT_PROGRAM:
1574 case GL_PACK_ALIGNMENT:
1575 case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
1576 case GL_UNPACK_ALIGNMENT:
1577 case GL_GENERATE_MIPMAP_HINT:
1578 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
1579 case GL_RED_BITS:
1580 case GL_GREEN_BITS:
1581 case GL_BLUE_BITS:
1582 case GL_ALPHA_BITS:
1583 case GL_DEPTH_BITS:
1584 case GL_STENCIL_BITS:
1585 case GL_ELEMENT_ARRAY_BUFFER_BINDING:
1586 case GL_CULL_FACE_MODE:
1587 case GL_FRONT_FACE:
1588 case GL_ACTIVE_TEXTURE:
1589 case GL_STENCIL_FUNC:
1590 case GL_STENCIL_VALUE_MASK:
1591 case GL_STENCIL_REF:
1592 case GL_STENCIL_FAIL:
1593 case GL_STENCIL_PASS_DEPTH_FAIL:
1594 case GL_STENCIL_PASS_DEPTH_PASS:
1595 case GL_STENCIL_BACK_FUNC:
1596 case GL_STENCIL_BACK_VALUE_MASK:
1597 case GL_STENCIL_BACK_REF:
1598 case GL_STENCIL_BACK_FAIL:
1599 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1600 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1601 case GL_DEPTH_FUNC:
1602 case GL_BLEND_SRC_RGB:
1603 case GL_BLEND_SRC_ALPHA:
1604 case GL_BLEND_DST_RGB:
1605 case GL_BLEND_DST_ALPHA:
1606 case GL_BLEND_EQUATION_RGB:
1607 case GL_BLEND_EQUATION_ALPHA:
1608 case GL_STENCIL_WRITEMASK:
1609 case GL_STENCIL_BACK_WRITEMASK:
1610 case GL_STENCIL_CLEAR_VALUE:
1611 case GL_SUBPIXEL_BITS:
1612 case GL_MAX_TEXTURE_SIZE:
1613 case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
1614 case GL_SAMPLE_BUFFERS:
1615 case GL_SAMPLES:
1616 case GL_IMPLEMENTATION_COLOR_READ_TYPE:
1617 case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
1618 case GL_TEXTURE_BINDING_2D:
1619 case GL_TEXTURE_BINDING_CUBE_MAP:
1620 case GL_RESET_NOTIFICATION_STRATEGY_EXT:
1621 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
1622 case GL_PROGRAM_BINARY_FORMATS_OES:
1623 {
1624 *type = GL_INT;
1625 *numParams = 1;
1626 }
1627 break;
1628 case GL_MAX_SAMPLES_ANGLE:
1629 {
1630 if (getMaxSupportedSamples() != 0)
1631 {
1632 *type = GL_INT;
1633 *numParams = 1;
1634 }
1635 else
1636 {
1637 return false;
1638 }
1639 }
1640 break;
1641 case GL_MAX_VIEWPORT_DIMS:
1642 {
1643 *type = GL_INT;
1644 *numParams = 2;
1645 }
1646 break;
1647 case GL_VIEWPORT:
1648 case GL_SCISSOR_BOX:
1649 {
1650 *type = GL_INT;
1651 *numParams = 4;
1652 }
1653 break;
1654 case GL_SHADER_COMPILER:
1655 case GL_SAMPLE_COVERAGE_INVERT:
1656 case GL_DEPTH_WRITEMASK:
1657 case GL_CULL_FACE: // CULL_FACE through DITHER are natural to IsEnabled,
1658 case GL_POLYGON_OFFSET_FILL: // but can be retrieved through the Get{Type}v queries.
1659 case GL_SAMPLE_ALPHA_TO_COVERAGE: // For this purpose, they are treated here as bool-natural
1660 case GL_SAMPLE_COVERAGE:
1661 case GL_SCISSOR_TEST:
1662 case GL_STENCIL_TEST:
1663 case GL_DEPTH_TEST:
1664 case GL_BLEND:
1665 case GL_DITHER:
1666 case GL_CONTEXT_ROBUST_ACCESS_EXT:
1667 {
1668 *type = GL_BOOL;
1669 *numParams = 1;
1670 }
1671 break;
1672 case GL_COLOR_WRITEMASK:
1673 {
1674 *type = GL_BOOL;
1675 *numParams = 4;
1676 }
1677 break;
1678 case GL_POLYGON_OFFSET_FACTOR:
1679 case GL_POLYGON_OFFSET_UNITS:
1680 case GL_SAMPLE_COVERAGE_VALUE:
1681 case GL_DEPTH_CLEAR_VALUE:
1682 case GL_LINE_WIDTH:
1683 {
1684 *type = GL_FLOAT;
1685 *numParams = 1;
1686 }
1687 break;
1688 case GL_ALIASED_LINE_WIDTH_RANGE:
1689 case GL_ALIASED_POINT_SIZE_RANGE:
1690 case GL_DEPTH_RANGE:
1691 {
1692 *type = GL_FLOAT;
1693 *numParams = 2;
1694 }
1695 break;
1696 case GL_COLOR_CLEAR_VALUE:
1697 case GL_BLEND_COLOR:
1698 {
1699 *type = GL_FLOAT;
1700 *numParams = 4;
1701 }
1702 break;
1703 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
1704 if (!supportsTextureFilterAnisotropy())
1705 {
1706 return false;
1707 }
1708 *type = GL_FLOAT;
1709 *numParams = 1;
1710 break;
1711 default:
1712 return false;
1713 }
1714
1715 return true;
1716 }
1717
1718 // Applies the render target surface, depth stencil surface, viewport rectangle and
1719 // scissor rectangle to the renderer
1720 bool Context::applyRenderTarget(GLenum drawMode, bool ignoreViewport)
1721 {
1722 Framebuffer *framebufferObject = getDrawFramebuffer();
1723
1724 if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
1725 {
1726 return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
1727 }
1728
1729 mRenderer->applyRenderTarget(framebufferObject);
1730
1731 if (!mRenderer->setViewport(mState.viewport, mState.zNear, mState.zFar, drawMode, mState.rasterizer.frontFace,
1732 ignoreViewport))
1733 {
1734 return false;
1735 }
1736
1737 mRenderer->setScissorRectangle(mState.scissor, mState.scissorTest);
1738
1739 return true;
1740 }
1741
1742 // Applies the fixed-function state (culling, depth test, alpha blending, stenciling, etc) to the Direct3D 9 device
1743 void Context::applyState(GLenum drawMode)
1744 {
1745 Framebuffer *framebufferObject = getDrawFramebuffer();
1746 int samples = framebufferObject->getSamples();
1747
1748 mState.rasterizer.pointDrawMode = (drawMode == GL_POINTS);
1749 mState.rasterizer.multiSample = (samples != 0);
1750 mRenderer->setRasterizerState(mState.rasterizer);
1751
1752 unsigned int mask = 0;
1753 if (mState.sampleCoverage)
1754 {
1755 if (mState.sampleCoverageValue != 0)
1756 {
1757
1758 float threshold = 0.5f;
1759
1760 for (int i = 0; i < samples; ++i)
1761 {
1762 mask <<= 1;
1763
1764 if ((i + 1) * mState.sampleCoverageValue >= threshold)
1765 {
1766 threshold += 1.0f;
1767 mask |= 1;
1768 }
1769 }
1770 }
1771
1772 if (mState.sampleCoverageInvert)
1773 {
1774 mask = ~mask;
1775 }
1776 }
1777 else
1778 {
1779 mask = 0xFFFFFFFF;
1780 }
1781 mRenderer->setBlendState(mState.blend, mState.blendColor, mask);
1782
1783 mRenderer->setDepthStencilState(mState.depthStencil, mState.stencilRef, mState.stencilBackRef,
1784 mState.rasterizer.frontFace == GL_CCW);
1785 }
1786
1787 // Applies the shaders and shader constants to the Direct3D 9 device
1788 void Context::applyShaders()
1789 {
1790 ProgramBinary *programBinary = getCurrentProgramBinary();
1791
1792 mRenderer->applyShaders(programBinary);
1793
1794 programBinary->applyUniforms();
1795 }
1796
1797 // Applies the textures and sampler states to the Direct3D 9 device
1798 void Context::applyTextures()
1799 {
1800 applyTextures(SAMPLER_PIXEL);
1801
1802 if (mSupportsVertexTexture)
1803 {
1804 applyTextures(SAMPLER_VERTEX);
1805 }
1806 }
1807
1808 // For each Direct3D 9 sampler of either the pixel or vertex stage,
1809 // looks up the corresponding OpenGL texture image unit and texture type,
1810 // and sets the texture and its addressing/filtering state (or NULL when inactive).
1811 void Context::applyTextures(SamplerType type)
1812 {
1813 ProgramBinary *programBinary = getCurrentProgramBinary();
1814
1815 // Range of Direct3D samplers of given sampler type
1816 int samplerCount = (type == SAMPLER_PIXEL) ? MAX_TEXTURE_IMAGE_UNITS : mRenderer->getMaxVertexTextureImageUnits();
1817 int samplerRange = programBinary->getUsedSamplerRange(type);
1818
1819 for (int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
1820 {
1821 int textureUnit = programBinary->getSamplerMapping(type, samplerIndex); // OpenGL texture image unit index
1822
1823 if (textureUnit != -1)
1824 {
1825 TextureType textureType = programBinary->getSamplerTextureType(type, samplerIndex);
1826 Texture *texture = getSamplerTexture(textureUnit, textureType);
1827
1828 if (texture->isSamplerComplete())
1829 {
1830 SamplerState samplerState;
1831 texture->getSamplerState(&samplerState);
1832 mRenderer->setSamplerState(type, samplerIndex, samplerState);
1833
1834 mRenderer->setTexture(type, samplerIndex, texture);
1835
1836 texture->resetDirty();
1837 }
1838 else
1839 {
1840 mRenderer->setTexture(type, samplerIndex, getIncompleteTexture(textureType));
1841 }
1842 }
1843 else
1844 {
1845 mRenderer->setTexture(type, samplerIndex, NULL);
1846 }
1847 }
1848
1849 for (int samplerIndex = samplerRange; samplerIndex < samplerCount; samplerIndex++)
1850 {
1851 mRenderer->setTexture(type, samplerIndex, NULL);
1852 }
1853 }
1854
1855 void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
1856 GLenum format, GLenum type, GLsizei *bufSize, void* pixels)
1857 {
1858 Framebuffer *framebuffer = getReadFramebuffer();
1859
1860 if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
1861 {
1862 return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
1863 }
1864
1865 if (getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
1866 {
1867 return gl::error(GL_INVALID_OPERATION);
1868 }
1869
1870 GLsizei outputPitch = ComputePitch(width, ConvertSizedInternalFormat(format, type), getPackAlignment());
1871 // sized query sanity check
1872 if (bufSize)
1873 {
1874 int requiredSize = outputPitch * height;
1875 if (requiredSize > *bufSize)
1876 {
1877 return gl::error(GL_INVALID_OPERATION);
1878 }
1879 }
1880
1881 mRenderer->readPixels(framebuffer, x, y, width, height, format, type, outputPitch, getPackReverseRowOrder(), getPackAlignment(), pixels);
1882 }
1883
1884 void Context::clear(GLbitfield mask)
1885 {
1886 Framebuffer *framebufferObject = getDrawFramebuffer();
1887
1888 if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
1889 {
1890 return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
1891 }
1892
1893 DWORD flags = 0;
1894 GLbitfield finalMask = 0;
1895
1896 if (mask & GL_COLOR_BUFFER_BIT)
1897 {
1898 mask &= ~GL_COLOR_BUFFER_BIT;
1899
1900 if (framebufferObject->hasEnabledColorAttachment())
1901 {
1902 finalMask |= GL_COLOR_BUFFER_BIT;
1903 }
1904 }
1905
1906 if (mask & GL_DEPTH_BUFFER_BIT)
1907 {
1908 mask &= ~GL_DEPTH_BUFFER_BIT;
1909 if (mState.depthStencil.depthMask && framebufferObject->getDepthbufferType() != GL_NONE)
1910 {
1911 finalMask |= GL_DEPTH_BUFFER_BIT;
1912 }
1913 }
1914
1915 if (mask & GL_STENCIL_BUFFER_BIT)
1916 {
1917 mask &= ~GL_STENCIL_BUFFER_BIT;
1918 if (framebufferObject->getStencilbufferType() != GL_NONE)
1919 {
1920 rx::RenderTarget *depthStencil = framebufferObject->getStencilbuffer()->getDepthStencil();
1921 if (!depthStencil)
1922 {
1923 ERR("Depth stencil pointer unexpectedly null.");
1924 return;
1925 }
1926
1927 if (GetStencilSize(depthStencil->getActualFormat()) > 0)
1928 {
1929 finalMask |= GL_STENCIL_BUFFER_BIT;
1930 }
1931 }
1932 }
1933
1934 if (mask != 0)
1935 {
1936 return gl::error(GL_INVALID_VALUE);
1937 }
1938
1939 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport
1940 {
1941 return;
1942 }
1943
1944 ClearParameters clearParams;
1945 clearParams.mask = finalMask;
1946 clearParams.colorClearValue = mState.colorClearValue;
1947 clearParams.colorMaskRed = mState.blend.colorMaskRed;
1948 clearParams.colorMaskGreen = mState.blend.colorMaskGreen;
1949 clearParams.colorMaskBlue = mState.blend.colorMaskBlue;
1950 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha;
1951 clearParams.depthClearValue = mState.depthClearValue;
1952 clearParams.stencilClearValue = mState.stencilClearValue;
1953 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask;
1954
1955 mRenderer->clear(clearParams, framebufferObject);
1956 }
1957
1958 void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances)
1959 {
1960 if (!mState.currentProgram)
1961 {
1962 return gl::error(GL_INVALID_OPERATION);
1963 }
1964
1965 if (!mRenderer->applyPrimitiveType(mode, count))
1966 {
1967 return;
1968 }
1969
1970 if (!applyRenderTarget(mode, false))
1971 {
1972 return;
1973 }
1974
1975 applyState(mode);
1976
1977 ProgramBinary *programBinary = getCurrentProgramBinary();
1978
1979 GLenum err = mRenderer->applyVertexBuffer(programBinary, mState.vertexAttribute, first, count, instances);
1980 if (err != GL_NO_ERROR)
1981 {
1982 return gl::error(err);
1983 }
1984
1985 applyShaders();
1986 applyTextures();
1987
1988 if (!programBinary->validateSamplers(NULL))
1989 {
1990 return gl::error(GL_INVALID_OPERATION);
1991 }
1992
1993 if (!skipDraw(mode))
1994 {
1995 mRenderer->drawArrays(mode, count, instances);
1996 }
1997 }
1998
1999 void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instances)
2000 {
2001 if (!mState.currentProgram)
2002 {
2003 return gl::error(GL_INVALID_OPERATION);
2004 }
2005
2006 if (!indices && !mState.elementArrayBuffer)
2007 {
2008 return gl::error(GL_INVALID_OPERATION);
2009 }
2010
2011 if (!mRenderer->applyPrimitiveType(mode, count))
2012 {
2013 return;
2014 }
2015
2016 if (!applyRenderTarget(mode, false))
2017 {
2018 return;
2019 }
2020
2021 applyState(mode);
2022
2023 rx::TranslatedIndexData indexInfo;
2024 GLenum err = mRenderer->applyIndexBuffer(indices, mState.elementArrayBuffer.get(), count, mode, type, &indexInfo);
2025 if (err != GL_NO_ERROR)
2026 {
2027 return gl::error(err);
2028 }
2029
2030 ProgramBinary *programBinary = getCurrentProgramBinary();
2031
2032 GLsizei vertexCount = indexInfo.maxIndex - indexInfo.minIndex + 1;
2033 err = mRenderer->applyVertexBuffer(programBinary, mState.vertexAttribute, indexInfo.minIndex, vertexCount, instances);
2034 if (err != GL_NO_ERROR)
2035 {
2036 return gl::error(err);
2037 }
2038
2039 applyShaders();
2040 applyTextures();
2041
2042 if (!programBinary->validateSamplers(NULL))
2043 {
2044 return gl::error(GL_INVALID_OPERATION);
2045 }
2046
2047 if (!skipDraw(mode))
2048 {
2049 mRenderer->drawElements(mode, count, type, indices, mState.elementArrayBuffer.get(), indexInfo, instances);
2050 }
2051 }
2052
2053 // Implements glFlush when block is false, glFinish when block is true
2054 void Context::sync(bool block)
2055 {
2056 mRenderer->sync(block);
2057 }
2058
2059 void Context::recordInvalidEnum()
2060 {
2061 mInvalidEnum = true;
2062 }
2063
2064 void Context::recordInvalidValue()
2065 {
2066 mInvalidValue = true;
2067 }
2068
2069 void Context::recordInvalidOperation()
2070 {
2071 mInvalidOperation = true;
2072 }
2073
2074 void Context::recordOutOfMemory()
2075 {
2076 mOutOfMemory = true;
2077 }
2078
2079 void Context::recordInvalidFramebufferOperation()
2080 {
2081 mInvalidFramebufferOperation = true;
2082 }
2083
2084 // Get one of the recorded errors and clear its flag, if any.
2085 // [OpenGL ES 2.0.24] section 2.5 page 13.
2086 GLenum Context::getError()
2087 {
2088 if (mInvalidEnum)
2089 {
2090 mInvalidEnum = false;
2091
2092 return GL_INVALID_ENUM;
2093 }
2094
2095 if (mInvalidValue)
2096 {
2097 mInvalidValue = false;
2098
2099 return GL_INVALID_VALUE;
2100 }
2101
2102 if (mInvalidOperation)
2103 {
2104 mInvalidOperation = false;
2105
2106 return GL_INVALID_OPERATION;
2107 }
2108
2109 if (mOutOfMemory)
2110 {
2111 mOutOfMemory = false;
2112
2113 return GL_OUT_OF_MEMORY;
2114 }
2115
2116 if (mInvalidFramebufferOperation)
2117 {
2118 mInvalidFramebufferOperation = false;
2119
2120 return GL_INVALID_FRAMEBUFFER_OPERATION;
2121 }
2122
2123 return GL_NO_ERROR;
2124 }
2125
2126 GLenum Context::getResetStatus()
2127 {
2128 if (mResetStatus == GL_NO_ERROR && !mContextLost)
2129 {
2130 // mResetStatus will be set by the markContextLost callback
2131 // in the case a notification is sent
2132 mRenderer->testDeviceLost(true);
2133 }
2134
2135 GLenum status = mResetStatus;
2136
2137 if (mResetStatus != GL_NO_ERROR)
2138 {
2139 ASSERT(mContextLost);
2140
2141 if (mRenderer->testDeviceResettable())
2142 {
2143 mResetStatus = GL_NO_ERROR;
2144 }
2145 }
2146
2147 return status;
2148 }
2149
2150 bool Context::isResetNotificationEnabled()
2151 {
2152 return (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT);
2153 }
2154
2155 int Context::getMajorShaderModel() const
2156 {
2157 return mMajorShaderModel;
2158 }
2159
2160 float Context::getMaximumPointSize() const
2161 {
2162 return mMaximumPointSize;
2163 }
2164
2165 unsigned int Context::getMaximumCombinedTextureImageUnits() const
2166 {
2167 return mRenderer->getMaxCombinedTextureImageUnits();
2168 }
2169
2170 int Context::getMaxSupportedSamples() const
2171 {
2172 return mRenderer->getMaxSupportedSamples();
2173 }
2174
2175 unsigned int Context::getMaximumRenderTargets() const
2176 {
2177 return mRenderer->getMaxRenderTargets();
2178 }
2179
2180 bool Context::supportsEventQueries() const
2181 {
2182 return mSupportsEventQueries;
2183 }
2184
2185 bool Context::supportsOcclusionQueries() const
2186 {
2187 return mSupportsOcclusionQueries;
2188 }
2189
2190 bool Context::supportsBGRATextures() const
2191 {
2192 return mSupportsBGRATextures;
2193 }
2194
2195 bool Context::supportsDXT1Textures() const
2196 {
2197 return mSupportsDXT1Textures;
2198 }
2199
2200 bool Context::supportsDXT3Textures() const
2201 {
2202 return mSupportsDXT3Textures;
2203 }
2204
2205 bool Context::supportsDXT5Textures() const
2206 {
2207 return mSupportsDXT5Textures;
2208 }
2209
2210 bool Context::supportsFloat32Textures() const
2211 {
2212 return mSupportsFloat32Textures;
2213 }
2214
2215 bool Context::supportsFloat32LinearFilter() const
2216 {
2217 return mSupportsFloat32LinearFilter;
2218 }
2219
2220 bool Context::supportsFloat32RenderableTextures() const
2221 {
2222 return mSupportsFloat32RenderableTextures;
2223 }
2224
2225 bool Context::supportsFloat16Textures() const
2226 {
2227 return mSupportsFloat16Textures;
2228 }
2229
2230 bool Context::supportsFloat16LinearFilter() const
2231 {
2232 return mSupportsFloat16LinearFilter;
2233 }
2234
2235 bool Context::supportsFloat16RenderableTextures() const
2236 {
2237 return mSupportsFloat16RenderableTextures;
2238 }
2239
2240 int Context::getMaximumRenderbufferDimension() const
2241 {
2242 return mMaxRenderbufferDimension;
2243 }
2244
2245 int Context::getMaximumTextureDimension() const
2246 {
2247 return mMaxTextureDimension;
2248 }
2249
2250 int Context::getMaximumCubeTextureDimension() const
2251 {
2252 return mMaxCubeTextureDimension;
2253 }
2254
2255 int Context::getMaximumTextureLevel() const
2256 {
2257 return mMaxTextureLevel;
2258 }
2259
2260 bool Context::supportsLuminanceTextures() const
2261 {
2262 return mSupportsLuminanceTextures;
2263 }
2264
2265 bool Context::supportsLuminanceAlphaTextures() const
2266 {
2267 return mSupportsLuminanceAlphaTextures;
2268 }
2269
2270 bool Context::supportsDepthTextures() const
2271 {
2272 return mSupportsDepthTextures;
2273 }
2274
2275 bool Context::supports32bitIndices() const
2276 {
2277 return mSupports32bitIndices;
2278 }
2279
2280 bool Context::supportsNonPower2Texture() const
2281 {
2282 return mSupportsNonPower2Texture;
2283 }
2284
2285 bool Context::supportsInstancing() const
2286 {
2287 return mSupportsInstancing;
2288 }
2289
2290 bool Context::supportsTextureFilterAnisotropy() const
2291 {
2292 return mSupportsTextureFilterAnisotropy;
2293 }
2294
2295 float Context::getTextureMaxAnisotropy() const
2296 {
2297 return mMaxTextureAnisotropy;
2298 }
2299
2300 bool Context::getCurrentReadFormatType(GLenum *format, GLenum *type)
2301 {
2302 Framebuffer *framebuffer = getReadFramebuffer();
2303 if (!framebuffer || framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
2304 {
2305 return gl::error(GL_INVALID_OPERATION, false);
2306 }
2307
2308 Renderbuffer *renderbuffer = framebuffer->getReadColorbuffer();
2309 if (!renderbuffer)
2310 {
2311 return gl::error(GL_INVALID_OPERATION, false);
2312 }
2313
2314 *format = gl::ExtractFormat(renderbuffer->getActualFormat());
2315 *type = gl::ExtractType(renderbuffer->getActualFormat());
2316
2317 return true;
2318 }
2319
2320 void Context::detachBuffer(GLuint buffer)
2321 {
2322 // [OpenGL ES 2.0.24] section 2.9 page 22:
2323 // If a buffer object is deleted while it is bound, all bindings to that object in the current context
2324 // (i.e. in the thread that called Delete-Buffers) are reset to zero.
2325
2326 if (mState.arrayBuffer.id() == buffer)
2327 {
2328 mState.arrayBuffer.set(NULL);
2329 }
2330
2331 if (mState.elementArrayBuffer.id() == buffer)
2332 {
2333 mState.elementArrayBuffer.set(NULL);
2334 }
2335
2336 for (int attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
2337 {
2338 if (mState.vertexAttribute[attribute].mBoundBuffer.id() == buffer)
2339 {
2340 mState.vertexAttribute[attribute].mBoundBuffer.set(NULL);
2341 }
2342 }
2343 }
2344
2345 void Context::detachTexture(GLuint texture)
2346 {
2347 // [OpenGL ES 2.0.24] section 3.8 page 84:
2348 // If a texture object is deleted, it is as if all texture units which are bound to that texture object are
2349 // rebound to texture object zero
2350
2351 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++)
2352 {
2353 for (int sampler = 0; sampler < IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++)
2354 {
2355 if (mState.samplerTexture[type][sampler].id() == texture)
2356 {
2357 mState.samplerTexture[type][sampler].set(NULL);
2358 }
2359 }
2360 }
2361
2362 // [OpenGL ES 2.0.24] section 4.4 page 112:
2363 // If a texture object is deleted while its image is attached to the currently bound framebuffer, then it is
2364 // as if FramebufferTexture2D had been called, with a texture of 0, for each attachment point to which this
2365 // image was attached in the currently bound framebuffer.
2366
2367 Framebuffer *readFramebuffer = getReadFramebuffer();
2368 Framebuffer *drawFramebuffer = getDrawFramebuffer();
2369
2370 if (readFramebuffer)
2371 {
2372 readFramebuffer->detachTexture(texture);
2373 }
2374
2375 if (drawFramebuffer && drawFramebuffer != readFramebuffer)
2376 {
2377 drawFramebuffer->detachTexture(texture);
2378 }
2379 }
2380
2381 void Context::detachFramebuffer(GLuint framebuffer)
2382 {
2383 // [OpenGL ES 2.0.24] section 4.4 page 107:
2384 // If a framebuffer that is currently bound to the target FRAMEBUFFER is deleted, it is as though
2385 // BindFramebuffer had been executed with the target of FRAMEBUFFER and framebuffer of zero.
2386
2387 if (mState.readFramebuffer == framebuffer)
2388 {
2389 bindReadFramebuffer(0);
2390 }
2391
2392 if (mState.drawFramebuffer == framebuffer)
2393 {
2394 bindDrawFramebuffer(0);
2395 }
2396 }
2397
2398 void Context::detachRenderbuffer(GLuint renderbuffer)
2399 {
2400 // [OpenGL ES 2.0.24] section 4.4 page 109:
2401 // If a renderbuffer that is currently bound to RENDERBUFFER is deleted, it is as though BindRenderbuffer
2402 // had been executed with the target RENDERBUFFER and name of zero.
2403
2404 if (mState.renderbuffer.id() == renderbuffer)
2405 {
2406 bindRenderbuffer(0);
2407 }
2408
2409 // [OpenGL ES 2.0.24] section 4.4 page 111:
2410 // If a renderbuffer object is deleted while its image is attached to the currently bound framebuffer,
2411 // then it is as if FramebufferRenderbuffer had been called, with a renderbuffer of 0, for each attachment
2412 // point to which this image was attached in the currently bound framebuffer.
2413
2414 Framebuffer *readFramebuffer = getReadFramebuffer();
2415 Framebuffer *drawFramebuffer = getDrawFramebuffer();
2416
2417 if (readFramebuffer)
2418 {
2419 readFramebuffer->detachRenderbuffer(renderbuffer);
2420 }
2421
2422 if (drawFramebuffer && drawFramebuffer != readFramebuffer)
2423 {
2424 drawFramebuffer->detachRenderbuffer(renderbuffer);
2425 }
2426 }
2427
2428 Texture *Context::getIncompleteTexture(TextureType type)
2429 {
2430 Texture *t = mIncompleteTextures[type].get();
2431
2432 if (t == NULL)
2433 {
2434 static const GLubyte color[] = { 0, 0, 0, 255 };
2435
2436 switch (type)
2437 {
2438 default:
2439 UNREACHABLE();
2440 // default falls through to TEXTURE_2D
2441
2442 case TEXTURE_2D:
2443 {
2444 Texture2D *incomplete2d = new Texture2D(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
2445 incomplete2d->setImage(0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, 1, color);
2446 t = incomplete2d;
2447 }
2448 break;
2449
2450 case TEXTURE_CUBE:
2451 {
2452 TextureCubeMap *incompleteCube = new TextureCubeMap(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
2453
2454 incompleteCube->setImagePosX(0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, 1, color);
2455 incompleteCube->setImageNegX(0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, 1, color);
2456 incompleteCube->setImagePosY(0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, 1, color);
2457 incompleteCube->setImageNegY(0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, 1, color);
2458 incompleteCube->setImagePosZ(0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, 1, color);
2459 incompleteCube->setImageNegZ(0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, 1, color);
2460
2461 t = incompleteCube;
2462 }
2463 break;
2464 }
2465
2466 mIncompleteTextures[type].set(t);
2467 }
2468
2469 return t;
2470 }
2471
2472 bool Context::skipDraw(GLenum drawMode)
2473 {
2474 if (drawMode == GL_POINTS)
2475 {
2476 // ProgramBinary assumes non-point rendering if gl_PointSize isn't written,
2477 // which affects varying interpolation. Since the value of gl_PointSize is
2478 // undefined when not written, just skip drawing to avoid unexpected results.
2479 if (!getCurrentProgramBinary()->usesPointSize())
2480 {
2481 // This is stictly speaking not an error, but developers should be
2482 // notified of risking undefined behavior.
2483 ERR("Point rendering without writing to gl_PointSize.");
2484
2485 return true;
2486 }
2487 }
2488 else if (IsTriangleMode(drawMode))
2489 {
2490 if (mState.rasterizer.cullFace && mState.rasterizer.cullMode == GL_FRONT_AND_BACK)
2491 {
2492 return true;
2493 }
2494 }
2495
2496 return false;
2497 }
2498
2499 void Context::setVertexAttrib(GLuint index, const GLfloat *values)
2500 {
2501 ASSERT(index < gl::MAX_VERTEX_ATTRIBS);
2502
2503 mState.vertexAttribute[index].mCurrentValue[0] = values[0];
2504 mState.vertexAttribute[index].mCurrentValue[1] = values[1];
2505 mState.vertexAttribute[index].mCurrentValue[2] = values[2];
2506 mState.vertexAttribute[index].mCurrentValue[3] = values[3];
2507 }
2508
2509 void Context::setVertexAttribDivisor(GLuint index, GLuint divisor)
2510 {
2511 ASSERT(index < gl::MAX_VERTEX_ATTRIBS);
2512
2513 mState.vertexAttribute[index].mDivisor = divisor;
2514 }
2515
2516 // keep list sorted in following order
2517 // OES extensions
2518 // EXT extensions
2519 // Vendor extensions
2520 void Context::initExtensionString()
2521 {
2522 std::string extensionString = "";
2523
2524 // OES extensions
2525 if (supports32bitIndices())
2526 {
2527 extensionString += "GL_OES_element_index_uint ";
2528 }
2529
2530 extensionString += "GL_OES_packed_depth_stencil ";
2531 extensionString += "GL_OES_get_program_binary ";
2532 extensionString += "GL_OES_rgb8_rgba8 ";
2533 if (mRenderer->getDerivativeInstructionSupport())
2534 {
2535 extensionString += "GL_OES_standard_derivatives ";
2536 }
2537
2538 if (supportsFloat16Textures())
2539 {
2540 extensionString += "GL_OES_texture_half_float ";
2541 }
2542 if (supportsFloat16LinearFilter())
2543 {
2544 extensionString += "GL_OES_texture_half_float_linear ";
2545 }
2546 if (supportsFloat32Textures())
2547 {
2548 extensionString += "GL_OES_texture_float ";
2549 }
2550 if (supportsFloat32LinearFilter())
2551 {
2552 extensionString += "GL_OES_texture_float_linear ";
2553 }
2554
2555 if (supportsNonPower2Texture())
2556 {
2557 extensionString += "GL_OES_texture_npot ";
2558 }
2559
2560 // Multi-vendor (EXT) extensions
2561 if (supportsOcclusionQueries())
2562 {
2563 extensionString += "GL_EXT_occlusion_query_boolean ";
2564 }
2565
2566 extensionString += "GL_EXT_read_format_bgra ";
2567 extensionString += "GL_EXT_robustness ";
2568
2569 if (supportsDXT1Textures())
2570 {
2571 extensionString += "GL_EXT_texture_compression_dxt1 ";
2572 }
2573
2574 if (supportsTextureFilterAnisotropy())
2575 {
2576 extensionString += "GL_EXT_texture_filter_anisotropic ";
2577 }
2578
2579 if (supportsBGRATextures())
2580 {
2581 extensionString += "GL_EXT_texture_format_BGRA8888 ";
2582 }
2583
2584 if (mRenderer->getMaxRenderTargets() > 1)
2585 {
2586 extensionString += "GL_EXT_draw_buffers ";
2587 }
2588
2589 extensionString += "GL_EXT_texture_storage ";
2590 extensionString += "GL_EXT_frag_depth ";
2591
2592 // ANGLE-specific extensions
2593 if (supportsDepthTextures())
2594 {
2595 extensionString += "GL_ANGLE_depth_texture ";
2596 }
2597
2598 extensionString += "GL_ANGLE_framebuffer_blit ";
2599 if (getMaxSupportedSamples() != 0)
2600 {
2601 extensionString += "GL_ANGLE_framebuffer_multisample ";
2602 }
2603
2604 if (supportsInstancing())
2605 {
2606 extensionString += "GL_ANGLE_instanced_arrays ";
2607 }
2608
2609 extensionString += "GL_ANGLE_pack_reverse_row_order ";
2610
2611 if (supportsDXT3Textures())
2612 {
2613 extensionString += "GL_ANGLE_texture_compression_dxt3 ";
2614 }
2615 if (supportsDXT5Textures())
2616 {
2617 extensionString += "GL_ANGLE_texture_compression_dxt5 ";
2618 }
2619
2620 extensionString += "GL_ANGLE_texture_usage ";
2621 extensionString += "GL_ANGLE_translated_shader_source ";
2622
2623 // Other vendor-specific extensions
2624 if (supportsEventQueries())
2625 {
2626 extensionString += "GL_NV_fence ";
2627 }
2628
2629 std::string::size_type end = extensionString.find_last_not_of(' ');
2630 if (end != std::string::npos)
2631 {
2632 extensionString.resize(end+1);
2633 }
2634
2635 mExtensionString = makeStaticString(extensionString);
2636 }
2637
2638 const char *Context::getExtensionString() const
2639 {
2640 return mExtensionString;
2641 }
2642
2643 void Context::initRendererString()
2644 {
2645 std::ostringstream rendererString;
2646 rendererString << "ANGLE (";
2647 rendererString << mRenderer->getRendererDescription();
2648 rendererString << ")";
2649
2650 mRendererString = makeStaticString(rendererString.str());
2651 }
2652
2653 const char *Context::getRendererString() const
2654 {
2655 return mRendererString;
2656 }
2657
2658 void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
2659 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
2660 GLbitfield mask)
2661 {
2662 Framebuffer *readFramebuffer = getReadFramebuffer();
2663 Framebuffer *drawFramebuffer = getDrawFramebuffer();
2664
2665 if (!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
2666 !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
2667 {
2668 return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
2669 }
2670
2671 if (drawFramebuffer->getSamples() != 0)
2672 {
2673 return gl::error(GL_INVALID_OPERATION);
2674 }
2675
2676 Renderbuffer *readColorBuffer = readFramebuffer->getReadColorbuffer();
2677 Renderbuffer *drawColorBuffer = drawFramebuffer->getFirstColorbuffer();
2678
2679 if (drawColorBuffer == NULL)
2680 {
2681 ERR("Draw buffers formats don't match, which is not supported in this implementation of BlitFramebufferANGLE");
2682 return gl::error(GL_INVALID_OPERATION);
2683 }
2684
2685 int readBufferWidth = readColorBuffer->getWidth();
2686 int readBufferHeight = readColorBuffer->getHeight();
2687 int drawBufferWidth = drawColorBuffer->getWidth();
2688 int drawBufferHeight = drawColorBuffer->getHeight();
2689
2690 Rectangle sourceRect;
2691 Rectangle destRect;
2692
2693 if (srcX0 < srcX1)
2694 {
2695 sourceRect.x = srcX0;
2696 destRect.x = dstX0;
2697 sourceRect.width = srcX1 - srcX0;
2698 destRect.width = dstX1 - dstX0;
2699 }
2700 else
2701 {
2702 sourceRect.x = srcX1;
2703 destRect.x = dstX1;
2704 sourceRect.width = srcX0 - srcX1;
2705 destRect.width = dstX0 - dstX1;
2706 }
2707
2708 if (srcY0 < srcY1)
2709 {
2710 sourceRect.height = srcY1 - srcY0;
2711 destRect.height = dstY1 - dstY0;
2712 sourceRect.y = srcY0;
2713 destRect.y = dstY0;
2714 }
2715 else
2716 {
2717 sourceRect.height = srcY0 - srcY1;
2718 destRect.height = dstY0 - srcY1;
2719 sourceRect.y = srcY1;
2720 destRect.y = dstY1;
2721 }
2722
2723 Rectangle sourceScissoredRect = sourceRect;
2724 Rectangle destScissoredRect = destRect;
2725
2726 if (mState.scissorTest)
2727 {
2728 // Only write to parts of the destination framebuffer which pass the scissor test.
2729 if (destRect.x < mState.scissor.x)
2730 {
2731 int xDiff = mState.scissor.x - destRect.x;
2732 destScissoredRect.x = mState.scissor.x;
2733 destScissoredRect.width -= xDiff;
2734 sourceScissoredRect.x += xDiff;
2735 sourceScissoredRect.width -= xDiff;
2736
2737 }
2738
2739 if (destRect.x + destRect.width > mState.scissor.x + mState.scissor.width)
2740 {
2741 int xDiff = (destRect.x + destRect.width) - (mState.scissor.x + mState.scissor.width);
2742 destScissoredRect.width -= xDiff;
2743 sourceScissoredRect.width -= xDiff;
2744 }
2745
2746 if (destRect.y < mState.scissor.y)
2747 {
2748 int yDiff = mState.scissor.y - destRect.y;
2749 destScissoredRect.y = mState.scissor.y;
2750 destScissoredRect.height -= yDiff;
2751 sourceScissoredRect.y += yDiff;
2752 sourceScissoredRect.height -= yDiff;
2753 }
2754
2755 if (destRect.y + destRect.height > mState.scissor.y + mState.scissor.height)
2756 {
2757 int yDiff = (destRect.y + destRect.height) - (mState.scissor.y + mState.scissor.height);
2758 destScissoredRect.height -= yDiff;
2759 sourceScissoredRect.height -= yDiff;
2760 }
2761 }
2762
2763 bool blitRenderTarget = false;
2764 bool blitDepthStencil = false;
2765
2766 Rectangle sourceTrimmedRect = sourceScissoredRect;
2767 Rectangle destTrimmedRect = destScissoredRect;
2768
2769 // The source & destination rectangles also may need to be trimmed if they fall out of the bounds of
2770 // the actual draw and read surfaces.
2771 if (sourceTrimmedRect.x < 0)
2772 {
2773 int xDiff = 0 - sourceTrimmedRect.x;
2774 sourceTrimmedRect.x = 0;
2775 sourceTrimmedRect.width -= xDiff;
2776 destTrimmedRect.x += xDiff;
2777 destTrimmedRect.width -= xDiff;
2778 }
2779
2780 if (sourceTrimmedRect.x + sourceTrimmedRect.width > readBufferWidth)
2781 {
2782 int xDiff = (sourceTrimmedRect.x + sourceTrimmedRect.width) - readBufferWidth;
2783 sourceTrimmedRect.width -= xDiff;
2784 destTrimmedRect.width -= xDiff;
2785 }
2786
2787 if (sourceTrimmedRect.y < 0)
2788 {
2789 int yDiff = 0 - sourceTrimmedRect.y;
2790 sourceTrimmedRect.y = 0;
2791 sourceTrimmedRect.height -= yDiff;
2792 destTrimmedRect.y += yDiff;
2793 destTrimmedRect.height -= yDiff;
2794 }
2795
2796 if (sourceTrimmedRect.y + sourceTrimmedRect.height > readBufferHeight)
2797 {
2798 int yDiff = (sourceTrimmedRect.y + sourceTrimmedRect.height) - readBufferHeight;
2799 sourceTrimmedRect.height -= yDiff;
2800 destTrimmedRect.height -= yDiff;
2801 }
2802
2803 if (destTrimmedRect.x < 0)
2804 {
2805 int xDiff = 0 - destTrimmedRect.x;
2806 destTrimmedRect.x = 0;
2807 destTrimmedRect.width -= xDiff;
2808 sourceTrimmedRect.x += xDiff;
2809 sourceTrimmedRect.width -= xDiff;
2810 }
2811
2812 if (destTrimmedRect.x + destTrimmedRect.width > drawBufferWidth)
2813 {
2814 int xDiff = (destTrimmedRect.x + destTrimmedRect.width) - drawBufferWidth;
2815 destTrimmedRect.width -= xDiff;
2816 sourceTrimmedRect.width -= xDiff;
2817 }
2818
2819 if (destTrimmedRect.y < 0)
2820 {
2821 int yDiff = 0 - destTrimmedRect.y;
2822 destTrimmedRect.y = 0;
2823 destTrimmedRect.height -= yDiff;
2824 sourceTrimmedRect.y += yDiff;
2825 sourceTrimmedRect.height -= yDiff;
2826 }
2827
2828 if (destTrimmedRect.y + destTrimmedRect.height > drawBufferHeight)
2829 {
2830 int yDiff = (destTrimmedRect.y + destTrimmedRect.height) - drawBufferHeight;
2831 destTrimmedRect.height -= yDiff;
2832 sourceTrimmedRect.height -= yDiff;
2833 }
2834
2835 bool partialBufferCopy = false;
2836 if (sourceTrimmedRect.height < readBufferHeight ||
2837 sourceTrimmedRect.width < readBufferWidth ||
2838 destTrimmedRect.height < drawBufferHeight ||
2839 destTrimmedRect.width < drawBufferWidth ||
2840 sourceTrimmedRect.y != 0 || destTrimmedRect.y != 0 || sourceTrimmedRect.x != 0 || destTrimmedRect.x != 0)
2841 {
2842 partialBufferCopy = true;
2843 }
2844
2845 if (mask & GL_COLOR_BUFFER_BIT)
2846 {
2847 const GLenum readColorbufferType = readFramebuffer->getReadColorbufferType();
2848 const bool validReadType = (readColorbufferType == GL_TEXTURE_2D) || (readColorbufferType == GL_RENDERBUFFER);
2849 bool validDrawType = true;
2850 bool validDrawFormat = true;
2851
2852 for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
2853 {
2854 if (drawFramebuffer->isEnabledColorAttachment(colorAttachment))
2855 {
2856 if (drawFramebuffer->getColorbufferType(colorAttachment) != GL_TEXTURE_2D &&
2857 drawFramebuffer->getColorbufferType(colorAttachment) != GL_RENDERBUFFER)
2858 {
2859 validDrawType = false;
2860 }
2861
2862 if (drawFramebuffer->getColorbuffer(colorAttachment)->getActualFormat() != readColorBuffer->getActualFormat())
2863 {
2864 validDrawFormat = false;
2865 }
2866 }
2867 }
2868
2869 if (!validReadType || !validDrawType || !validDrawFormat)
2870 {
2871 ERR("Color buffer format conversion in BlitFramebufferANGLE not supported by this implementation");
2872 return gl::error(GL_INVALID_OPERATION);
2873 }
2874
2875 if (partialBufferCopy && readFramebuffer->getSamples() != 0)
2876 {
2877 return gl::error(GL_INVALID_OPERATION);
2878 }
2879
2880 blitRenderTarget = true;
2881
2882 }
2883
2884 if (mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT))
2885 {
2886 Renderbuffer *readDSBuffer = NULL;
2887 Renderbuffer *drawDSBuffer = NULL;
2888
2889 // We support OES_packed_depth_stencil, and do not support a separately attached depth and stencil buffer, so if we have
2890 // both a depth and stencil buffer, it will be the same buffer.
2891
2892 if (mask & GL_DEPTH_BUFFER_BIT)
2893 {
2894 if (readFramebuffer->getDepthbuffer() && drawFramebuffer->getDepthbuffer())
2895 {
2896 if (readFramebuffer->getDepthbufferType() != drawFramebuffer->getDepthbufferType() ||
2897 readFramebuffer->getDepthbuffer()->getActualFormat() != drawFramebuffer->getDepthbuffer()->getActualFormat())
2898 {
2899 return gl::error(GL_INVALID_OPERATION);
2900 }
2901
2902 blitDepthStencil = true;
2903 readDSBuffer = readFramebuffer->getDepthbuffer();
2904 drawDSBuffer = drawFramebuffer->getDepthbuffer();
2905 }
2906 }
2907
2908 if (mask & GL_STENCIL_BUFFER_BIT)
2909 {
2910 if (readFramebuffer->getStencilbuffer() && drawFramebuffer->getStencilbuffer())
2911 {
2912 if (readFramebuffer->getStencilbufferType() != drawFramebuffer->getStencilbufferType() ||
2913 readFramebuffer->getStencilbuffer()->getActualFormat() != drawFramebuffer->getStencilbuffer()->getActualFormat())
2914 {
2915 return gl::error(GL_INVALID_OPERATION);
2916 }
2917
2918 blitDepthStencil = true;
2919 readDSBuffer = readFramebuffer->getStencilbuffer();
2920 drawDSBuffer = drawFramebuffer->getStencilbuffer();
2921 }
2922 }
2923
2924 if (partialBufferCopy)
2925 {
2926 ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
2927 return gl::error(GL_INVALID_OPERATION); // only whole-buffer copies are permitted
2928 }
2929
2930 if ((drawDSBuffer && drawDSBuffer->getSamples() != 0) ||
2931 (readDSBuffer && readDSBuffer->getSamples() != 0))
2932 {
2933 return gl::error(GL_INVALID_OPERATION);
2934 }
2935 }
2936
2937 if (blitRenderTarget || blitDepthStencil)
2938 {
2939 mRenderer->blitRect(readFramebuffer, sourceTrimmedRect, drawFramebuffer, destTrimmedRect, blitRenderTarget, blitDepthStencil);
2940 }
2941 }
2942
2943 }
2944
2945 extern "C"
2946 {
2947 gl::Context *glCreateContext(const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess)
2948 {
2949 return new gl::Context(shareContext, renderer, notifyResets, robustAccess);
2950 }
2951
2952 void glDestroyContext(gl::Context *context)
2953 {
2954 delete context;
2955
2956 if (context == gl::getContext())
2957 {
2958 gl::makeCurrent(NULL, NULL, NULL);
2959 }
2960 }
2961
2962 void glMakeCurrent(gl::Context *context, egl::Display *display, egl::Surface *surface)
2963 {
2964 gl::makeCurrent(context, display, surface);
2965 }
2966
2967 gl::Context *glGetCurrentContext()
2968 {
2969 return gl::getContext();
2970 }
2971
2972 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial