public static DependencyReader CreateReader(this ICacheFile cache, IAddressTranslator translator, Stream stream, bool leaveOpen)
{
var reader = new DependencyReader(stream, cache.ByteOrder, leaveOpen);
reader.RegisterInstance(cache);
reader.RegisterInstance(translator);
if (cache.CacheType >= CacheType.Halo2Xbox)
{
reader.RegisterType(() => new Matrix4x4
{
M11 = reader.ReadSingle(),
M12 = reader.ReadSingle(),
M13 = reader.ReadSingle(),
M21 = reader.ReadSingle(),
M22 = reader.ReadSingle(),
M23 = reader.ReadSingle(),
M31 = reader.ReadSingle(),
M32 = reader.ReadSingle(),
M33 = reader.ReadSingle(),
M41 = reader.ReadSingle(),
M42 = reader.ReadSingle(),
M43 = reader.ReadSingle(),
});
}
return(reader);
}
public BlockCollection(DependencyReader reader, MetadataHeader metadata)
{
this.metadata = metadata;
reader.Seek(16, SeekOrigin.Current);
blockCount = reader.ReadUInt32();
}
public MetadataHeader(DependencyReader reader)
{
reader.RegisterInstance(this);
Header = reader.ReadObject <TagHeader>();
Dependencies = reader.ReadEnumerable <TagDependency>(Header.DependencyCount).ToList();
DataBlocks = reader.ReadEnumerable <DataBlock>(Header.DataBlockCount).ToList();
StructureDefinitions = reader.ReadEnumerable <TagStructureDefinition>(Header.TagStructureCount).ToList();
DataReferences = reader.ReadEnumerable <DataBlockReference>(Header.DataReferenceCount).ToList();
TagReferences = reader.ReadEnumerable <TagBlockReference>(Header.TagReferenceCount).ToList();
StringIds = reader.ReadEnumerable <StringId>(Header.StringIdCount).ToList();
stringTable = new List <string>(StringIds.Count);
stringsByOffset = new Dictionary <int, int>(StringIds.Count);
stringsByHash = new Dictionary <uint, int>(StringIds.Count);
var startPos = reader.BaseStream.Position;
while (reader.BaseStream.Position < startPos + Header.StringTableSize)
{
var relative = reader.BaseStream.Position - startPos;
var currentValue = reader.ReadNullTerminatedString();
stringsByOffset.Add((int)relative, stringTable.Count);
var hash = MurMur3.Hash32(currentValue);
if (!stringsByHash.ContainsKey(hash))
{
stringsByHash.Add(hash, stringTable.Count);
}
stringTable.Add(currentValue);
}
}
public DependencyReader CreateReader()
{
var fs = new FileStream(FileName, FileMode.Open, FileAccess.Read);
var reader = new DependencyReader(fs, ByteOrder.LittleEndian);
return(reader);
}
public void ExtractCodeDependencies_NamespaceMatch()
{
var reader = new DependencyReader();
var dependency = reader.ExtractCodeDependencies(FileText);
dependency.Namespace.ShouldBe("Omnia.Behaviours.T99.Internal.System");
}
public static IIndexItem GetShaderDiffuse(TagReference tagRef, DependencyReader reader)
{
if (tagRef.Tag == null)
{
return(null);
}
int offset;
switch (tagRef.Tag.ClassCode)
{
case "soso":
offset = 176;
break;
case "senv":
offset = 148;
break;
case "sgla":
offset = 356;
break;
case "schi":
offset = 228;
break;
case "scex":
offset = 900;
break;
case "swat":
case "smet":
offset = 88;
break;
default: return(null);
}
reader.Seek(tagRef.Tag.MetaPointer.Address + offset, SeekOrigin.Begin);
var bitmId = reader.ReadInt16();
if (bitmId == -1)
{
return(null);
}
else
{
return(tagRef.Tag.CacheFile.TagIndex[bitmId]);
}
}
public CompressedVertex(DependencyReader reader)
{
Position = new RealVector3D(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Normal = new HenDN3(reader.ReadUInt32());
Binormal = new HenDN3(reader.ReadUInt32());
Tangent = new HenDN3(reader.ReadUInt32());
TexCoords = new RealVector2D(reader.ReadInt16() / (float)short.MaxValue, reader.ReadInt16() / (float)short.MaxValue);
NodeIndex1 = (short)(reader.ReadByte() / 3);
NodeIndex2 = (short)(reader.ReadByte() / 3);
var node0Weight = reader.ReadUInt16() / (float)short.MaxValue;
NodeWeights = new RealVector2D(node0Weight, 1 - node0Weight);
}
public BlockCollection(DependencyReader reader, ICacheFile cache, IAddressTranslator translator, IPointerExpander expander)
: base(reader, cache, translator, expander)
{
if (IsInvalid)
{
return;
}
reader.BaseStream.Position = Pointer.Address;
for (int i = 0; i < Count; i++)
{
items.Add((T)reader.ReadObject(typeof(T), (int)cache.CacheType));
}
}
public void ExtractFileDependencies_Successfully()
{
var reader = new DependencyReader();
var references = reader.ExtractFileDependencies(@"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>net472</TargetFramework>
<AssemblyTitle>MySystem.External.MyCompany</AssemblyTitle>
<AssemblyVersion>1.0.1</AssemblyVersion>
<FileVersion>1.0.1</FileVersion>
</PropertyGroup>
<PropertyGroup>
<OutputPath>$(ProjectDir)bin</OutputPath>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=""Google.Protobuf"" Version=""3.6.1"" />
<PackageReference Include=""Microsoft.AspNet.WebApi.Client"" Version=""5.2.6"" />
<PackageReference Include=""Newtonsoft.Json"" Version=""12.0.3"" />
<PackageReference Include=""Omnia.Libraries.Infrastructure.Connector.Client"" Version=""3.0.237"" />
<PackageReference Include=""Omnia.Libraries.Infrastructure.Behaviours"" Version=""3.0.118"" />
<PackageReference Include=""Microsoft.Extensions.DependencyInjection"" Version=""3.1.3"" />
<PackageReference Include=""Microsoft.Extensions.Http"" Version=""3.1.3"" />
<PackageReference Include=""Microsoft.CSharp"" Version=""4.5.0"" />
</ItemGroup>
<ItemGroup>
<Compile Include=""..\..\_common\**\*.*"" LinkBase=""_common"" />
</ItemGroup>
<ItemGroup>
<Reference Include=""MyCompany"">
<HintPath>C:\Program Files (x86)\Common Files\MyCompany\MyCompany.dll</HintPath>
</Reference>
</ItemGroup>
</Project>");
references.Count.ShouldBe(1);
var reference = references.First();
reference.AssemblyName.ShouldBe("MyCompany");
reference.Path.ShouldBe(@"C:\Program Files (x86)\Common Files\MyCompany\MyCompany.dll");
}
public DataPointer(DependencyReader reader, ICacheFile cache)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (cache == null)
{
throw new ArgumentNullException(nameof(cache));
}
_value = reader.ReadInt32();
_cache = cache;
}
public ResourceIdentifier(DependencyReader reader, ICacheFile cache)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (cache == null)
{
throw new ArgumentNullException(nameof(cache));
}
this.cache = cache;
identifier = reader.ReadInt32();
}
private DependencyReader CreateReader(string fileName, IAddressTranslator translator)
{
var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
var reader = new DependencyReader(fs, ByteOrder);
reader.RegisterInstance <CacheFile>(this);
reader.RegisterInstance <ICacheFile>(this);
if (translator != null)
{
reader.RegisterInstance <IAddressTranslator>(translator);
}
return(reader);
}
public void ExtractCodeDependencies_Successfully()
{
var reader = new DependencyReader();
var data = reader.ExtractCodeDependencies(FileText);
data.Expression.ShouldNotBeNull();
data.Expression.ShouldBe(@"using MyCompany;
namespace CodeDependencies
{
public class MyDto
{
public string Name { get; set; }
}
}");
}
public TagBlock(DependencyReader reader, ICacheFile cache, IAddressTranslator translator, IPointerExpander expander)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (translator == null)
{
throw new ArgumentNullException(nameof(translator));
}
Count = reader.ReadInt32();
Pointer = new Pointer(reader.ReadInt32(), translator, expander);
IsInvalid = Count <= 0 || Pointer.Address < 0 || Pointer.Address >= reader.BaseStream.Length;
}
internal DependencyReader CreateReader(Stream stream)
{
var reader = new DependencyReader(stream, ByteOrder.LittleEndian);
//verify header when reading a module file
if (stream is FileStream)
{
var header = reader.PeekInt32();
if (header != ModuleHeader)
{
throw Exceptions.NotAValidMapFile(FileName);
}
}
reader.RegisterInstance(this);
return(reader);
}
internal void LoadBlocks(int currentBlock, long collectionOffset, DependencyReader reader)
{
if (blockCount == 0)
{
return;
}
var structdef = metadata.StructureDefinitions.First(s => s.FieldBlock == currentBlock && s.FieldOffset == collectionOffset);
if (structdef.TargetIndex < 0)
{
return;
}
var block = metadata.DataBlocks[structdef.TargetIndex];
var blockSize = FixedSizeAttribute.ValueFor(typeof(T));
reader.Seek(block.Offset, SeekOrigin.Begin);
for (int i = 0; i < blockCount; i++)
{
Add(reader.ReadObject <T>());
}
var blockProps = typeof(T).GetProperties()
.Where(p => p.PropertyType.IsGenericType && p.PropertyType.GetGenericTypeDefinition() == typeof(BlockCollection <>));
int index = 0;
foreach (var item in this)
{
var adjustedBase = blockSize * index++;
foreach (var prop in blockProps)
{
var collection = prop.GetValue(item) as IBlockCollection;
var offset = OffsetAttribute.ValueFor(prop);
collection.LoadBlocks(structdef.TargetIndex, adjustedBase + offset, reader);
}
}
}
internal void ReadItems(DependencyReader reader)
{
if (items.Any())
{
throw new InvalidOperationException();
}
for (int i = 0; i < TagCount; i++)
{
reader.Seek(cache.Header.IndexAddress + HeaderSize + i * 32, SeekOrigin.Begin);
var item = reader.ReadObject(new IndexItem(cache));
items.Add(item);
if (CacheFactory.SystemClasses.Contains(item.ClassCode))
{
sysItems.Add(item.ClassCode, item);
}
reader.Seek(item.FileNamePointer.Address, SeekOrigin.Begin);
Filenames.Add(item.Id, reader.ReadNullTerminatedString());
}
}
public DdsImage ToDds(int index)
{
if (index < 0 || index >= Bitmaps.Count)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
var submap = Bitmaps[index];
var dir = Directory.GetParent(cache.FileName).FullName;
var bitmapSource = Path.Combine(dir, CacheFile.BitmapsMap);
//Xbox maps and player-made CE maps use internal bitmap resources
if (cache.CacheType == CacheType.Halo1Xbox ||
cache.CacheType == CacheType.Halo1CE && item.MetaPointer.Address > 0)
{
bitmapSource = cache.FileName;
}
byte[] data;
using (var fs = new FileStream(bitmapSource, FileMode.Open, FileAccess.Read))
using (var reader = new DependencyReader(fs, ByteOrder.LittleEndian))
{
reader.Seek(submap.PixelsOffset, SeekOrigin.Begin);
data = reader.ReadBytes(submap.PixelsSize);
}
//not sure if this works, haven't seen any Halo1 bitmaps with the swizzle flag
//if (submap.Flags.HasFlag(BitmapFlags.Swizzled))
//{
// var bpp = submap.BitmapFormat.Bpp();
// data = TextureUtils.Swizzle(data, submap.Width, submap.Height, 1, bpp);
//}
return(TextureUtils.GetDds(submap.Height, submap.Width, submap.BitmapFormat, submap.BitmapType == TextureType.CubeMap, data));
}
public BlockCollection(DependencyReader reader, ICacheFile cache, IAddressTranslator translator)
: this(reader, cache, translator, null)
{
}
public static IEnumerable <GeometryMaterial> GetMaterials(IEnumerable <TagReference> shaderRefs, DependencyReader reader)
{
foreach (var shaderRef in shaderRefs)
{
var bitmTag = GetShaderDiffuse(shaderRef, reader);
if (bitmTag == null)
{
yield return(null);
continue;
}
yield return(new GeometryMaterial
{
Name = Utils.GetFileName(shaderRef.Tag.FullPath),
Submaterials = new List <ISubmaterial>
{
new SubMaterial
{
Usage = MaterialUsage.Diffuse,
Bitmap = bitmTag.ReadMetadata <bitmap>(),
Tiling = new RealVector2D(1, 1)
}
}
});
}
}
void IBlockCollection.LoadBlocks(int currentBlock, long collectionOffset, DependencyReader itemReader) => LoadBlocks(currentBlock, collectionOffset, itemReader);
private IEnumerable <GeometryMesh> ReadPCMeshes(DependencyReader reader)
{
var tagIndex = cache.TagIndex as ITagIndexGen1;
if (tagIndex == null)
{
throw new NotSupportedException();
}
foreach (var section in Sections)
{
var indices = new List <int>();
var vertices = new List <UncompressedVertex>();
var submeshes = new List <IGeometrySubmesh>();
foreach (var submesh in section.Submeshes)
{
var gSubmesh = new GeometrySubmesh
{
MaterialIndex = submesh.ShaderIndex,
IndexStart = indices.Count,
IndexLength = submesh.IndexCount + 2
};
submeshes.Add(gSubmesh);
reader.Seek(tagIndex.VertexDataOffset + tagIndex.IndexDataOffset + submesh.IndexOffset, SeekOrigin.Begin);
indices.AddRange(reader.ReadEnumerable <ushort>(gSubmesh.IndexLength).Select(i => i + vertices.Count));
reader.Seek(tagIndex.VertexDataOffset + submesh.VertexOffset, SeekOrigin.Begin);
var vertsTemp = reader.ReadEnumerable <UncompressedVertex>(submesh.VertexCount).ToList();
if (UScale != 1 || VScale != 1)
{
vertsTemp.ForEach((v) =>
{
var vec = v.TexCoords;
vec.X *= UScale;
vec.Y *= VScale;
v.TexCoords = vec;
});
}
if (Flags.HasFlag(ModelFlags.UseLocalNodes))
{
var address = section.Submeshes.Pointer.Address;
address += section.Submeshes.IndexOf(submesh) * 132;
reader.Seek(address + 107, SeekOrigin.Begin);
var nodeCount = reader.ReadByte();
var nodes = reader.ReadEnumerable <byte>(nodeCount).ToArray();
vertsTemp.ForEach((v) =>
{
v.NodeIndex1 = nodes[v.NodeIndex1];
v.NodeIndex2 = nodes[v.NodeIndex2];
});
}
vertices.AddRange(vertsTemp);
}
yield return(new GeometryMesh
{
IndexFormat = IndexFormat.TriangleStrip,
VertexWeights = VertexWeights.Skinned,
Indicies = indices.ToArray(),
Vertices = vertices.ToArray(),
Submeshes = submeshes
});
}
}
private IEnumerable <GeometryMesh> ReadXboxMeshes(DependencyReader reader)
{
var tagIndex = cache.TagIndex as ITagIndexGen1;
if (tagIndex == null)
{
throw new NotSupportedException();
}
foreach (var section in Sections)
{
var indices = new List <int>();
var vertices = new List <CompressedVertex>();
var submeshes = new List <IGeometrySubmesh>();
foreach (var submesh in section.Submeshes)
{
if (submesh.IndexCount == 0 || submesh.VertexCount == 0)
{
continue;
}
try
{
var gSubmesh = new GeometrySubmesh
{
MaterialIndex = submesh.ShaderIndex,
IndexStart = indices.Count,
IndexLength = submesh.IndexCount + 2
};
submeshes.Add(gSubmesh);
reader.Seek(submesh.IndexOffset - tagIndex.Magic, SeekOrigin.Begin);
reader.ReadInt32();
reader.Seek(reader.ReadInt32() - tagIndex.Magic, SeekOrigin.Begin);
var indicesTemp = reader.ReadEnumerable <ushort>(gSubmesh.IndexLength).ToList();
indices.AddRange(indicesTemp.Select(i => i + vertices.Count));
reader.Seek(submesh.VertexOffset - tagIndex.Magic, SeekOrigin.Begin);
reader.ReadInt32();
reader.Seek(reader.ReadInt32() - tagIndex.Magic, SeekOrigin.Begin);
var vertsTemp = new List <CompressedVertex>();
for (int i = 0; i < submesh.VertexCount; i++)
{
vertsTemp.Add(new CompressedVertex(reader));
}
if (UScale != 1 || VScale != 1)
{
vertsTemp.ForEach((v) =>
{
var vec = v.TexCoords;
vec.X *= UScale;
vec.Y *= VScale;
v.TexCoords = vec;
});
}
//if (Flags.HasFlag(ModelFlags.UseLocalNodes))
//{
// var address = section.Submeshes.Pointer.Address;
// address += section.Submeshes.IndexOf(submesh) * 208;
// reader.Seek(address + 107, SeekOrigin.Begin);
// var nodeCount = reader.ReadByte();
// var nodes = reader.ReadEnumerable<byte>(nodeCount).ToArray();
// vertsTemp.ForEach((v) =>
// {
// v.NodeIndex1 = nodes[v.NodeIndex1];
// v.NodeIndex2 = nodes[v.NodeIndex2];
// });
//}
vertices.AddRange(vertsTemp);
}
catch { }
}
yield return(new GeometryMesh
{
IndexFormat = IndexFormat.TriangleStrip,
VertexWeights = VertexWeights.Skinned,
Indicies = indices.ToArray(),
Vertices = vertices.ToArray(),
Submeshes = submeshes
});
}
}
