framework/opengl/gluES3PlusWrapperContext.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES Utilities
   3  * ------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief OpenGL ES 3plus wrapper context.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "gluES3PlusWrapperContext.hpp"
  25 #include "gluRenderContext.hpp"
  26 #include "gluRenderConfig.hpp"
  27 #include "glwInitFunctions.hpp"
  28 #include "glwFunctionLoader.hpp"
  29 #include "gluContextFactory.hpp"
  30 #include "gluContextInfo.hpp"
  31 #include "gluShaderUtil.hpp"
  32 #include "deThreadLocal.hpp"
  33 #include "deSTLUtil.hpp"
  34 #include "deUniquePtr.hpp"
  35 #include "glwEnums.hpp"
  36
  37 #include <sstream>
  38 #include <vector>
  39 #include <string>
  40 #include <cstring>
  41 #include <algorithm>
  42 #include <map>
  43
  44 namespace glu
  45 {
  46
  47 namespace es3plus
  48 {
  49
  50 using std::vector;
  51 using std::string;
  52
  53 class Context
  54 {
  55 public:
  56                                                                 Context                 (const glu::RenderContext& ctx);
  57                                                                 ~Context                (void);
  58
  59         void                                            addExtension    (const char* name);
  60
  61         const glw::Functions&           gl;                     //!< GL 4.3 core context functions.
  62
  63         // Wrapper state.
  64         string                                          vendor;
  65         string                                          version;
  66         string                                          renderer;
  67         string                                          shadingLanguageVersion;
  68         string                                          extensions;
  69         vector<string>                          extensionList;
  70         bool                                            primitiveRestartEnabled;
  71
  72         deUint32                                        defaultVAO;
  73         bool                                            defaultVAOBound;
  74
  75         const glu::GLSLVersion          nativeGLSLVersion;
  76 };
  77
  78 Context::Context (const glu::RenderContext& ctx)
  79         : gl                                            (ctx.getFunctions())
  80         , vendor                                        ("drawElements")
  81         , version                                       ("OpenGL ES 3.2")
  82         , renderer                                      ((const char*)gl.getString(GL_RENDERER))
  83         , shadingLanguageVersion        ("OpenGL ES GLSL ES 3.2")
  84         , primitiveRestartEnabled       (false)
  85         , defaultVAO                            (0)
  86         , defaultVAOBound                       (false)
  87         , nativeGLSLVersion                     (glu::getContextTypeGLSLVersion(ctx.getType()))
  88 {
  89         const de::UniquePtr<glu::ContextInfo> ctxInfo(glu::ContextInfo::create(ctx));
  90
  91         gl.genVertexArrays(1, &defaultVAO);
  92         if (gl.getError() != GL_NO_ERROR || defaultVAO == 0)
  93                 throw tcu::InternalError("Failed to allocate VAO for emulation");
  94
  95         gl.bindVertexArray(defaultVAO);
  96         if (gl.getError() != GL_NO_ERROR)
  97                 throw tcu::InternalError("Failed to bind default VAO");
  98         defaultVAOBound = true;
  99
 100         gl.enable(GL_PROGRAM_POINT_SIZE);
 101         gl.getError(); // supress potential errors, feature is not critical
 102
 103         gl.enable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
 104         gl.getError(); // suppress
 105
 106         // Extensions
 107         addExtension("GL_OES_texture_stencil8");
 108         addExtension("GL_OES_sample_shading");
 109         addExtension("GL_OES_sample_variables");
 110         addExtension("GL_OES_shader_multisample_interpolation");
 111         addExtension("GL_OES_shader_image_atomic");
 112         addExtension("GL_OES_texture_storage_multisample_2d_array");
 113
 114         // Enable only if base ctx supports these or compatible GL_NV_blend_equation_advanced ext
 115         if (ctxInfo->isExtensionSupported("GL_NV_blend_equation_advanced") ||
 116                 ctxInfo->isExtensionSupported("GL_KHR_blend_equation_advanced"))
 117         {
 118                 addExtension("GL_KHR_blend_equation_advanced");
 119         }
 120         if (ctxInfo->isExtensionSupported("GL_NV_blend_equation_advanced_coherent") ||
 121                 ctxInfo->isExtensionSupported("GL_KHR_blend_equation_advanced_coherent"))
 122         {
 123                 addExtension("GL_KHR_blend_equation_advanced_coherent");
 124         }
 125
 126         addExtension("GL_EXT_shader_io_blocks");
 127         addExtension("GL_EXT_geometry_shader");
 128         addExtension("GL_EXT_geometry_point_size");
 129         addExtension("GL_EXT_tessellation_shader");
 130         addExtension("GL_EXT_tessellation_point_size");
 131         addExtension("GL_EXT_gpu_shader5");
 132         addExtension("GL_KHR_debug");
 133         addExtension("GL_EXT_texture_cube_map_array");
 134         addExtension("GL_EXT_shader_implicit_conversions");
 135         addExtension("GL_EXT_primitive_bounding_box");
 136         addExtension("GL_EXT_texture_sRGB_decode");
 137         addExtension("GL_EXT_texture_border_clamp");
 138         addExtension("GL_EXT_texture_buffer");
 139         addExtension("GL_EXT_draw_buffers_indexed");
 140 }
 141
 142 Context::~Context (void)
 143 {
 144         if (defaultVAO)
 145                 gl.deleteVertexArrays(1, &defaultVAO);
 146 }
 147
 148 void Context::addExtension (const char* name)
 149 {
 150         if (!extensions.empty())
 151                 extensions += " ";
 152         extensions += name;
 153
 154         extensionList.push_back(name);
 155 }
 156
 157 static de::ThreadLocal tls_context;
 158
 159 void setCurrentContext (Context* context)
 160 {
 161         tls_context.set(context);
 162 }
 163
 164 inline Context* getCurrentContext (void)
 165 {
 166         return (Context*)tls_context.get();
 167 }
 168
 169 static GLW_APICALL void GLW_APIENTRY getIntegerv (deUint32 pname, deInt32* params)
 170 {
 171         Context* context = getCurrentContext();
 172
 173         if (context)
 174         {
 175                 if (pname == GL_NUM_EXTENSIONS && params)
 176                         *params = (deInt32)context->extensionList.size();
 177                 else
 178                         context->gl.getIntegerv(pname, params);
 179         }
 180 }
 181
 182 static GLW_APICALL const glw::GLubyte* GLW_APIENTRY getString (deUint32 name)
 183 {
 184         Context* context = getCurrentContext();
 185
 186         if (context)
 187         {
 188                 switch (name)
 189                 {
 190                         case GL_VENDOR:                                         return (const glw::GLubyte*)context->vendor.c_str();
 191                         case GL_VERSION:                                        return (const glw::GLubyte*)context->version.c_str();
 192                         case GL_RENDERER:                                       return (const glw::GLubyte*)context->renderer.c_str();
 193                         case GL_SHADING_LANGUAGE_VERSION:       return (const glw::GLubyte*)context->shadingLanguageVersion.c_str();
 194                         case GL_EXTENSIONS:                                     return (const glw::GLubyte*)context->extensions.c_str();
 195                         default:                                                        return context->gl.getString(name);
 196                 }
 197         }
 198         else
 199                 return DE_NULL;
 200 }
 201
 202 static GLW_APICALL const glw::GLubyte* GLW_APIENTRY getStringi (deUint32 name, deUint32 index)
 203 {
 204         Context* context = getCurrentContext();
 205
 206         if (context)
 207         {
 208                 if (name == GL_EXTENSIONS)
 209                 {
 210                         if ((size_t)index < context->extensionList.size())
 211                                 return (const glw::GLubyte*)context->extensionList[index].c_str();
 212                         else
 213                                 return context->gl.getStringi(name, ~0u);
 214                 }
 215                 else
 216                         return context->gl.getStringi(name, index);
 217         }
 218         else
 219                 return DE_NULL;
 220 }
 221
 222 static GLW_APICALL void GLW_APIENTRY enable (deUint32 cap)
 223 {
 224         Context* context = getCurrentContext();
 225
 226         if (context)
 227         {
 228                 if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX)
 229                 {
 230                         context->primitiveRestartEnabled = true;
 231                         // \todo [2013-09-30 pyry] Call to glPrimitiveRestartIndex() is required prior to all draw calls!
 232                 }
 233                 else
 234                         context->gl.enable(cap);
 235         }
 236 }
 237
 238 static GLW_APICALL void GLW_APIENTRY disable (deUint32 cap)
 239 {
 240         Context* context = getCurrentContext();
 241
 242         if (context)
 243         {
 244                 if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX)
 245                         context->primitiveRestartEnabled = false;
 246                 else
 247                         context->gl.disable(cap);
 248         }
 249 }
 250
 251 static GLW_APICALL void GLW_APIENTRY bindVertexArray (deUint32 array)
 252 {
 253         Context* context = getCurrentContext();
 254
 255         if (context)
 256         {
 257                 context->gl.bindVertexArray(array == 0 ? context->defaultVAO : array);
 258                 context->defaultVAOBound = (array == 0);
 259         }
 260 }
 261
 262 static GLW_APICALL void GLW_APIENTRY hint (deUint32 target, deUint32 mode)
 263 {
 264         Context* context = getCurrentContext();
 265
 266         if (context)
 267         {
 268                 if (target != GL_GENERATE_MIPMAP_HINT)
 269                         context->gl.hint(target, mode);
 270                 // \todo [2013-09-30 pyry] Verify mode.
 271         }
 272 }
 273
 274 static void translateShaderSource (deUint32 shaderType, std::ostream& dst, const std::string& src, const std::vector<std::string>& filteredExtensions, GLSLVersion version)
 275 {
 276         bool                            foundVersion            = false;
 277         std::istringstream      istr                            (src);
 278         std::string                     line;
 279         int                                     srcLineNdx                      = 1;
 280         bool                            preprocessorSection     = true;
 281
 282         while (std::getline(istr, line, '\n'))
 283         {
 284                 if (preprocessorSection && !line.empty() && line[0] != '#')
 285                 {
 286                         preprocessorSection = false;
 287
 288                         // ARB_separate_shader_objects requires gl_PerVertex to be explicitly declared
 289                         if (shaderType == GL_VERTEX_SHADER)
 290                         {
 291                                 dst << "out gl_PerVertex {\n"
 292                                         << "    vec4 gl_Position;\n"
 293                                         << "    float gl_PointSize;\n"
 294                                         << "    float gl_ClipDistance[];\n"
 295                                         << "};\n"
 296                                         << "#line " << (srcLineNdx + 1) << "\n";
 297                         }
 298                         else if (shaderType == GL_TESS_CONTROL_SHADER)
 299                         {
 300                                 dst << "#extension GL_ARB_tessellation_shader : enable\n"
 301                                         << "in gl_PerVertex {\n"
 302                                         << "    highp vec4 gl_Position;\n"
 303                                         << "    highp float gl_PointSize;\n"
 304                                         << "} gl_in[gl_MaxPatchVertices];\n"
 305                                         << "out gl_PerVertex {\n"
 306                                         << "    highp vec4 gl_Position;\n"
 307                                         << "    highp float gl_PointSize;\n"
 308                                         << "} gl_out[];\n"
 309                                         << "#line " << (srcLineNdx + 1) << "\n";
 310                         }
 311                         else if (shaderType == GL_TESS_EVALUATION_SHADER)
 312                         {
 313                                 dst << "#extension GL_ARB_tessellation_shader : enable\n"
 314                                         << "in gl_PerVertex {\n"
 315                                         << "    highp vec4 gl_Position;\n"
 316                                         << "    highp float gl_PointSize;\n"
 317                                         << "} gl_in[gl_MaxPatchVertices];\n"
 318                                         << "out gl_PerVertex {\n"
 319                                         << "    highp vec4 gl_Position;\n"
 320                                         << "    highp float gl_PointSize;\n"
 321                                         << "};\n"
 322                                         << "#line " << (srcLineNdx + 1) << "\n";
 323                         }
 324                         else if (shaderType == GL_GEOMETRY_SHADER)
 325                         {
 326                                 dst << "in gl_PerVertex {\n"
 327                                         << "    highp vec4 gl_Position;\n"
 328                                         << "    highp float gl_PointSize;\n"
 329                                         << "} gl_in[];\n"
 330                                         << "out gl_PerVertex {\n"
 331                                         << "    highp vec4 gl_Position;\n"
 332                                         << "    highp float gl_PointSize;\n"
 333                                         << "};\n"
 334                                         << "#line " << (srcLineNdx + 1) << "\n";
 335                         }
 336
 337                         // GL_EXT_primitive_bounding_box tessellation no-op fallback
 338                         if (shaderType == GL_TESS_CONTROL_SHADER)
 339                         {
 340                                 dst << "#define gl_BoundingBoxEXT _dummy_unused_output_for_primitive_bbox\n"
 341                                         << "patch out vec4 _dummy_unused_output_for_primitive_bbox[2];\n"
 342                                         << "#line " << (srcLineNdx + 1) << "\n";
 343                         }
 344                 }
 345
 346                 if (line == "#version 310 es" || line == "#version 320 es")
 347                 {
 348                         foundVersion = true;
 349                         dst << glu::getGLSLVersionDeclaration(version) << "\n";
 350                 }
 351                 else if (line == "#version 300 es")
 352                 {
 353                         foundVersion = true;
 354                         dst << "#version 330\n";
 355                 }
 356                 else if (line.substr(0, 10) == "precision ")
 357                 {
 358                         const size_t    precPos         = 10;
 359                         const size_t    precEndPos      = line.find(' ', precPos);
 360                         const size_t    endPos          = line.find(';');
 361
 362                         if (precEndPos != std::string::npos && endPos != std::string::npos && endPos > precEndPos+1)
 363                         {
 364                                 const size_t            typePos         = precEndPos+1;
 365                                 const std::string       precision       = line.substr(precPos, precEndPos-precPos);
 366                                 const std::string       type            = line.substr(typePos, endPos-typePos);
 367                                 const bool                      precOk          = precision == "lowp" || precision == "mediump" || precision == "highp";
 368
 369                                 if (precOk &&
 370                                         (type == "image2D" || type == "uimage2D" || type == "iimage2D" ||
 371                                          type == "imageCube" || type == "uimageCube" || type == "iimageCube" ||
 372                                          type == "image3D" || type == "iimage3D" || type == "uimage3D" ||
 373                                          type == "image2DArray" || type == "iimage2DArray" || type == "uimage2DArray" ||
 374                                          type == "imageCubeArray" || type == "iimageCubeArray" || type == "uimageCubeArray"))
 375                                         dst << "// "; // Filter out statement
 376                         }
 377
 378                         dst << line << "\n";
 379                 }
 380                 else if (line.substr(0, 11) == "#extension ")
 381                 {
 382                         const size_t    extNamePos              = 11;
 383                         const size_t    extNameEndPos   = line.find_first_of(" :", extNamePos);
 384                         const size_t    behaviorPos             = line.find_first_not_of(" :", extNameEndPos);
 385
 386                         if (extNameEndPos != std::string::npos && behaviorPos != std::string::npos)
 387                         {
 388                                 const std::string       extName                         = line.substr(extNamePos, extNameEndPos-extNamePos);
 389                                 const std::string       behavior                        = line.substr(behaviorPos);
 390                                 const bool                      filteredExtension       = de::contains(filteredExtensions.begin(), filteredExtensions.end(), extName);
 391                                 const bool                      validBehavior           = behavior == "require" || behavior == "enable" || behavior == "warn" || behavior == "disable";
 392
 393                                 if (filteredExtension && validBehavior)
 394                                         dst << "// "; // Filter out extension
 395                         }
 396                         dst << line << "\n";
 397                 }
 398                 else if (line.substr(0, 21) == "layout(blend_support_")
 399                         dst << "// " << line << "\n";
 400                 else
 401                         dst << line << "\n";
 402
 403                 srcLineNdx += 1;
 404         }
 405
 406         DE_ASSERT(foundVersion);
 407         DE_UNREF(foundVersion);
 408 }
 409
 410 static std::string translateShaderSources (deUint32 shaderType, deInt32 count, const char* const* strings, const int* length, const std::vector<std::string>& filteredExtensions, GLSLVersion version)
 411 {
 412         std::ostringstream      srcIn;
 413         std::ostringstream      srcOut;
 414
 415         for (int ndx = 0; ndx < count; ndx++)
 416         {
 417                 const int len = length && length[ndx] >= 0 ? length[ndx] : (int)strlen(strings[ndx]);
 418                 srcIn << std::string(strings[ndx], strings[ndx] + len);
 419         }
 420
 421         translateShaderSource(shaderType, srcOut, srcIn.str(), filteredExtensions, version);
 422
 423         return srcOut.str();
 424 }
 425
 426 static GLW_APICALL void GLW_APIENTRY shaderSource (deUint32 shader, deInt32 count, const char* const* strings, const int* length)
 427 {
 428         Context* context = getCurrentContext();
 429
 430         if (context)
 431         {
 432                 if (count > 0 && strings)
 433                 {
 434                         deInt32                         shaderType = GL_NONE;
 435                         context->gl.getShaderiv(shader, GL_SHADER_TYPE, &shaderType);
 436                         {
 437                                 const std::string       translatedSrc   = translateShaderSources(shaderType, count, strings, length, context->extensionList, context->nativeGLSLVersion);
 438                                 const char*                     srcPtr                  = translatedSrc.c_str();
 439                                 context->gl.shaderSource(shader, 1, &srcPtr, DE_NULL);
 440                         }
 441                 }
 442                 else
 443                         context->gl.shaderSource(shader, count, strings, length);
 444         }
 445 }
 446
 447 static GLW_APICALL void GLW_APIENTRY bindFramebuffer (deUint32 target, deUint32 framebuffer)
 448 {
 449         Context* context = getCurrentContext();
 450
 451         if (context)
 452         {
 453                 context->gl.bindFramebuffer(target, framebuffer);
 454
 455                 // Emulate ES behavior where sRGB conversion is only controlled by color buffer format.
 456                 if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER)
 457                         ((framebuffer != 0) ? context->gl.enable : context->gl.disable)(GL_FRAMEBUFFER_SRGB);
 458         }
 459 }
 460
 461 static GLW_APICALL void GLW_APIENTRY blendBarrierKHR (void)
 462 {
 463         Context* context = getCurrentContext();
 464
 465         if (context)
 466         {
 467                 // \todo [2014-03-18 pyry] Use BlendBarrierNV() if supported
 468                 context->gl.finish();
 469         }
 470 }
 471
 472 static GLW_APICALL deUint32 GLW_APIENTRY createShaderProgramv (deUint32 type, deInt32 count, const char* const* strings)
 473 {
 474         Context* context = getCurrentContext();
 475
 476         if (context)
 477         {
 478                 if (count > 0 && strings)
 479                 {
 480                         const std::string       translatedSrc   = translateShaderSources(type, count, strings, DE_NULL, context->extensionList, context->nativeGLSLVersion);
 481                         const char*                     srcPtr                  = translatedSrc.c_str();
 482                         return context->gl.createShaderProgramv(type, 1, &srcPtr);
 483                 }
 484                 else
 485                         return context->gl.createShaderProgramv(type, count, strings);
 486         }
 487         return 0;
 488 }
 489
 490 static GLW_APICALL void GLW_APIENTRY dummyPrimitiveBoundingBox (float minX, float minY, float minZ, float minW, float maxX, float maxY, float maxZ, float maxW)
 491 {
 492         // dummy no-op. No-op is a valid implementation. States queries are not emulated.
 493         DE_UNREF(minX);
 494         DE_UNREF(minY);
 495         DE_UNREF(minZ);
 496         DE_UNREF(minW);
 497         DE_UNREF(maxX);
 498         DE_UNREF(maxY);
 499         DE_UNREF(maxZ);
 500         DE_UNREF(maxW);
 501 }
 502
 503 static void initFunctions (glw::Functions* dst, const glw::Functions& src)
 504 {
 505         // Functions directly passed to GL context.
 506 #include "gluES3PlusWrapperFuncs.inl"
 507
 508         // Wrapped functions.
 509         dst->bindVertexArray            = bindVertexArray;
 510         dst->disable                            = disable;
 511         dst->enable                                     = enable;
 512         dst->getIntegerv                        = getIntegerv;
 513         dst->getString                          = getString;
 514         dst->getStringi                         = getStringi;
 515         dst->hint                                       = hint;
 516         dst->shaderSource                       = shaderSource;
 517         dst->createShaderProgramv       = createShaderProgramv;
 518         dst->bindFramebuffer            = bindFramebuffer;
 519
 520         // Extension functions
 521         {
 522                 using std::map;
 523
 524                 class ExtFuncLoader : public glw::FunctionLoader
 525                 {
 526                 public:
 527                         ExtFuncLoader (const map<string, glw::GenericFuncType>& extFuncs)
 528                                 : m_extFuncs(extFuncs)
 529                         {
 530                         }
 531
 532                         glw::GenericFuncType get (const char* name) const
 533                         {
 534                                 map<string, glw::GenericFuncType>::const_iterator pos = m_extFuncs.find(name);
 535                                 return pos != m_extFuncs.end() ? pos->second : DE_NULL;
 536                         }
 537
 538                 private:
 539                         const map<string, glw::GenericFuncType>& m_extFuncs;
 540                 };
 541
 542                 map<string, glw::GenericFuncType>       extFuncMap;
 543                 const ExtFuncLoader                                     extFuncLoader   (extFuncMap);
 544
 545                 // OES_sample_shading
 546                 extFuncMap["glMinSampleShadingOES"]                     = (glw::GenericFuncType)src.minSampleShading;
 547
 548                 // OES_texture_storage_multisample_2d_array
 549                 extFuncMap["glTexStorage3DMultisampleOES"]      = (glw::GenericFuncType)src.texStorage3DMultisample;
 550
 551                 // KHR_blend_equation_advanced
 552                 extFuncMap["glBlendBarrierKHR"]                         = (glw::GenericFuncType)blendBarrierKHR;
 553
 554                 // EXT_tessellation_shader
 555                 extFuncMap["glPatchParameteriEXT"]                      = (glw::GenericFuncType)src.patchParameteri;
 556
 557                 // EXT_geometry_shader
 558                 extFuncMap["glFramebufferTextureEXT"]           = (glw::GenericFuncType)src.framebufferTexture;
 559
 560                 // KHR_debug
 561                 extFuncMap["glDebugMessageControlKHR"]          = (glw::GenericFuncType)src.debugMessageControl;
 562                 extFuncMap["glDebugMessageInsertKHR"]           = (glw::GenericFuncType)src.debugMessageInsert;
 563                 extFuncMap["glDebugMessageCallbackKHR"]         = (glw::GenericFuncType)src.debugMessageCallback;
 564                 extFuncMap["glGetDebugMessageLogKHR"]           = (glw::GenericFuncType)src.getDebugMessageLog;
 565                 extFuncMap["glGetPointervKHR"]                          = (glw::GenericFuncType)src.getPointerv;
 566                 extFuncMap["glPushDebugGroupKHR"]                       = (glw::GenericFuncType)src.pushDebugGroup;
 567                 extFuncMap["glPopDebugGroupKHR"]                        = (glw::GenericFuncType)src.popDebugGroup;
 568                 extFuncMap["glObjectLabelKHR"]                          = (glw::GenericFuncType)src.objectLabel;
 569                 extFuncMap["glGetObjectLabelKHR"]                       = (glw::GenericFuncType)src.getObjectLabel;
 570                 extFuncMap["glObjectPtrLabelKHR"]                       = (glw::GenericFuncType)src.objectPtrLabel;
 571                 extFuncMap["glGetObjectPtrLabelKHR"]            = (glw::GenericFuncType)src.getObjectPtrLabel;
 572
 573                 // GL_EXT_primitive_bounding_box (dummy no-op)
 574                 extFuncMap["glPrimitiveBoundingBoxEXT"]         = (glw::GenericFuncType)dummyPrimitiveBoundingBox;
 575
 576                 // GL_EXT_texture_border_clamp
 577                 extFuncMap["glTexParameterIivEXT"]                      = (glw::GenericFuncType)src.texParameterIiv;
 578                 extFuncMap["glTexParameterIuivEXT"]                     = (glw::GenericFuncType)src.texParameterIuiv;
 579                 extFuncMap["glGetTexParameterIivEXT"]           = (glw::GenericFuncType)src.getTexParameterIiv;
 580                 extFuncMap["glGetTexParameterIuivEXT"]          = (glw::GenericFuncType)src.getTexParameterIuiv;
 581                 extFuncMap["glSamplerParameterIivEXT"]          = (glw::GenericFuncType)src.samplerParameterIiv;
 582                 extFuncMap["glSamplerParameterIuivEXT"]         = (glw::GenericFuncType)src.samplerParameterIuiv;
 583                 extFuncMap["glGetSamplerParameterIivEXT"]       = (glw::GenericFuncType)src.getSamplerParameterIiv;
 584                 extFuncMap["glGetSamplerParameterIuivEXT"]      = (glw::GenericFuncType)src.getSamplerParameterIuiv;
 585
 586                 // GL_EXT_texture_buffer
 587                 extFuncMap["glTexBufferEXT"]                            = (glw::GenericFuncType)src.texBuffer;
 588                 extFuncMap["glTexBufferRangeEXT"]                       = (glw::GenericFuncType)src.texBufferRange;
 589
 590                 // GL_EXT_draw_buffers_indexed
 591                 extFuncMap["glEnableiEXT"]                                      = (glw::GenericFuncType)src.enablei;
 592                 extFuncMap["glDisableiEXT"]                                     = (glw::GenericFuncType)src.disablei;
 593                 extFuncMap["glBlendEquationiEXT"]                       = (glw::GenericFuncType)src.blendEquationi;
 594                 extFuncMap["glBlendEquationSeparateiEXT"]       = (glw::GenericFuncType)src.blendEquationSeparatei;
 595                 extFuncMap["glBlendFunciEXT"]                           = (glw::GenericFuncType)src.blendFunci;
 596                 extFuncMap["glBlendFuncSeparateiEXT"]           = (glw::GenericFuncType)src.blendFuncSeparatei;
 597                 extFuncMap["glColorMaskiEXT"]                           = (glw::GenericFuncType)src.colorMaski;
 598                 extFuncMap["glIsEnablediEXT"]                           = (glw::GenericFuncType)src.isEnabledi;
 599
 600                 {
 601                         int     numExts = 0;
 602                         dst->getIntegerv(GL_NUM_EXTENSIONS, &numExts);
 603
 604                         if (numExts > 0)
 605                         {
 606                                 vector<const char*> extStr(numExts);
 607
 608                                 for (int ndx = 0; ndx < numExts; ndx++)
 609                                         extStr[ndx] = (const char*)dst->getStringi(GL_EXTENSIONS, ndx);
 610
 611                                 glw::initExtensionsES(dst, &extFuncLoader, (int)extStr.size(), &extStr[0]);
 612                         }
 613                 }
 614         }
 615 }
 616
 617 } // es3plus
 618
 619 ES3PlusWrapperContext::ES3PlusWrapperContext (const ContextFactory& factory, const RenderConfig& config, const tcu::CommandLine& cmdLine)
 620         : m_context             (DE_NULL)
 621         , m_wrapperCtx  (DE_NULL)
 622 {
 623         // Flags that are valid for both core & es context. Currently only excludes CONTEXT_FORWARD_COMPATIBLE
 624         const ContextFlags validContextFlags = CONTEXT_ROBUST | CONTEXT_DEBUG;
 625
 626         static const ContextType wrappableNativeTypes[] =
 627         {
 628                 ContextType(ApiType::core(4,4), config.type.getFlags() & validContextFlags),    // !< higher in the list, preferred
 629                 ContextType(ApiType::core(4,3), config.type.getFlags() & validContextFlags),
 630         };
 631
 632         if (config.type.getAPI() != ApiType::es(3,2))
 633                 throw tcu::NotSupportedError("Unsupported context type (ES3.2 wrapper supports only ES3.2)");
 634
 635         // try to create any wrappable context
 636
 637         for (int nativeCtxNdx = 0; nativeCtxNdx < DE_LENGTH_OF_ARRAY(wrappableNativeTypes); ++nativeCtxNdx)
 638         {
 639                 glu::ContextType nativeContext = wrappableNativeTypes[nativeCtxNdx];
 640
 641                 try
 642                 {
 643                         glu::RenderConfig nativeConfig = config;
 644                         nativeConfig.type = nativeContext;
 645
 646                         m_context               = factory.createContext(nativeConfig, cmdLine);
 647                         m_wrapperCtx    = new es3plus::Context(*m_context);
 648
 649                         es3plus::setCurrentContext(m_wrapperCtx);
 650                         es3plus::initFunctions(&m_functions, m_context->getFunctions());
 651                         break;
 652                 }
 653                 catch (...)
 654                 {
 655                         es3plus::setCurrentContext(DE_NULL);
 656
 657                         delete m_wrapperCtx;
 658                         delete m_context;
 659
 660                         m_wrapperCtx = DE_NULL;
 661                         m_context = DE_NULL;
 662
 663                         // throw only if all tries failed (that is, this was the last potential target)
 664                         if (nativeCtxNdx + 1 == DE_LENGTH_OF_ARRAY(wrappableNativeTypes))
 665                                 throw;
 666                         else
 667                                 continue;
 668                 }
 669         }
 670 }
 671
 672 ES3PlusWrapperContext::~ES3PlusWrapperContext (void)
 673 {
 674         delete m_wrapperCtx;
 675         delete m_context;
 676 }
 677
 678 ContextType ES3PlusWrapperContext::getType (void) const
 679 {
 680         return ContextType(ApiType::es(3,2), m_context->getType().getFlags());
 681 }
 682
 683 } // glu