//
// Read a file's data into a string, and parse it using Hlsl2Glsl_Parse
//
bool ParseFile(const char *fileName, ShHandle parser, int debugOptions)
{
int ret;
char *data = ReadFileData(fileName);
if (!data)
return false;
ret = Hlsl2Glsl_Parse(parser, data, ETargetGLSL_120, debugOptions);
FreeFileData(data);
return ret ? true : false;
}
//============================================================
// <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;
}
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 (TestRun type,
const std::string& inputPath,
const std::string& outputPath,
const char* entryPoint,
ETargetVersion version,
unsigned options,
bool doCheckGLSL)
{
assert(version != ETargetVersionCount);
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 char* sourceStr = input.c_str();
bool res = true;
if (kDumpShaderAST)
options |= ETranslateOpIntermediate;
IncludeContext includeCtx;
includeCtx.currentFolder = inputPath.substr(0, inputPath.rfind('/'));
Hlsl2Glsl_ParseCallbacks includeCB;
includeCB.includeOpenCallback = IncludeOpenCallback;
includeCB.includeCloseCallback = NULL;
includeCB.data = &includeCtx;
int parseOk = Hlsl2Glsl_Parse (parser, sourceStr, version, &includeCB, 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);
int translateOk = Hlsl2Glsl_Translate (parser, entryPoint, version, options);
const char* infoLog = Hlsl2Glsl_GetInfoLog( parser );
if (translateOk)
{
std::string text = GetCompiledShaderText(parser);
for (size_t i = 0, n = text.size(); i != n; ++i)
{
char c = text[i];
if (!isascii(c))
{
printf (" contains non-ascii '%c' (0x%02X)\n", c, c);
res = false;
}
}
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 (kIsVertexShader[type], version, text))
{
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;
}
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;
}
