private static string RunGlslValidator(ShaderCompilerArguments arguments, string stage, string codeFilePath, string args) { ProcessHelper.Run( CommonParameters.GetBinaryPath("glslang", arguments, "glslangValidator.exe"), $"-S {stage} -d {args} {codeFilePath}", out var stdOutput, out var stdError); // First line is always full path of input file - remove that. string RemoveCodeFilePath(string value) { return((value != null && value.StartsWith(codeFilePath)) ? value.Substring(codeFilePath.Length).Trim() : value); } stdOutput = RemoveCodeFilePath(stdOutput); stdError = RemoveCodeFilePath(stdError); if (!string.IsNullOrWhiteSpace(stdError)) { return(stdError); } if (!string.IsNullOrWhiteSpace(stdOutput)) { return(stdOutput); } return(null); }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; var encodeFlags = arguments.GetBoolean("StripDebugInfo") ? 1 : 0; ProcessHelper.Run( CommonParameters.GetBinaryPath("smol-v", arguments, "ShaderPlayground.Shims.Smolv.exe"), $"\"{tempFile.FilePath}\" 0 {encodeFlags} \"{outputPath}\"", out var stdOutput, out var _); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); var hasCompilationError = string.IsNullOrEmpty(stdOutput); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(outputLanguage, binaryOutput) : null, hasCompilationError ? (int?)1 : null, new ShaderCompilerOutput("Stats", null, stdOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; var lang = outputLanguage == LanguageNames.Metal ? 14 // LANG_METAL : 0; // LANG_DEFAULT ProcessHelper.Run( CommonParameters.GetBinaryPath("hlslcc", arguments, "ShaderPlayground.Shims.HLSLcc.exe"), $"\"{tempFile.FilePath}\" {lang} \"{outputPath}\"", out var _, out var _); var textOutput = FileHelper.ReadAllTextIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, textOutput), null, new ShaderCompilerOutput("Output", outputLanguage, textOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("miniz", arguments, "ShaderPlayground.Shims.Miniz.exe"), $"\"{tempFile.FilePath}\" {arguments.GetString("CompressionLevel")} \"{outputPath}\"", out var _, out var _); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, binaryOutput), null, new ShaderCompilerOutput("Output", null, $"Compressed {shaderCode.Binary.Length} bytes into {binaryOutput.Length} bytes"))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var args = "--ispc"; using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-cross-ispc", arguments, "spirv-cross.exe"), $"--ispc-interface-name {arguments.GetString("IspcInterfaceName")} --output \"{outputPath}\" \"{tempFile.FilePath}\" {args}", out var _, out var stdError); var hasCompilationErrors = !string.IsNullOrWhiteSpace(stdError); var textOutput = FileHelper.ReadAllTextIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( !hasCompilationErrors, new ShaderCode(LanguageNames.Ispc, textOutput), hasCompilationErrors ? (int?)1 : null, new ShaderCompilerOutput("Output", LanguageNames.Ispc, textOutput), new ShaderCompilerOutput("Errors", null, hasCompilationErrors ? stdError : "<No compilation errors>"))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var stage = GetStageFlag(arguments.GetString("ShaderStage")); var core = arguments.GetString("Core"); var args = string.Empty; if (shaderCode.Language == LanguageNames.SpirV) { var spirVEntryPoint = arguments.GetString("EntryPoint"); args += "--spirv "; args += $"--spirv_entrypoint_name {spirVEntryPoint}"; } using (var tempFile = TempFile.FromShaderCode(shaderCode)) { ProcessHelper.Run( CommonParameters.GetBinaryPath("mali", arguments, "malisc.exe"), $"{stage} -c {core} {args} {tempFile.FilePath}", out var stdOutput, out var stdError); return(new ShaderCompilerResult( true, null, null, new ShaderCompilerOutput("Output", null, stdOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("yari-v", arguments, "ShaderPlayground.Shims.Yariv.exe"), $"\"{tempFile.FilePath}\" 1 0 \"{outputPath}\"", out var stdOutput, out var _); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); var hasCompilationError = string.IsNullOrEmpty(stdOutput); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(outputLanguage, binaryOutput) : null, hasCompilationError ? (int?)1 : null)); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("zstd", arguments, "zstd.exe"), $"-{arguments.GetString("CompressionLevel")} -v \"{tempFile.FilePath}\" -o \"{outputPath}\"", out var _, out var stdError); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, binaryOutput), null, new ShaderCompilerOutput("Output", null, stdError))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-markv.exe"), $"d --comments --model={arguments.GetString("Model")} -o \"{outputPath}\" \"{tempFile.FilePath}\"", out var stdOutput, out var stdError); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, binaryOutput), null, new ShaderCompilerOutput("Output", outputLanguage, stdError))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var args = string.Empty; switch (shaderCode.Language) { case LanguageNames.Hlsl: args += $" --function {arguments.GetString("EntryPoint")}"; args += $" --profile {arguments.GetString("TargetProfile")}"; args += $" -s hlsl --api {arguments.GetString("Api")}"; break; case LanguageNames.Dxbc: args += " -s dxbc --api dx11"; break; case LanguageNames.Dxil: args += " -s dxbc --api dx12"; break; default: throw new InvalidOperationException(); } using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPrefix = $"{Path.ChangeExtension(tempFile.FilePath, null)}out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("intelshaderanalyzer", arguments, "IntelShaderAnalyzer.exe"), $"{args} \"{tempFile.FilePath}\" --isa \"{outputPrefix}\"", out var stdOutput, out _); var hasCompilationErrors = !string.IsNullOrWhiteSpace(stdOutput); var outputFileNamePrefix = Path.GetFileNameWithoutExtension(outputPrefix); var outputs = new List <ShaderCompilerOutput>(); foreach (var file in Directory.GetFiles(Path.GetDirectoryName(outputPrefix), outputFileNamePrefix + "*.asm")) { outputs.Add(new ShaderCompilerOutput( Path.GetFileNameWithoutExtension(file).Substring(outputFileNamePrefix.Length), null, File.ReadAllText(file))); File.Delete(file); } outputs.Add(new ShaderCompilerOutput("Errors", null, hasCompilationErrors ? stdOutput : "<No compilation errors>")); return(new ShaderCompilerResult( !hasCompilationErrors, null, hasCompilationErrors ? (int?)outputs.Count : null, outputs.ToArray())); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; var compressionLevelArgs = string.Empty; switch (arguments.GetString("CompressionLevel")) { case "0": compressionLevelArgs = "-a0 -d14 -fb32"; break; case "1": compressionLevelArgs = "-a0 -d16 -fb32"; break; case "2": compressionLevelArgs = "-a0 -d18 -fb32"; break; case "3": compressionLevelArgs = "-a0 -d20 -fb32"; break; case "4": compressionLevelArgs = "-a0 -d22 -fb32"; break; case "5": compressionLevelArgs = "-a1 -d24 -fb32"; break; case "6": compressionLevelArgs = "-a1 -d25 -fb32"; break; } ProcessHelper.Run( CommonParameters.GetBinaryPath("lzma", arguments, "lzma.exe"), $"e \"{tempFile.FilePath}\" \"{outputPath}\" {compressionLevelArgs}", out var stdOutput, out var _); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, binaryOutput), null, new ShaderCompilerOutput("Output", null, stdOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var args = $"-entry {arguments.GetString("EntryPoint")}"; args += $" -profile {arguments.GetString("Profile")}"; var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); switch (outputLanguage) { case LanguageNames.Glsl: args += " -target glsl"; break; case LanguageNames.Hlsl: args += " -target hlsl"; break; case LanguageNames.Cuda: args += " -target cuda"; break; case LanguageNames.Cpp: args += " -target cpp"; break; case LanguageNames.Ptx: args += " -target ptx"; break; } using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("slang", arguments, "slangc.exe"), $"\"{tempFile.FilePath}\" -o \"{outputPath}\" {args}", out var _, out var stdError); var hasCompilationErrors = !string.IsNullOrWhiteSpace(stdError); var textOutput = FileHelper.ReadAllTextIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( !hasCompilationErrors, new ShaderCode(outputLanguage, textOutput), hasCompilationErrors ? (int?)1 : null, new ShaderCompilerOutput("Output", outputLanguage, textOutput), new ShaderCompilerOutput("Errors", null, hasCompilationErrors ? stdError : "<No compilation errors>"))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var entryPoint = arguments.GetString("EntryPoint"); var targetProfile = arguments.GetString("TargetProfile"); var disableOptimizations = arguments.GetBoolean("DisableOptimizations"); var optimizationLevel = Convert.ToInt32(arguments.GetString("OptimizationLevel")); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var fcPath = $"{tempFile.FilePath}.fc"; var fePath = $"{tempFile.FilePath}.fe"; var foPath = $"{tempFile.FilePath}.fo"; var args = $"--target {targetProfile} --entrypoint {entryPoint} --optimizationlevel {optimizationLevel}"; args += $" --assemblyfile \"{fcPath}\" --errorsfile \"{fePath}\" --objectfile \"{foPath}\""; if (disableOptimizations) { args += " --disableoptimizations"; } var fxcShimPath = CommonParameters.GetBinaryPath("fxc", arguments, "ShaderPlayground.Shims.Fxc.dll"); ProcessHelper.Run( "dotnet.exe", $"\"{fxcShimPath}\" {args} \"{tempFile.FilePath}\"", out var _, out var _); int?selectedOutputIndex = null; var disassembly = FileHelper.ReadAllTextIfExists(fcPath); if (string.IsNullOrWhiteSpace(disassembly)) { disassembly = "<Compilation error occurred>"; selectedOutputIndex = 1; } var binaryOutput = FileHelper.ReadAllBytesIfExists(foPath); var buildOutput = FileHelper.ReadAllTextIfExists(fePath); FileHelper.DeleteIfExists(fcPath); FileHelper.DeleteIfExists(fePath); FileHelper.DeleteIfExists(foPath); return(new ShaderCompilerResult( selectedOutputIndex == null, new ShaderCode(LanguageNames.Dxbc, binaryOutput), selectedOutputIndex, new ShaderCompilerOutput("Disassembly", LanguageNames.Dxbc, disassembly), new ShaderCompilerOutput("Build output", null, buildOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; var errorPath = $"{tempFile.FilePath}.error"; string outputArg; switch (outputLanguage) { case LanguageNames.Glsl: outputArg = "e"; break; case LanguageNames.Hlsl: outputArg = "h11"; break; default: throw new ArgumentOutOfRangeException(); } string RunCompiler(string arg) { ProcessHelper.Run( CommonParameters.GetBinaryPath("angle", arguments, "shader_translator.exe"), $"{arg} -b={outputArg} \"{tempFile.FilePath}\"", out var result, out var _); return(result); } var intermediateTree = RunCompiler("-i"); var translatedCode = RunCompiler("-o"); var metadata = RunCompiler("-u"); var hasCompilationError = translatedCode.Contains("\nERROR: "); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(outputLanguage, translatedCode) : null, hasCompilationError ? (int?)0 : null, new ShaderCompilerOutput("Output", outputLanguage, translatedCode), new ShaderCompilerOutput("Intermediate tree", null, intermediateTree), new ShaderCompilerOutput("Metadata", null, metadata))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.spv"; ProcessHelper.Run( CommonParameters.GetBinaryPath("clspv", arguments, "clspv.exe"), $"{arguments.GetString(CommonParameters.ExtraOptionsParameter.Name)} \"{tempFile.FilePath}\" -o \"{outputPath}\"", out var stdOutput, out var stdError); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); var hasCompilationError = binaryOutput == null; var textOutput = ""; if (!hasCompilationError) { var textOutputPath = $"{tempFile.FilePath}.txt"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-dis.exe"), $"-o \"{textOutputPath}\" \"{outputPath}\"", out var _, out var _); textOutput = FileHelper.ReadAllTextIfExists(textOutputPath); FileHelper.DeleteIfExists(textOutputPath); } if (!string.IsNullOrWhiteSpace(stdOutput)) { stdError += Environment.NewLine + stdOutput; } FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(LanguageNames.SpirV, binaryOutput) : null, hasCompilationError ? (int?)1 : null, new ShaderCompilerOutput("Assembly", LanguageNames.SpirV, textOutput), new ShaderCompilerOutput("Output", null, stdError))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; var options = string.Empty; if (arguments.GetBoolean("OptimizeForPerformance")) { options += "-O "; } if (arguments.GetBoolean("OptimizeForSize")) { options += "-Os "; } ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-opt.exe"), $"{options} \"{tempFile.FilePath}\" -o \"{outputPath}\"", out var _, out var _); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); var textOutputPath = $"{tempFile.FilePath}.txt"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-dis.exe"), $"-o \"{textOutputPath}\" \"{outputPath}\"", out var _, out var _); FileHelper.DeleteIfExists(outputPath); var textOutput = FileHelper.ReadAllTextIfExists(textOutputPath); FileHelper.DeleteIfExists(textOutputPath); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, binaryOutput), null, new ShaderCompilerOutput("Output", outputLanguage, textOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; Directory.CreateDirectory(outputPath); var stripArgument = string.Empty; if (arguments.GetBoolean("Strip")) { stripArgument = "--strip-all"; } ProcessHelper.Run( CommonParameters.GetBinaryPath("glslang", arguments, "spirv-remap.exe"), $"--map {arguments.GetString("Map")} --dce {arguments.GetString("Dce")} --opt {arguments.GetString("Opt")} {stripArgument} --input \"{tempFile.FilePath}\" --output \"{outputPath}\"", out var _, out var _); var outputFile = Path.Combine(outputPath, Path.GetFileName(tempFile.FilePath)); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputFile); var textOutputPath = $"{tempFile.FilePath}.txt"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-dis.exe"), $"-o \"{textOutputPath}\" \"{outputFile}\"", out var _, out var _); FileHelper.DeleteDirectoryIfExists(outputPath); var textOutput = FileHelper.ReadAllTextIfExists(textOutputPath); FileHelper.DeleteIfExists(textOutputPath); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, binaryOutput), null, new ShaderCompilerOutput("Output", outputLanguage, textOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var shaderType = arguments.GetString("ShaderType") == "Vertex" ? "-vs" : "-fs"; string targetLanguage = null; switch (outputLanguage) { case LanguageNames.Glsl: targetLanguage = "-glsl"; break; case LanguageNames.Hlsl: targetLanguage = "-hlsl"; break; case LanguageNames.Metal: targetLanguage = "-metal"; break; default: throw new InvalidOperationException(); } var entryPoint = arguments.GetString("EntryPoint"); ProcessHelper.Run( CommonParameters.GetBinaryPath("hlslparser", arguments, "hlslparser.exe"), $"{shaderType} {targetLanguage} \"{tempFile.FilePath}\" {entryPoint}", out var stdOutput, out var _); var hasCompilationError = stdOutput.Contains("failed, aborting"); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(outputLanguage, stdOutput) : null, hasCompilationError ? (int?)1 : null, new ShaderCompilerOutput("Output", outputLanguage, stdOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { using (var tempFile = TempFile.FromShaderCode(shaderCode)) { ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-cfg.exe"), $"\"{tempFile.FilePath}\"", out var stdOutput, out var _); return(new ShaderCompilerResult( true, null, null, new ShaderCompilerOutput("Output", "graphviz", stdOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-as.exe"), $"-o \"{outputPath}\" --preserve-numeric-ids --target-env {arguments.GetString("TargetEnv")} \"{tempFile.FilePath}\"", out var _, out var stdError); var binaryOutput = FileHelper.ReadAllBytesIfExists(outputPath); var hasCompilationError = !string.IsNullOrEmpty(stdError); string textOutput = null; if (!hasCompilationError) { var textOutputPath = $"{tempFile.FilePath}.txt"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-tools", arguments, "spirv-dis.exe"), $"-o \"{textOutputPath}\" \"{outputPath}\"", out var _, out var _); textOutput = FileHelper.ReadAllTextIfExists(textOutputPath); FileHelper.DeleteIfExists(textOutputPath); } FileHelper.DeleteIfExists(outputPath); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(outputLanguage, binaryOutput) : null, hasCompilationError ? (int?)1 : null, new ShaderCompilerOutput("Output", outputLanguage, textOutput), new ShaderCompilerOutput("Build errors", null, stdError))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var stage = GetStageFlag(arguments.GetString("ShaderStage")); var core = arguments.GetString("Core"); var maliscBinaryPath = CommonParameters.GetBinaryPath("mali", arguments, "malisc.exe"); var maliocBinaryPath = CommonParameters.GetBinaryPath("mali", arguments, "malioc.exe"); var isMalisc = File.Exists(maliscBinaryPath); var args = string.Empty; if (shaderCode.Language == LanguageNames.SpirV) { args += "--spirv"; if (isMalisc) { var spirVEntryPoint = arguments.GetString("EntryPoint"); args += $" --spirv_entrypoint_name {spirVEntryPoint}"; } } if (!isMalisc) { args += $" --{arguments.GetString("API")}"; } using (var tempFile = TempFile.FromShaderCode(shaderCode)) { ProcessHelper.Run( isMalisc ? maliscBinaryPath : maliocBinaryPath, $"{stage} -c {core} {args} {tempFile.FilePath}", out var stdOutput, out var stdError); return(new ShaderCompilerResult( true, null, !string.IsNullOrWhiteSpace(stdError) ? (int?)1 : null, new ShaderCompilerOutput("Output", null, stdOutput), new ShaderCompilerOutput("Errors", null, stdError))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var stage = arguments.GetString("ShaderStage"); var entryPoint = arguments.GetString("EntryPoint"); var glslVersion = arguments.GetString("GlslVersion"); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("xshadercompiler", arguments, "xsc.exe"), $"-T {stage} -E {entryPoint} -Vout {glslVersion} -o \"{outputPath}\" \"{tempFile.FilePath}\"", out var stdOutput, out var _); var textOutput = FileHelper.ReadAllTextIfExists(outputPath); var hasCompilationErrors = string.IsNullOrWhiteSpace(textOutput); FileHelper.DeleteIfExists(outputPath); string ast = null; if (!hasCompilationErrors) { ProcessHelper.Run( CommonParameters.GetBinaryPath("xshadercompiler", arguments, "xsc.exe"), $"-E {entryPoint} -Valid --show-ast \"{tempFile.FilePath}\"", out ast, out var _); } return(new ShaderCompilerResult( !hasCompilationErrors, new ShaderCode(LanguageNames.Glsl, textOutput), hasCompilationErrors ? (int?)1 : null, new ShaderCompilerOutput("Output", LanguageNames.Glsl, textOutput), new ShaderCompilerOutput("Build output", null, stdOutput), new ShaderCompilerOutput("AST", null, ast))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; var errorPath = $"{tempFile.FilePath}.error"; var shaderType = arguments.GetString("ShaderType") == "Vertex" ? 0 // EShLangVertex : 1; // EShLangFragment var targetVersion = Array.IndexOf(TargetVersionOptions, arguments.GetString("TargetVersion")); var entryPoint = arguments.GetString("EntryPoint"); ProcessHelper.Run( CommonParameters.GetBinaryPath("hlsl2glsl", arguments, "ShaderPlayground.Shims.Hlsl2Glsl.exe"), $"\"{tempFile.FilePath}\" {shaderType} {targetVersion} {entryPoint} \"{outputPath}\" \"{errorPath}\"", out var _, out var _); var textOutput = FileHelper.ReadAllTextIfExists(outputPath); var errorOutput = FileHelper.ReadAllTextIfExists(errorPath); FileHelper.DeleteIfExists(outputPath); FileHelper.DeleteIfExists(errorPath); var hasCompilationError = !string.IsNullOrEmpty(errorOutput); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(outputLanguage, textOutput) : null, hasCompilationError ? (int?)1 : null, new ShaderCompilerOutput("Output", outputLanguage, textOutput), new ShaderCompilerOutput("Build errors", null, errorOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; var errorPath = $"{tempFile.FilePath}.error"; var targetVersion = outputLanguage == LanguageNames.Metal ? 3 // kGlslTargetMetal : 0; // kGlslTargetOpenGL var shaderType = arguments.GetString("ShaderType") == "Vertex" ? 0 // kGlslOptShaderVertex : 1; // kGlslOptShaderFragment ProcessHelper.Run( CommonParameters.GetBinaryPath("glsl-optimizer", arguments, "ShaderPlayground.Shims.GlslOptimizer.exe"), $"\"{tempFile.FilePath}\" {targetVersion} {shaderType} \"{outputPath}\" \"{errorPath}\"", out var _, out var _); var textOutput = FileHelper.ReadAllTextIfExists(outputPath); var errorOutput = FileHelper.ReadAllTextIfExists(errorPath); FileHelper.DeleteIfExists(outputPath); FileHelper.DeleteIfExists(errorPath); var hasCompilationError = !string.IsNullOrEmpty(errorOutput); return(new ShaderCompilerResult( !hasCompilationError, !hasCompilationError ? new ShaderCode(outputLanguage, textOutput) : null, hasCompilationError ? (int?)1 : null, new ShaderCompilerOutput("Output", outputLanguage, textOutput), new ShaderCompilerOutput("Build errors", null, errorOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var stage = arguments.GetString(ShaderStageName); var entryPoint = arguments.GetString(EntryPointName); var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); var exePath = CommonParameters.GetBinaryPath("tint", arguments, "tint.exe"); if (!RunTint(exePath, shaderCode, stage, entryPoint, outputLanguage, out var output, out var error)) { return(ErrorResult(outputLanguage, error)); } if (outputLanguage == LanguageNames.SpirV) { // SPIR-V is currently the only binary format that requires disassembling. if (!RunTint(exePath, shaderCode, stage, entryPoint, LanguageNames.SpirvAssembly, out var asm, out error)) { return(ErrorResult(outputLanguage, error)); } return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, output), 0, new ShaderCompilerOutput("Disassembly", outputLanguage, Encoding.ASCII.GetString(asm)), new ShaderCompilerOutput("Build output", null, ""))); } else { var disassembly = Encoding.ASCII.GetString(output); return(new ShaderCompilerResult( true, new ShaderCode(outputLanguage, disassembly), 0, new ShaderCompilerOutput("Disassembly", outputLanguage, disassembly), new ShaderCompilerOutput("Build output", null, ""))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { string shaderType; switch (arguments.GetString("ShaderStage")) { case "vert": shaderType = "-v"; break; case "tesc": shaderType = "-tc"; break; case "tese": shaderType = "-te"; break; case "geom": shaderType = "-g"; break; case "frag": shaderType = "-f"; break; case "comp": shaderType = "-c"; break; default: throw new InvalidOperationException(); } using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputDisassemblyPath = Path.ChangeExtension(tempFile.FilePath, ".disasm"); var outputProfilePath = Path.ChangeExtension(tempFile.FilePath, ".prof"); ProcessHelper.Run( CommonParameters.GetBinaryPath("powervr", arguments, "GLSLESCompiler_Rogue.exe"), $"{tempFile.FilePath} {tempFile.FilePath} {shaderType} -disasm -profile", out var stdOutput, out var stdError); if (stdError == string.Empty) { stdError = stdOutput; } var outputDisassembly = FileHelper.ReadAllTextIfExists(outputDisassemblyPath); var outputProfile = FileHelper.ReadAllTextIfExists(outputProfilePath); FileHelper.DeleteIfExists(outputDisassemblyPath); FileHelper.DeleteIfExists(outputProfilePath); var selectedOutputIndex = stdError.Contains("failed") ? 2 : (int?)null; return(new ShaderCompilerResult( true, null, selectedOutputIndex, new ShaderCompilerOutput("Disassembly", null, outputDisassembly), new ShaderCompilerOutput("Profiling", null, outputProfile), new ShaderCompilerOutput("Output", null, stdError))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var asic = arguments.GetString("Asic"); var entryPoint = arguments.GetString("EntryPoint"); var targetProfile = arguments.GetString("TargetProfile"); var shaderStage = arguments.GetString(CommonParameters.GlslShaderStage.Name); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputAnalysisPath = $"{tempFile.FilePath}.analysis"; var isaPath = $"{tempFile.FilePath}.isa"; var liveRegPath = $"{tempFile.FilePath}.livereg"; var cfgPath = $"{tempFile.FilePath}.cfg"; var args = $"--asic \"{asic}\" --analysis \"{outputAnalysisPath}\" --isa \"{isaPath}\" --livereg \"{liveRegPath}\" --cfg \"{cfgPath}\""; switch (shaderCode.Language) { case LanguageNames.Hlsl: args += $" -s hlsl --profile {targetProfile} --function {entryPoint}"; break; case LanguageNames.Glsl: switch (arguments.GetString("GlslTarget")) { case TargetOpenGL: args += $" -s opengl --{shaderStage}"; break; case TargetVulkan: args += $" -s vulkan --{shaderStage}"; break; } break; case LanguageNames.SpirvAssembly: args += $" -s vulkan-spv-txt --{shaderStage}"; break; } args += $" \"{tempFile.FilePath}\""; var rgaPath = CommonParameters.GetBinaryPath("rga", arguments, "rga.exe"); ProcessHelper.Run( rgaPath, args, out var stdOutput, out _); string GetActualOutputPath(string extension) { if (extension == "analysis" && shaderCode.Language == LanguageNames.Hlsl) { return(Path.Combine( Path.GetDirectoryName(tempFile.FilePath), $"{entryPoint}_{Path.GetFileName(tempFile.FilePath)}.analysis")); } var name = shaderCode.Language == LanguageNames.Hlsl ? entryPoint : shaderStage; return(Path.Combine( Path.GetDirectoryName(tempFile.FilePath), $"{asic}_{name}_{Path.GetFileName(tempFile.FilePath)}.{extension}")); } outputAnalysisPath = GetActualOutputPath("analysis"); isaPath = GetActualOutputPath("isa"); liveRegPath = GetActualOutputPath("livereg"); cfgPath = GetActualOutputPath("cfg"); var outputAnalysis = FileHelper.ReadAllTextIfExists(outputAnalysisPath); var isa = FileHelper.ReadAllTextIfExists(isaPath); var liveReg = FileHelper.ReadAllTextIfExists(liveRegPath); var cfg = FileHelper.ReadAllTextIfExists(cfgPath); FileHelper.DeleteIfExists(outputAnalysisPath); FileHelper.DeleteIfExists(isaPath); FileHelper.DeleteIfExists(liveRegPath); FileHelper.DeleteIfExists(cfgPath); var selectedOutputIndex = stdOutput.Contains("\nError: ") || stdOutput.Contains("... failed.") ? 3 : (int?)null; return(new ShaderCompilerResult( selectedOutputIndex == null, null, selectedOutputIndex, new ShaderCompilerOutput("Disassembly", null, isa), //new ShaderCompilerOutput("Analysis", null, outputAnalysis), new ShaderCompilerOutput("Live register analysis", null, liveReg), new ShaderCompilerOutput("Control flow graph", "graphviz", cfg), new ShaderCompilerOutput("Build output", null, stdOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var entryPoint = arguments.GetString("EntryPoint"); var targetProfile = arguments.GetString("TargetProfile"); var disableOptimizations = arguments.GetBoolean("DisableOptimizations"); var optimizationLevel = Convert.ToInt32(arguments.GetString("OptimizationLevel")); var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); var spirv = (outputLanguage == LanguageNames.SpirV) ? $"-spirv -fspv-target-env={arguments.GetString("SpirvTarget")}" : string.Empty; using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var fcPath = $"{tempFile.FilePath}.fc"; var fePath = $"{tempFile.FilePath}.fe"; var foPath = $"{tempFile.FilePath}.fo"; var args = $"{spirv} -T {targetProfile} -E {entryPoint} -O{optimizationLevel} -Fc \"{fcPath}\" -Fe \"{fePath}\" -Fo \"{foPath}\""; if (disableOptimizations) { args += " -Od"; } args += $" \"{tempFile.FilePath}\""; var dxcPath = CommonParameters.GetBinaryPath("dxc", arguments, "dxc.exe"); ProcessHelper.Run( dxcPath, args, out var _, out var _); int?selectedOutputIndex = null; var disassembly = FileHelper.ReadAllTextIfExists(fcPath); if (string.IsNullOrWhiteSpace(disassembly)) { disassembly = "<Compilation error occurred>"; selectedOutputIndex = 2; } var binaryOutput = FileHelper.ReadAllBytesIfExists(foPath); var buildOutput = FileHelper.ReadAllTextIfExists(fePath); FileHelper.DeleteIfExists(fcPath); FileHelper.DeleteIfExists(fePath); FileHelper.DeleteIfExists(foPath); // Run again to get AST (can't be done in combination with output files, above). ProcessHelper.Run( dxcPath, $"-T {targetProfile} -E {entryPoint} -ast-dump \"{tempFile.FilePath}\"", out var stdOutputAst, out var _); return(new ShaderCompilerResult( selectedOutputIndex == null, new ShaderCode(outputLanguage, binaryOutput), selectedOutputIndex, new ShaderCompilerOutput("Disassembly", outputLanguage, disassembly), new ShaderCompilerOutput("AST", null, stdOutputAst), new ShaderCompilerOutput("Build output", null, buildOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var version = Version.Parse(arguments.GetString(CommonParameters.VersionParameterName)); var isVersion21OrLater = version >= new Version(2, 1); var isVersion22OrLater = version >= new Version(2, 2); var asic = arguments.GetString("Asic"); var entryPoint = arguments.GetString("EntryPoint"); var targetProfile = arguments.GetString("TargetProfile"); var shaderStage = arguments.GetString(CommonParameters.GlslShaderStage.Name); using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputAnalysisPath = $"{tempFile.FilePath}.analysis"; var ilPath = $"{tempFile.FilePath}.il"; var isaPath = $"{tempFile.FilePath}.isa"; var liveRegPath = $"{tempFile.FilePath}.livereg"; var cfgPath = $"{tempFile.FilePath}.cfg"; var args = $"--asic \"{asic}\" --il \"{ilPath}\" --line-numbers --isa \"{isaPath}\" --livereg \"{liveRegPath}\" --cfg \"{cfgPath}\""; switch (shaderCode.Language) { case LanguageNames.Hlsl: args += isVersion22OrLater ? $" -s dx11" : " -s hlsl"; args += $" --profile {targetProfile} --function {entryPoint}"; args += $" \"{tempFile.FilePath}\""; break; case LanguageNames.Glsl: switch (arguments.GetString("GlslTarget")) { case TargetOpenGL: args += $" -s opengl --{shaderStage}"; break; case TargetVulkan: args += $" -s {(isVersion21OrLater ? "vk-offline" : "vulkan")} --{shaderStage}"; break; } args += $" \"{tempFile.FilePath}\""; break; case LanguageNames.SpirvAssembly: args += $" -s {(isVersion21OrLater ? "vk-spv-txt-offline" : "vulkan-spv-text")} --{shaderStage}"; args += $" \"{tempFile.FilePath}\""; break; } var rgaPath = CommonParameters.GetBinaryPath("rga", arguments, "rga.exe"); var result = ProcessHelper.Run( rgaPath, args, out var stdOutput, out _); var actualOutputPathPrefix = Path.GetDirectoryName(tempFile.FilePath); string GetActualOutputPath(string extension) { if (extension == "analysis" && shaderCode.Language == LanguageNames.Hlsl) { return(Path.Combine( Path.GetDirectoryName(tempFile.FilePath), $"{entryPoint}_{Path.GetFileName(tempFile.FilePath)}.analysis")); } switch (shaderCode.Language) { case LanguageNames.Hlsl: return(Path.Combine( actualOutputPathPrefix, $"{asic}_{entryPoint}_{Path.GetFileName(tempFile.FilePath)}.{extension}")); default: if (isVersion21OrLater) { return(Path.Combine( actualOutputPathPrefix, $"{asic}_{Path.GetFileName(tempFile.FilePath)}_{shaderStage}.{extension}")); } else { return(Path.Combine( actualOutputPathPrefix, $"{asic}_{shaderStage}_{Path.GetFileName(tempFile.FilePath)}.{extension}")); } } } outputAnalysisPath = GetActualOutputPath("analysis"); ilPath = GetActualOutputPath("il"); isaPath = GetActualOutputPath("isa"); liveRegPath = GetActualOutputPath("livereg"); cfgPath = GetActualOutputPath("cfg"); var outputAnalysis = FileHelper.ReadAllTextIfExists(outputAnalysisPath); var il = FileHelper.ReadAllTextIfExists(ilPath); var isa = FileHelper.ReadAllTextIfExists(isaPath); var liveReg = FileHelper.ReadAllTextIfExists(liveRegPath); var cfg = FileHelper.ReadAllTextIfExists(cfgPath); FileHelper.DeleteIfExists(outputAnalysisPath); FileHelper.DeleteIfExists(ilPath); FileHelper.DeleteIfExists(isaPath); FileHelper.DeleteIfExists(liveRegPath); FileHelper.DeleteIfExists(cfgPath); var selectedOutputIndex = !result || stdOutput.Contains("\nError: ") || stdOutput.Contains("... failed.") ? 4 : (int?)null; return(new ShaderCompilerResult( selectedOutputIndex == null, null, selectedOutputIndex, new ShaderCompilerOutput("ISA Disassembly", null, isa), new ShaderCompilerOutput("IL Disassembly", null, il), //new ShaderCompilerOutput("Analysis", null, outputAnalysis), new ShaderCompilerOutput("Live register analysis", null, liveReg), new ShaderCompilerOutput("Control flow graph", "graphviz", cfg), new ShaderCompilerOutput("Build output", null, stdOutput))); } }
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments) { var args = string.Empty; var outputLanguage = arguments.GetString(CommonParameters.OutputLanguageParameterName); switch (outputLanguage) { case LanguageNames.Glsl: args += ""; // TODO break; case LanguageNames.Metal: args += " --msl"; break; case LanguageNames.Hlsl: args += " --hlsl"; break; case LanguageNames.Cpp: args += " --cpp"; break; } var entryPointArg = $" --entry {arguments.GetString("EntryPoint")}"; args += entryPointArg; using (var tempFile = TempFile.FromShaderCode(shaderCode)) { var outputPath = $"{tempFile.FilePath}.out"; ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-cross", arguments, "spirv-cross.exe"), $"--output \"{outputPath}\" \"{tempFile.FilePath}\" {args}", out var _, out var stdError); var hasCompilationErrors = !string.IsNullOrWhiteSpace(stdError); var textOutput = FileHelper.ReadAllTextIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); string reflectionJson = null; if (!hasCompilationErrors) { ProcessHelper.Run( CommonParameters.GetBinaryPath("spirv-cross", arguments, "spirv-cross.exe"), $"--output \"{outputPath}\" \"{tempFile.FilePath}\" --reflect {entryPointArg}", out var _, out var _); reflectionJson = FileHelper.ReadAllTextIfExists(outputPath); FileHelper.DeleteIfExists(outputPath); } return(new ShaderCompilerResult( !hasCompilationErrors, new ShaderCode(outputLanguage, textOutput), hasCompilationErrors ? (int?)1 : null, new ShaderCompilerOutput("Output", outputLanguage, textOutput), new ShaderCompilerOutput("Reflection", "JSON", reflectionJson), new ShaderCompilerOutput("Errors", null, hasCompilationErrors ? stdError : "<No compilation errors>"))); } }