blob: 27d5583d9394ffaad6937dcc36e45fcb7c685d72 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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