framework/opengl/gluRenderContext.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 rendering context.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "gluRenderContext.hpp"
  25 #include "gluDefs.hpp"
  26 #include "gluRenderConfig.hpp"
  27 #include "gluFboRenderContext.hpp"
  28 #include "gluPlatform.hpp"
  29 #include "gluStrUtil.hpp"
  30 #include "glwInitFunctions.hpp"
  31 #include "glwEnums.hpp"
  32 #include "tcuPlatform.hpp"
  33 #include "tcuCommandLine.hpp"
  34 #include "deStringUtil.hpp"
  35 #include "deSTLUtil.hpp"
  36
  37 namespace glu
  38 {
  39
  40 // RenderContext
  41
  42 glw::GenericFuncType RenderContext::getProcAddress (const char*) const
  43 {
  44         return (glw::GenericFuncType)DE_NULL;
  45 }
  46
  47 void RenderContext::makeCurrent (void)
  48 {
  49         TCU_THROW(InternalError, "RenderContext::makeCurrent() is not implemented");
  50 }
  51
  52 // Utilities
  53
  54 inline bool versionGreaterOrEqual (ApiType a, ApiType b)
  55 {
  56         return a.getMajorVersion() > b.getMajorVersion() ||
  57                    (a.getMajorVersion() == b.getMajorVersion() && a.getMinorVersion() >= b.getMinorVersion());
  58 }
  59
  60 bool contextSupports (ContextType ctxType, ApiType requiredApiType)
  61 {
  62         // \todo [2014-10-06 pyry] Check exact forward-compatible restrictions.
  63         const bool forwardCompatible = (ctxType.getFlags() & CONTEXT_FORWARD_COMPATIBLE) != 0;
  64
  65         if (isContextTypeES(ctxType))
  66         {
  67                 DE_ASSERT(!forwardCompatible);
  68                 return requiredApiType.getProfile() == PROFILE_ES &&
  69                            versionGreaterOrEqual(ctxType.getAPI(), requiredApiType);
  70         }
  71         else if (isContextTypeGLCore(ctxType))
  72         {
  73                 if (forwardCompatible)
  74                         return ctxType.getAPI() == requiredApiType;
  75                 else
  76                         return requiredApiType.getProfile() == PROFILE_CORE &&
  77                                    versionGreaterOrEqual(ctxType.getAPI(), requiredApiType);
  78         }
  79         else if (isContextTypeGLCompatibility(ctxType))
  80         {
  81                 DE_ASSERT(!forwardCompatible);
  82                 return (requiredApiType.getProfile() == PROFILE_CORE || requiredApiType.getProfile() == PROFILE_COMPATIBILITY) &&
  83                            versionGreaterOrEqual(ctxType.getAPI(), requiredApiType);
  84         }
  85         else
  86         {
  87                 DE_ASSERT(false);
  88                 return false;
  89         }
  90 }
  91
  92 static ContextFlags parseContextFlags (const std::string& flagsStr)
  93 {
  94         const std::vector<std::string>  flagNames       = de::splitString(flagsStr, ',');
  95         ContextFlags                                    flags           = ContextFlags(0);
  96         static const struct
  97         {
  98                 const char*             name;
  99                 ContextFlags    flag;
 100         } s_flagMap[] =
 101         {
 102                 { "debug",              CONTEXT_DEBUG   },
 103                 { "robust",             CONTEXT_ROBUST  }
 104         };
 105
 106         for (std::vector<std::string>::const_iterator flagIter = flagNames.begin(); flagIter != flagNames.end(); ++flagIter)
 107         {
 108                 int ndx;
 109                 for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_flagMap); ndx++)
 110                 {
 111                         if (*flagIter == s_flagMap[ndx].name)
 112                         {
 113                                 flags = flags | s_flagMap[ndx].flag;
 114                                 break;
 115                         }
 116                 }
 117
 118                 if (ndx == DE_LENGTH_OF_ARRAY(s_flagMap))
 119                 {
 120                         tcu::print("ERROR: Unrecognized GL context flag '%s'\n", flagIter->c_str());
 121                         tcu::print("Supported GL context flags:\n");
 122
 123                         for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_flagMap); ndx++)
 124                                 tcu::print("  %s\n", s_flagMap[ndx].name);
 125
 126                         throw tcu::NotSupportedError((std::string("Unknown GL context flag '") + *flagIter + "'").c_str(), DE_NULL, __FILE__, __LINE__);
 127                 }
 128         }
 129
 130         return flags;
 131 }
 132
 133 RenderContext* createRenderContext (tcu::Platform& platform, const tcu::CommandLine& cmdLine, const RenderConfig& config, const RenderContext* sharedContext)
 134 {
 135         const ContextFactoryRegistry&   registry                = platform.getGLPlatform().getContextFactoryRegistry();
 136         const char*                                             factoryName             = cmdLine.getGLContextType();
 137         const ContextFactory*                   factory                 = DE_NULL;
 138
 139         if (registry.empty())
 140                 throw tcu::NotSupportedError("OpenGL is not supported", DE_NULL, __FILE__, __LINE__);
 141
 142         if (factoryName)
 143         {
 144                 factory = registry.getFactoryByName(factoryName);
 145
 146                 if (!factory)
 147                 {
 148                         tcu::print("ERROR: Unknown or unsupported GL context type '%s'\n", factoryName);
 149                         tcu::print("Supported GL context types:\n");
 150
 151                         for (int factoryNdx = 0; factoryNdx < (int)registry.getFactoryCount(); factoryNdx++)
 152                         {
 153                                 const ContextFactory* curFactory = registry.getFactoryByIndex(factoryNdx);
 154                                 tcu::print("  %s: %s\n", curFactory->getName(), curFactory->getDescription());
 155                         }
 156
 157                         throw tcu::NotSupportedError((std::string("Unknown GL context type '") + factoryName + "'").c_str(), DE_NULL, __FILE__, __LINE__);
 158                 }
 159         }
 160         else
 161                 factory = registry.getDefaultFactory();
 162
 163         if (cmdLine.getSurfaceType() == tcu::SURFACETYPE_FBO)
 164         {
 165                 if (sharedContext)
 166                         TCU_FAIL("Shared context not implemented for  FBO surface type");
 167                 return new FboRenderContext(*factory, config, cmdLine);
 168         }
 169         else
 170                 return factory->createContext(config, cmdLine, sharedContext);
 171 }
 172
 173 RenderContext* createDefaultRenderContext (tcu::Platform& platform, const tcu::CommandLine& cmdLine, ApiType apiType)
 174 {
 175         RenderConfig    config;
 176         ContextFlags    ctxFlags        = ContextFlags(0);
 177
 178         if (cmdLine.getGLContextFlags())
 179                 ctxFlags = parseContextFlags(cmdLine.getGLContextFlags());
 180
 181         config.type = glu::ContextType(apiType, ctxFlags);
 182         parseRenderConfig(&config, cmdLine);
 183
 184         return createRenderContext(platform, cmdLine, config);
 185 }
 186
 187 static std::vector<std::string> getExtensions (const glw::Functions& gl, ApiType apiType)
 188 {
 189         using std::vector;
 190         using std::string;
 191
 192         if (apiType.getProfile() == PROFILE_ES && apiType.getMajorVersion() == 2)
 193         {
 194                 TCU_CHECK(gl.getString);
 195
 196                 const char*     extStr  = (const char*)gl.getString(GL_EXTENSIONS);
 197                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetString(GL_EXTENSIONS)");
 198
 199                 if (extStr)
 200                         return de::splitString(extStr);
 201                 else
 202                         throw tcu::TestError("glGetString(GL_EXTENSIONS) returned null pointer", DE_NULL, __FILE__, __LINE__);
 203         }
 204         else
 205         {
 206                 int                             numExtensions   = 0;
 207                 vector<string>  extensions;
 208
 209                 TCU_CHECK(gl.getIntegerv && gl.getStringi);
 210
 211                 gl.getIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
 212                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_NUM_EXTENSIONS)");
 213
 214                 if (numExtensions > 0)
 215                 {
 216                         extensions.resize(numExtensions);
 217
 218                         for (int ndx = 0; ndx < numExtensions; ndx++)
 219                         {
 220                                 const char* const ext = (const char*)gl.getStringi(GL_EXTENSIONS, ndx);
 221                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetStringi(GL_EXTENSIONS)");
 222
 223                                 if (ext)
 224                                         extensions[ndx] = ext;
 225                                 else
 226                                         throw tcu::TestError("glGetStringi(GL_EXTENSIONS) returned null pointer", DE_NULL, __FILE__, __LINE__);
 227                         }
 228
 229                 }
 230
 231                 return extensions;
 232         }
 233 }
 234
 235 bool hasExtension (const glw::Functions& gl, ApiType apiType, const std::string& extension)
 236 {
 237         std::vector<std::string> extensions(getExtensions(gl, apiType));
 238
 239         return de::contains(extensions.begin(), extensions.end(), extension);
 240 }
 241
 242 void initCoreFunctions (glw::Functions* dst, const glw::FunctionLoader* loader, ApiType apiType)
 243 {
 244         static const struct
 245         {
 246                 ApiType         apiType;
 247                 void            (*initFunc)             (glw::Functions* gl, const glw::FunctionLoader* loader);
 248         } s_initFuncs[] =
 249         {
 250                 { ApiType::es(2,0),             glw::initES20           },
 251                 { ApiType::es(3,0),             glw::initES30           },
 252                 { ApiType::es(3,1),             glw::initES31           },
 253                 { ApiType::es(3,2),             glw::initES32           },
 254                 { ApiType::core(3,0),   glw::initGL30Core       },
 255                 { ApiType::core(3,1),   glw::initGL31Core       },
 256                 { ApiType::core(3,2),   glw::initGL32Core       },
 257                 { ApiType::core(3,3),   glw::initGL33Core       },
 258                 { ApiType::core(4,0),   glw::initGL40Core       },
 259                 { ApiType::core(4,1),   glw::initGL41Core       },
 260                 { ApiType::core(4,2),   glw::initGL42Core       },
 261                 { ApiType::core(4,3),   glw::initGL43Core       },
 262                 { ApiType::core(4,4),   glw::initGL44Core       },
 263                 { ApiType::core(4,5),   glw::initGL45Core       },
 264                 { ApiType::core(4,6),   glw::initGL46Core       },
 265         };
 266
 267         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_initFuncs); ndx++)
 268         {
 269                 if (s_initFuncs[ndx].apiType == apiType)
 270                 {
 271                         s_initFuncs[ndx].initFunc(dst, loader);
 272                         return;
 273                 }
 274         }
 275
 276         throw tcu::InternalError(std::string("Don't know how to load functions for ") + de::toString(apiType));
 277 }
 278
 279 void initExtensionFunctions (glw::Functions* dst, const glw::FunctionLoader* loader, ApiType apiType)
 280 {
 281         std::vector<std::string> extensions = getExtensions(*dst, apiType);
 282
 283         if (!extensions.empty())
 284         {
 285                 std::vector<const char*> extStr(extensions.size());
 286
 287                 for (size_t ndx = 0; ndx < extensions.size(); ndx++)
 288                         extStr[ndx] = extensions[ndx].c_str();
 289
 290                 initExtensionFunctions(dst, loader, apiType, (int)extStr.size(), &extStr[0]);
 291         }
 292 }
 293
 294 void initExtensionFunctions (glw::Functions* dst, const glw::FunctionLoader* loader, ApiType apiType, int numExtensions, const char* const* extensions)
 295 {
 296         if (apiType.getProfile() == PROFILE_ES)
 297                 glw::initExtensionsES(dst, loader, numExtensions, extensions);
 298         else
 299                 glw::initExtensionsGL(dst, loader, numExtensions, extensions);
 300 }
 301
 302 void initFunctions (glw::Functions* dst, const glw::FunctionLoader* loader, ApiType apiType)
 303 {
 304         initCoreFunctions(dst, loader, apiType);
 305         initExtensionFunctions(dst, loader, apiType);
 306 }
 307
 308 const char* getApiTypeDescription (ApiType type)
 309 {
 310         if (type == glu::ApiType::es(2, 0))                     return "OpenGL ES 2";
 311         else if (type == glu::ApiType::es(3, 0))        return "OpenGL ES 3";
 312         else if (type == glu::ApiType::es(3, 1))        return "OpenGL ES 3.1";
 313         else if (type == glu::ApiType::es(3, 2))        return "OpenGL ES 3.2";
 314         else if (type == glu::ApiType::core(3, 0))      return "OpenGL 3.0 core";
 315         else if (type == glu::ApiType::core(3, 1))      return "OpenGL 3.1 core";
 316         else if (type == glu::ApiType::core(3, 2))      return "OpenGL 3.2 core";
 317         else if (type == glu::ApiType::core(3, 3))      return "OpenGL 3.3 core";
 318         else if (type == glu::ApiType::core(4, 0))      return "OpenGL 4.0 core";
 319         else if (type == glu::ApiType::core(4, 1))      return "OpenGL 4.1 core";
 320         else if (type == glu::ApiType::core(4, 2))      return "OpenGL 4.2 core";
 321         else if (type == glu::ApiType::core(4, 3))      return "OpenGL 4.3 core";
 322         else if (type == glu::ApiType::core(4, 4))      return "OpenGL 4.4 core";
 323         else if (type == glu::ApiType::core(4, 5))      return "OpenGL 4.5 core";
 324         else if (type == glu::ApiType::core(4, 6))      return "OpenGL 4.6 core";
 325         else                                                                            return DE_NULL;
 326 }
 327
 328 } // glu