public void DisplayVertexInstructions(TagDatum vertexDatum, CacheStream cache)
{
var vertexBlock = ( VertexShaderBlock )cache.Deserialize(vertexDatum.Identifier);
var code = vertexBlock.GeometryClassifications[0].Code;
var altCode = vertexBlock.GeometryClassifications[0].CompiledShader;
var strBuilder = new StringBuilder();
foreach (var s in altCode)
{
strBuilder.Append("$ " + s + " ");
}
strBuilder.AppendLine();
if (code.Length < 4)
{
textEditorControl1.Text = strBuilder.ToString();
textEditorControl1.Refresh( );
return;
}
using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(code)))
{
var version = binaryReader.ReadInt16( );
strBuilder.AppendLine("#" + version);
var instructionCount = binaryReader.ReadInt16( );
for (int i = 0; i < instructionCount; i++)
{
var instructionBytes = binaryReader.ReadBytes(16);
var instruction = new VertexProgramInstruction(instructionBytes);
strBuilder.AppendLine(instruction.ToAsm);
}
}
textEditorControl1.Text = strBuilder.ToString( );
textEditorControl1.Refresh();
}
public GuerillaBlockReferenceNode(string name, string text, TagDatum reference)
{
Text = Path.ChangeExtension(text, reference.Class.ToString( ));
Name = Path.ChangeExtension(name, reference.Class.ToString( ));
BlockIdent = reference.Identifier;
BlockClass = reference.Class;
Datum = reference;
}
public void DisplayVertexConstants(TagDatum vertexTag, CacheStream cache)
{
var items = GetVertexConstants(vertexTag, cache);
items.Sort((u, v) => u.bytes[0].CompareTo(v.bytes[0]));
var source = new BindingSource {
DataSource = items
};
dataGridView1.DataSource = source;
}
public TagReferenceListViewItem(TagDatum datum, int imageIndex = 0)
{
Reference = datum;
Name = Path.ChangeExtension(datum.Identifier.GetPath(datum.CacheKey), datum.Class.ToString());
Text = Path.ChangeExtension(Path.GetFileName(datum.Identifier.GetPath(datum.CacheKey)),
datum.Class.ToString( ));
ImageIndex = imageIndex;
SubItems.AddRange(new[]
{
datum.Class.ToString( ),
datum.Length.ToString( )
});
}
private void EditTag(TagDatum reference)
{
if (reference.Class == TagClass.Bitm)
{
}
if (reference.Class == TagClass.Scen || reference.Class == TagClass.Bloc ||
reference.Class == TagClass.Vehi || reference.Class == TagClass.Bipd ||
reference.Class == TagClass.Crea || reference.Class == TagClass.Ctrl ||
reference.Class == TagClass.Mach || reference.Class == TagClass.Unit ||
reference.Class == TagClass.Weap)
{
}
}
private List <VertexConstantInfo> GetVertexConstants(TagDatum vertexTag, CacheStream cache)
{
if (!cache.Index.Contains(vertexTag))
{
return(new List <VertexConstantInfo>( ));
}
var vertexConstantInfos = new List <VertexConstantInfo>( );
foreach (var tagDatum in cache.Index.Where(TagClass.Spas))
{
var block = ( ShaderPassBlock )cache.Deserialize(tagDatum.Identifier);
var usesVertex =
block.PostprocessDefinition[0].Implementations.Any(
u => u.VertexShader.Ident == vertexTag.Identifier);
if (!usesVertex)
{
continue;
}
foreach (var templateDatum in cache.Index.Where(TagClass.Stem))
{
var templateBlock = ( ShaderTemplateBlock )cache.Deserialize(templateDatum.Identifier);
var usesPass =
templateBlock.PostprocessDefinition[0].Passes.Any(
v => v.Pass.Ident == tagDatum.Identifier);
if (!usesPass)
{
continue;
}
foreach (var shaderDatum in cache.Index.Where(TagClass.Shad))
{
var shaderBlock = ( ShaderBlock )cache.Deserialize(shaderDatum.Identifier);
var usesTemplate = shaderBlock.Template.Ident == templateDatum.Identifier;
if (usesTemplate)
{
var items = GetVertexConstants(shaderBlock, templateBlock, block, vertexTag, tagDatum,
templateDatum,
shaderDatum, cache);
vertexConstantInfos.AddRange(items);
}
}
}
}
return(vertexConstantInfos);
}
private void DisplayVertexInstructions(TagDatum vertexDatum, CacheStream cache)
{
foreach (var documentsDockContent in documentsDockContents)
{
documentsDockContent.DockHandler.DockPanel = null;
documentsDockContent.Dispose( );
}
var vertexBlock = ( VertexShaderBlock )cache.Deserialize(vertexDatum.Identifier);
for (var i = 0; i < vertexBlock.GeometryClassifications.Length; i++)
{
var asmEditor = new AsmEditor($"vertex_{i}.glsl");
var code = vertexBlock.GeometryClassifications[i].Code;
var altCode = vertexBlock.GeometryClassifications[i].CompiledShader;
var strBuilder = new StringBuilder( );
foreach (var s in altCode)
{
strBuilder.Append("$ " + s + " ");
}
strBuilder.AppendLine( );
if (code.Length < 4)
{
asmEditor.SetText(strBuilder.ToString( ));
return;
}
using (var binaryReader = new BinaryReader(new MemoryStream(code)))
{
var version = binaryReader.ReadInt16( );
strBuilder.AppendLine("#" + version);
var instructionCount = binaryReader.ReadInt16( );
for (var index = 0; index < instructionCount; index++)
{
var instructionBytes = binaryReader.ReadBytes(16);
var instruction = new VertexProgramInstruction(instructionBytes);
strBuilder.AppendLine(instruction.ToAsm);
}
}
documentsDockContents.Add(asmEditor);
asmEditor.SetText(strBuilder.ToString( ));
asmEditor.Show(dockPanel1, DockState.Document);
}
}
public TagDatum Add <T>(T item, string tagName) where T : GuerillaBlock
{
var attribute = (TagClassAttribute)item.GetType().Attribute(typeof(TagClassAttribute)) ??
(TagClassAttribute)
item.GetType().BaseType?.GetCustomAttributes(typeof(TagClassAttribute)).FirstOrDefault();
var tagDatum = new TagDatum
{
Class = attribute?.TagClass ?? TagClass.Empty,
Identifier = new TagIdent(( short )Count, ( short )~Count),
Length = 0,
Path = tagName,
VirtualAddress = 0
};
tagDatums.Add(tagDatum);
items[tagDatum.Identifier] = item;
return(tagDatum);
}
public void Validate(TagDatum datum, Stream dataStream)
{
error = false;
_pointersList = new List <Tuple <BlamPointer, ElementArray> >();
_writeMessage = Console.WriteLine;
var offset = 0;
var definition =
new MoonfishTagGroup(Guerilla.h2Tags.First(x => x.Class == datum.Class));
var definitionPool = Guerilla.h2Tags.Select(x => new MoonfishTagGroup(x));
var elementArray = CompileElementArray(definition, definitionPool, offset);
elementArray.count = 1;
var binaryReader = new BinaryReader(dataStream);
var virtualTagMemory = new VirtualMappedAddress
{
Address = datum.VirtualAddress,
Length = datum.Length
};
_isValidDelegate = virtualTagMemory.Contains;
_isPointerOwnedByTagDelegate = virtualTagMemory.Contains;
offset = (int)dataStream.Seek(datum.VirtualAddress, SeekOrigin.Begin);
elementArray.virtualAddress = datum.VirtualAddress;
ValidateTagBlock(elementArray, elementArray.ToFixedArrayPointer(), binaryReader, ref offset);
if (error)
{
OnWriteMessage(string.Format("Tag ({0}.{1})", datum.Path, datum.Class.ToTokenString()));
}
}
private List <VertexConstantInfo> GetVertexConstants(ShaderBlock shaderBlock,
ShaderTemplateBlock shaderTemplateBlock,
ShaderPassBlock shaderPassBlock, TagDatum vrtxDatum, TagDatum spasDatum, TagDatum stemDatum,
TagDatum shaderDatum, CacheStream cache)
{
var vertexConstantInfos = new List <VertexConstantInfo>( );
var passes =
shaderTemplateBlock.PostprocessDefinition[0].Passes.Where(u => u.Pass.Ident == spasDatum.Identifier);
foreach (var pass in passes)
{
for (int i = pass.Implementations.Index; i < pass.Implementations.Index + pass.Implementations.Length; i++)
{
var index =
shaderTemplateBlock.PostprocessDefinition[0].Implementations[i].VertexConstants.Index;
var length =
shaderTemplateBlock.PostprocessDefinition[0].Implementations[i].VertexConstants.Length;
for (int j = index; j < index + length; j++)
{
var sourceIndex = shaderTemplateBlock.PostprocessDefinition[0].Remappings[j].SourceIndex;
var bytes = shaderTemplateBlock.PostprocessDefinition[0].Remappings[j].fieldskip;
var vertexConstant = shaderBlock.PostprocessDefinition[0].VertexConstants[sourceIndex];
var info = new VertexConstantInfo
{
source = sourceIndex,
bytes = bytes,
value = new Vector4(vertexConstant.Vector3, vertexConstant.W),
stringId = Halo2.Strings[new StringIdent(BitConverter.ToInt16(bytes, 0), 0)]
};
vertexConstantInfos.Add(info);
}
}
}
return(vertexConstantInfos);
}
public TagTreeNode(TagDatum tag)
{
Text = tag.Path;
Info = tag;
}
