blob: 8c7810746e8f2a691208923ef33422fad3d7ab7d [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 OpenGL rendering configuration.
*//*--------------------------------------------------------------------*/
#include "gluRenderConfig.hpp"
#include "tcuCommandLine.hpp"
#include "deString.h"
#include "eglwEnums.hpp"
namespace glu
{
void parseConfigBitsFromName(RenderConfig *config, const char *renderCfgName)
{
const char *cfgName = renderCfgName;
DE_ASSERT(config->redBits == RenderConfig::DONT_CARE && config->greenBits == RenderConfig::DONT_CARE &&
config->blueBits == RenderConfig::DONT_CARE && config->alphaBits == RenderConfig::DONT_CARE &&
config->depthBits == RenderConfig::DONT_CARE && config->stencilBits == RenderConfig::DONT_CARE &&
config->numSamples == RenderConfig::DONT_CARE);
static const struct
{
const char *name;
int redBits;
int greenBits;
int blueBits;
int alphaBits;
} colorCfgs[] = {{"rgb888", 8, 8, 8, 0},
{"rgba8888", 8, 8, 8, 8},
{"rgb565", 5, 6, 5, 0},
{"rgba4444", 4, 4, 4, 4},
{"rgba5551", 5, 5, 5, 1}};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorCfgs); ndx++)
{
if (deStringBeginsWith(cfgName, colorCfgs[ndx].name))
{
config->redBits = colorCfgs[ndx].redBits;
config->greenBits = colorCfgs[ndx].greenBits;
config->blueBits = colorCfgs[ndx].blueBits;
config->alphaBits = colorCfgs[ndx].alphaBits;
cfgName += strlen(colorCfgs[ndx].name);
break;
}
}
static const struct
{
const char *name;
int depthSize;
} depthCfgs[] = {{"d0", 0}, {"d16", 16}, {"d24", 24}, {"d32", 32}};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthCfgs); ndx++)
{
if (deStringBeginsWith(cfgName, depthCfgs[ndx].name))
{
config->depthBits = depthCfgs[ndx].depthSize;
cfgName += strlen(depthCfgs[ndx].name);
break;
}
}
static const struct
{
const char *name;
int stencilSize;
} stencilCfgs[] = {
{"s0", 0},
{"s8", 8},
{"s16", 16},
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilCfgs); ndx++)
{
if (deStringBeginsWith(cfgName, stencilCfgs[ndx].name))
{
config->stencilBits = stencilCfgs[ndx].stencilSize;
cfgName += strlen(stencilCfgs[ndx].name);
break;
}
}
static const struct
{
const char *name;
int numSamples;
} multiSampleCfgs[] = {{"ms0", 0}, {"ms16", 16}, {"ms1", 1}, {"ms2", 2}, {"ms4", 4}, {"ms8", 8}};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(multiSampleCfgs); ndx++)
{
if (deStringBeginsWith(cfgName, multiSampleCfgs[ndx].name))
{
config->numSamples = multiSampleCfgs[ndx].numSamples;
cfgName += strlen(multiSampleCfgs[ndx].name);
break;
}
}
if (cfgName[0] != 0)
throw tcu::InternalError(std::string("Invalid GL configuration: '") + renderCfgName + "'");
}
void parseRenderConfig(RenderConfig *config, const tcu::CommandLine &cmdLine)
{
switch (cmdLine.getSurfaceType())
{
case tcu::SURFACETYPE_WINDOW:
config->surfaceType = RenderConfig::SURFACETYPE_WINDOW;
break;
case tcu::SURFACETYPE_OFFSCREEN_NATIVE:
config->surfaceType = RenderConfig::SURFACETYPE_OFFSCREEN_NATIVE;
break;
case tcu::SURFACETYPE_OFFSCREEN_GENERIC:
config->surfaceType = RenderConfig::SURFACETYPE_OFFSCREEN_GENERIC;
break;
case tcu::SURFACETYPE_FBO:
config->surfaceType = RenderConfig::SURFACETYPE_DONT_CARE;
break;
case tcu::SURFACETYPE_LAST:
config->surfaceType = RenderConfig::SURFACETYPE_DONT_CARE;
break;
default:
throw tcu::InternalError("Unsupported surface type");
}
config->windowVisibility = parseWindowVisibility(cmdLine);
if (cmdLine.getSurfaceWidth() > 0)
config->width = cmdLine.getSurfaceWidth();
if (cmdLine.getSurfaceHeight() > 0)
config->height = cmdLine.getSurfaceHeight();
if (cmdLine.getGLConfigName() != DE_NULL)
parseConfigBitsFromName(config, cmdLine.getGLConfigName());
if (cmdLine.getGLConfigId() >= 0)
config->id = cmdLine.getGLConfigId();
}
RenderConfig::Visibility parseWindowVisibility(const tcu::CommandLine &cmdLine)
{
switch (cmdLine.getVisibility())
{
case tcu::WINDOWVISIBILITY_HIDDEN:
return RenderConfig::VISIBILITY_HIDDEN;
case tcu::WINDOWVISIBILITY_WINDOWED:
return RenderConfig::VISIBILITY_VISIBLE;
case tcu::WINDOWVISIBILITY_FULLSCREEN:
return RenderConfig::VISIBILITY_FULLSCREEN;
default:
throw tcu::InternalError("Unsupported window visibility");
}
}
RenderConfig::ComponentType fromEGLComponentType(int eglComponentType)
{
switch (eglComponentType)
{
case EGL_NONE:
return glu::RenderConfig::COMPONENT_TYPE_DONT_CARE;
case EGL_DONT_CARE:
return glu::RenderConfig::COMPONENT_TYPE_DONT_CARE;
case EGL_COLOR_COMPONENT_TYPE_FIXED_EXT:
return glu::RenderConfig::COMPONENT_TYPE_FIXED;
case EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT:
return glu::RenderConfig::COMPONENT_TYPE_FLOAT;
default:
throw tcu::InternalError("Unsupported color component type");
}
}
int toEGLComponentType(RenderConfig::ComponentType gluComponentType)
{
switch (gluComponentType)
{
case glu::RenderConfig::COMPONENT_TYPE_DONT_CARE:
return EGL_DONT_CARE;
case glu::RenderConfig::COMPONENT_TYPE_FIXED:
return EGL_COLOR_COMPONENT_TYPE_FIXED_EXT;
case glu::RenderConfig::COMPONENT_TYPE_FLOAT:
return EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT;
default:
throw tcu::InternalError("Unsupported color component type");
}
}
} // namespace glu