Update To 11.40.268.0
[platform/framework/web/crosswalk.git] / src / third_party / angle / src / libGLESv2 / State.cpp
1 //
2 // Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 // State.cpp: Implements the State class, encapsulating raw GL state.
8
9 #include "libGLESv2/State.h"
10
11 #include "libGLESv2/Context.h"
12 #include "libGLESv2/Caps.h"
13 #include "libGLESv2/VertexArray.h"
14 #include "libGLESv2/Query.h"
15 #include "libGLESv2/Framebuffer.h"
16 #include "libGLESv2/FramebufferAttachment.h"
17 #include "libGLESv2/renderer/RenderTarget.h"
18 #include "libGLESv2/formatutils.h"
19
20 namespace gl
21 {
22
23 State::State()
24 {
25     mMaxDrawBuffers = 0;
26     mMaxCombinedTextureImageUnits = 0;
27 }
28
29 State::~State()
30 {
31     reset();
32 }
33
34 void State::initialize(const Caps& caps, GLuint clientVersion)
35 {
36     mMaxDrawBuffers = caps.maxDrawBuffers;
37     mMaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
38
39     setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
40
41     mDepthClearValue = 1.0f;
42     mStencilClearValue = 0;
43
44     mRasterizer.rasterizerDiscard = false;
45     mRasterizer.cullFace = false;
46     mRasterizer.cullMode = GL_BACK;
47     mRasterizer.frontFace = GL_CCW;
48     mRasterizer.polygonOffsetFill = false;
49     mRasterizer.polygonOffsetFactor = 0.0f;
50     mRasterizer.polygonOffsetUnits = 0.0f;
51     mRasterizer.pointDrawMode = false;
52     mRasterizer.multiSample = false;
53     mScissorTest = false;
54     mScissor.x = 0;
55     mScissor.y = 0;
56     mScissor.width = 0;
57     mScissor.height = 0;
58
59     mBlend.blend = false;
60     mBlend.sourceBlendRGB = GL_ONE;
61     mBlend.sourceBlendAlpha = GL_ONE;
62     mBlend.destBlendRGB = GL_ZERO;
63     mBlend.destBlendAlpha = GL_ZERO;
64     mBlend.blendEquationRGB = GL_FUNC_ADD;
65     mBlend.blendEquationAlpha = GL_FUNC_ADD;
66     mBlend.sampleAlphaToCoverage = false;
67     mBlend.dither = true;
68
69     mBlendColor.red = 0;
70     mBlendColor.green = 0;
71     mBlendColor.blue = 0;
72     mBlendColor.alpha = 0;
73
74     mDepthStencil.depthTest = false;
75     mDepthStencil.depthFunc = GL_LESS;
76     mDepthStencil.depthMask = true;
77     mDepthStencil.stencilTest = false;
78     mDepthStencil.stencilFunc = GL_ALWAYS;
79     mDepthStencil.stencilMask = -1;
80     mDepthStencil.stencilWritemask = -1;
81     mDepthStencil.stencilBackFunc = GL_ALWAYS;
82     mDepthStencil.stencilBackMask = -1;
83     mDepthStencil.stencilBackWritemask = -1;
84     mDepthStencil.stencilFail = GL_KEEP;
85     mDepthStencil.stencilPassDepthFail = GL_KEEP;
86     mDepthStencil.stencilPassDepthPass = GL_KEEP;
87     mDepthStencil.stencilBackFail = GL_KEEP;
88     mDepthStencil.stencilBackPassDepthFail = GL_KEEP;
89     mDepthStencil.stencilBackPassDepthPass = GL_KEEP;
90
91     mStencilRef = 0;
92     mStencilBackRef = 0;
93
94     mSampleCoverage = false;
95     mSampleCoverageValue = 1.0f;
96     mSampleCoverageInvert = false;
97     mGenerateMipmapHint = GL_DONT_CARE;
98     mFragmentShaderDerivativeHint = GL_DONT_CARE;
99
100     mLineWidth = 1.0f;
101
102     mViewport.x = 0;
103     mViewport.y = 0;
104     mViewport.width = 0;
105     mViewport.height = 0;
106     mNearZ = 0.0f;
107     mFarZ = 1.0f;
108
109     mBlend.colorMaskRed = true;
110     mBlend.colorMaskGreen = true;
111     mBlend.colorMaskBlue = true;
112     mBlend.colorMaskAlpha = true;
113
114     mActiveSampler = 0;
115
116     const GLfloat defaultFloatValues[] = { 0.0f, 0.0f, 0.0f, 1.0f };
117     mVertexAttribCurrentValues.resize(caps.maxVertexAttributes);
118     for (size_t attribIndex = 0; attribIndex < mVertexAttribCurrentValues.size(); ++attribIndex)
119     {
120         mVertexAttribCurrentValues[attribIndex].setFloatValues(defaultFloatValues);
121     }
122
123     mUniformBuffers.resize(caps.maxCombinedUniformBlocks);
124     mTransformFeedbackBuffers.resize(caps.maxTransformFeedbackSeparateAttributes);
125
126     mSamplerTextures[GL_TEXTURE_2D].resize(caps.maxCombinedTextureImageUnits);
127     mSamplerTextures[GL_TEXTURE_CUBE_MAP].resize(caps.maxCombinedTextureImageUnits);
128     if (clientVersion >= 3)
129     {
130         // TODO: These could also be enabled via extension
131         mSamplerTextures[GL_TEXTURE_2D_ARRAY].resize(caps.maxCombinedTextureImageUnits);
132         mSamplerTextures[GL_TEXTURE_3D].resize(caps.maxCombinedTextureImageUnits);
133     }
134
135     mSamplers.resize(caps.maxCombinedTextureImageUnits);
136
137     mActiveQueries[GL_ANY_SAMPLES_PASSED].set(NULL);
138     mActiveQueries[GL_ANY_SAMPLES_PASSED_CONSERVATIVE].set(NULL);
139     mActiveQueries[GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN].set(NULL);
140
141     mCurrentProgramId = 0;
142     mCurrentProgramBinary.set(NULL);
143
144     mReadFramebuffer = NULL;
145     mDrawFramebuffer = NULL;
146 }
147
148 void State::reset()
149 {
150     for (TextureBindingMap::iterator bindingVec = mSamplerTextures.begin(); bindingVec != mSamplerTextures.end(); bindingVec++)
151     {
152         TextureBindingVector &textureVector = bindingVec->second;
153         for (size_t textureIdx = 0; textureIdx < textureVector.size(); textureIdx++)
154         {
155             textureVector[textureIdx].set(NULL);
156         }
157     }
158     for (size_t samplerIdx = 0; samplerIdx < mSamplers.size(); samplerIdx++)
159     {
160         mSamplers[samplerIdx].set(NULL);
161     }
162
163     mArrayBuffer.set(NULL);
164     mRenderbuffer.set(NULL);
165
166     mTransformFeedback.set(NULL);
167
168     for (State::ActiveQueryMap::iterator i = mActiveQueries.begin(); i != mActiveQueries.end(); i++)
169     {
170         i->second.set(NULL);
171     }
172
173     mGenericUniformBuffer.set(NULL);
174     mGenericTransformFeedbackBuffer.set(NULL);
175     for (BufferVector::iterator bufItr = mUniformBuffers.begin(); bufItr != mUniformBuffers.end(); ++bufItr)
176     {
177         bufItr->set(NULL);
178     }
179
180     for (BufferVector::iterator bufItr = mTransformFeedbackBuffers.begin(); bufItr != mTransformFeedbackBuffers.end(); ++bufItr)
181     {
182         bufItr->set(NULL);
183     }
184
185     mCopyReadBuffer.set(NULL);
186     mCopyWriteBuffer.set(NULL);
187
188     mPack.pixelBuffer.set(NULL);
189     mUnpack.pixelBuffer.set(NULL);
190 }
191
192 const RasterizerState &State::getRasterizerState() const
193 {
194     return mRasterizer;
195 }
196
197 const BlendState &State::getBlendState() const
198 {
199     return mBlend;
200 }
201
202 const DepthStencilState &State::getDepthStencilState() const
203 {
204     return mDepthStencil;
205 }
206
207 void State::setClearColor(float red, float green, float blue, float alpha)
208 {
209     mColorClearValue.red = red;
210     mColorClearValue.green = green;
211     mColorClearValue.blue = blue;
212     mColorClearValue.alpha = alpha;
213 }
214
215 void State::setClearDepth(float depth)
216 {
217     mDepthClearValue = depth;
218 }
219
220 void State::setClearStencil(int stencil)
221 {
222     mStencilClearValue = stencil;
223 }
224
225 ClearParameters State::getClearParameters(GLbitfield mask) const
226 {
227     ClearParameters clearParams = { 0 };
228     for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
229     {
230         clearParams.clearColor[i] = false;
231     }
232     clearParams.colorFClearValue = mColorClearValue;
233     clearParams.colorClearType = GL_FLOAT;
234     clearParams.colorMaskRed = mBlend.colorMaskRed;
235     clearParams.colorMaskGreen = mBlend.colorMaskGreen;
236     clearParams.colorMaskBlue = mBlend.colorMaskBlue;
237     clearParams.colorMaskAlpha = mBlend.colorMaskAlpha;
238     clearParams.clearDepth = false;
239     clearParams.depthClearValue = mDepthClearValue;
240     clearParams.clearStencil = false;
241     clearParams.stencilClearValue = mStencilClearValue;
242     clearParams.stencilWriteMask = mDepthStencil.stencilWritemask;
243     clearParams.scissorEnabled = mScissorTest;
244     clearParams.scissor = mScissor;
245
246     const Framebuffer *framebufferObject = getDrawFramebuffer();
247     if (mask & GL_COLOR_BUFFER_BIT)
248     {
249         if (framebufferObject->hasEnabledColorAttachment())
250         {
251             for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
252             {
253                 clearParams.clearColor[i] = true;
254             }
255         }
256     }
257
258     if (mask & GL_DEPTH_BUFFER_BIT)
259     {
260         if (mDepthStencil.depthMask && framebufferObject->getDepthbuffer() != NULL)
261         {
262             clearParams.clearDepth = true;
263         }
264     }
265
266     if (mask & GL_STENCIL_BUFFER_BIT)
267     {
268         if (framebufferObject->getStencilbuffer() != NULL)
269         {
270             GLenum stencilActualFormat = framebufferObject->getStencilbuffer()->getActualFormat();
271             if (GetInternalFormatInfo(stencilActualFormat).stencilBits > 0)
272             {
273                 clearParams.clearStencil = true;
274             }
275         }
276     }
277
278     return clearParams;
279 }
280
281 void State::setColorMask(bool red, bool green, bool blue, bool alpha)
282 {
283     mBlend.colorMaskRed = red;
284     mBlend.colorMaskGreen = green;
285     mBlend.colorMaskBlue = blue;
286     mBlend.colorMaskAlpha = alpha;
287 }
288
289 void State::setDepthMask(bool mask)
290 {
291     mDepthStencil.depthMask = mask;
292 }
293
294 bool State::isRasterizerDiscardEnabled() const
295 {
296     return mRasterizer.rasterizerDiscard;
297 }
298
299 void State::setRasterizerDiscard(bool enabled)
300 {
301     mRasterizer.rasterizerDiscard = enabled;
302 }
303
304 bool State::isCullFaceEnabled() const
305 {
306     return mRasterizer.cullFace;
307 }
308
309 void State::setCullFace(bool enabled)
310 {
311     mRasterizer.cullFace = enabled;
312 }
313
314 void State::setCullMode(GLenum mode)
315 {
316     mRasterizer.cullMode = mode;
317 }
318
319 void State::setFrontFace(GLenum front)
320 {
321     mRasterizer.frontFace = front;
322 }
323
324 bool State::isDepthTestEnabled() const
325 {
326     return mDepthStencil.depthTest;
327 }
328
329 void State::setDepthTest(bool enabled)
330 {
331     mDepthStencil.depthTest = enabled;
332 }
333
334 void State::setDepthFunc(GLenum depthFunc)
335 {
336      mDepthStencil.depthFunc = depthFunc;
337 }
338
339 void State::setDepthRange(float zNear, float zFar)
340 {
341     mNearZ = zNear;
342     mFarZ = zFar;
343 }
344
345 void State::getDepthRange(float *zNear, float *zFar) const
346 {
347     *zNear = mNearZ;
348     *zFar = mFarZ;
349 }
350
351 bool State::isBlendEnabled() const
352 {
353     return mBlend.blend;
354 }
355
356 void State::setBlend(bool enabled)
357 {
358     mBlend.blend = enabled;
359 }
360
361 void State::setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha)
362 {
363     mBlend.sourceBlendRGB = sourceRGB;
364     mBlend.destBlendRGB = destRGB;
365     mBlend.sourceBlendAlpha = sourceAlpha;
366     mBlend.destBlendAlpha = destAlpha;
367 }
368
369 void State::setBlendColor(float red, float green, float blue, float alpha)
370 {
371     mBlendColor.red = red;
372     mBlendColor.green = green;
373     mBlendColor.blue = blue;
374     mBlendColor.alpha = alpha;
375 }
376
377 void State::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
378 {
379     mBlend.blendEquationRGB = rgbEquation;
380     mBlend.blendEquationAlpha = alphaEquation;
381 }
382
383 const ColorF &State::getBlendColor() const
384 {
385     return mBlendColor;
386 }
387
388 bool State::isStencilTestEnabled() const
389 {
390     return mDepthStencil.stencilTest;
391 }
392
393 void State::setStencilTest(bool enabled)
394 {
395     mDepthStencil.stencilTest = enabled;
396 }
397
398 void State::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask)
399 {
400     mDepthStencil.stencilFunc = stencilFunc;
401     mStencilRef = (stencilRef > 0) ? stencilRef : 0;
402     mDepthStencil.stencilMask = stencilMask;
403 }
404
405 void State::setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask)
406 {
407     mDepthStencil.stencilBackFunc = stencilBackFunc;
408     mStencilBackRef = (stencilBackRef > 0) ? stencilBackRef : 0;
409     mDepthStencil.stencilBackMask = stencilBackMask;
410 }
411
412 void State::setStencilWritemask(GLuint stencilWritemask)
413 {
414     mDepthStencil.stencilWritemask = stencilWritemask;
415 }
416
417 void State::setStencilBackWritemask(GLuint stencilBackWritemask)
418 {
419     mDepthStencil.stencilBackWritemask = stencilBackWritemask;
420 }
421
422 void State::setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass)
423 {
424     mDepthStencil.stencilFail = stencilFail;
425     mDepthStencil.stencilPassDepthFail = stencilPassDepthFail;
426     mDepthStencil.stencilPassDepthPass = stencilPassDepthPass;
427 }
428
429 void State::setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass)
430 {
431     mDepthStencil.stencilBackFail = stencilBackFail;
432     mDepthStencil.stencilBackPassDepthFail = stencilBackPassDepthFail;
433     mDepthStencil.stencilBackPassDepthPass = stencilBackPassDepthPass;
434 }
435
436 GLint State::getStencilRef() const
437 {
438     return mStencilRef;
439 }
440
441 GLint State::getStencilBackRef() const
442 {
443     return mStencilBackRef;
444 }
445
446 bool State::isPolygonOffsetFillEnabled() const
447 {
448     return mRasterizer.polygonOffsetFill;
449 }
450
451 void State::setPolygonOffsetFill(bool enabled)
452 {
453      mRasterizer.polygonOffsetFill = enabled;
454 }
455
456 void State::setPolygonOffsetParams(GLfloat factor, GLfloat units)
457 {
458     // An application can pass NaN values here, so handle this gracefully
459     mRasterizer.polygonOffsetFactor = factor != factor ? 0.0f : factor;
460     mRasterizer.polygonOffsetUnits = units != units ? 0.0f : units;
461 }
462
463 bool State::isSampleAlphaToCoverageEnabled() const
464 {
465     return mBlend.sampleAlphaToCoverage;
466 }
467
468 void State::setSampleAlphaToCoverage(bool enabled)
469 {
470     mBlend.sampleAlphaToCoverage = enabled;
471 }
472
473 bool State::isSampleCoverageEnabled() const
474 {
475     return mSampleCoverage;
476 }
477
478 void State::setSampleCoverage(bool enabled)
479 {
480     mSampleCoverage = enabled;
481 }
482
483 void State::setSampleCoverageParams(GLclampf value, bool invert)
484 {
485     mSampleCoverageValue = value;
486     mSampleCoverageInvert = invert;
487 }
488
489 void State::getSampleCoverageParams(GLclampf *value, bool *invert)
490 {
491     ASSERT(value != NULL && invert != NULL);
492
493     *value = mSampleCoverageValue;
494     *invert = mSampleCoverageInvert;
495 }
496
497 bool State::isScissorTestEnabled() const
498 {
499     return mScissorTest;
500 }
501
502 void State::setScissorTest(bool enabled)
503 {
504     mScissorTest = enabled;
505 }
506
507 void State::setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height)
508 {
509     mScissor.x = x;
510     mScissor.y = y;
511     mScissor.width = width;
512     mScissor.height = height;
513 }
514
515 const Rectangle &State::getScissor() const
516 {
517     return mScissor;
518 }
519
520 bool State::isDitherEnabled() const
521 {
522     return mBlend.dither;
523 }
524
525 void State::setDither(bool enabled)
526 {
527     mBlend.dither = enabled;
528 }
529
530 void State::setEnableFeature(GLenum feature, bool enabled)
531 {
532     switch (feature)
533     {
534       case GL_CULL_FACE:                     setCullFace(enabled);              break;
535       case GL_POLYGON_OFFSET_FILL:           setPolygonOffsetFill(enabled);     break;
536       case GL_SAMPLE_ALPHA_TO_COVERAGE:      setSampleAlphaToCoverage(enabled); break;
537       case GL_SAMPLE_COVERAGE:               setSampleCoverage(enabled);        break;
538       case GL_SCISSOR_TEST:                  setScissorTest(enabled);           break;
539       case GL_STENCIL_TEST:                  setStencilTest(enabled);           break;
540       case GL_DEPTH_TEST:                    setDepthTest(enabled);             break;
541       case GL_BLEND:                         setBlend(enabled);                 break;
542       case GL_DITHER:                        setDither(enabled);                break;
543       case GL_PRIMITIVE_RESTART_FIXED_INDEX: UNIMPLEMENTED();                   break;
544       case GL_RASTERIZER_DISCARD:            setRasterizerDiscard(enabled);     break;
545       default:                               UNREACHABLE();
546     }
547 }
548
549 bool State::getEnableFeature(GLenum feature)
550 {
551     switch (feature)
552     {
553       case GL_CULL_FACE:                     return isCullFaceEnabled();
554       case GL_POLYGON_OFFSET_FILL:           return isPolygonOffsetFillEnabled();
555       case GL_SAMPLE_ALPHA_TO_COVERAGE:      return isSampleAlphaToCoverageEnabled();
556       case GL_SAMPLE_COVERAGE:               return isSampleCoverageEnabled();
557       case GL_SCISSOR_TEST:                  return isScissorTestEnabled();
558       case GL_STENCIL_TEST:                  return isStencilTestEnabled();
559       case GL_DEPTH_TEST:                    return isDepthTestEnabled();
560       case GL_BLEND:                         return isBlendEnabled();
561       case GL_DITHER:                        return isDitherEnabled();
562       case GL_PRIMITIVE_RESTART_FIXED_INDEX: UNIMPLEMENTED(); return false;
563       case GL_RASTERIZER_DISCARD:            return isRasterizerDiscardEnabled();
564       default:                               UNREACHABLE(); return false;
565     }
566 }
567
568 void State::setLineWidth(GLfloat width)
569 {
570     mLineWidth = width;
571 }
572
573 void State::setGenerateMipmapHint(GLenum hint)
574 {
575     mGenerateMipmapHint = hint;
576 }
577
578 void State::setFragmentShaderDerivativeHint(GLenum hint)
579 {
580     mFragmentShaderDerivativeHint = hint;
581     // TODO: Propagate the hint to shader translator so we can write
582     // ddx, ddx_coarse, or ddx_fine depending on the hint.
583     // Ignore for now. It is valid for implementations to ignore hint.
584 }
585
586 void State::setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height)
587 {
588     mViewport.x = x;
589     mViewport.y = y;
590     mViewport.width = width;
591     mViewport.height = height;
592 }
593
594 const Rectangle &State::getViewport() const
595 {
596     return mViewport;
597 }
598
599 void State::setActiveSampler(unsigned int active)
600 {
601     mActiveSampler = active;
602 }
603
604 unsigned int State::getActiveSampler() const
605 {
606     return mActiveSampler;
607 }
608
609 void State::setSamplerTexture(GLenum type, Texture *texture)
610 {
611     mSamplerTextures[type][mActiveSampler].set(texture);
612 }
613
614 Texture *State::getSamplerTexture(unsigned int sampler, GLenum type) const
615 {
616     const BindingPointer<Texture>& binding = mSamplerTextures.at(type)[sampler];
617
618     if (binding.id() == 0)   // Special case: 0 refers to default textures held by Context
619     {
620         return NULL;
621     }
622
623     return binding.get();
624 }
625
626 GLuint State::getSamplerTextureId(unsigned int sampler, GLenum type) const
627 {
628     return mSamplerTextures.at(type)[sampler].id();
629 }
630
631 void State::detachTexture(GLuint texture)
632 {
633     // Textures have a detach method on State rather than a simple
634     // removeBinding, because the zero/null texture objects are managed
635     // separately, and don't have to go through the Context's maps or
636     // the ResourceManager.
637
638     // [OpenGL ES 2.0.24] section 3.8 page 84:
639     // If a texture object is deleted, it is as if all texture units which are bound to that texture object are
640     // rebound to texture object zero
641
642     for (TextureBindingMap::iterator bindingVec = mSamplerTextures.begin(); bindingVec != mSamplerTextures.end(); bindingVec++)
643     {
644         TextureBindingVector &textureVector = bindingVec->second;
645         for (size_t textureIdx = 0; textureIdx < textureVector.size(); textureIdx++)
646         {
647             BindingPointer<Texture> &binding = textureVector[textureIdx];
648             if (binding.id() == texture)
649             {
650                 binding.set(NULL);
651             }
652         }
653     }
654
655     // [OpenGL ES 2.0.24] section 4.4 page 112:
656     // If a texture object is deleted while its image is attached to the currently bound framebuffer, then it is
657     // as if Texture2DAttachment had been called, with a texture of 0, for each attachment point to which this
658     // image was attached in the currently bound framebuffer.
659
660     if (mReadFramebuffer)
661     {
662         mReadFramebuffer->detachTexture(texture);
663     }
664
665     if (mDrawFramebuffer)
666     {
667         mDrawFramebuffer->detachTexture(texture);
668     }
669 }
670
671 void State::setSamplerBinding(GLuint textureUnit, Sampler *sampler)
672 {
673     mSamplers[textureUnit].set(sampler);
674 }
675
676 GLuint State::getSamplerId(GLuint textureUnit) const
677 {
678     ASSERT(textureUnit < mSamplers.size());
679     return mSamplers[textureUnit].id();
680 }
681
682 Sampler *State::getSampler(GLuint textureUnit) const
683 {
684     return mSamplers[textureUnit].get();
685 }
686
687 void State::detachSampler(GLuint sampler)
688 {
689     // [OpenGL ES 3.0.2] section 3.8.2 pages 123-124:
690     // If a sampler object that is currently bound to one or more texture units is
691     // deleted, it is as though BindSampler is called once for each texture unit to
692     // which the sampler is bound, with unit set to the texture unit and sampler set to zero.
693     for (size_t textureUnit = 0; textureUnit < mSamplers.size(); textureUnit++)
694     {
695         BindingPointer<Sampler> &samplerBinding = mSamplers[textureUnit];
696         if (samplerBinding.id() == sampler)
697         {
698             samplerBinding.set(NULL);
699         }
700     }
701 }
702
703 void State::setRenderbufferBinding(Renderbuffer *renderbuffer)
704 {
705     mRenderbuffer.set(renderbuffer);
706 }
707
708 GLuint State::getRenderbufferId() const
709 {
710     return mRenderbuffer.id();
711 }
712
713 Renderbuffer *State::getCurrentRenderbuffer()
714 {
715     return mRenderbuffer.get();
716 }
717
718 void State::detachRenderbuffer(GLuint renderbuffer)
719 {
720     // [OpenGL ES 2.0.24] section 4.4 page 109:
721     // If a renderbuffer that is currently bound to RENDERBUFFER is deleted, it is as though BindRenderbuffer
722     // had been executed with the target RENDERBUFFER and name of zero.
723
724     if (mRenderbuffer.id() == renderbuffer)
725     {
726         mRenderbuffer.set(NULL);
727     }
728
729     // [OpenGL ES 2.0.24] section 4.4 page 111:
730     // If a renderbuffer object is deleted while its image is attached to the currently bound framebuffer,
731     // then it is as if FramebufferRenderbuffer had been called, with a renderbuffer of 0, for each attachment
732     // point to which this image was attached in the currently bound framebuffer.
733
734     Framebuffer *readFramebuffer = mReadFramebuffer;
735     Framebuffer *drawFramebuffer = mDrawFramebuffer;
736
737     if (readFramebuffer)
738     {
739         readFramebuffer->detachRenderbuffer(renderbuffer);
740     }
741
742     if (drawFramebuffer && drawFramebuffer != readFramebuffer)
743     {
744         drawFramebuffer->detachRenderbuffer(renderbuffer);
745     }
746
747 }
748
749 void State::setReadFramebufferBinding(Framebuffer *framebuffer)
750 {
751     mReadFramebuffer = framebuffer;
752 }
753
754 void State::setDrawFramebufferBinding(Framebuffer *framebuffer)
755 {
756     mDrawFramebuffer = framebuffer;
757 }
758
759 Framebuffer *State::getTargetFramebuffer(GLenum target) const
760 {
761     switch (target)
762     {
763     case GL_READ_FRAMEBUFFER_ANGLE:  return mReadFramebuffer;
764     case GL_DRAW_FRAMEBUFFER_ANGLE:
765     case GL_FRAMEBUFFER:             return mDrawFramebuffer;
766     default:                         UNREACHABLE(); return NULL;
767     }
768 }
769
770 Framebuffer *State::getReadFramebuffer()
771 {
772     return mReadFramebuffer;
773 }
774
775 Framebuffer *State::getDrawFramebuffer()
776 {
777     return mDrawFramebuffer;
778 }
779
780 const Framebuffer *State::getReadFramebuffer() const
781 {
782     return mReadFramebuffer;
783 }
784
785 const Framebuffer *State::getDrawFramebuffer() const
786 {
787     return mDrawFramebuffer;
788 }
789
790 bool State::removeReadFramebufferBinding(GLuint framebuffer)
791 {
792     if (mReadFramebuffer->id() == framebuffer)
793     {
794         mReadFramebuffer = NULL;
795         return true;
796     }
797
798     return false;
799 }
800
801 bool State::removeDrawFramebufferBinding(GLuint framebuffer)
802 {
803     if (mDrawFramebuffer->id() == framebuffer)
804     {
805         mDrawFramebuffer = NULL;
806         return true;
807     }
808
809     return false;
810 }
811
812 void State::setVertexArrayBinding(VertexArray *vertexArray)
813 {
814     mVertexArray = vertexArray;
815 }
816
817 GLuint State::getVertexArrayId() const
818 {
819     ASSERT(mVertexArray != NULL);
820     return mVertexArray->id();
821 }
822
823 VertexArray *State::getVertexArray() const
824 {
825     ASSERT(mVertexArray != NULL);
826     return mVertexArray;
827 }
828
829 bool State::removeVertexArrayBinding(GLuint vertexArray)
830 {
831     if (mVertexArray->id() == vertexArray)
832     {
833         mVertexArray = NULL;
834         return true;
835     }
836
837     return false;
838 }
839
840 void State::setCurrentProgram(GLuint programId, Program *newProgram)
841 {
842     mCurrentProgramId = programId; // set new ID before trying to delete program binary; otherwise it will only be flagged for deletion
843     mCurrentProgramBinary.set(NULL);
844
845     if (newProgram)
846     {
847         newProgram->addRef();
848         mCurrentProgramBinary.set(newProgram->getProgramBinary());
849     }
850 }
851
852 void State::setCurrentProgramBinary(ProgramBinary *binary)
853 {
854     mCurrentProgramBinary.set(binary);
855 }
856
857 GLuint State::getCurrentProgramId() const
858 {
859     return mCurrentProgramId;
860 }
861
862 ProgramBinary *State::getCurrentProgramBinary() const
863 {
864     return mCurrentProgramBinary.get();
865 }
866
867 void State::setTransformFeedbackBinding(TransformFeedback *transformFeedback)
868 {
869     mTransformFeedback.set(transformFeedback);
870 }
871
872 TransformFeedback *State::getCurrentTransformFeedback() const
873 {
874     return mTransformFeedback.get();
875 }
876
877 void State::detachTransformFeedback(GLuint transformFeedback)
878 {
879     if (mTransformFeedback.id() == transformFeedback)
880     {
881         mTransformFeedback.set(NULL);
882     }
883 }
884
885 bool State::isQueryActive() const
886 {
887     for (State::ActiveQueryMap::const_iterator i = mActiveQueries.begin();
888         i != mActiveQueries.end(); i++)
889     {
890         if (i->second.get() != NULL)
891         {
892             return true;
893         }
894     }
895
896     return false;
897 }
898
899 void State::setActiveQuery(GLenum target, Query *query)
900 {
901     mActiveQueries[target].set(query);
902 }
903
904 GLuint State::getActiveQueryId(GLenum target) const
905 {
906     const Query *query = getActiveQuery(target);
907     return (query ? query->id() : 0u);
908 }
909
910 Query *State::getActiveQuery(GLenum target) const
911 {
912     // All query types should already exist in the activeQueries map
913     ASSERT(mActiveQueries.find(target) != mActiveQueries.end());
914
915     return mActiveQueries.at(target).get();
916 }
917
918 void State::setArrayBufferBinding(Buffer *buffer)
919 {
920     mArrayBuffer.set(buffer);
921 }
922
923 GLuint State::getArrayBufferId() const
924 {
925     return mArrayBuffer.id();
926 }
927
928 bool State::removeArrayBufferBinding(GLuint buffer)
929 {
930     if (mArrayBuffer.id() == buffer)
931     {
932         mArrayBuffer.set(NULL);
933         return true;
934     }
935
936     return false;
937 }
938
939 void State::setGenericUniformBufferBinding(Buffer *buffer)
940 {
941     mGenericUniformBuffer.set(buffer);
942 }
943
944 void State::setIndexedUniformBufferBinding(GLuint index, Buffer *buffer, GLintptr offset, GLsizeiptr size)
945 {
946     mUniformBuffers[index].set(buffer, offset, size);
947 }
948
949 GLuint State::getIndexedUniformBufferId(GLuint index) const
950 {
951     ASSERT(static_cast<size_t>(index) < mUniformBuffers.size());
952
953     return mUniformBuffers[index].id();
954 }
955
956 Buffer *State::getIndexedUniformBuffer(GLuint index) const
957 {
958     ASSERT(static_cast<size_t>(index) < mUniformBuffers.size());
959
960     return mUniformBuffers[index].get();
961 }
962
963 void State::setGenericTransformFeedbackBufferBinding(Buffer *buffer)
964 {
965     mGenericTransformFeedbackBuffer.set(buffer);
966 }
967
968 void State::setIndexedTransformFeedbackBufferBinding(GLuint index, Buffer *buffer, GLintptr offset, GLsizeiptr size)
969 {
970     mTransformFeedbackBuffers[index].set(buffer, offset, size);
971 }
972
973 GLuint State::getIndexedTransformFeedbackBufferId(GLuint index) const
974 {
975     ASSERT(static_cast<size_t>(index) < mTransformFeedbackBuffers.size());
976
977     return mTransformFeedbackBuffers[index].id();
978 }
979
980 Buffer *State::getIndexedTransformFeedbackBuffer(GLuint index) const
981 {
982     ASSERT(static_cast<size_t>(index) < mTransformFeedbackBuffers.size());
983
984     return mTransformFeedbackBuffers[index].get();
985 }
986
987 GLuint State::getIndexedTransformFeedbackBufferOffset(GLuint index) const
988 {
989     ASSERT(static_cast<size_t>(index) < mTransformFeedbackBuffers.size());
990
991     return mTransformFeedbackBuffers[index].getOffset();
992 }
993
994 size_t State::getTransformFeedbackBufferIndexRange() const
995 {
996     return mTransformFeedbackBuffers.size();
997 }
998
999 void State::setCopyReadBufferBinding(Buffer *buffer)
1000 {
1001     mCopyReadBuffer.set(buffer);
1002 }
1003
1004 void State::setCopyWriteBufferBinding(Buffer *buffer)
1005 {
1006     mCopyWriteBuffer.set(buffer);
1007 }
1008
1009 void State::setPixelPackBufferBinding(Buffer *buffer)
1010 {
1011     mPack.pixelBuffer.set(buffer);
1012 }
1013
1014 void State::setPixelUnpackBufferBinding(Buffer *buffer)
1015 {
1016     mUnpack.pixelBuffer.set(buffer);
1017 }
1018
1019 Buffer *State::getTargetBuffer(GLenum target) const
1020 {
1021     switch (target)
1022     {
1023       case GL_ARRAY_BUFFER:              return mArrayBuffer.get();
1024       case GL_COPY_READ_BUFFER:          return mCopyReadBuffer.get();
1025       case GL_COPY_WRITE_BUFFER:         return mCopyWriteBuffer.get();
1026       case GL_ELEMENT_ARRAY_BUFFER:      return getVertexArray()->getElementArrayBuffer();
1027       case GL_PIXEL_PACK_BUFFER:         return mPack.pixelBuffer.get();
1028       case GL_PIXEL_UNPACK_BUFFER:       return mUnpack.pixelBuffer.get();
1029       case GL_TRANSFORM_FEEDBACK_BUFFER: return mGenericTransformFeedbackBuffer.get();
1030       case GL_UNIFORM_BUFFER:            return mGenericUniformBuffer.get();
1031       default: UNREACHABLE();            return NULL;
1032     }
1033 }
1034
1035 void State::setEnableVertexAttribArray(unsigned int attribNum, bool enabled)
1036 {
1037     getVertexArray()->enableAttribute(attribNum, enabled);
1038 }
1039
1040 void State::setVertexAttribf(GLuint index, const GLfloat values[4])
1041 {
1042     ASSERT(static_cast<size_t>(index) < mVertexAttribCurrentValues.size());
1043     mVertexAttribCurrentValues[index].setFloatValues(values);
1044 }
1045
1046 void State::setVertexAttribu(GLuint index, const GLuint values[4])
1047 {
1048     ASSERT(static_cast<size_t>(index) < mVertexAttribCurrentValues.size());
1049     mVertexAttribCurrentValues[index].setUnsignedIntValues(values);
1050 }
1051
1052 void State::setVertexAttribi(GLuint index, const GLint values[4])
1053 {
1054     ASSERT(static_cast<size_t>(index) < mVertexAttribCurrentValues.size());
1055     mVertexAttribCurrentValues[index].setIntValues(values);
1056 }
1057
1058 void State::setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type, bool normalized,
1059     bool pureInteger, GLsizei stride, const void *pointer)
1060 {
1061     getVertexArray()->setAttributeState(attribNum, boundBuffer, size, type, normalized, pureInteger, stride, pointer);
1062 }
1063
1064 const VertexAttribute &State::getVertexAttribState(unsigned int attribNum) const
1065 {
1066     return getVertexArray()->getVertexAttribute(attribNum);
1067 }
1068
1069 const VertexAttribCurrentValueData &State::getVertexAttribCurrentValue(unsigned int attribNum) const
1070 {
1071     ASSERT(static_cast<size_t>(attribNum) < mVertexAttribCurrentValues.size());
1072     return mVertexAttribCurrentValues[attribNum];
1073 }
1074
1075 const void *State::getVertexAttribPointer(unsigned int attribNum) const
1076 {
1077     return getVertexArray()->getVertexAttribute(attribNum).pointer;
1078 }
1079
1080 void State::setPackAlignment(GLint alignment)
1081 {
1082     mPack.alignment = alignment;
1083 }
1084
1085 GLint State::getPackAlignment() const
1086 {
1087     return mPack.alignment;
1088 }
1089
1090 void State::setPackReverseRowOrder(bool reverseRowOrder)
1091 {
1092     mPack.reverseRowOrder = reverseRowOrder;
1093 }
1094
1095 bool State::getPackReverseRowOrder() const
1096 {
1097     return mPack.reverseRowOrder;
1098 }
1099
1100 const PixelPackState &State::getPackState() const
1101 {
1102     return mPack;
1103 }
1104
1105 void State::setUnpackAlignment(GLint alignment)
1106 {
1107     mUnpack.alignment = alignment;
1108 }
1109
1110 GLint State::getUnpackAlignment() const
1111 {
1112     return mUnpack.alignment;
1113 }
1114
1115 const PixelUnpackState &State::getUnpackState() const
1116 {
1117     return mUnpack;
1118 }
1119
1120 void State::getBooleanv(GLenum pname, GLboolean *params)
1121 {
1122     switch (pname)
1123     {
1124       case GL_SAMPLE_COVERAGE_INVERT:    *params = mSampleCoverageInvert;         break;
1125       case GL_DEPTH_WRITEMASK:           *params = mDepthStencil.depthMask;       break;
1126       case GL_COLOR_WRITEMASK:
1127         params[0] = mBlend.colorMaskRed;
1128         params[1] = mBlend.colorMaskGreen;
1129         params[2] = mBlend.colorMaskBlue;
1130         params[3] = mBlend.colorMaskAlpha;
1131         break;
1132       case GL_CULL_FACE:                 *params = mRasterizer.cullFace;          break;
1133       case GL_POLYGON_OFFSET_FILL:       *params = mRasterizer.polygonOffsetFill; break;
1134       case GL_SAMPLE_ALPHA_TO_COVERAGE:  *params = mBlend.sampleAlphaToCoverage;  break;
1135       case GL_SAMPLE_COVERAGE:           *params = mSampleCoverage;               break;
1136       case GL_SCISSOR_TEST:              *params = mScissorTest;                  break;
1137       case GL_STENCIL_TEST:              *params = mDepthStencil.stencilTest;     break;
1138       case GL_DEPTH_TEST:                *params = mDepthStencil.depthTest;       break;
1139       case GL_BLEND:                     *params = mBlend.blend;                  break;
1140       case GL_DITHER:                    *params = mBlend.dither;                 break;
1141       case GL_TRANSFORM_FEEDBACK_ACTIVE: *params = getCurrentTransformFeedback()->isStarted(); break;
1142       case GL_TRANSFORM_FEEDBACK_PAUSED: *params = getCurrentTransformFeedback()->isPaused();  break;
1143       default:
1144         UNREACHABLE();
1145         break;
1146     }
1147 }
1148
1149 void State::getFloatv(GLenum pname, GLfloat *params)
1150 {
1151     // Please note: DEPTH_CLEAR_VALUE is included in our internal getFloatv implementation
1152     // because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1153     // GetIntegerv as its native query function. As it would require conversion in any
1154     // case, this should make no difference to the calling application.
1155     switch (pname)
1156     {
1157       case GL_LINE_WIDTH:               *params = mLineWidth;                         break;
1158       case GL_SAMPLE_COVERAGE_VALUE:    *params = mSampleCoverageValue;               break;
1159       case GL_DEPTH_CLEAR_VALUE:        *params = mDepthClearValue;                   break;
1160       case GL_POLYGON_OFFSET_FACTOR:    *params = mRasterizer.polygonOffsetFactor;    break;
1161       case GL_POLYGON_OFFSET_UNITS:     *params = mRasterizer.polygonOffsetUnits;     break;
1162       case GL_DEPTH_RANGE:
1163         params[0] = mNearZ;
1164         params[1] = mFarZ;
1165         break;
1166       case GL_COLOR_CLEAR_VALUE:
1167         params[0] = mColorClearValue.red;
1168         params[1] = mColorClearValue.green;
1169         params[2] = mColorClearValue.blue;
1170         params[3] = mColorClearValue.alpha;
1171         break;
1172       case GL_BLEND_COLOR:
1173         params[0] = mBlendColor.red;
1174         params[1] = mBlendColor.green;
1175         params[2] = mBlendColor.blue;
1176         params[3] = mBlendColor.alpha;
1177         break;
1178       default:
1179         UNREACHABLE();
1180         break;
1181     }
1182 }
1183
1184 void State::getIntegerv(GLenum pname, GLint *params)
1185 {
1186     if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT)
1187     {
1188         unsigned int colorAttachment = (pname - GL_DRAW_BUFFER0_EXT);
1189         ASSERT(colorAttachment < mMaxDrawBuffers);
1190         Framebuffer *framebuffer = mDrawFramebuffer;
1191         *params = framebuffer->getDrawBufferState(colorAttachment);
1192         return;
1193     }
1194
1195     // Please note: DEPTH_CLEAR_VALUE is not included in our internal getIntegerv implementation
1196     // because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1197     // GetIntegerv as its native query function. As it would require conversion in any
1198     // case, this should make no difference to the calling application. You may find it in
1199     // State::getFloatv.
1200     switch (pname)
1201     {
1202       case GL_ARRAY_BUFFER_BINDING:                     *params = mArrayBuffer.id();                              break;
1203       case GL_ELEMENT_ARRAY_BUFFER_BINDING:             *params = getVertexArray()->getElementArrayBufferId();    break;
1204         //case GL_FRAMEBUFFER_BINDING:                    // now equivalent to GL_DRAW_FRAMEBUFFER_BINDING_ANGLE
1205       case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE:           *params = mDrawFramebuffer->id();                         break;
1206       case GL_READ_FRAMEBUFFER_BINDING_ANGLE:           *params = mReadFramebuffer->id();                         break;
1207       case GL_RENDERBUFFER_BINDING:                     *params = mRenderbuffer.id();                             break;
1208       case GL_VERTEX_ARRAY_BINDING:                     *params = mVertexArray->id();                             break;
1209       case GL_CURRENT_PROGRAM:                          *params = mCurrentProgramId;                              break;
1210       case GL_PACK_ALIGNMENT:                           *params = mPack.alignment;                                break;
1211       case GL_PACK_REVERSE_ROW_ORDER_ANGLE:             *params = mPack.reverseRowOrder;                          break;
1212       case GL_UNPACK_ALIGNMENT:                         *params = mUnpack.alignment;                              break;
1213       case GL_GENERATE_MIPMAP_HINT:                     *params = mGenerateMipmapHint;                            break;
1214       case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:      *params = mFragmentShaderDerivativeHint;                  break;
1215       case GL_ACTIVE_TEXTURE:                           *params = (mActiveSampler + GL_TEXTURE0);                 break;
1216       case GL_STENCIL_FUNC:                             *params = mDepthStencil.stencilFunc;                      break;
1217       case GL_STENCIL_REF:                              *params = mStencilRef;                                    break;
1218       case GL_STENCIL_VALUE_MASK:                       *params = clampToInt(mDepthStencil.stencilMask);          break;
1219       case GL_STENCIL_BACK_FUNC:                        *params = mDepthStencil.stencilBackFunc;                  break;
1220       case GL_STENCIL_BACK_REF:                         *params = mStencilBackRef;                                break;
1221       case GL_STENCIL_BACK_VALUE_MASK:                  *params = clampToInt(mDepthStencil.stencilBackMask);      break;
1222       case GL_STENCIL_FAIL:                             *params = mDepthStencil.stencilFail;                      break;
1223       case GL_STENCIL_PASS_DEPTH_FAIL:                  *params = mDepthStencil.stencilPassDepthFail;             break;
1224       case GL_STENCIL_PASS_DEPTH_PASS:                  *params = mDepthStencil.stencilPassDepthPass;             break;
1225       case GL_STENCIL_BACK_FAIL:                        *params = mDepthStencil.stencilBackFail;                  break;
1226       case GL_STENCIL_BACK_PASS_DEPTH_FAIL:             *params = mDepthStencil.stencilBackPassDepthFail;         break;
1227       case GL_STENCIL_BACK_PASS_DEPTH_PASS:             *params = mDepthStencil.stencilBackPassDepthPass;         break;
1228       case GL_DEPTH_FUNC:                               *params = mDepthStencil.depthFunc;                        break;
1229       case GL_BLEND_SRC_RGB:                            *params = mBlend.sourceBlendRGB;                          break;
1230       case GL_BLEND_SRC_ALPHA:                          *params = mBlend.sourceBlendAlpha;                        break;
1231       case GL_BLEND_DST_RGB:                            *params = mBlend.destBlendRGB;                            break;
1232       case GL_BLEND_DST_ALPHA:                          *params = mBlend.destBlendAlpha;                          break;
1233       case GL_BLEND_EQUATION_RGB:                       *params = mBlend.blendEquationRGB;                        break;
1234       case GL_BLEND_EQUATION_ALPHA:                     *params = mBlend.blendEquationAlpha;                      break;
1235       case GL_STENCIL_WRITEMASK:                        *params = clampToInt(mDepthStencil.stencilWritemask);     break;
1236       case GL_STENCIL_BACK_WRITEMASK:                   *params = clampToInt(mDepthStencil.stencilBackWritemask); break;
1237       case GL_STENCIL_CLEAR_VALUE:                      *params = mStencilClearValue;                             break;
1238       case GL_SAMPLE_BUFFERS:
1239       case GL_SAMPLES:
1240         {
1241             gl::Framebuffer *framebuffer = mDrawFramebuffer;
1242             if (framebuffer->completeness() == GL_FRAMEBUFFER_COMPLETE)
1243             {
1244                 switch (pname)
1245                 {
1246                   case GL_SAMPLE_BUFFERS:
1247                     if (framebuffer->getSamples() != 0)
1248                     {
1249                         *params = 1;
1250                     }
1251                     else
1252                     {
1253                         *params = 0;
1254                     }
1255                     break;
1256                   case GL_SAMPLES:
1257                     *params = framebuffer->getSamples();
1258                     break;
1259                 }
1260             }
1261             else
1262             {
1263                 *params = 0;
1264             }
1265         }
1266         break;
1267       case GL_VIEWPORT:
1268         params[0] = mViewport.x;
1269         params[1] = mViewport.y;
1270         params[2] = mViewport.width;
1271         params[3] = mViewport.height;
1272         break;
1273       case GL_SCISSOR_BOX:
1274         params[0] = mScissor.x;
1275         params[1] = mScissor.y;
1276         params[2] = mScissor.width;
1277         params[3] = mScissor.height;
1278         break;
1279       case GL_CULL_FACE_MODE:                   *params = mRasterizer.cullMode;   break;
1280       case GL_FRONT_FACE:                       *params = mRasterizer.frontFace;  break;
1281       case GL_RED_BITS:
1282       case GL_GREEN_BITS:
1283       case GL_BLUE_BITS:
1284       case GL_ALPHA_BITS:
1285         {
1286             gl::Framebuffer *framebuffer = getDrawFramebuffer();
1287             gl::FramebufferAttachment *colorbuffer = framebuffer->getFirstColorbuffer();
1288
1289             if (colorbuffer)
1290             {
1291                 switch (pname)
1292                 {
1293                 case GL_RED_BITS:   *params = colorbuffer->getRedSize();      break;
1294                 case GL_GREEN_BITS: *params = colorbuffer->getGreenSize();    break;
1295                 case GL_BLUE_BITS:  *params = colorbuffer->getBlueSize();     break;
1296                 case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize();    break;
1297                 }
1298             }
1299             else
1300             {
1301                 *params = 0;
1302             }
1303         }
1304         break;
1305       case GL_DEPTH_BITS:
1306         {
1307             gl::Framebuffer *framebuffer = getDrawFramebuffer();
1308             gl::FramebufferAttachment *depthbuffer = framebuffer->getDepthbuffer();
1309
1310             if (depthbuffer)
1311             {
1312                 *params = depthbuffer->getDepthSize();
1313             }
1314             else
1315             {
1316                 *params = 0;
1317             }
1318         }
1319         break;
1320       case GL_STENCIL_BITS:
1321         {
1322             gl::Framebuffer *framebuffer = getDrawFramebuffer();
1323             gl::FramebufferAttachment *stencilbuffer = framebuffer->getStencilbuffer();
1324
1325             if (stencilbuffer)
1326             {
1327                 *params = stencilbuffer->getStencilSize();
1328             }
1329             else
1330             {
1331                 *params = 0;
1332             }
1333         }
1334         break;
1335       case GL_TEXTURE_BINDING_2D:
1336         ASSERT(mActiveSampler < mMaxCombinedTextureImageUnits);
1337         *params = mSamplerTextures.at(GL_TEXTURE_2D)[mActiveSampler].id();
1338         break;
1339       case GL_TEXTURE_BINDING_CUBE_MAP:
1340         ASSERT(mActiveSampler < mMaxCombinedTextureImageUnits);
1341         *params = mSamplerTextures.at(GL_TEXTURE_CUBE_MAP)[mActiveSampler].id();
1342         break;
1343       case GL_TEXTURE_BINDING_3D:
1344         ASSERT(mActiveSampler < mMaxCombinedTextureImageUnits);
1345         *params = mSamplerTextures.at(GL_TEXTURE_3D)[mActiveSampler].id();
1346         break;
1347       case GL_TEXTURE_BINDING_2D_ARRAY:
1348         ASSERT(mActiveSampler < mMaxCombinedTextureImageUnits);
1349         *params = mSamplerTextures.at(GL_TEXTURE_2D_ARRAY)[mActiveSampler].id();
1350         break;
1351       case GL_UNIFORM_BUFFER_BINDING:
1352         *params = mGenericUniformBuffer.id();
1353         break;
1354       case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
1355         *params = mGenericTransformFeedbackBuffer.id();
1356         break;
1357       case GL_COPY_READ_BUFFER_BINDING:
1358         *params = mCopyReadBuffer.id();
1359         break;
1360       case GL_COPY_WRITE_BUFFER_BINDING:
1361         *params = mCopyWriteBuffer.id();
1362         break;
1363       case GL_PIXEL_PACK_BUFFER_BINDING:
1364         *params = mPack.pixelBuffer.id();
1365         break;
1366       case GL_PIXEL_UNPACK_BUFFER_BINDING:
1367         *params = mUnpack.pixelBuffer.id();
1368         break;
1369       default:
1370         UNREACHABLE();
1371         break;
1372     }
1373 }
1374
1375 bool State::getIndexedIntegerv(GLenum target, GLuint index, GLint *data)
1376 {
1377     switch (target)
1378     {
1379       case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
1380         if (static_cast<size_t>(index) < mTransformFeedbackBuffers.size())
1381         {
1382             *data = mTransformFeedbackBuffers[index].id();
1383         }
1384         break;
1385       case GL_UNIFORM_BUFFER_BINDING:
1386         if (static_cast<size_t>(index) < mUniformBuffers.size())
1387         {
1388             *data = mUniformBuffers[index].id();
1389         }
1390         break;
1391       default:
1392         return false;
1393     }
1394
1395     return true;
1396 }
1397
1398 bool State::getIndexedInteger64v(GLenum target, GLuint index, GLint64 *data)
1399 {
1400     switch (target)
1401     {
1402       case GL_TRANSFORM_FEEDBACK_BUFFER_START:
1403         if (static_cast<size_t>(index) < mTransformFeedbackBuffers.size())
1404         {
1405             *data = mTransformFeedbackBuffers[index].getOffset();
1406         }
1407         break;
1408       case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
1409         if (static_cast<size_t>(index) < mTransformFeedbackBuffers.size())
1410         {
1411             *data = mTransformFeedbackBuffers[index].getSize();
1412         }
1413         break;
1414       case GL_UNIFORM_BUFFER_START:
1415         if (static_cast<size_t>(index) < mUniformBuffers.size())
1416         {
1417             *data = mUniformBuffers[index].getOffset();
1418         }
1419         break;
1420       case GL_UNIFORM_BUFFER_SIZE:
1421         if (static_cast<size_t>(index) < mUniformBuffers.size())
1422         {
1423             *data = mUniformBuffers[index].getSize();
1424         }
1425         break;
1426       default:
1427         return false;
1428     }
1429
1430     return true;
1431 }
1432
1433 bool State::hasMappedBuffer(GLenum target) const
1434 {
1435     if (target == GL_ARRAY_BUFFER)
1436     {
1437         for (size_t attribIndex = 0; attribIndex < mVertexAttribCurrentValues.size(); attribIndex++)
1438         {
1439             const gl::VertexAttribute &vertexAttrib = getVertexAttribState(static_cast<unsigned int>(attribIndex));
1440             gl::Buffer *boundBuffer = vertexAttrib.buffer.get();
1441             if (vertexAttrib.enabled && boundBuffer && boundBuffer->isMapped())
1442             {
1443                 return true;
1444             }
1445         }
1446
1447         return false;
1448     }
1449     else
1450     {
1451         Buffer *buffer = getTargetBuffer(target);
1452         return (buffer && buffer->isMapped());
1453     }
1454 }
1455
1456 }