int main(int argc, char** argv)
{
FILE* outputFile;
GLSLShader result;
GLLang language = LANG_DEFAULT;
int returnValue = 0;//EXIT_SUCCESS
Timer_t timer;
int compiledOK = 0;
double crossCompileTime = 0;
double glslCompileTime = 0;
printf("args: bytecode-file [output-file] [language override - es100 es300 120 130 etc.]\n");
if(argc < 2 || !fileExists(argv[1]))
{
printf("Bad args. Supply a valid shader path, optionaly followed by the output path\n");
return 1;//EXIT_FAILURE
}
if(argc > 3)
{
language = LanguageFromString(argv[3]);
}
InitTimer(&timer);
ResetTimer(&timer);
compiledOK = TranslateHLSLFromFile(argv[1], 0, language, NULL, &result);
crossCompileTime = ReadTimer(&timer);
if(compiledOK)
{
printf("cc time: %.2f us\n", crossCompileTime);
if(argc > 2)
{
//Dump to file
outputFile = fopen(argv[2], "w");
fprintf(outputFile, result.sourceCode);
fclose(outputFile);
}
#if defined(VALIDATE_OUTPUT)
compiledOK = TryCompileShader(result.shaderType, (argc > 2) ? argv[2] : "", result.sourceCode, &glslCompileTime);
if(!compiledOK)
{
returnValue = 1;//EXIT_FAILURE
}
else
{
printf("glsl time: %.2f us\n", glslCompileTime);
}
#endif
bcstrfree(result.sourceCode);
}
return returnValue;
}
void ShaderEffect::FromByteFile(std::string& path)
{
GLSLShader result;
int translated = TranslateHLSLFromFile(path.c_str(), mCompileFlags, mRequestedLang, &mDependencies, &result);
ASSERT(translated);
uint_t shader = 0;
#if 0 //Disabled to allow running with only a vertex shader + rasterizer discard.
if(PixelInterpDependency(result.GLSLLanguage))
{
//Must compile pixel shader first!
if(mPixel == InvalidShaderHandle && result.shaderType != GL_FRAGMENT_SHADER)
{
ASSERT(0);
}
}
#endif
switch(result.shaderType)
{
case GL_VERTEX_SHADER:
{
mVertex = glCreateShader(GL_VERTEX_SHADER);
shader = mVertex;
mVSLang = result.GLSLLanguage;
break;
}
case GL_FRAGMENT_SHADER:
{
mPixel = glCreateShader(GL_FRAGMENT_SHADER);
shader = mPixel;
mPSLang = result.GLSLLanguage;
break;
}
case GL_GEOMETRY_SHADER:
{
mGeometry = glCreateShader(GL_GEOMETRY_SHADER);
shader = mGeometry;
mGSLang = result.GLSLLanguage;
break;
}
case GL_TESS_CONTROL_SHADER:
{
mHull = glCreateShader(GL_TESS_CONTROL_SHADER);
shader = mHull;
mHSLang = result.GLSLLanguage;
break;
}
case GL_TESS_EVALUATION_SHADER:
{
mDomain = glCreateShader(GL_TESS_EVALUATION_SHADER);
shader = mDomain;
mDSLang = result.GLSLLanguage;
//Hull shader must be compiled before domain in order
//to ensure correct partitioning and primitive type information
//is OR'ed into mCompileFlags.
ASSERT(mHull != InvalidShaderHandle);
break;
}
default:
{
break;
}
}
CheckStateRequirements(result.shaderType, &result.reflection);
glShaderSource(shader, 1, (const char **)&result.sourceCode, 0);
glCompileShader(shader);
glAttachShader(mProgram, shader);
#ifdef _DEBUG
GLint compiled = GL_FALSE;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if(!compiled)
{
char* log;
GLint length = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
log = new char[length];
glGetShaderInfoLog(shader, length, NULL, log);
ASSERT(0);
delete [] log;
ASSERT(0);
}
#endif
#if 0
//Set the default values for constants.
for(uint32_t i = 0; i < result.reflection.ui32NumConstantBuffers; ++i)
{
ConstantBuffer* cbuf = result.reflection.psConstantBuffers+i;
for(uint32_t k = 0; k < cbuf->ui32NumVars; ++k)
{
uint32_t loc = glGetUniformLocation(mProgram, cbuf->asVars[k].Name);
glUniform1f(loc, *(float*)&cbuf->asVars[k].ui32DefaultValue);
}
}
#endif
FreeGLSLShader(&result);
}
