/*-------------------------------------------------------------------------
|
* drawElements Quality Program OpenGL ES Utilities
|
* ------------------------------------------------
|
*
|
* Copyright 2014 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
*//*!
|
* \file
|
* \brief Context Info Class.
|
*//*--------------------------------------------------------------------*/
|
|
#include "gluContextInfo.hpp"
|
#include "gluRenderContext.hpp"
|
#include "gluShaderProgram.hpp"
|
#include "glwFunctions.hpp"
|
#include "glwEnums.hpp"
|
|
#include <iterator>
|
#include <algorithm>
|
|
using std::vector;
|
using std::string;
|
using std::set;
|
|
namespace glu
|
{
|
|
class TryCompileProgram
|
{
|
public:
|
// \note Assumes that shader pointer can be stored as is (eg. it is static data)
|
TryCompileProgram (const char* vertexSource, const char* fragmentSource)
|
: m_vertexSource (vertexSource)
|
, m_fragmentSource (fragmentSource)
|
{
|
}
|
|
bool operator() (const RenderContext& context) const
|
{
|
ShaderProgram program(context,
|
ProgramSources() << VertexSource(m_vertexSource)
|
<< FragmentSource(m_fragmentSource));
|
return program.isOk();
|
}
|
|
private:
|
const char* m_vertexSource;
|
const char* m_fragmentSource;
|
};
|
|
typedef CachedValue<bool, TryCompileProgram> IsProgramSupported;
|
|
// ES2-specific context info
|
class ES2ContextInfo : public ContextInfo
|
{
|
public:
|
ES2ContextInfo (const RenderContext& context);
|
~ES2ContextInfo (void) {}
|
|
bool isVertexUniformLoopSupported (void) const { return m_vertexUniformLoopsSupported.getValue(m_context); }
|
bool isVertexDynamicLoopSupported (void) const { return m_vertexDynamicLoopsSupported.getValue(m_context); }
|
bool isFragmentHighPrecisionSupported (void) const { return m_fragmentHighPrecisionSupported.getValue(m_context); }
|
bool isFragmentUniformLoopSupported (void) const { return m_fragmentUniformLoopsSupported.getValue(m_context); }
|
bool isFragmentDynamicLoopSupported (void) const { return m_fragmentDynamicLoopsSupported.getValue(m_context); }
|
|
private:
|
IsProgramSupported m_vertexUniformLoopsSupported;
|
IsProgramSupported m_vertexDynamicLoopsSupported;
|
|
IsProgramSupported m_fragmentHighPrecisionSupported;
|
IsProgramSupported m_fragmentUniformLoopsSupported;
|
IsProgramSupported m_fragmentDynamicLoopsSupported;
|
};
|
|
static const char* s_defaultVertexShader =
|
"attribute highp vec4 a_position;\n"
|
"void main (void) {\n"
|
" gl_Position = a_position;\n"
|
"}\n";
|
static const char* s_defaultFragmentShader =
|
"void main (void) {\n"
|
" gl_FragColor = vec4(1.0);\n"
|
"}\n";
|
|
static const char* s_vertexUniformLoopsSupported =
|
"attribute highp vec4 a_position;\n"
|
"uniform int u_numIters;\n"
|
"void main (void) {\n"
|
" gl_Position = a_position;\n"
|
" for (int i = 0; i < u_numIters; i++)\n"
|
" gl_Position += vec4(0.1);\n"
|
"}\n";
|
static const char* s_vertexDynamicLoopsSupported =
|
"attribute highp vec4 a_position;\n"
|
"uniform mediump float a, b;\n"
|
"void main (void) {\n"
|
" gl_Position = a_position;\n"
|
" int numIters = a < b ? int(3.0*b) : int(a_position.x);\n"
|
" for (int i = 0; i < numIters; i++)\n"
|
" gl_Position += vec4(0.1);\n"
|
"}\n";
|
|
static const char* s_fragmentHighPrecisionSupported =
|
"varying highp vec4 v_color;\n"
|
"void main (void) {\n"
|
" highp float tmp = v_color.r;\n"
|
" gl_FragColor = v_color;\n"
|
"}\n";
|
static const char* s_fragmentUniformLoopsSupported =
|
"varying mediump vec4 v_color;\n"
|
"uniform int u_numIters;\n"
|
"void main (void) {\n"
|
" gl_FragColor = v_color;\n"
|
" for (int i = 0; i < u_numIters; i++)\n"
|
" gl_FragColor += vec4(0.1);\n"
|
"}\n";
|
static const char* s_fragmentDynamicLoopsSupported =
|
"varying mediump vec4 v_color;\n"
|
"uniform mediump float a, b;\n"
|
"void main (void) {\n"
|
" gl_FragColor = v_color;\n"
|
" int numIters = a < b ? int(3.0*b) : int(v_color.x);\n"
|
" for (int i = 0; i < numIters; i++)\n"
|
" gl_FragColor += vec4(0.1);\n"
|
"}\n";
|
|
ES2ContextInfo::ES2ContextInfo (const RenderContext& context)
|
: glu::ContextInfo (context)
|
, m_vertexUniformLoopsSupported (TryCompileProgram(s_vertexUniformLoopsSupported, s_defaultFragmentShader))
|
, m_vertexDynamicLoopsSupported (TryCompileProgram(s_vertexDynamicLoopsSupported, s_defaultFragmentShader))
|
, m_fragmentHighPrecisionSupported (TryCompileProgram(s_defaultVertexShader, s_fragmentHighPrecisionSupported))
|
, m_fragmentUniformLoopsSupported (TryCompileProgram(s_defaultVertexShader, s_fragmentUniformLoopsSupported))
|
, m_fragmentDynamicLoopsSupported (TryCompileProgram(s_defaultVertexShader, s_fragmentDynamicLoopsSupported))
|
{
|
}
|
|
static void split (vector<string>& dst, const string& src)
|
{
|
size_t start = 0;
|
size_t end = string::npos;
|
|
while ((end = src.find(' ', start)) != string::npos)
|
{
|
dst.push_back(src.substr(start, end-start));
|
start = end+1;
|
}
|
|
if (start < end)
|
dst.push_back(src.substr(start, end-start));
|
}
|
|
set<int> GetCompressedTextureFormats::operator() (const RenderContext& context) const
|
{
|
const glw::Functions& gl = context.getFunctions();
|
|
int numFormats = 0;
|
gl.getIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
|
|
vector<int> formats(numFormats);
|
if (numFormats > 0)
|
gl.getIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, &formats[0]);
|
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS) failed");
|
|
set<int> formatSet;
|
std::copy(formats.begin(), formats.end(), std::inserter(formatSet, formatSet.begin()));
|
|
return formatSet;
|
}
|
|
// ContextInfo
|
|
ContextInfo::ContextInfo (const RenderContext& context)
|
: m_context(context)
|
{
|
const glw::Functions& gl = context.getFunctions();
|
|
if (context.getType().getAPI() == ApiType::es(2,0))
|
{
|
const char* result = (const char*)gl.getString(GL_EXTENSIONS);
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetString(GL_EXTENSIONS) failed");
|
|
split(m_extensions, string(result));
|
}
|
else
|
{
|
int numExtensions = 0;
|
|
gl.getIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_NUM_EXTENSIONS) failed");
|
|
m_extensions.resize(numExtensions);
|
for (int ndx = 0; ndx < numExtensions; ndx++)
|
m_extensions[ndx] = (const char*)gl.getStringi(GL_EXTENSIONS, ndx);
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetStringi(GL_EXTENSIONS, ndx) failed");
|
}
|
}
|
|
ContextInfo::~ContextInfo (void)
|
{
|
}
|
|
int ContextInfo::getInt (int param) const
|
{
|
int val = -1;
|
m_context.getFunctions().getIntegerv(param, &val);
|
GLU_EXPECT_NO_ERROR(m_context.getFunctions().getError(), "glGetIntegerv() failed");
|
return val;
|
}
|
|
bool ContextInfo::getBool (int param) const
|
{
|
glw::GLboolean val = GL_FALSE;
|
m_context.getFunctions().getBooleanv(param, &val);
|
GLU_EXPECT_NO_ERROR(m_context.getFunctions().getError(), "glGetBooleanv() failed");
|
return val != GL_FALSE;
|
}
|
|
const char* ContextInfo::getString (int param) const
|
{
|
const char* str = (const char*)m_context.getFunctions().getString(param);
|
GLU_EXPECT_NO_ERROR(m_context.getFunctions().getError(), "glGetString() failed");
|
return str;
|
}
|
|
bool ContextInfo::isCompressedTextureFormatSupported (int format) const
|
{
|
const set<int>& formats = m_compressedTextureFormats.getValue(m_context);
|
return formats.find(format) != formats.end();
|
}
|
|
bool ContextInfo::isExtensionSupported (const char* name) const
|
{
|
const std::vector<std::string>& extensions = getExtensions();
|
return std::find(extensions.begin(), extensions.end(), name) != extensions.end();
|
}
|
|
ContextInfo* ContextInfo::create (const RenderContext& context)
|
{
|
// ES2 uses special variant that checks support for various shader features
|
// by trying to compile shader programs.
|
if (context.getType().getAPI() == ApiType::es(2,0))
|
return new ES2ContextInfo(context);
|
|
return new ContextInfo(context);
|
}
|
|
} // glu
|
