Compile GLSL to SPIRV

                std::vector<uint32_t> RenderManager::compileShaderStage(ShaderFile& shaderFile, ShaderStage const& stage)
                {
                    std::string filePath = (stage == Vertex ? shaderFile.vertexFilePath.get() : shaderFile.fragmentFilePath.get());
                    std::string fileString = shaderFile.getFileData(stage);
                    const char* file = fileString.c_str();

                    //Setup shader
                    EShLanguage type = EShLangVertex;
                    glslang::TShader shader(type);
                    shader.setStrings(&file, 1);

                    //Set vulkan specific settings
                    int clientInputSemanticsVersion = 450;
                    glslang::EShTargetClientVersion vulkanClientVersion = glslang::EShTargetVulkan_1_0;
                    glslang::EShTargetLanguageVersion targetVersion = glslang::EShTargetSpv_1_0;
                    shader.setEnvInput(glslang::EShSourceGlsl, type, glslang::EShClientVulkan, clientInputSemanticsVersion);
                    shader.setEnvClient(glslang::EShClientVulkan, vulkanClientVersion);
                    shader.setEnvTarget(glslang::EShTargetSpv, targetVersion);

                    TBuiltInResource resources = {};
                    resources.limits.generalVariableIndexing = true;
                    resources.limits.whileLoops = true;

                    auto messages = static_cast<EShMessages>(EShMsgSpvRules | EShMsgVulkanRules);

                    const int defaultVersion = 450;

                    DirStackFileIncluder includer; //Default, no include files supported for now.

                    //Preprocess shader
                    std::string preprocessedGLSL;
                    if (!shader.preprocess(&resources, defaultVersion, EEsProfile, false, false, messages, &preprocessedGLSL, includer))
                    {
                        Misc::Console::warning("GLSL Preprocessing Failed for: " + filePath);
                        Misc::Console::warning(shader.getInfoLog());
                        Misc::Console::warning(shader.getInfoDebugLog());

                        return {};
                    }
                    Misc::Console::write("Successfully preprocessed shader " + filePath);

                    //Parse shader
                    const char* preprocessedStr = preprocessedGLSL.c_str();
                    shader.setStrings(&preprocessedStr, 1);
                    if (!shader.parse(&resources, defaultVersion, EEsProfile, false, false, messages))
                    {
                        Misc::Console::warning("GLSL Parsing Failed for: " + filePath);
                        Misc::Console::warning(shader.getInfoLog());
                        Misc::Console::warning(shader.getInfoDebugLog());

                        return {};
                    }
                    Misc::Console::write("Successfully parsed shader " + filePath);

                    //Link program
                    glslang::TProgram program;
                    program.addShader(&shader);
                    if (!program.link(messages))
                    {
                        Misc::Console::warning("GLSL Linking Failed for: " + filePath);
                        Misc::Console::warning(shader.getInfoLog());
                        Misc::Console::warning(shader.getInfoDebugLog());

                        return {};
                    }
                    Misc::Console::write("Successfully linked shader " + filePath);

                    //Compile into SPIRV
                    std::vector<uint32_t> spirV;
                    spv::SpvBuildLogger logger;
                    glslang::SpvOptions spvOptions;
#ifdef TRISTEON_LOGENABLED
                    spvOptions.validate = true;
                    spvOptions.generateDebugInfo = true;
                    spvOptions.disableOptimizer = true;
                    spvOptions.optimizeSize = false;
#else
                    spvOptions.validate = false;
                    spvOptions.generateDebugInfo = false;
                    spvOptions.disableOptimizer = false;
                    spvOptions.optimizeSize = true;
#endif
                    glslang::GlslangToSpv(*program.getIntermediate(type), spirV, &logger, &spvOptions);

                    Misc::Console::write("Finished compilation of " + filePath + ". Compiler messages: { " + logger.getAllMessages() + " }");
                    return spirV;
                }