public void Decompile(string relPath)
{
string file = $"{ShaderDirectory}/{relPath}";
// Arrange.
// Act.
var bytecode = File.ReadAllBytes(file + ".o");
var shader = ShaderReader.ReadShader(bytecode);
var hlslWriter = new HlslWriter(shader);
string decompiledHlsl = "";
using (var stream = new MemoryStream())
{
hlslWriter.Write(stream);
stream.Position = 0;
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
decompiledHlsl = reader.ReadToEnd();
}
}
File.WriteAllText($"{file}.d.hlsl", decompiledHlsl);
// Assert.
}
public void DecompileTest(string baseFilename)
{
string compiledShaderFilename = $"CompiledShaders{Path.DirectorySeparatorChar}{baseFilename}.fxc";
string asmExpectedFilename = $"ShaderAssembly{Path.DirectorySeparatorChar}{baseFilename}.asm";
string hlslExpectedFilename = $"ShaderSources{Path.DirectorySeparatorChar}{baseFilename}.fx";
string asmOutputFilename = $"{baseFilename}.asm";
string hlslOutputFilename = $"{baseFilename}.fx";
ShaderModel shader;
var inputStream = File.Open(compiledShaderFilename, FileMode.Open, FileAccess.Read);
using (var input = new ShaderReader(inputStream, true))
{
shader = input.ReadShader();
}
var asmWriter = new AsmWriter(shader);
asmWriter.Write(asmOutputFilename);
var hlslWriter = new HlslWriter(shader, true);
hlslWriter.Write(hlslOutputFilename);
FileAssert.AreEqual(asmExpectedFilename, asmOutputFilename, "Assembly not equal");
FileAssert.AreEqual(hlslExpectedFilename, hlslOutputFilename, "HLSL not equal");
}
public void RecompileShaders(string relPath)
{
string file = $"{ShaderDirectory}/{relPath}";
// Arrange.
var relDir = Path.GetDirectoryName(relPath);
Directory.CreateDirectory($"{OutputDir}/{relDir}");
var sourceName = GetSourceNameFromObject($"{ShaderDirectory}/{relPath}.o");
if (ShaderDirectory != OutputDir)
{
File.Copy($"{ShaderDirectory}/{relDir}/{sourceName}", $"{OutputDir}/{relDir}/{sourceName}", true);
}
if (ShaderDirectory != OutputDir)
{
File.Copy($"{ShaderDirectory}/{relPath}.asm", $"{OutputDir}/{relPath}.asm", true);
}
var asmFileText = string.Join(Environment.NewLine,
File.ReadAllLines(file + ".asm").Select(x => x.Trim()));
// Act.
var binaryFileBytes = File.ReadAllBytes(file + ".o");
var shaderModel = ShaderReader.ReadShader(binaryFileBytes);
var hlslWriter = new HlslWriter(shaderModel);
string decompiledHLSL = "";
using (var stream = new MemoryStream())
{
hlslWriter.Write(stream);
stream.Position = 0;
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
decompiledHLSL = reader.ReadToEnd();
}
}
File.WriteAllText($"{OutputDir}/{relPath}.d.hlsl", decompiledHLSL);
using (var shaderBytecode = ShaderBytecode.FromStream(new MemoryStream(binaryFileBytes)))
{
var profile = shaderModel.Type == DX9Shader.ShaderType.Pixel ?
$"ps_{shaderModel.MajorVersion}_{shaderModel.MinorVersion}" :
$"vs_{shaderModel.MajorVersion}_{shaderModel.MinorVersion}";
var compiledShader = ShaderBytecode.Compile(decompiledHLSL, "main", profile);
var disassembly = shaderBytecode.Disassemble();
var redisassembly = compiledShader.Bytecode.Disassemble();
File.WriteAllText($"{OutputDir}/{relPath}.d1.asm", disassembly);
File.WriteAllText($"{OutputDir}/{relPath}.d2.asm", redisassembly);
// Assert.
Warn.If(disassembly, Is.EqualTo(redisassembly));
}
// Assert.
Assert.Pass();
}
public void Decompile(string relPath)
{
string file = $"{ShaderDirectory}/{relPath}";
// Arrange.
// Act.
var bytecode = File.ReadAllBytes(file + ".o");
var decompiledHlsl = HlslWriter.Decompile(bytecode);
File.WriteAllText($"{file}.d.hlsl", decompiledHlsl);
// Assert.
}
public void TestSimpleVertexShaderWithConstants()
{
var bytecode = ShaderBytecode.Compile(@"
struct T {
float f;
float4 v;
};
struct U {
row_major float2x3 f;
T t[2];
float g;
};
U u[3];
float4 HakureiReimuAliceMargatroid;
row_major float2x2 m;
column_major float2x2 n;
sampler Gensokyo[2];
float4 VS(float4 p : POSITION) : POSITION {
return p * HakureiReimuAliceMargatroid.w * u[2].t[1].v * m[0].y * n[0].y;
}
float4 PS(float4 t : TEXCOORD) : COLOR {
return tex2D(Gensokyo[0], t.xy) + tex2D(Gensokyo[1], t.zw);
}
technique Tq {
pass p0 {
VertexShader = compile vs_3_0 VS();
PixelShader = compile ps_3_0 PS();
}
}
" , "fx_2_0").Bytecode;
var shaderModel = ShaderReader.ReadShader(bytecode);
var shaders = from blob in shaderModel.EffectChunk.StateBlobLookup.Values
where blob.BlobType == DX9Shader.FX9.StateBlobType.Shader
select blob.Shader;
string AstDecompile(ShaderModel shader) => new HlslWriter(shader, doAstAnalysis: true).Decompile();
var testVertexShader = shaders.First(s => s.Type == ShaderType.Vertex);
var decompiledVertexShader = AstDecompile(testVertexShader);
// here we use the `.w` component, to make sure `HakureiReimuAliceMargatroid.w`
// is inside the actual decompiled shader too, not just inside constant declaration
// (that is, `float4 HakureiReimuAliceMargatroid`).
StringAssert.Contains("HakureiReimuAliceMargatroid.w", decompiledVertexShader);
// assert that `u[2].t[1].v` appears inside the decompiled source code
StringAssert.Contains("u[2].t[1].v", decompiledVertexShader);
var testPixelShader = shaders.First(s => s.Type == ShaderType.Pixel);
var decompiledPixelShader = AstDecompile(testPixelShader);
// assert that sampler array elements `Gensokyo[0]` and `[1]`
// appears inside the decompile source code
StringAssert.Contains("Gensokyo[0]", decompiledPixelShader);
StringAssert.Contains("Gensokyo[1]", decompiledPixelShader);
var fromNonAst = HlslWriter.Decompile(bytecode);
StringAssert.Contains("HakureiReimuAliceMargatroid.w", fromNonAst);
StringAssert.Contains("u[2].t[1].v", fromNonAst);
StringAssert.Contains("Gensokyo[0]", fromNonAst);
StringAssert.Contains("Gensokyo[1]", fromNonAst);
}
