Shader::Shader(ResourceManager *manager, GLuint handle) : mHandle(handle), mResourceManager(manager)
{
mSource = NULL;
mHlsl = NULL;
mInfoLog = NULL;
// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
if (!mFragmentCompiler)
{
int result = ShInitialize();
if (result)
{
TBuiltInResource resources;
ShInitBuiltInResource(&resources);
resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
mFragmentCompiler = ShConstructCompiler(EShLangFragment, EShSpecGLES2, &resources);
mVertexCompiler = ShConstructCompiler(EShLangVertex, EShSpecGLES2, &resources);
}
}
mRefCount = 0;
mDeleteStatus = false;
}
// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
void Shader::initializeCompiler()
{
if (!mFragmentCompiler)
{
int result = ShInitialize();
if (result)
{
ShBuiltInResources resources;
ShInitBuiltInResources(&resources);
Context *context = getContext();
resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
resources.MaxVaryingVectors = context->getMaximumVaryingVectors();
resources.MaxVertexTextureImageUnits = context->getMaximumVertexTextureImageUnits();
resources.MaxCombinedTextureImageUnits = context->getMaximumCombinedTextureImageUnits();
resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
resources.MaxFragmentUniformVectors = context->getMaximumFragmentUniformVectors();
resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
resources.OES_standard_derivatives = 1;
// resources.OES_EGL_image_external = getDisplay()->isD3d9ExDevice() ? 1 : 0; // TODO: commented out until the extension is actually supported.
mFragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_GLES2_SPEC, SH_HLSL_OUTPUT, &resources);
mVertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_GLES2_SPEC, SH_HLSL_OUTPUT, &resources);
}
}
}
Shader::Shader(ResourceManager *manager, GLuint handle) : mHandle(handle), mResourceManager(manager)
{
mSource = NULL;
mHlsl = NULL;
mInfoLog = NULL;
// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
if (!mFragmentCompiler)
{
int result = ShInitialize();
if (result)
{
ShBuiltInResources resources;
ShInitBuiltInResources(&resources);
Context *context = getContext();
resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
resources.MaxVaryingVectors = context->getMaximumVaryingVectors();
resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
resources.MaxFragmentUniformVectors = context->getMaximumFragmentUniformVectors();
resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
resources.OES_standard_derivatives = 1;
mFragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources);
mVertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources);
}
}
mRefCount = 0;
mDeleteStatus = false;
}
bool ANGLEWebKitBridge::validateShaderSource(const char* shaderSource, ANGLEShaderType shaderType, String& translatedShaderSource, String& shaderValidationLog)
{
if (!builtCompilers) {
m_fragmentCompiler = ShConstructCompiler(EShLangFragment, EShSpecWebGL, &m_resources);
m_vertexCompiler = ShConstructCompiler(EShLangVertex, EShSpecWebGL, &m_resources);
builtCompilers = true;
}
ShHandle compiler;
if (shaderType == SHADER_TYPE_VERTEX)
compiler = m_vertexCompiler;
else
compiler = m_fragmentCompiler;
const char* const shaderSourceStrings[] = { shaderSource };
bool validateSuccess = ShCompile(compiler, shaderSourceStrings, 1, EShOptNone, EDebugOpIntermediate);
translatedShaderSource = ShGetObjectCode(compiler);
shaderValidationLog = ShGetInfoLog(compiler);
return validateSuccess;
}
// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
void Shader::initializeCompiler()
{
if (!mFragmentCompiler)
{
int result = ShInitialize();
if (result)
{
ShShaderOutput hlslVersion = (mRenderer->getMajorShaderModel() >= 4) ? SH_HLSL11_OUTPUT : SH_HLSL9_OUTPUT;
ShBuiltInResources resources;
ShInitBuiltInResources(&resources);
resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
resources.MaxVertexUniformVectors = mRenderer->getMaxVertexUniformVectors();
resources.MaxVaryingVectors = mRenderer->getMaxVaryingVectors();
resources.MaxVertexTextureImageUnits = 0;
resources.MaxCombinedTextureImageUnits = mRenderer->getMaxCombinedTextureImageUnits();
resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
resources.MaxFragmentUniformVectors = mRenderer->getMaxFragmentUniformVectors();
resources.MaxDrawBuffers = mRenderer->getMaxRenderTargets();
resources.OES_standard_derivatives = mRenderer->getDerivativeInstructionSupport();
resources.EXT_draw_buffers = mRenderer->getMaxRenderTargets() > 1;
// resources.OES_EGL_image_external = mRenderer->getShareHandleSupport() ? 1 : 0; // TODO: commented out until the extension is actually supported.
resources.FragmentPrecisionHigh = 1; // Shader Model 2+ always supports FP24 (s16e7) which corresponds to highp
resources.EXT_frag_depth = 1; // Shader Model 2+ always supports explicit depth output
mFragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
mVertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
}
}
}
bool ANGLEPlatformBridge::compileShaderSource(const char* shaderSource, ANGLEShaderType shaderType, String& translatedShaderSource, String& shaderValidationLog, Vector<ANGLEShaderSymbol>& symbols, int extraCompileOptions)
{
if (!builtCompilers) {
m_fragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, m_shaderSpec, m_shaderOutput, &m_resources);
m_vertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, m_shaderSpec, m_shaderOutput, &m_resources);
if (!m_fragmentCompiler || !m_vertexCompiler) {
cleanupCompilers();
return false;
}
builtCompilers = true;
}
ShHandle compiler;
if (shaderType == SHADER_TYPE_VERTEX)
compiler = m_vertexCompiler;
else
compiler = m_fragmentCompiler;
const char* const shaderSourceStrings[] = { shaderSource };
#if ANGLE_SH_VERSION >= 111
bool validateSuccess = ShCompile(compiler, shaderSourceStrings, 1, SH_OBJECT_CODE | SH_VARIABLES | extraCompileOptions);
#else
bool validateSuccess = ShCompile(compiler, shaderSourceStrings, 1, SH_OBJECT_CODE | SH_ATTRIBUTES_UNIFORMS | extraCompileOptions);
#endif
if (!validateSuccess) {
int logSize = getValidationResultValue(compiler, SH_INFO_LOG_LENGTH);
if (logSize > 1) {
OwnPtr<char[]> logBuffer = adoptArrayPtr(new char[logSize]);
if (logBuffer) {
ShGetInfoLog(compiler, logBuffer.get());
shaderValidationLog = logBuffer.get();
}
}
return false;
}
int translationLength = getValidationResultValue(compiler, SH_OBJECT_CODE_LENGTH);
if (translationLength > 1) {
OwnPtr<char[]> translationBuffer = adoptArrayPtr(new char[translationLength]);
if (!translationBuffer)
return false;
ShGetObjectCode(compiler, translationBuffer.get());
translatedShaderSource = translationBuffer.get();
}
if (!getSymbolInfo(compiler, SH_ACTIVE_ATTRIBUTES, symbols))
return false;
if (!getSymbolInfo(compiler, SH_ACTIVE_UNIFORMS, symbols))
return false;
return true;
}
bool ANGLEWebKitBridge::validateShaderSource(const char* shaderSource, ANGLEShaderType shaderType, String& translatedShaderSource, String& shaderValidationLog)
{
if (!builtCompilers) {
m_fragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_WEBGL_SPEC, m_shaderOutput, &m_resources);
m_vertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_WEBGL_SPEC, m_shaderOutput, &m_resources);
if (!m_fragmentCompiler || !m_vertexCompiler) {
cleanupCompilers();
return false;
}
builtCompilers = true;
}
ShHandle compiler;
if (shaderType == SHADER_TYPE_VERTEX)
compiler = m_vertexCompiler;
else
compiler = m_fragmentCompiler;
const char* const shaderSourceStrings[] = { shaderSource };
bool validateSuccess = ShCompile(compiler, shaderSourceStrings, 1, SH_OBJECT_CODE);
if (!validateSuccess) {
int logSize = 0;
ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &logSize);
if (logSize > 1) {
OwnArrayPtr<char> logBuffer = adoptArrayPtr(new char[logSize]);
if (logBuffer) {
ShGetInfoLog(compiler, logBuffer.get());
shaderValidationLog = logBuffer.get();
}
}
return false;
}
int translationLength = 0;
ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &translationLength);
if (translationLength > 1) {
OwnArrayPtr<char> translationBuffer = adoptArrayPtr(new char[translationLength]);
if (!translationBuffer)
return false;
ShGetObjectCode(compiler, translationBuffer.get());
translatedShaderSource = translationBuffer.get();
}
return true;
}
ShHandle CompilerD3D::getCompilerHandle(GLenum type)
{
ShHandle *compiler = NULL;
switch (type)
{
case GL_VERTEX_SHADER:
compiler = &mVertexCompiler;
break;
case GL_FRAGMENT_SHADER:
compiler = &mFragmentCompiler;
break;
default:
UNREACHABLE();
return NULL;
}
if (!(*compiler))
{
if (activeCompilerHandles == 0)
{
ShInitialize();
}
*compiler = ShConstructCompiler(type, mSpec, mOutputType, &mResources);
activeCompilerHandles++;
}
return *compiler;
}
void InitializeCompiler()
{
DestroyCompiler();
mCompiler =
ShConstructCompiler(GL_FRAGMENT_SHADER, SH_GLES3_SPEC, SH_GLSL_OUTPUT, &mResources);
ASSERT_TRUE(mCompiler != nullptr) << "Compiler could not be constructed.";
}
void InitializeCompiler()
{
DestroyCompiler();
mCompiler = ShConstructCompiler(GL_FRAGMENT_SHADER, SH_WEBGL_SPEC,
SH_GLSL_COMPATIBILITY_OUTPUT, &mResources);
ASSERT_TRUE(mCompiler != NULL) << "Compiler could not be constructed.";
}
bool ANGLEWebKitBridge::compileShaderSource(const char* shaderSource, ANGLEShaderType shaderType, String& translatedShaderSource, String& shaderValidationLog, Vector<ANGLEShaderSymbol>& symbols, int extraCompileOptions)
{
if (!builtCompilers) {
m_fragmentCompiler = ShConstructCompiler(GL_FRAGMENT_SHADER, m_shaderSpec, m_shaderOutput, &m_resources);
m_vertexCompiler = ShConstructCompiler(GL_VERTEX_SHADER, m_shaderSpec, m_shaderOutput, &m_resources);
if (!m_fragmentCompiler || !m_vertexCompiler) {
cleanupCompilers();
return false;
}
builtCompilers = true;
}
ShHandle compiler;
if (shaderType == SHADER_TYPE_VERTEX)
compiler = m_vertexCompiler;
else
compiler = m_fragmentCompiler;
const char* const shaderSourceStrings[] = { shaderSource };
bool validateSuccess = ShCompile(compiler, shaderSourceStrings, 1, SH_OBJECT_CODE | SH_VARIABLES | extraCompileOptions);
if (!validateSuccess) {
const std::string& log = ShGetInfoLog(compiler);
if (log.length())
shaderValidationLog = log.c_str();
return false;
}
const std::string& objectCode = ShGetObjectCode(compiler);
if (objectCode.length())
translatedShaderSource = objectCode.c_str();
if (!getSymbolInfo(compiler, SHADER_SYMBOL_TYPE_ATTRIBUTE, symbols))
return false;
if (!getSymbolInfo(compiler, SHADER_SYMBOL_TYPE_UNIFORM, symbols))
return false;
if (!getSymbolInfo(compiler, SHADER_SYMBOL_TYPE_VARYING, symbols))
return false;
return true;
}
// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
void ShaderD3D::initializeCompiler()
{
if (!mFragmentCompiler)
{
bool result = ShInitialize();
if (result)
{
ShShaderSpec specVersion = (mRenderer->getCurrentClientVersion() >= 3) ? SH_GLES3_SPEC : SH_GLES2_SPEC;
ShShaderOutput hlslVersion = (mRenderer->getMajorShaderModel() >= 4) ? SH_HLSL11_OUTPUT : SH_HLSL9_OUTPUT;
ShBuiltInResources resources;
ShInitBuiltInResources(&resources);
// TODO(geofflang): use context's caps
const gl::Caps &caps = mRenderer->getRendererCaps();
const gl::Extensions &extensions = mRenderer->getRendererExtensions();
resources.MaxVertexAttribs = caps.maxVertexAttributes;
resources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
resources.MaxVaryingVectors = caps.maxVaryingVectors;
resources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
resources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
resources.MaxTextureImageUnits = caps.maxTextureImageUnits;
resources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
resources.MaxDrawBuffers = caps.maxDrawBuffers;
resources.OES_standard_derivatives = extensions.standardDerivatives;
resources.EXT_draw_buffers = extensions.drawBuffers;
resources.EXT_shader_texture_lod = 1;
// resources.OES_EGL_image_external = mRenderer->getShareHandleSupport() ? 1 : 0; // TODO: commented out until the extension is actually supported.
resources.FragmentPrecisionHigh = 1; // Shader Model 2+ always supports FP24 (s16e7) which corresponds to highp
resources.EXT_frag_depth = 1; // Shader Model 2+ always supports explicit depth output
// GLSL ES 3.0 constants
resources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
resources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
resources.MinProgramTexelOffset = caps.minProgramTexelOffset;
resources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
mFragmentCompiler = ShConstructCompiler(GL_FRAGMENT_SHADER, specVersion, hlslVersion, &resources);
mVertexCompiler = ShConstructCompiler(GL_VERTEX_SHADER, specVersion, hlslVersion, &resources);
}
}
}
/*static*/ ShaderValidator*
ShaderValidator::Create(GLenum shaderType, ShShaderSpec spec,
ShShaderOutput outputLanguage,
const ShBuiltInResources& resources, int compileOptions)
{
ShHandle handle = ShConstructCompiler(shaderType, spec, outputLanguage, &resources);
if (!handle)
return nullptr;
return new ShaderValidator(handle, compileOptions, resources.MaxVaryingVectors);
}
Shader::Shader(GLuint handle) : mHandle(handle)
{
mSource = NULL;
mHlsl = NULL;
mInfoLog = NULL;
// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
if (!mFragmentCompiler)
{
int result = ShInitialize();
if (result)
{
mFragmentCompiler = ShConstructCompiler(EShLangFragment, EDebugOpObjectCode);
mVertexCompiler = ShConstructCompiler(EShLangVertex, EDebugOpObjectCode);
}
}
mAttachCount = 0;
mDeleteStatus = false;
}
//
// Thread entry point, for non-linking asynchronous mode.
//
// Return 0 for failure, 1 for success.
//
unsigned int CompileShaders(void*)
{
glslang::TWorkItem* workItem;
while (Worklist.remove(workItem)) {
ShHandle compiler = ShConstructCompiler(FindLanguage(workItem->name), Options);
if (compiler == 0)
return 0;
CompileFile(workItem->name.c_str(), compiler);
if (! (Options & EOptionSuppressInfolog))
workItem->results = ShGetInfoLog(compiler);
ShDestruct(compiler);
}
return 0;
}
osgToy::GlslLint::Status
osgToy::GlslLint::compile( osg::Shader::Type type, const std::string& sourceText )
{
int options = (_options == VERBOSE) ? EDebugOpIntermediate : 0;
EShLanguage lang = (type == osg::Shader::VERTEX) ? EShLangVertex : EShLangFragment;
_infoLog = "";
ShHandle compiler = ShConstructCompiler( lang, options );
if( !compiler ) return ERR_COMPILER_CTOR;
_compilerList.push_back( compiler );
const char* text = sourceText.c_str();
int success = ShCompile( compiler, &text, 1, EShOptNone, &g_Resources, options );
_infoLog = ShGetInfoLog( compiler );
if( !success ) return ERR_COMPILE;
return SUCCESS;
}
// Test that using invariant varyings doesn't trigger a double delete.
TEST(ShaderVariableTest, InvariantDoubleDeleteBug)
{
ShBuiltInResources resources;
ShInitBuiltInResources(&resources);
ShHandle compiler = ShConstructCompiler(GL_VERTEX_SHADER, SH_GLES2_SPEC,
SH_GLSL_COMPATIBILITY_OUTPUT, &resources);
EXPECT_NE(static_cast<ShHandle>(0), compiler);
const char *program[] =
{
"attribute vec4 position;\n"
"varying float v;\n"
"invariant v;\n"
"void main() {\n"
" v = 1.0;\n"
" gl_Position = position;\n"
"}"
};
EXPECT_TRUE(ShCompile(compiler, program, 1, SH_OBJECT_CODE));
EXPECT_TRUE(ShCompile(compiler, program, 1, SH_OBJECT_CODE));
ShDestruct(compiler);
}
int main(int argc, char *argv[])
{
TFailCode failCode = ESuccess;
int compileOptions = 0;
int numCompiles = 0;
ShHandle vertexCompiler = 0;
ShHandle fragmentCompiler = 0;
ShShaderSpec spec = SH_GLES2_SPEC;
ShShaderOutput output = SH_ESSL_OUTPUT;
ShInitialize();
ShBuiltInResources resources;
GenerateResources(&resources);
argc--;
argv++;
for (; (argc >= 1) && (failCode == ESuccess); argc--, argv++)
{
if (argv[0][0] == '-')
{
switch (argv[0][1])
{
case 'i': compileOptions |= SH_INTERMEDIATE_TREE; break;
case 'o': compileOptions |= SH_OBJECT_CODE; break;
case 'u': compileOptions |= SH_VARIABLES; break;
case 'l': compileOptions |= SH_UNROLL_FOR_LOOP_WITH_INTEGER_INDEX; break;
case 'e': compileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS; break;
case 'd': compileOptions |= SH_DEPENDENCY_GRAPH; break;
case 't': compileOptions |= SH_TIMING_RESTRICTIONS; break;
case 'p': resources.WEBGL_debug_shader_precision = 1; break;
case 's':
if (argv[0][2] == '=')
{
switch (argv[0][3])
{
case 'e':
if (argv[0][4] == '3')
{
spec = SH_GLES3_SPEC;
}
else
{
spec = SH_GLES2_SPEC;
}
break;
case 'w':
if (argv[0][4] == '2')
{
spec = SH_WEBGL2_SPEC;
}
else
{
spec = SH_WEBGL_SPEC;
}
break;
case 'c': spec = SH_CSS_SHADERS_SPEC; break;
default: failCode = EFailUsage;
}
}
else
{
failCode = EFailUsage;
}
break;
case 'b':
if (argv[0][2] == '=')
{
switch (argv[0][3])
{
case 'e': output = SH_ESSL_OUTPUT; break;
case 'g': output = SH_GLSL_OUTPUT; break;
case 'h':
if (argv[0][4] == '1' && argv[0][5] == '1')
{
output = SH_HLSL11_OUTPUT;
}
else
{
output = SH_HLSL9_OUTPUT;
}
break;
default: failCode = EFailUsage;
}
}
else
{
failCode = EFailUsage;
}
break;
case 'x':
if (argv[0][2] == '=')
{
switch (argv[0][3])
{
case 'i': resources.OES_EGL_image_external = 1; break;
case 'd': resources.OES_standard_derivatives = 1; break;
case 'r': resources.ARB_texture_rectangle = 1; break;
case 'l': resources.EXT_shader_texture_lod = 1; break;
case 'f': resources.EXT_shader_framebuffer_fetch = 1; break;
case 'n': resources.NV_shader_framebuffer_fetch = 1; break;
case 'a': resources.ARM_shader_framebuffer_fetch = 1; break;
default: failCode = EFailUsage;
}
}
else
{
failCode = EFailUsage;
}
break;
default: failCode = EFailUsage;
}
}
else
{
ShHandle compiler = 0;
switch (FindShaderType(argv[0]))
{
case GL_VERTEX_SHADER:
if (vertexCompiler == 0)
{
vertexCompiler = ShConstructCompiler(
GL_VERTEX_SHADER, spec, output, &resources);
}
compiler = vertexCompiler;
break;
case GL_FRAGMENT_SHADER:
if (fragmentCompiler == 0)
{
fragmentCompiler = ShConstructCompiler(
GL_FRAGMENT_SHADER, spec, output, &resources);
}
compiler = fragmentCompiler;
break;
default: break;
}
if (compiler)
{
bool compiled = CompileFile(argv[0], compiler, compileOptions);
LogMsg("BEGIN", "COMPILER", numCompiles, "INFO LOG");
std::string log = ShGetInfoLog(compiler);
puts(log.c_str());
LogMsg("END", "COMPILER", numCompiles, "INFO LOG");
printf("\n\n");
if (compiled && (compileOptions & SH_OBJECT_CODE))
{
LogMsg("BEGIN", "COMPILER", numCompiles, "OBJ CODE");
std::string code = ShGetObjectCode(compiler);
puts(code.c_str());
LogMsg("END", "COMPILER", numCompiles, "OBJ CODE");
printf("\n\n");
}
if (compiled && (compileOptions & SH_VARIABLES))
{
LogMsg("BEGIN", "COMPILER", numCompiles, "VARIABLES");
PrintActiveVariables(compiler);
LogMsg("END", "COMPILER", numCompiles, "VARIABLES");
printf("\n\n");
}
if (!compiled)
failCode = EFailCompile;
++numCompiles;
}
else
{
failCode = EFailCompilerCreate;
}
}
}
if ((vertexCompiler == 0) && (fragmentCompiler == 0))
failCode = EFailUsage;
if (failCode == EFailUsage)
usage();
if (vertexCompiler)
ShDestruct(vertexCompiler);
if (fragmentCompiler)
ShDestruct(fragmentCompiler);
ShFinalize();
return failCode;
}
int main(int argc, char* argv[])
{
TFailCode failCode = ESuccess;
int compileOptions = 0;
int numCompiles = 0;
ShHandle vertexCompiler = 0;
ShHandle fragmentCompiler = 0;
char* buffer = 0;
int bufferLen = 0;
int numAttribs = 0, numUniforms = 0;
ShShaderSpec spec = SH_GLES2_SPEC;
ShShaderOutput output = SH_ESSL_OUTPUT;
ShInitialize();
ShBuiltInResources resources;
GenerateResources(&resources);
argc--;
argv++;
for (; (argc >= 1) && (failCode == ESuccess); argc--, argv++) {
if (argv[0][0] == '-') {
switch (argv[0][1]) {
case 'i':
compileOptions |= SH_INTERMEDIATE_TREE;
break;
case 'm':
compileOptions |= SH_MAP_LONG_VARIABLE_NAMES;
break;
case 'o':
compileOptions |= SH_OBJECT_CODE;
break;
case 'u':
compileOptions |= SH_ATTRIBUTES_UNIFORMS;
break;
case 'l':
compileOptions |= SH_UNROLL_FOR_LOOP_WITH_INTEGER_INDEX;
break;
case 'e':
compileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS;
break;
case 'd':
compileOptions |= SH_DEPENDENCY_GRAPH;
break;
case 't':
compileOptions |= SH_TIMING_RESTRICTIONS;
break;
case 's':
if (argv[0][2] == '=') {
switch (argv[0][3]) {
case 'e':
spec = SH_GLES2_SPEC;
break;
case 'w':
spec = SH_WEBGL_SPEC;
break;
case 'c':
spec = SH_CSS_SHADERS_SPEC;
break;
default:
failCode = EFailUsage;
}
} else {
failCode = EFailUsage;
}
break;
case 'b':
if (argv[0][2] == '=') {
switch (argv[0][3]) {
case 'e':
output = SH_ESSL_OUTPUT;
break;
case 'g':
output = SH_GLSL_OUTPUT;
break;
case 'h':
output = SH_HLSL_OUTPUT;
break;
default:
failCode = EFailUsage;
}
} else {
failCode = EFailUsage;
}
break;
case 'x':
if (argv[0][2] == '=') {
switch (argv[0][3]) {
case 'i':
resources.OES_EGL_image_external = 1;
break;
case 'd':
resources.OES_standard_derivatives = 1;
break;
case 'r':
resources.ARB_texture_rectangle = 1;
break;
default:
failCode = EFailUsage;
}
} else {
failCode = EFailUsage;
}
break;
default:
failCode = EFailUsage;
}
} else {
ShHandle compiler = 0;
switch (FindShaderType(argv[0])) {
case SH_VERTEX_SHADER:
if (vertexCompiler == 0)
vertexCompiler = ShConstructCompiler(
SH_VERTEX_SHADER, spec, output, &resources);
compiler = vertexCompiler;
break;
case SH_FRAGMENT_SHADER:
if (fragmentCompiler == 0)
fragmentCompiler = ShConstructCompiler(
SH_FRAGMENT_SHADER, spec, output, &resources);
compiler = fragmentCompiler;
break;
default:
break;
}
if (compiler) {
bool compiled = CompileFile(argv[0], compiler, compileOptions);
LogMsg("BEGIN", "COMPILER", numCompiles, "INFO LOG");
ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &bufferLen);
buffer = (char*) realloc(buffer, bufferLen * sizeof(char));
ShGetInfoLog(compiler, buffer);
puts(buffer);
LogMsg("END", "COMPILER", numCompiles, "INFO LOG");
printf("\n\n");
if (compiled && (compileOptions & SH_OBJECT_CODE)) {
LogMsg("BEGIN", "COMPILER", numCompiles, "OBJ CODE");
ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &bufferLen);
buffer = (char*) realloc(buffer, bufferLen * sizeof(char));
ShGetObjectCode(compiler, buffer);
puts(buffer);
LogMsg("END", "COMPILER", numCompiles, "OBJ CODE");
printf("\n\n");
}
if (compiled && (compileOptions & SH_ATTRIBUTES_UNIFORMS)) {
LogMsg("BEGIN", "COMPILER", numCompiles, "ACTIVE ATTRIBS");
PrintActiveVariables(compiler, SH_ACTIVE_ATTRIBUTES, (compileOptions & SH_MAP_LONG_VARIABLE_NAMES) != 0);
LogMsg("END", "COMPILER", numCompiles, "ACTIVE ATTRIBS");
printf("\n\n");
LogMsg("BEGIN", "COMPILER", numCompiles, "ACTIVE UNIFORMS");
PrintActiveVariables(compiler, SH_ACTIVE_UNIFORMS, (compileOptions & SH_MAP_LONG_VARIABLE_NAMES) != 0);
LogMsg("END", "COMPILER", numCompiles, "ACTIVE UNIFORMS");
printf("\n\n");
}
if (!compiled)
failCode = EFailCompile;
++numCompiles;
} else {
failCode = EFailCompilerCreate;
}
}
}
if ((vertexCompiler == 0) && (fragmentCompiler == 0))
failCode = EFailUsage;
if (failCode == EFailUsage)
usage();
if (vertexCompiler)
ShDestruct(vertexCompiler);
if (fragmentCompiler)
ShDestruct(fragmentCompiler);
if (buffer)
free(buffer);
ShFinalize();
return failCode;
}
