static std::string GetCompiledShaderText(ShHandle parser)
{
std::string txt = Hlsl2Glsl_GetShader (parser);
int count = Hlsl2Glsl_GetUniformCount (parser);
if (count > 0)
{
const ShUniformInfo* uni = Hlsl2Glsl_GetUniformInfo(parser);
txt += "\n// uniforms:\n";
for (int i = 0; i < count; ++i)
{
char buf[1000];
snprintf(buf,1000,"// %s:%s type %d arrsize %d", uni[i].name, uni[i].semantic?uni[i].semantic:"<none>", uni[i].type, uni[i].arraySize);
txt += buf;
if (uni[i].registerSpec)
{
txt += " register ";
txt += uni[i].registerSpec;
}
txt += "\n";
}
}
return txt;
}
//============================================================
// <T>转换脚本。</T>
//
// @param pOutputScript 输出脚本
// @param pInputScript 输入脚本
// @return 处理结果
//============================================================
TResult FPoRenderShaderTransformer::Convert(MString* pOutputScript, MString* pInputScript){
Hlsl2Glsl_Initialize();
ShHandle parser = Hlsl2Glsl_ConstructCompiler(EShLangVertex);
TInt parseOk = Hlsl2Glsl_Parse(parser, pInputScript->MemoryC(), ETargetGLSL_120, ETranslateOpIntermediate);
TCharC* pInfo = Hlsl2Glsl_GetInfoLog(parser);
if(parseOk){
TInt translateOk = Hlsl2Glsl_Translate(parser, "main", ETargetGLSL_120, ETranslateOpIntermediate);
TCharC* infoLog = Hlsl2Glsl_GetInfoLog( parser );
if(translateOk){
TCharC* pGlslScript = Hlsl2Glsl_GetShader(parser);
pOutputScript->Assign(pGlslScript);
}
}
Hlsl2Glsl_DestructCompiler(parser);
Hlsl2Glsl_Shutdown();
return ESuccess;
}
//
// Save the shader to the file
//
bool SaveShader( const char* fn, ShHandle handle, const char* shaderHeader = NULL)
{
FILE* fp = fopen( fn, "w");
//__asm int 3;
if (!fp)
return false; // failed to open file
const char* text = Hlsl2Glsl_GetShader( handle);
if(shaderHeader)
fprintf( fp, "%s", shaderHeader);
if (text)
fprintf( fp, "%s", text);
fclose(fp);
return !text;
}
static bool TestFileFailure (TestRun type,
const std::string& inputPath,
const std::string& outputPath)
{
std::string input;
if (!ReadStringFromFile (inputPath.c_str(), input))
{
printf (" failed to read input file\n");
return false;
}
ShHandle parser = Hlsl2Glsl_ConstructCompiler (kTypeLangs[type]);
const ETargetVersion version = kTargets1[type];
const char* sourceStr = input.c_str();
bool res = true;
unsigned options = 0;
if (kDumpShaderAST)
options |= ETranslateOpIntermediate;
int parseOk = Hlsl2Glsl_Parse (parser, sourceStr, version, NULL, options);
if (parseOk)
{
int translateOk = Hlsl2Glsl_Translate (parser, "main", version, options);
if (translateOk)
{
printf (" translation was expected to fail\n");
res = false;
}
}
std::string text = Hlsl2Glsl_GetInfoLog( parser );
if (!res)
{
text += "\n// compiled shader:\n";
text += Hlsl2Glsl_GetShader (parser);
}
std::string output;
if (res)
{
ReadStringFromFile (outputPath.c_str(), output);
}
if (!res || (text != output))
{
// write output
FILE* f = fopen (outputPath.c_str(), "wb");
fwrite (text.c_str(), 1, text.size(), f);
fclose (f);
printf (" does not match expected output\n");
res = false;
}
Hlsl2Glsl_DestructCompiler (parser);
return res;
}
static bool TestFile (bool vertex,
const std::string& inputPath,
const std::string& outputPath,
bool usePrecision,
bool doCheckGLSL)
{
std::string input;
if (!ReadStringFromFile (inputPath.c_str(), input))
{
printf (" failed to read input file\n");
return false;
}
ShHandle parser = Hlsl2Glsl_ConstructCompiler (vertex ? EShLangVertex : EShLangFragment);
const char* sourceStr = input.c_str();
bool res = true;
int options = 0;
if (kDumpShaderAST)
options |= ETranslateOpIntermediate;
if (usePrecision)
options |= ETranslateOpUsePrecision;
int parseOk = Hlsl2Glsl_Parse (parser, sourceStr, options);
const char* infoLog = Hlsl2Glsl_GetInfoLog( parser );
if (kDumpShaderAST)
{
// write output
FILE* f = fopen ((outputPath+"-ir.txt").c_str(), "wb");
fwrite (infoLog, 1, strlen(infoLog), f);
fclose (f);
}
if (parseOk)
{
static EAttribSemantic kAttribSemantic[] = {
EAttrSemTangent,
};
static const char* kAttribString[] = {
"TANGENT",
};
Hlsl2Glsl_SetUserAttributeNames (parser, kAttribSemantic, kAttribString, 1);
Hlsl2Glsl_UseUserVaryings (parser, true);
int translateOk = Hlsl2Glsl_Translate (parser, "main", options);
const char* infoLog = Hlsl2Glsl_GetInfoLog( parser );
if (translateOk)
{
std::string text = Hlsl2Glsl_GetShader (parser);
std::string output;
ReadStringFromFile (outputPath.c_str(), output);
if (text != output)
{
// write output
FILE* f = fopen (outputPath.c_str(), "wb");
fwrite (text.c_str(), 1, text.size(), f);
fclose (f);
printf (" does not match expected output\n");
res = false;
}
if (doCheckGLSL && !CheckGLSL (vertex, text.c_str()))
{
res = false;
}
}
else
{
printf (" translate error: %s\n", infoLog);
res = false;
}
}
else
{
printf (" parse error: %s\n", infoLog);
res = false;
}
Hlsl2Glsl_DestructCompiler (parser);
return res;
}
