void ExportSerializedProgram(SerializedProgram serializedProgram, ShaderWriter writer, ShaderType type)
{
if (serializedProgram.SubPrograms.Count > 0)
{
writer.WriteIndent(3);
writer.Write("Program \"{0}\" {{\n", type.ToProgramTypeString());
HashSet <ShaderGpuProgramType> isTierLookup = GetIsTierLookup(serializedProgram.SubPrograms);
var subprograms = serializedProgram.SubPrograms;
var best = serializedProgram.SubPrograms
.OrderByDescending(subProgram =>
{
GPUPlatform platform = subProgram.GpuProgramType.ToGPUPlatform(writer.Platform);
int index = writer.Shader.Platforms.IndexOf(platform);
ShaderSubProgramBlob blob = writer.Shader.SubProgramBlobs[index];
var sp = blob.SubPrograms[(int)subProgram.BlobIndex];
return(sp.ProgramData.Count);
//return sp.GlobalKeywords.Sum(keyword => keyword.Contains("ON") ? 2 : 1);
}).FirstOrDefault();
if (FilterSubPrograms)
{
subprograms = new SerializedSubProgram[] { best };
}
foreach (SerializedSubProgram subProgram in subprograms)
{
Platform uplatform = writer.Platform;
GPUPlatform platform = subProgram.GpuProgramType.ToGPUPlatform(uplatform);
int index = writer.Shader.Platforms.IndexOf(platform);
ShaderSubProgramBlob blob = writer.Shader.SubProgramBlobs[index];
bool isTier = isTierLookup.Contains(subProgram.GpuProgramType);
ExportSerializedSubProgram(subProgram, writer, blob, type, isTier, best.BlobIndex == subProgram.BlobIndex);
}
writer.WriteIndent(3);
writer.Write("}\n");
}
}
public Shader(AssetInfo assetInfo) :
base(assetInfo)
{
if (IsEncoded)
{
SubProgramBlob = new ShaderSubProgramBlob();
}
}
public override void Read(EndianStream stream)
{
base.Read(stream);
ParsedForm.Read(stream);
Name = ParsedForm.Name;
m_platforms = stream.ReadEnum32Array((t) => (GPUPlatform)t);
uint[] offsets = stream.ReadUInt32Array();
uint[] compressedLengths = stream.ReadUInt32Array();
uint[] decompressedLengths = stream.ReadUInt32Array();
byte[] compressedBlob = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
m_subProgramBlobs = new ShaderSubProgramBlob[m_platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < m_platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4Stream lz4Stream = new Lz4Stream(memStream, (int)compressedLength))
{
int read = lz4Stream.Read(decompressedBuffer, 0, decompressedBuffer.Length);
if (read != decompressedLength)
{
throw new Exception($"Can't properly decode shader blob. Read {read} but expected {decompressedLength}");
}
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (EndianStream blobStream = new EndianStream(blobMem))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob(AssetsFile);
blob.Read(blobStream);
m_subProgramBlobs[i] = blob;
}
}
}
}
m_dependencies = stream.ReadArray(() => new PPtr <SShader>(AssetsFile));
ShaderIsBaked = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
private void UnpackSubProgramBlobs(AssetLayout layout, uint[][] offsets, uint[][] compressedLengths, uint[][] decompressedLengths, byte[] compressedBlob)
{
Blobs = new ShaderSubProgramBlob[offsets.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < Platforms.Length; i++)
{
uint[] blobOffsets = offsets[i];
uint[] blobCompressedLengths = compressedLengths[i];
uint[] blobDecompressedLengths = decompressedLengths[i];
Blobs[i].Read(layout, memStream, blobOffsets, blobCompressedLengths, blobDecompressedLengths);
}
}
}
public void Export(ShaderWriter writer, ShaderType type)
{
writer.WriteIndent(3);
writer.Write("Program \"{0}\" {{\n", type.ToProgramTypeString());
int tierCount = GetTierCount(SubPrograms);
for (int i = 0; i < SubPrograms.Length; i++)
{
SerializedSubProgram subProgram = SubPrograms[i];
Platform uplatform = writer.Platform;
GPUPlatform platform = subProgram.GpuProgramType.ToGPUPlatform(uplatform);
int index = writer.Shader.Platforms.IndexOf(platform);
ref ShaderSubProgramBlob blob = ref writer.Shader.SubProgramBlobs[index];
subProgram.Export(writer, ref blob, type, tierCount > 1);
}
private void ReadSubProgramBlobs(AssetLayout layout, uint[] offsets, uint[] compressedLengths, uint[] decompressedLengths, byte[] compressedBlob)
{
SubProgramBlobs = new ShaderSubProgramBlob[Platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < Platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
SubProgramBlobs[i] = ReadSubProgramBlobs(layout, memStream, offset, compressedLength, decompressedLength);
}
}
}
private void UnpackSubProgramBlobs(AssetLayout layout, uint offset, uint compressedLength, uint decompressedLength, byte[] compressedBlob)
{
if (compressedBlob.Length == 0)
{
Blobs = Array.Empty <ShaderSubProgramBlob>();
}
else
{
Blobs = new ShaderSubProgramBlob[1];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
uint[] offsets = new uint[] { offset };
uint[] compressedLengths = new uint[] { compressedLength };
uint[] decompressedLengths = new uint[] { decompressedLength };
Blobs[0].Read(layout, memStream, offsets, compressedLengths, decompressedLengths);
}
}
}
public void Export(ShaderWriter writer, ref ShaderSubProgramBlob blob, ShaderType type, bool isTier)
{
writer.WriteIndent(4);
#warning TODO: convertion (DX to HLSL)
writer.Write("SubProgram \"{0} ", GpuProgramType.ToGPUPlatform(writer.Platform));
if (isTier)
{
writer.Write("hw_tier{0} ", ShaderHardwareTier.ToString("00"));
}
writer.Write("\" {\n");
writer.WriteIndent(5);
blob.SubPrograms[(int)BlobIndex].Export(writer, type);
writer.Write('\n');
writer.WriteIndent(4);
writer.Write("}\n");
}
private ShaderSubProgramBlob ReadSubProgramBlobs(AssetLayout layout, MemoryStream memStream, uint offset, uint compressedLength, uint decompressedLength)
{
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream, (int)compressedLength))
{
lz4Stream.ReadBuffer(decompressedBuffer, 0, decompressedBuffer.Length);
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(blobMem, EndianType.LittleEndian, layout))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobReader);
return(blob);
}
}
}
public override void Read(AssetReader reader)
{
if (IsSerialized(reader.Version))
{
ReadBase(reader);
ParsedForm.Read(reader);
m_platforms = reader.ReadEnum32Array((t) => (GPUPlatform)t);
uint[] offsets = reader.ReadUInt32Array();
uint[] compressedLengths = reader.ReadUInt32Array();
uint[] decompressedLengths = reader.ReadUInt32Array();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
m_subProgramBlobs = new ShaderSubProgramBlob[m_platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < m_platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream, (int)compressedLength))
{
int read = lz4Stream.Read(decompressedBuffer, 0, decompressedBuffer.Length);
if (read != decompressedLength)
{
throw new Exception($"Can't properly decode shader blob. Read {read} but expected {decompressedLength}");
}
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(blobMem, reader.Version, reader.Platform, reader.Flags))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobReader);
m_subProgramBlobs[i] = blob;
}
}
}
}
}
else
{
base.Read(reader);
if (IsEncoded(reader.Version))
{
uint decompressedSize = reader.ReadUInt32();
int comressedSize = reader.ReadInt32();
byte[] subProgramBlob = new byte[comressedSize];
reader.Read(subProgramBlob, 0, comressedSize);
reader.AlignStream(AlignType.Align4);
if (comressedSize > 0 && decompressedSize > 0)
{
byte[] decompressedBuffer = new byte[decompressedSize];
using (MemoryStream memStream = new MemoryStream(subProgramBlob))
{
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream))
{
int read = lz4Stream.Read(decompressedBuffer, 0, decompressedBuffer.Length);
if (read != decompressedSize)
{
throw new Exception($"Can't properly decode sub porgram blob. Read {read} but expected {decompressedSize}");
}
}
}
using (MemoryStream memStream = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(memStream, reader.Version, reader.Platform, reader.Flags))
{
SubProgramBlob.Read(blobReader);
}
}
}
}
if (IsReadFallback(reader.Version))
{
Fallback.Read(reader);
}
if (IsReadDefaultProperties(reader.Version))
{
DefaultProperties.Read(reader);
}
if (IsReadStaticProperties(reader.Version))
{
StaticProperties.Read(reader);
}
}
if (IsReadDependencies(reader.Version))
{
m_dependencies = reader.ReadAssetArray <PPtr <Shader> >();
}
if (IsReadNonModifiableTextures(reader.Version))
{
m_nonModifiableTextures = reader.ReadAssetArray <PPtr <Texture> >();
}
if (IsReadShaderIsBaked(reader.Version))
{
ShaderIsBaked = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
void ExportSerializedSubProgram(SerializedSubProgram subProgram, ShaderWriter writer, ShaderSubProgramBlob blob, ShaderType type, bool isTier, bool isBest)
{
writer.WriteIndent(4);
writer.Write("SubProgram \"{0} ", subProgram.GpuProgramType.ToGPUPlatform(writer.Platform));
if (isTier)
{
writer.Write("hw_tier{0} ", subProgram.ShaderHardwareTier.ToString("00"));
}
writer.Write("\" {\n");
writer.WriteIndent(5);
var shaderSubProgram = blob.SubPrograms[(int)subProgram.BlobIndex];
string hash = Hash(shaderSubProgram.ProgramData.ToArray());
var filesteam = writer.BaseStream as FileStream;
var folder = Path.GetDirectoryName(filesteam.Name);
DXShaderObjectExporter.FixShaderSubProgram(shaderSubProgram,
subProgram);
ExportShaderSubProgram(shaderSubProgram, writer, type, isBest);
writer.Write('\n');
writer.WriteIndent(4);
writer.Write("}\n");
}
public override void Read(AssetReader reader)
{
if (IsSerialized(reader.Version))
{
ReadNamedObject(reader);
ParsedForm.Read(reader);
Platforms = reader.ReadArray((t) => (GPUPlatform)t);
uint[] offsets = reader.ReadUInt32Array();
uint[] compressedLengths = reader.ReadUInt32Array();
uint[] decompressedLengths = reader.ReadUInt32Array();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
SubProgramBlobs = new ShaderSubProgramBlob[Platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < Platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream, (int)compressedLength))
{
lz4Stream.ReadBuffer(decompressedBuffer, 0, decompressedBuffer.Length);
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(blobMem, EndianType.LittleEndian, reader.Version, reader.Platform, reader.Flags))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobReader);
SubProgramBlobs[i] = blob;
}
}
}
}
}
else
{
base.Read(reader);
if (IsEncoded(reader.Version))
{
uint decompressedSize = reader.ReadUInt32();
int comressedSize = reader.ReadInt32();
if (comressedSize > 0 && decompressedSize > 0)
{
byte[] subProgramBlob = new byte[comressedSize];
reader.ReadBuffer(subProgramBlob, 0, comressedSize);
byte[] decompressedBuffer = new byte[decompressedSize];
using (MemoryStream memStream = new MemoryStream(subProgramBlob))
{
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream))
{
lz4Stream.ReadBuffer(decompressedBuffer, 0, decompressedBuffer.Length);
}
}
using (MemoryStream memStream = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(memStream, EndianType.LittleEndian, reader.Version, reader.Platform, reader.Flags))
{
SubProgramBlob.Read(blobReader);
}
}
}
reader.AlignStream();
}
if (HasFallback(reader.Version))
{
Fallback.Read(reader);
}
if (HasDefaultProperties(reader.Version))
{
DefaultProperties.Read(reader);
}
if (HasStaticProperties(reader.Version))
{
StaticProperties.Read(reader);
}
}
if (HasDependencies(reader.Version))
{
Dependencies = reader.ReadAssetArray <PPtr <Shader> >();
}
if (HasNonModifiableTextures(reader.Version))
{
NonModifiableTextures = new Dictionary <string, PPtr <Texture> >();
NonModifiableTextures.Read(reader);
}
if (HasShaderIsBaked(reader.Version))
{
ShaderIsBaked = reader.ReadBoolean();
reader.AlignStream();
}
#if UNIVERSAL
if (HasErrors(reader.Version, reader.Flags))
{
Errors = reader.ReadAssetArray <ShaderError>();
}
if (HasDefaultTextures(reader.Version, reader.Flags))
{
DefaultTextures = new Dictionary <string, PPtr <Texture> >();
DefaultTextures.Read(reader);
}
if (HasCompileInfo(reader.Version, reader.Flags))
{
CompileInfo.Read(reader);
}
#endif
}
