1 #include "precompiled.h"
2 //
3 // Copyright (c) 2002-2014 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 "common/utilities.h"
15 #include "libGLESv2/formatutils.h"
16 #include "libGLESv2/Buffer.h"
17 #include "libGLESv2/Fence.h"
18 #include "libGLESv2/Framebuffer.h"
19 #include "libGLESv2/Renderbuffer.h"
20 #include "libGLESv2/Program.h"
21 #include "libGLESv2/ProgramBinary.h"
22 #include "libGLESv2/Query.h"
23 #include "libGLESv2/Texture.h"
24 #include "libGLESv2/ResourceManager.h"
25 #include "libGLESv2/renderer/IndexDataManager.h"
26 #include "libGLESv2/renderer/RenderTarget.h"
27 #include "libGLESv2/renderer/Renderer.h"
28 #include "libGLESv2/VertexArray.h"
29 #include "libGLESv2/Sampler.h"
30 #include "libGLESv2/validationES.h"
31 #include "libGLESv2/TransformFeedback.h"
32
33 #include "libEGL/Surface.h"
34
35 #undef near
36 #undef far
37
38 namespace gl
39 {
makeStaticString(const std::string & str)40 static const char* makeStaticString(const std::string& str)
41 {
42 static std::set<std::string> strings;
43 std::set<std::string>::iterator it = strings.find(str);
44 if (it != strings.end())
45 return it->c_str();
46
47 return strings.insert(str).first->c_str();
48 }
49
Context(int clientVersion,const gl::Context * shareContext,rx::Renderer * renderer,bool notifyResets,bool robustAccess)50 Context::Context(int clientVersion, const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess) : mRenderer(renderer)
51 {
52 ASSERT(robustAccess == false); // Unimplemented
53
54 mFenceNVHandleAllocator.setBaseHandle(0);
55
56 setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
57
58 mClientVersion = clientVersion;
59
60 mState.depthClearValue = 1.0f;
61 mState.stencilClearValue = 0;
62
63 mState.rasterizer.rasterizerDiscard = false;
64 mState.rasterizer.cullFace = false;
65 mState.rasterizer.cullMode = GL_BACK;
66 mState.rasterizer.frontFace = GL_CCW;
67 mState.rasterizer.polygonOffsetFill = false;
68 mState.rasterizer.polygonOffsetFactor = 0.0f;
69 mState.rasterizer.polygonOffsetUnits = 0.0f;
70 mState.rasterizer.pointDrawMode = false;
71 mState.rasterizer.multiSample = false;
72 mState.scissorTest = false;
73 mState.scissor.x = 0;
74 mState.scissor.y = 0;
75 mState.scissor.width = 0;
76 mState.scissor.height = 0;
77
78 mState.blend.blend = false;
79 mState.blend.sourceBlendRGB = GL_ONE;
80 mState.blend.sourceBlendAlpha = GL_ONE;
81 mState.blend.destBlendRGB = GL_ZERO;
82 mState.blend.destBlendAlpha = GL_ZERO;
83 mState.blend.blendEquationRGB = GL_FUNC_ADD;
84 mState.blend.blendEquationAlpha = GL_FUNC_ADD;
85 mState.blend.sampleAlphaToCoverage = false;
86 mState.blend.dither = true;
87
88 mState.blendColor.red = 0;
89 mState.blendColor.green = 0;
90 mState.blendColor.blue = 0;
91 mState.blendColor.alpha = 0;
92
93 mState.depthStencil.depthTest = false;
94 mState.depthStencil.depthFunc = GL_LESS;
95 mState.depthStencil.depthMask = true;
96 mState.depthStencil.stencilTest = false;
97 mState.depthStencil.stencilFunc = GL_ALWAYS;
98 mState.depthStencil.stencilMask = -1;
99 mState.depthStencil.stencilWritemask = -1;
100 mState.depthStencil.stencilBackFunc = GL_ALWAYS;
101 mState.depthStencil.stencilBackMask = - 1;
102 mState.depthStencil.stencilBackWritemask = -1;
103 mState.depthStencil.stencilFail = GL_KEEP;
104 mState.depthStencil.stencilPassDepthFail = GL_KEEP;
105 mState.depthStencil.stencilPassDepthPass = GL_KEEP;
106 mState.depthStencil.stencilBackFail = GL_KEEP;
107 mState.depthStencil.stencilBackPassDepthFail = GL_KEEP;
108 mState.depthStencil.stencilBackPassDepthPass = GL_KEEP;
109
110 mState.stencilRef = 0;
111 mState.stencilBackRef = 0;
112
113 mState.sampleCoverage = false;
114 mState.sampleCoverageValue = 1.0f;
115 mState.sampleCoverageInvert = false;
116 mState.generateMipmapHint = GL_DONT_CARE;
117 mState.fragmentShaderDerivativeHint = GL_DONT_CARE;
118
119 mState.lineWidth = 1.0f;
120
121 mState.viewport.x = 0;
122 mState.viewport.y = 0;
123 mState.viewport.width = 0;
124 mState.viewport.height = 0;
125 mState.zNear = 0.0f;
126 mState.zFar = 1.0f;
127
128 mState.blend.colorMaskRed = true;
129 mState.blend.colorMaskGreen = true;
130 mState.blend.colorMaskBlue = true;
131 mState.blend.colorMaskAlpha = true;
132
133 const GLfloat defaultFloatValues[] = { 0.0f, 0.0f, 0.0f, 1.0f };
134 for (int attribIndex = 0; attribIndex < MAX_VERTEX_ATTRIBS; attribIndex++)
135 {
136 mState.vertexAttribCurrentValues[attribIndex].setFloatValues(defaultFloatValues);
137 }
138
139 if (shareContext != NULL)
140 {
141 mResourceManager = shareContext->mResourceManager;
142 mResourceManager->addRef();
143 }
144 else
145 {
146 mResourceManager = new ResourceManager(mRenderer);
147 }
148
149 // [OpenGL ES 2.0.24] section 3.7 page 83:
150 // In the initial state, TEXTURE_2D and TEXTURE_CUBE_MAP have twodimensional
151 // and cube map texture state vectors respectively associated with them.
152 // In order that access to these initial textures not be lost, they are treated as texture
153 // objects all of whose names are 0.
154
155 mTexture2DZero.set(new Texture2D(mRenderer, 0));
156 mTextureCubeMapZero.set(new TextureCubeMap(mRenderer, 0));
157 mTexture3DZero.set(new Texture3D(mRenderer, 0));
158 mTexture2DArrayZero.set(new Texture2DArray(mRenderer, 0));
159
160 for (unsigned int textureUnit = 0; textureUnit < ArraySize(mState.samplers); textureUnit++)
161 {
162 mState.samplers[textureUnit] = 0;
163 }
164
165 mState.activeSampler = 0;
166 bindVertexArray(0);
167 bindArrayBuffer(0);
168 bindElementArrayBuffer(0);
169 bindTextureCubeMap(0);
170 bindTexture2D(0);
171 bindReadFramebuffer(0);
172 bindDrawFramebuffer(0);
173 bindRenderbuffer(0);
174
175 mState.activeQueries[GL_ANY_SAMPLES_PASSED].set(NULL);
176 mState.activeQueries[GL_ANY_SAMPLES_PASSED_CONSERVATIVE].set(NULL);
177 mState.activeQueries[GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN].set(NULL);
178
179 bindGenericUniformBuffer(0);
180 for (int i = 0; i < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; i++)
181 {
182 bindIndexedUniformBuffer(0, i, 0, -1);
183 }
184
185 bindGenericTransformFeedbackBuffer(0);
186 for (int i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
187 {
188 bindIndexedTransformFeedbackBuffer(0, i, 0, -1);
189 }
190
191 bindCopyReadBuffer(0);
192 bindCopyWriteBuffer(0);
193 bindPixelPackBuffer(0);
194 bindPixelUnpackBuffer(0);
195
196 // [OpenGL ES 3.0.2] section 2.14.1 pg 85:
197 // In the initial state, a default transform feedback object is bound and treated as
198 // a transform feedback object with a name of zero. That object is bound any time
199 // BindTransformFeedback is called with id of zero
200 mTransformFeedbackZero.set(new TransformFeedback(0));
201 bindTransformFeedback(0);
202
203 mState.currentProgram = 0;
204 mCurrentProgramBinary.set(NULL);
205
206 mCombinedExtensionsString = NULL;
207 mRendererString = NULL;
208
209 mInvalidEnum = false;
210 mInvalidValue = false;
211 mInvalidOperation = false;
212 mOutOfMemory = false;
213 mInvalidFramebufferOperation = false;
214
215 mHasBeenCurrent = false;
216 mContextLost = false;
217 mResetStatus = GL_NO_ERROR;
218 mResetStrategy = (notifyResets ? GL_LOSE_CONTEXT_ON_RESET_EXT : GL_NO_RESET_NOTIFICATION_EXT);
219 mRobustAccess = robustAccess;
220
221 mSupportsBGRATextures = false;
222 mSupportsDXT1Textures = false;
223 mSupportsDXT3Textures = false;
224 mSupportsDXT5Textures = false;
225 mSupportsEventQueries = false;
226 mSupportsOcclusionQueries = false;
227 mNumCompressedTextureFormats = 0;
228 }
229
~Context()230 Context::~Context()
231 {
232 if (mState.currentProgram != 0)
233 {
234 Program *programObject = mResourceManager->getProgram(mState.currentProgram);
235 if (programObject)
236 {
237 programObject->release();
238 }
239 mState.currentProgram = 0;
240 }
241 mCurrentProgramBinary.set(NULL);
242
243 while (!mFramebufferMap.empty())
244 {
245 deleteFramebuffer(mFramebufferMap.begin()->first);
246 }
247
248 while (!mFenceNVMap.empty())
249 {
250 deleteFenceNV(mFenceNVMap.begin()->first);
251 }
252
253 while (!mQueryMap.empty())
254 {
255 deleteQuery(mQueryMap.begin()->first);
256 }
257
258 while (!mVertexArrayMap.empty())
259 {
260 deleteVertexArray(mVertexArrayMap.begin()->first);
261 }
262
263 mTransformFeedbackZero.set(NULL);
264 while (!mTransformFeedbackMap.empty())
265 {
266 deleteTransformFeedback(mTransformFeedbackMap.begin()->first);
267 }
268
269 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++)
270 {
271 for (int sampler = 0; sampler < IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++)
272 {
273 mState.samplerTexture[type][sampler].set(NULL);
274 }
275 }
276
277 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++)
278 {
279 mIncompleteTextures[type].set(NULL);
280 }
281
282 const GLfloat defaultFloatValues[] = { 0.0f, 0.0f, 0.0f, 1.0f };
283 for (int attribIndex = 0; attribIndex < MAX_VERTEX_ATTRIBS; attribIndex++)
284 {
285 mState.vertexAttribCurrentValues[attribIndex].setFloatValues(defaultFloatValues);
286 }
287
288 mState.arrayBuffer.set(NULL);
289 mState.renderbuffer.set(NULL);
290
291 mState.transformFeedback.set(NULL);
292
293 mTexture2DZero.set(NULL);
294 mTextureCubeMapZero.set(NULL);
295 mTexture3DZero.set(NULL);
296 mTexture2DArrayZero.set(NULL);
297
298 for (State::ActiveQueryMap::iterator i = mState.activeQueries.begin(); i != mState.activeQueries.end(); i++)
299 {
300 i->second.set(NULL);
301 }
302
303 mState.genericUniformBuffer.set(NULL);
304 for (int i = 0; i < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; i++)
305 {
306 mState.uniformBuffers[i].set(NULL);
307 }
308
309 mState.genericTransformFeedbackBuffer.set(NULL);
310 for (int i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
311 {
312 mState.transformFeedbackBuffers[i].set(NULL);
313 }
314
315 mState.copyReadBuffer.set(NULL);
316 mState.copyWriteBuffer.set(NULL);
317
318 mState.pack.pixelBuffer.set(NULL);
319 mState.unpack.pixelBuffer.set(NULL);
320
321 mResourceManager->release();
322 }
323
makeCurrent(egl::Surface * surface)324 void Context::makeCurrent(egl::Surface *surface)
325 {
326 if (!mHasBeenCurrent)
327 {
328 mMajorShaderModel = mRenderer->getMajorShaderModel();
329 mMaximumPointSize = mRenderer->getMaxPointSize();
330 mSupportsVertexTexture = mRenderer->getVertexTextureSupport();
331 mSupportsNonPower2Texture = mRenderer->getNonPower2TextureSupport();
332 mSupportsInstancing = mRenderer->getInstancingSupport();
333
334 mMaxViewportDimension = mRenderer->getMaxViewportDimension();
335 mMax2DTextureDimension = std::min(std::min(mRenderer->getMaxTextureWidth(), mRenderer->getMaxTextureHeight()),
336 (int)gl::IMPLEMENTATION_MAX_2D_TEXTURE_SIZE);
337 mMaxCubeTextureDimension = std::min(mMax2DTextureDimension, (int)gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE);
338 mMax3DTextureDimension = std::min(std::min(mMax2DTextureDimension, mRenderer->getMaxTextureDepth()),
339 (int)gl::IMPLEMENTATION_MAX_3D_TEXTURE_SIZE);
340 mMax2DArrayTextureLayers = mRenderer->getMaxTextureArrayLayers();
341 mMaxRenderbufferDimension = mMax2DTextureDimension;
342 mMax2DTextureLevel = log2(mMax2DTextureDimension) + 1;
343 mMaxCubeTextureLevel = log2(mMaxCubeTextureDimension) + 1;
344 mMax3DTextureLevel = log2(mMax3DTextureDimension) + 1;
345 mMax2DArrayTextureLevel = log2(mMax2DTextureDimension) + 1;
346 mMaxTextureAnisotropy = mRenderer->getTextureMaxAnisotropy();
347 TRACE("Max2DTextureDimension=%d, MaxCubeTextureDimension=%d, Max3DTextureDimension=%d, Max2DArrayTextureLayers = %d, "
348 "Max2DTextureLevel=%d, MaxCubeTextureLevel=%d, Max3DTextureLevel=%d, Max2DArrayTextureLevel=%d, "
349 "MaxRenderbufferDimension=%d, MaxTextureAnisotropy=%f",
350 mMax2DTextureDimension, mMaxCubeTextureDimension, mMax3DTextureDimension, mMax2DArrayTextureLayers,
351 mMax2DTextureLevel, mMaxCubeTextureLevel, mMax3DTextureLevel, mMax2DArrayTextureLevel,
352 mMaxRenderbufferDimension, mMaxTextureAnisotropy);
353
354 mSupportsEventQueries = mRenderer->getEventQuerySupport();
355 mSupportsOcclusionQueries = mRenderer->getOcclusionQuerySupport();
356 mSupportsBGRATextures = mRenderer->getBGRATextureSupport();
357 mSupportsDXT1Textures = mRenderer->getDXT1TextureSupport();
358 mSupportsDXT3Textures = mRenderer->getDXT3TextureSupport();
359 mSupportsDXT5Textures = mRenderer->getDXT5TextureSupport();
360 mSupportsFloat32Textures = mRenderer->getFloat32TextureSupport();
361 mSupportsFloat32LinearFilter = mRenderer->getFloat32TextureFilteringSupport();
362 mSupportsFloat32RenderableTextures = mRenderer->getFloat32TextureRenderingSupport();
363 mSupportsFloat16Textures = mRenderer->getFloat16TextureSupport();
364 mSupportsFloat16LinearFilter = mRenderer->getFloat16TextureFilteringSupport();
365 mSupportsFloat16RenderableTextures = mRenderer->getFloat16TextureRenderingSupport();
366 mSupportsLuminanceTextures = mRenderer->getLuminanceTextureSupport();
367 mSupportsLuminanceAlphaTextures = mRenderer->getLuminanceAlphaTextureSupport();
368 mSupportsRGTextures = mRenderer->getRGTextureSupport();
369 mSupportsDepthTextures = mRenderer->getDepthTextureSupport();
370 mSupportsTextureFilterAnisotropy = mRenderer->getTextureFilterAnisotropySupport();
371 mSupports32bitIndices = mRenderer->get32BitIndexSupport();
372 mSupportsPBOs = mRenderer->getPBOSupport();
373
374 mNumCompressedTextureFormats = 0;
375 if (supportsDXT1Textures())
376 {
377 mNumCompressedTextureFormats += 2;
378 }
379 if (supportsDXT3Textures())
380 {
381 mNumCompressedTextureFormats += 1;
382 }
383 if (supportsDXT5Textures())
384 {
385 mNumCompressedTextureFormats += 1;
386 }
387
388 initExtensionString();
389 initRendererString();
390
391 mState.viewport.x = 0;
392 mState.viewport.y = 0;
393 mState.viewport.width = surface->getWidth();
394 mState.viewport.height = surface->getHeight();
395
396 mState.scissor.x = 0;
397 mState.scissor.y = 0;
398 mState.scissor.width = surface->getWidth();
399 mState.scissor.height = surface->getHeight();
400
401 mHasBeenCurrent = true;
402 }
403
404 // Wrap the existing swapchain resources into GL objects and assign them to the '0' names
405 rx::SwapChain *swapchain = surface->getSwapChain();
406
407 Colorbuffer *colorbufferZero = new Colorbuffer(mRenderer, swapchain);
408 DepthStencilbuffer *depthStencilbufferZero = new DepthStencilbuffer(mRenderer, swapchain);
409 Framebuffer *framebufferZero = new DefaultFramebuffer(mRenderer, colorbufferZero, depthStencilbufferZero);
410
411 setFramebufferZero(framebufferZero);
412
413 // Store the current client version in the renderer
414 mRenderer->setCurrentClientVersion(mClientVersion);
415 }
416
417 // NOTE: this function should not assume that this context is current!
markContextLost()418 void Context::markContextLost()
419 {
420 if (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT)
421 mResetStatus = GL_UNKNOWN_CONTEXT_RESET_EXT;
422 mContextLost = true;
423 }
424
isContextLost()425 bool Context::isContextLost()
426 {
427 return mContextLost;
428 }
429
setCap(GLenum cap,bool enabled)430 void Context::setCap(GLenum cap, bool enabled)
431 {
432 switch (cap)
433 {
434 case GL_CULL_FACE: setCullFace(enabled); break;
435 case GL_POLYGON_OFFSET_FILL: setPolygonOffsetFill(enabled); break;
436 case GL_SAMPLE_ALPHA_TO_COVERAGE: setSampleAlphaToCoverage(enabled); break;
437 case GL_SAMPLE_COVERAGE: setSampleCoverage(enabled); break;
438 case GL_SCISSOR_TEST: setScissorTest(enabled); break;
439 case GL_STENCIL_TEST: setStencilTest(enabled); break;
440 case GL_DEPTH_TEST: setDepthTest(enabled); break;
441 case GL_BLEND: setBlend(enabled); break;
442 case GL_DITHER: setDither(enabled); break;
443 case GL_PRIMITIVE_RESTART_FIXED_INDEX: UNIMPLEMENTED(); break;
444 case GL_RASTERIZER_DISCARD: setRasterizerDiscard(enabled); break;
445 default: UNREACHABLE();
446 }
447 }
448
getCap(GLenum cap)449 bool Context::getCap(GLenum cap)
450 {
451 switch (cap)
452 {
453 case GL_CULL_FACE: return isCullFaceEnabled();
454 case GL_POLYGON_OFFSET_FILL: return isPolygonOffsetFillEnabled();
455 case GL_SAMPLE_ALPHA_TO_COVERAGE: return isSampleAlphaToCoverageEnabled();
456 case GL_SAMPLE_COVERAGE: return isSampleCoverageEnabled();
457 case GL_SCISSOR_TEST: return isScissorTestEnabled();
458 case GL_STENCIL_TEST: return isStencilTestEnabled();
459 case GL_DEPTH_TEST: return isDepthTestEnabled();
460 case GL_BLEND: return isBlendEnabled();
461 case GL_DITHER: return isDitherEnabled();
462 case GL_PRIMITIVE_RESTART_FIXED_INDEX: UNIMPLEMENTED(); return false;
463 case GL_RASTERIZER_DISCARD: return isRasterizerDiscardEnabled();
464 default: UNREACHABLE(); return false;
465 }
466 }
467
setClearColor(float red,float green,float blue,float alpha)468 void Context::setClearColor(float red, float green, float blue, float alpha)
469 {
470 mState.colorClearValue.red = red;
471 mState.colorClearValue.green = green;
472 mState.colorClearValue.blue = blue;
473 mState.colorClearValue.alpha = alpha;
474 }
475
setClearDepth(float depth)476 void Context::setClearDepth(float depth)
477 {
478 mState.depthClearValue = depth;
479 }
480
setClearStencil(int stencil)481 void Context::setClearStencil(int stencil)
482 {
483 mState.stencilClearValue = stencil;
484 }
485
setRasterizerDiscard(bool enabled)486 void Context::setRasterizerDiscard(bool enabled)
487 {
488 mState.rasterizer.rasterizerDiscard = enabled;
489 }
490
isRasterizerDiscardEnabled() const491 bool Context::isRasterizerDiscardEnabled() const
492 {
493 return mState.rasterizer.rasterizerDiscard;
494 }
495
setCullFace(bool enabled)496 void Context::setCullFace(bool enabled)
497 {
498 mState.rasterizer.cullFace = enabled;
499 }
500
isCullFaceEnabled() const501 bool Context::isCullFaceEnabled() const
502 {
503 return mState.rasterizer.cullFace;
504 }
505
setCullMode(GLenum mode)506 void Context::setCullMode(GLenum mode)
507 {
508 mState.rasterizer.cullMode = mode;
509 }
510
setFrontFace(GLenum front)511 void Context::setFrontFace(GLenum front)
512 {
513 mState.rasterizer.frontFace = front;
514 }
515
setDepthTest(bool enabled)516 void Context::setDepthTest(bool enabled)
517 {
518 mState.depthStencil.depthTest = enabled;
519 }
520
isDepthTestEnabled() const521 bool Context::isDepthTestEnabled() const
522 {
523 return mState.depthStencil.depthTest;
524 }
525
setDepthFunc(GLenum depthFunc)526 void Context::setDepthFunc(GLenum depthFunc)
527 {
528 mState.depthStencil.depthFunc = depthFunc;
529 }
530
setDepthRange(float zNear,float zFar)531 void Context::setDepthRange(float zNear, float zFar)
532 {
533 mState.zNear = zNear;
534 mState.zFar = zFar;
535 }
536
setBlend(bool enabled)537 void Context::setBlend(bool enabled)
538 {
539 mState.blend.blend = enabled;
540 }
541
isBlendEnabled() const542 bool Context::isBlendEnabled() const
543 {
544 return mState.blend.blend;
545 }
546
setBlendFactors(GLenum sourceRGB,GLenum destRGB,GLenum sourceAlpha,GLenum destAlpha)547 void Context::setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha)
548 {
549 mState.blend.sourceBlendRGB = sourceRGB;
550 mState.blend.destBlendRGB = destRGB;
551 mState.blend.sourceBlendAlpha = sourceAlpha;
552 mState.blend.destBlendAlpha = destAlpha;
553 }
554
setBlendColor(float red,float green,float blue,float alpha)555 void Context::setBlendColor(float red, float green, float blue, float alpha)
556 {
557 mState.blendColor.red = red;
558 mState.blendColor.green = green;
559 mState.blendColor.blue = blue;
560 mState.blendColor.alpha = alpha;
561 }
562
setBlendEquation(GLenum rgbEquation,GLenum alphaEquation)563 void Context::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
564 {
565 mState.blend.blendEquationRGB = rgbEquation;
566 mState.blend.blendEquationAlpha = alphaEquation;
567 }
568
setStencilTest(bool enabled)569 void Context::setStencilTest(bool enabled)
570 {
571 mState.depthStencil.stencilTest = enabled;
572 }
573
isStencilTestEnabled() const574 bool Context::isStencilTestEnabled() const
575 {
576 return mState.depthStencil.stencilTest;
577 }
578
setStencilParams(GLenum stencilFunc,GLint stencilRef,GLuint stencilMask)579 void Context::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask)
580 {
581 mState.depthStencil.stencilFunc = stencilFunc;
582 mState.stencilRef = (stencilRef > 0) ? stencilRef : 0;
583 mState.depthStencil.stencilMask = stencilMask;
584 }
585
setStencilBackParams(GLenum stencilBackFunc,GLint stencilBackRef,GLuint stencilBackMask)586 void Context::setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask)
587 {
588 mState.depthStencil.stencilBackFunc = stencilBackFunc;
589 mState.stencilBackRef = (stencilBackRef > 0) ? stencilBackRef : 0;
590 mState.depthStencil.stencilBackMask = stencilBackMask;
591 }
592
setStencilWritemask(GLuint stencilWritemask)593 void Context::setStencilWritemask(GLuint stencilWritemask)
594 {
595 mState.depthStencil.stencilWritemask = stencilWritemask;
596 }
597
setStencilBackWritemask(GLuint stencilBackWritemask)598 void Context::setStencilBackWritemask(GLuint stencilBackWritemask)
599 {
600 mState.depthStencil.stencilBackWritemask = stencilBackWritemask;
601 }
602
setStencilOperations(GLenum stencilFail,GLenum stencilPassDepthFail,GLenum stencilPassDepthPass)603 void Context::setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass)
604 {
605 mState.depthStencil.stencilFail = stencilFail;
606 mState.depthStencil.stencilPassDepthFail = stencilPassDepthFail;
607 mState.depthStencil.stencilPassDepthPass = stencilPassDepthPass;
608 }
609
setStencilBackOperations(GLenum stencilBackFail,GLenum stencilBackPassDepthFail,GLenum stencilBackPassDepthPass)610 void Context::setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass)
611 {
612 mState.depthStencil.stencilBackFail = stencilBackFail;
613 mState.depthStencil.stencilBackPassDepthFail = stencilBackPassDepthFail;
614 mState.depthStencil.stencilBackPassDepthPass = stencilBackPassDepthPass;
615 }
616
setPolygonOffsetFill(bool enabled)617 void Context::setPolygonOffsetFill(bool enabled)
618 {
619 mState.rasterizer.polygonOffsetFill = enabled;
620 }
621
isPolygonOffsetFillEnabled() const622 bool Context::isPolygonOffsetFillEnabled() const
623 {
624 return mState.rasterizer.polygonOffsetFill;
625 }
626
setPolygonOffsetParams(GLfloat factor,GLfloat units)627 void Context::setPolygonOffsetParams(GLfloat factor, GLfloat units)
628 {
629 // An application can pass NaN values here, so handle this gracefully
630 mState.rasterizer.polygonOffsetFactor = factor != factor ? 0.0f : factor;
631 mState.rasterizer.polygonOffsetUnits = units != units ? 0.0f : units;
632 }
633
setSampleAlphaToCoverage(bool enabled)634 void Context::setSampleAlphaToCoverage(bool enabled)
635 {
636 mState.blend.sampleAlphaToCoverage = enabled;
637 }
638
isSampleAlphaToCoverageEnabled() const639 bool Context::isSampleAlphaToCoverageEnabled() const
640 {
641 return mState.blend.sampleAlphaToCoverage;
642 }
643
setSampleCoverage(bool enabled)644 void Context::setSampleCoverage(bool enabled)
645 {
646 mState.sampleCoverage = enabled;
647 }
648
isSampleCoverageEnabled() const649 bool Context::isSampleCoverageEnabled() const
650 {
651 return mState.sampleCoverage;
652 }
653
setSampleCoverageParams(GLclampf value,bool invert)654 void Context::setSampleCoverageParams(GLclampf value, bool invert)
655 {
656 mState.sampleCoverageValue = value;
657 mState.sampleCoverageInvert = invert;
658 }
659
setScissorTest(bool enabled)660 void Context::setScissorTest(bool enabled)
661 {
662 mState.scissorTest = enabled;
663 }
664
isScissorTestEnabled() const665 bool Context::isScissorTestEnabled() const
666 {
667 return mState.scissorTest;
668 }
669
setDither(bool enabled)670 void Context::setDither(bool enabled)
671 {
672 mState.blend.dither = enabled;
673 }
674
isDitherEnabled() const675 bool Context::isDitherEnabled() const
676 {
677 return mState.blend.dither;
678 }
679
setLineWidth(GLfloat width)680 void Context::setLineWidth(GLfloat width)
681 {
682 mState.lineWidth = width;
683 }
684
setGenerateMipmapHint(GLenum hint)685 void Context::setGenerateMipmapHint(GLenum hint)
686 {
687 mState.generateMipmapHint = hint;
688 }
689
setFragmentShaderDerivativeHint(GLenum hint)690 void Context::setFragmentShaderDerivativeHint(GLenum hint)
691 {
692 mState.fragmentShaderDerivativeHint = hint;
693 // TODO: Propagate the hint to shader translator so we can write
694 // ddx, ddx_coarse, or ddx_fine depending on the hint.
695 // Ignore for now. It is valid for implementations to ignore hint.
696 }
697
setViewportParams(GLint x,GLint y,GLsizei width,GLsizei height)698 void Context::setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height)
699 {
700 mState.viewport.x = x;
701 mState.viewport.y = y;
702 mState.viewport.width = width;
703 mState.viewport.height = height;
704 }
705
setScissorParams(GLint x,GLint y,GLsizei width,GLsizei height)706 void Context::setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height)
707 {
708 mState.scissor.x = x;
709 mState.scissor.y = y;
710 mState.scissor.width = width;
711 mState.scissor.height = height;
712 }
713
getScissorParams(GLint * x,GLint * y,GLsizei * width,GLsizei * height)714 void Context::getScissorParams(GLint *x, GLint *y, GLsizei *width, GLsizei *height)
715 {
716 *x = mState.scissor.x;
717 *y = mState.scissor.y;
718 *width = mState.scissor.width;
719 *height = mState.scissor.height;
720 }
721
setColorMask(bool red,bool green,bool blue,bool alpha)722 void Context::setColorMask(bool red, bool green, bool blue, bool alpha)
723 {
724 mState.blend.colorMaskRed = red;
725 mState.blend.colorMaskGreen = green;
726 mState.blend.colorMaskBlue = blue;
727 mState.blend.colorMaskAlpha = alpha;
728 }
729
setDepthMask(bool mask)730 void Context::setDepthMask(bool mask)
731 {
732 mState.depthStencil.depthMask = mask;
733 }
734
setActiveSampler(unsigned int active)735 void Context::setActiveSampler(unsigned int active)
736 {
737 mState.activeSampler = active;
738 }
739
getReadFramebufferHandle() const740 GLuint Context::getReadFramebufferHandle() const
741 {
742 return mState.readFramebuffer;
743 }
744
getDrawFramebufferHandle() const745 GLuint Context::getDrawFramebufferHandle() const
746 {
747 return mState.drawFramebuffer;
748 }
749
getRenderbufferHandle() const750 GLuint Context::getRenderbufferHandle() const
751 {
752 return mState.renderbuffer.id();
753 }
754
getVertexArrayHandle() const755 GLuint Context::getVertexArrayHandle() const
756 {
757 return mState.vertexArray;
758 }
759
getSamplerHandle(GLuint textureUnit) const760 GLuint Context::getSamplerHandle(GLuint textureUnit) const
761 {
762 ASSERT(textureUnit < ArraySize(mState.samplers));
763 return mState.samplers[textureUnit];
764 }
765
getActiveSampler() const766 unsigned int Context::getActiveSampler() const
767 {
768 return mState.activeSampler;
769 }
770
getArrayBufferHandle() const771 GLuint Context::getArrayBufferHandle() const
772 {
773 return mState.arrayBuffer.id();
774 }
775
isQueryActive() const776 bool Context::isQueryActive() const
777 {
778 for (State::ActiveQueryMap::const_iterator i = mState.activeQueries.begin();
779 i != mState.activeQueries.end(); i++)
780 {
781 if (i->second.get() != NULL)
782 {
783 return true;
784 }
785 }
786
787 return false;
788 }
789
getActiveQuery(GLenum target) const790 const Query *Context::getActiveQuery(GLenum target) const
791 {
792 // All query types should already exist in the activeQueries map
793 ASSERT(mState.activeQueries.find(target) != mState.activeQueries.end());
794
795 return mState.activeQueries.at(target).get();
796 }
797
getActiveQueryId(GLenum target) const798 GLuint Context::getActiveQueryId(GLenum target) const
799 {
800 const Query *query = getActiveQuery(target);
801 return (query ? query->id() : 0u);
802 }
803
setEnableVertexAttribArray(unsigned int attribNum,bool enabled)804 void Context::setEnableVertexAttribArray(unsigned int attribNum, bool enabled)
805 {
806 getCurrentVertexArray()->enableAttribute(attribNum, enabled);
807 }
808
getVertexAttribState(unsigned int attribNum) const809 const VertexAttribute &Context::getVertexAttribState(unsigned int attribNum) const
810 {
811 return getCurrentVertexArray()->getVertexAttribute(attribNum);
812 }
813
getVertexAttribCurrentValue(unsigned int attribNum) const814 const VertexAttribCurrentValueData &Context::getVertexAttribCurrentValue(unsigned int attribNum) const
815 {
816 ASSERT(attribNum < MAX_VERTEX_ATTRIBS);
817 return mState.vertexAttribCurrentValues[attribNum];
818 }
819
setVertexAttribState(unsigned int attribNum,Buffer * boundBuffer,GLint size,GLenum type,bool normalized,bool pureInteger,GLsizei stride,const void * pointer)820 void Context::setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type, bool normalized,
821 bool pureInteger, GLsizei stride, const void *pointer)
822 {
823 getCurrentVertexArray()->setAttributeState(attribNum, boundBuffer, size, type, normalized, pureInteger, stride, pointer);
824 }
825
getVertexAttribPointer(unsigned int attribNum) const826 const void *Context::getVertexAttribPointer(unsigned int attribNum) const
827 {
828 return getCurrentVertexArray()->getVertexAttribute(attribNum).mPointer;
829 }
830
setPackAlignment(GLint alignment)831 void Context::setPackAlignment(GLint alignment)
832 {
833 mState.pack.alignment = alignment;
834 }
835
getPackAlignment() const836 GLint Context::getPackAlignment() const
837 {
838 return mState.pack.alignment;
839 }
840
setUnpackAlignment(GLint alignment)841 void Context::setUnpackAlignment(GLint alignment)
842 {
843 mState.unpack.alignment = alignment;
844 }
845
getUnpackAlignment() const846 GLint Context::getUnpackAlignment() const
847 {
848 return mState.unpack.alignment;
849 }
850
setPackReverseRowOrder(bool reverseRowOrder)851 void Context::setPackReverseRowOrder(bool reverseRowOrder)
852 {
853 mState.pack.reverseRowOrder = reverseRowOrder;
854 }
855
getPackReverseRowOrder() const856 bool Context::getPackReverseRowOrder() const
857 {
858 return mState.pack.reverseRowOrder;
859 }
860
getUnpackState() const861 const PixelUnpackState &Context::getUnpackState() const
862 {
863 return mState.unpack;
864 }
865
getPackState() const866 const PixelPackState &Context::getPackState() const
867 {
868 return mState.pack;
869 }
870
createBuffer()871 GLuint Context::createBuffer()
872 {
873 return mResourceManager->createBuffer();
874 }
875
createProgram()876 GLuint Context::createProgram()
877 {
878 return mResourceManager->createProgram();
879 }
880
createShader(GLenum type)881 GLuint Context::createShader(GLenum type)
882 {
883 return mResourceManager->createShader(type);
884 }
885
createTexture()886 GLuint Context::createTexture()
887 {
888 return mResourceManager->createTexture();
889 }
890
createRenderbuffer()891 GLuint Context::createRenderbuffer()
892 {
893 return mResourceManager->createRenderbuffer();
894 }
895
createFenceSync(GLenum condition)896 GLsync Context::createFenceSync(GLenum condition)
897 {
898 GLuint handle = mResourceManager->createFenceSync();
899
900 gl::FenceSync *fenceSync = mResourceManager->getFenceSync(handle);
901 ASSERT(fenceSync);
902
903 fenceSync->set(condition);
904
905 return reinterpret_cast<GLsync>(handle);
906 }
907
createVertexArray()908 GLuint Context::createVertexArray()
909 {
910 GLuint handle = mVertexArrayHandleAllocator.allocate();
911
912 // Although the spec states VAO state is not initialized until the object is bound,
913 // we create it immediately. The resulting behaviour is transparent to the application,
914 // since it's not currently possible to access the state until the object is bound.
915 mVertexArrayMap[handle] = new VertexArray(mRenderer, handle);
916
917 return handle;
918 }
919
createSampler()920 GLuint Context::createSampler()
921 {
922 return mResourceManager->createSampler();
923 }
924
createTransformFeedback()925 GLuint Context::createTransformFeedback()
926 {
927 GLuint handle = mTransformFeedbackAllocator.allocate();
928 TransformFeedback *transformFeedback = new TransformFeedback(handle);
929 transformFeedback->addRef();
930 mTransformFeedbackMap[handle] = transformFeedback;
931 return handle;
932 }
933
934 // Returns an unused framebuffer name
createFramebuffer()935 GLuint Context::createFramebuffer()
936 {
937 GLuint handle = mFramebufferHandleAllocator.allocate();
938
939 mFramebufferMap[handle] = NULL;
940
941 return handle;
942 }
943
createFenceNV()944 GLuint Context::createFenceNV()
945 {
946 GLuint handle = mFenceNVHandleAllocator.allocate();
947
948 mFenceNVMap[handle] = new FenceNV(mRenderer);
949
950 return handle;
951 }
952
953 // Returns an unused query name
createQuery()954 GLuint Context::createQuery()
955 {
956 GLuint handle = mQueryHandleAllocator.allocate();
957
958 mQueryMap[handle] = NULL;
959
960 return handle;
961 }
962
deleteBuffer(GLuint buffer)963 void Context::deleteBuffer(GLuint buffer)
964 {
965 if (mResourceManager->getBuffer(buffer))
966 {
967 detachBuffer(buffer);
968 }
969
970 mResourceManager->deleteBuffer(buffer);
971 }
972
deleteShader(GLuint shader)973 void Context::deleteShader(GLuint shader)
974 {
975 mResourceManager->deleteShader(shader);
976 }
977
deleteProgram(GLuint program)978 void Context::deleteProgram(GLuint program)
979 {
980 mResourceManager->deleteProgram(program);
981 }
982
deleteTexture(GLuint texture)983 void Context::deleteTexture(GLuint texture)
984 {
985 if (mResourceManager->getTexture(texture))
986 {
987 detachTexture(texture);
988 }
989
990 mResourceManager->deleteTexture(texture);
991 }
992
deleteRenderbuffer(GLuint renderbuffer)993 void Context::deleteRenderbuffer(GLuint renderbuffer)
994 {
995 if (mResourceManager->getRenderbuffer(renderbuffer))
996 {
997 detachRenderbuffer(renderbuffer);
998 }
999
1000 mResourceManager->deleteRenderbuffer(renderbuffer);
1001 }
1002
deleteFenceSync(GLsync fenceSync)1003 void Context::deleteFenceSync(GLsync fenceSync)
1004 {
1005 // The spec specifies the underlying Fence object is not deleted until all current
1006 // wait commands finish. However, since the name becomes invalid, we cannot query the fence,
1007 // and since our API is currently designed for being called from a single thread, we can delete
1008 // the fence immediately.
1009 mResourceManager->deleteFenceSync(reinterpret_cast<GLuint>(fenceSync));
1010 }
1011
deleteVertexArray(GLuint vertexArray)1012 void Context::deleteVertexArray(GLuint vertexArray)
1013 {
1014 auto vertexArrayObject = mVertexArrayMap.find(vertexArray);
1015
1016 if (vertexArrayObject != mVertexArrayMap.end())
1017 {
1018 detachVertexArray(vertexArray);
1019
1020 mVertexArrayHandleAllocator.release(vertexArrayObject->first);
1021 delete vertexArrayObject->second;
1022 mVertexArrayMap.erase(vertexArrayObject);
1023 }
1024 }
1025
deleteSampler(GLuint sampler)1026 void Context::deleteSampler(GLuint sampler)
1027 {
1028 if (mResourceManager->getSampler(sampler))
1029 {
1030 detachSampler(sampler);
1031 }
1032
1033 mResourceManager->deleteSampler(sampler);
1034 }
1035
deleteTransformFeedback(GLuint transformFeedback)1036 void Context::deleteTransformFeedback(GLuint transformFeedback)
1037 {
1038 TransformFeedbackMap::const_iterator iter = mTransformFeedbackMap.find(transformFeedback);
1039 if (iter != mTransformFeedbackMap.end())
1040 {
1041 detachTransformFeedback(transformFeedback);
1042 mTransformFeedbackAllocator.release(transformFeedback);
1043 iter->second->release();
1044 mTransformFeedbackMap.erase(iter);
1045 }
1046 }
1047
deleteFramebuffer(GLuint framebuffer)1048 void Context::deleteFramebuffer(GLuint framebuffer)
1049 {
1050 FramebufferMap::iterator framebufferObject = mFramebufferMap.find(framebuffer);
1051
1052 if (framebufferObject != mFramebufferMap.end())
1053 {
1054 detachFramebuffer(framebuffer);
1055
1056 mFramebufferHandleAllocator.release(framebufferObject->first);
1057 delete framebufferObject->second;
1058 mFramebufferMap.erase(framebufferObject);
1059 }
1060 }
1061
deleteFenceNV(GLuint fence)1062 void Context::deleteFenceNV(GLuint fence)
1063 {
1064 FenceNVMap::iterator fenceObject = mFenceNVMap.find(fence);
1065
1066 if (fenceObject != mFenceNVMap.end())
1067 {
1068 mFenceNVHandleAllocator.release(fenceObject->first);
1069 delete fenceObject->second;
1070 mFenceNVMap.erase(fenceObject);
1071 }
1072 }
1073
deleteQuery(GLuint query)1074 void Context::deleteQuery(GLuint query)
1075 {
1076 QueryMap::iterator queryObject = mQueryMap.find(query);
1077 if (queryObject != mQueryMap.end())
1078 {
1079 mQueryHandleAllocator.release(queryObject->first);
1080 if (queryObject->second)
1081 {
1082 queryObject->second->release();
1083 }
1084 mQueryMap.erase(queryObject);
1085 }
1086 }
1087
getBuffer(GLuint handle)1088 Buffer *Context::getBuffer(GLuint handle)
1089 {
1090 return mResourceManager->getBuffer(handle);
1091 }
1092
getShader(GLuint handle) const1093 Shader *Context::getShader(GLuint handle) const
1094 {
1095 return mResourceManager->getShader(handle);
1096 }
1097
getProgram(GLuint handle) const1098 Program *Context::getProgram(GLuint handle) const
1099 {
1100 return mResourceManager->getProgram(handle);
1101 }
1102
getTexture(GLuint handle)1103 Texture *Context::getTexture(GLuint handle)
1104 {
1105 return mResourceManager->getTexture(handle);
1106 }
1107
getRenderbuffer(GLuint handle)1108 FramebufferAttachment *Context::getRenderbuffer(GLuint handle)
1109 {
1110 return mResourceManager->getRenderbuffer(handle);
1111 }
1112
getFenceSync(GLsync handle) const1113 FenceSync *Context::getFenceSync(GLsync handle) const
1114 {
1115 return mResourceManager->getFenceSync(reinterpret_cast<GLuint>(handle));
1116 }
1117
getVertexArray(GLuint handle) const1118 VertexArray *Context::getVertexArray(GLuint handle) const
1119 {
1120 auto vertexArray = mVertexArrayMap.find(handle);
1121
1122 if (vertexArray == mVertexArrayMap.end())
1123 {
1124 return NULL;
1125 }
1126 else
1127 {
1128 return vertexArray->second;
1129 }
1130 }
1131
getSampler(GLuint handle) const1132 Sampler *Context::getSampler(GLuint handle) const
1133 {
1134 return mResourceManager->getSampler(handle);
1135 }
1136
getTransformFeedback(GLuint handle) const1137 TransformFeedback *Context::getTransformFeedback(GLuint handle) const
1138 {
1139 if (handle == 0)
1140 {
1141 return mTransformFeedbackZero.get();
1142 }
1143 else
1144 {
1145 TransformFeedbackMap::const_iterator iter = mTransformFeedbackMap.find(handle);
1146 return (iter != mTransformFeedbackMap.end()) ? iter->second : NULL;
1147 }
1148 }
1149
getReadFramebuffer()1150 Framebuffer *Context::getReadFramebuffer()
1151 {
1152 return getFramebuffer(mState.readFramebuffer);
1153 }
1154
getDrawFramebuffer()1155 Framebuffer *Context::getDrawFramebuffer()
1156 {
1157 return mBoundDrawFramebuffer;
1158 }
1159
getCurrentVertexArray() const1160 VertexArray *Context::getCurrentVertexArray() const
1161 {
1162 VertexArray *vao = getVertexArray(mState.vertexArray);
1163 ASSERT(vao != NULL);
1164 return vao;
1165 }
1166
getCurrentTransformFeedback() const1167 TransformFeedback *Context::getCurrentTransformFeedback() const
1168 {
1169 return mState.transformFeedback.get();
1170 }
1171
isSampler(GLuint samplerName) const1172 bool Context::isSampler(GLuint samplerName) const
1173 {
1174 return mResourceManager->isSampler(samplerName);
1175 }
1176
bindArrayBuffer(unsigned int buffer)1177 void Context::bindArrayBuffer(unsigned int buffer)
1178 {
1179 mResourceManager->checkBufferAllocation(buffer);
1180
1181 mState.arrayBuffer.set(getBuffer(buffer));
1182 }
1183
bindElementArrayBuffer(unsigned int buffer)1184 void Context::bindElementArrayBuffer(unsigned int buffer)
1185 {
1186 mResourceManager->checkBufferAllocation(buffer);
1187
1188 getCurrentVertexArray()->setElementArrayBuffer(getBuffer(buffer));
1189 }
1190
bindTexture2D(GLuint texture)1191 void Context::bindTexture2D(GLuint texture)
1192 {
1193 mResourceManager->checkTextureAllocation(texture, TEXTURE_2D);
1194
1195 mState.samplerTexture[TEXTURE_2D][mState.activeSampler].set(getTexture(texture));
1196 }
1197
bindTextureCubeMap(GLuint texture)1198 void Context::bindTextureCubeMap(GLuint texture)
1199 {
1200 mResourceManager->checkTextureAllocation(texture, TEXTURE_CUBE);
1201
1202 mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].set(getTexture(texture));
1203 }
1204
bindTexture3D(GLuint texture)1205 void Context::bindTexture3D(GLuint texture)
1206 {
1207 mResourceManager->checkTextureAllocation(texture, TEXTURE_3D);
1208
1209 mState.samplerTexture[TEXTURE_3D][mState.activeSampler].set(getTexture(texture));
1210 }
1211
bindTexture2DArray(GLuint texture)1212 void Context::bindTexture2DArray(GLuint texture)
1213 {
1214 mResourceManager->checkTextureAllocation(texture, TEXTURE_2D_ARRAY);
1215
1216 mState.samplerTexture[TEXTURE_2D_ARRAY][mState.activeSampler].set(getTexture(texture));
1217 }
1218
bindReadFramebuffer(GLuint framebuffer)1219 void Context::bindReadFramebuffer(GLuint framebuffer)
1220 {
1221 if (!getFramebuffer(framebuffer))
1222 {
1223 mFramebufferMap[framebuffer] = new Framebuffer(mRenderer);
1224 }
1225
1226 mState.readFramebuffer = framebuffer;
1227 }
1228
bindDrawFramebuffer(GLuint framebuffer)1229 void Context::bindDrawFramebuffer(GLuint framebuffer)
1230 {
1231 if (!getFramebuffer(framebuffer))
1232 {
1233 mFramebufferMap[framebuffer] = new Framebuffer(mRenderer);
1234 }
1235
1236 mState.drawFramebuffer = framebuffer;
1237
1238 mBoundDrawFramebuffer = getFramebuffer(framebuffer);
1239 }
1240
bindRenderbuffer(GLuint renderbuffer)1241 void Context::bindRenderbuffer(GLuint renderbuffer)
1242 {
1243 mResourceManager->checkRenderbufferAllocation(renderbuffer);
1244
1245 mState.renderbuffer.set(getRenderbuffer(renderbuffer));
1246 }
1247
bindVertexArray(GLuint vertexArray)1248 void Context::bindVertexArray(GLuint vertexArray)
1249 {
1250 if (!getVertexArray(vertexArray))
1251 {
1252 mVertexArrayMap[vertexArray] = new VertexArray(mRenderer, vertexArray);
1253 }
1254
1255 mState.vertexArray = vertexArray;
1256 }
1257
bindSampler(GLuint textureUnit,GLuint sampler)1258 void Context::bindSampler(GLuint textureUnit, GLuint sampler)
1259 {
1260 ASSERT(textureUnit < ArraySize(mState.samplers));
1261 mResourceManager->checkSamplerAllocation(sampler);
1262
1263 mState.samplers[textureUnit] = sampler;
1264 }
1265
bindGenericUniformBuffer(GLuint buffer)1266 void Context::bindGenericUniformBuffer(GLuint buffer)
1267 {
1268 mResourceManager->checkBufferAllocation(buffer);
1269
1270 mState.genericUniformBuffer.set(getBuffer(buffer));
1271 }
1272
bindIndexedUniformBuffer(GLuint buffer,GLuint index,GLintptr offset,GLsizeiptr size)1273 void Context::bindIndexedUniformBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size)
1274 {
1275 mResourceManager->checkBufferAllocation(buffer);
1276
1277 mState.uniformBuffers[index].set(getBuffer(buffer), offset, size);
1278 }
1279
bindGenericTransformFeedbackBuffer(GLuint buffer)1280 void Context::bindGenericTransformFeedbackBuffer(GLuint buffer)
1281 {
1282 mResourceManager->checkBufferAllocation(buffer);
1283
1284 mState.genericTransformFeedbackBuffer.set(getBuffer(buffer));
1285 }
1286
bindIndexedTransformFeedbackBuffer(GLuint buffer,GLuint index,GLintptr offset,GLsizeiptr size)1287 void Context::bindIndexedTransformFeedbackBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size)
1288 {
1289 mResourceManager->checkBufferAllocation(buffer);
1290
1291 mState.transformFeedbackBuffers[index].set(getBuffer(buffer), offset, size);
1292 }
1293
bindCopyReadBuffer(GLuint buffer)1294 void Context::bindCopyReadBuffer(GLuint buffer)
1295 {
1296 mResourceManager->checkBufferAllocation(buffer);
1297
1298 mState.copyReadBuffer.set(getBuffer(buffer));
1299 }
1300
bindCopyWriteBuffer(GLuint buffer)1301 void Context::bindCopyWriteBuffer(GLuint buffer)
1302 {
1303 mResourceManager->checkBufferAllocation(buffer);
1304
1305 mState.copyWriteBuffer.set(getBuffer(buffer));
1306 }
1307
bindPixelPackBuffer(GLuint buffer)1308 void Context::bindPixelPackBuffer(GLuint buffer)
1309 {
1310 mResourceManager->checkBufferAllocation(buffer);
1311
1312 mState.pack.pixelBuffer.set(getBuffer(buffer));
1313 }
1314
bindPixelUnpackBuffer(GLuint buffer)1315 void Context::bindPixelUnpackBuffer(GLuint buffer)
1316 {
1317 mResourceManager->checkBufferAllocation(buffer);
1318
1319 mState.unpack.pixelBuffer.set(getBuffer(buffer));
1320 }
1321
useProgram(GLuint program)1322 void Context::useProgram(GLuint program)
1323 {
1324 GLuint priorProgram = mState.currentProgram;
1325 mState.currentProgram = program; // Must switch before trying to delete, otherwise it only gets flagged.
1326
1327 if (priorProgram != program)
1328 {
1329 Program *newProgram = mResourceManager->getProgram(program);
1330 Program *oldProgram = mResourceManager->getProgram(priorProgram);
1331 mCurrentProgramBinary.set(NULL);
1332
1333 if (newProgram)
1334 {
1335 newProgram->addRef();
1336 mCurrentProgramBinary.set(newProgram->getProgramBinary());
1337 }
1338
1339 if (oldProgram)
1340 {
1341 oldProgram->release();
1342 }
1343 }
1344 }
1345
linkProgram(GLuint program)1346 void Context::linkProgram(GLuint program)
1347 {
1348 Program *programObject = mResourceManager->getProgram(program);
1349
1350 bool linked = programObject->link();
1351
1352 // if the current program was relinked successfully we
1353 // need to install the new executables
1354 if (linked && program == mState.currentProgram)
1355 {
1356 mCurrentProgramBinary.set(programObject->getProgramBinary());
1357 }
1358 }
1359
setProgramBinary(GLuint program,const void * binary,GLint length)1360 void Context::setProgramBinary(GLuint program, const void *binary, GLint length)
1361 {
1362 Program *programObject = mResourceManager->getProgram(program);
1363
1364 bool loaded = programObject->setProgramBinary(binary, length);
1365
1366 // if the current program was reloaded successfully we
1367 // need to install the new executables
1368 if (loaded && program == mState.currentProgram)
1369 {
1370 mCurrentProgramBinary.set(programObject->getProgramBinary());
1371 }
1372
1373 }
1374
bindTransformFeedback(GLuint transformFeedback)1375 void Context::bindTransformFeedback(GLuint transformFeedback)
1376 {
1377 TransformFeedback *transformFeedbackObject = getTransformFeedback(transformFeedback);
1378 mState.transformFeedback.set(transformFeedbackObject);
1379 }
1380
beginQuery(GLenum target,GLuint query)1381 void Context::beginQuery(GLenum target, GLuint query)
1382 {
1383 Query *queryObject = getQuery(query, true, target);
1384 ASSERT(queryObject);
1385
1386 // set query as active for specified target
1387 mState.activeQueries[target].set(queryObject);
1388
1389 // begin query
1390 queryObject->begin();
1391 }
1392
endQuery(GLenum target)1393 void Context::endQuery(GLenum target)
1394 {
1395 Query *queryObject = mState.activeQueries[target].get();
1396 ASSERT(queryObject);
1397
1398 queryObject->end();
1399
1400 mState.activeQueries[target].set(NULL);
1401 }
1402
setFramebufferZero(Framebuffer * buffer)1403 void Context::setFramebufferZero(Framebuffer *buffer)
1404 {
1405 delete mFramebufferMap[0];
1406 mFramebufferMap[0] = buffer;
1407 if (mState.drawFramebuffer == 0)
1408 {
1409 mBoundDrawFramebuffer = buffer;
1410 }
1411 }
1412
setRenderbufferStorage(GLsizei width,GLsizei height,GLenum internalformat,GLsizei samples)1413 void Context::setRenderbufferStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples)
1414 {
1415 const bool color = gl::IsColorRenderingSupported(internalformat, this);
1416 const bool depth = gl::IsDepthRenderingSupported(internalformat, this);
1417 const bool stencil = gl::IsStencilRenderingSupported(internalformat, this);
1418
1419 RenderbufferStorage *renderbuffer = NULL;
1420
1421 if (color)
1422 {
1423 renderbuffer = new gl::Colorbuffer(mRenderer,width, height, internalformat, samples);
1424 }
1425 else if (depth && stencil)
1426 {
1427 renderbuffer = new gl::DepthStencilbuffer(mRenderer, width, height, samples);
1428 }
1429 else if (depth)
1430 {
1431 renderbuffer = new gl::Depthbuffer(mRenderer, width, height, samples);
1432 }
1433 else if (stencil)
1434 {
1435 renderbuffer = new gl::Stencilbuffer(mRenderer, width, height, samples);
1436 }
1437 else
1438 {
1439 UNREACHABLE();
1440 return;
1441 }
1442
1443 FramebufferAttachment *renderbufferObject = mState.renderbuffer.get();
1444 renderbufferObject->setStorage(renderbuffer);
1445 }
1446
getFramebuffer(unsigned int handle) const1447 Framebuffer *Context::getFramebuffer(unsigned int handle) const
1448 {
1449 FramebufferMap::const_iterator framebuffer = mFramebufferMap.find(handle);
1450
1451 if (framebuffer == mFramebufferMap.end())
1452 {
1453 return NULL;
1454 }
1455 else
1456 {
1457 return framebuffer->second;
1458 }
1459 }
1460
getFenceNV(unsigned int handle)1461 FenceNV *Context::getFenceNV(unsigned int handle)
1462 {
1463 FenceNVMap::iterator fence = mFenceNVMap.find(handle);
1464
1465 if (fence == mFenceNVMap.end())
1466 {
1467 return NULL;
1468 }
1469 else
1470 {
1471 return fence->second;
1472 }
1473 }
1474
getQuery(unsigned int handle,bool create,GLenum type)1475 Query *Context::getQuery(unsigned int handle, bool create, GLenum type)
1476 {
1477 QueryMap::iterator query = mQueryMap.find(handle);
1478
1479 if (query == mQueryMap.end())
1480 {
1481 return NULL;
1482 }
1483 else
1484 {
1485 if (!query->second && create)
1486 {
1487 query->second = new Query(mRenderer, type, handle);
1488 query->second->addRef();
1489 }
1490 return query->second;
1491 }
1492 }
1493
getTargetBuffer(GLenum target) const1494 Buffer *Context::getTargetBuffer(GLenum target) const
1495 {
1496 switch (target)
1497 {
1498 case GL_ARRAY_BUFFER: return mState.arrayBuffer.get();
1499 case GL_COPY_READ_BUFFER: return mState.copyReadBuffer.get();
1500 case GL_COPY_WRITE_BUFFER: return mState.copyWriteBuffer.get();
1501 case GL_ELEMENT_ARRAY_BUFFER: return getCurrentVertexArray()->getElementArrayBuffer();
1502 case GL_PIXEL_PACK_BUFFER: return mState.pack.pixelBuffer.get();
1503 case GL_PIXEL_UNPACK_BUFFER: return mState.unpack.pixelBuffer.get();
1504 case GL_TRANSFORM_FEEDBACK_BUFFER: return mState.genericTransformFeedbackBuffer.get();
1505 case GL_UNIFORM_BUFFER: return mState.genericUniformBuffer.get();
1506 default: UNREACHABLE(); return NULL;
1507 }
1508 }
1509
getArrayBuffer()1510 Buffer *Context::getArrayBuffer()
1511 {
1512 return mState.arrayBuffer.get();
1513 }
1514
getElementArrayBuffer() const1515 Buffer *Context::getElementArrayBuffer() const
1516 {
1517 return getCurrentVertexArray()->getElementArrayBuffer();
1518 }
1519
getCurrentProgramBinary()1520 ProgramBinary *Context::getCurrentProgramBinary()
1521 {
1522 return mCurrentProgramBinary.get();
1523 }
1524
getTargetTexture(GLenum target) const1525 Texture *Context::getTargetTexture(GLenum target) const
1526 {
1527 if (!ValidTextureTarget(this, target))
1528 {
1529 return NULL;
1530 }
1531
1532 switch (target)
1533 {
1534 case GL_TEXTURE_2D: return getTexture2D();
1535 case GL_TEXTURE_CUBE_MAP: return getTextureCubeMap();
1536 case GL_TEXTURE_3D: return getTexture3D();
1537 case GL_TEXTURE_2D_ARRAY: return getTexture2DArray();
1538 default: return NULL;
1539 }
1540 }
1541
getTargetFramebufferHandle(GLenum target) const1542 GLuint Context::getTargetFramebufferHandle(GLenum target) const
1543 {
1544 if (!ValidFramebufferTarget(target))
1545 {
1546 return GL_INVALID_INDEX;
1547 }
1548
1549 if (target == GL_READ_FRAMEBUFFER_ANGLE)
1550 {
1551 return mState.readFramebuffer;
1552 }
1553 else
1554 {
1555 return mState.drawFramebuffer;
1556 }
1557 }
1558
getTargetFramebuffer(GLenum target) const1559 Framebuffer *Context::getTargetFramebuffer(GLenum target) const
1560 {
1561 GLuint framebufferHandle = getTargetFramebufferHandle(target);
1562 return (framebufferHandle == GL_INVALID_INDEX ? NULL : getFramebuffer(framebufferHandle));
1563 }
1564
getTexture2D() const1565 Texture2D *Context::getTexture2D() const
1566 {
1567 return static_cast<Texture2D*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D));
1568 }
1569
getTextureCubeMap() const1570 TextureCubeMap *Context::getTextureCubeMap() const
1571 {
1572 return static_cast<TextureCubeMap*>(getSamplerTexture(mState.activeSampler, TEXTURE_CUBE));
1573 }
1574
getTexture3D() const1575 Texture3D *Context::getTexture3D() const
1576 {
1577 return static_cast<Texture3D*>(getSamplerTexture(mState.activeSampler, TEXTURE_3D));
1578 }
1579
getTexture2DArray() const1580 Texture2DArray *Context::getTexture2DArray() const
1581 {
1582 return static_cast<Texture2DArray*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D_ARRAY));
1583 }
1584
getGenericUniformBuffer()1585 Buffer *Context::getGenericUniformBuffer()
1586 {
1587 return mState.genericUniformBuffer.get();
1588 }
1589
getGenericTransformFeedbackBuffer()1590 Buffer *Context::getGenericTransformFeedbackBuffer()
1591 {
1592 return mState.genericTransformFeedbackBuffer.get();
1593 }
1594
getCopyReadBuffer()1595 Buffer *Context::getCopyReadBuffer()
1596 {
1597 return mState.copyReadBuffer.get();
1598 }
1599
getCopyWriteBuffer()1600 Buffer *Context::getCopyWriteBuffer()
1601 {
1602 return mState.copyWriteBuffer.get();
1603 }
1604
getPixelPackBuffer()1605 Buffer *Context::getPixelPackBuffer()
1606 {
1607 return mState.pack.pixelBuffer.get();
1608 }
1609
getPixelUnpackBuffer()1610 Buffer *Context::getPixelUnpackBuffer()
1611 {
1612 return mState.unpack.pixelBuffer.get();
1613 }
1614
getSamplerTexture(unsigned int sampler,TextureType type) const1615 Texture *Context::getSamplerTexture(unsigned int sampler, TextureType type) const
1616 {
1617 GLuint texid = mState.samplerTexture[type][sampler].id();
1618
1619 if (texid == 0) // Special case: 0 refers to different initial textures based on the target
1620 {
1621 switch (type)
1622 {
1623 default: UNREACHABLE();
1624 case TEXTURE_2D: return mTexture2DZero.get();
1625 case TEXTURE_CUBE: return mTextureCubeMapZero.get();
1626 case TEXTURE_3D: return mTexture3DZero.get();
1627 case TEXTURE_2D_ARRAY: return mTexture2DArrayZero.get();
1628 }
1629 }
1630
1631 return mState.samplerTexture[type][sampler].get();
1632 }
1633
getBooleanv(GLenum pname,GLboolean * params)1634 void Context::getBooleanv(GLenum pname, GLboolean *params)
1635 {
1636 switch (pname)
1637 {
1638 case GL_SHADER_COMPILER: *params = GL_TRUE; break;
1639 case GL_SAMPLE_COVERAGE_INVERT: *params = mState.sampleCoverageInvert; break;
1640 case GL_DEPTH_WRITEMASK: *params = mState.depthStencil.depthMask; break;
1641 case GL_COLOR_WRITEMASK:
1642 params[0] = mState.blend.colorMaskRed;
1643 params[1] = mState.blend.colorMaskGreen;
1644 params[2] = mState.blend.colorMaskBlue;
1645 params[3] = mState.blend.colorMaskAlpha;
1646 break;
1647 case GL_CULL_FACE: *params = mState.rasterizer.cullFace; break;
1648 case GL_POLYGON_OFFSET_FILL: *params = mState.rasterizer.polygonOffsetFill; break;
1649 case GL_SAMPLE_ALPHA_TO_COVERAGE: *params = mState.blend.sampleAlphaToCoverage; break;
1650 case GL_SAMPLE_COVERAGE: *params = mState.sampleCoverage; break;
1651 case GL_SCISSOR_TEST: *params = mState.scissorTest; break;
1652 case GL_STENCIL_TEST: *params = mState.depthStencil.stencilTest; break;
1653 case GL_DEPTH_TEST: *params = mState.depthStencil.depthTest; break;
1654 case GL_BLEND: *params = mState.blend.blend; break;
1655 case GL_DITHER: *params = mState.blend.dither; break;
1656 case GL_CONTEXT_ROBUST_ACCESS_EXT: *params = mRobustAccess ? GL_TRUE : GL_FALSE; break;
1657 case GL_TRANSFORM_FEEDBACK_ACTIVE: *params = getCurrentTransformFeedback()->isStarted(); break;
1658 case GL_TRANSFORM_FEEDBACK_PAUSED: *params = getCurrentTransformFeedback()->isPaused(); break;
1659 default:
1660 UNREACHABLE();
1661 break;
1662 }
1663 }
1664
getFloatv(GLenum pname,GLfloat * params)1665 void Context::getFloatv(GLenum pname, GLfloat *params)
1666 {
1667 // Please note: DEPTH_CLEAR_VALUE is included in our internal getFloatv implementation
1668 // because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1669 // GetIntegerv as its native query function. As it would require conversion in any
1670 // case, this should make no difference to the calling application.
1671 switch (pname)
1672 {
1673 case GL_LINE_WIDTH: *params = mState.lineWidth; break;
1674 case GL_SAMPLE_COVERAGE_VALUE: *params = mState.sampleCoverageValue; break;
1675 case GL_DEPTH_CLEAR_VALUE: *params = mState.depthClearValue; break;
1676 case GL_POLYGON_OFFSET_FACTOR: *params = mState.rasterizer.polygonOffsetFactor; break;
1677 case GL_POLYGON_OFFSET_UNITS: *params = mState.rasterizer.polygonOffsetUnits; break;
1678 case GL_ALIASED_LINE_WIDTH_RANGE:
1679 params[0] = gl::ALIASED_LINE_WIDTH_RANGE_MIN;
1680 params[1] = gl::ALIASED_LINE_WIDTH_RANGE_MAX;
1681 break;
1682 case GL_ALIASED_POINT_SIZE_RANGE:
1683 params[0] = gl::ALIASED_POINT_SIZE_RANGE_MIN;
1684 params[1] = getMaximumPointSize();
1685 break;
1686 case GL_DEPTH_RANGE:
1687 params[0] = mState.zNear;
1688 params[1] = mState.zFar;
1689 break;
1690 case GL_COLOR_CLEAR_VALUE:
1691 params[0] = mState.colorClearValue.red;
1692 params[1] = mState.colorClearValue.green;
1693 params[2] = mState.colorClearValue.blue;
1694 params[3] = mState.colorClearValue.alpha;
1695 break;
1696 case GL_BLEND_COLOR:
1697 params[0] = mState.blendColor.red;
1698 params[1] = mState.blendColor.green;
1699 params[2] = mState.blendColor.blue;
1700 params[3] = mState.blendColor.alpha;
1701 break;
1702 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
1703 ASSERT(supportsTextureFilterAnisotropy());
1704 *params = mMaxTextureAnisotropy;
1705 break;
1706 default:
1707 UNREACHABLE();
1708 break;
1709 }
1710 }
1711
getIntegerv(GLenum pname,GLint * params)1712 void Context::getIntegerv(GLenum pname, GLint *params)
1713 {
1714 if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT)
1715 {
1716 unsigned int colorAttachment = (pname - GL_DRAW_BUFFER0_EXT);
1717 ASSERT(colorAttachment < mRenderer->getMaxRenderTargets());
1718 Framebuffer *framebuffer = getDrawFramebuffer();
1719 *params = framebuffer->getDrawBufferState(colorAttachment);
1720 return;
1721 }
1722
1723 // Please note: DEPTH_CLEAR_VALUE is not included in our internal getIntegerv implementation
1724 // because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1725 // GetIntegerv as its native query function. As it would require conversion in any
1726 // case, this should make no difference to the calling application. You may find it in
1727 // Context::getFloatv.
1728 switch (pname)
1729 {
1730 case GL_MAX_VERTEX_ATTRIBS: *params = gl::MAX_VERTEX_ATTRIBS; break;
1731 case GL_MAX_VERTEX_UNIFORM_VECTORS: *params = mRenderer->getMaxVertexUniformVectors(); break;
1732 case GL_MAX_VERTEX_UNIFORM_COMPONENTS: *params = mRenderer->getMaxVertexUniformVectors() * 4; break;
1733 case GL_MAX_VARYING_VECTORS: *params = mRenderer->getMaxVaryingVectors(); break;
1734 case GL_MAX_VARYING_COMPONENTS: *params = mRenderer->getMaxVaryingVectors() * 4; break;
1735 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: *params = mRenderer->getMaxCombinedTextureImageUnits(); break;
1736 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: *params = mRenderer->getMaxVertexTextureImageUnits(); break;
1737 case GL_MAX_TEXTURE_IMAGE_UNITS: *params = gl::MAX_TEXTURE_IMAGE_UNITS; break;
1738 case GL_MAX_FRAGMENT_UNIFORM_VECTORS: *params = mRenderer->getMaxFragmentUniformVectors(); break;
1739 case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS: *params = mRenderer->getMaxFragmentUniformVectors() * 4; break;
1740 case GL_MAX_RENDERBUFFER_SIZE: *params = getMaximumRenderbufferDimension(); break;
1741 case GL_MAX_COLOR_ATTACHMENTS_EXT: *params = mRenderer->getMaxRenderTargets(); break;
1742 case GL_MAX_DRAW_BUFFERS_EXT: *params = mRenderer->getMaxRenderTargets(); break;
1743 case GL_NUM_SHADER_BINARY_FORMATS: *params = 0; break;
1744 case GL_SHADER_BINARY_FORMATS: /* no shader binary formats are supported */ break;
1745 case GL_ARRAY_BUFFER_BINDING: *params = mState.arrayBuffer.id(); break;
1746 case GL_ELEMENT_ARRAY_BUFFER_BINDING: *params = getCurrentVertexArray()->getElementArrayBufferId(); break;
1747 //case GL_FRAMEBUFFER_BINDING: // now equivalent to GL_DRAW_FRAMEBUFFER_BINDING_ANGLE
1748 case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE: *params = mState.drawFramebuffer; break;
1749 case GL_READ_FRAMEBUFFER_BINDING_ANGLE: *params = mState.readFramebuffer; break;
1750 case GL_RENDERBUFFER_BINDING: *params = mState.renderbuffer.id(); break;
1751 case GL_VERTEX_ARRAY_BINDING: *params = mState.vertexArray; break;
1752 case GL_CURRENT_PROGRAM: *params = mState.currentProgram; break;
1753 case GL_PACK_ALIGNMENT: *params = mState.pack.alignment; break;
1754 case GL_PACK_REVERSE_ROW_ORDER_ANGLE: *params = mState.pack.reverseRowOrder; break;
1755 case GL_UNPACK_ALIGNMENT: *params = mState.unpack.alignment; break;
1756 case GL_GENERATE_MIPMAP_HINT: *params = mState.generateMipmapHint; break;
1757 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: *params = mState.fragmentShaderDerivativeHint; break;
1758 case GL_ACTIVE_TEXTURE: *params = (mState.activeSampler + GL_TEXTURE0); break;
1759 case GL_STENCIL_FUNC: *params = mState.depthStencil.stencilFunc; break;
1760 case GL_STENCIL_REF: *params = mState.stencilRef; break;
1761 case GL_STENCIL_VALUE_MASK: *params = clampToInt(mState.depthStencil.stencilMask); break;
1762 case GL_STENCIL_BACK_FUNC: *params = mState.depthStencil.stencilBackFunc; break;
1763 case GL_STENCIL_BACK_REF: *params = mState.stencilBackRef; break;
1764 case GL_STENCIL_BACK_VALUE_MASK: *params = clampToInt(mState.depthStencil.stencilBackMask); break;
1765 case GL_STENCIL_FAIL: *params = mState.depthStencil.stencilFail; break;
1766 case GL_STENCIL_PASS_DEPTH_FAIL: *params = mState.depthStencil.stencilPassDepthFail; break;
1767 case GL_STENCIL_PASS_DEPTH_PASS: *params = mState.depthStencil.stencilPassDepthPass; break;
1768 case GL_STENCIL_BACK_FAIL: *params = mState.depthStencil.stencilBackFail; break;
1769 case GL_STENCIL_BACK_PASS_DEPTH_FAIL: *params = mState.depthStencil.stencilBackPassDepthFail; break;
1770 case GL_STENCIL_BACK_PASS_DEPTH_PASS: *params = mState.depthStencil.stencilBackPassDepthPass; break;
1771 case GL_DEPTH_FUNC: *params = mState.depthStencil.depthFunc; break;
1772 case GL_BLEND_SRC_RGB: *params = mState.blend.sourceBlendRGB; break;
1773 case GL_BLEND_SRC_ALPHA: *params = mState.blend.sourceBlendAlpha; break;
1774 case GL_BLEND_DST_RGB: *params = mState.blend.destBlendRGB; break;
1775 case GL_BLEND_DST_ALPHA: *params = mState.blend.destBlendAlpha; break;
1776 case GL_BLEND_EQUATION_RGB: *params = mState.blend.blendEquationRGB; break;
1777 case GL_BLEND_EQUATION_ALPHA: *params = mState.blend.blendEquationAlpha; break;
1778 case GL_STENCIL_WRITEMASK: *params = clampToInt(mState.depthStencil.stencilWritemask); break;
1779 case GL_STENCIL_BACK_WRITEMASK: *params = clampToInt(mState.depthStencil.stencilBackWritemask); break;
1780 case GL_STENCIL_CLEAR_VALUE: *params = mState.stencilClearValue; break;
1781 case GL_SUBPIXEL_BITS: *params = 4; break;
1782 case GL_MAX_TEXTURE_SIZE: *params = getMaximum2DTextureDimension(); break;
1783 case GL_MAX_CUBE_MAP_TEXTURE_SIZE: *params = getMaximumCubeTextureDimension(); break;
1784 case GL_MAX_3D_TEXTURE_SIZE: *params = getMaximum3DTextureDimension(); break;
1785 case GL_MAX_ARRAY_TEXTURE_LAYERS: *params = getMaximum2DArrayTextureLayers(); break;
1786 case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: *params = getUniformBufferOffsetAlignment(); break;
1787 case GL_MAX_UNIFORM_BUFFER_BINDINGS: *params = getMaximumCombinedUniformBufferBindings(); break;
1788 case GL_MAX_VERTEX_UNIFORM_BLOCKS: *params = mRenderer->getMaxVertexShaderUniformBuffers(); break;
1789 case GL_MAX_FRAGMENT_UNIFORM_BLOCKS: *params = mRenderer->getMaxFragmentShaderUniformBuffers(); break;
1790 case GL_MAX_COMBINED_UNIFORM_BLOCKS: *params = getMaximumCombinedUniformBufferBindings(); break;
1791 case GL_MAJOR_VERSION: *params = mClientVersion; break;
1792 case GL_MINOR_VERSION: *params = 0; break;
1793 case GL_MAX_ELEMENTS_INDICES: *params = mRenderer->getMaxRecommendedElementsIndices(); break;
1794 case GL_MAX_ELEMENTS_VERTICES: *params = mRenderer->getMaxRecommendedElementsVertices(); break;
1795 case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: *params = mRenderer->getMaxTransformFeedbackInterleavedComponents(); break;
1796 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: *params = mRenderer->getMaxTransformFeedbackBuffers(); break;
1797 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: *params = mRenderer->getMaxTransformFeedbackSeparateComponents(); break;
1798 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1799 params[0] = mNumCompressedTextureFormats;
1800 break;
1801 case GL_MAX_SAMPLES_ANGLE:
1802 *params = static_cast<GLint>(getMaxSupportedSamples());
1803 break;
1804 case GL_SAMPLE_BUFFERS:
1805 case GL_SAMPLES:
1806 {
1807 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1808 if (framebuffer->completeness() == GL_FRAMEBUFFER_COMPLETE)
1809 {
1810 switch (pname)
1811 {
1812 case GL_SAMPLE_BUFFERS:
1813 if (framebuffer->getSamples() != 0)
1814 {
1815 *params = 1;
1816 }
1817 else
1818 {
1819 *params = 0;
1820 }
1821 break;
1822 case GL_SAMPLES:
1823 *params = framebuffer->getSamples();
1824 break;
1825 }
1826 }
1827 else
1828 {
1829 *params = 0;
1830 }
1831 }
1832 break;
1833 case GL_IMPLEMENTATION_COLOR_READ_TYPE:
1834 case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
1835 {
1836 GLenum internalFormat, format, type;
1837 getCurrentReadFormatType(&internalFormat, &format, &type);
1838 if (pname == GL_IMPLEMENTATION_COLOR_READ_FORMAT)
1839 *params = format;
1840 else
1841 *params = type;
1842 }
1843 break;
1844 case GL_MAX_VIEWPORT_DIMS:
1845 {
1846 params[0] = mMaxViewportDimension;
1847 params[1] = mMaxViewportDimension;
1848 }
1849 break;
1850 case GL_COMPRESSED_TEXTURE_FORMATS:
1851 {
1852 if (supportsDXT1Textures())
1853 {
1854 *params++ = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
1855 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
1856 }
1857 if (supportsDXT3Textures())
1858 {
1859 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE;
1860 }
1861 if (supportsDXT5Textures())
1862 {
1863 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE;
1864 }
1865 }
1866 break;
1867 case GL_VIEWPORT:
1868 params[0] = mState.viewport.x;
1869 params[1] = mState.viewport.y;
1870 params[2] = mState.viewport.width;
1871 params[3] = mState.viewport.height;
1872 break;
1873 case GL_SCISSOR_BOX:
1874 params[0] = mState.scissor.x;
1875 params[1] = mState.scissor.y;
1876 params[2] = mState.scissor.width;
1877 params[3] = mState.scissor.height;
1878 break;
1879 case GL_CULL_FACE_MODE: *params = mState.rasterizer.cullMode; break;
1880 case GL_FRONT_FACE: *params = mState.rasterizer.frontFace; break;
1881 case GL_RED_BITS:
1882 case GL_GREEN_BITS:
1883 case GL_BLUE_BITS:
1884 case GL_ALPHA_BITS:
1885 {
1886 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1887 gl::FramebufferAttachment *colorbuffer = framebuffer->getFirstColorbuffer();
1888
1889 if (colorbuffer)
1890 {
1891 switch (pname)
1892 {
1893 case GL_RED_BITS: *params = colorbuffer->getRedSize(); break;
1894 case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); break;
1895 case GL_BLUE_BITS: *params = colorbuffer->getBlueSize(); break;
1896 case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); break;
1897 }
1898 }
1899 else
1900 {
1901 *params = 0;
1902 }
1903 }
1904 break;
1905 case GL_DEPTH_BITS:
1906 {
1907 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1908 gl::FramebufferAttachment *depthbuffer = framebuffer->getDepthbuffer();
1909
1910 if (depthbuffer)
1911 {
1912 *params = depthbuffer->getDepthSize();
1913 }
1914 else
1915 {
1916 *params = 0;
1917 }
1918 }
1919 break;
1920 case GL_STENCIL_BITS:
1921 {
1922 gl::Framebuffer *framebuffer = getDrawFramebuffer();
1923 gl::FramebufferAttachment *stencilbuffer = framebuffer->getStencilbuffer();
1924
1925 if (stencilbuffer)
1926 {
1927 *params = stencilbuffer->getStencilSize();
1928 }
1929 else
1930 {
1931 *params = 0;
1932 }
1933 }
1934 break;
1935 case GL_TEXTURE_BINDING_2D:
1936 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits());
1937 *params = mState.samplerTexture[TEXTURE_2D][mState.activeSampler].id();
1938 break;
1939 case GL_TEXTURE_BINDING_CUBE_MAP:
1940 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits());
1941 *params = mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].id();
1942 break;
1943 case GL_TEXTURE_BINDING_3D:
1944 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits());
1945 *params = mState.samplerTexture[TEXTURE_3D][mState.activeSampler].id();
1946 break;
1947 case GL_TEXTURE_BINDING_2D_ARRAY:
1948 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits());
1949 *params = mState.samplerTexture[TEXTURE_2D_ARRAY][mState.activeSampler].id();
1950 break;
1951 case GL_RESET_NOTIFICATION_STRATEGY_EXT:
1952 *params = mResetStrategy;
1953 break;
1954 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
1955 *params = 1;
1956 break;
1957 case GL_PROGRAM_BINARY_FORMATS_OES:
1958 *params = GL_PROGRAM_BINARY_ANGLE;
1959 break;
1960 case GL_UNIFORM_BUFFER_BINDING:
1961 *params = mState.genericUniformBuffer.id();
1962 break;
1963 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
1964 *params = mState.genericTransformFeedbackBuffer.id();
1965 break;
1966 case GL_COPY_READ_BUFFER_BINDING:
1967 *params = mState.copyReadBuffer.id();
1968 break;
1969 case GL_COPY_WRITE_BUFFER_BINDING:
1970 *params = mState.copyWriteBuffer.id();
1971 break;
1972 case GL_PIXEL_PACK_BUFFER_BINDING:
1973 *params = mState.pack.pixelBuffer.id();
1974 break;
1975 case GL_PIXEL_UNPACK_BUFFER_BINDING:
1976 *params = mState.unpack.pixelBuffer.id();
1977 break;
1978 case GL_NUM_EXTENSIONS:
1979 *params = static_cast<GLint>(getNumExtensions());
1980 break;
1981 default:
1982 UNREACHABLE();
1983 break;
1984 }
1985 }
1986
getInteger64v(GLenum pname,GLint64 * params)1987 void Context::getInteger64v(GLenum pname, GLint64 *params)
1988 {
1989 switch (pname)
1990 {
1991 case GL_MAX_ELEMENT_INDEX:
1992 *params = static_cast<GLint64>(std::numeric_limits<unsigned int>::max());
1993 break;
1994 case GL_MAX_UNIFORM_BLOCK_SIZE:
1995 *params = static_cast<GLint64>(mRenderer->getMaxUniformBufferSize());
1996 break;
1997 case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
1998 {
1999 GLint64 uniformBufferComponents = static_cast<GLint64>(mRenderer->getMaxVertexShaderUniformBuffers()) * static_cast<GLint64>(mRenderer->getMaxUniformBufferSize() / 4);
2000 GLint64 defaultBufferComponents = static_cast<GLint64>(mRenderer->getMaxVertexUniformVectors() * 4);
2001 *params = uniformBufferComponents + defaultBufferComponents;
2002 }
2003 break;
2004 case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
2005 {
2006 GLint64 uniformBufferComponents = static_cast<GLint64>(mRenderer->getMaxFragmentShaderUniformBuffers()) * static_cast<GLint64>(mRenderer->getMaxUniformBufferSize() / 4);
2007 GLint64 defaultBufferComponents = static_cast<GLint64>(mRenderer->getMaxVertexUniformVectors() * 4);
2008 *params = uniformBufferComponents + defaultBufferComponents;
2009 }
2010 break;
2011 case GL_MAX_SERVER_WAIT_TIMEOUT:
2012 // We do not wait for server fence objects internally, so report a max timeout of zero.
2013 *params = 0;
2014 break;
2015 default:
2016 UNREACHABLE();
2017 break;
2018 }
2019 }
2020
getIndexedIntegerv(GLenum target,GLuint index,GLint * data)2021 bool Context::getIndexedIntegerv(GLenum target, GLuint index, GLint *data)
2022 {
2023 switch (target)
2024 {
2025 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2026 if (index < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS)
2027 {
2028 *data = mState.transformFeedbackBuffers[index].id();
2029 }
2030 break;
2031 case GL_UNIFORM_BUFFER_BINDING:
2032 if (index < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS)
2033 {
2034 *data = mState.uniformBuffers[index].id();
2035 }
2036 break;
2037 default:
2038 return false;
2039 }
2040
2041 return true;
2042 }
2043
getIndexedInteger64v(GLenum target,GLuint index,GLint64 * data)2044 bool Context::getIndexedInteger64v(GLenum target, GLuint index, GLint64 *data)
2045 {
2046 switch (target)
2047 {
2048 case GL_TRANSFORM_FEEDBACK_BUFFER_START:
2049 if (index < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS)
2050 {
2051 *data = mState.transformFeedbackBuffers[index].getOffset();
2052 }
2053 break;
2054 case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
2055 if (index < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS)
2056 {
2057 *data = mState.transformFeedbackBuffers[index].getSize();
2058 }
2059 break;
2060 case GL_UNIFORM_BUFFER_START:
2061 if (index < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS)
2062 {
2063 *data = mState.uniformBuffers[index].getOffset();
2064 }
2065 break;
2066 case GL_UNIFORM_BUFFER_SIZE:
2067 if (index < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS)
2068 {
2069 *data = mState.uniformBuffers[index].getSize();
2070 }
2071 break;
2072 default:
2073 return false;
2074 }
2075
2076 return true;
2077 }
2078
getQueryParameterInfo(GLenum pname,GLenum * type,unsigned int * numParams)2079 bool Context::getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams)
2080 {
2081 if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT)
2082 {
2083 *type = GL_INT;
2084 *numParams = 1;
2085 return true;
2086 }
2087
2088 // Please note: the query type returned for DEPTH_CLEAR_VALUE in this implementation
2089 // is FLOAT rather than INT, as would be suggested by the GL ES 2.0 spec. This is due
2090 // to the fact that it is stored internally as a float, and so would require conversion
2091 // if returned from Context::getIntegerv. Since this conversion is already implemented
2092 // in the case that one calls glGetIntegerv to retrieve a float-typed state variable, we
2093 // place DEPTH_CLEAR_VALUE with the floats. This should make no difference to the calling
2094 // application.
2095 switch (pname)
2096 {
2097 case GL_COMPRESSED_TEXTURE_FORMATS:
2098 {
2099 *type = GL_INT;
2100 *numParams = mNumCompressedTextureFormats;
2101 }
2102 return true;
2103 case GL_SHADER_BINARY_FORMATS:
2104 {
2105 *type = GL_INT;
2106 *numParams = 0;
2107 }
2108 return true;
2109 case GL_MAX_VERTEX_ATTRIBS:
2110 case GL_MAX_VERTEX_UNIFORM_VECTORS:
2111 case GL_MAX_VARYING_VECTORS:
2112 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
2113 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
2114 case GL_MAX_TEXTURE_IMAGE_UNITS:
2115 case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
2116 case GL_MAX_RENDERBUFFER_SIZE:
2117 case GL_MAX_COLOR_ATTACHMENTS_EXT:
2118 case GL_MAX_DRAW_BUFFERS_EXT:
2119 case GL_NUM_SHADER_BINARY_FORMATS:
2120 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
2121 case GL_ARRAY_BUFFER_BINDING:
2122 //case GL_FRAMEBUFFER_BINDING: // equivalent to DRAW_FRAMEBUFFER_BINDING_ANGLE
2123 case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE:
2124 case GL_READ_FRAMEBUFFER_BINDING_ANGLE:
2125 case GL_RENDERBUFFER_BINDING:
2126 case GL_CURRENT_PROGRAM:
2127 case GL_PACK_ALIGNMENT:
2128 case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
2129 case GL_UNPACK_ALIGNMENT:
2130 case GL_GENERATE_MIPMAP_HINT:
2131 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
2132 case GL_RED_BITS:
2133 case GL_GREEN_BITS:
2134 case GL_BLUE_BITS:
2135 case GL_ALPHA_BITS:
2136 case GL_DEPTH_BITS:
2137 case GL_STENCIL_BITS:
2138 case GL_ELEMENT_ARRAY_BUFFER_BINDING:
2139 case GL_CULL_FACE_MODE:
2140 case GL_FRONT_FACE:
2141 case GL_ACTIVE_TEXTURE:
2142 case GL_STENCIL_FUNC:
2143 case GL_STENCIL_VALUE_MASK:
2144 case GL_STENCIL_REF:
2145 case GL_STENCIL_FAIL:
2146 case GL_STENCIL_PASS_DEPTH_FAIL:
2147 case GL_STENCIL_PASS_DEPTH_PASS:
2148 case GL_STENCIL_BACK_FUNC:
2149 case GL_STENCIL_BACK_VALUE_MASK:
2150 case GL_STENCIL_BACK_REF:
2151 case GL_STENCIL_BACK_FAIL:
2152 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
2153 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
2154 case GL_DEPTH_FUNC:
2155 case GL_BLEND_SRC_RGB:
2156 case GL_BLEND_SRC_ALPHA:
2157 case GL_BLEND_DST_RGB:
2158 case GL_BLEND_DST_ALPHA:
2159 case GL_BLEND_EQUATION_RGB:
2160 case GL_BLEND_EQUATION_ALPHA:
2161 case GL_STENCIL_WRITEMASK:
2162 case GL_STENCIL_BACK_WRITEMASK:
2163 case GL_STENCIL_CLEAR_VALUE:
2164 case GL_SUBPIXEL_BITS:
2165 case GL_MAX_TEXTURE_SIZE:
2166 case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
2167 case GL_SAMPLE_BUFFERS:
2168 case GL_SAMPLES:
2169 case GL_IMPLEMENTATION_COLOR_READ_TYPE:
2170 case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
2171 case GL_TEXTURE_BINDING_2D:
2172 case GL_TEXTURE_BINDING_CUBE_MAP:
2173 case GL_RESET_NOTIFICATION_STRATEGY_EXT:
2174 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
2175 case GL_PROGRAM_BINARY_FORMATS_OES:
2176 {
2177 *type = GL_INT;
2178 *numParams = 1;
2179 }
2180 return true;
2181 case GL_MAX_SAMPLES_ANGLE:
2182 {
2183 if (getMaxSupportedSamples() != 0)
2184 {
2185 *type = GL_INT;
2186 *numParams = 1;
2187 }
2188 else
2189 {
2190 return false;
2191 }
2192 }
2193 return true;
2194 case GL_PIXEL_PACK_BUFFER_BINDING:
2195 case GL_PIXEL_UNPACK_BUFFER_BINDING:
2196 {
2197 if (supportsPBOs())
2198 {
2199 *type = GL_INT;
2200 *numParams = 1;
2201 }
2202 else
2203 {
2204 return false;
2205 }
2206 }
2207 return true;
2208 case GL_MAX_VIEWPORT_DIMS:
2209 {
2210 *type = GL_INT;
2211 *numParams = 2;
2212 }
2213 return true;
2214 case GL_VIEWPORT:
2215 case GL_SCISSOR_BOX:
2216 {
2217 *type = GL_INT;
2218 *numParams = 4;
2219 }
2220 return true;
2221 case GL_SHADER_COMPILER:
2222 case GL_SAMPLE_COVERAGE_INVERT:
2223 case GL_DEPTH_WRITEMASK:
2224 case GL_CULL_FACE: // CULL_FACE through DITHER are natural to IsEnabled,
2225 case GL_POLYGON_OFFSET_FILL: // but can be retrieved through the Get{Type}v queries.
2226 case GL_SAMPLE_ALPHA_TO_COVERAGE: // For this purpose, they are treated here as bool-natural
2227 case GL_SAMPLE_COVERAGE:
2228 case GL_SCISSOR_TEST:
2229 case GL_STENCIL_TEST:
2230 case GL_DEPTH_TEST:
2231 case GL_BLEND:
2232 case GL_DITHER:
2233 case GL_CONTEXT_ROBUST_ACCESS_EXT:
2234 {
2235 *type = GL_BOOL;
2236 *numParams = 1;
2237 }
2238 return true;
2239 case GL_COLOR_WRITEMASK:
2240 {
2241 *type = GL_BOOL;
2242 *numParams = 4;
2243 }
2244 return true;
2245 case GL_POLYGON_OFFSET_FACTOR:
2246 case GL_POLYGON_OFFSET_UNITS:
2247 case GL_SAMPLE_COVERAGE_VALUE:
2248 case GL_DEPTH_CLEAR_VALUE:
2249 case GL_LINE_WIDTH:
2250 {
2251 *type = GL_FLOAT;
2252 *numParams = 1;
2253 }
2254 return true;
2255 case GL_ALIASED_LINE_WIDTH_RANGE:
2256 case GL_ALIASED_POINT_SIZE_RANGE:
2257 case GL_DEPTH_RANGE:
2258 {
2259 *type = GL_FLOAT;
2260 *numParams = 2;
2261 }
2262 return true;
2263 case GL_COLOR_CLEAR_VALUE:
2264 case GL_BLEND_COLOR:
2265 {
2266 *type = GL_FLOAT;
2267 *numParams = 4;
2268 }
2269 return true;
2270 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
2271 if (!supportsTextureFilterAnisotropy())
2272 {
2273 return false;
2274 }
2275 *type = GL_FLOAT;
2276 *numParams = 1;
2277 return true;
2278 }
2279
2280 if (mClientVersion < 3)
2281 {
2282 return false;
2283 }
2284
2285 // Check for ES3.0+ parameter names
2286 switch (pname)
2287 {
2288 case GL_MAX_UNIFORM_BUFFER_BINDINGS:
2289 case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
2290 case GL_UNIFORM_BUFFER_BINDING:
2291 case GL_TRANSFORM_FEEDBACK_BINDING:
2292 case GL_COPY_READ_BUFFER_BINDING:
2293 case GL_COPY_WRITE_BUFFER_BINDING:
2294 case GL_TEXTURE_BINDING_3D:
2295 case GL_TEXTURE_BINDING_2D_ARRAY:
2296 case GL_MAX_3D_TEXTURE_SIZE:
2297 case GL_MAX_ARRAY_TEXTURE_LAYERS:
2298 case GL_MAX_VERTEX_UNIFORM_BLOCKS:
2299 case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
2300 case GL_MAX_COMBINED_UNIFORM_BLOCKS:
2301 case GL_MAX_VARYING_COMPONENTS:
2302 case GL_VERTEX_ARRAY_BINDING:
2303 case GL_MAX_VERTEX_UNIFORM_COMPONENTS:
2304 case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
2305 case GL_NUM_EXTENSIONS:
2306 case GL_MAJOR_VERSION:
2307 case GL_MINOR_VERSION:
2308 case GL_MAX_ELEMENTS_INDICES:
2309 case GL_MAX_ELEMENTS_VERTICES:
2310 case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
2311 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
2312 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
2313 {
2314 *type = GL_INT;
2315 *numParams = 1;
2316 }
2317 return true;
2318
2319 case GL_MAX_ELEMENT_INDEX:
2320 case GL_MAX_UNIFORM_BLOCK_SIZE:
2321 case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
2322 case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
2323 case GL_MAX_SERVER_WAIT_TIMEOUT:
2324 {
2325 *type = GL_INT_64_ANGLEX;
2326 *numParams = 1;
2327 }
2328 return true;
2329
2330 case GL_TRANSFORM_FEEDBACK_ACTIVE:
2331 case GL_TRANSFORM_FEEDBACK_PAUSED:
2332 {
2333 *type = GL_BOOL;
2334 *numParams = 1;
2335 }
2336 return true;
2337 }
2338
2339 return false;
2340 }
2341
getIndexedQueryParameterInfo(GLenum target,GLenum * type,unsigned int * numParams)2342 bool Context::getIndexedQueryParameterInfo(GLenum target, GLenum *type, unsigned int *numParams)
2343 {
2344 if (mClientVersion < 3)
2345 {
2346 return false;
2347 }
2348
2349 switch (target)
2350 {
2351 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2352 case GL_UNIFORM_BUFFER_BINDING:
2353 {
2354 *type = GL_INT;
2355 *numParams = 1;
2356 }
2357 return true;
2358 case GL_TRANSFORM_FEEDBACK_BUFFER_START:
2359 case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
2360 case GL_UNIFORM_BUFFER_START:
2361 case GL_UNIFORM_BUFFER_SIZE:
2362 {
2363 *type = GL_INT_64_ANGLEX;
2364 *numParams = 1;
2365 }
2366 }
2367
2368 return false;
2369 }
2370
2371 // Applies the render target surface, depth stencil surface, viewport rectangle and
2372 // scissor rectangle to the renderer
applyRenderTarget(GLenum drawMode,bool ignoreViewport)2373 bool Context::applyRenderTarget(GLenum drawMode, bool ignoreViewport)
2374 {
2375 Framebuffer *framebufferObject = getDrawFramebuffer();
2376
2377 if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
2378 {
2379 return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
2380 }
2381
2382 mRenderer->applyRenderTarget(framebufferObject);
2383
2384 if (!mRenderer->setViewport(mState.viewport, mState.zNear, mState.zFar, drawMode, mState.rasterizer.frontFace,
2385 ignoreViewport))
2386 {
2387 return false;
2388 }
2389
2390 mRenderer->setScissorRectangle(mState.scissor, mState.scissorTest);
2391
2392 return true;
2393 }
2394
2395 // Applies the fixed-function state (culling, depth test, alpha blending, stenciling, etc) to the Direct3D 9 device
applyState(GLenum drawMode)2396 void Context::applyState(GLenum drawMode)
2397 {
2398 Framebuffer *framebufferObject = getDrawFramebuffer();
2399 int samples = framebufferObject->getSamples();
2400
2401 mState.rasterizer.pointDrawMode = (drawMode == GL_POINTS);
2402 mState.rasterizer.multiSample = (samples != 0);
2403 mRenderer->setRasterizerState(mState.rasterizer);
2404
2405 unsigned int mask = 0;
2406 if (mState.sampleCoverage)
2407 {
2408 if (mState.sampleCoverageValue != 0)
2409 {
2410
2411 float threshold = 0.5f;
2412
2413 for (int i = 0; i < samples; ++i)
2414 {
2415 mask <<= 1;
2416
2417 if ((i + 1) * mState.sampleCoverageValue >= threshold)
2418 {
2419 threshold += 1.0f;
2420 mask |= 1;
2421 }
2422 }
2423 }
2424
2425 if (mState.sampleCoverageInvert)
2426 {
2427 mask = ~mask;
2428 }
2429 }
2430 else
2431 {
2432 mask = 0xFFFFFFFF;
2433 }
2434 mRenderer->setBlendState(framebufferObject, mState.blend, mState.blendColor, mask);
2435
2436 mRenderer->setDepthStencilState(mState.depthStencil, mState.stencilRef, mState.stencilBackRef,
2437 mState.rasterizer.frontFace == GL_CCW);
2438 }
2439
2440 // Applies the shaders and shader constants to the Direct3D 9 device
applyShaders(ProgramBinary * programBinary,bool transformFeedbackActive)2441 void Context::applyShaders(ProgramBinary *programBinary, bool transformFeedbackActive)
2442 {
2443 const VertexAttribute *vertexAttributes = getCurrentVertexArray()->getVertexAttributes();
2444
2445 VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS];
2446 VertexFormat::GetInputLayout(inputLayout, programBinary, vertexAttributes, mState.vertexAttribCurrentValues);
2447
2448 mRenderer->applyShaders(programBinary, mState.rasterizer.rasterizerDiscard, transformFeedbackActive, inputLayout);
2449
2450 programBinary->applyUniforms();
2451 }
2452
getCurrentTexturesAndSamplerStates(ProgramBinary * programBinary,SamplerType type,Texture ** outTextures,TextureType * outTextureTypes,SamplerState * outSamplers)2453 size_t Context::getCurrentTexturesAndSamplerStates(ProgramBinary *programBinary, SamplerType type, Texture **outTextures,
2454 TextureType *outTextureTypes, SamplerState *outSamplers)
2455 {
2456 size_t samplerRange = programBinary->getUsedSamplerRange(type);
2457 for (size_t i = 0; i < samplerRange; i++)
2458 {
2459 outTextureTypes[i] = programBinary->getSamplerTextureType(type, i);
2460 GLint textureUnit = programBinary->getSamplerMapping(type, i); // OpenGL texture image unit index
2461 if (textureUnit != -1)
2462 {
2463 outTextures[i] = getSamplerTexture(textureUnit, outTextureTypes[i]);
2464 outTextures[i]->getSamplerState(&outSamplers[i]);
2465 if (mState.samplers[textureUnit] != 0)
2466 {
2467 Sampler *samplerObject = getSampler(mState.samplers[textureUnit]);
2468 samplerObject->getState(&outSamplers[i]);
2469 }
2470 }
2471 else
2472 {
2473 outTextures[i] = NULL;
2474 }
2475 }
2476
2477 return samplerRange;
2478 }
2479
generateSwizzles(Texture * textures[],size_t count)2480 void Context::generateSwizzles(Texture *textures[], size_t count)
2481 {
2482 for (size_t i = 0; i < count; i++)
2483 {
2484 if (textures[i] && textures[i]->isSwizzled())
2485 {
2486 mRenderer->generateSwizzle(textures[i]);
2487 }
2488 }
2489 }
2490
2491 // For each Direct3D sampler of either the pixel or vertex stage,
2492 // looks up the corresponding OpenGL texture image unit and texture type,
2493 // and sets the texture and its addressing/filtering state (or NULL when inactive).
applyTextures(SamplerType shaderType,Texture * textures[],TextureType * textureTypes,SamplerState * samplers,size_t textureCount,const FramebufferTextureSerialArray & framebufferSerials,size_t framebufferSerialCount)2494 void Context::applyTextures(SamplerType shaderType, Texture *textures[], TextureType *textureTypes, SamplerState *samplers,
2495 size_t textureCount, const FramebufferTextureSerialArray& framebufferSerials,
2496 size_t framebufferSerialCount)
2497 {
2498 // Range of Direct3D samplers of given sampler type
2499 size_t samplerCount = (shaderType == SAMPLER_PIXEL) ? MAX_TEXTURE_IMAGE_UNITS
2500 : mRenderer->getMaxVertexTextureImageUnits();
2501
2502 for (size_t samplerIndex = 0; samplerIndex < textureCount; samplerIndex++)
2503 {
2504 Texture *texture = textures[samplerIndex];
2505 const SamplerState &sampler = samplers[samplerIndex];
2506 TextureType textureType = textureTypes[samplerIndex];
2507
2508 if (texture)
2509 {
2510 // TODO: std::binary_search may become unavailable using older versions of GCC
2511 if (texture->isSamplerComplete(sampler) &&
2512 !std::binary_search(framebufferSerials.begin(), framebufferSerials.begin() + framebufferSerialCount, texture->getTextureSerial()))
2513 {
2514 mRenderer->setSamplerState(shaderType, samplerIndex, sampler);
2515 mRenderer->setTexture(shaderType, samplerIndex, texture);
2516 texture->resetDirty();
2517 }
2518 else
2519 {
2520 Texture *incompleteTexture = getIncompleteTexture(textureType);
2521 mRenderer->setTexture(shaderType, samplerIndex, incompleteTexture);
2522 incompleteTexture->resetDirty();
2523 }
2524 }
2525 else
2526 {
2527 mRenderer->setTexture(shaderType, samplerIndex, NULL);
2528 }
2529 }
2530
2531 for (size_t samplerIndex = textureCount; samplerIndex < samplerCount; samplerIndex++)
2532 {
2533 mRenderer->setTexture(shaderType, samplerIndex, NULL);
2534 }
2535 }
2536
applyUniformBuffers()2537 bool Context::applyUniformBuffers()
2538 {
2539 Program *programObject = getProgram(mState.currentProgram);
2540 ProgramBinary *programBinary = programObject->getProgramBinary();
2541
2542 std::vector<gl::Buffer*> boundBuffers;
2543
2544 for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < programBinary->getActiveUniformBlockCount(); uniformBlockIndex++)
2545 {
2546 GLuint blockBinding = programObject->getUniformBlockBinding(uniformBlockIndex);
2547 const OffsetBindingPointer<Buffer>& boundBuffer = mState.uniformBuffers[blockBinding];
2548 if (boundBuffer.id() == 0)
2549 {
2550 // undefined behaviour
2551 return false;
2552 }
2553 else
2554 {
2555 gl::Buffer *uniformBuffer = boundBuffer.get();
2556 ASSERT(uniformBuffer);
2557 boundBuffers.push_back(uniformBuffer);
2558 }
2559 }
2560
2561 return programBinary->applyUniformBuffers(boundBuffers);
2562 }
2563
applyTransformFeedbackBuffers()2564 bool Context::applyTransformFeedbackBuffers()
2565 {
2566 TransformFeedback *curTransformFeedback = getCurrentTransformFeedback();
2567 if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused())
2568 {
2569 Buffer *transformFeedbackBuffers[IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS];
2570 GLintptr transformFeedbackOffsets[IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS];
2571 for (size_t i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
2572 {
2573 transformFeedbackBuffers[i] = mState.transformFeedbackBuffers[i].get();
2574 transformFeedbackOffsets[i] = mState.transformFeedbackBuffers[i].getOffset();
2575 }
2576 mRenderer->applyTransformFeedbackBuffers(transformFeedbackBuffers, transformFeedbackOffsets);
2577 return true;
2578 }
2579 else
2580 {
2581 return false;
2582 }
2583 }
2584
markTransformFeedbackUsage()2585 void Context::markTransformFeedbackUsage()
2586 {
2587 for (size_t i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
2588 {
2589 Buffer *buffer = mState.transformFeedbackBuffers[i].get();
2590 if (buffer)
2591 {
2592 buffer->markTransformFeedbackUsage();
2593 }
2594 }
2595 }
2596
clear(GLbitfield mask)2597 void Context::clear(GLbitfield mask)
2598 {
2599 if (isRasterizerDiscardEnabled())
2600 {
2601 return;
2602 }
2603
2604 ClearParameters clearParams = { 0 };
2605 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2606 {
2607 clearParams.clearColor[i] = false;
2608 }
2609 clearParams.colorFClearValue = mState.colorClearValue;
2610 clearParams.colorClearType = GL_FLOAT;
2611 clearParams.colorMaskRed = mState.blend.colorMaskRed;
2612 clearParams.colorMaskGreen = mState.blend.colorMaskGreen;
2613 clearParams.colorMaskBlue = mState.blend.colorMaskBlue;
2614 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha;
2615 clearParams.clearDepth = false;
2616 clearParams.depthClearValue = mState.depthClearValue;
2617 clearParams.clearStencil = false;
2618 clearParams.stencilClearValue = mState.stencilClearValue;
2619 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask;
2620 clearParams.scissorEnabled = mState.scissorTest;
2621 clearParams.scissor = mState.scissor;
2622
2623 Framebuffer *framebufferObject = getDrawFramebuffer();
2624 if (mask & GL_COLOR_BUFFER_BIT)
2625 {
2626 if (framebufferObject->hasEnabledColorAttachment())
2627 {
2628 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2629 {
2630 clearParams.clearColor[i] = true;
2631 }
2632 }
2633 }
2634
2635 if (mask & GL_DEPTH_BUFFER_BIT)
2636 {
2637 if (mState.depthStencil.depthMask && framebufferObject->getDepthbufferType() != GL_NONE)
2638 {
2639 clearParams.clearDepth = true;
2640 }
2641 }
2642
2643 if (mask & GL_STENCIL_BUFFER_BIT)
2644 {
2645 if (framebufferObject->getStencilbufferType() != GL_NONE)
2646 {
2647 rx::RenderTarget *depthStencil = framebufferObject->getStencilbuffer()->getDepthStencil();
2648 if (!depthStencil)
2649 {
2650 ERR("Depth stencil pointer unexpectedly null.");
2651 return;
2652 }
2653
2654 if (gl::GetStencilBits(depthStencil->getActualFormat(), mClientVersion) > 0)
2655 {
2656 clearParams.clearStencil = true;
2657 }
2658 }
2659 }
2660
2661
2662 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport
2663 {
2664 return;
2665 }
2666
2667 mRenderer->clear(clearParams, framebufferObject);
2668 }
2669
clearBufferfv(GLenum buffer,int drawbuffer,const float * values)2670 void Context::clearBufferfv(GLenum buffer, int drawbuffer, const float *values)
2671 {
2672 if (isRasterizerDiscardEnabled())
2673 {
2674 return;
2675 }
2676
2677 // glClearBufferfv can be called to clear the color buffer or depth buffer
2678 ClearParameters clearParams = { 0 };
2679
2680 if (buffer == GL_COLOR)
2681 {
2682 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2683 {
2684 clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
2685 }
2686 clearParams.colorFClearValue = ColorF(values[0], values[1], values[2], values[3]);
2687 clearParams.colorClearType = GL_FLOAT;
2688 }
2689 else
2690 {
2691 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2692 {
2693 clearParams.clearColor[i] = false;
2694 }
2695 clearParams.colorFClearValue = mState.colorClearValue;
2696 clearParams.colorClearType = GL_FLOAT;
2697 }
2698
2699 clearParams.colorMaskRed = mState.blend.colorMaskRed;
2700 clearParams.colorMaskGreen = mState.blend.colorMaskGreen;
2701 clearParams.colorMaskBlue = mState.blend.colorMaskBlue;
2702 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha;
2703
2704 if (buffer == GL_DEPTH)
2705 {
2706 clearParams.clearDepth = true;
2707 clearParams.depthClearValue = values[0];
2708 }
2709 else
2710 {
2711 clearParams.clearDepth = false;
2712 clearParams.depthClearValue = mState.depthClearValue;
2713 }
2714
2715 clearParams.clearStencil = false;
2716 clearParams.stencilClearValue = mState.stencilClearValue;
2717 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask;
2718 clearParams.scissorEnabled = mState.scissorTest;
2719 clearParams.scissor = mState.scissor;
2720
2721 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport
2722 {
2723 return;
2724 }
2725
2726 mRenderer->clear(clearParams, getDrawFramebuffer());
2727 }
2728
clearBufferuiv(GLenum buffer,int drawbuffer,const unsigned int * values)2729 void Context::clearBufferuiv(GLenum buffer, int drawbuffer, const unsigned int *values)
2730 {
2731 if (isRasterizerDiscardEnabled())
2732 {
2733 return;
2734 }
2735
2736 // glClearBufferuv can only be called to clear a color buffer
2737 ClearParameters clearParams = { 0 };
2738 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2739 {
2740 clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
2741 }
2742 clearParams.colorUIClearValue = ColorUI(values[0], values[1], values[2], values[3]);
2743 clearParams.colorClearType = GL_UNSIGNED_INT;
2744 clearParams.colorMaskRed = mState.blend.colorMaskRed;
2745 clearParams.colorMaskGreen = mState.blend.colorMaskGreen;
2746 clearParams.colorMaskBlue = mState.blend.colorMaskBlue;
2747 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha;
2748 clearParams.clearDepth = false;
2749 clearParams.depthClearValue = mState.depthClearValue;
2750 clearParams.clearStencil = false;
2751 clearParams.stencilClearValue = mState.stencilClearValue;
2752 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask;
2753 clearParams.scissorEnabled = mState.scissorTest;
2754 clearParams.scissor = mState.scissor;
2755
2756 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport
2757 {
2758 return;
2759 }
2760
2761 mRenderer->clear(clearParams, getDrawFramebuffer());
2762 }
2763
clearBufferiv(GLenum buffer,int drawbuffer,const int * values)2764 void Context::clearBufferiv(GLenum buffer, int drawbuffer, const int *values)
2765 {
2766 if (isRasterizerDiscardEnabled())
2767 {
2768 return;
2769 }
2770
2771 // glClearBufferfv can be called to clear the color buffer or stencil buffer
2772 ClearParameters clearParams = { 0 };
2773
2774 if (buffer == GL_COLOR)
2775 {
2776 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2777 {
2778 clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
2779 }
2780 clearParams.colorIClearValue = ColorI(values[0], values[1], values[2], values[3]);
2781 clearParams.colorClearType = GL_INT;
2782 }
2783 else
2784 {
2785 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2786 {
2787 clearParams.clearColor[i] = false;
2788 }
2789 clearParams.colorFClearValue = mState.colorClearValue;
2790 clearParams.colorClearType = GL_FLOAT;
2791 }
2792
2793 clearParams.colorMaskRed = mState.blend.colorMaskRed;
2794 clearParams.colorMaskGreen = mState.blend.colorMaskGreen;
2795 clearParams.colorMaskBlue = mState.blend.colorMaskBlue;
2796 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha;
2797
2798 clearParams.clearDepth = false;
2799 clearParams.depthClearValue = mState.depthClearValue;
2800
2801 if (buffer == GL_STENCIL)
2802 {
2803 clearParams.clearStencil = true;
2804 clearParams.stencilClearValue = values[1];
2805 }
2806 else
2807 {
2808 clearParams.clearStencil = false;
2809 clearParams.stencilClearValue = mState.stencilClearValue;
2810 }
2811 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask;
2812
2813 clearParams.scissorEnabled = mState.scissorTest;
2814 clearParams.scissor = mState.scissor;
2815
2816 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport
2817 {
2818 return;
2819 }
2820
2821 mRenderer->clear(clearParams, getDrawFramebuffer());
2822 }
2823
clearBufferfi(GLenum buffer,int drawbuffer,float depth,int stencil)2824 void Context::clearBufferfi(GLenum buffer, int drawbuffer, float depth, int stencil)
2825 {
2826 if (isRasterizerDiscardEnabled())
2827 {
2828 return;
2829 }
2830
2831 // glClearBufferfi can only be called to clear a depth stencil buffer
2832 ClearParameters clearParams = { 0 };
2833 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
2834 {
2835 clearParams.clearColor[i] = false;
2836 }
2837 clearParams.colorFClearValue = mState.colorClearValue;
2838 clearParams.colorClearType = GL_FLOAT;
2839 clearParams.colorMaskRed = mState.blend.colorMaskRed;
2840 clearParams.colorMaskGreen = mState.blend.colorMaskGreen;
2841 clearParams.colorMaskBlue = mState.blend.colorMaskBlue;
2842 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha;
2843 clearParams.clearDepth = true;
2844 clearParams.depthClearValue = depth;
2845 clearParams.clearStencil = true;
2846 clearParams.stencilClearValue = stencil;
2847 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask;
2848 clearParams.scissorEnabled = mState.scissorTest;
2849 clearParams.scissor = mState.scissor;
2850
2851 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport
2852 {
2853 return;
2854 }
2855
2856 mRenderer->clear(clearParams, getDrawFramebuffer());
2857 }
2858
readPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei * bufSize,void * pixels)2859 void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
2860 GLenum format, GLenum type, GLsizei *bufSize, void* pixels)
2861 {
2862 gl::Framebuffer *framebuffer = getReadFramebuffer();
2863
2864 bool isSized = IsSizedInternalFormat(format, mClientVersion);
2865 GLenum sizedInternalFormat = (isSized ? format : GetSizedInternalFormat(format, type, mClientVersion));
2866 GLuint outputPitch = GetRowPitch(sizedInternalFormat, type, mClientVersion, width, mState.pack.alignment);
2867
2868 mRenderer->readPixels(framebuffer, x, y, width, height, format, type, outputPitch, mState.pack, pixels);
2869 }
2870
drawArrays(GLenum mode,GLint first,GLsizei count,GLsizei instances)2871 void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances)
2872 {
2873 if (!mState.currentProgram)
2874 {
2875 return gl::error(GL_INVALID_OPERATION);
2876 }
2877
2878 ProgramBinary *programBinary = getCurrentProgramBinary();
2879 programBinary->applyUniforms();
2880
2881 Texture *vsTextures[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
2882 TextureType vsTextureTypes[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
2883 SamplerState vsSamplers[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
2884 size_t vsTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers);
2885
2886 Texture *psTextures[MAX_TEXTURE_IMAGE_UNITS];
2887 TextureType psTextureTypes[MAX_TEXTURE_IMAGE_UNITS];
2888 SamplerState psSamplers[MAX_TEXTURE_IMAGE_UNITS];
2889 size_t psTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers);
2890
2891 generateSwizzles(vsTextures, vsTextureCount);
2892 generateSwizzles(psTextures, psTextureCount);
2893
2894 if (!mRenderer->applyPrimitiveType(mode, count))
2895 {
2896 return;
2897 }
2898
2899 if (!applyRenderTarget(mode, false))
2900 {
2901 return;
2902 }
2903
2904 applyState(mode);
2905
2906 GLenum err = mRenderer->applyVertexBuffer(programBinary, getCurrentVertexArray()->getVertexAttributes(), mState.vertexAttribCurrentValues, first, count, instances);
2907 if (err != GL_NO_ERROR)
2908 {
2909 return gl::error(err);
2910 }
2911
2912 bool transformFeedbackActive = applyTransformFeedbackBuffers();
2913
2914 applyShaders(programBinary, transformFeedbackActive);
2915
2916 FramebufferTextureSerialArray frameBufferSerials;
2917 size_t framebufferSerialCount = getBoundFramebufferTextureSerials(&frameBufferSerials);
2918
2919 applyTextures(SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers, vsTextureCount, frameBufferSerials, framebufferSerialCount);
2920 applyTextures(SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers, psTextureCount, frameBufferSerials, framebufferSerialCount);
2921
2922 if (!applyUniformBuffers())
2923 {
2924 return;
2925 }
2926
2927 if (!programBinary->validateSamplers(NULL))
2928 {
2929 return gl::error(GL_INVALID_OPERATION);
2930 }
2931
2932 if (!skipDraw(mode))
2933 {
2934 mRenderer->drawArrays(mode, count, instances, transformFeedbackActive);
2935
2936 if (transformFeedbackActive)
2937 {
2938 markTransformFeedbackUsage();
2939 }
2940 }
2941 }
2942
drawElements(GLenum mode,GLsizei count,GLenum type,const GLvoid * indices,GLsizei instances)2943 void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instances)
2944 {
2945 if (!mState.currentProgram)
2946 {
2947 return gl::error(GL_INVALID_OPERATION);
2948 }
2949
2950 VertexArray *vao = getCurrentVertexArray();
2951 if (!indices && !vao->getElementArrayBuffer())
2952 {
2953 return gl::error(GL_INVALID_OPERATION);
2954 }
2955
2956 ProgramBinary *programBinary = getCurrentProgramBinary();
2957 programBinary->applyUniforms();
2958
2959 Texture *vsTextures[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
2960 TextureType vsTextureTypes[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
2961 SamplerState vsSamplers[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
2962 size_t vsTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers);
2963
2964 Texture *psTextures[MAX_TEXTURE_IMAGE_UNITS];
2965 TextureType psTextureTypes[MAX_TEXTURE_IMAGE_UNITS];
2966 SamplerState psSamplers[MAX_TEXTURE_IMAGE_UNITS];
2967 size_t psTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers);
2968
2969 generateSwizzles(vsTextures, vsTextureCount);
2970 generateSwizzles(psTextures, psTextureCount);
2971
2972 if (!mRenderer->applyPrimitiveType(mode, count))
2973 {
2974 return;
2975 }
2976
2977 if (!applyRenderTarget(mode, false))
2978 {
2979 return;
2980 }
2981
2982 applyState(mode);
2983
2984 rx::TranslatedIndexData indexInfo;
2985 GLenum err = mRenderer->applyIndexBuffer(indices, vao->getElementArrayBuffer(), count, mode, type, &indexInfo);
2986 if (err != GL_NO_ERROR)
2987 {
2988 return gl::error(err);
2989 }
2990
2991 GLsizei vertexCount = indexInfo.maxIndex - indexInfo.minIndex + 1;
2992 err = mRenderer->applyVertexBuffer(programBinary, vao->getVertexAttributes(), mState.vertexAttribCurrentValues, indexInfo.minIndex, vertexCount, instances);
2993 if (err != GL_NO_ERROR)
2994 {
2995 return gl::error(err);
2996 }
2997
2998 bool transformFeedbackActive = applyTransformFeedbackBuffers();
2999 // Transform feedback is not allowed for DrawElements, this error should have been caught at the API validation
3000 // layer.
3001 ASSERT(!transformFeedbackActive);
3002
3003 applyShaders(programBinary, transformFeedbackActive);
3004
3005 FramebufferTextureSerialArray frameBufferSerials;
3006 size_t framebufferSerialCount = getBoundFramebufferTextureSerials(&frameBufferSerials);
3007
3008 applyTextures(SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers, vsTextureCount, frameBufferSerials, framebufferSerialCount);
3009 applyTextures(SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers, psTextureCount, frameBufferSerials, framebufferSerialCount);
3010
3011 if (!applyUniformBuffers())
3012 {
3013 return;
3014 }
3015
3016 if (!programBinary->validateSamplers(NULL))
3017 {
3018 return gl::error(GL_INVALID_OPERATION);
3019 }
3020
3021 if (!skipDraw(mode))
3022 {
3023 mRenderer->drawElements(mode, count, type, indices, vao->getElementArrayBuffer(), indexInfo, instances);
3024 }
3025 }
3026
3027 // Implements glFlush when block is false, glFinish when block is true
sync(bool block)3028 void Context::sync(bool block)
3029 {
3030 mRenderer->sync(block);
3031 }
3032
recordInvalidEnum()3033 void Context::recordInvalidEnum()
3034 {
3035 mInvalidEnum = true;
3036 }
3037
recordInvalidValue()3038 void Context::recordInvalidValue()
3039 {
3040 mInvalidValue = true;
3041 }
3042
recordInvalidOperation()3043 void Context::recordInvalidOperation()
3044 {
3045 mInvalidOperation = true;
3046 }
3047
recordOutOfMemory()3048 void Context::recordOutOfMemory()
3049 {
3050 mOutOfMemory = true;
3051 }
3052
recordInvalidFramebufferOperation()3053 void Context::recordInvalidFramebufferOperation()
3054 {
3055 mInvalidFramebufferOperation = true;
3056 }
3057
3058 // Get one of the recorded errors and clear its flag, if any.
3059 // [OpenGL ES 2.0.24] section 2.5 page 13.
getError()3060 GLenum Context::getError()
3061 {
3062 if (mInvalidEnum)
3063 {
3064 mInvalidEnum = false;
3065
3066 return GL_INVALID_ENUM;
3067 }
3068
3069 if (mInvalidValue)
3070 {
3071 mInvalidValue = false;
3072
3073 return GL_INVALID_VALUE;
3074 }
3075
3076 if (mInvalidOperation)
3077 {
3078 mInvalidOperation = false;
3079
3080 return GL_INVALID_OPERATION;
3081 }
3082
3083 if (mOutOfMemory)
3084 {
3085 mOutOfMemory = false;
3086
3087 return GL_OUT_OF_MEMORY;
3088 }
3089
3090 if (mInvalidFramebufferOperation)
3091 {
3092 mInvalidFramebufferOperation = false;
3093
3094 return GL_INVALID_FRAMEBUFFER_OPERATION;
3095 }
3096
3097 return GL_NO_ERROR;
3098 }
3099
getResetStatus()3100 GLenum Context::getResetStatus()
3101 {
3102 if (mResetStatus == GL_NO_ERROR && !mContextLost)
3103 {
3104 // mResetStatus will be set by the markContextLost callback
3105 // in the case a notification is sent
3106 mRenderer->testDeviceLost(true);
3107 }
3108
3109 GLenum status = mResetStatus;
3110
3111 if (mResetStatus != GL_NO_ERROR)
3112 {
3113 ASSERT(mContextLost);
3114
3115 if (mRenderer->testDeviceResettable())
3116 {
3117 mResetStatus = GL_NO_ERROR;
3118 }
3119 }
3120
3121 return status;
3122 }
3123
isResetNotificationEnabled()3124 bool Context::isResetNotificationEnabled()
3125 {
3126 return (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT);
3127 }
3128
getClientVersion() const3129 int Context::getClientVersion() const
3130 {
3131 return mClientVersion;
3132 }
3133
getMajorShaderModel() const3134 int Context::getMajorShaderModel() const
3135 {
3136 return mMajorShaderModel;
3137 }
3138
getMaximumPointSize() const3139 float Context::getMaximumPointSize() const
3140 {
3141 return mMaximumPointSize;
3142 }
3143
getMaximumCombinedTextureImageUnits() const3144 unsigned int Context::getMaximumCombinedTextureImageUnits() const
3145 {
3146 return mRenderer->getMaxCombinedTextureImageUnits();
3147 }
3148
getMaximumCombinedUniformBufferBindings() const3149 unsigned int Context::getMaximumCombinedUniformBufferBindings() const
3150 {
3151 return mRenderer->getMaxVertexShaderUniformBuffers() +
3152 mRenderer->getMaxFragmentShaderUniformBuffers();
3153 }
3154
getMaxSupportedSamples() const3155 int Context::getMaxSupportedSamples() const
3156 {
3157 return mRenderer->getMaxSupportedSamples();
3158 }
3159
getMaxSupportedFormatSamples(GLenum internalFormat) const3160 GLsizei Context::getMaxSupportedFormatSamples(GLenum internalFormat) const
3161 {
3162 return mRenderer->getMaxSupportedFormatSamples(internalFormat);
3163 }
3164
getNumSampleCounts(GLenum internalFormat) const3165 GLsizei Context::getNumSampleCounts(GLenum internalFormat) const
3166 {
3167 return mRenderer->getNumSampleCounts(internalFormat);
3168 }
3169
getSampleCounts(GLenum internalFormat,GLsizei bufSize,GLint * params) const3170 void Context::getSampleCounts(GLenum internalFormat, GLsizei bufSize, GLint *params) const
3171 {
3172 mRenderer->getSampleCounts(internalFormat, bufSize, params);
3173 }
3174
getMaxTransformFeedbackBufferBindings() const3175 unsigned int Context::getMaxTransformFeedbackBufferBindings() const
3176 {
3177 return mRenderer->getMaxTransformFeedbackBuffers();
3178 }
3179
getUniformBufferOffsetAlignment() const3180 GLintptr Context::getUniformBufferOffsetAlignment() const
3181 {
3182 // setting a large alignment forces uniform buffers to bind with zero offset
3183 return static_cast<GLintptr>(std::numeric_limits<GLint>::max());
3184 }
3185
getMaximumRenderTargets() const3186 unsigned int Context::getMaximumRenderTargets() const
3187 {
3188 return mRenderer->getMaxRenderTargets();
3189 }
3190
supportsEventQueries() const3191 bool Context::supportsEventQueries() const
3192 {
3193 return mSupportsEventQueries;
3194 }
3195
supportsOcclusionQueries() const3196 bool Context::supportsOcclusionQueries() const
3197 {
3198 return mSupportsOcclusionQueries;
3199 }
3200
supportsBGRATextures() const3201 bool Context::supportsBGRATextures() const
3202 {
3203 return mSupportsBGRATextures;
3204 }
3205
supportsDXT1Textures() const3206 bool Context::supportsDXT1Textures() const
3207 {
3208 return mSupportsDXT1Textures;
3209 }
3210
supportsDXT3Textures() const3211 bool Context::supportsDXT3Textures() const
3212 {
3213 return mSupportsDXT3Textures;
3214 }
3215
supportsDXT5Textures() const3216 bool Context::supportsDXT5Textures() const
3217 {
3218 return mSupportsDXT5Textures;
3219 }
3220
supportsFloat32Textures() const3221 bool Context::supportsFloat32Textures() const
3222 {
3223 return mSupportsFloat32Textures;
3224 }
3225
supportsFloat32LinearFilter() const3226 bool Context::supportsFloat32LinearFilter() const
3227 {
3228 return mSupportsFloat32LinearFilter;
3229 }
3230
supportsFloat32RenderableTextures() const3231 bool Context::supportsFloat32RenderableTextures() const
3232 {
3233 return mSupportsFloat32RenderableTextures;
3234 }
3235
supportsFloat16Textures() const3236 bool Context::supportsFloat16Textures() const
3237 {
3238 return mSupportsFloat16Textures;
3239 }
3240
supportsFloat16LinearFilter() const3241 bool Context::supportsFloat16LinearFilter() const
3242 {
3243 return mSupportsFloat16LinearFilter;
3244 }
3245
supportsFloat16RenderableTextures() const3246 bool Context::supportsFloat16RenderableTextures() const
3247 {
3248 return mSupportsFloat16RenderableTextures;
3249 }
3250
getMaximumRenderbufferDimension() const3251 int Context::getMaximumRenderbufferDimension() const
3252 {
3253 return mMaxRenderbufferDimension;
3254 }
3255
getMaximum2DTextureDimension() const3256 int Context::getMaximum2DTextureDimension() const
3257 {
3258 return mMax2DTextureDimension;
3259 }
3260
getMaximumCubeTextureDimension() const3261 int Context::getMaximumCubeTextureDimension() const
3262 {
3263 return mMaxCubeTextureDimension;
3264 }
3265
getMaximum3DTextureDimension() const3266 int Context::getMaximum3DTextureDimension() const
3267 {
3268 return mMax3DTextureDimension;
3269 }
3270
getMaximum2DArrayTextureLayers() const3271 int Context::getMaximum2DArrayTextureLayers() const
3272 {
3273 return mMax2DArrayTextureLayers;
3274 }
3275
getMaximum2DTextureLevel() const3276 int Context::getMaximum2DTextureLevel() const
3277 {
3278 return mMax2DTextureLevel;
3279 }
3280
getMaximumCubeTextureLevel() const3281 int Context::getMaximumCubeTextureLevel() const
3282 {
3283 return mMaxCubeTextureLevel;
3284 }
3285
getMaximum3DTextureLevel() const3286 int Context::getMaximum3DTextureLevel() const
3287 {
3288 return mMax3DTextureLevel;
3289 }
3290
getMaximum2DArrayTextureLevel() const3291 int Context::getMaximum2DArrayTextureLevel() const
3292 {
3293 return mMax2DArrayTextureLevel;
3294 }
3295
supportsLuminanceTextures() const3296 bool Context::supportsLuminanceTextures() const
3297 {
3298 return mSupportsLuminanceTextures;
3299 }
3300
supportsLuminanceAlphaTextures() const3301 bool Context::supportsLuminanceAlphaTextures() const
3302 {
3303 return mSupportsLuminanceAlphaTextures;
3304 }
3305
supportsRGTextures() const3306 bool Context::supportsRGTextures() const
3307 {
3308 return mSupportsRGTextures;
3309 }
3310
supportsDepthTextures() const3311 bool Context::supportsDepthTextures() const
3312 {
3313 return mSupportsDepthTextures;
3314 }
3315
supports32bitIndices() const3316 bool Context::supports32bitIndices() const
3317 {
3318 return mSupports32bitIndices;
3319 }
3320
supportsNonPower2Texture() const3321 bool Context::supportsNonPower2Texture() const
3322 {
3323 return mSupportsNonPower2Texture;
3324 }
3325
supportsInstancing() const3326 bool Context::supportsInstancing() const
3327 {
3328 return mSupportsInstancing;
3329 }
3330
supportsTextureFilterAnisotropy() const3331 bool Context::supportsTextureFilterAnisotropy() const
3332 {
3333 return mSupportsTextureFilterAnisotropy;
3334 }
3335
supportsPBOs() const3336 bool Context::supportsPBOs() const
3337 {
3338 return mSupportsPBOs;
3339 }
3340
getTextureMaxAnisotropy() const3341 float Context::getTextureMaxAnisotropy() const
3342 {
3343 return mMaxTextureAnisotropy;
3344 }
3345
getCurrentReadFormatType(GLenum * internalFormat,GLenum * format,GLenum * type)3346 void Context::getCurrentReadFormatType(GLenum *internalFormat, GLenum *format, GLenum *type)
3347 {
3348 Framebuffer *framebuffer = getReadFramebuffer();
3349 ASSERT(framebuffer && framebuffer->completeness() == GL_FRAMEBUFFER_COMPLETE);
3350
3351 FramebufferAttachment *attachment = framebuffer->getReadColorbuffer();
3352 ASSERT(attachment);
3353
3354 *internalFormat = attachment->getActualFormat();
3355 *format = gl::GetFormat(attachment->getActualFormat(), mClientVersion);
3356 *type = gl::GetType(attachment->getActualFormat(), mClientVersion);
3357 }
3358
detachBuffer(GLuint buffer)3359 void Context::detachBuffer(GLuint buffer)
3360 {
3361 // [OpenGL ES 2.0.24] section 2.9 page 22:
3362 // If a buffer object is deleted while it is bound, all bindings to that object in the current context
3363 // (i.e. in the thread that called Delete-Buffers) are reset to zero.
3364
3365 if (mState.arrayBuffer.id() == buffer)
3366 {
3367 mState.arrayBuffer.set(NULL);
3368 }
3369
3370 // mark as freed among the vertex array objects
3371 for (auto vaoIt = mVertexArrayMap.begin(); vaoIt != mVertexArrayMap.end(); vaoIt++)
3372 {
3373 vaoIt->second->detachBuffer(buffer);
3374 }
3375 }
3376
detachTexture(GLuint texture)3377 void Context::detachTexture(GLuint texture)
3378 {
3379 // [OpenGL ES 2.0.24] section 3.8 page 84:
3380 // If a texture object is deleted, it is as if all texture units which are bound to that texture object are
3381 // rebound to texture object zero
3382
3383 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++)
3384 {
3385 for (int sampler = 0; sampler < IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++)
3386 {
3387 if (mState.samplerTexture[type][sampler].id() == texture)
3388 {
3389 mState.samplerTexture[type][sampler].set(NULL);
3390 }
3391 }
3392 }
3393
3394 // [OpenGL ES 2.0.24] section 4.4 page 112:
3395 // If a texture object is deleted while its image is attached to the currently bound framebuffer, then it is
3396 // as if Texture2DAttachment had been called, with a texture of 0, for each attachment point to which this
3397 // image was attached in the currently bound framebuffer.
3398
3399 Framebuffer *readFramebuffer = getReadFramebuffer();
3400 Framebuffer *drawFramebuffer = getDrawFramebuffer();
3401
3402 if (readFramebuffer)
3403 {
3404 readFramebuffer->detachTexture(texture);
3405 }
3406
3407 if (drawFramebuffer && drawFramebuffer != readFramebuffer)
3408 {
3409 drawFramebuffer->detachTexture(texture);
3410 }
3411 }
3412
detachFramebuffer(GLuint framebuffer)3413 void Context::detachFramebuffer(GLuint framebuffer)
3414 {
3415 // [OpenGL ES 2.0.24] section 4.4 page 107:
3416 // If a framebuffer that is currently bound to the target FRAMEBUFFER is deleted, it is as though
3417 // BindFramebuffer had been executed with the target of FRAMEBUFFER and framebuffer of zero.
3418
3419 if (mState.readFramebuffer == framebuffer)
3420 {
3421 bindReadFramebuffer(0);
3422 }
3423
3424 if (mState.drawFramebuffer == framebuffer)
3425 {
3426 bindDrawFramebuffer(0);
3427 }
3428 }
3429
detachRenderbuffer(GLuint renderbuffer)3430 void Context::detachRenderbuffer(GLuint renderbuffer)
3431 {
3432 // [OpenGL ES 2.0.24] section 4.4 page 109:
3433 // If a renderbuffer that is currently bound to RENDERBUFFER is deleted, it is as though BindRenderbuffer
3434 // had been executed with the target RENDERBUFFER and name of zero.
3435
3436 if (mState.renderbuffer.id() == renderbuffer)
3437 {
3438 bindRenderbuffer(0);
3439 }
3440
3441 // [OpenGL ES 2.0.24] section 4.4 page 111:
3442 // If a renderbuffer object is deleted while its image is attached to the currently bound framebuffer,
3443 // then it is as if FramebufferRenderbuffer had been called, with a renderbuffer of 0, for each attachment
3444 // point to which this image was attached in the currently bound framebuffer.
3445
3446 Framebuffer *readFramebuffer = getReadFramebuffer();
3447 Framebuffer *drawFramebuffer = getDrawFramebuffer();
3448
3449 if (readFramebuffer)
3450 {
3451 readFramebuffer->detachRenderbuffer(renderbuffer);
3452 }
3453
3454 if (drawFramebuffer && drawFramebuffer != readFramebuffer)
3455 {
3456 drawFramebuffer->detachRenderbuffer(renderbuffer);
3457 }
3458 }
3459
detachVertexArray(GLuint vertexArray)3460 void Context::detachVertexArray(GLuint vertexArray)
3461 {
3462 // [OpenGL ES 3.0.2] section 2.10 page 43:
3463 // If a vertex array object that is currently bound is deleted, the binding
3464 // for that object reverts to zero and the default vertex array becomes current.
3465 if (mState.vertexArray == vertexArray)
3466 {
3467 bindVertexArray(0);
3468 }
3469 }
3470
detachTransformFeedback(GLuint transformFeedback)3471 void Context::detachTransformFeedback(GLuint transformFeedback)
3472 {
3473 if (mState.transformFeedback.id() == transformFeedback)
3474 {
3475 bindTransformFeedback(0);
3476 }
3477 }
3478
detachSampler(GLuint sampler)3479 void Context::detachSampler(GLuint sampler)
3480 {
3481 // [OpenGL ES 3.0.2] section 3.8.2 pages 123-124:
3482 // If a sampler object that is currently bound to one or more texture units is
3483 // deleted, it is as though BindSampler is called once for each texture unit to
3484 // which the sampler is bound, with unit set to the texture unit and sampler set to zero.
3485 for (unsigned int textureUnit = 0; textureUnit < ArraySize(mState.samplers); textureUnit++)
3486 {
3487 if (mState.samplers[textureUnit] == sampler)
3488 {
3489 mState.samplers[textureUnit] = 0;
3490 }
3491 }
3492 }
3493
getIncompleteTexture(TextureType type)3494 Texture *Context::getIncompleteTexture(TextureType type)
3495 {
3496 Texture *t = mIncompleteTextures[type].get();
3497
3498 if (t == NULL)
3499 {
3500 const GLubyte color[] = { 0, 0, 0, 255 };
3501 const PixelUnpackState incompleteUnpackState(1);
3502
3503 switch (type)
3504 {
3505 default:
3506 UNREACHABLE();
3507 // default falls through to TEXTURE_2D
3508
3509 case TEXTURE_2D:
3510 {
3511 Texture2D *incomplete2d = new Texture2D(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
3512 incomplete2d->setImage(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3513 t = incomplete2d;
3514 }
3515 break;
3516
3517 case TEXTURE_CUBE:
3518 {
3519 TextureCubeMap *incompleteCube = new TextureCubeMap(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
3520
3521 incompleteCube->setImagePosX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3522 incompleteCube->setImageNegX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3523 incompleteCube->setImagePosY(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3524 incompleteCube->setImageNegY(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3525 incompleteCube->setImagePosZ(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3526 incompleteCube->setImageNegZ(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3527
3528 t = incompleteCube;
3529 }
3530 break;
3531
3532 case TEXTURE_3D:
3533 {
3534 Texture3D *incomplete3d = new Texture3D(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
3535 incomplete3d->setImage(0, 1, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3536
3537 t = incomplete3d;
3538 }
3539 break;
3540
3541 case TEXTURE_2D_ARRAY:
3542 {
3543 Texture2DArray *incomplete2darray = new Texture2DArray(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
3544 incomplete2darray->setImage(0, 1, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
3545
3546 t = incomplete2darray;
3547 }
3548 break;
3549 }
3550
3551 mIncompleteTextures[type].set(t);
3552 }
3553
3554 return t;
3555 }
3556
skipDraw(GLenum drawMode)3557 bool Context::skipDraw(GLenum drawMode)
3558 {
3559 if (drawMode == GL_POINTS)
3560 {
3561 // ProgramBinary assumes non-point rendering if gl_PointSize isn't written,
3562 // which affects varying interpolation. Since the value of gl_PointSize is
3563 // undefined when not written, just skip drawing to avoid unexpected results.
3564 if (!getCurrentProgramBinary()->usesPointSize())
3565 {
3566 // This is stictly speaking not an error, but developers should be
3567 // notified of risking undefined behavior.
3568 ERR("Point rendering without writing to gl_PointSize.");
3569
3570 return true;
3571 }
3572 }
3573 else if (IsTriangleMode(drawMode))
3574 {
3575 if (mState.rasterizer.cullFace && mState.rasterizer.cullMode == GL_FRONT_AND_BACK)
3576 {
3577 return true;
3578 }
3579 }
3580
3581 return false;
3582 }
3583
setVertexAttribf(GLuint index,const GLfloat values[4])3584 void Context::setVertexAttribf(GLuint index, const GLfloat values[4])
3585 {
3586 ASSERT(index < gl::MAX_VERTEX_ATTRIBS);
3587 mState.vertexAttribCurrentValues[index].setFloatValues(values);
3588 }
3589
setVertexAttribu(GLuint index,const GLuint values[4])3590 void Context::setVertexAttribu(GLuint index, const GLuint values[4])
3591 {
3592 ASSERT(index < gl::MAX_VERTEX_ATTRIBS);
3593 mState.vertexAttribCurrentValues[index].setUnsignedIntValues(values);
3594 }
3595
setVertexAttribi(GLuint index,const GLint values[4])3596 void Context::setVertexAttribi(GLuint index, const GLint values[4])
3597 {
3598 ASSERT(index < gl::MAX_VERTEX_ATTRIBS);
3599 mState.vertexAttribCurrentValues[index].setIntValues(values);
3600 }
3601
setVertexAttribDivisor(GLuint index,GLuint divisor)3602 void Context::setVertexAttribDivisor(GLuint index, GLuint divisor)
3603 {
3604 getCurrentVertexArray()->setVertexAttribDivisor(index, divisor);
3605 }
3606
samplerParameteri(GLuint sampler,GLenum pname,GLint param)3607 void Context::samplerParameteri(GLuint sampler, GLenum pname, GLint param)
3608 {
3609 mResourceManager->checkSamplerAllocation(sampler);
3610
3611 Sampler *samplerObject = getSampler(sampler);
3612 ASSERT(samplerObject);
3613
3614 switch (pname)
3615 {
3616 case GL_TEXTURE_MIN_FILTER: samplerObject->setMinFilter(static_cast<GLenum>(param)); break;
3617 case GL_TEXTURE_MAG_FILTER: samplerObject->setMagFilter(static_cast<GLenum>(param)); break;
3618 case GL_TEXTURE_WRAP_S: samplerObject->setWrapS(static_cast<GLenum>(param)); break;
3619 case GL_TEXTURE_WRAP_T: samplerObject->setWrapT(static_cast<GLenum>(param)); break;
3620 case GL_TEXTURE_WRAP_R: samplerObject->setWrapR(static_cast<GLenum>(param)); break;
3621 case GL_TEXTURE_MIN_LOD: samplerObject->setMinLod(static_cast<GLfloat>(param)); break;
3622 case GL_TEXTURE_MAX_LOD: samplerObject->setMaxLod(static_cast<GLfloat>(param)); break;
3623 case GL_TEXTURE_COMPARE_MODE: samplerObject->setComparisonMode(static_cast<GLenum>(param)); break;
3624 case GL_TEXTURE_COMPARE_FUNC: samplerObject->setComparisonFunc(static_cast<GLenum>(param)); break;
3625 default: UNREACHABLE(); break;
3626 }
3627 }
3628
samplerParameterf(GLuint sampler,GLenum pname,GLfloat param)3629 void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
3630 {
3631 mResourceManager->checkSamplerAllocation(sampler);
3632
3633 Sampler *samplerObject = getSampler(sampler);
3634 ASSERT(samplerObject);
3635
3636 switch (pname)
3637 {
3638 case GL_TEXTURE_MIN_FILTER: samplerObject->setMinFilter(uiround<GLenum>(param)); break;
3639 case GL_TEXTURE_MAG_FILTER: samplerObject->setMagFilter(uiround<GLenum>(param)); break;
3640 case GL_TEXTURE_WRAP_S: samplerObject->setWrapS(uiround<GLenum>(param)); break;
3641 case GL_TEXTURE_WRAP_T: samplerObject->setWrapT(uiround<GLenum>(param)); break;
3642 case GL_TEXTURE_WRAP_R: samplerObject->setWrapR(uiround<GLenum>(param)); break;
3643 case GL_TEXTURE_MIN_LOD: samplerObject->setMinLod(param); break;
3644 case GL_TEXTURE_MAX_LOD: samplerObject->setMaxLod(param); break;
3645 case GL_TEXTURE_COMPARE_MODE: samplerObject->setComparisonMode(uiround<GLenum>(param)); break;
3646 case GL_TEXTURE_COMPARE_FUNC: samplerObject->setComparisonFunc(uiround<GLenum>(param)); break;
3647 default: UNREACHABLE(); break;
3648 }
3649 }
3650
getSamplerParameteri(GLuint sampler,GLenum pname)3651 GLint Context::getSamplerParameteri(GLuint sampler, GLenum pname)
3652 {
3653 mResourceManager->checkSamplerAllocation(sampler);
3654
3655 Sampler *samplerObject = getSampler(sampler);
3656 ASSERT(samplerObject);
3657
3658 switch (pname)
3659 {
3660 case GL_TEXTURE_MIN_FILTER: return static_cast<GLint>(samplerObject->getMinFilter());
3661 case GL_TEXTURE_MAG_FILTER: return static_cast<GLint>(samplerObject->getMagFilter());
3662 case GL_TEXTURE_WRAP_S: return static_cast<GLint>(samplerObject->getWrapS());
3663 case GL_TEXTURE_WRAP_T: return static_cast<GLint>(samplerObject->getWrapT());
3664 case GL_TEXTURE_WRAP_R: return static_cast<GLint>(samplerObject->getWrapR());
3665 case GL_TEXTURE_MIN_LOD: return uiround<GLint>(samplerObject->getMinLod());
3666 case GL_TEXTURE_MAX_LOD: return uiround<GLint>(samplerObject->getMaxLod());
3667 case GL_TEXTURE_COMPARE_MODE: return static_cast<GLint>(samplerObject->getComparisonMode());
3668 case GL_TEXTURE_COMPARE_FUNC: return static_cast<GLint>(samplerObject->getComparisonFunc());
3669 default: UNREACHABLE(); return 0;
3670 }
3671 }
3672
getSamplerParameterf(GLuint sampler,GLenum pname)3673 GLfloat Context::getSamplerParameterf(GLuint sampler, GLenum pname)
3674 {
3675 mResourceManager->checkSamplerAllocation(sampler);
3676
3677 Sampler *samplerObject = getSampler(sampler);
3678 ASSERT(samplerObject);
3679
3680 switch (pname)
3681 {
3682 case GL_TEXTURE_MIN_FILTER: return static_cast<GLfloat>(samplerObject->getMinFilter());
3683 case GL_TEXTURE_MAG_FILTER: return static_cast<GLfloat>(samplerObject->getMagFilter());
3684 case GL_TEXTURE_WRAP_S: return static_cast<GLfloat>(samplerObject->getWrapS());
3685 case GL_TEXTURE_WRAP_T: return static_cast<GLfloat>(samplerObject->getWrapT());
3686 case GL_TEXTURE_WRAP_R: return static_cast<GLfloat>(samplerObject->getWrapR());
3687 case GL_TEXTURE_MIN_LOD: return samplerObject->getMinLod();
3688 case GL_TEXTURE_MAX_LOD: return samplerObject->getMaxLod();
3689 case GL_TEXTURE_COMPARE_MODE: return static_cast<GLfloat>(samplerObject->getComparisonMode());
3690 case GL_TEXTURE_COMPARE_FUNC: return static_cast<GLfloat>(samplerObject->getComparisonFunc());
3691 default: UNREACHABLE(); return 0;
3692 }
3693 }
3694
3695 // keep list sorted in following order
3696 // OES extensions
3697 // EXT extensions
3698 // Vendor extensions
initExtensionString()3699 void Context::initExtensionString()
3700 {
3701 // Do not report extension in GLES 3 contexts for now
3702 if (mClientVersion == 2)
3703 {
3704 // OES extensions
3705 if (supports32bitIndices())
3706 {
3707 mExtensionStringList.push_back("GL_OES_element_index_uint");
3708 }
3709
3710 mExtensionStringList.push_back("GL_OES_packed_depth_stencil");
3711 mExtensionStringList.push_back("GL_OES_get_program_binary");
3712 mExtensionStringList.push_back("GL_OES_rgb8_rgba8");
3713
3714 if (supportsPBOs())
3715 {
3716 mExtensionStringList.push_back("NV_pixel_buffer_object");
3717 mExtensionStringList.push_back("GL_OES_mapbuffer");
3718 mExtensionStringList.push_back("GL_EXT_map_buffer_range");
3719 }
3720
3721 if (mRenderer->getDerivativeInstructionSupport())
3722 {
3723 mExtensionStringList.push_back("GL_OES_standard_derivatives");
3724 }
3725
3726 if (supportsFloat16Textures())
3727 {
3728 mExtensionStringList.push_back("GL_OES_texture_half_float");
3729 }
3730 if (supportsFloat16LinearFilter())
3731 {
3732 mExtensionStringList.push_back("GL_OES_texture_half_float_linear");
3733 }
3734 if (supportsFloat32Textures())
3735 {
3736 mExtensionStringList.push_back("GL_OES_texture_float");
3737 }
3738 if (supportsFloat32LinearFilter())
3739 {
3740 mExtensionStringList.push_back("GL_OES_texture_float_linear");
3741 }
3742
3743 if (supportsRGTextures())
3744 {
3745 mExtensionStringList.push_back("GL_EXT_texture_rg");
3746 }
3747
3748 if (supportsNonPower2Texture())
3749 {
3750 mExtensionStringList.push_back("GL_OES_texture_npot");
3751 }
3752
3753 // Multi-vendor (EXT) extensions
3754 if (supportsOcclusionQueries())
3755 {
3756 mExtensionStringList.push_back("GL_EXT_occlusion_query_boolean");
3757 }
3758
3759 mExtensionStringList.push_back("GL_EXT_read_format_bgra");
3760 mExtensionStringList.push_back("GL_EXT_robustness");
3761 mExtensionStringList.push_back("GL_EXT_shader_texture_lod");
3762
3763 if (supportsDXT1Textures())
3764 {
3765 mExtensionStringList.push_back("GL_EXT_texture_compression_dxt1");
3766 }
3767
3768 if (supportsTextureFilterAnisotropy())
3769 {
3770 mExtensionStringList.push_back("GL_EXT_texture_filter_anisotropic");
3771 }
3772
3773 if (supportsBGRATextures())
3774 {
3775 mExtensionStringList.push_back("GL_EXT_texture_format_BGRA8888");
3776 }
3777
3778 if (mRenderer->getMaxRenderTargets() > 1)
3779 {
3780 mExtensionStringList.push_back("GL_EXT_draw_buffers");
3781 }
3782
3783 mExtensionStringList.push_back("GL_EXT_texture_storage");
3784 mExtensionStringList.push_back("GL_EXT_frag_depth");
3785 mExtensionStringList.push_back("GL_EXT_blend_minmax");
3786
3787 // ANGLE-specific extensions
3788 if (supportsDepthTextures())
3789 {
3790 mExtensionStringList.push_back("GL_ANGLE_depth_texture");
3791 }
3792
3793 mExtensionStringList.push_back("GL_ANGLE_framebuffer_blit");
3794 if (getMaxSupportedSamples() != 0)
3795 {
3796 mExtensionStringList.push_back("GL_ANGLE_framebuffer_multisample");
3797 }
3798
3799 if (supportsInstancing())
3800 {
3801 mExtensionStringList.push_back("GL_ANGLE_instanced_arrays");
3802 }
3803
3804 mExtensionStringList.push_back("GL_ANGLE_pack_reverse_row_order");
3805
3806 if (supportsDXT3Textures())
3807 {
3808 mExtensionStringList.push_back("GL_ANGLE_texture_compression_dxt3");
3809 }
3810 if (supportsDXT5Textures())
3811 {
3812 mExtensionStringList.push_back("GL_ANGLE_texture_compression_dxt5");
3813 }
3814
3815 mExtensionStringList.push_back("GL_ANGLE_texture_usage");
3816 mExtensionStringList.push_back("GL_ANGLE_translated_shader_source");
3817
3818 // Other vendor-specific extensions
3819 if (supportsEventQueries())
3820 {
3821 mExtensionStringList.push_back("GL_NV_fence");
3822 }
3823 }
3824
3825 if (mClientVersion == 3)
3826 {
3827 mExtensionStringList.push_back("GL_EXT_color_buffer_float");
3828
3829 mExtensionStringList.push_back("GL_EXT_read_format_bgra");
3830
3831 if (supportsBGRATextures())
3832 {
3833 mExtensionStringList.push_back("GL_EXT_texture_format_BGRA8888");
3834 }
3835 }
3836
3837 // Join the extension strings to one long string for use with GetString
3838 std::stringstream strstr;
3839 for (unsigned int extensionIndex = 0; extensionIndex < mExtensionStringList.size(); extensionIndex++)
3840 {
3841 strstr << mExtensionStringList[extensionIndex];
3842 strstr << " ";
3843 }
3844
3845 mCombinedExtensionsString = makeStaticString(strstr.str());
3846 }
3847
getCombinedExtensionsString() const3848 const char *Context::getCombinedExtensionsString() const
3849 {
3850 return mCombinedExtensionsString;
3851 }
3852
getExtensionString(const GLuint index) const3853 const char *Context::getExtensionString(const GLuint index) const
3854 {
3855 ASSERT(index < mExtensionStringList.size());
3856 return mExtensionStringList[index].c_str();
3857 }
3858
getNumExtensions() const3859 unsigned int Context::getNumExtensions() const
3860 {
3861 return mExtensionStringList.size();
3862 }
3863
initRendererString()3864 void Context::initRendererString()
3865 {
3866 std::ostringstream rendererString;
3867 rendererString << "ANGLE (";
3868 rendererString << mRenderer->getRendererDescription();
3869 rendererString << ")";
3870
3871 mRendererString = makeStaticString(rendererString.str());
3872 }
3873
getRendererString() const3874 const char *Context::getRendererString() const
3875 {
3876 return mRendererString;
3877 }
3878
getBoundFramebufferTextureSerials(FramebufferTextureSerialArray * outSerialArray)3879 size_t Context::getBoundFramebufferTextureSerials(FramebufferTextureSerialArray *outSerialArray)
3880 {
3881 size_t serialCount = 0;
3882
3883 Framebuffer *drawFramebuffer = getDrawFramebuffer();
3884 for (unsigned int i = 0; i < IMPLEMENTATION_MAX_DRAW_BUFFERS; i++)
3885 {
3886 FramebufferAttachment *attachment = drawFramebuffer->getColorbuffer(i);
3887 if (attachment && attachment->isTexture())
3888 {
3889 (*outSerialArray)[serialCount++] = attachment->getTextureSerial();
3890 }
3891 }
3892
3893 FramebufferAttachment *depthStencilAttachment = drawFramebuffer->getDepthOrStencilbuffer();
3894 if (depthStencilAttachment && depthStencilAttachment->isTexture())
3895 {
3896 (*outSerialArray)[serialCount++] = depthStencilAttachment->getTextureSerial();
3897 }
3898
3899 std::sort(outSerialArray->begin(), outSerialArray->begin() + serialCount);
3900
3901 return serialCount;
3902 }
3903
blitFramebuffer(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)3904 void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
3905 GLbitfield mask, GLenum filter)
3906 {
3907 Framebuffer *readFramebuffer = getReadFramebuffer();
3908 Framebuffer *drawFramebuffer = getDrawFramebuffer();
3909
3910 bool blitRenderTarget = false;
3911 bool blitDepth = false;
3912 bool blitStencil = false;
3913 if ((mask & GL_COLOR_BUFFER_BIT) && readFramebuffer->getReadColorbuffer() && drawFramebuffer->getFirstColorbuffer())
3914 {
3915 blitRenderTarget = true;
3916 }
3917 if ((mask & GL_STENCIL_BUFFER_BIT) && readFramebuffer->getStencilbuffer() && drawFramebuffer->getStencilbuffer())
3918 {
3919 blitStencil = true;
3920 }
3921 if ((mask & GL_DEPTH_BUFFER_BIT) && readFramebuffer->getDepthbuffer() && drawFramebuffer->getDepthbuffer())
3922 {
3923 blitDepth = true;
3924 }
3925
3926 gl::Rectangle srcRect(srcX0, srcY0, srcX1 - srcX0, srcY1 - srcY0);
3927 gl::Rectangle dstRect(dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0);
3928 if (blitRenderTarget || blitDepth || blitStencil)
3929 {
3930 const gl::Rectangle *scissor = mState.scissorTest ? &mState.scissor : NULL;
3931 mRenderer->blitRect(readFramebuffer, srcRect, drawFramebuffer, dstRect, scissor,
3932 blitRenderTarget, blitDepth, blitStencil, filter);
3933 }
3934 }
3935
invalidateFrameBuffer(GLenum target,GLsizei numAttachments,const GLenum * attachments,GLint x,GLint y,GLsizei width,GLsizei height)3936 void Context::invalidateFrameBuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments,
3937 GLint x, GLint y, GLsizei width, GLsizei height)
3938 {
3939 Framebuffer *frameBuffer = NULL;
3940 switch (target)
3941 {
3942 case GL_FRAMEBUFFER:
3943 case GL_DRAW_FRAMEBUFFER:
3944 frameBuffer = getDrawFramebuffer();
3945 break;
3946 case GL_READ_FRAMEBUFFER:
3947 frameBuffer = getReadFramebuffer();
3948 break;
3949 default:
3950 UNREACHABLE();
3951 }
3952
3953 if (frameBuffer && frameBuffer->completeness() == GL_FRAMEBUFFER_COMPLETE)
3954 {
3955 for (int i = 0; i < numAttachments; ++i)
3956 {
3957 rx::RenderTarget *renderTarget = NULL;
3958
3959 if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[i] <= GL_COLOR_ATTACHMENT15)
3960 {
3961 gl::FramebufferAttachment *attachment = frameBuffer->getColorbuffer(attachments[i] - GL_COLOR_ATTACHMENT0);
3962 if (attachment)
3963 {
3964 renderTarget = attachment->getRenderTarget();
3965 }
3966 }
3967 else if (attachments[i] == GL_COLOR)
3968 {
3969 gl::FramebufferAttachment *attachment = frameBuffer->getColorbuffer(0);
3970 if (attachment)
3971 {
3972 renderTarget = attachment->getRenderTarget();
3973 }
3974 }
3975 else
3976 {
3977 gl::FramebufferAttachment *attachment = NULL;
3978 switch (attachments[i])
3979 {
3980 case GL_DEPTH_ATTACHMENT:
3981 case GL_DEPTH:
3982 attachment = frameBuffer->getDepthbuffer();
3983 break;
3984 case GL_STENCIL_ATTACHMENT:
3985 case GL_STENCIL:
3986 attachment = frameBuffer->getStencilbuffer();
3987 break;
3988 case GL_DEPTH_STENCIL_ATTACHMENT:
3989 attachment = frameBuffer->getDepthOrStencilbuffer();
3990 break;
3991 default:
3992 UNREACHABLE();
3993 }
3994
3995 if (attachment)
3996 {
3997 renderTarget = attachment->getDepthStencil();
3998 }
3999 }
4000
4001 if (renderTarget)
4002 {
4003 renderTarget->invalidate(x, y, width, height);
4004 }
4005 }
4006 }
4007 }
4008
hasMappedBuffer(GLenum target) const4009 bool Context::hasMappedBuffer(GLenum target) const
4010 {
4011 if (target == GL_ARRAY_BUFFER)
4012 {
4013 for (unsigned int attribIndex = 0; attribIndex < gl::MAX_VERTEX_ATTRIBS; attribIndex++)
4014 {
4015 const gl::VertexAttribute &vertexAttrib = getVertexAttribState(attribIndex);
4016 gl::Buffer *boundBuffer = vertexAttrib.mBoundBuffer.get();
4017 if (vertexAttrib.mArrayEnabled && boundBuffer && boundBuffer->mapped())
4018 {
4019 return true;
4020 }
4021 }
4022 }
4023 else if (target == GL_ELEMENT_ARRAY_BUFFER)
4024 {
4025 Buffer *elementBuffer = getElementArrayBuffer();
4026 return (elementBuffer && elementBuffer->mapped());
4027 }
4028 else if (target == GL_TRANSFORM_FEEDBACK_BUFFER)
4029 {
4030 UNIMPLEMENTED();
4031 }
4032 else UNREACHABLE();
4033 return false;
4034 }
4035
4036 }
4037
4038 extern "C"
4039 {
glCreateContext(int clientVersion,const gl::Context * shareContext,rx::Renderer * renderer,bool notifyResets,bool robustAccess)4040 gl::Context *glCreateContext(int clientVersion, const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess)
4041 {
4042 return new gl::Context(clientVersion, shareContext, renderer, notifyResets, robustAccess);
4043 }
4044
glDestroyContext(gl::Context * context)4045 void glDestroyContext(gl::Context *context)
4046 {
4047 delete context;
4048
4049 if (context == gl::getContext())
4050 {
4051 gl::makeCurrent(NULL, NULL, NULL);
4052 }
4053 }
4054
glMakeCurrent(gl::Context * context,egl::Display * display,egl::Surface * surface)4055 void glMakeCurrent(gl::Context *context, egl::Display *display, egl::Surface *surface)
4056 {
4057 gl::makeCurrent(context, display, surface);
4058 }
4059
glGetCurrentContext()4060 gl::Context *glGetCurrentContext()
4061 {
4062 return gl::getContext();
4063 }
4064
4065 }
4066