static unsigned
AutoDetect()
{
#ifndef HAVE_POSIX
// Retrieve the default user language identifier from the OS
LANGID lang_id = GetUserDefaultUILanguage();
LogFormat("Units: GetUserDefaultUILanguage() = 0x%x", (int)lang_id);
if (lang_id == 0)
return 0;
return FindLanguage(lang_id);
#elif defined(ANDROID)
JNIEnv *env = Java::GetEnv();
Java::Class cls(env, "java/util/Locale");
// Call static function Locale.getDefault() that
// returns the user's default Locale object
jmethodID cid = env->GetStaticMethodID(cls, "getDefault",
"()Ljava/util/Locale;");
assert(cid != nullptr);
Java::LocalObject obj(env, env->CallStaticObjectMethod(cls, cid));
if (!obj)
return 0;
// Call function Locale.getLanguage() that
// returns a two-letter language string
jstring language = Java::Object::toString(env, obj);
if (language == nullptr)
return 0;
// Convert the jstring to a char string
const char *language2 = env->GetStringUTFChars(language, nullptr);
if (language2 == nullptr) {
env->DeleteLocalRef(language);
return 0;
}
unsigned id = FindLanguage(language2);
// Clean up the memory
env->ReleaseStringUTFChars(language, language2);
env->DeleteLocalRef(language);
// Return e.g. "de.mo"
return id;
#else
// Metric default on Linux
return 0;
#endif
}
static bool
ReadResourceLanguageFile(const TCHAR *resource)
{
if (!FindLanguage(resource))
/* refuse to load resources which are not in the language table */
return false;
LogFormat(_T("Language: loading resource '%s'"), resource);
// Load resource
ResourceLoader::Data data = ResourceLoader::Load(resource, _T("MO"));
if (data.first == NULL) {
LogFormat(_T("Language: resource '%s' not found"), resource);
return false;
}
// Load MO file from resource
delete mo_loader;
mo_loader = new MOLoader(data.first, data.second);
if (mo_loader->error()) {
LogFormat(_T("Language: could not load resource '%s'"), resource);
delete mo_loader;
mo_loader = NULL;
return false;
}
LogFormat(_T("Loaded translations from resource '%s'"), resource);
mo_file = &mo_loader->get();
return true;
}
// Compile a given string containing GLSL into SPV for use by VK
// Return value of false means an error was encountered.
bool GLSLtoSPV(const VkShaderStageFlagBits shader_type,
const char *pshader,
std::vector<unsigned int> &spirv, std::string *errorMessage) {
glslang::TProgram program;
const char *shaderStrings[1];
TBuiltInResource Resources;
init_resources(Resources);
// Enable SPIR-V and Vulkan rules when parsing GLSL
EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules);
EShLanguage stage = FindLanguage(shader_type);
glslang::TShader shader(stage);
shaderStrings[0] = pshader;
shader.setStrings(shaderStrings, 1);
if (!shader.parse(&Resources, 100, false, messages)) {
puts(shader.getInfoLog());
puts(shader.getInfoDebugLog());
if (errorMessage) {
*errorMessage = shader.getInfoLog();
(*errorMessage) += shader.getInfoDebugLog();
}
return false; // something didn't work
}
// Note that program does not take ownership of &shader, so this is fine.
program.addShader(&shader);
if (!program.link(messages)) {
puts(shader.getInfoLog());
puts(shader.getInfoDebugLog());
if (errorMessage) {
*errorMessage = shader.getInfoLog();
(*errorMessage) += shader.getInfoDebugLog();
}
return false;
}
// Can't fail, parsing worked, "linking" worked.
glslang::GlslangToSpv(*program.getIntermediate(stage), spirv);
return true;
}
//
// 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;
}
//
// Do file IO part of compile and link, handing off the pure
// API/programmatic mode to CompileAndLinkShaderUnits(), which can
// be put in a loop for testing memory footprint and performance.
//
// This is just for linking mode: meaning all the shaders will be put into the
// the same program linked together.
//
// This means there are a limited number of work items (not multi-threading mode)
// and that the point is testing at the linking level. Hence, to enable
// performance and memory testing, the actual compile/link can be put in
// a loop, independent of processing the work items and file IO.
//
void CompileAndLinkShaderFiles()
{
std::vector<ShaderCompUnit> compUnits;
// Transfer all the work items from to a simple list of
// of compilation units. (We don't care about the thread
// work-item distribution properties in this path, which
// is okay due to the limited number of shaders, know since
// they are all getting linked together.)
glslang::TWorkItem* workItem;
while (Worklist.remove(workItem)) {
ShaderCompUnit compUnit(
FindLanguage(workItem->name),
workItem->name,
ReadFileData(workItem->name.c_str())
);
if (! compUnit.text) {
usage();
return;
}
compUnits.push_back(compUnit);
}
// Actual call to programmatic processing of compile and link,
// in a loop for testing memory and performance. This part contains
// all the perf/memory that a programmatic consumer will care about.
for (int i = 0; i < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++i) {
for (int j = 0; j < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++j)
CompileAndLinkShaderUnits(compUnits);
if (Options & EOptionMemoryLeakMode)
glslang::OS_DumpMemoryCounters();
}
for (auto it = compUnits.begin(); it != compUnits.end(); ++it)
FreeFileData(it->text);
}
bool GLSLtoSPV(const VkShaderStageFlagBits shaderType, const char *shaderText,
std::vector<unsigned int> &spirv) {
EShLanguage stage = FindLanguage(shaderType);
glslang::TShader shader(stage);
glslang::TProgram program;
const char *shaderStrings [1];
TBuiltInResource Resources;
init_resources(Resources);
// Enable SPIR-V and Vulkan rules when parsing GLSL
EShMessages messages = (EShMessages) (EShMsgSpvRules | EShMsgVulkanRules);
shaderStrings [0] = shaderText;
shader.setStrings(shaderStrings, 1);
if(!shader.parse(&Resources, 100, false, messages)) {
puts(shader.getInfoLog());
puts(shader.getInfoDebugLog());
return false; // something didn't work
}
program.addShader(&shader);
//
// Program-level processing...
//
if(!program.link(messages)) {
puts(shader.getInfoLog());
puts(shader.getInfoDebugLog());
fflush(stdout);
return false;
}
glslang::GlslangToSpv(*program.getIntermediate(stage), spirv);
return true;
}
//
// Process an optional binding base of the form:
// --argname [stage] base
// Where stage is one of the forms accepted by FindLanguage, and base is an integer
//
void ProcessBindingBase(int& argc, char**& argv, std::array<unsigned int, EShLangCount>& base)
{
if (argc < 2)
usage();
if (!isdigit(argv[1][0])) {
if (argc < 3) // this form needs one more argument
usage();
// Parse form: --argname stage base
const EShLanguage lang = FindLanguage(argv[1], false);
base[lang] = atoi(argv[2]);
argc-= 2;
argv+= 2;
} else {
// Parse form: --argname base
for (int lang=0; lang<EShLangCount; ++lang)
base[lang] = atoi(argv[1]);
argc--;
argv++;
}
}
//
// For linking mode: Will independently parse each item in the worklist, but then put them
// in the same program and link them together.
//
// Uses the new C++ interface instead of the old handle-based interface.
//
void CompileAndLinkShaders()
{
// keep track of what to free
std::list<glslang::TShader*> shaders;
EShMessages messages = EShMsgDefault;
SetMessageOptions(messages);
//
// Per-shader processing...
//
glslang::TProgram& program = *new glslang::TProgram;
glslang::TWorkItem* workItem;
while (Worklist.remove(workItem)) {
EShLanguage stage = FindLanguage(workItem->name);
glslang::TShader* shader = new glslang::TShader(stage);
shaders.push_back(shader);
char** shaderStrings = ReadFileData(workItem->name.c_str());
if (! shaderStrings) {
usage();
delete &program;
return;
}
const int defaultVersion = Options & EOptionDefaultDesktop? 110: 100;
shader->setStrings(shaderStrings, 1);
if (Options & EOptionOutputPreprocessed) {
std::string str;
if (shader->preprocess(&Resources, defaultVersion, ENoProfile, false, false,
messages, &str, glslang::TShader::ForbidInclude())) {
PutsIfNonEmpty(str.c_str());
} else {
CompileFailed = true;
}
StderrIfNonEmpty(shader->getInfoLog());
StderrIfNonEmpty(shader->getInfoDebugLog());
FreeFileData(shaderStrings);
continue;
}
if (! shader->parse(&Resources, defaultVersion, false, messages))
CompileFailed = true;
program.addShader(shader);
if (! (Options & EOptionSuppressInfolog)) {
PutsIfNonEmpty(workItem->name.c_str());
PutsIfNonEmpty(shader->getInfoLog());
PutsIfNonEmpty(shader->getInfoDebugLog());
}
FreeFileData(shaderStrings);
}
//
// Program-level processing...
//
if (! (Options & EOptionOutputPreprocessed) && ! program.link(messages))
LinkFailed = true;
if (! (Options & EOptionSuppressInfolog)) {
PutsIfNonEmpty(program.getInfoLog());
PutsIfNonEmpty(program.getInfoDebugLog());
}
if (Options & EOptionDumpReflection) {
program.buildReflection();
program.dumpReflection();
}
if (Options & EOptionSpv) {
if (CompileFailed || LinkFailed)
printf("SPIR-V is not generated for failed compile or link\n");
else {
for (int stage = 0; stage < EShLangCount; ++stage) {
if (program.getIntermediate((EShLanguage)stage)) {
std::vector<unsigned int> spirv;
glslang::GlslangToSpv(*program.getIntermediate((EShLanguage)stage), spirv);
glslang::OutputSpv(spirv, GetBinaryName((EShLanguage)stage));
if (Options & EOptionHumanReadableSpv) {
spv::Parameterize();
spv::Disassemble(std::cout, spirv);
}
}
}
}
}
// Free everything up, program has to go before the shaders
// because it might have merged stuff from the shaders, and
// the stuff from the shaders has to have its destructors called
// before the pools holding the memory in the shaders is freed.
delete &program;
while (shaders.size() > 0) {
delete shaders.back();
shaders.pop_back();
}
}
//
// For linking mode: Will independently parse each item in the worklist, but then put them
// in the same program and link them together.
//
// Uses the new C++ interface instead of the old handle-based interface.
//
void CompileAndLinkShaders(krafix::Target target, const char* filename, const char* tempdir, const glslang::TShader::Includer& includer)
{
// keep track of what to free
std::list<glslang::TShader*> shaders;
EShMessages messages = EShMsgDefault;
SetMessageOptions(messages);
//
// Per-shader processing...
//
glslang::TProgram& program = *new glslang::TProgram;
glslang::TWorkItem* workItem;
while (Worklist.remove(workItem)) {
EShLanguage stage = FindLanguage(workItem->name);
glslang::TShader* shader = new glslang::TShader(stage);
shaders.push_back(shader);
char** shaderStrings = ReadFileData(workItem->name.c_str());
if (! shaderStrings) {
usage();
delete &program;
return;
}
const int defaultVersion = Options & EOptionDefaultDesktop? 110: 100;
shader->setStrings(shaderStrings, 1);
if (Options & EOptionOutputPreprocessed) {
std::string str;
if (shader->preprocess(&Resources, defaultVersion, ENoProfile, false, false,
messages, &str, includer)) {
PutsIfNonEmpty(str.c_str());
} else {
CompileFailed = true;
}
StderrIfNonEmpty(shader->getInfoLog());
StderrIfNonEmpty(shader->getInfoDebugLog());
FreeFileData(shaderStrings);
continue;
}
if (! shader->parse(&Resources, defaultVersion, ENoProfile, false, false, messages, includer))
CompileFailed = true;
program.addShader(shader);
if (! (Options & EOptionSuppressInfolog)) {
//PutsIfNonEmpty(workItem->name.c_str());
PutsIfNonEmpty(shader->getInfoLog());
PutsIfNonEmpty(shader->getInfoDebugLog());
}
FreeFileData(shaderStrings);
}
//
// Program-level processing...
//
if (! (Options & EOptionOutputPreprocessed) && ! program.link(messages))
LinkFailed = true;
if (! (Options & EOptionSuppressInfolog)) {
PutsIfNonEmpty(program.getInfoLog());
PutsIfNonEmpty(program.getInfoDebugLog());
}
if (Options & EOptionDumpReflection) {
program.buildReflection();
program.dumpReflection();
}
if (Options & EOptionSpv) {
if (CompileFailed || LinkFailed)
printf("SPIRV is not generated for failed compile or link\n");
else {
for (int stage = 0; stage < EShLangCount; ++stage) {
if (program.getIntermediate((EShLanguage)stage)) {
std::vector<unsigned int> spirv;
glslang::GlslangToSpv(*program.getIntermediate((EShLanguage)stage), spirv);
krafix::Translator* translator = NULL;
std::map<std::string, int> attributes;
switch (target.lang) {
case krafix::GLSL:
translator = new krafix::GlslTranslator(spirv, (EShLanguage)stage);
break;
case krafix::HLSL:
translator = new krafix::HlslTranslator(spirv, (EShLanguage)stage);
break;
case krafix::Metal:
translator = new krafix::MetalTranslator(spirv, (EShLanguage)stage);
break;
case krafix::AGAL:
translator = new krafix::AgalTranslator(spirv, (EShLanguage)stage);
break;
case krafix::VarList:
translator = new krafix::VarListTranslator(spirv, (EShLanguage)stage);
break;
}
if (target.lang == krafix::HLSL && target.system != krafix::Unity) {
std::string temp = std::string(tempdir) + "/" + removeExtension(extractFilename(workItem->name)) + ".hlsl";
translator->outputCode(target, temp.c_str(), attributes);
if (target.version == 9) {
compileHLSLToD3D9(temp.c_str(), filename, attributes, (EShLanguage)stage);
}
else {
compileHLSLToD3D11(temp.c_str(), filename, attributes, (EShLanguage)stage);
}
}
else {
translator->outputCode(target, filename, attributes);
}
delete translator;
//glslang::OutputSpv(spirv, GetBinaryName((EShLanguage)stage));
if (Options & EOptionHumanReadableSpv) {
spv::Parameterize();
spv::Disassemble(std::cout, spirv);
}
}
}
}
}
// Free everything up, program has to go before the shaders
// because it might have merged stuff from the shaders, and
// the stuff from the shaders has to have its destructors called
// before the pools holding the memory in the shaders is freed.
delete &program;
while (shaders.size() > 0) {
delete shaders.back();
shaders.pop_back();
}
}
static bool
ReadResourceLanguageFile(const TCHAR *resource)
{
auto language = FindLanguage(resource);
return language != nullptr && ReadBuiltinLanguage(*language);
}
static const BuiltinLanguage *
DetectLanguage()
{
#ifdef ANDROID
JNIEnv *env = Java::GetEnv();
Java::Class cls(env, "java/util/Locale");
// Call static function Locale.getDefault() that
// returns the user's default Locale object
jmethodID cid = env->GetStaticMethodID(cls, "getDefault",
"()Ljava/util/Locale;");
assert(cid != NULL);
jobject _obj = env->CallStaticObjectMethod(cls, cid);
if (_obj == NULL)
return NULL;
Java::LocalObject obj(env, _obj);
// Call function Locale.getLanguage() that
// returns a two-letter language string
cid = env->GetMethodID(cls, "getLanguage", "()Ljava/lang/String;");
assert(cid != NULL);
jstring language = (jstring)env->CallObjectMethod(obj, cid);
if (language == NULL)
return NULL;
// Convert the jstring to a char string
const char *language2 = env->GetStringUTFChars(language, NULL);
if (language2 == NULL) {
env->DeleteLocalRef(language);
return NULL;
}
/* generate the resource name */
const char *language3 = language2;
if (strcmp(language3, "pt") == 0)
/* hack */
language3 = "pt_BR";
// Attach .mo to the language identifier
static char language_buffer[16];
snprintf(language_buffer, sizeof(language_buffer), "%s.mo", language3);
// Clean up the memory
env->ReleaseStringUTFChars(language, language2);
env->DeleteLocalRef(language);
// Return e.g. "de.mo"
return FindLanguage(language_buffer);
#elif defined(WIN32)
#if defined(_WIN32_WCE)
/* the GetUserDefaultUILanguage() prototype is missing on
mingw32ce, we have to look it up dynamically */
DynamicLibrary coreloc_dll(_T("coredll"));
if (!coreloc_dll.IsDefined()) {
LogFormat("Language: coredll.dll not found");
return NULL;
}
typedef LANGID WINAPI (*GetUserDefaultUILanguage_t)();
GetUserDefaultUILanguage_t GetUserDefaultUILanguage =
(GetUserDefaultUILanguage_t)
coreloc_dll.Lookup(_T("GetUserDefaultUILanguage"));
if (GetUserDefaultUILanguage == NULL) {
LogFormat("Language: GetUserDefaultUILanguage() not available");
return NULL;
}
#endif
// Retrieve the default user language identifier from the OS
LANGID lang_id = GetUserDefaultUILanguage();
LogFormat("Language: GetUserDefaultUILanguage()=0x%x", (int)lang_id);
if (lang_id == 0)
return NULL;
// Try to convert the primary language part of the language identifier
// to a MO file name in the language table
return FindLanguage(PRIMARYLANGID(lang_id));
#else
return nullptr;
#endif
}
//
// Compile a given string containing GLSL into SPV for use by VK
// Return value of false means an error was encountered.
//
bool VkTestFramework::GLSLtoSPV(const VkShaderStageFlagBits shader_type, const char *pshader, std::vector<unsigned int> &spirv) {
glslang::TProgram program;
const char *shaderStrings[1];
// TODO: Do we want to load a special config file depending on the
// shader source? Optional name maybe?
// SetConfigFile(fileName);
ProcessConfigFile();
EShMessages messages = EShMsgDefault;
SetMessageOptions(messages);
messages = static_cast<EShMessages>(messages | EShMsgSpvRules | EShMsgVulkanRules);
EShLanguage stage = FindLanguage(shader_type);
glslang::TShader *shader = new glslang::TShader(stage);
shaderStrings[0] = pshader;
shader->setStrings(shaderStrings, 1);
if (!shader->parse(&Resources, (m_compile_options & EOptionDefaultDesktop) ? 110 : 100, false, messages)) {
if (!(m_compile_options & EOptionSuppressInfolog)) {
puts(shader->getInfoLog());
puts(shader->getInfoDebugLog());
}
return false; // something didn't work
}
program.addShader(shader);
//
// Program-level processing...
//
if (!program.link(messages)) {
if (!(m_compile_options & EOptionSuppressInfolog)) {
puts(shader->getInfoLog());
puts(shader->getInfoDebugLog());
}
return false;
}
if (m_compile_options & EOptionDumpReflection) {
program.buildReflection();
program.dumpReflection();
}
glslang::GlslangToSpv(*program.getIntermediate(stage), spirv);
//
// Test the different modes of SPIR-V modification
//
if (this->m_canonicalize_spv) {
spv::spirvbin_t(0).remap(spirv, spv::spirvbin_t::ALL_BUT_STRIP);
}
if (this->m_strip_spv) {
spv::spirvbin_t(0).remap(spirv, spv::spirvbin_t::STRIP);
}
if (this->m_do_everything_spv) {
spv::spirvbin_t(0).remap(spirv, spv::spirvbin_t::DO_EVERYTHING);
}
delete shader;
return true;
}
static unsigned
AutoDetect()
{
#ifndef HAVE_POSIX
#if defined(_WIN32_WCE)
/* the GetUserDefaultUILanguage() prototype is missing on
mingw32ce, we have to look it up dynamically */
DynamicLibrary coreloc_dll(_T("coredll"));
if (!coreloc_dll.IsDefined()) {
LogFormat("Units: coredll.dll not found");
return 0;
}
typedef LANGID WINAPI (*GetUserDefaultUILanguage_t)();
GetUserDefaultUILanguage_t GetUserDefaultUILanguage =
(GetUserDefaultUILanguage_t)
coreloc_dll.Lookup(_T("GetUserDefaultUILanguage"));
if (GetUserDefaultUILanguage == NULL) {
LogFormat("Units: GetUserDefaultUILanguage() not available");
return 0;
}
#endif
// Retrieve the default user language identifier from the OS
LANGID lang_id = GetUserDefaultUILanguage();
LogFormat("Units: GetUserDefaultUILanguage() = 0x%x", (int)lang_id);
if (lang_id == 0)
return 0;
return FindLanguage(lang_id);
#elif defined(ANDROID)
JNIEnv *env = Java::GetEnv();
Java::Class cls(env, "java/util/Locale");
// Call static function Locale.getDefault() that
// returns the user's default Locale object
jmethodID cid = env->GetStaticMethodID(cls, "getDefault",
"()Ljava/util/Locale;");
assert(cid != NULL);
jobject _obj = env->CallStaticObjectMethod(cls, cid);
if (_obj == NULL)
return 0;
Java::LocalObject obj(env, _obj);
// Call function Locale.getLanguage() that
// returns a two-letter language string
cid = env->GetMethodID(cls, "toString", "()Ljava/lang/String;");
assert(cid != NULL);
jstring language = (jstring)env->CallObjectMethod(obj, cid);
if (language == NULL)
return 0;
// Convert the jstring to a char string
const char *language2 = env->GetStringUTFChars(language, NULL);
if (language2 == NULL) {
env->DeleteLocalRef(language);
return 0;
}
unsigned id = FindLanguage(language2);
// Clean up the memory
env->ReleaseStringUTFChars(language, language2);
env->DeleteLocalRef(language);
// Return e.g. "de.mo"
return id;
#else
// Metric default on Linux
return 0;
#endif
}
int C_DECL main(int argc, char* argv[])
{
bool parseFailed = false;
bool translateFailed = false;
int debugOptions = 0;
std::map<EShLanguage, std::string> Entrys;
std::map<EShLanguage, ShHandle> parsers;
std::map<EShLanguage, std::string> parsersIns;
std::map<EShLanguage, std::string> Outs;
char *uOut = 0;
char *shaderHeader = 0;
//ShHandle translator = 0;
//ShHandle uniformMap = 0;
bool bUseUserVaryings = false;
int attribSemanticCount = 0;
EAttribSemantic attribSemanticEnums[EAttrSemCount];
char* attribSemanticNames[EAttrSemCount];
for ( int i = 0; i < EAttrSemCount; i++ )
{
attribSemanticEnums[i] = EAttrSemUnknown;
attribSemanticNames[i] = NULL;
};
Hlsl2Glsl_Initialize();
argc--;
argv++;
for (; argc >= 1; argc--, argv++)
{
if (argv[0][0] == '-' || argv[0][0] == '/')
{
switch (argv[0][1])
{
case 'f': Entrys.insert(std::pair<EShLanguage, std::string>(EShLangFragment, (++argv)[0])); argc--; break;
case 'v': Entrys.insert(std::pair<EShLanguage, std::string>(EShLangVertex, (++argv)[0])); argc--; break;
case 'o':
if (strlen(argv[0]) > 2)
{
switch (argv[0][2])
{
case 'f':
Outs.insert(std::pair<EShLanguage, std::string>(EShLangFragment, (++argv)[0]));
argc--;
break;
case 'v':
Outs.insert(std::pair<EShLanguage, std::string>(EShLangVertex, (++argv)[0]));
argc--;
break;
case 'u':
uOut = (++argv)[0]; argc--;
break;
default:
usage();
return EFailUsage;
break;
}
}
break;
case 'i':
if (strlen(argv[0]) > 2)
{
EShLanguage language = EShLangFragment;
switch (argv[0][2])
{
case 'f':
language = EShLangFragment;
break;
case 'v':
language = EShLangVertex;
break;
default:
usage();
return EFailUsage;
break;
};
ShHandle l_parser = Hlsl2Glsl_ConstructCompiler(language);
if (l_parser == 0)
return EFailParserCreate;
argv++;
argc--;
parsers.insert(std::pair<EShLanguage, ShHandle>(language, l_parser));
parsersIns.insert(std::pair<EShLanguage, std::string>(language, argv[0]));
}
break;
case 'u':
bUseUserVaryings = true;
break;
case 'a':
{
char *configFileName = (++argv)[0];
argc--;
// Load a configuration file specifying user attributes
if ( !LoadUserAttribConfigFile ( configFileName, attribSemanticEnums, attribSemanticNames, &attribSemanticCount ) )
{
printf ( "Error loading attribute configuration file '%s'.\n", configFileName );
return EFailUsage;
}
}
break;
case 'h':
{
char *shaderHeaderName = (++argv)[0];
argc--;
shaderHeader = ReadFileData ( shaderHeaderName );
}
break;
default:
usage();
return EFailUsage;
}
}
else
{
EShLanguage language = FindLanguage(argv[0]);
ShHandle l_parser = Hlsl2Glsl_ConstructCompiler(language);
if (l_parser == 0)
return EFailParserCreate;
parsers.insert(std::pair<EShLanguage, ShHandle>(language, l_parser));
parsersIns.insert(std::pair<EShLanguage, std::string>(language, argv[0]));
}
}
if (parsers.size() == 0)
{
usage();
return EFailUsage;
}
/*
translator = Hlsl2Glsl_ConstructTranslator(debugOptions);
if (translator == 0)
return EFailTranslatorCreate;
*/
if ( bUseUserVaryings )
{
// Set the translator up to use user varyings
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
Hlsl2Glsl_UseUserVaryings (it->second, bUseUserVaryings );
};
};
/*
if ( shaderHeader != NULL )
{
// Set a shader header if requested
Hlsl2Glsl_SetShaderHeader ( translator, true, shaderHeader );
}
*/
if ( attribSemanticCount > 0 )
{
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
// Use user attributes if the user specified user attribute configuration file
if ( !Hlsl2Glsl_SetUserAttributeNames (it->second, attribSemanticEnums, (const char**)&attribSemanticNames[0], attribSemanticCount ) )
{
printf ("ERROR: Setting user attribute names\n");
};
};
};
if (parsers.size() > 0)
{
int l_i = -1;
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
EShLanguage l_language = it->first;
ShHandle l_parser = it->second;
std::string l_parsedfile = parsersIns[l_language];
l_i += 1;
if(ParseFile(l_parsedfile.c_str(), l_parser, debugOptions))
{
if(Entrys.find(l_language) != Entrys.end())
{
std::string l_entrypointname = Entrys[l_language];
//TODO
if (Hlsl2Glsl_Translate(l_parser, l_entrypointname.c_str() , ETargetGLSL_120, 0))
{
if(Outs.find(l_language) != Outs.end())
{
SaveShader(Outs[l_language].c_str(), l_parser, shaderHeader);
};
if (uOut)
SaveUniforms(uOut, l_parser);
}
else
{
translateFailed = true;
};
}
}
else
{
parseFailed = true;
};
InfoLogMsg("BEGIN", "COMPILER", l_i);
puts(Hlsl2Glsl_GetInfoLog(l_parser));
InfoLogMsg("END", "COMPILER", l_i);
};
};
/*
InfoLogMsg("BEGIN", "LINKER", -1);
puts(Hlsl2Glsl_GetInfoLog(translator));
InfoLogMsg("END", "LINKER", -1);
if (!translateFailed )
{
if (fOut)
SaveShader( fOut, translator, EShLangFragment);
if (vOut)
SaveShader( vOut, translator, EShLangVertex);
if (uOut)
SaveUniforms( uOut, translator);
}
*/
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
Hlsl2Glsl_DestructCompiler(it->second);
};
// Hlsl2Glsl_Destruct(translator);
// Hlsl2Glsl_Destruct(uniformMap);
for ( int i = 0; i < EAttrSemCount; i++ )
{
if ( attribSemanticNames[i] != NULL )
{
delete[] attribSemanticNames[i];
attribSemanticNames[i] = NULL;
};
};
if ( shaderHeader )
{
FreeFileData ( shaderHeader );
};
if (parseFailed)
return EFailParse;
if (translateFailed)
return EFailTranslate;
return 0;
}
