Context.cpp revision 94ca5b63700fab01e8aa3f3fc67a2753efdd866e
1// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//    http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Context.cpp: Implements the es2::Context class, managing all GL state and performing
16// rendering operations. It is the GLES2 specific implementation of EGLContext.
17
18#include "Context.h"
19
20#include "main.h"
21#include "mathutil.h"
22#include "utilities.h"
23#include "ResourceManager.h"
24#include "Buffer.h"
25#include "Fence.h"
26#include "Framebuffer.h"
27#include "Program.h"
28#include "Query.h"
29#include "Renderbuffer.h"
30#include "Sampler.h"
31#include "Shader.h"
32#include "Texture.h"
33#include "TransformFeedback.h"
34#include "VertexArray.h"
35#include "VertexDataManager.h"
36#include "IndexDataManager.h"
37#include "libEGL/Display.h"
38#include "common/Surface.hpp"
39#include "Common/Half.hpp"
40
41#include <EGL/eglext.h>
42
43#include <algorithm>
44#include <string>
45
46namespace es2
47{
48Context::Context(egl::Display *display, const Context *shareContext, EGLint clientVersion, const egl::Config *config)
49	: egl::Context(display), clientVersion(clientVersion), config(config)
50{
51	sw::Context *context = new sw::Context();
52	device = new es2::Device(context);
53
54	setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
55
56	mState.depthClearValue = 1.0f;
57	mState.stencilClearValue = 0;
58
59	mState.cullFaceEnabled = false;
60	mState.cullMode = GL_BACK;
61	mState.frontFace = GL_CCW;
62	mState.depthTestEnabled = false;
63	mState.depthFunc = GL_LESS;
64	mState.blendEnabled = false;
65	mState.sourceBlendRGB = GL_ONE;
66	mState.sourceBlendAlpha = GL_ONE;
67	mState.destBlendRGB = GL_ZERO;
68	mState.destBlendAlpha = GL_ZERO;
69	mState.blendEquationRGB = GL_FUNC_ADD;
70	mState.blendEquationAlpha = GL_FUNC_ADD;
71	mState.blendColor.red = 0;
72	mState.blendColor.green = 0;
73	mState.blendColor.blue = 0;
74	mState.blendColor.alpha = 0;
75	mState.stencilTestEnabled = false;
76	mState.stencilFunc = GL_ALWAYS;
77	mState.stencilRef = 0;
78	mState.stencilMask = 0xFFFFFFFFu;
79	mState.stencilWritemask = 0xFFFFFFFFu;
80	mState.stencilBackFunc = GL_ALWAYS;
81	mState.stencilBackRef = 0;
82	mState.stencilBackMask = 0xFFFFFFFFu;
83	mState.stencilBackWritemask = 0xFFFFFFFFu;
84	mState.stencilFail = GL_KEEP;
85	mState.stencilPassDepthFail = GL_KEEP;
86	mState.stencilPassDepthPass = GL_KEEP;
87	mState.stencilBackFail = GL_KEEP;
88	mState.stencilBackPassDepthFail = GL_KEEP;
89	mState.stencilBackPassDepthPass = GL_KEEP;
90	mState.polygonOffsetFillEnabled = false;
91	mState.polygonOffsetFactor = 0.0f;
92	mState.polygonOffsetUnits = 0.0f;
93	mState.sampleAlphaToCoverageEnabled = false;
94	mState.sampleCoverageEnabled = false;
95	mState.sampleCoverageValue = 1.0f;
96	mState.sampleCoverageInvert = false;
97	mState.scissorTestEnabled = false;
98	mState.ditherEnabled = true;
99	mState.primitiveRestartFixedIndexEnabled = false;
100	mState.rasterizerDiscardEnabled = false;
101	mState.generateMipmapHint = GL_DONT_CARE;
102	mState.fragmentShaderDerivativeHint = GL_DONT_CARE;
103	mState.textureFilteringHint = GL_DONT_CARE;
104
105	mState.lineWidth = 1.0f;
106
107	mState.viewportX = 0;
108	mState.viewportY = 0;
109	mState.viewportWidth = 0;
110	mState.viewportHeight = 0;
111	mState.zNear = 0.0f;
112	mState.zFar = 1.0f;
113
114	mState.scissorX = 0;
115	mState.scissorY = 0;
116	mState.scissorWidth = 0;
117	mState.scissorHeight = 0;
118
119	mState.colorMaskRed = true;
120	mState.colorMaskGreen = true;
121	mState.colorMaskBlue = true;
122	mState.colorMaskAlpha = true;
123	mState.depthMask = true;
124
125	if(shareContext)
126	{
127		mResourceManager = shareContext->mResourceManager;
128		mResourceManager->addRef();
129	}
130	else
131	{
132		mResourceManager = new ResourceManager();
133	}
134
135	// [OpenGL ES 2.0.24] section 3.7 page 83:
136	// In the initial state, TEXTURE_2D and TEXTURE_CUBE_MAP have twodimensional
137	// and cube map texture state vectors respectively associated with them.
138	// In order that access to these initial textures not be lost, they are treated as texture
139	// objects all of whose names are 0.
140
141	mTexture2DZero = new Texture2D(0);
142	mTexture3DZero = new Texture3D(0);
143	mTexture2DArrayZero = new Texture2DArray(0);
144	mTextureCubeMapZero = new TextureCubeMap(0);
145	mTextureExternalZero = new TextureExternal(0);
146
147	mState.activeSampler = 0;
148	bindVertexArray(0);
149	bindArrayBuffer(0);
150	bindElementArrayBuffer(0);
151	bindTextureCubeMap(0);
152	bindTexture2D(0);
153	bindReadFramebuffer(0);
154	bindDrawFramebuffer(0);
155	bindRenderbuffer(0);
156	bindGenericUniformBuffer(0);
157	bindTransformFeedback(0);
158
159	mState.currentProgram = 0;
160
161	mState.packAlignment = 4;
162	mState.unpackInfo.alignment = 4;
163	mState.packRowLength = 0;
164	mState.packImageHeight = 0;
165	mState.packSkipPixels = 0;
166	mState.packSkipRows = 0;
167	mState.packSkipImages = 0;
168	mState.unpackInfo.rowLength = 0;
169	mState.unpackInfo.imageHeight = 0;
170	mState.unpackInfo.skipPixels = 0;
171	mState.unpackInfo.skipRows = 0;
172	mState.unpackInfo.skipImages = 0;
173
174	mVertexDataManager = nullptr;
175	mIndexDataManager = nullptr;
176
177	mInvalidEnum = false;
178	mInvalidValue = false;
179	mInvalidOperation = false;
180	mOutOfMemory = false;
181	mInvalidFramebufferOperation = false;
182
183	mHasBeenCurrent = false;
184
185	markAllStateDirty();
186}
187
188Context::~Context()
189{
190	if(mState.currentProgram != 0)
191	{
192		Program *programObject = mResourceManager->getProgram(mState.currentProgram);
193		if(programObject)
194		{
195			programObject->release();
196		}
197		mState.currentProgram = 0;
198	}
199
200	while(!mFramebufferNameSpace.empty())
201	{
202		deleteFramebuffer(mFramebufferNameSpace.firstName());
203	}
204
205	while(!mFenceNameSpace.empty())
206	{
207		deleteFence(mFenceNameSpace.firstName());
208	}
209
210	while(!mQueryNameSpace.empty())
211	{
212		deleteQuery(mQueryNameSpace.firstName());
213	}
214
215	while(!mVertexArrayNameSpace.empty())
216	{
217		deleteVertexArray(mVertexArrayNameSpace.lastName());
218	}
219
220	while(!mTransformFeedbackNameSpace.empty())
221	{
222		deleteTransformFeedback(mTransformFeedbackNameSpace.firstName());
223	}
224
225	for(int type = 0; type < TEXTURE_TYPE_COUNT; type++)
226	{
227		for(int sampler = 0; sampler < MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++)
228		{
229			mState.samplerTexture[type][sampler] = nullptr;
230		}
231	}
232
233	for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
234	{
235		mState.vertexAttribute[i].mBoundBuffer = nullptr;
236	}
237
238	for(int i = 0; i < QUERY_TYPE_COUNT; i++)
239	{
240		mState.activeQuery[i] = nullptr;
241	}
242
243	mState.arrayBuffer = nullptr;
244	mState.copyReadBuffer = nullptr;
245	mState.copyWriteBuffer = nullptr;
246	mState.pixelPackBuffer = nullptr;
247	mState.pixelUnpackBuffer = nullptr;
248	mState.genericUniformBuffer = nullptr;
249
250	for(int i = 0; i < MAX_UNIFORM_BUFFER_BINDINGS; i++) {
251		mState.uniformBuffers[i].set(nullptr, 0, 0);
252	}
253
254	mState.renderbuffer = nullptr;
255
256	for(int i = 0; i < MAX_COMBINED_TEXTURE_IMAGE_UNITS; ++i)
257	{
258		mState.sampler[i] = nullptr;
259	}
260
261	mTexture2DZero = nullptr;
262	mTexture3DZero = nullptr;
263	mTexture2DArrayZero = nullptr;
264	mTextureCubeMapZero = nullptr;
265	mTextureExternalZero = nullptr;
266
267	delete mVertexDataManager;
268	delete mIndexDataManager;
269
270	mResourceManager->release();
271	delete device;
272}
273
274void Context::makeCurrent(gl::Surface *surface)
275{
276	if(!mHasBeenCurrent)
277	{
278		mVertexDataManager = new VertexDataManager(this);
279		mIndexDataManager = new IndexDataManager();
280
281		mState.viewportX = 0;
282		mState.viewportY = 0;
283		mState.viewportWidth = surface ? surface->getWidth() : 0;
284		mState.viewportHeight = surface ? surface->getHeight() : 0;
285
286		mState.scissorX = 0;
287		mState.scissorY = 0;
288		mState.scissorWidth = surface ? surface->getWidth() : 0;
289		mState.scissorHeight = surface ? surface->getHeight() : 0;
290
291		mHasBeenCurrent = true;
292	}
293
294	if(surface)
295	{
296		// Wrap the existing resources into GL objects and assign them to the '0' names
297		egl::Image *defaultRenderTarget = surface->getRenderTarget();
298		egl::Image *depthStencil = surface->getDepthStencil();
299
300		Colorbuffer *colorbufferZero = new Colorbuffer(defaultRenderTarget);
301		DepthStencilbuffer *depthStencilbufferZero = new DepthStencilbuffer(depthStencil);
302		Framebuffer *framebufferZero = new DefaultFramebuffer(colorbufferZero, depthStencilbufferZero);
303
304		setFramebufferZero(framebufferZero);
305
306		if(defaultRenderTarget)
307		{
308			defaultRenderTarget->release();
309		}
310
311		if(depthStencil)
312		{
313			depthStencil->release();
314		}
315	}
316	else
317	{
318		setFramebufferZero(nullptr);
319	}
320
321	markAllStateDirty();
322}
323
324EGLint Context::getClientVersion() const
325{
326	return clientVersion;
327}
328
329EGLint Context::getConfigID() const
330{
331	return config->mConfigID;
332}
333
334// This function will set all of the state-related dirty flags, so that all state is set during next pre-draw.
335void Context::markAllStateDirty()
336{
337	mAppliedProgramSerial = 0;
338
339	mDepthStateDirty = true;
340	mMaskStateDirty = true;
341	mBlendStateDirty = true;
342	mStencilStateDirty = true;
343	mPolygonOffsetStateDirty = true;
344	mSampleStateDirty = true;
345	mDitherStateDirty = true;
346	mFrontFaceDirty = true;
347}
348
349void Context::setClearColor(float red, float green, float blue, float alpha)
350{
351	mState.colorClearValue.red = red;
352	mState.colorClearValue.green = green;
353	mState.colorClearValue.blue = blue;
354	mState.colorClearValue.alpha = alpha;
355}
356
357void Context::setClearDepth(float depth)
358{
359	mState.depthClearValue = depth;
360}
361
362void Context::setClearStencil(int stencil)
363{
364	mState.stencilClearValue = stencil;
365}
366
367void Context::setCullFaceEnabled(bool enabled)
368{
369	mState.cullFaceEnabled = enabled;
370}
371
372bool Context::isCullFaceEnabled() const
373{
374	return mState.cullFaceEnabled;
375}
376
377void Context::setCullMode(GLenum mode)
378{
379   mState.cullMode = mode;
380}
381
382void Context::setFrontFace(GLenum front)
383{
384	if(mState.frontFace != front)
385	{
386		mState.frontFace = front;
387		mFrontFaceDirty = true;
388	}
389}
390
391void Context::setDepthTestEnabled(bool enabled)
392{
393	if(mState.depthTestEnabled != enabled)
394	{
395		mState.depthTestEnabled = enabled;
396		mDepthStateDirty = true;
397	}
398}
399
400bool Context::isDepthTestEnabled() const
401{
402	return mState.depthTestEnabled;
403}
404
405void Context::setDepthFunc(GLenum depthFunc)
406{
407	if(mState.depthFunc != depthFunc)
408	{
409		mState.depthFunc = depthFunc;
410		mDepthStateDirty = true;
411	}
412}
413
414void Context::setDepthRange(float zNear, float zFar)
415{
416	mState.zNear = zNear;
417	mState.zFar = zFar;
418}
419
420void Context::setBlendEnabled(bool enabled)
421{
422	if(mState.blendEnabled != enabled)
423	{
424		mState.blendEnabled = enabled;
425		mBlendStateDirty = true;
426	}
427}
428
429bool Context::isBlendEnabled() const
430{
431	return mState.blendEnabled;
432}
433
434void Context::setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha)
435{
436	if(mState.sourceBlendRGB != sourceRGB ||
437	   mState.sourceBlendAlpha != sourceAlpha ||
438	   mState.destBlendRGB != destRGB ||
439	   mState.destBlendAlpha != destAlpha)
440	{
441		mState.sourceBlendRGB = sourceRGB;
442		mState.destBlendRGB = destRGB;
443		mState.sourceBlendAlpha = sourceAlpha;
444		mState.destBlendAlpha = destAlpha;
445		mBlendStateDirty = true;
446	}
447}
448
449void Context::setBlendColor(float red, float green, float blue, float alpha)
450{
451	if(mState.blendColor.red != red ||
452	   mState.blendColor.green != green ||
453	   mState.blendColor.blue != blue ||
454	   mState.blendColor.alpha != alpha)
455	{
456		mState.blendColor.red = red;
457		mState.blendColor.green = green;
458		mState.blendColor.blue = blue;
459		mState.blendColor.alpha = alpha;
460		mBlendStateDirty = true;
461	}
462}
463
464void Context::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
465{
466	if(mState.blendEquationRGB != rgbEquation ||
467	   mState.blendEquationAlpha != alphaEquation)
468	{
469		mState.blendEquationRGB = rgbEquation;
470		mState.blendEquationAlpha = alphaEquation;
471		mBlendStateDirty = true;
472	}
473}
474
475void Context::setStencilTestEnabled(bool enabled)
476{
477	if(mState.stencilTestEnabled != enabled)
478	{
479		mState.stencilTestEnabled = enabled;
480		mStencilStateDirty = true;
481	}
482}
483
484bool Context::isStencilTestEnabled() const
485{
486	return mState.stencilTestEnabled;
487}
488
489void Context::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask)
490{
491	if(mState.stencilFunc != stencilFunc ||
492	   mState.stencilRef != stencilRef ||
493	   mState.stencilMask != stencilMask)
494	{
495		mState.stencilFunc = stencilFunc;
496		mState.stencilRef = (stencilRef > 0) ? stencilRef : 0;
497		mState.stencilMask = stencilMask;
498		mStencilStateDirty = true;
499	}
500}
501
502void Context::setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask)
503{
504	if(mState.stencilBackFunc != stencilBackFunc ||
505	   mState.stencilBackRef != stencilBackRef ||
506	   mState.stencilBackMask != stencilBackMask)
507	{
508		mState.stencilBackFunc = stencilBackFunc;
509		mState.stencilBackRef = (stencilBackRef > 0) ? stencilBackRef : 0;
510		mState.stencilBackMask = stencilBackMask;
511		mStencilStateDirty = true;
512	}
513}
514
515void Context::setStencilWritemask(GLuint stencilWritemask)
516{
517	if(mState.stencilWritemask != stencilWritemask)
518	{
519		mState.stencilWritemask = stencilWritemask;
520		mStencilStateDirty = true;
521	}
522}
523
524void Context::setStencilBackWritemask(GLuint stencilBackWritemask)
525{
526	if(mState.stencilBackWritemask != stencilBackWritemask)
527	{
528		mState.stencilBackWritemask = stencilBackWritemask;
529		mStencilStateDirty = true;
530	}
531}
532
533void Context::setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass)
534{
535	if(mState.stencilFail != stencilFail ||
536	   mState.stencilPassDepthFail != stencilPassDepthFail ||
537	   mState.stencilPassDepthPass != stencilPassDepthPass)
538	{
539		mState.stencilFail = stencilFail;
540		mState.stencilPassDepthFail = stencilPassDepthFail;
541		mState.stencilPassDepthPass = stencilPassDepthPass;
542		mStencilStateDirty = true;
543	}
544}
545
546void Context::setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass)
547{
548	if(mState.stencilBackFail != stencilBackFail ||
549	   mState.stencilBackPassDepthFail != stencilBackPassDepthFail ||
550	   mState.stencilBackPassDepthPass != stencilBackPassDepthPass)
551	{
552		mState.stencilBackFail = stencilBackFail;
553		mState.stencilBackPassDepthFail = stencilBackPassDepthFail;
554		mState.stencilBackPassDepthPass = stencilBackPassDepthPass;
555		mStencilStateDirty = true;
556	}
557}
558
559void Context::setPolygonOffsetFillEnabled(bool enabled)
560{
561	if(mState.polygonOffsetFillEnabled != enabled)
562	{
563		mState.polygonOffsetFillEnabled = enabled;
564		mPolygonOffsetStateDirty = true;
565	}
566}
567
568bool Context::isPolygonOffsetFillEnabled() const
569{
570	return mState.polygonOffsetFillEnabled;
571}
572
573void Context::setPolygonOffsetParams(GLfloat factor, GLfloat units)
574{
575	if(mState.polygonOffsetFactor != factor ||
576	   mState.polygonOffsetUnits != units)
577	{
578		mState.polygonOffsetFactor = factor;
579		mState.polygonOffsetUnits = units;
580		mPolygonOffsetStateDirty = true;
581	}
582}
583
584void Context::setSampleAlphaToCoverageEnabled(bool enabled)
585{
586	if(mState.sampleAlphaToCoverageEnabled != enabled)
587	{
588		mState.sampleAlphaToCoverageEnabled = enabled;
589		mSampleStateDirty = true;
590	}
591}
592
593bool Context::isSampleAlphaToCoverageEnabled() const
594{
595	return mState.sampleAlphaToCoverageEnabled;
596}
597
598void Context::setSampleCoverageEnabled(bool enabled)
599{
600	if(mState.sampleCoverageEnabled != enabled)
601	{
602		mState.sampleCoverageEnabled = enabled;
603		mSampleStateDirty = true;
604	}
605}
606
607bool Context::isSampleCoverageEnabled() const
608{
609	return mState.sampleCoverageEnabled;
610}
611
612void Context::setSampleCoverageParams(GLclampf value, bool invert)
613{
614	if(mState.sampleCoverageValue != value ||
615	   mState.sampleCoverageInvert != invert)
616	{
617		mState.sampleCoverageValue = value;
618		mState.sampleCoverageInvert = invert;
619		mSampleStateDirty = true;
620	}
621}
622
623void Context::setScissorTestEnabled(bool enabled)
624{
625	mState.scissorTestEnabled = enabled;
626}
627
628bool Context::isScissorTestEnabled() const
629{
630	return mState.scissorTestEnabled;
631}
632
633void Context::setDitherEnabled(bool enabled)
634{
635	if(mState.ditherEnabled != enabled)
636	{
637		mState.ditherEnabled = enabled;
638		mDitherStateDirty = true;
639	}
640}
641
642bool Context::isDitherEnabled() const
643{
644	return mState.ditherEnabled;
645}
646
647void Context::setPrimitiveRestartFixedIndexEnabled(bool enabled)
648{
649	mState.primitiveRestartFixedIndexEnabled = enabled;
650}
651
652bool Context::isPrimitiveRestartFixedIndexEnabled() const
653{
654	return mState.primitiveRestartFixedIndexEnabled;
655}
656
657void Context::setRasterizerDiscardEnabled(bool enabled)
658{
659	mState.rasterizerDiscardEnabled = enabled;
660}
661
662bool Context::isRasterizerDiscardEnabled() const
663{
664	return mState.rasterizerDiscardEnabled;
665}
666
667void Context::setLineWidth(GLfloat width)
668{
669	mState.lineWidth = width;
670	device->setLineWidth(clamp(width, ALIASED_LINE_WIDTH_RANGE_MIN, ALIASED_LINE_WIDTH_RANGE_MAX));
671}
672
673void Context::setGenerateMipmapHint(GLenum hint)
674{
675	mState.generateMipmapHint = hint;
676}
677
678void Context::setFragmentShaderDerivativeHint(GLenum hint)
679{
680	mState.fragmentShaderDerivativeHint = hint;
681	// TODO: Propagate the hint to shader translator so we can write
682	// ddx, ddx_coarse, or ddx_fine depending on the hint.
683	// Ignore for now. It is valid for implementations to ignore hint.
684}
685
686void Context::setTextureFilteringHint(GLenum hint)
687{
688	mState.textureFilteringHint = hint;
689}
690
691void Context::setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height)
692{
693	mState.viewportX = x;
694	mState.viewportY = y;
695	mState.viewportWidth = std::min<GLsizei>(width, IMPLEMENTATION_MAX_RENDERBUFFER_SIZE);     // GL_MAX_VIEWPORT_DIMS[0]
696	mState.viewportHeight = std::min<GLsizei>(height, IMPLEMENTATION_MAX_RENDERBUFFER_SIZE);   // GL_MAX_VIEWPORT_DIMS[1]
697}
698
699void Context::setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height)
700{
701	mState.scissorX = x;
702	mState.scissorY = y;
703	mState.scissorWidth = width;
704	mState.scissorHeight = height;
705}
706
707void Context::setColorMask(bool red, bool green, bool blue, bool alpha)
708{
709	if(mState.colorMaskRed != red || mState.colorMaskGreen != green ||
710	   mState.colorMaskBlue != blue || mState.colorMaskAlpha != alpha)
711	{
712		mState.colorMaskRed = red;
713		mState.colorMaskGreen = green;
714		mState.colorMaskBlue = blue;
715		mState.colorMaskAlpha = alpha;
716		mMaskStateDirty = true;
717	}
718}
719
720unsigned int Context::getColorMask() const
721{
722	return (mState.colorMaskRed ? 0x1 : 0) |
723	       (mState.colorMaskGreen ? 0x2 : 0) |
724	       (mState.colorMaskBlue ? 0x4 : 0) |
725	       (mState.colorMaskAlpha ? 0x8 : 0);
726}
727
728void Context::setDepthMask(bool mask)
729{
730	if(mState.depthMask != mask)
731	{
732		mState.depthMask = mask;
733		mMaskStateDirty = true;
734	}
735}
736
737void Context::setActiveSampler(unsigned int active)
738{
739	mState.activeSampler = active;
740}
741
742GLuint Context::getReadFramebufferName() const
743{
744	return mState.readFramebuffer;
745}
746
747GLuint Context::getDrawFramebufferName() const
748{
749	return mState.drawFramebuffer;
750}
751
752GLuint Context::getRenderbufferName() const
753{
754	return mState.renderbuffer.name();
755}
756
757void Context::setFramebufferReadBuffer(GLuint buf)
758{
759	getReadFramebuffer()->setReadBuffer(buf);
760}
761
762void Context::setFramebufferDrawBuffers(GLsizei n, const GLenum *bufs)
763{
764	Framebuffer *drawFramebuffer = getDrawFramebuffer();
765
766	for(int i = 0; i < MAX_COLOR_ATTACHMENTS; i++)
767	{
768		drawFramebuffer->setDrawBuffer(i, (i < n) ? bufs[i] : GL_NONE);
769	}
770}
771
772GLuint Context::getReadFramebufferColorIndex() const
773{
774	GLenum buf = getReadFramebuffer()->getReadBuffer();
775	switch(buf)
776	{
777	case GL_BACK:
778		return 0;
779	case GL_NONE:
780		return GL_INVALID_INDEX;
781	default:
782		return buf - GL_COLOR_ATTACHMENT0;
783}
784}
785
786GLuint Context::getArrayBufferName() const
787{
788	return mState.arrayBuffer.name();
789}
790
791GLuint Context::getElementArrayBufferName() const
792{
793	Buffer* elementArrayBuffer = getCurrentVertexArray()->getElementArrayBuffer();
794	return elementArrayBuffer ? elementArrayBuffer->name : 0;
795}
796
797GLuint Context::getActiveQuery(GLenum target) const
798{
799	Query *queryObject = nullptr;
800
801	switch(target)
802	{
803	case GL_ANY_SAMPLES_PASSED_EXT:
804		queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED];
805		break;
806	case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
807		queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE];
808		break;
809	case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
810		queryObject = mState.activeQuery[QUERY_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN];
811		break;
812	default:
813		ASSERT(false);
814	}
815
816	if(queryObject)
817	{
818		return queryObject->name;
819	}
820
821	return 0;
822}
823
824void Context::setVertexAttribArrayEnabled(unsigned int attribNum, bool enabled)
825{
826	getCurrentVertexArray()->enableAttribute(attribNum, enabled);
827}
828
829void Context::setVertexAttribDivisor(unsigned int attribNum, GLuint divisor)
830{
831	getCurrentVertexArray()->setVertexAttribDivisor(attribNum, divisor);
832}
833
834const VertexAttribute &Context::getVertexAttribState(unsigned int attribNum) const
835{
836	return getCurrentVertexArray()->getVertexAttribute(attribNum);
837}
838
839void Context::setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type, bool normalized,
840                                   GLsizei stride, const void *pointer)
841{
842	getCurrentVertexArray()->setAttributeState(attribNum, boundBuffer, size, type, normalized, stride, pointer);
843}
844
845const void *Context::getVertexAttribPointer(unsigned int attribNum) const
846{
847	return getCurrentVertexArray()->getVertexAttribute(attribNum).mPointer;
848}
849
850const VertexAttributeArray &Context::getVertexArrayAttributes()
851{
852	return getCurrentVertexArray()->getVertexAttributes();
853}
854
855const VertexAttributeArray &Context::getCurrentVertexAttributes()
856{
857	return mState.vertexAttribute;
858}
859
860void Context::setPackAlignment(GLint alignment)
861{
862	mState.packAlignment = alignment;
863}
864
865void Context::setUnpackAlignment(GLint alignment)
866{
867	mState.unpackInfo.alignment = alignment;
868}
869
870const egl::Image::UnpackInfo& Context::getUnpackInfo() const
871{
872	return mState.unpackInfo;
873}
874
875void Context::setPackRowLength(GLint rowLength)
876{
877	mState.packRowLength = rowLength;
878}
879
880void Context::setPackImageHeight(GLint imageHeight)
881{
882	mState.packImageHeight = imageHeight;
883}
884
885void Context::setPackSkipPixels(GLint skipPixels)
886{
887	mState.packSkipPixels = skipPixels;
888}
889
890void Context::setPackSkipRows(GLint skipRows)
891{
892	mState.packSkipRows = skipRows;
893}
894
895void Context::setPackSkipImages(GLint skipImages)
896{
897	mState.packSkipImages = skipImages;
898}
899
900void Context::setUnpackRowLength(GLint rowLength)
901{
902	mState.unpackInfo.rowLength = rowLength;
903}
904
905void Context::setUnpackImageHeight(GLint imageHeight)
906{
907	mState.unpackInfo.imageHeight = imageHeight;
908}
909
910void Context::setUnpackSkipPixels(GLint skipPixels)
911{
912	mState.unpackInfo.skipPixels = skipPixels;
913}
914
915void Context::setUnpackSkipRows(GLint skipRows)
916{
917	mState.unpackInfo.skipRows = skipRows;
918}
919
920void Context::setUnpackSkipImages(GLint skipImages)
921{
922	mState.unpackInfo.skipImages = skipImages;
923}
924
925GLuint Context::createBuffer()
926{
927	return mResourceManager->createBuffer();
928}
929
930GLuint Context::createProgram()
931{
932	return mResourceManager->createProgram();
933}
934
935GLuint Context::createShader(GLenum type)
936{
937	return mResourceManager->createShader(type);
938}
939
940GLuint Context::createTexture()
941{
942	return mResourceManager->createTexture();
943}
944
945GLuint Context::createRenderbuffer()
946{
947	return mResourceManager->createRenderbuffer();
948}
949
950// Returns an unused framebuffer name
951GLuint Context::createFramebuffer()
952{
953	return mFramebufferNameSpace.allocate();
954}
955
956GLuint Context::createFence()
957{
958	return mFenceNameSpace.allocate(new Fence());
959}
960
961// Returns an unused query name
962GLuint Context::createQuery()
963{
964	return mQueryNameSpace.allocate();
965}
966
967// Returns an unused vertex array name
968GLuint Context::createVertexArray()
969{
970	return mVertexArrayNameSpace.allocate();
971}
972
973GLsync Context::createFenceSync(GLenum condition, GLbitfield flags)
974{
975	GLuint handle = mResourceManager->createFenceSync(condition, flags);
976
977	return reinterpret_cast<GLsync>(static_cast<uintptr_t>(handle));
978}
979
980// Returns an unused transform feedback name
981GLuint Context::createTransformFeedback()
982{
983	return mTransformFeedbackNameSpace.allocate();
984}
985
986// Returns an unused sampler name
987GLuint Context::createSampler()
988{
989	return mResourceManager->createSampler();
990}
991
992void Context::deleteBuffer(GLuint buffer)
993{
994	detachBuffer(buffer);
995
996	mResourceManager->deleteBuffer(buffer);
997}
998
999void Context::deleteShader(GLuint shader)
1000{
1001	mResourceManager->deleteShader(shader);
1002}
1003
1004void Context::deleteProgram(GLuint program)
1005{
1006	mResourceManager->deleteProgram(program);
1007}
1008
1009void Context::deleteTexture(GLuint texture)
1010{
1011	detachTexture(texture);
1012
1013	mResourceManager->deleteTexture(texture);
1014}
1015
1016void Context::deleteRenderbuffer(GLuint renderbuffer)
1017{
1018	if(mResourceManager->getRenderbuffer(renderbuffer))
1019	{
1020		detachRenderbuffer(renderbuffer);
1021	}
1022
1023	mResourceManager->deleteRenderbuffer(renderbuffer);
1024}
1025
1026void Context::deleteFramebuffer(GLuint framebuffer)
1027{
1028	detachFramebuffer(framebuffer);
1029
1030	Framebuffer *framebufferObject = mFramebufferNameSpace.remove(framebuffer);
1031
1032	if(framebufferObject)
1033	{
1034		delete framebufferObject;
1035	}
1036}
1037
1038void Context::deleteFence(GLuint fence)
1039{
1040	Fence *fenceObject = mFenceNameSpace.remove(fence);
1041
1042	if(fenceObject)
1043	{
1044		delete fenceObject;
1045	}
1046}
1047
1048void Context::deleteQuery(GLuint query)
1049{
1050	Query *queryObject = mQueryNameSpace.remove(query);
1051
1052	if(queryObject)
1053	{
1054		queryObject->release();
1055	}
1056}
1057
1058void Context::deleteVertexArray(GLuint vertexArray)
1059{
1060	// [OpenGL ES 3.0.2] section 2.10 page 43:
1061	// If a vertex array object that is currently bound is deleted, the binding
1062	// for that object reverts to zero and the default vertex array becomes current.
1063	if(getCurrentVertexArray()->name == vertexArray)
1064	{
1065		bindVertexArray(0);
1066	}
1067
1068	VertexArray *vertexArrayObject = mVertexArrayNameSpace.remove(vertexArray);
1069
1070	if(vertexArrayObject)
1071	{
1072		delete vertexArrayObject;
1073	}
1074}
1075
1076void Context::deleteFenceSync(GLsync fenceSync)
1077{
1078	// The spec specifies the underlying Fence object is not deleted until all current
1079	// wait commands finish. However, since the name becomes invalid, we cannot query the fence,
1080	// and since our API is currently designed for being called from a single thread, we can delete
1081	// the fence immediately.
1082	mResourceManager->deleteFenceSync(static_cast<GLuint>(reinterpret_cast<uintptr_t>(fenceSync)));
1083}
1084
1085void Context::deleteTransformFeedback(GLuint transformFeedback)
1086{
1087	TransformFeedback *transformFeedbackObject = mTransformFeedbackNameSpace.remove(transformFeedback);
1088
1089	if(transformFeedbackObject)
1090	{
1091		delete transformFeedbackObject;
1092	}
1093}
1094
1095void Context::deleteSampler(GLuint sampler)
1096{
1097	detachSampler(sampler);
1098
1099	mResourceManager->deleteSampler(sampler);
1100}
1101
1102Buffer *Context::getBuffer(GLuint handle) const
1103{
1104	return mResourceManager->getBuffer(handle);
1105}
1106
1107Shader *Context::getShader(GLuint handle) const
1108{
1109	return mResourceManager->getShader(handle);
1110}
1111
1112Program *Context::getProgram(GLuint handle) const
1113{
1114	return mResourceManager->getProgram(handle);
1115}
1116
1117Texture *Context::getTexture(GLuint handle) const
1118{
1119	return mResourceManager->getTexture(handle);
1120}
1121
1122Renderbuffer *Context::getRenderbuffer(GLuint handle) const
1123{
1124	return mResourceManager->getRenderbuffer(handle);
1125}
1126
1127Framebuffer *Context::getReadFramebuffer() const
1128{
1129	return getFramebuffer(mState.readFramebuffer);
1130}
1131
1132Framebuffer *Context::getDrawFramebuffer() const
1133{
1134	return getFramebuffer(mState.drawFramebuffer);
1135}
1136
1137void Context::bindArrayBuffer(unsigned int buffer)
1138{
1139	mResourceManager->checkBufferAllocation(buffer);
1140
1141	mState.arrayBuffer = getBuffer(buffer);
1142}
1143
1144void Context::bindElementArrayBuffer(unsigned int buffer)
1145{
1146	mResourceManager->checkBufferAllocation(buffer);
1147
1148	getCurrentVertexArray()->setElementArrayBuffer(getBuffer(buffer));
1149}
1150
1151void Context::bindCopyReadBuffer(GLuint buffer)
1152{
1153	mResourceManager->checkBufferAllocation(buffer);
1154
1155	mState.copyReadBuffer = getBuffer(buffer);
1156}
1157
1158void Context::bindCopyWriteBuffer(GLuint buffer)
1159{
1160	mResourceManager->checkBufferAllocation(buffer);
1161
1162	mState.copyWriteBuffer = getBuffer(buffer);
1163}
1164
1165void Context::bindPixelPackBuffer(GLuint buffer)
1166{
1167	mResourceManager->checkBufferAllocation(buffer);
1168
1169	mState.pixelPackBuffer = getBuffer(buffer);
1170}
1171
1172void Context::bindPixelUnpackBuffer(GLuint buffer)
1173{
1174	mResourceManager->checkBufferAllocation(buffer);
1175
1176	mState.pixelUnpackBuffer = getBuffer(buffer);
1177}
1178
1179void Context::bindTransformFeedbackBuffer(GLuint buffer)
1180{
1181	mResourceManager->checkBufferAllocation(buffer);
1182
1183	TransformFeedback* transformFeedback = getTransformFeedback(mState.transformFeedback);
1184
1185	if(transformFeedback)
1186	{
1187		transformFeedback->setGenericBuffer(getBuffer(buffer));
1188	}
1189}
1190
1191void Context::bindTexture2D(GLuint texture)
1192{
1193	mResourceManager->checkTextureAllocation(texture, TEXTURE_2D);
1194
1195	mState.samplerTexture[TEXTURE_2D][mState.activeSampler] = getTexture(texture);
1196}
1197
1198void Context::bindTextureCubeMap(GLuint texture)
1199{
1200	mResourceManager->checkTextureAllocation(texture, TEXTURE_CUBE);
1201
1202	mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler] = getTexture(texture);
1203}
1204
1205void Context::bindTextureExternal(GLuint texture)
1206{
1207	mResourceManager->checkTextureAllocation(texture, TEXTURE_EXTERNAL);
1208
1209	mState.samplerTexture[TEXTURE_EXTERNAL][mState.activeSampler] = getTexture(texture);
1210}
1211
1212void Context::bindTexture3D(GLuint texture)
1213{
1214	mResourceManager->checkTextureAllocation(texture, TEXTURE_3D);
1215
1216	mState.samplerTexture[TEXTURE_3D][mState.activeSampler] = getTexture(texture);
1217}
1218
1219void Context::bindTexture2DArray(GLuint texture)
1220{
1221	mResourceManager->checkTextureAllocation(texture, TEXTURE_2D_ARRAY);
1222
1223	mState.samplerTexture[TEXTURE_2D_ARRAY][mState.activeSampler] = getTexture(texture);
1224}
1225
1226void Context::bindReadFramebuffer(GLuint framebuffer)
1227{
1228	if(!getFramebuffer(framebuffer))
1229	{
1230		mFramebufferNameSpace.insert(framebuffer, new Framebuffer());
1231	}
1232
1233	mState.readFramebuffer = framebuffer;
1234}
1235
1236void Context::bindDrawFramebuffer(GLuint framebuffer)
1237{
1238	if(!getFramebuffer(framebuffer))
1239	{
1240		mFramebufferNameSpace.insert(framebuffer, new Framebuffer());
1241	}
1242
1243	mState.drawFramebuffer = framebuffer;
1244}
1245
1246void Context::bindRenderbuffer(GLuint renderbuffer)
1247{
1248	mResourceManager->checkRenderbufferAllocation(renderbuffer);
1249
1250	mState.renderbuffer = getRenderbuffer(renderbuffer);
1251}
1252
1253void Context::bindVertexArray(GLuint array)
1254{
1255	VertexArray *vertexArray = getVertexArray(array);
1256
1257	if(!vertexArray)
1258	{
1259		vertexArray = new VertexArray(array);
1260		mVertexArrayNameSpace.insert(array, vertexArray);
1261	}
1262
1263	mState.vertexArray = array;
1264}
1265
1266void Context::bindGenericUniformBuffer(GLuint buffer)
1267{
1268	mResourceManager->checkBufferAllocation(buffer);
1269
1270	mState.genericUniformBuffer = getBuffer(buffer);
1271}
1272
1273void Context::bindIndexedUniformBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size)
1274{
1275	mResourceManager->checkBufferAllocation(buffer);
1276
1277	Buffer* bufferObject = getBuffer(buffer);
1278	mState.uniformBuffers[index].set(bufferObject, static_cast<int>(offset), static_cast<int>(size));
1279}
1280
1281void Context::bindGenericTransformFeedbackBuffer(GLuint buffer)
1282{
1283	mResourceManager->checkBufferAllocation(buffer);
1284
1285	getTransformFeedback()->setGenericBuffer(getBuffer(buffer));
1286}
1287
1288void Context::bindIndexedTransformFeedbackBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size)
1289{
1290	mResourceManager->checkBufferAllocation(buffer);
1291
1292	Buffer* bufferObject = getBuffer(buffer);
1293	getTransformFeedback()->setBuffer(index, bufferObject, offset, size);
1294}
1295
1296void Context::bindTransformFeedback(GLuint id)
1297{
1298	if(!getTransformFeedback(id))
1299	{
1300		mTransformFeedbackNameSpace.insert(id, new TransformFeedback(id));
1301	}
1302
1303	mState.transformFeedback = id;
1304}
1305
1306bool Context::bindSampler(GLuint unit, GLuint sampler)
1307{
1308	mResourceManager->checkSamplerAllocation(sampler);
1309
1310	Sampler* samplerObject = getSampler(sampler);
1311
1312	mState.sampler[unit] = samplerObject;
1313
1314	return !!samplerObject;
1315}
1316
1317void Context::useProgram(GLuint program)
1318{
1319	GLuint priorProgram = mState.currentProgram;
1320	mState.currentProgram = program;               // Must switch before trying to delete, otherwise it only gets flagged.
1321
1322	if(priorProgram != program)
1323	{
1324		Program *newProgram = mResourceManager->getProgram(program);
1325		Program *oldProgram = mResourceManager->getProgram(priorProgram);
1326
1327		if(newProgram)
1328		{
1329			newProgram->addRef();
1330		}
1331
1332		if(oldProgram)
1333		{
1334			oldProgram->release();
1335		}
1336	}
1337}
1338
1339void Context::beginQuery(GLenum target, GLuint query)
1340{
1341	// From EXT_occlusion_query_boolean: If BeginQueryEXT is called with an <id>
1342	// of zero, if the active query object name for <target> is non-zero (for the
1343	// targets ANY_SAMPLES_PASSED_EXT and ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, if
1344	// the active query for either target is non-zero), if <id> is the name of an
1345	// existing query object whose type does not match <target>, or if <id> is the
1346	// active query object name for any query type, the error INVALID_OPERATION is
1347	// generated.
1348
1349	// Ensure no other queries are active
1350	// NOTE: If other queries than occlusion are supported, we will need to check
1351	// separately that:
1352	//    a) The query ID passed is not the current active query for any target/type
1353	//    b) There are no active queries for the requested target (and in the case
1354	//       of GL_ANY_SAMPLES_PASSED_EXT and GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
1355	//       no query may be active for either if glBeginQuery targets either.
1356	for(int i = 0; i < QUERY_TYPE_COUNT; i++)
1357	{
1358		if(mState.activeQuery[i])
1359		{
1360			switch(mState.activeQuery[i]->getType())
1361			{
1362			case GL_ANY_SAMPLES_PASSED_EXT:
1363			case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
1364				if((target == GL_ANY_SAMPLES_PASSED_EXT) ||
1365				   (target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT))
1366				{
1367					return error(GL_INVALID_OPERATION);
1368				}
1369				break;
1370			case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
1371				if(target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN)
1372				{
1373					return error(GL_INVALID_OPERATION);
1374				}
1375				break;
1376			default:
1377				break;
1378			}
1379		}
1380	}
1381
1382	QueryType qType;
1383	switch(target)
1384	{
1385	case GL_ANY_SAMPLES_PASSED_EXT:
1386		qType = QUERY_ANY_SAMPLES_PASSED;
1387		break;
1388	case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
1389		qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE;
1390		break;
1391	case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
1392		qType = QUERY_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN;
1393		break;
1394	default:
1395		UNREACHABLE(target);
1396		return error(GL_INVALID_ENUM);
1397	}
1398
1399	Query *queryObject = createQuery(query, target);
1400
1401	// Check that name was obtained with glGenQueries
1402	if(!queryObject)
1403	{
1404		return error(GL_INVALID_OPERATION);
1405	}
1406
1407	// Check for type mismatch
1408	if(queryObject->getType() != target)
1409	{
1410		return error(GL_INVALID_OPERATION);
1411	}
1412
1413	// Set query as active for specified target
1414	mState.activeQuery[qType] = queryObject;
1415
1416	// Begin query
1417	queryObject->begin();
1418}
1419
1420void Context::endQuery(GLenum target)
1421{
1422	QueryType qType;
1423
1424	switch(target)
1425	{
1426	case GL_ANY_SAMPLES_PASSED_EXT:                qType = QUERY_ANY_SAMPLES_PASSED;                    break;
1427	case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:   qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE;       break;
1428	case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: qType = QUERY_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN; break;
1429	default: UNREACHABLE(target); return;
1430	}
1431
1432	Query *queryObject = mState.activeQuery[qType];
1433
1434	if(!queryObject)
1435	{
1436		return error(GL_INVALID_OPERATION);
1437	}
1438
1439	queryObject->end();
1440
1441	mState.activeQuery[qType] = nullptr;
1442}
1443
1444void Context::setFramebufferZero(Framebuffer *buffer)
1445{
1446	delete mFramebufferNameSpace.remove(0);
1447	mFramebufferNameSpace.insert(0, buffer);
1448}
1449
1450void Context::setRenderbufferStorage(RenderbufferStorage *renderbuffer)
1451{
1452	Renderbuffer *renderbufferObject = mState.renderbuffer;
1453	renderbufferObject->setStorage(renderbuffer);
1454}
1455
1456Framebuffer *Context::getFramebuffer(unsigned int handle) const
1457{
1458	return mFramebufferNameSpace.find(handle);
1459}
1460
1461Fence *Context::getFence(unsigned int handle) const
1462{
1463	return mFenceNameSpace.find(handle);
1464}
1465
1466FenceSync *Context::getFenceSync(GLsync handle) const
1467{
1468	return mResourceManager->getFenceSync(static_cast<GLuint>(reinterpret_cast<uintptr_t>(handle)));
1469}
1470
1471Query *Context::getQuery(unsigned int handle) const
1472{
1473	return mQueryNameSpace.find(handle);
1474}
1475
1476Query *Context::createQuery(unsigned int handle, GLenum type)
1477{
1478	if(!mQueryNameSpace.isReserved(handle))
1479	{
1480		return nullptr;
1481	}
1482	else
1483	{
1484		Query *query = mQueryNameSpace.find(handle);
1485		if(!query)
1486		{
1487			query = new Query(handle, type);
1488			query->addRef();
1489			mQueryNameSpace.insert(handle, query);
1490		}
1491
1492		return query;
1493	}
1494}
1495
1496VertexArray *Context::getVertexArray(GLuint array) const
1497{
1498	return mVertexArrayNameSpace.find(array);
1499}
1500
1501VertexArray *Context::getCurrentVertexArray() const
1502{
1503	return getVertexArray(mState.vertexArray);
1504}
1505
1506bool Context::isVertexArray(GLuint array) const
1507{
1508	return mVertexArrayNameSpace.isReserved(array);
1509}
1510
1511bool Context::hasZeroDivisor() const
1512{
1513	// Verify there is at least one active attribute with a divisor of zero
1514	es2::Program *programObject = getCurrentProgram();
1515	for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
1516	{
1517		bool active = (programObject->getAttributeStream(attributeIndex) != -1);
1518		if(active && getCurrentVertexArray()->getVertexAttribute(attributeIndex).mDivisor == 0)
1519		{
1520			return true;
1521		}
1522	}
1523
1524	return false;
1525}
1526
1527TransformFeedback *Context::getTransformFeedback(GLuint transformFeedback) const
1528{
1529	return mTransformFeedbackNameSpace.find(transformFeedback);
1530}
1531
1532bool Context::isTransformFeedback(GLuint array) const
1533{
1534	return mTransformFeedbackNameSpace.isReserved(array);
1535}
1536
1537Sampler *Context::getSampler(GLuint sampler) const
1538{
1539	return mResourceManager->getSampler(sampler);
1540}
1541
1542bool Context::isSampler(GLuint sampler) const
1543{
1544	return mResourceManager->isSampler(sampler);
1545}
1546
1547Buffer *Context::getArrayBuffer() const
1548{
1549	return mState.arrayBuffer;
1550}
1551
1552Buffer *Context::getElementArrayBuffer() const
1553{
1554	return getCurrentVertexArray()->getElementArrayBuffer();
1555}
1556
1557Buffer *Context::getCopyReadBuffer() const
1558{
1559	return mState.copyReadBuffer;
1560}
1561
1562Buffer *Context::getCopyWriteBuffer() const
1563{
1564	return mState.copyWriteBuffer;
1565}
1566
1567Buffer *Context::getPixelPackBuffer() const
1568{
1569	return mState.pixelPackBuffer;
1570}
1571
1572Buffer *Context::getPixelUnpackBuffer() const
1573{
1574	return mState.pixelUnpackBuffer;
1575}
1576
1577Buffer *Context::getGenericUniformBuffer() const
1578{
1579	return mState.genericUniformBuffer;
1580}
1581
1582const GLvoid* Context::getPixels(const GLvoid* data) const
1583{
1584	es2::Buffer* unpackBuffer = getPixelUnpackBuffer();
1585	const unsigned char* unpackBufferData = unpackBuffer ? static_cast<const unsigned char*>(unpackBuffer->data()) : nullptr;
1586	return unpackBufferData ? unpackBufferData + (ptrdiff_t)(data) : data;
1587}
1588
1589bool Context::getBuffer(GLenum target, es2::Buffer **buffer) const
1590{
1591	switch(target)
1592	{
1593	case GL_ARRAY_BUFFER:
1594		*buffer = getArrayBuffer();
1595		break;
1596	case GL_ELEMENT_ARRAY_BUFFER:
1597		*buffer = getElementArrayBuffer();
1598		break;
1599	case GL_COPY_READ_BUFFER:
1600		if(clientVersion >= 3)
1601		{
1602			*buffer = getCopyReadBuffer();
1603			break;
1604		}
1605		else return false;
1606	case GL_COPY_WRITE_BUFFER:
1607		if(clientVersion >= 3)
1608		{
1609			*buffer = getCopyWriteBuffer();
1610			break;
1611		}
1612		else return false;
1613	case GL_PIXEL_PACK_BUFFER:
1614		if(clientVersion >= 3)
1615		{
1616			*buffer = getPixelPackBuffer();
1617			break;
1618		}
1619		else return false;
1620	case GL_PIXEL_UNPACK_BUFFER:
1621		if(clientVersion >= 3)
1622		{
1623			*buffer = getPixelUnpackBuffer();
1624			break;
1625		}
1626		else return false;
1627	case GL_TRANSFORM_FEEDBACK_BUFFER:
1628		if(clientVersion >= 3)
1629		{
1630			TransformFeedback* transformFeedback = getTransformFeedback();
1631			*buffer = transformFeedback ? static_cast<es2::Buffer*>(transformFeedback->getGenericBuffer()) : nullptr;
1632			break;
1633		}
1634		else return false;
1635	case GL_UNIFORM_BUFFER:
1636		if(clientVersion >= 3)
1637		{
1638			*buffer = getGenericUniformBuffer();
1639			break;
1640		}
1641		else return false;
1642	default:
1643		return false;
1644	}
1645	return true;
1646}
1647
1648TransformFeedback *Context::getTransformFeedback() const
1649{
1650	return getTransformFeedback(mState.transformFeedback);
1651}
1652
1653Program *Context::getCurrentProgram() const
1654{
1655	return mResourceManager->getProgram(mState.currentProgram);
1656}
1657
1658Texture2D *Context::getTexture2D() const
1659{
1660	return static_cast<Texture2D*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D));
1661}
1662
1663Texture3D *Context::getTexture3D() const
1664{
1665	return static_cast<Texture3D*>(getSamplerTexture(mState.activeSampler, TEXTURE_3D));
1666}
1667
1668Texture2DArray *Context::getTexture2DArray() const
1669{
1670	return static_cast<Texture2DArray*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D_ARRAY));
1671}
1672
1673TextureCubeMap *Context::getTextureCubeMap() const
1674{
1675	return static_cast<TextureCubeMap*>(getSamplerTexture(mState.activeSampler, TEXTURE_CUBE));
1676}
1677
1678TextureExternal *Context::getTextureExternal() const
1679{
1680	return static_cast<TextureExternal*>(getSamplerTexture(mState.activeSampler, TEXTURE_EXTERNAL));
1681}
1682
1683Texture *Context::getSamplerTexture(unsigned int sampler, TextureType type) const
1684{
1685	GLuint texid = mState.samplerTexture[type][sampler].name();
1686
1687	if(texid == 0)   // Special case: 0 refers to different initial textures based on the target
1688	{
1689		switch(type)
1690		{
1691		case TEXTURE_2D: return mTexture2DZero;
1692		case TEXTURE_3D: return mTexture3DZero;
1693		case TEXTURE_2D_ARRAY: return mTexture2DArrayZero;
1694		case TEXTURE_CUBE: return mTextureCubeMapZero;
1695		case TEXTURE_EXTERNAL: return mTextureExternalZero;
1696		default: UNREACHABLE(type);
1697		}
1698	}
1699
1700	return mState.samplerTexture[type][sampler];
1701}
1702
1703void Context::samplerParameteri(GLuint sampler, GLenum pname, GLint param)
1704{
1705	mResourceManager->checkSamplerAllocation(sampler);
1706
1707	Sampler *samplerObject = getSampler(sampler);
1708	ASSERT(samplerObject);
1709
1710	switch(pname)
1711	{
1712	case GL_TEXTURE_MIN_FILTER:   samplerObject->setMinFilter(static_cast<GLenum>(param));   break;
1713	case GL_TEXTURE_MAG_FILTER:   samplerObject->setMagFilter(static_cast<GLenum>(param));   break;
1714	case GL_TEXTURE_WRAP_S:       samplerObject->setWrapS(static_cast<GLenum>(param));       break;
1715	case GL_TEXTURE_WRAP_T:       samplerObject->setWrapT(static_cast<GLenum>(param));       break;
1716	case GL_TEXTURE_WRAP_R:       samplerObject->setWrapR(static_cast<GLenum>(param));       break;
1717	case GL_TEXTURE_MIN_LOD:      samplerObject->setMinLod(static_cast<GLfloat>(param));     break;
1718	case GL_TEXTURE_MAX_LOD:      samplerObject->setMaxLod(static_cast<GLfloat>(param));     break;
1719	case GL_TEXTURE_COMPARE_MODE: samplerObject->setCompareMode(static_cast<GLenum>(param)); break;
1720	case GL_TEXTURE_COMPARE_FUNC: samplerObject->setCompareFunc(static_cast<GLenum>(param)); break;
1721	default:                      UNREACHABLE(pname); break;
1722	}
1723}
1724
1725void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1726{
1727	mResourceManager->checkSamplerAllocation(sampler);
1728
1729	Sampler *samplerObject = getSampler(sampler);
1730	ASSERT(samplerObject);
1731
1732	switch(pname)
1733	{
1734	case GL_TEXTURE_MIN_FILTER:   samplerObject->setMinFilter(static_cast<GLenum>(roundf(param)));   break;
1735	case GL_TEXTURE_MAG_FILTER:   samplerObject->setMagFilter(static_cast<GLenum>(roundf(param)));   break;
1736	case GL_TEXTURE_WRAP_S:       samplerObject->setWrapS(static_cast<GLenum>(roundf(param)));       break;
1737	case GL_TEXTURE_WRAP_T:       samplerObject->setWrapT(static_cast<GLenum>(roundf(param)));       break;
1738	case GL_TEXTURE_WRAP_R:       samplerObject->setWrapR(static_cast<GLenum>(roundf(param)));       break;
1739	case GL_TEXTURE_MIN_LOD:      samplerObject->setMinLod(param);                                   break;
1740	case GL_TEXTURE_MAX_LOD:      samplerObject->setMaxLod(param);                                   break;
1741	case GL_TEXTURE_COMPARE_MODE: samplerObject->setCompareMode(static_cast<GLenum>(roundf(param))); break;
1742	case GL_TEXTURE_COMPARE_FUNC: samplerObject->setCompareFunc(static_cast<GLenum>(roundf(param))); break;
1743	default:                      UNREACHABLE(pname); break;
1744	}
1745}
1746
1747GLint Context::getSamplerParameteri(GLuint sampler, GLenum pname)
1748{
1749	mResourceManager->checkSamplerAllocation(sampler);
1750
1751	Sampler *samplerObject = getSampler(sampler);
1752	ASSERT(samplerObject);
1753
1754	switch(pname)
1755	{
1756	case GL_TEXTURE_MIN_FILTER:   return static_cast<GLint>(samplerObject->getMinFilter());
1757	case GL_TEXTURE_MAG_FILTER:   return static_cast<GLint>(samplerObject->getMagFilter());
1758	case GL_TEXTURE_WRAP_S:       return static_cast<GLint>(samplerObject->getWrapS());
1759	case GL_TEXTURE_WRAP_T:       return static_cast<GLint>(samplerObject->getWrapT());
1760	case GL_TEXTURE_WRAP_R:       return static_cast<GLint>(samplerObject->getWrapR());
1761	case GL_TEXTURE_MIN_LOD:      return static_cast<GLint>(roundf(samplerObject->getMinLod()));
1762	case GL_TEXTURE_MAX_LOD:      return static_cast<GLint>(roundf(samplerObject->getMaxLod()));
1763	case GL_TEXTURE_COMPARE_MODE: return static_cast<GLint>(samplerObject->getCompareMode());
1764	case GL_TEXTURE_COMPARE_FUNC: return static_cast<GLint>(samplerObject->getCompareFunc());
1765	default:                      UNREACHABLE(pname); return 0;
1766	}
1767}
1768
1769GLfloat Context::getSamplerParameterf(GLuint sampler, GLenum pname)
1770{
1771	mResourceManager->checkSamplerAllocation(sampler);
1772
1773	Sampler *samplerObject = getSampler(sampler);
1774	ASSERT(samplerObject);
1775
1776	switch(pname)
1777	{
1778	case GL_TEXTURE_MIN_FILTER:   return static_cast<GLfloat>(samplerObject->getMinFilter());
1779	case GL_TEXTURE_MAG_FILTER:   return static_cast<GLfloat>(samplerObject->getMagFilter());
1780	case GL_TEXTURE_WRAP_S:       return static_cast<GLfloat>(samplerObject->getWrapS());
1781	case GL_TEXTURE_WRAP_T:       return static_cast<GLfloat>(samplerObject->getWrapT());
1782	case GL_TEXTURE_WRAP_R:       return static_cast<GLfloat>(samplerObject->getWrapR());
1783	case GL_TEXTURE_MIN_LOD:      return samplerObject->getMinLod();
1784	case GL_TEXTURE_MAX_LOD:      return samplerObject->getMaxLod();
1785	case GL_TEXTURE_COMPARE_MODE: return static_cast<GLfloat>(samplerObject->getCompareMode());
1786	case GL_TEXTURE_COMPARE_FUNC: return static_cast<GLfloat>(samplerObject->getCompareFunc());
1787	default:                      UNREACHABLE(pname); return 0;
1788	}
1789}
1790
1791bool Context::getBooleanv(GLenum pname, GLboolean *params) const
1792{
1793	switch(pname)
1794	{
1795	case GL_SHADER_COMPILER:          *params = GL_TRUE;                          break;
1796	case GL_SAMPLE_COVERAGE_INVERT:   *params = mState.sampleCoverageInvert;      break;
1797	case GL_DEPTH_WRITEMASK:          *params = mState.depthMask;                 break;
1798	case GL_COLOR_WRITEMASK:
1799		params[0] = mState.colorMaskRed;
1800		params[1] = mState.colorMaskGreen;
1801		params[2] = mState.colorMaskBlue;
1802		params[3] = mState.colorMaskAlpha;
1803		break;
1804	case GL_CULL_FACE:                *params = mState.cullFaceEnabled;                  break;
1805	case GL_POLYGON_OFFSET_FILL:      *params = mState.polygonOffsetFillEnabled;         break;
1806	case GL_SAMPLE_ALPHA_TO_COVERAGE: *params = mState.sampleAlphaToCoverageEnabled;     break;
1807	case GL_SAMPLE_COVERAGE:          *params = mState.sampleCoverageEnabled;            break;
1808	case GL_SCISSOR_TEST:             *params = mState.scissorTestEnabled;               break;
1809	case GL_STENCIL_TEST:             *params = mState.stencilTestEnabled;               break;
1810	case GL_DEPTH_TEST:               *params = mState.depthTestEnabled;                 break;
1811	case GL_BLEND:                    *params = mState.blendEnabled;                     break;
1812	case GL_DITHER:                   *params = mState.ditherEnabled;                    break;
1813	case GL_PRIMITIVE_RESTART_FIXED_INDEX: *params = mState.primitiveRestartFixedIndexEnabled; break;
1814	case GL_RASTERIZER_DISCARD:       *params = mState.rasterizerDiscardEnabled;         break;
1815	case GL_TRANSFORM_FEEDBACK_ACTIVE:
1816		{
1817			TransformFeedback* transformFeedback = getTransformFeedback(mState.transformFeedback);
1818			if(transformFeedback)
1819			{
1820				*params = transformFeedback->isActive();
1821				break;
1822			}
1823			else return false;
1824		}
1825	 case GL_TRANSFORM_FEEDBACK_PAUSED:
1826		{
1827			TransformFeedback* transformFeedback = getTransformFeedback(mState.transformFeedback);
1828			if(transformFeedback)
1829			{
1830				*params = transformFeedback->isPaused();
1831				break;
1832			}
1833			else return false;
1834		}
1835	default:
1836		return false;
1837	}
1838
1839	return true;
1840}
1841
1842bool Context::getFloatv(GLenum pname, GLfloat *params) const
1843{
1844	// Please note: DEPTH_CLEAR_VALUE is included in our internal getFloatv implementation
1845	// because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1846	// GetIntegerv as its native query function. As it would require conversion in any
1847	// case, this should make no difference to the calling application.
1848	switch(pname)
1849	{
1850	case GL_LINE_WIDTH:               *params = mState.lineWidth;            break;
1851	case GL_SAMPLE_COVERAGE_VALUE:    *params = mState.sampleCoverageValue;  break;
1852	case GL_DEPTH_CLEAR_VALUE:        *params = mState.depthClearValue;      break;
1853	case GL_POLYGON_OFFSET_FACTOR:    *params = mState.polygonOffsetFactor;  break;
1854	case GL_POLYGON_OFFSET_UNITS:     *params = mState.polygonOffsetUnits;   break;
1855	case GL_ALIASED_LINE_WIDTH_RANGE:
1856		params[0] = ALIASED_LINE_WIDTH_RANGE_MIN;
1857		params[1] = ALIASED_LINE_WIDTH_RANGE_MAX;
1858		break;
1859	case GL_ALIASED_POINT_SIZE_RANGE:
1860		params[0] = ALIASED_POINT_SIZE_RANGE_MIN;
1861		params[1] = ALIASED_POINT_SIZE_RANGE_MAX;
1862		break;
1863	case GL_DEPTH_RANGE:
1864		params[0] = mState.zNear;
1865		params[1] = mState.zFar;
1866		break;
1867	case GL_COLOR_CLEAR_VALUE:
1868		params[0] = mState.colorClearValue.red;
1869		params[1] = mState.colorClearValue.green;
1870		params[2] = mState.colorClearValue.blue;
1871		params[3] = mState.colorClearValue.alpha;
1872		break;
1873	case GL_BLEND_COLOR:
1874		params[0] = mState.blendColor.red;
1875		params[1] = mState.blendColor.green;
1876		params[2] = mState.blendColor.blue;
1877		params[3] = mState.blendColor.alpha;
1878		break;
1879	case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
1880		*params = MAX_TEXTURE_MAX_ANISOTROPY;
1881		break;
1882	default:
1883		return false;
1884	}
1885
1886	return true;
1887}
1888
1889template bool Context::getIntegerv<GLint>(GLenum pname, GLint *params) const;
1890template bool Context::getIntegerv<GLint64>(GLenum pname, GLint64 *params) const;
1891
1892template<typename T> bool Context::getIntegerv(GLenum pname, T *params) const
1893{
1894	// Please note: DEPTH_CLEAR_VALUE is not included in our internal getIntegerv implementation
1895	// because it is stored as a float, despite the fact that the GL ES 2.0 spec names
1896	// GetIntegerv as its native query function. As it would require conversion in any
1897	// case, this should make no difference to the calling application. You may find it in
1898	// Context::getFloatv.
1899	switch(pname)
1900	{
1901	case GL_MAX_VERTEX_ATTRIBS:               *params = MAX_VERTEX_ATTRIBS;               return true;
1902	case GL_MAX_VERTEX_UNIFORM_VECTORS:       *params = MAX_VERTEX_UNIFORM_VECTORS;       return true;
1903	case GL_MAX_VARYING_VECTORS:              *params = MAX_VARYING_VECTORS;              return true;
1904	case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: *params = MAX_COMBINED_TEXTURE_IMAGE_UNITS; return true;
1905	case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:   *params = MAX_VERTEX_TEXTURE_IMAGE_UNITS;   return true;
1906	case GL_MAX_TEXTURE_IMAGE_UNITS:          *params = MAX_TEXTURE_IMAGE_UNITS;          return true;
1907	case GL_MAX_FRAGMENT_UNIFORM_VECTORS:     *params = MAX_FRAGMENT_UNIFORM_VECTORS;     return true;
1908	case GL_MAX_RENDERBUFFER_SIZE:            *params = IMPLEMENTATION_MAX_RENDERBUFFER_SIZE; return true;
1909	case GL_NUM_SHADER_BINARY_FORMATS:        *params = 0;                                    return true;
1910	case GL_SHADER_BINARY_FORMATS:      /* no shader binary formats are supported */          return true;
1911	case GL_ARRAY_BUFFER_BINDING:             *params = getArrayBufferName();                 return true;
1912	case GL_ELEMENT_ARRAY_BUFFER_BINDING:     *params = getElementArrayBufferName();          return true;
1913//	case GL_FRAMEBUFFER_BINDING:            // now equivalent to GL_DRAW_FRAMEBUFFER_BINDING_ANGLE
1914	case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE:   *params = mState.drawFramebuffer;               return true;
1915	case GL_READ_FRAMEBUFFER_BINDING_ANGLE:   *params = mState.readFramebuffer;               return true;
1916	case GL_RENDERBUFFER_BINDING:             *params = mState.renderbuffer.name();           return true;
1917	case GL_CURRENT_PROGRAM:                  *params = mState.currentProgram;                return true;
1918	case GL_PACK_ALIGNMENT:                   *params = mState.packAlignment;                 return true;
1919	case GL_UNPACK_ALIGNMENT:                 *params = mState.unpackInfo.alignment;          return true;
1920	case GL_GENERATE_MIPMAP_HINT:             *params = mState.generateMipmapHint;            return true;
1921	case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: *params = mState.fragmentShaderDerivativeHint; return true;
1922	case GL_TEXTURE_FILTERING_HINT_CHROMIUM:  *params = mState.textureFilteringHint;          return true;
1923	case GL_ACTIVE_TEXTURE:                   *params = (mState.activeSampler + GL_TEXTURE0); return true;
1924	case GL_STENCIL_FUNC:                     *params = mState.stencilFunc;                   return true;
1925	case GL_STENCIL_REF:                      *params = mState.stencilRef;                    return true;
1926	case GL_STENCIL_VALUE_MASK:               *params = sw::clampToSignedInt(mState.stencilMask); return true;
1927	case GL_STENCIL_BACK_FUNC:                *params = mState.stencilBackFunc;               return true;
1928	case GL_STENCIL_BACK_REF:                 *params = mState.stencilBackRef;                return true;
1929	case GL_STENCIL_BACK_VALUE_MASK:          *params = sw::clampToSignedInt(mState.stencilBackMask); return true;
1930	case GL_STENCIL_FAIL:                     *params = mState.stencilFail;                   return true;
1931	case GL_STENCIL_PASS_DEPTH_FAIL:          *params = mState.stencilPassDepthFail;          return true;
1932	case GL_STENCIL_PASS_DEPTH_PASS:          *params = mState.stencilPassDepthPass;          return true;
1933	case GL_STENCIL_BACK_FAIL:                *params = mState.stencilBackFail;               return true;
1934	case GL_STENCIL_BACK_PASS_DEPTH_FAIL:     *params = mState.stencilBackPassDepthFail;      return true;
1935	case GL_STENCIL_BACK_PASS_DEPTH_PASS:     *params = mState.stencilBackPassDepthPass;      return true;
1936	case GL_DEPTH_FUNC:                       *params = mState.depthFunc;                     return true;
1937	case GL_BLEND_SRC_RGB:                    *params = mState.sourceBlendRGB;                return true;
1938	case GL_BLEND_SRC_ALPHA:                  *params = mState.sourceBlendAlpha;              return true;
1939	case GL_BLEND_DST_RGB:                    *params = mState.destBlendRGB;                  return true;
1940	case GL_BLEND_DST_ALPHA:                  *params = mState.destBlendAlpha;                return true;
1941	case GL_BLEND_EQUATION_RGB:               *params = mState.blendEquationRGB;              return true;
1942	case GL_BLEND_EQUATION_ALPHA:             *params = mState.blendEquationAlpha;            return true;
1943	case GL_STENCIL_WRITEMASK:                *params = sw::clampToSignedInt(mState.stencilWritemask); return true;
1944	case GL_STENCIL_BACK_WRITEMASK:           *params = sw::clampToSignedInt(mState.stencilBackWritemask); return true;
1945	case GL_STENCIL_CLEAR_VALUE:              *params = mState.stencilClearValue;             return true;
1946	case GL_SUBPIXEL_BITS:                    *params = 4;                                    return true;
1947	case GL_MAX_TEXTURE_SIZE:                 *params = IMPLEMENTATION_MAX_TEXTURE_SIZE;          return true;
1948	case GL_MAX_CUBE_MAP_TEXTURE_SIZE:        *params = IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE; return true;
1949	case GL_NUM_COMPRESSED_TEXTURE_FORMATS:   *params = NUM_COMPRESSED_TEXTURE_FORMATS;           return true;
1950	case GL_MAX_SAMPLES_ANGLE:                *params = IMPLEMENTATION_MAX_SAMPLES;               return true;
1951	case GL_SAMPLE_BUFFERS:
1952	case GL_SAMPLES:
1953		{
1954			Framebuffer *framebuffer = getDrawFramebuffer();
1955			int width, height, samples;
1956
1957			if(framebuffer->completeness(width, height, samples) == GL_FRAMEBUFFER_COMPLETE)
1958			{
1959				switch(pname)
1960				{
1961				case GL_SAMPLE_BUFFERS:
1962					if(samples > 1)
1963					{
1964						*params = 1;
1965					}
1966					else
1967					{
1968						*params = 0;
1969					}
1970					break;
1971				case GL_SAMPLES:
1972					*params = samples;
1973					break;
1974				}
1975			}
1976			else
1977			{
1978				*params = 0;
1979			}
1980		}
1981		return true;
1982	case GL_IMPLEMENTATION_COLOR_READ_TYPE:
1983		{
1984			Framebuffer *framebuffer = getReadFramebuffer();
1985			*params = framebuffer->getImplementationColorReadType();
1986		}
1987		return true;
1988	case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
1989		{
1990			Framebuffer *framebuffer = getReadFramebuffer();
1991			*params = framebuffer->getImplementationColorReadFormat();
1992		}
1993		return true;
1994	case GL_MAX_VIEWPORT_DIMS:
1995		{
1996			int maxDimension = IMPLEMENTATION_MAX_RENDERBUFFER_SIZE;
1997			params[0] = maxDimension;
1998			params[1] = maxDimension;
1999		}
2000		return true;
2001	case GL_COMPRESSED_TEXTURE_FORMATS:
2002		{
2003			for(int i = 0; i < NUM_COMPRESSED_TEXTURE_FORMATS; i++)
2004			{
2005				params[i] = compressedTextureFormats[i];
2006			}
2007		}
2008		return true;
2009	case GL_VIEWPORT:
2010		params[0] = mState.viewportX;
2011		params[1] = mState.viewportY;
2012		params[2] = mState.viewportWidth;
2013		params[3] = mState.viewportHeight;
2014		return true;
2015	case GL_SCISSOR_BOX:
2016		params[0] = mState.scissorX;
2017		params[1] = mState.scissorY;
2018		params[2] = mState.scissorWidth;
2019		params[3] = mState.scissorHeight;
2020		return true;
2021	case GL_CULL_FACE_MODE:                   *params = mState.cullMode;                 return true;
2022	case GL_FRONT_FACE:                       *params = mState.frontFace;                return true;
2023	case GL_RED_BITS:
2024	case GL_GREEN_BITS:
2025	case GL_BLUE_BITS:
2026	case GL_ALPHA_BITS:
2027		{
2028			Framebuffer *framebuffer = getDrawFramebuffer();
2029			Renderbuffer *colorbuffer = framebuffer->getColorbuffer(0);
2030
2031			if(colorbuffer)
2032			{
2033				switch(pname)
2034				{
2035				case GL_RED_BITS:   *params = colorbuffer->getRedSize();   return true;
2036				case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); return true;
2037				case GL_BLUE_BITS:  *params = colorbuffer->getBlueSize();  return true;
2038				case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); return true;
2039				}
2040			}
2041			else
2042			{
2043				*params = 0;
2044			}
2045		}
2046		return true;
2047	case GL_DEPTH_BITS:
2048		{
2049			Framebuffer *framebuffer = getDrawFramebuffer();
2050			Renderbuffer *depthbuffer = framebuffer->getDepthbuffer();
2051
2052			if(depthbuffer)
2053			{
2054				*params = depthbuffer->getDepthSize();
2055			}
2056			else
2057			{
2058				*params = 0;
2059			}
2060		}
2061		return true;
2062	case GL_STENCIL_BITS:
2063		{
2064			Framebuffer *framebuffer = getDrawFramebuffer();
2065			Renderbuffer *stencilbuffer = framebuffer->getStencilbuffer();
2066
2067			if(stencilbuffer)
2068			{
2069				*params = stencilbuffer->getStencilSize();
2070			}
2071			else
2072			{
2073				*params = 0;
2074			}
2075		}
2076		return true;
2077	case GL_TEXTURE_BINDING_2D:
2078		if(mState.activeSampler > MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
2079		{
2080			error(GL_INVALID_OPERATION);
2081			return false;
2082		}
2083
2084		*params = mState.samplerTexture[TEXTURE_2D][mState.activeSampler].name();
2085		return true;
2086	case GL_TEXTURE_BINDING_CUBE_MAP:
2087		if(mState.activeSampler > MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
2088		{
2089			error(GL_INVALID_OPERATION);
2090			return false;
2091		}
2092
2093		*params = mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].name();
2094		return true;
2095	case GL_TEXTURE_BINDING_EXTERNAL_OES:
2096		if(mState.activeSampler > MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
2097		{
2098			error(GL_INVALID_OPERATION);
2099			return false;
2100		}
2101
2102		*params = mState.samplerTexture[TEXTURE_EXTERNAL][mState.activeSampler].name();
2103		return true;
2104	case GL_TEXTURE_BINDING_3D_OES:
2105		if(mState.activeSampler > MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
2106		{
2107			error(GL_INVALID_OPERATION);
2108			return false;
2109		}
2110
2111		*params = mState.samplerTexture[TEXTURE_3D][mState.activeSampler].name();
2112		return true;
2113	case GL_DRAW_BUFFER0:
2114	case GL_DRAW_BUFFER1:
2115	case GL_DRAW_BUFFER2:
2116	case GL_DRAW_BUFFER3:
2117	case GL_DRAW_BUFFER4:
2118	case GL_DRAW_BUFFER5:
2119	case GL_DRAW_BUFFER6:
2120	case GL_DRAW_BUFFER7:
2121	case GL_DRAW_BUFFER8:
2122	case GL_DRAW_BUFFER9:
2123	case GL_DRAW_BUFFER10:
2124	case GL_DRAW_BUFFER11:
2125	case GL_DRAW_BUFFER12:
2126	case GL_DRAW_BUFFER13:
2127	case GL_DRAW_BUFFER14:
2128	case GL_DRAW_BUFFER15:
2129		if((pname - GL_DRAW_BUFFER0) < MAX_DRAW_BUFFERS)
2130		{
2131			*params = getDrawFramebuffer()->getDrawBuffer(pname - GL_DRAW_BUFFER0);
2132		}
2133		else
2134		{
2135			return false;
2136		}
2137		return true;
2138	case GL_MAX_DRAW_BUFFERS:
2139		*params = MAX_DRAW_BUFFERS;
2140		return true;
2141	case GL_MAX_COLOR_ATTACHMENTS: // Note: MAX_COLOR_ATTACHMENTS_EXT added by GL_EXT_draw_buffers
2142		*params = MAX_COLOR_ATTACHMENTS;
2143		return true;
2144	default:
2145		break;
2146	}
2147
2148	if(clientVersion >= 3)
2149	{
2150		switch(pname)
2151		{
2152		case GL_TEXTURE_BINDING_2D_ARRAY:
2153			if(mState.activeSampler > MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
2154			{
2155				error(GL_INVALID_OPERATION);
2156				return false;
2157			}
2158
2159			*params = mState.samplerTexture[TEXTURE_2D_ARRAY][mState.activeSampler].name();
2160			return true;
2161		case GL_COPY_READ_BUFFER_BINDING:
2162			*params = mState.copyReadBuffer.name();
2163			return true;
2164		case GL_COPY_WRITE_BUFFER_BINDING:
2165			*params = mState.copyWriteBuffer.name();
2166			return true;
2167		case GL_MAJOR_VERSION:
2168			*params = clientVersion;
2169			return true;
2170		case GL_MAX_3D_TEXTURE_SIZE:
2171			*params = IMPLEMENTATION_MAX_TEXTURE_SIZE;
2172			return true;
2173		case GL_MAX_ARRAY_TEXTURE_LAYERS:
2174			*params = IMPLEMENTATION_MAX_TEXTURE_SIZE;
2175			return true;
2176		case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
2177			*params = MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS;
2178			return true;
2179		case GL_MAX_COMBINED_UNIFORM_BLOCKS:
2180			*params = MAX_VERTEX_UNIFORM_BLOCKS + MAX_FRAGMENT_UNIFORM_BLOCKS;
2181			return true;
2182		case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
2183			*params = MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS;
2184			return true;
2185		case GL_MAX_ELEMENT_INDEX:
2186			*params = MAX_ELEMENT_INDEX;
2187			return true;
2188		case GL_MAX_ELEMENTS_INDICES:
2189			*params = MAX_ELEMENTS_INDICES;
2190			return true;
2191		case GL_MAX_ELEMENTS_VERTICES:
2192			*params = MAX_ELEMENTS_VERTICES;
2193			return true;
2194		case GL_MAX_FRAGMENT_INPUT_COMPONENTS:
2195			*params = MAX_FRAGMENT_INPUT_VECTORS * 4;
2196			return true;
2197		case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
2198			*params = MAX_FRAGMENT_UNIFORM_BLOCKS;
2199			return true;
2200		case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
2201			*params = MAX_FRAGMENT_UNIFORM_COMPONENTS;
2202			return true;
2203		case GL_MAX_PROGRAM_TEXEL_OFFSET:
2204			// Note: SwiftShader has no actual texel offset limit, so this limit can be modified if required.
2205			// In any case, any behavior outside the specified range is valid since the spec mentions:
2206			// (see OpenGL ES 3.0.5, 3.8.10.1 Scale Factor and Level of Detail, p.153)
2207			// "If any of the offset values are outside the range of the  implementation-defined values
2208			//  MIN_PROGRAM_TEXEL_OFFSET and MAX_PROGRAM_TEXEL_OFFSET, results of the texture lookup are
2209			//  undefined."
2210			*params = MAX_PROGRAM_TEXEL_OFFSET;
2211			return true;
2212		case GL_MAX_SERVER_WAIT_TIMEOUT:
2213			*params = 0;
2214			return true;
2215		case GL_MAX_TEXTURE_LOD_BIAS:
2216			*params = MAX_TEXTURE_LOD_BIAS;
2217			return true;
2218		case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
2219			*params = sw::MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS;
2220			return true;
2221		case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
2222			*params = MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS;
2223			return true;
2224		case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
2225			*params = sw::MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS;
2226			return true;
2227		case GL_MAX_UNIFORM_BLOCK_SIZE:
2228			*params = MAX_UNIFORM_BLOCK_SIZE;
2229			return true;
2230		case GL_MAX_UNIFORM_BUFFER_BINDINGS:
2231			*params = MAX_UNIFORM_BUFFER_BINDINGS;
2232			return true;
2233		case GL_MAX_VARYING_COMPONENTS:
2234			*params = MAX_VARYING_VECTORS * 4;
2235			return true;
2236		case GL_MAX_VERTEX_OUTPUT_COMPONENTS:
2237			*params = MAX_VERTEX_OUTPUT_VECTORS * 4;
2238			return true;
2239		case GL_MAX_VERTEX_UNIFORM_BLOCKS:
2240			*params = MAX_VERTEX_UNIFORM_BLOCKS;
2241			return true;
2242		case GL_MAX_VERTEX_UNIFORM_COMPONENTS:
2243			*params = MAX_VERTEX_UNIFORM_COMPONENTS;
2244			return true;
2245		case GL_MIN_PROGRAM_TEXEL_OFFSET:
2246			// Note: SwiftShader has no actual texel offset limit, so this limit can be modified if required.
2247			// In any case, any behavior outside the specified range is valid since the spec mentions:
2248			// (see OpenGL ES 3.0.5, 3.8.10.1 Scale Factor and Level of Detail, p.153)
2249			// "If any of the offset values are outside the range of the  implementation-defined values
2250			//  MIN_PROGRAM_TEXEL_OFFSET and MAX_PROGRAM_TEXEL_OFFSET, results of the texture lookup are
2251			//  undefined."
2252			*params = MIN_PROGRAM_TEXEL_OFFSET;
2253			return true;
2254		case GL_MINOR_VERSION:
2255			*params = 0;
2256			return true;
2257		case GL_NUM_EXTENSIONS:
2258			GLuint numExtensions;
2259			getExtensions(0, &numExtensions);
2260			*params = numExtensions;
2261			return true;
2262		case GL_NUM_PROGRAM_BINARY_FORMATS:
2263			*params = NUM_PROGRAM_BINARY_FORMATS;
2264			return true;
2265		case GL_PACK_ROW_LENGTH:
2266			*params = mState.packRowLength;
2267			return true;
2268		case GL_PACK_SKIP_PIXELS:
2269			*params = mState.packSkipPixels;
2270			return true;
2271		case GL_PACK_SKIP_ROWS:
2272			*params = mState.packSkipRows;
2273			return true;
2274		case GL_PIXEL_PACK_BUFFER_BINDING:
2275			*params = mState.pixelPackBuffer.name();
2276			return true;
2277		case GL_PIXEL_UNPACK_BUFFER_BINDING:
2278			*params = mState.pixelUnpackBuffer.name();
2279			return true;
2280		case GL_PROGRAM_BINARY_FORMATS:
2281			// Since NUM_PROGRAM_BINARY_FORMATS is 0, the input
2282			// should be a 0 sized array, so don't write to params
2283			return true;
2284		case GL_READ_BUFFER:
2285			*params = getReadFramebuffer()->getReadBuffer();
2286			return true;
2287		case GL_SAMPLER_BINDING:
2288			*params = mState.sampler[mState.activeSampler].name();
2289			return true;
2290		case GL_UNIFORM_BUFFER_BINDING:
2291			*params = mState.genericUniformBuffer.name();
2292			return true;
2293		case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
2294			*params = UNIFORM_BUFFER_OFFSET_ALIGNMENT;
2295			return true;
2296		case GL_UNIFORM_BUFFER_SIZE:
2297			*params = static_cast<T>(mState.genericUniformBuffer->size());
2298			return true;
2299		case GL_UNIFORM_BUFFER_START:
2300			*params = static_cast<T>(mState.genericUniformBuffer->offset());
2301			return true;
2302		case GL_UNPACK_IMAGE_HEIGHT:
2303			*params = mState.unpackInfo.imageHeight;
2304			return true;
2305		case GL_UNPACK_ROW_LENGTH:
2306			*params = mState.unpackInfo.rowLength;
2307			return true;
2308		case GL_UNPACK_SKIP_IMAGES:
2309			*params = mState.unpackInfo.skipImages;
2310			return true;
2311		case GL_UNPACK_SKIP_PIXELS:
2312			*params = mState.unpackInfo.skipPixels;
2313			return true;
2314		case GL_UNPACK_SKIP_ROWS:
2315			*params = mState.unpackInfo.skipRows;
2316			return true;
2317		case GL_VERTEX_ARRAY_BINDING:
2318			*params = getCurrentVertexArray()->name;
2319			return true;
2320		case GL_TRANSFORM_FEEDBACK_BINDING:
2321			{
2322				TransformFeedback* transformFeedback = getTransformFeedback(mState.transformFeedback);
2323				if(transformFeedback)
2324				{
2325					*params = transformFeedback->name;
2326				}
2327				else
2328				{
2329					return false;
2330				}
2331			}
2332			return true;
2333		case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2334			{
2335				TransformFeedback* transformFeedback = getTransformFeedback(mState.transformFeedback);
2336				if(transformFeedback)
2337				{
2338					*params = transformFeedback->getGenericBufferName();
2339				}
2340				else
2341				{
2342					return false;
2343				}
2344			}
2345			return true;
2346		default:
2347			break;
2348		}
2349	}
2350
2351	return false;
2352}
2353
2354template bool Context::getTransformFeedbackiv<GLint>(GLuint index, GLenum pname, GLint *param) const;
2355template bool Context::getTransformFeedbackiv<GLint64>(GLuint index, GLenum pname, GLint64 *param) const;
2356
2357template<typename T> bool Context::getTransformFeedbackiv(GLuint index, GLenum pname, T *param) const
2358{
2359	TransformFeedback* transformFeedback = getTransformFeedback(mState.transformFeedback);
2360	if(!transformFeedback)
2361	{
2362		return false;
2363	}
2364
2365	switch(pname)
2366	{
2367	case GL_TRANSFORM_FEEDBACK_BINDING: // GLint, initially 0
2368		*param = transformFeedback->name;
2369		break;
2370	case GL_TRANSFORM_FEEDBACK_ACTIVE: // boolean, initially GL_FALSE
2371		*param = transformFeedback->isActive();
2372		break;
2373	case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: // name, initially 0
2374		*param = transformFeedback->getBufferName(index);
2375		break;
2376	case GL_TRANSFORM_FEEDBACK_PAUSED: // boolean, initially GL_FALSE
2377		*param = transformFeedback->isPaused();
2378		break;
2379	case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE: // indexed[n] 64-bit integer, initially 0
2380		if(transformFeedback->getBuffer(index))
2381		{
2382			*param = transformFeedback->getSize(index);
2383			break;
2384		}
2385		else return false;
2386	case GL_TRANSFORM_FEEDBACK_BUFFER_START: // indexed[n] 64-bit integer, initially 0
2387		if(transformFeedback->getBuffer(index))
2388		{
2389			*param = transformFeedback->getOffset(index);
2390		break;
2391		}
2392		else return false;
2393	default:
2394		return false;
2395	}
2396
2397	return true;
2398}
2399
2400template bool Context::getUniformBufferiv<GLint>(GLuint index, GLenum pname, GLint *param) const;
2401template bool Context::getUniformBufferiv<GLint64>(GLuint index, GLenum pname, GLint64 *param) const;
2402
2403template<typename T> bool Context::getUniformBufferiv(GLuint index, GLenum pname, T *param) const
2404{
2405	const BufferBinding& uniformBuffer = mState.uniformBuffers[index];
2406
2407	switch(pname)
2408	{
2409	case GL_UNIFORM_BUFFER_BINDING: // name, initially 0
2410		*param = uniformBuffer.get().name();
2411		break;
2412	case GL_UNIFORM_BUFFER_SIZE: // indexed[n] 64-bit integer, initially 0
2413		*param = uniformBuffer.getSize();
2414		break;
2415	case GL_UNIFORM_BUFFER_START: // indexed[n] 64-bit integer, initially 0
2416		*param = uniformBuffer.getOffset();
2417		break;
2418	default:
2419		return false;
2420	}
2421
2422	return true;
2423}
2424
2425bool Context::getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams) const
2426{
2427	// Please note: the query type returned for DEPTH_CLEAR_VALUE in this implementation
2428	// is FLOAT rather than INT, as would be suggested by the GL ES 2.0 spec. This is due
2429	// to the fact that it is stored internally as a float, and so would require conversion
2430	// if returned from Context::getIntegerv. Since this conversion is already implemented
2431	// in the case that one calls glGetIntegerv to retrieve a float-typed state variable, we
2432	// place DEPTH_CLEAR_VALUE with the floats. This should make no difference to the calling
2433	// application.
2434	switch(pname)
2435	{
2436	case GL_COMPRESSED_TEXTURE_FORMATS:
2437		{
2438			*type = GL_INT;
2439			*numParams = NUM_COMPRESSED_TEXTURE_FORMATS;
2440		}
2441		break;
2442	case GL_SHADER_BINARY_FORMATS:
2443		{
2444			*type = GL_INT;
2445			*numParams = 0;
2446		}
2447		break;
2448	case GL_MAX_VERTEX_ATTRIBS:
2449	case GL_MAX_VERTEX_UNIFORM_VECTORS:
2450	case GL_MAX_VARYING_VECTORS:
2451	case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
2452	case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
2453	case GL_MAX_TEXTURE_IMAGE_UNITS:
2454	case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
2455	case GL_MAX_RENDERBUFFER_SIZE:
2456	case GL_NUM_SHADER_BINARY_FORMATS:
2457	case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
2458	case GL_ARRAY_BUFFER_BINDING:
2459	case GL_FRAMEBUFFER_BINDING: // Same as GL_DRAW_FRAMEBUFFER_BINDING_ANGLE
2460	case GL_READ_FRAMEBUFFER_BINDING_ANGLE:
2461	case GL_RENDERBUFFER_BINDING:
2462	case GL_CURRENT_PROGRAM:
2463	case GL_PACK_ALIGNMENT:
2464	case GL_UNPACK_ALIGNMENT:
2465	case GL_GENERATE_MIPMAP_HINT:
2466	case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
2467	case GL_TEXTURE_FILTERING_HINT_CHROMIUM:
2468	case GL_RED_BITS:
2469	case GL_GREEN_BITS:
2470	case GL_BLUE_BITS:
2471	case GL_ALPHA_BITS:
2472	case GL_DEPTH_BITS:
2473	case GL_STENCIL_BITS:
2474	case GL_ELEMENT_ARRAY_BUFFER_BINDING:
2475	case GL_CULL_FACE_MODE:
2476	case GL_FRONT_FACE:
2477	case GL_ACTIVE_TEXTURE:
2478	case GL_STENCIL_FUNC:
2479	case GL_STENCIL_VALUE_MASK:
2480	case GL_STENCIL_REF:
2481	case GL_STENCIL_FAIL:
2482	case GL_STENCIL_PASS_DEPTH_FAIL:
2483	case GL_STENCIL_PASS_DEPTH_PASS:
2484	case GL_STENCIL_BACK_FUNC:
2485	case GL_STENCIL_BACK_VALUE_MASK:
2486	case GL_STENCIL_BACK_REF:
2487	case GL_STENCIL_BACK_FAIL:
2488	case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
2489	case GL_STENCIL_BACK_PASS_DEPTH_PASS:
2490	case GL_DEPTH_FUNC:
2491	case GL_BLEND_SRC_RGB:
2492	case GL_BLEND_SRC_ALPHA:
2493	case GL_BLEND_DST_RGB:
2494	case GL_BLEND_DST_ALPHA:
2495	case GL_BLEND_EQUATION_RGB:
2496	case GL_BLEND_EQUATION_ALPHA:
2497	case GL_STENCIL_WRITEMASK:
2498	case GL_STENCIL_BACK_WRITEMASK:
2499	case GL_STENCIL_CLEAR_VALUE:
2500	case GL_SUBPIXEL_BITS:
2501	case GL_MAX_TEXTURE_SIZE:
2502	case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
2503	case GL_SAMPLE_BUFFERS:
2504	case GL_SAMPLES:
2505	case GL_IMPLEMENTATION_COLOR_READ_TYPE:
2506	case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
2507	case GL_TEXTURE_BINDING_2D:
2508	case GL_TEXTURE_BINDING_CUBE_MAP:
2509	case GL_TEXTURE_BINDING_EXTERNAL_OES:
2510	case GL_TEXTURE_BINDING_3D_OES:
2511	case GL_COPY_READ_BUFFER_BINDING:
2512	case GL_COPY_WRITE_BUFFER_BINDING:
2513	case GL_DRAW_BUFFER0:
2514	case GL_DRAW_BUFFER1:
2515	case GL_DRAW_BUFFER2:
2516	case GL_DRAW_BUFFER3:
2517	case GL_DRAW_BUFFER4:
2518	case GL_DRAW_BUFFER5:
2519	case GL_DRAW_BUFFER6:
2520	case GL_DRAW_BUFFER7:
2521	case GL_DRAW_BUFFER8:
2522	case GL_DRAW_BUFFER9:
2523	case GL_DRAW_BUFFER10:
2524	case GL_DRAW_BUFFER11:
2525	case GL_DRAW_BUFFER12:
2526	case GL_DRAW_BUFFER13:
2527	case GL_DRAW_BUFFER14:
2528	case GL_DRAW_BUFFER15:
2529	case GL_MAJOR_VERSION:
2530	case GL_MAX_3D_TEXTURE_SIZE:
2531	case GL_MAX_ARRAY_TEXTURE_LAYERS:
2532	case GL_MAX_COLOR_ATTACHMENTS:
2533	case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
2534	case GL_MAX_COMBINED_UNIFORM_BLOCKS:
2535	case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
2536	case GL_MAX_DRAW_BUFFERS:
2537	case GL_MAX_ELEMENT_INDEX:
2538	case GL_MAX_ELEMENTS_INDICES:
2539	case GL_MAX_ELEMENTS_VERTICES:
2540	case GL_MAX_FRAGMENT_INPUT_COMPONENTS:
2541	case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
2542	case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
2543	case GL_MAX_PROGRAM_TEXEL_OFFSET:
2544	case GL_MAX_SERVER_WAIT_TIMEOUT:
2545	case GL_MAX_TEXTURE_LOD_BIAS:
2546	case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
2547	case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
2548	case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
2549	case GL_MAX_UNIFORM_BLOCK_SIZE:
2550	case GL_MAX_UNIFORM_BUFFER_BINDINGS:
2551	case GL_MAX_VARYING_COMPONENTS:
2552	case GL_MAX_VERTEX_OUTPUT_COMPONENTS:
2553	case GL_MAX_VERTEX_UNIFORM_BLOCKS:
2554	case GL_MAX_VERTEX_UNIFORM_COMPONENTS:
2555	case GL_MIN_PROGRAM_TEXEL_OFFSET:
2556	case GL_MINOR_VERSION:
2557	case GL_NUM_EXTENSIONS:
2558	case GL_NUM_PROGRAM_BINARY_FORMATS:
2559	case GL_PACK_ROW_LENGTH:
2560	case GL_PACK_SKIP_PIXELS:
2561	case GL_PACK_SKIP_ROWS:
2562	case GL_PIXEL_PACK_BUFFER_BINDING:
2563	case GL_PIXEL_UNPACK_BUFFER_BINDING:
2564	case GL_PROGRAM_BINARY_FORMATS:
2565	case GL_READ_BUFFER:
2566	case GL_SAMPLER_BINDING:
2567	case GL_TEXTURE_BINDING_2D_ARRAY:
2568	case GL_UNIFORM_BUFFER_BINDING:
2569	case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
2570	case GL_UNIFORM_BUFFER_SIZE:
2571	case GL_UNIFORM_BUFFER_START:
2572	case GL_UNPACK_IMAGE_HEIGHT:
2573	case GL_UNPACK_ROW_LENGTH:
2574	case GL_UNPACK_SKIP_IMAGES:
2575	case GL_UNPACK_SKIP_PIXELS:
2576	case GL_UNPACK_SKIP_ROWS:
2577	case GL_VERTEX_ARRAY_BINDING:
2578	case GL_TRANSFORM_FEEDBACK_BINDING:
2579	case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2580		{
2581			*type = GL_INT;
2582			*numParams = 1;
2583		}
2584		break;
2585	case GL_MAX_SAMPLES_ANGLE:
2586		{
2587			*type = GL_INT;
2588			*numParams = 1;
2589		}
2590		break;
2591	case GL_MAX_VIEWPORT_DIMS:
2592		{
2593			*type = GL_INT;
2594			*numParams = 2;
2595		}
2596		break;
2597	case GL_VIEWPORT:
2598	case GL_SCISSOR_BOX:
2599		{
2600			*type = GL_INT;
2601			*numParams = 4;
2602		}
2603		break;
2604	case GL_SHADER_COMPILER:
2605	case GL_SAMPLE_COVERAGE_INVERT:
2606	case GL_DEPTH_WRITEMASK:
2607	case GL_CULL_FACE:                // CULL_FACE through DITHER are natural to IsEnabled,
2608	case GL_POLYGON_OFFSET_FILL:      // but can be retrieved through the Get{Type}v queries.
2609	case GL_SAMPLE_ALPHA_TO_COVERAGE: // For this purpose, they are treated here as bool-natural
2610	case GL_SAMPLE_COVERAGE:
2611	case GL_SCISSOR_TEST:
2612	case GL_STENCIL_TEST:
2613	case GL_DEPTH_TEST:
2614	case GL_BLEND:
2615	case GL_DITHER:
2616	case GL_PRIMITIVE_RESTART_FIXED_INDEX:
2617	case GL_RASTERIZER_DISCARD:
2618	case GL_TRANSFORM_FEEDBACK_ACTIVE:
2619	case GL_TRANSFORM_FEEDBACK_PAUSED:
2620		{
2621			*type = GL_BOOL;
2622			*numParams = 1;
2623		}
2624		break;
2625	case GL_COLOR_WRITEMASK:
2626		{
2627			*type = GL_BOOL;
2628			*numParams = 4;
2629		}
2630		break;
2631	case GL_POLYGON_OFFSET_FACTOR:
2632	case GL_POLYGON_OFFSET_UNITS:
2633	case GL_SAMPLE_COVERAGE_VALUE:
2634	case GL_DEPTH_CLEAR_VALUE:
2635	case GL_LINE_WIDTH:
2636		{
2637			*type = GL_FLOAT;
2638			*numParams = 1;
2639		}
2640		break;
2641	case GL_ALIASED_LINE_WIDTH_RANGE:
2642	case GL_ALIASED_POINT_SIZE_RANGE:
2643	case GL_DEPTH_RANGE:
2644		{
2645			*type = GL_FLOAT;
2646			*numParams = 2;
2647		}
2648		break;
2649	case GL_COLOR_CLEAR_VALUE:
2650	case GL_BLEND_COLOR:
2651		{
2652			*type = GL_FLOAT;
2653			*numParams = 4;
2654		}
2655		break;
2656	case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
2657		*type = GL_FLOAT;
2658		*numParams = 1;
2659		break;
2660	default:
2661		return false;
2662	}
2663
2664	return true;
2665}
2666
2667void Context::applyScissor(int width, int height)
2668{
2669	if(mState.scissorTestEnabled)
2670	{
2671		sw::Rect scissor = { mState.scissorX, mState.scissorY, mState.scissorX + mState.scissorWidth, mState.scissorY + mState.scissorHeight };
2672		scissor.clip(0, 0, width, height);
2673
2674		device->setScissorRect(scissor);
2675		device->setScissorEnable(true);
2676	}
2677	else
2678	{
2679		device->setScissorEnable(false);
2680	}
2681}
2682
2683// Applies the render target surface, depth stencil surface, viewport rectangle and scissor rectangle
2684bool Context::applyRenderTarget()
2685{
2686	Framebuffer *framebuffer = getDrawFramebuffer();
2687	int width, height, samples;
2688
2689	if(!framebuffer || framebuffer->completeness(width, height, samples) != GL_FRAMEBUFFER_COMPLETE)
2690	{
2691		return error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
2692	}
2693
2694	for(int i = 0; i < MAX_DRAW_BUFFERS; i++)
2695	{
2696		if(framebuffer->getDrawBuffer(i) != GL_NONE)
2697		{
2698			egl::Image *renderTarget = framebuffer->getRenderTarget(i);
2699			device->setRenderTarget(i, renderTarget);
2700			if(renderTarget) renderTarget->release();
2701		}
2702		else
2703		{
2704			device->setRenderTarget(i, nullptr);
2705		}
2706	}
2707
2708	egl::Image *depthBuffer = framebuffer->getDepthBuffer();
2709	device->setDepthBuffer(depthBuffer);
2710	if(depthBuffer) depthBuffer->release();
2711
2712	egl::Image *stencilBuffer = framebuffer->getStencilBuffer();
2713	device->setStencilBuffer(stencilBuffer);
2714	if(stencilBuffer) stencilBuffer->release();
2715
2716	Viewport viewport;
2717	float zNear = clamp01(mState.zNear);
2718	float zFar = clamp01(mState.zFar);
2719
2720	viewport.x0 = mState.viewportX;
2721	viewport.y0 = mState.viewportY;
2722	viewport.width = mState.viewportWidth;
2723	viewport.height = mState.viewportHeight;
2724	viewport.minZ = zNear;
2725	viewport.maxZ = zFar;
2726
2727	device->setViewport(viewport);
2728
2729	applyScissor(width, height);
2730
2731	Program *program = getCurrentProgram();
2732
2733	if(program)
2734	{
2735		GLfloat nearFarDiff[3] = {zNear, zFar, zFar - zNear};
2736		program->setUniform1fv(program->getUniformLocation("gl_DepthRange.near"), 1, &nearFarDiff[0]);
2737		program->setUniform1fv(program->getUniformLocation("gl_DepthRange.far"), 1, &nearFarDiff[1]);
2738		program->setUniform1fv(program->getUniformLocation("gl_DepthRange.diff"), 1, &nearFarDiff[2]);
2739	}
2740
2741	return true;
2742}
2743
2744// Applies the fixed-function state (culling, depth test, alpha blending, stenciling, etc)
2745void Context::applyState(GLenum drawMode)
2746{
2747	Framebuffer *framebuffer = getDrawFramebuffer();
2748
2749	if(mState.cullFaceEnabled)
2750	{
2751		device->setCullMode(es2sw::ConvertCullMode(mState.cullMode, mState.frontFace));
2752	}
2753	else
2754	{
2755		device->setCullMode(sw::CULL_NONE);
2756	}
2757
2758	if(mDepthStateDirty)
2759	{
2760		if(mState.depthTestEnabled)
2761		{
2762			device->setDepthBufferEnable(true);
2763			device->setDepthCompare(es2sw::ConvertDepthComparison(mState.depthFunc));
2764		}
2765		else
2766		{
2767			device->setDepthBufferEnable(false);
2768		}
2769
2770		mDepthStateDirty = false;
2771	}
2772
2773	if(mBlendStateDirty)
2774	{
2775		if(mState.blendEnabled)
2776		{
2777			device->setAlphaBlendEnable(true);
2778			device->setSeparateAlphaBlendEnable(true);
2779
2780			device->setBlendConstant(es2sw::ConvertColor(mState.blendColor));
2781
2782			device->setSourceBlendFactor(es2sw::ConvertBlendFunc(mState.sourceBlendRGB));
2783			device->setDestBlendFactor(es2sw::ConvertBlendFunc(mState.destBlendRGB));
2784			device->setBlendOperation(es2sw::ConvertBlendOp(mState.blendEquationRGB));
2785
2786			device->setSourceBlendFactorAlpha(es2sw::ConvertBlendFunc(mState.sourceBlendAlpha));
2787			device->setDestBlendFactorAlpha(es2sw::ConvertBlendFunc(mState.destBlendAlpha));
2788			device->setBlendOperationAlpha(es2sw::ConvertBlendOp(mState.blendEquationAlpha));
2789		}
2790		else
2791		{
2792			device->setAlphaBlendEnable(false);
2793		}
2794
2795		mBlendStateDirty = false;
2796	}
2797
2798	if(mStencilStateDirty || mFrontFaceDirty)
2799	{
2800		if(mState.stencilTestEnabled && framebuffer->hasStencil())
2801		{
2802			device->setStencilEnable(true);
2803			device->setTwoSidedStencil(true);
2804
2805			// get the maximum size of the stencil ref
2806			Renderbuffer *stencilbuffer = framebuffer->getStencilbuffer();
2807			GLuint maxStencil = (1 << stencilbuffer->getStencilSize()) - 1;
2808
2809			if(mState.frontFace == GL_CCW)
2810			{
2811				device->setStencilWriteMask(mState.stencilWritemask);
2812				device->setStencilCompare(es2sw::ConvertStencilComparison(mState.stencilFunc));
2813
2814				device->setStencilReference((mState.stencilRef < (GLint)maxStencil) ? mState.stencilRef : maxStencil);
2815				device->setStencilMask(mState.stencilMask);
2816
2817				device->setStencilFailOperation(es2sw::ConvertStencilOp(mState.stencilFail));
2818				device->setStencilZFailOperation(es2sw::ConvertStencilOp(mState.stencilPassDepthFail));
2819				device->setStencilPassOperation(es2sw::ConvertStencilOp(mState.stencilPassDepthPass));
2820
2821				device->setStencilWriteMaskCCW(mState.stencilBackWritemask);
2822				device->setStencilCompareCCW(es2sw::ConvertStencilComparison(mState.stencilBackFunc));
2823
2824				device->setStencilReferenceCCW((mState.stencilBackRef < (GLint)maxStencil) ? mState.stencilBackRef : maxStencil);
2825				device->setStencilMaskCCW(mState.stencilBackMask);
2826
2827				device->setStencilFailOperationCCW(es2sw::ConvertStencilOp(mState.stencilBackFail));
2828				device->setStencilZFailOperationCCW(es2sw::ConvertStencilOp(mState.stencilBackPassDepthFail));
2829				device->setStencilPassOperationCCW(es2sw::ConvertStencilOp(mState.stencilBackPassDepthPass));
2830			}
2831			else
2832			{
2833				device->setStencilWriteMaskCCW(mState.stencilWritemask);
2834				device->setStencilCompareCCW(es2sw::ConvertStencilComparison(mState.stencilFunc));
2835
2836				device->setStencilReferenceCCW((mState.stencilRef < (GLint)maxStencil) ? mState.stencilRef : maxStencil);
2837				device->setStencilMaskCCW(mState.stencilMask);
2838
2839				device->setStencilFailOperationCCW(es2sw::ConvertStencilOp(mState.stencilFail));
2840				device->setStencilZFailOperationCCW(es2sw::ConvertStencilOp(mState.stencilPassDepthFail));
2841				device->setStencilPassOperationCCW(es2sw::ConvertStencilOp(mState.stencilPassDepthPass));
2842
2843				device->setStencilWriteMask(mState.stencilBackWritemask);
2844				device->setStencilCompare(es2sw::ConvertStencilComparison(mState.stencilBackFunc));
2845
2846				device->setStencilReference((mState.stencilBackRef < (GLint)maxStencil) ? mState.stencilBackRef : maxStencil);
2847				device->setStencilMask(mState.stencilBackMask);
2848
2849				device->setStencilFailOperation(es2sw::ConvertStencilOp(mState.stencilBackFail));
2850				device->setStencilZFailOperation(es2sw::ConvertStencilOp(mState.stencilBackPassDepthFail));
2851				device->setStencilPassOperation(es2sw::ConvertStencilOp(mState.stencilBackPassDepthPass));
2852			}
2853		}
2854		else
2855		{
2856			device->setStencilEnable(false);
2857		}
2858
2859		mStencilStateDirty = false;
2860		mFrontFaceDirty = false;
2861	}
2862
2863	if(mMaskStateDirty)
2864	{
2865		for(int i = 0; i < MAX_DRAW_BUFFERS; i++)
2866		{
2867			device->setColorWriteMask(i, es2sw::ConvertColorMask(mState.colorMaskRed, mState.colorMaskGreen, mState.colorMaskBlue, mState.colorMaskAlpha));
2868		}
2869
2870		device->setDepthWriteEnable(mState.depthMask);
2871
2872		mMaskStateDirty = false;
2873	}
2874
2875	if(mPolygonOffsetStateDirty)
2876	{
2877		if(mState.polygonOffsetFillEnabled)
2878		{
2879			Renderbuffer *depthbuffer = framebuffer->getDepthbuffer();
2880			if(depthbuffer)
2881			{
2882				device->setSlopeDepthBias(mState.polygonOffsetFactor);
2883				float depthBias = ldexp(mState.polygonOffsetUnits, -23);   // We use 32-bit floating-point for all depth formats, with 23 mantissa bits.
2884				device->setDepthBias(depthBias);
2885			}
2886		}
2887		else
2888		{
2889			device->setSlopeDepthBias(0);
2890			device->setDepthBias(0);
2891		}
2892
2893		mPolygonOffsetStateDirty = false;
2894	}
2895
2896	if(mSampleStateDirty)
2897	{
2898		if(mState.sampleAlphaToCoverageEnabled)
2899		{
2900			device->setTransparencyAntialiasing(sw::TRANSPARENCY_ALPHA_TO_COVERAGE);
2901		}
2902		else
2903		{
2904			device->setTransparencyAntialiasing(sw::TRANSPARENCY_NONE);
2905		}
2906
2907		if(mState.sampleCoverageEnabled)
2908		{
2909			unsigned int mask = 0;
2910			if(mState.sampleCoverageValue != 0)
2911			{
2912				int width, height, samples;
2913				framebuffer->completeness(width, height, samples);
2914
2915				float threshold = 0.5f;
2916
2917				for(int i = 0; i < samples; i++)
2918				{
2919					mask <<= 1;
2920
2921					if((i + 1) * mState.sampleCoverageValue >= threshold)
2922					{
2923						threshold += 1.0f;
2924						mask |= 1;
2925					}
2926				}
2927			}
2928
2929			if(mState.sampleCoverageInvert)
2930			{
2931				mask = ~mask;
2932			}
2933
2934			device->setMultiSampleMask(mask);
2935		}
2936		else
2937		{
2938			device->setMultiSampleMask(0xFFFFFFFF);
2939		}
2940
2941		mSampleStateDirty = false;
2942	}
2943
2944	if(mDitherStateDirty)
2945	{
2946	//	UNIMPLEMENTED();   // FIXME
2947
2948		mDitherStateDirty = false;
2949	}
2950
2951	device->setRasterizerDiscard(mState.rasterizerDiscardEnabled);
2952}
2953
2954GLenum Context::applyVertexBuffer(GLint base, GLint first, GLsizei count, GLsizei instanceId)
2955{
2956	TranslatedAttribute attributes[MAX_VERTEX_ATTRIBS];
2957
2958	GLenum err = mVertexDataManager->prepareVertexData(first, count, attributes, instanceId);
2959	if(err != GL_NO_ERROR)
2960	{
2961		return err;
2962	}
2963
2964	Program *program = getCurrentProgram();
2965
2966	device->resetInputStreams(false);
2967
2968	for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
2969	{
2970		if(program->getAttributeStream(i) == -1)
2971		{
2972			continue;
2973		}
2974
2975		sw::Resource *resource = attributes[i].vertexBuffer;
2976		const void *buffer = (char*)resource->data() + attributes[i].offset;
2977
2978		int stride = attributes[i].stride;
2979
2980		buffer = (char*)buffer + stride * base;
2981
2982		sw::Stream attribute(resource, buffer, stride);
2983
2984		attribute.type = attributes[i].type;
2985		attribute.count = attributes[i].count;
2986		attribute.normalized = attributes[i].normalized;
2987
2988		int stream = program->getAttributeStream(i);
2989		device->setInputStream(stream, attribute);
2990	}
2991
2992	return GL_NO_ERROR;
2993}
2994
2995// Applies the indices and element array bindings
2996GLenum Context::applyIndexBuffer(const void *indices, GLuint start, GLuint end, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo)
2997{
2998	GLenum err = mIndexDataManager->prepareIndexData(mode, type, start, end, count, getCurrentVertexArray()->getElementArrayBuffer(), indices, indexInfo, isPrimitiveRestartFixedIndexEnabled());
2999
3000	if(err == GL_NO_ERROR)
3001	{
3002		device->setIndexBuffer(indexInfo->indexBuffer);
3003	}
3004
3005	return err;
3006}
3007
3008// Applies the shaders and shader constants
3009void Context::applyShaders()
3010{
3011	Program *programObject = getCurrentProgram();
3012	sw::VertexShader *vertexShader = programObject->getVertexShader();
3013	sw::PixelShader *pixelShader = programObject->getPixelShader();
3014
3015	device->setVertexShader(vertexShader);
3016	device->setPixelShader(pixelShader);
3017
3018	if(programObject->getSerial() != mAppliedProgramSerial)
3019	{
3020		programObject->dirtyAllUniforms();
3021		mAppliedProgramSerial = programObject->getSerial();
3022	}
3023
3024	programObject->applyTransformFeedback(device, getTransformFeedback());
3025	programObject->applyUniformBuffers(device, mState.uniformBuffers);
3026	programObject->applyUniforms(device);
3027}
3028
3029void Context::applyTextures()
3030{
3031	applyTextures(sw::SAMPLER_PIXEL);
3032	applyTextures(sw::SAMPLER_VERTEX);
3033}
3034
3035void Context::applyTextures(sw::SamplerType samplerType)
3036{
3037	Program *programObject = getCurrentProgram();
3038
3039	int samplerCount = (samplerType == sw::SAMPLER_PIXEL) ? MAX_TEXTURE_IMAGE_UNITS : MAX_VERTEX_TEXTURE_IMAGE_UNITS;   // Range of samplers of given sampler type
3040
3041	for(int samplerIndex = 0; samplerIndex < samplerCount; samplerIndex++)
3042	{
3043		int textureUnit = programObject->getSamplerMapping(samplerType, samplerIndex);   // OpenGL texture image unit index
3044
3045		if(textureUnit != -1)
3046		{
3047			TextureType textureType = programObject->getSamplerTextureType(samplerType, samplerIndex);
3048
3049			Texture *texture = getSamplerTexture(textureUnit, textureType);
3050
3051			if(texture->isSamplerComplete())
3052			{
3053				GLenum wrapS, wrapT, wrapR, minFilter, magFilter, compFunc, compMode;
3054				GLfloat minLOD, maxLOD;
3055
3056				Sampler *samplerObject = mState.sampler[textureUnit];
3057				if(samplerObject)
3058				{
3059					wrapS = samplerObject->getWrapS();
3060					wrapT = samplerObject->getWrapT();
3061					wrapR = samplerObject->getWrapR();
3062					minFilter = samplerObject->getMinFilter();
3063					magFilter = samplerObject->getMagFilter();
3064					minLOD = samplerObject->getMinLod();
3065					maxLOD = samplerObject->getMaxLod();
3066					compFunc = samplerObject->getCompareFunc();
3067					compMode = samplerObject->getCompareMode();
3068				}
3069				else
3070				{
3071					wrapS = texture->getWrapS();
3072					wrapT = texture->getWrapT();
3073					wrapR = texture->getWrapR();
3074					minFilter = texture->getMinFilter();
3075					magFilter = texture->getMagFilter();
3076					minLOD = texture->getMinLOD();
3077					maxLOD = texture->getMaxLOD();
3078					compFunc = texture->getCompareFunc();
3079					compMode = texture->getCompareMode();
3080				}
3081
3082				GLfloat maxAnisotropy = texture->getMaxAnisotropy();
3083				GLint baseLevel = texture->getBaseLevel();
3084				GLint maxLevel = texture->getMaxLevel();
3085				GLenum swizzleR = texture->getSwizzleR();
3086				GLenum swizzleG = texture->getSwizzleG();
3087				GLenum swizzleB = texture->getSwizzleB();
3088				GLenum swizzleA = texture->getSwizzleA();
3089
3090				device->setAddressingModeU(samplerType, samplerIndex, es2sw::ConvertTextureWrap(wrapS));
3091				device->setAddressingModeV(samplerType, samplerIndex, es2sw::ConvertTextureWrap(wrapT));
3092				device->setAddressingModeW(samplerType, samplerIndex, es2sw::ConvertTextureWrap(wrapR));
3093				device->setCompareFunc(samplerType, samplerIndex, es2sw::ConvertCompareFunc(compFunc, compMode));
3094				device->setSwizzleR(samplerType, samplerIndex, es2sw::ConvertSwizzleType(swizzleR));
3095				device->setSwizzleG(samplerType, samplerIndex, es2sw::ConvertSwizzleType(swizzleG));
3096				device->setSwizzleB(samplerType, samplerIndex, es2sw::ConvertSwizzleType(swizzleB));
3097				device->setSwizzleA(samplerType, samplerIndex, es2sw::ConvertSwizzleType(swizzleA));
3098				device->setMinLod(samplerType, samplerIndex, minLOD);
3099				device->setMaxLod(samplerType, samplerIndex, maxLOD);
3100				device->setBaseLevel(samplerType, samplerIndex, baseLevel);
3101				device->setMaxLevel(samplerType, samplerIndex, maxLevel);
3102				device->setTextureFilter(samplerType, samplerIndex, es2sw::ConvertTextureFilter(minFilter, magFilter, maxAnisotropy));
3103				device->setMipmapFilter(samplerType, samplerIndex, es2sw::ConvertMipMapFilter(minFilter));
3104				device->setMaxAnisotropy(samplerType, samplerIndex, maxAnisotropy);
3105				device->setHighPrecisionFiltering(samplerType, samplerIndex, mState.textureFilteringHint == GL_NICEST);
3106
3107				applyTexture(samplerType, samplerIndex, texture);
3108			}
3109			else
3110			{
3111				applyTexture(samplerType, samplerIndex, nullptr);
3112			}
3113		}
3114		else
3115		{
3116			applyTexture(samplerType, samplerIndex, nullptr);
3117		}
3118	}
3119}
3120
3121void Context::applyTexture(sw::SamplerType type, int index, Texture *baseTexture)
3122{
3123	Program *program = getCurrentProgram();
3124	int sampler = (type == sw::SAMPLER_PIXEL) ? index : 16 + index;
3125	bool textureUsed = false;
3126
3127	if(type == sw::SAMPLER_PIXEL)
3128	{
3129		textureUsed = program->getPixelShader()->usesSampler(index);
3130	}
3131	else if(type == sw::SAMPLER_VERTEX)
3132	{
3133		textureUsed = program->getVertexShader()->usesSampler(index);
3134	}
3135	else UNREACHABLE(type);
3136
3137	sw::Resource *resource = 0;
3138
3139	if(baseTexture && textureUsed)
3140	{
3141		resource = baseTexture->getResource();
3142	}
3143
3144	device->setTextureResource(sampler, resource);
3145
3146	if(baseTexture && textureUsed)
3147	{
3148		int levelCount = baseTexture->getLevelCount();
3149
3150		if(baseTexture->getTarget() == GL_TEXTURE_2D || baseTexture->getTarget() == GL_TEXTURE_EXTERNAL_OES)
3151		{
3152			Texture2D *texture = static_cast<Texture2D*>(baseTexture);
3153
3154			for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
3155			{
3156				int surfaceLevel = mipmapLevel;
3157
3158				if(surfaceLevel < 0)
3159				{
3160					surfaceLevel = 0;
3161				}
3162				else if(surfaceLevel >= levelCount)
3163				{
3164					surfaceLevel = levelCount - 1;
3165				}
3166
3167				egl::Image *surface = texture->getImage(surfaceLevel);
3168				device->setTextureLevel(sampler, 0, mipmapLevel, surface, sw::TEXTURE_2D);
3169			}
3170		}
3171		else if(baseTexture->getTarget() == GL_TEXTURE_3D_OES)
3172		{
3173			Texture3D *texture = static_cast<Texture3D*>(baseTexture);
3174
3175			for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
3176			{
3177				int surfaceLevel = mipmapLevel;
3178
3179				if(surfaceLevel < 0)
3180				{
3181					surfaceLevel = 0;
3182				}
3183				else if(surfaceLevel >= levelCount)
3184				{
3185					surfaceLevel = levelCount - 1;
3186				}
3187
3188				egl::Image *surface = texture->getImage(surfaceLevel);
3189				device->setTextureLevel(sampler, 0, mipmapLevel, surface, sw::TEXTURE_3D);
3190			}
3191		}
3192		else if(baseTexture->getTarget() == GL_TEXTURE_2D_ARRAY)
3193		{
3194			Texture2DArray *texture = static_cast<Texture2DArray*>(baseTexture);
3195
3196			for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
3197			{
3198				int surfaceLevel = mipmapLevel;
3199
3200				if(surfaceLevel < 0)
3201				{
3202					surfaceLevel = 0;
3203				}
3204				else if(surfaceLevel >= levelCount)
3205				{
3206					surfaceLevel = levelCount - 1;
3207				}
3208
3209				egl::Image *surface = texture->getImage(surfaceLevel);
3210				device->setTextureLevel(sampler, 0, mipmapLevel, surface, sw::TEXTURE_2D_ARRAY);
3211			}
3212		}
3213		else if(baseTexture->getTarget() == GL_TEXTURE_CUBE_MAP)
3214		{
3215			for(int face = 0; face < 6; face++)
3216			{
3217				TextureCubeMap *cubeTexture = static_cast<TextureCubeMap*>(baseTexture);
3218
3219				for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
3220				{
3221					int surfaceLevel = mipmapLevel;
3222
3223					if(surfaceLevel < 0)
3224					{
3225						surfaceLevel = 0;
3226					}
3227					else if(surfaceLevel >= levelCount)
3228					{
3229						surfaceLevel = levelCount - 1;
3230					}
3231
3232					egl::Image *surface = cubeTexture->getImage(face, surfaceLevel);
3233					device->setTextureLevel(sampler, face, mipmapLevel, surface, sw::TEXTURE_CUBE);
3234				}
3235			}
3236		}
3237		else UNIMPLEMENTED();
3238	}
3239	else
3240	{
3241		device->setTextureLevel(sampler, 0, 0, 0, sw::TEXTURE_NULL);
3242	}
3243}
3244
3245void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels)
3246{
3247	Framebuffer *framebuffer = getReadFramebuffer();
3248	int framebufferWidth, framebufferHeight, framebufferSamples;
3249
3250	if(framebuffer->completeness(framebufferWidth, framebufferHeight, framebufferSamples) != GL_FRAMEBUFFER_COMPLETE)
3251	{
3252		return error(GL_INVALID_FRAMEBUFFER_OPERATION);
3253	}
3254
3255	if(getReadFramebufferName() != 0 && framebufferSamples != 0)
3256	{
3257		return error(GL_INVALID_OPERATION);
3258	}
3259
3260	if(!IsValidReadPixelsFormatType(framebuffer, format, type, clientVersion))
3261	{
3262		return error(GL_INVALID_OPERATION);
3263	}
3264
3265	GLsizei outputWidth = (mState.packRowLength > 0) ? mState.packRowLength : width;
3266	GLsizei outputPitch = egl::ComputePitch(outputWidth, format, type, mState.packAlignment);
3267	GLsizei outputHeight = (mState.packImageHeight == 0) ? height : mState.packImageHeight;
3268	pixels = getPixelPackBuffer() ? (unsigned char*)getPixelPackBuffer()->data() + (ptrdiff_t)pixels : (unsigned char*)pixels;
3269	pixels = ((char*)pixels) + egl::ComputePackingOffset(format, type, outputWidth, outputHeight, mState.packAlignment, mState.packSkipImages, mState.packSkipRows, mState.packSkipPixels);
3270
3271	// Sized query sanity check
3272	if(bufSize)
3273	{
3274		int requiredSize = outputPitch * height;
3275		if(requiredSize > *bufSize)
3276		{
3277			return error(GL_INVALID_OPERATION);
3278		}
3279	}
3280
3281	egl::Image *renderTarget = nullptr;
3282	switch(format)
3283	{
3284	case GL_DEPTH_COMPONENT:
3285		renderTarget = framebuffer->getDepthBuffer();
3286		break;
3287	default:
3288		renderTarget = framebuffer->getReadRenderTarget();
3289		break;
3290	}
3291
3292	if(!renderTarget)
3293	{
3294		return error(GL_INVALID_OPERATION);
3295	}
3296
3297	sw::Rect rect = {x, y, x + width, y + height};
3298	sw::Rect dstRect = { 0, 0, width, height };
3299	rect.clip(0, 0, renderTarget->getWidth(), renderTarget->getHeight());
3300
3301	sw::Surface *externalSurface = sw::Surface::create(width, height, 1, egl::ConvertFormatType(format, type), pixels, outputPitch, outputPitch * outputHeight);
3302	sw::SliceRect sliceRect(rect);
3303	sw::SliceRect dstSliceRect(dstRect);
3304	device->blit(renderTarget, sliceRect, externalSurface, dstSliceRect, false);
3305	delete externalSurface;
3306
3307	renderTarget->release();
3308}
3309
3310void Context::clear(GLbitfield mask)
3311{
3312	if(mState.rasterizerDiscardEnabled)
3313	{
3314		return;
3315	}
3316
3317	Framebuffer *framebuffer = getDrawFramebuffer();
3318
3319	if(!framebuffer || framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
3320	{
3321		return error(GL_INVALID_FRAMEBUFFER_OPERATION);
3322	}
3323
3324	if(!applyRenderTarget())
3325	{
3326		return;
3327	}
3328
3329	if(mask & GL_COLOR_BUFFER_BIT)
3330	{
3331		unsigned int rgbaMask = getColorMask();
3332
3333		if(rgbaMask != 0)
3334		{
3335			device->clearColor(mState.colorClearValue.red, mState.colorClearValue.green, mState.colorClearValue.blue, mState.colorClearValue.alpha, rgbaMask);
3336		}
3337	}
3338
3339	if(mask & GL_DEPTH_BUFFER_BIT)
3340	{
3341		if(mState.depthMask != 0)
3342		{
3343			float depth = clamp01(mState.depthClearValue);
3344			device->clearDepth(depth);
3345		}
3346	}
3347
3348	if(mask & GL_STENCIL_BUFFER_BIT)
3349	{
3350		if(mState.stencilWritemask != 0)
3351		{
3352			int stencil = mState.stencilClearValue & 0x000000FF;
3353			device->clearStencil(stencil, mState.stencilWritemask);
3354		}
3355	}
3356}
3357
3358void Context::clearColorBuffer(GLint drawbuffer, void *value, sw::Format format)
3359{
3360	unsigned int rgbaMask = getColorMask();
3361	if(rgbaMask && !mState.rasterizerDiscardEnabled)
3362	{
3363		Framebuffer *framebuffer = getDrawFramebuffer();
3364		egl::Image *colorbuffer = framebuffer->getRenderTarget(drawbuffer);
3365
3366		if(colorbuffer)
3367		{
3368			sw::Rect clearRect = colorbuffer->getRect();
3369
3370			if(mState.scissorTestEnabled)
3371			{
3372				clearRect.clip(mState.scissorX, mState.scissorY, mState.scissorX + mState.scissorWidth, mState.scissorY + mState.scissorHeight);
3373			}
3374
3375			device->clear(value, format, colorbuffer, clearRect, rgbaMask);
3376
3377			colorbuffer->release();
3378		}
3379	}
3380}
3381
3382void Context::clearColorBuffer(GLint drawbuffer, const GLint *value)
3383{
3384	clearColorBuffer(drawbuffer, (void*)value, sw::FORMAT_A32B32G32R32I);
3385}
3386
3387void Context::clearColorBuffer(GLint drawbuffer, const GLuint *value)
3388{
3389	clearColorBuffer(drawbuffer, (void*)value, sw::FORMAT_A32B32G32R32UI);
3390}
3391
3392void Context::clearColorBuffer(GLint drawbuffer, const GLfloat *value)
3393{
3394	clearColorBuffer(drawbuffer, (void*)value, sw::FORMAT_A32B32G32R32F);
3395}
3396
3397void Context::clearDepthBuffer(const GLfloat value)
3398{
3399	if(mState.depthMask && !mState.rasterizerDiscardEnabled)
3400	{
3401		Framebuffer *framebuffer = getDrawFramebuffer();
3402		egl::Image *depthbuffer = framebuffer->getDepthBuffer();
3403
3404		if(depthbuffer)
3405		{
3406			float depth = clamp01(value);
3407			sw::Rect clearRect = depthbuffer->getRect();
3408
3409			if(mState.scissorTestEnabled)
3410			{
3411				clearRect.clip(mState.scissorX, mState.scissorY, mState.scissorX + mState.scissorWidth, mState.scissorY + mState.scissorHeight);
3412			}
3413
3414			depthbuffer->clearDepth(depth, clearRect.x0, clearRect.y0, clearRect.width(), clearRect.height());
3415
3416			depthbuffer->release();
3417		}
3418	}
3419}
3420
3421void Context::clearStencilBuffer(const GLint value)
3422{
3423	if(mState.stencilWritemask && !mState.rasterizerDiscardEnabled)
3424	{
3425		Framebuffer *framebuffer = getDrawFramebuffer();
3426		egl::Image *stencilbuffer = framebuffer->getStencilBuffer();
3427
3428		if(stencilbuffer)
3429		{
3430			unsigned char stencil = value < 0 ? 0 : static_cast<unsigned char>(value & 0x000000FF);
3431			sw::Rect clearRect = stencilbuffer->getRect();
3432
3433			if(mState.scissorTestEnabled)
3434			{
3435				clearRect.clip(mState.scissorX, mState.scissorY, mState.scissorX + mState.scissorWidth, mState.scissorY + mState.scissorHeight);
3436			}
3437
3438			stencilbuffer->clearStencil(stencil, static_cast<unsigned char>(mState.stencilWritemask), clearRect.x0, clearRect.y0, clearRect.width(), clearRect.height());
3439
3440			stencilbuffer->release();
3441		}
3442	}
3443}
3444
3445void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
3446{
3447	if(!mState.currentProgram)
3448	{
3449		return error(GL_INVALID_OPERATION);
3450	}
3451
3452	sw::DrawType primitiveType;
3453	int primitiveCount;
3454	int verticesPerPrimitive;
3455
3456	if(!es2sw::ConvertPrimitiveType(mode, count, GL_NONE, primitiveType, primitiveCount, verticesPerPrimitive))
3457		return error(GL_INVALID_ENUM);
3458
3459	if(primitiveCount <= 0)
3460	{
3461		return;
3462	}
3463
3464	if(!applyRenderTarget())
3465	{
3466		return;
3467	}
3468
3469	applyState(mode);
3470
3471	for(int i = 0; i < instanceCount; ++i)
3472	{
3473		device->setInstanceID(i);
3474
3475		GLenum err = applyVertexBuffer(0, first, count, i);
3476		if(err != GL_NO_ERROR)
3477		{
3478			return error(err);
3479		}
3480
3481		applyShaders();
3482		applyTextures();
3483
3484		if(!getCurrentProgram()->validateSamplers(false))
3485		{
3486			return error(GL_INVALID_OPERATION);
3487		}
3488
3489		TransformFeedback* transformFeedback = getTransformFeedback();
3490		if(!cullSkipsDraw(mode) || (transformFeedback->isActive() && !transformFeedback->isPaused()))
3491		{
3492			device->drawPrimitive(primitiveType, primitiveCount);
3493		}
3494		if(transformFeedback)
3495		{
3496			transformFeedback->addVertexOffset(primitiveCount * verticesPerPrimitive);
3497		}
3498	}
3499}
3500
3501void Context::drawElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLsizei instanceCount)
3502{
3503	if(!mState.currentProgram)
3504	{
3505		return error(GL_INVALID_OPERATION);
3506	}
3507
3508	if(!indices && !getCurrentVertexArray()->getElementArrayBuffer())
3509	{
3510		return error(GL_INVALID_OPERATION);
3511	}
3512
3513	GLenum internalMode = mode;
3514	if(isPrimitiveRestartFixedIndexEnabled())
3515	{
3516		switch(mode)
3517		{
3518		case GL_TRIANGLE_FAN:
3519		case GL_TRIANGLE_STRIP:
3520			internalMode = GL_TRIANGLES;
3521			break;
3522		case GL_LINE_LOOP:
3523		case GL_LINE_STRIP:
3524			internalMode = GL_LINES;
3525			break;
3526		default:
3527			break;
3528		}
3529	}
3530
3531	sw::DrawType primitiveType;
3532	int primitiveCount;
3533	int verticesPerPrimitive;
3534
3535	if(!es2sw::ConvertPrimitiveType(internalMode, count, type, primitiveType, primitiveCount, verticesPerPrimitive))
3536		return error(GL_INVALID_ENUM);
3537
3538	if(primitiveCount <= 0)
3539	{
3540		return;
3541	}
3542
3543	if(!applyRenderTarget())
3544	{
3545		return;
3546	}
3547
3548	TranslatedIndexData indexInfo(primitiveCount);
3549	GLenum err = applyIndexBuffer(indices, start, end, count, mode, type, &indexInfo);
3550	if(err != GL_NO_ERROR)
3551	{
3552		return error(err);
3553	}
3554
3555	applyState(internalMode);
3556
3557	for(int i = 0; i < instanceCount; ++i)
3558	{
3559		device->setInstanceID(i);
3560
3561		GLsizei vertexCount = indexInfo.maxIndex - indexInfo.minIndex + 1;
3562		err = applyVertexBuffer(-(int)indexInfo.minIndex, indexInfo.minIndex, vertexCount, i);
3563		if(err != GL_NO_ERROR)
3564		{
3565			return error(err);
3566		}
3567
3568		applyShaders();
3569		applyTextures();
3570
3571		if(!getCurrentProgram()->validateSamplers(false))
3572		{
3573			return error(GL_INVALID_OPERATION);
3574		}
3575
3576		TransformFeedback* transformFeedback = getTransformFeedback();
3577		if(!cullSkipsDraw(internalMode) || (transformFeedback->isActive() && !transformFeedback->isPaused()))
3578		{
3579			device->drawIndexedPrimitive(primitiveType, indexInfo.indexOffset, indexInfo.primitiveCount);
3580		}
3581		if(transformFeedback)
3582		{
3583			transformFeedback->addVertexOffset(indexInfo.primitiveCount * verticesPerPrimitive);
3584		}
3585	}
3586}
3587
3588void Context::blit(sw::Surface *source, const sw::SliceRect &sRect, sw::Surface *dest, const sw::SliceRect &dRect)
3589{
3590	device->blit(source, sRect, dest, dRect, false);
3591}
3592
3593void Context::finish()
3594{
3595	device->finish();
3596}
3597
3598void Context::flush()
3599{
3600	// We don't queue anything without processing it as fast as possible
3601}
3602
3603void Context::recordInvalidEnum()
3604{
3605	mInvalidEnum = true;
3606}
3607
3608void Context::recordInvalidValue()
3609{
3610	mInvalidValue = true;
3611}
3612
3613void Context::recordInvalidOperation()
3614{
3615	mInvalidOperation = true;
3616}
3617
3618void Context::recordOutOfMemory()
3619{
3620	mOutOfMemory = true;
3621}
3622
3623void Context::recordInvalidFramebufferOperation()
3624{
3625	mInvalidFramebufferOperation = true;
3626}
3627
3628// Get one of the recorded errors and clear its flag, if any.
3629// [OpenGL ES 2.0.24] section 2.5 page 13.
3630GLenum Context::getError()
3631{
3632	if(mInvalidEnum)
3633	{
3634		mInvalidEnum = false;
3635
3636		return GL_INVALID_ENUM;
3637	}
3638
3639	if(mInvalidValue)
3640	{
3641		mInvalidValue = false;
3642
3643		return GL_INVALID_VALUE;
3644	}
3645
3646	if(mInvalidOperation)
3647	{
3648		mInvalidOperation = false;
3649
3650		return GL_INVALID_OPERATION;
3651	}
3652
3653	if(mOutOfMemory)
3654	{
3655		mOutOfMemory = false;
3656
3657		return GL_OUT_OF_MEMORY;
3658	}
3659
3660	if(mInvalidFramebufferOperation)
3661	{
3662		mInvalidFramebufferOperation = false;
3663
3664		return GL_INVALID_FRAMEBUFFER_OPERATION;
3665	}
3666
3667	return GL_NO_ERROR;
3668}
3669
3670int Context::getSupportedMultisampleCount(int requested)
3671{
3672	int supported = 0;
3673
3674	for(int i = NUM_MULTISAMPLE_COUNTS - 1; i >= 0; i--)
3675	{
3676		if(supported >= requested)
3677		{
3678			return supported;
3679		}
3680
3681		supported = multisampleCount[i];
3682	}
3683
3684	return supported;
3685}
3686
3687void Context::detachBuffer(GLuint buffer)
3688{
3689	// [OpenGL ES 2.0.24] section 2.9 page 22:
3690	// If a buffer object is deleted while it is bound, all bindings to that object in the current context
3691	// (i.e. in the thread that called Delete-Buffers) are reset to zero.
3692
3693	if(mState.copyReadBuffer.name() == buffer)
3694	{
3695		mState.copyReadBuffer = nullptr;
3696	}
3697
3698	if(mState.copyWriteBuffer.name() == buffer)
3699	{
3700		mState.copyWriteBuffer = nullptr;
3701	}
3702
3703	if(mState.pixelPackBuffer.name() == buffer)
3704	{
3705		mState.pixelPackBuffer = nullptr;
3706	}
3707
3708	if(mState.pixelUnpackBuffer.name() == buffer)
3709	{
3710		mState.pixelUnpackBuffer = nullptr;
3711	}
3712
3713	if(mState.genericUniformBuffer.name() == buffer)
3714	{
3715		mState.genericUniformBuffer = nullptr;
3716	}
3717
3718	if(getArrayBufferName() == buffer)
3719	{
3720		mState.arrayBuffer = nullptr;
3721	}
3722
3723	// Only detach from the current transform feedback
3724	TransformFeedback* currentTransformFeedback = getTransformFeedback();
3725	if(currentTransformFeedback)
3726	{
3727		currentTransformFeedback->detachBuffer(buffer);
3728	}
3729
3730	// Only detach from the current vertex array
3731	VertexArray* currentVertexArray = getCurrentVertexArray();
3732	if(currentVertexArray)
3733	{
3734		currentVertexArray->detachBuffer(buffer);
3735	}
3736
3737	for(int attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
3738	{
3739		if(mState.vertexAttribute[attribute].mBoundBuffer.name() == buffer)
3740		{
3741			mState.vertexAttribute[attribute].mBoundBuffer = nullptr;
3742		}
3743	}
3744}
3745
3746void Context::detachTexture(GLuint texture)
3747{
3748	// [OpenGL ES 2.0.24] section 3.8 page 84:
3749	// If a texture object is deleted, it is as if all texture units which are bound to that texture object are
3750	// rebound to texture object zero
3751
3752	for(int type = 0; type < TEXTURE_TYPE_COUNT; type++)
3753	{
3754		for(int sampler = 0; sampler < MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++)
3755		{
3756			if(mState.samplerTexture[type][sampler].name() == texture)
3757			{
3758				mState.samplerTexture[type][sampler] = nullptr;
3759			}
3760		}
3761	}
3762
3763	// [OpenGL ES 2.0.24] section 4.4 page 112:
3764	// If a texture object is deleted while its image is attached to the currently bound framebuffer, then it is
3765	// as if FramebufferTexture2D had been called, with a texture of 0, for each attachment point to which this
3766	// image was attached in the currently bound framebuffer.
3767
3768	Framebuffer *readFramebuffer = getReadFramebuffer();
3769	Framebuffer *drawFramebuffer = getDrawFramebuffer();
3770
3771	if(readFramebuffer)
3772	{
3773		readFramebuffer->detachTexture(texture);
3774	}
3775
3776	if(drawFramebuffer && drawFramebuffer != readFramebuffer)
3777	{
3778		drawFramebuffer->detachTexture(texture);
3779	}
3780}
3781
3782void Context::detachFramebuffer(GLuint framebuffer)
3783{
3784	// [OpenGL ES 2.0.24] section 4.4 page 107:
3785	// If a framebuffer that is currently bound to the target FRAMEBUFFER is deleted, it is as though
3786	// BindFramebuffer had been executed with the target of FRAMEBUFFER and framebuffer of zero.
3787
3788	if(mState.readFramebuffer == framebuffer)
3789	{
3790		bindReadFramebuffer(0);
3791	}
3792
3793	if(mState.drawFramebuffer == framebuffer)
3794	{
3795		bindDrawFramebuffer(0);
3796	}
3797}
3798
3799void Context::detachRenderbuffer(GLuint renderbuffer)
3800{
3801	// [OpenGL ES 2.0.24] section 4.4 page 109:
3802	// If a renderbuffer that is currently bound to RENDERBUFFER is deleted, it is as though BindRenderbuffer
3803	// had been executed with the target RENDERBUFFER and name of zero.
3804
3805	if(mState.renderbuffer.name() == renderbuffer)
3806	{
3807		bindRenderbuffer(0);
3808	}
3809
3810	// [OpenGL ES 2.0.24] section 4.4 page 111:
3811	// If a renderbuffer object is deleted while its image is attached to the currently bound framebuffer,
3812	// then it is as if FramebufferRenderbuffer had been called, with a renderbuffer of 0, for each attachment
3813	// point to which this image was attached in the currently bound framebuffer.
3814
3815	Framebuffer *readFramebuffer = getReadFramebuffer();
3816	Framebuffer *drawFramebuffer = getDrawFramebuffer();
3817
3818	if(readFramebuffer)
3819	{
3820		readFramebuffer->detachRenderbuffer(renderbuffer);
3821	}
3822
3823	if(drawFramebuffer && drawFramebuffer != readFramebuffer)
3824	{
3825		drawFramebuffer->detachRenderbuffer(renderbuffer);
3826	}
3827}
3828
3829void Context::detachSampler(GLuint sampler)
3830{
3831	// [OpenGL ES 3.0.2] section 3.8.2 pages 123-124:
3832	// If a sampler object that is currently bound to one or more texture units is
3833	// deleted, it is as though BindSampler is called once for each texture unit to
3834	// which the sampler is bound, with unit set to the texture unit and sampler set to zero.
3835	for(size_t textureUnit = 0; textureUnit < MAX_COMBINED_TEXTURE_IMAGE_UNITS; ++textureUnit)
3836	{
3837		gl::BindingPointer<Sampler> &samplerBinding = mState.sampler[textureUnit];
3838		if(samplerBinding.name() == sampler)
3839		{
3840			samplerBinding = nullptr;
3841		}
3842	}
3843}
3844
3845bool Context::cullSkipsDraw(GLenum drawMode)
3846{
3847	return mState.cullFaceEnabled && mState.cullMode == GL_FRONT_AND_BACK && isTriangleMode(drawMode);
3848}
3849
3850bool Context::isTriangleMode(GLenum drawMode)
3851{
3852	switch(drawMode)
3853	{
3854	case GL_TRIANGLES:
3855	case GL_TRIANGLE_FAN:
3856	case GL_TRIANGLE_STRIP:
3857		return true;
3858	case GL_POINTS:
3859	case GL_LINES:
3860	case GL_LINE_LOOP:
3861	case GL_LINE_STRIP:
3862		return false;
3863	default: UNREACHABLE(drawMode);
3864	}
3865
3866	return false;
3867}
3868
3869void Context::setVertexAttrib(GLuint index, const GLfloat *values)
3870{
3871	ASSERT(index < MAX_VERTEX_ATTRIBS);
3872
3873	mState.vertexAttribute[index].setCurrentValue(values);
3874
3875	mVertexDataManager->dirtyCurrentValue(index);
3876}
3877
3878void Context::setVertexAttrib(GLuint index, const GLint *values)
3879{
3880	ASSERT(index < MAX_VERTEX_ATTRIBS);
3881
3882	mState.vertexAttribute[index].setCurrentValue(values);
3883
3884	mVertexDataManager->dirtyCurrentValue(index);
3885}
3886
3887void Context::setVertexAttrib(GLuint index, const GLuint *values)
3888{
3889	ASSERT(index < MAX_VERTEX_ATTRIBS);
3890
3891	mState.vertexAttribute[index].setCurrentValue(values);
3892
3893	mVertexDataManager->dirtyCurrentValue(index);
3894}
3895
3896void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
3897                              GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
3898                              GLbitfield mask, bool filter, bool allowPartialDepthStencilBlit)
3899{
3900	Framebuffer *readFramebuffer = getReadFramebuffer();
3901	Framebuffer *drawFramebuffer = getDrawFramebuffer();
3902
3903	int readBufferWidth, readBufferHeight, readBufferSamples;
3904	int drawBufferWidth, drawBufferHeight, drawBufferSamples;
3905
3906	if(!readFramebuffer || readFramebuffer->completeness(readBufferWidth, readBufferHeight, readBufferSamples) != GL_FRAMEBUFFER_COMPLETE ||
3907	   !drawFramebuffer || drawFramebuffer->completeness(drawBufferWidth, drawBufferHeight, drawBufferSamples) != GL_FRAMEBUFFER_COMPLETE)
3908	{
3909		return error(GL_INVALID_FRAMEBUFFER_OPERATION);
3910	}
3911
3912	if(drawBufferSamples > 1)
3913	{
3914		return error(GL_INVALID_OPERATION);
3915	}
3916
3917	sw::SliceRect sourceRect;
3918	sw::SliceRect destRect;
3919	bool flipX = (srcX0 < srcX1) ^ (dstX0 < dstX1);
3920	bool flipy = (srcY0 < srcY1) ^ (dstY0 < dstY1);
3921
3922	if(srcX0 < srcX1)
3923	{
3924		sourceRect.x0 = srcX0;
3925		sourceRect.x1 = srcX1;
3926	}
3927	else
3928	{
3929		sourceRect.x0 = srcX1;
3930		sourceRect.x1 = srcX0;
3931	}
3932
3933	if(dstX0 < dstX1)
3934	{
3935		destRect.x0 = dstX0;
3936		destRect.x1 = dstX1;
3937	}
3938	else
3939	{
3940		destRect.x0 = dstX1;
3941		destRect.x1 = dstX0;
3942	}
3943
3944	if(srcY0 < srcY1)
3945	{
3946		sourceRect.y0 = srcY0;
3947		sourceRect.y1 = srcY1;
3948	}
3949	else
3950	{
3951		sourceRect.y0 = srcY1;
3952		sourceRect.y1 = srcY0;
3953	}
3954
3955	if(dstY0 < dstY1)
3956	{
3957		destRect.y0 = dstY0;
3958		destRect.y1 = dstY1;
3959	}
3960	else
3961	{
3962		destRect.y0 = dstY1;
3963		destRect.y1 = dstY0;
3964	}
3965
3966	sw::Rect sourceScissoredRect = sourceRect;
3967	sw::Rect destScissoredRect = destRect;
3968
3969	if(mState.scissorTestEnabled)   // Only write to parts of the destination framebuffer which pass the scissor test
3970	{
3971		if(destRect.x0 < mState.scissorX)
3972		{
3973			int xDiff = mState.scissorX - destRect.x0;
3974			destScissoredRect.x0 = mState.scissorX;
3975			sourceScissoredRect.x0 += xDiff;
3976		}
3977
3978		if(destRect.x1 > mState.scissorX + mState.scissorWidth)
3979		{
3980			int xDiff = destRect.x1 - (mState.scissorX + mState.scissorWidth);
3981			destScissoredRect.x1 = mState.scissorX + mState.scissorWidth;
3982			sourceScissoredRect.x1 -= xDiff;
3983		}
3984
3985		if(destRect.y0 < mState.scissorY)
3986		{
3987			int yDiff = mState.scissorY - destRect.y0;
3988			destScissoredRect.y0 = mState.scissorY;
3989			sourceScissoredRect.y0 += yDiff;
3990		}
3991
3992		if(destRect.y1 > mState.scissorY + mState.scissorHeight)
3993		{
3994			int yDiff = destRect.y1 - (mState.scissorY + mState.scissorHeight);
3995			destScissoredRect.y1 = mState.scissorY + mState.scissorHeight;
3996			sourceScissoredRect.y1 -= yDiff;
3997		}
3998	}
3999
4000	sw::Rect sourceTrimmedRect = sourceScissoredRect;
4001	sw::Rect destTrimmedRect = destScissoredRect;
4002
4003	// The source & destination rectangles also may need to be trimmed if they fall out of the bounds of
4004	// the actual draw and read surfaces.
4005	if(sourceTrimmedRect.x0 < 0)
4006	{
4007		int xDiff = 0 - sourceTrimmedRect.x0;
4008		sourceTrimmedRect.x0 = 0;
4009		destTrimmedRect.x0 += xDiff;
4010	}
4011
4012	if(sourceTrimmedRect.x1 > readBufferWidth)
4013	{
4014		int xDiff = sourceTrimmedRect.x1 - readBufferWidth;
4015		sourceTrimmedRect.x1 = readBufferWidth;
4016		destTrimmedRect.x1 -= xDiff;
4017	}
4018
4019	if(sourceTrimmedRect.y0 < 0)
4020	{
4021		int yDiff = 0 - sourceTrimmedRect.y0;
4022		sourceTrimmedRect.y0 = 0;
4023		destTrimmedRect.y0 += yDiff;
4024	}
4025
4026	if(sourceTrimmedRect.y1 > readBufferHeight)
4027	{
4028		int yDiff = sourceTrimmedRect.y1 - readBufferHeight;
4029		sourceTrimmedRect.y1 = readBufferHeight;
4030		destTrimmedRect.y1 -= yDiff;
4031	}
4032
4033	if(destTrimmedRect.x0 < 0)
4034	{
4035		int xDiff = 0 - destTrimmedRect.x0;
4036		destTrimmedRect.x0 = 0;
4037		sourceTrimmedRect.x0 += xDiff;
4038	}
4039
4040	if(destTrimmedRect.x1 > drawBufferWidth)
4041	{
4042		int xDiff = destTrimmedRect.x1 - drawBufferWidth;
4043		destTrimmedRect.x1 = drawBufferWidth;
4044		sourceTrimmedRect.x1 -= xDiff;
4045	}
4046
4047	if(destTrimmedRect.y0 < 0)
4048	{
4049		int yDiff = 0 - destTrimmedRect.y0;
4050		destTrimmedRect.y0 = 0;
4051		sourceTrimmedRect.y0 += yDiff;
4052	}
4053
4054	if(destTrimmedRect.y1 > drawBufferHeight)
4055	{
4056		int yDiff = destTrimmedRect.y1 - drawBufferHeight;
4057		destTrimmedRect.y1 = drawBufferHeight;
4058		sourceTrimmedRect.y1 -= yDiff;
4059	}
4060
4061	bool partialBufferCopy = false;
4062
4063	if(sourceTrimmedRect.y1 - sourceTrimmedRect.y0 < readBufferHeight ||
4064	   sourceTrimmedRect.x1 - sourceTrimmedRect.x0 < readBufferWidth ||
4065	   destTrimmedRect.y1 - destTrimmedRect.y0 < drawBufferHeight ||
4066	   destTrimmedRect.x1 - destTrimmedRect.x0 < drawBufferWidth ||
4067	   sourceTrimmedRect.y0 != 0 || destTrimmedRect.y0 != 0 || sourceTrimmedRect.x0 != 0 || destTrimmedRect.x0 != 0)
4068	{
4069		partialBufferCopy = true;
4070	}
4071
4072	bool sameBounds = (srcX0 == dstX0 && srcY0 == dstY0 && srcX1 == dstX1 && srcY1 == dstY1);
4073	bool blitRenderTarget = false;
4074	bool blitDepth = false;
4075	bool blitStencil = false;
4076
4077	if(mask & GL_COLOR_BUFFER_BIT)
4078	{
4079		GLenum readColorbufferType = readFramebuffer->getColorbufferType(getReadFramebufferColorIndex());
4080		GLenum drawColorbufferType = drawFramebuffer->getColorbufferType(0);
4081		const bool validReadType = readColorbufferType == GL_TEXTURE_2D || Framebuffer::IsRenderbuffer(readColorbufferType);
4082		const bool validDrawType = drawColorbufferType == GL_TEXTURE_2D || Framebuffer::IsRenderbuffer(drawColorbufferType);
4083		if(!validReadType || !validDrawType)
4084		{
4085			return error(GL_INVALID_OPERATION);
4086		}
4087
4088		if(partialBufferCopy && readBufferSamples > 1 && !sameBounds)
4089		{
4090			return error(GL_INVALID_OPERATION);
4091		}
4092
4093		blitRenderTarget = true;
4094	}
4095
4096	if(mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT))
4097	{
4098		Renderbuffer *readDSBuffer = nullptr;
4099		Renderbuffer *drawDSBuffer = nullptr;
4100
4101		if(mask & GL_DEPTH_BUFFER_BIT)
4102		{
4103			if(readFramebuffer->getDepthbuffer() && drawFramebuffer->getDepthbuffer())
4104			{
4105				GLenum readDepthBufferType = readFramebuffer->getDepthbufferType();
4106				GLenum drawDepthBufferType = drawFramebuffer->getDepthbufferType();
4107				if((readDepthBufferType != drawDepthBufferType) &&
4108				   !(Framebuffer::IsRenderbuffer(readDepthBufferType) && Framebuffer::IsRenderbuffer(drawDepthBufferType)))
4109				{
4110					return error(GL_INVALID_OPERATION);
4111				}
4112
4113				blitDepth = true;
4114				readDSBuffer = readFramebuffer->getDepthbuffer();
4115				drawDSBuffer = drawFramebuffer->getDepthbuffer();
4116			}
4117		}
4118
4119		if(mask & GL_STENCIL_BUFFER_BIT)
4120		{
4121			if(readFramebuffer->getStencilbuffer() && drawFramebuffer->getStencilbuffer())
4122			{
4123				GLenum readStencilBufferType = readFramebuffer->getStencilbufferType();
4124				GLenum drawStencilBufferType = drawFramebuffer->getStencilbufferType();
4125				if((readStencilBufferType != drawStencilBufferType) &&
4126				   !(Framebuffer::IsRenderbuffer(readStencilBufferType) && Framebuffer::IsRenderbuffer(drawStencilBufferType)))
4127				{
4128					return error(GL_INVALID_OPERATION);
4129				}
4130
4131				blitStencil = true;
4132				readDSBuffer = readFramebuffer->getStencilbuffer();
4133				drawDSBuffer = drawFramebuffer->getStencilbuffer();
4134			}
4135		}
4136
4137		if(partialBufferCopy && !allowPartialDepthStencilBlit)
4138		{
4139			ERR("Only whole-buffer depth and stencil blits are supported by ANGLE_framebuffer_blit.");
4140			return error(GL_INVALID_OPERATION);   // Only whole-buffer copies are permitted
4141		}
4142
4143		// OpenGL ES 3.0.4 spec, p.199:
4144		// ...an INVALID_OPERATION error is generated if the formats of the read
4145		// and draw framebuffers are not identical or if the source and destination
4146		// rectangles are not defined with the same(X0, Y 0) and (X1, Y 1) bounds.
4147		// If SAMPLE_BUFFERS for the draw framebuffer is greater than zero, an
4148		// INVALID_OPERATION error is generated.
4149		if((drawDSBuffer && drawDSBuffer->getSamples() > 1) ||
4150		   ((readDSBuffer && readDSBuffer->getSamples() > 1) &&
4151		    (!sameBounds || (drawDSBuffer->getFormat() != readDSBuffer->getFormat()))))
4152		{
4153			return error(GL_INVALID_OPERATION);
4154		}
4155	}
4156
4157	if(blitRenderTarget || blitDepth || blitStencil)
4158	{
4159		if(blitRenderTarget)
4160		{
4161			egl::Image *readRenderTarget = readFramebuffer->getReadRenderTarget();
4162			egl::Image *drawRenderTarget = drawFramebuffer->getRenderTarget(0);
4163
4164			if(flipX)
4165			{
4166				swap(destRect.x0, destRect.x1);
4167			}
4168			if(flipy)
4169			{
4170				swap(destRect.y0, destRect.y1);
4171			}
4172
4173			bool success = device->stretchRect(readRenderTarget, &sourceRect, drawRenderTarget, &destRect, (filter ? Device::USE_FILTER : 0) | Device::COLOR_BUFFER);
4174
4175			readRenderTarget->release();
4176			drawRenderTarget->release();
4177
4178			if(!success)
4179			{
4180				ERR("BlitFramebuffer failed.");
4181				return;
4182			}
4183		}
4184
4185		if(blitDepth)
4186		{
4187			egl::Image *readRenderTarget = readFramebuffer->getDepthBuffer();
4188			egl::Image *drawRenderTarget = drawFramebuffer->getDepthBuffer();
4189
4190			bool success = device->stretchRect(readRenderTarget, &sourceRect, drawRenderTarget, &destRect, (filter ? Device::USE_FILTER : 0) | Device::DEPTH_BUFFER);
4191
4192			readRenderTarget->release();
4193			drawRenderTarget->release();
4194
4195			if(!success)
4196			{
4197				ERR("BlitFramebuffer failed.");
4198				return;
4199			}
4200		}
4201
4202		if(blitStencil)
4203		{
4204			egl::Image *readRenderTarget = readFramebuffer->getStencilBuffer();
4205			egl::Image *drawRenderTarget = drawFramebuffer->getStencilBuffer();
4206
4207			bool success = device->stretchRect(readRenderTarget, &sourceRect, drawRenderTarget, &destRect, (filter ? Device::USE_FILTER : 0) | Device::STENCIL_BUFFER);
4208
4209			readRenderTarget->release();
4210			drawRenderTarget->release();
4211
4212			if(!success)
4213			{
4214				ERR("BlitFramebuffer failed.");
4215				return;
4216			}
4217		}
4218	}
4219}
4220
4221void Context::bindTexImage(gl::Surface *surface)
4222{
4223	es2::Texture2D *textureObject = getTexture2D();
4224
4225	if(textureObject)
4226	{
4227		textureObject->bindTexImage(surface);
4228	}
4229}
4230
4231EGLenum Context::validateSharedImage(EGLenum target, GLuint name, GLuint textureLevel)
4232{
4233	GLenum textureTarget = GL_NONE;
4234
4235	switch(target)
4236	{
4237	case EGL_GL_TEXTURE_2D_KHR:
4238		textureTarget = GL_TEXTURE_2D;
4239		break;
4240	case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
4241	case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
4242	case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
4243	case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
4244	case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
4245	case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
4246		textureTarget = GL_TEXTURE_CUBE_MAP;
4247		break;
4248	case EGL_GL_RENDERBUFFER_KHR:
4249		break;
4250	default:
4251		return EGL_BAD_PARAMETER;
4252	}
4253
4254	if(textureLevel >= es2::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
4255	{
4256		return EGL_BAD_MATCH;
4257	}
4258
4259	if(textureTarget != GL_NONE)
4260	{
4261		es2::Texture *texture = getTexture(name);
4262
4263		if(!texture || texture->getTarget() != textureTarget)
4264		{
4265			return EGL_BAD_PARAMETER;
4266		}
4267
4268		if(texture->isShared(textureTarget, textureLevel))   // Bound to an EGLSurface or already an EGLImage sibling
4269		{
4270			return EGL_BAD_ACCESS;
4271		}
4272
4273		if(textureLevel != 0 && !texture->isSamplerComplete())
4274		{
4275			return EGL_BAD_PARAMETER;
4276		}
4277
4278		if(textureLevel == 0 && !(texture->isSamplerComplete() && texture->getLevelCount() == 1))
4279		{
4280			return EGL_BAD_PARAMETER;
4281		}
4282	}
4283	else if(target == EGL_GL_RENDERBUFFER_KHR)
4284	{
4285		es2::Renderbuffer *renderbuffer = getRenderbuffer(name);
4286
4287		if(!renderbuffer)
4288		{
4289			return EGL_BAD_PARAMETER;
4290		}
4291
4292		if(renderbuffer->isShared())   // Already an EGLImage sibling
4293		{
4294			return EGL_BAD_ACCESS;
4295		}
4296	}
4297	else UNREACHABLE(target);
4298
4299	return EGL_SUCCESS;
4300}
4301
4302egl::Image *Context::createSharedImage(EGLenum target, GLuint name, GLuint textureLevel)
4303{
4304	GLenum textureTarget = GL_NONE;
4305
4306	switch(target)
4307	{
4308	case EGL_GL_TEXTURE_2D_KHR:                  textureTarget = GL_TEXTURE_2D;                  break;
4309	case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR: textureTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X; break;
4310	case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR: textureTarget = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; break;
4311	case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR: textureTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; break;
4312	case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR: textureTarget = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; break;
4313	case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR: textureTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; break;
4314	case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR: textureTarget = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; break;
4315	}
4316
4317	if(textureTarget != GL_NONE)
4318	{
4319		es2::Texture *texture = getTexture(name);
4320
4321		return texture->createSharedImage(textureTarget, textureLevel);
4322	}
4323	else if(target == EGL_GL_RENDERBUFFER_KHR)
4324	{
4325		es2::Renderbuffer *renderbuffer = getRenderbuffer(name);
4326
4327		return renderbuffer->createSharedImage();
4328	}
4329	else UNREACHABLE(target);
4330
4331	return nullptr;
4332}
4333
4334egl::Image *Context::getSharedImage(GLeglImageOES image)
4335{
4336	return display->getSharedImage(image);
4337}
4338
4339Device *Context::getDevice()
4340{
4341	return device;
4342}
4343
4344const GLubyte *Context::getExtensions(GLuint index, GLuint *numExt) const
4345{
4346	// Keep list sorted in following order:
4347	// OES extensions
4348	// EXT extensions
4349	// Vendor extensions
4350	static const char *es2extensions[] =
4351	{
4352		"GL_OES_compressed_ETC1_RGB8_texture",
4353		"GL_OES_depth24",
4354		"GL_OES_depth32",
4355		"GL_OES_depth_texture",
4356		"GL_OES_depth_texture_cube_map",
4357		"GL_OES_EGL_image",
4358		"GL_OES_EGL_image_external",
4359		"GL_OES_EGL_sync",
4360		"GL_OES_element_index_uint",
4361		"GL_OES_framebuffer_object",
4362		"GL_OES_packed_depth_stencil",
4363		"GL_OES_rgb8_rgba8",
4364		"GL_OES_standard_derivatives",
4365		"GL_OES_texture_float",
4366		"GL_OES_texture_float_linear",
4367		"GL_OES_texture_half_float",
4368		"GL_OES_texture_half_float_linear",
4369		"GL_OES_texture_npot",
4370		"GL_OES_texture_3D",
4371		"GL_OES_vertex_half_float",
4372		"GL_EXT_blend_minmax",
4373		"GL_EXT_color_buffer_half_float",
4374		"GL_EXT_draw_buffers",
4375		"GL_EXT_instanced_arrays",
4376		"GL_EXT_occlusion_query_boolean",
4377		"GL_EXT_read_format_bgra",
4378#if (S3TC_SUPPORT)
4379		"GL_EXT_texture_compression_dxt1",
4380#endif
4381		"GL_EXT_texture_filter_anisotropic",
4382		"GL_EXT_texture_format_BGRA8888",
4383		"GL_EXT_texture_rg",
4384#if (ASTC_SUPPORT)
4385		"GL_KHR_texture_compression_astc_hdr",
4386		"GL_KHR_texture_compression_astc_ldr",
4387#endif
4388		"GL_ANGLE_framebuffer_blit",
4389		"GL_ANGLE_framebuffer_multisample",
4390		"GL_ANGLE_instanced_arrays",
4391#if (S3TC_SUPPORT)
4392		"GL_ANGLE_texture_compression_dxt3",
4393		"GL_ANGLE_texture_compression_dxt5",
4394#endif
4395		"GL_CHROMIUM_texture_filtering_hint",
4396		"GL_NV_fence",
4397		"GL_NV_framebuffer_blit",
4398		"GL_NV_read_depth",
4399	};
4400
4401	// Extensions exclusive to OpenGL ES 3.0 and above.
4402	static const char *es3extensions[] =
4403	{
4404		"GL_EXT_color_buffer_float",
4405	};
4406
4407	GLuint numES2extensions = sizeof(es2extensions) / sizeof(es2extensions[0]);
4408	GLuint numExtensions = numES2extensions;
4409
4410	if(clientVersion >= 3)
4411	{
4412		numExtensions += sizeof(es3extensions) / sizeof(es3extensions[0]);
4413	}
4414
4415	if(numExt)
4416	{
4417		*numExt = numExtensions;
4418
4419		return nullptr;
4420	}
4421
4422	if(index == GL_INVALID_INDEX)
4423	{
4424		static std::string extensionsCat;
4425
4426		if(extensionsCat.empty() && (numExtensions > 0))
4427		{
4428			for(const char *extension : es2extensions)
4429			{
4430				extensionsCat += std::string(extension) + " ";
4431			}
4432
4433			if(clientVersion >= 3)
4434			{
4435				for(const char *extension : es3extensions)
4436				{
4437					extensionsCat += std::string(extension) + " ";
4438				}
4439			}
4440		}
4441
4442		return (const GLubyte*)extensionsCat.c_str();
4443	}
4444
4445	if(index >= numExtensions)
4446	{
4447		return nullptr;
4448	}
4449
4450	if(index < numES2extensions)
4451	{
4452		return (const GLubyte*)es2extensions[index];
4453	}
4454	else
4455	{
4456		return (const GLubyte*)es3extensions[index - numES2extensions];
4457	}
4458}
4459
4460}
4461
4462NO_SANITIZE_FUNCTION egl::Context *es2CreateContext(egl::Display *display, const egl::Context *shareContext, int clientVersion, const egl::Config *config)
4463{
4464	ASSERT(!shareContext || shareContext->getClientVersion() == clientVersion);   // Should be checked by eglCreateContext
4465	return new es2::Context(display, static_cast<const es2::Context*>(shareContext), clientVersion, config);
4466}
4467