framework/opengl/gluContextInfo.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 Context Info Class.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "gluContextInfo.hpp"
  25 #include "gluRenderContext.hpp"
  26 #include "gluShaderProgram.hpp"
  27 #include "glwFunctions.hpp"
  28 #include "glwEnums.hpp"
  29
  30 #include <iterator>
  31 #include <algorithm>
  32
  33 using std::vector;
  34 using std::string;
  35 using std::set;
  36
  37 namespace glu
  38 {
  39
  40 class TryCompileProgram
  41 {
  42 public:
  43         // \note Assumes that shader pointer can be stored as is (eg. it is static data)
  44         TryCompileProgram (const char* vertexSource, const char* fragmentSource)
  45                 : m_vertexSource        (vertexSource)
  46                 , m_fragmentSource      (fragmentSource)
  47         {
  48         }
  49
  50         bool operator() (const RenderContext& context) const
  51         {
  52                 ShaderProgram program(context,
  53                         ProgramSources() << VertexSource(m_vertexSource)
  54                                                          << FragmentSource(m_fragmentSource));
  55                 return program.isOk();
  56         }
  57
  58 private:
  59         const char*     m_vertexSource;
  60         const char*     m_fragmentSource;
  61 };
  62
  63 typedef CachedValue<bool, TryCompileProgram> IsProgramSupported;
  64
  65 // ES2-specific context info
  66 class ES2ContextInfo : public ContextInfo
  67 {
  68 public:
  69                                                                                 ES2ContextInfo                                          (const RenderContext& context);
  70                                                                                 ~ES2ContextInfo                                         (void) {}
  71
  72         bool                                                            isVertexUniformLoopSupported            (void) const    { return m_vertexUniformLoopsSupported.getValue(m_context);             }
  73         bool                                                            isVertexDynamicLoopSupported            (void) const    { return m_vertexDynamicLoopsSupported.getValue(m_context);             }
  74         bool                                                            isFragmentHighPrecisionSupported        (void) const    { return m_fragmentHighPrecisionSupported.getValue(m_context);  }
  75         bool                                                            isFragmentUniformLoopSupported          (void) const    { return m_fragmentUniformLoopsSupported.getValue(m_context);   }
  76         bool                                                            isFragmentDynamicLoopSupported          (void) const    { return m_fragmentDynamicLoopsSupported.getValue(m_context);   }
  77
  78 private:
  79         IsProgramSupported                                      m_vertexUniformLoopsSupported;
  80         IsProgramSupported                                      m_vertexDynamicLoopsSupported;
  81
  82         IsProgramSupported                                      m_fragmentHighPrecisionSupported;
  83         IsProgramSupported                                      m_fragmentUniformLoopsSupported;
  84         IsProgramSupported                                      m_fragmentDynamicLoopsSupported;
  85 };
  86
  87 static const char* s_defaultVertexShader =
  88         "attribute highp vec4 a_position;\n"
  89         "void main (void) {\n"
  90         "       gl_Position = a_position;\n"
  91         "}\n";
  92 static const char* s_defaultFragmentShader =
  93         "void main (void) {\n"
  94         "       gl_FragColor = vec4(1.0);\n"
  95         "}\n";
  96
  97 static const char* s_vertexUniformLoopsSupported =
  98         "attribute highp vec4   a_position;\n"
  99         "uniform int                    u_numIters;\n"
 100         "void main (void) {\n"
 101         "       gl_Position = a_position;\n"
 102         "       for (int i = 0; i < u_numIters; i++)\n"
 103         "               gl_Position += vec4(0.1);\n"
 104         "}\n";
 105 static const char* s_vertexDynamicLoopsSupported =
 106         "attribute highp vec4   a_position;\n"
 107         "uniform mediump float  a, b;\n"
 108         "void main (void) {\n"
 109         "       gl_Position = a_position;\n"
 110         "       int numIters = a < b ? int(3.0*b) : int(a_position.x);\n"
 111         "       for (int i = 0; i < numIters; i++)\n"
 112         "               gl_Position += vec4(0.1);\n"
 113         "}\n";
 114
 115 static const char* s_fragmentHighPrecisionSupported =
 116         "varying highp vec4             v_color;\n"
 117         "void main (void) {\n"
 118         "       highp float tmp = v_color.r;\n"
 119         "       gl_FragColor = v_color;\n"
 120         "}\n";
 121 static const char* s_fragmentUniformLoopsSupported =
 122         "varying mediump vec4   v_color;\n"
 123         "uniform int                    u_numIters;\n"
 124         "void main (void) {\n"
 125         "       gl_FragColor = v_color;\n"
 126         "       for (int i = 0; i < u_numIters; i++)\n"
 127         "               gl_FragColor += vec4(0.1);\n"
 128         "}\n";
 129 static const char* s_fragmentDynamicLoopsSupported =
 130         "varying mediump vec4   v_color;\n"
 131         "uniform mediump float  a, b;\n"
 132         "void main (void) {\n"
 133         "       gl_FragColor = v_color;\n"
 134         "       int numIters = a < b ? int(3.0*b) : int(v_color.x);\n"
 135         "       for (int i = 0; i < numIters; i++)\n"
 136         "               gl_FragColor += vec4(0.1);\n"
 137         "}\n";
 138
 139 ES2ContextInfo::ES2ContextInfo (const RenderContext& context)
 140         : glu::ContextInfo                                      (context)
 141         , m_vertexUniformLoopsSupported         (TryCompileProgram(s_vertexUniformLoopsSupported, s_defaultFragmentShader))
 142         , m_vertexDynamicLoopsSupported         (TryCompileProgram(s_vertexDynamicLoopsSupported, s_defaultFragmentShader))
 143         , m_fragmentHighPrecisionSupported      (TryCompileProgram(s_defaultVertexShader, s_fragmentHighPrecisionSupported))
 144         , m_fragmentUniformLoopsSupported       (TryCompileProgram(s_defaultVertexShader, s_fragmentUniformLoopsSupported))
 145         , m_fragmentDynamicLoopsSupported       (TryCompileProgram(s_defaultVertexShader, s_fragmentDynamicLoopsSupported))
 146 {
 147 }
 148
 149 static void split (vector<string>& dst, const string& src)
 150 {
 151         size_t start = 0;
 152         size_t end       = string::npos;
 153
 154         while ((end = src.find(' ', start)) != string::npos)
 155         {
 156                 dst.push_back(src.substr(start, end-start));
 157                 start = end+1;
 158         }
 159
 160         if (start < end)
 161                 dst.push_back(src.substr(start, end-start));
 162 }
 163
 164 set<int> GetCompressedTextureFormats::operator() (const RenderContext& context) const
 165 {
 166         const glw::Functions& gl = context.getFunctions();
 167
 168         int numFormats = 0;
 169         gl.getIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
 170
 171         vector<int> formats(numFormats);
 172         if (numFormats > 0)
 173                 gl.getIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, &formats[0]);
 174
 175         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS) failed");
 176
 177         set<int> formatSet;
 178         std::copy(formats.begin(), formats.end(), std::inserter(formatSet, formatSet.begin()));
 179
 180         return formatSet;
 181 }
 182
 183 // ContextInfo
 184
 185 ContextInfo::ContextInfo (const RenderContext& context)
 186         : m_context(context)
 187 {
 188         const glw::Functions& gl = context.getFunctions();
 189
 190         if (context.getType().getAPI() == ApiType::es(2,0))
 191         {
 192                 const char* result = (const char*)gl.getString(GL_EXTENSIONS);
 193                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetString(GL_EXTENSIONS) failed");
 194
 195                 split(m_extensions, string(result));
 196         }
 197         else
 198         {
 199                 int                             numExtensions   = 0;
 200
 201                 gl.getIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
 202                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_NUM_EXTENSIONS) failed");
 203
 204                 m_extensions.resize(numExtensions);
 205                 for (int ndx = 0; ndx < numExtensions; ndx++)
 206                         m_extensions[ndx] = (const char*)gl.getStringi(GL_EXTENSIONS, ndx);
 207                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetStringi(GL_EXTENSIONS, ndx) failed");
 208         }
 209 }
 210
 211 ContextInfo::~ContextInfo (void)
 212 {
 213 }
 214
 215 int ContextInfo::getInt (int param) const
 216 {
 217         int val = -1;
 218         m_context.getFunctions().getIntegerv(param, &val);
 219         GLU_EXPECT_NO_ERROR(m_context.getFunctions().getError(), "glGetIntegerv() failed");
 220         return val;
 221 }
 222
 223 bool ContextInfo::getBool (int param) const
 224 {
 225         glw::GLboolean val = GL_FALSE;
 226         m_context.getFunctions().getBooleanv(param, &val);
 227         GLU_EXPECT_NO_ERROR(m_context.getFunctions().getError(), "glGetBooleanv() failed");
 228         return val != GL_FALSE;
 229 }
 230
 231 const char* ContextInfo::getString (int param) const
 232 {
 233         const char* str = (const char*)m_context.getFunctions().getString(param);
 234         GLU_EXPECT_NO_ERROR(m_context.getFunctions().getError(), "glGetString() failed");
 235         return str;
 236 }
 237
 238 bool ContextInfo::isCompressedTextureFormatSupported (int format) const
 239 {
 240         const set<int>& formats = m_compressedTextureFormats.getValue(m_context);
 241         return formats.find(format) != formats.end();
 242 }
 243
 244 bool ContextInfo::isExtensionSupported (const char* name) const
 245 {
 246         const std::vector<std::string>& extensions = getExtensions();
 247         return std::find(extensions.begin(), extensions.end(), name) != extensions.end();
 248 }
 249
 250 ContextInfo* ContextInfo::create (const RenderContext& context)
 251 {
 252         // ES2 uses special variant that checks support for various shader features
 253         // by trying to compile shader programs.
 254         if (context.getType().getAPI() == ApiType::es(2,0))
 255                 return new ES2ContextInfo(context);
 256
 257         return new ContextInfo(context);
 258 }
 259
 260 } // glu