public VBIB(IKeyValueCollection data) : this()
{
var vertexBuffers = data.GetArray("m_vertexBuffers");
foreach (var vb in vertexBuffers)
{
var vertexBuffer = BufferDataFromDATA(vb);
var decompressedSize = vertexBuffer.ElementCount * vertexBuffer.ElementSizeInBytes;
if (vertexBuffer.Data.Length != decompressedSize)
{
vertexBuffer.Data = MeshOptimizerVertexDecoder.DecodeVertexBuffer((int)vertexBuffer.ElementCount, (int)vertexBuffer.ElementSizeInBytes, vertexBuffer.Data);
}
VertexBuffers.Add(vertexBuffer);
}
var indexBuffers = data.GetArray("m_indexBuffers");
foreach (var ib in indexBuffers)
{
var indexBuffer = BufferDataFromDATA(ib);
var decompressedSize = indexBuffer.ElementCount * indexBuffer.ElementSizeInBytes;
if (indexBuffer.Data.Length != decompressedSize)
{
indexBuffer.Data = MeshOptimizerIndexDecoder.DecodeIndexBuffer((int)indexBuffer.ElementCount, (int)indexBuffer.ElementSizeInBytes, indexBuffer.Data);
}
IndexBuffers.Add(indexBuffer);
}
}
public Element(VertexBuffers owner, Definition parent, IO.XmlStream s) : base(parent, s)
{
UsageIndex = 0;
string TypeStr = null;
s.ReadAttribute("type", ref TypeStr);
s.ReadAttribute("declUsage", ref DeclarationUsage);
s.ReadAttributeOpt("usageIndex", 10, ref UsageIndex);
TypeBase t;
if (TypeStr[0] == '0')
{
t = owner.TypeFind(Convert.ToInt16(TypeStr, 16));
}
else
{
t = owner.TypeFind(TypeStr);
}
if (t != null)
{
this.Type = t as Type;
}
else
{
throw new Debug.ExceptionLog("'{0}' isn't a defined type (Owner: {1}/{2})", TypeStr, parent.Opcode.ToString("X2"), parent.Name);
}
}
public Definition(VertexBuffers owner, IO.XmlStream s) : base(owner, s)
{
//s.ReadAttribute("size", 16, ref Size);
if (s.Cursor.ChildNodes.Count > 0)
{
var elems = new List <Element>(s.Cursor.ChildNodes.Count);
foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name != "element")
{
continue;
}
s.SaveCursor(node);
elems.Add(new Element(owner, this, s));
s.RestoreCursor();
}
elems.TrimExcess();
Elements = elems.ToArray();
foreach (Element e in Elements)
{
Size += GetElementSize(e);
}
}
}
public override void Save(SaveContext saveContext)
{
var utility = saveContext.Utility;
base.Save(saveContext);
utility.Write(Flags);
saveContext.WritePointerPlaceholder(BoundingBox);
PositionOffset.Write(utility);
saveContext.WriteObjectListPointerPlaceholder(SubMeshes);
utility.Write(BaseAddress);
saveContext.WriteObjectListPointerPlaceholder(VertexBuffers);
saveContext.WritePointerPlaceholder(BlendShape);
/////////////////////////////
// Begin saving dependent data
saveContext.SaveAndMarkReference(SubMeshes);
saveContext.SaveAndMarkReference(VertexBuffers);
saveContext.SaveAndMarkReference(BoundingBox);
SubMeshes.SaveList(saveContext);
VertexBuffers.SaveList(saveContext);
saveContext.SaveAndMarkReference(BlendShape);
}
public Element(VertexBuffers owner, Definition parent, IO.XmlStream s) : base(parent, s)
{
string temp = string.Empty;
s.ReadAttribute("type", ref temp);
Type t = owner.TypeFind(temp) as Type;
if (t != null)
{
this.Type = t;
}
else
{
throw new Debug.ExceptionLog("'{0}' isn't a defined type (Owner: {1}/{2})", temp, parent.Opcode.ToString("X2"), parent.Name);
}
if (base.DeclarationType == DeclarationType.Skip)
{
s.ReadAttribute("usageIndex", 10, ref UsageIndex);
}
else
{
UsageIndex = 0;
}
}
public void ClearState()
{
PrimitiveTopology.InitializeState();
VertexBuffers.InitializeState();
IndexBuffer.InitializeState();
IndexBufferFormat.InitializeState();
InputElements.InitializeState();
}
public void ResetTracking()
{
PrimitiveTopology.ResetTracking();
VertexBuffers.ResetTracking();
IndexBuffer.ResetTracking();
IndexBufferFormat.ResetTracking();
// InputElements.ResetTracking(); // reset nicht hier, weil in VertexShader gesetzt
}
/// <summary>
/// Function to reset the states for the input assembler.
/// </summary>
internal void Reset()
{
_graphics.Context.InputAssembler.SetIndexBuffer(null, GI.Format.Unknown, 0);
VertexBuffers.Reset();
_graphics.Context.InputAssembler.PrimitiveTopology = (PrimitiveTopology.TriangleList);
_graphics.Context.InputAssembler.InputLayout = null;
_indexBuffer = null;
_inputLayout = null;
_primitiveType = PrimitiveType.TriangleList;
}
protected DefinitionBase(VertexBuffers owner, IO.XmlStream s)
{
if (!s.ReadAttributeOpt("name", ref Name))
{
Name = string.Empty;
}
s.ReadAttribute("opcode", 16, ref Opcode);
if (Name == "")
{
Name = Opcode.ToString();
}
}
public Element(VertexBuffers owner, Definition parent, IO.XmlStream s) : base(parent, s)
{
UsageIndex = 0;
string TypeStr = null;
s.ReadAttribute("type", ref TypeStr);
s.ReadAttributeOpt("usageIndex", 10, ref UsageIndex);
Type t = owner.TypeFind(TypeStr) as Type;
if (t != null) this.Type = t;
else throw new Debug.ExceptionLog("'{0}' isn't a defined type (Owner: {1}/{2})", TypeStr, parent.Opcode.ToString("X2"), parent.Name);
}
private void Update(EvaluationContext context)
{
var resourceManager = ResourceManager.Instance();
var device = resourceManager.Device;
var deviceContext = device.ImmediateContext;
var iaStage = deviceContext.InputAssembler;
InputLayout.GetValue(context);
VertexBuffers.GetValues(ref _vertexBuffer, context);
IndexBuffer.GetValue(context);
_prevTopology = iaStage.PrimitiveTopology;
iaStage.PrimitiveTopology = PrimitiveTopology.GetValue(context);
}
// Find apropriate vertex buffer and create it if doesn't exist
public NVRVertexBuffer GetVertexBuffer(int vertexToAddCount, NVRVertexType type)
{
foreach (NVRVertexBuffer buffer in VertexBuffers)
{
if (buffer.Type == type && buffer.Vertices.Count < (UInt16.MaxValue - vertexToAddCount))
{
return(buffer);
}
}
NVRVertexBuffer created = new NVRVertexBuffer(type);
VertexBuffers.Add(created);
return(created);
}
private void GLControl_Load(object sender, EventArgs e)
{
// Set Clear Color
GL.ClearColor(Color4.Black);
_program = ShaderProgram.InitializeAndGetID(
"Shaders/VertexShader.glsl",
"Shaders/FragmentShader.glsl");
Vector3 eyePos = new Vector3(3f, 3f, 7f);
Vector3 targetPos = new Vector3(0f, 0f, 0f);
_camera = new Camera(_program, eyePos, targetPos);
// Set the vertex information
_amountOfVertices = VertexBuffers.InitVBOsAndGetAmountOfVertices(_program);
}
protected override void DefinitionsRead(VertexBuffers owner, IO.XmlStream s)
{
Definitions = new List <Definition>(s.Cursor.ChildNodes.Count);
foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name != "definition")
{
continue;
}
s.SaveCursor(node);
Definitions.Add(new Definition(owner, s));
s.RestoreCursor();
}
Definitions.TrimExcess();
}
bool ReadVertexBufferHack(Blam.CacheFile c,
geometry_block_info_struct gbi)
{
var rsrc_cache = Program.Halo2.FromLocation(c as Halo2.CacheFile, gbi.GetBlockOffset());
// the shared cache isn't loaded, break
if (rsrc_cache == null)
{
return(false);
}
// seek to the actual data
var er = rsrc_cache.InputStream;
er.Seek(gbi.GetBlockOffset().Offset + 8);
VertexBuffers.Add();
VertexBuffers.Read(er);
return(true);
}
public override void Read(BinaryReader reader, Resource resource)
{
reader.BaseStream.Position = Offset;
var vertexBufferOffset = reader.ReadUInt32();
var vertexBufferCount = reader.ReadUInt32();
var indexBufferOffset = reader.ReadUInt32();
var indexBufferCount = reader.ReadUInt32();
reader.BaseStream.Position = Offset + vertexBufferOffset;
for (var i = 0; i < vertexBufferCount; i++)
{
var vertexBuffer = ReadOnDiskBufferData(reader);
var decompressedSize = vertexBuffer.ElementCount * vertexBuffer.ElementSizeInBytes;
if (vertexBuffer.Data.Length != decompressedSize)
{
vertexBuffer.Data = MeshOptimizerVertexDecoder.DecodeVertexBuffer((int)vertexBuffer.ElementCount, (int)vertexBuffer.ElementSizeInBytes, vertexBuffer.Data);
}
VertexBuffers.Add(vertexBuffer);
}
reader.BaseStream.Position = Offset + 8 + indexBufferOffset; //8 to take into account vertexOffset / count
for (var i = 0; i < indexBufferCount; i++)
{
var indexBuffer = ReadOnDiskBufferData(reader);
var decompressedSize = indexBuffer.ElementCount * indexBuffer.ElementSizeInBytes;
if (indexBuffer.Data.Length != decompressedSize)
{
indexBuffer.Data = MeshOptimizerIndexDecoder.DecodeIndexBuffer((int)indexBuffer.ElementCount, (int)indexBuffer.ElementSizeInBytes, indexBuffer.Data);
}
IndexBuffers.Add(indexBuffer);
}
}
public Definition(VertexBuffers owner, IO.XmlStream s) : base(owner, s)
{
//s.ReadAttribute("size", 16, ref Size);
if (s.Cursor.ChildNodes.Count > 0)
{
var elems = new List<Element>(s.Cursor.ChildNodes.Count);
foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name != "element") continue;
s.SaveCursor(node);
elems.Add(new Element(owner, this, s));
s.RestoreCursor();
}
elems.TrimExcess();
Elements = elems.ToArray();
foreach (Element e in Elements) Size += GetElementSize(e);
}
}
public void Dispose()
{
VertexBuffers.ForEach(x => x.Dispose());
IndexBuffers.ForEach(x => x.Dispose());
IndirectBuffers.ForEach(x => x.Dispose());
}
private void CommitCurrentBuffers()
{
if (!_inBuffer)
{
return;
}
_device.Unmap(_currentVertexBuffer);
_device.Unmap(_currentIndexBuffer);
var numInd = _currentIndirectArguments.Count;
var indSize = Unsafe.SizeOf <IndirectDrawIndexedArguments>();
if (numInd == 0)
{
// No indirect arguments, this buffer is empty.
_currentVertexBuffer.Dispose();
_currentIndexBuffer.Dispose();
_currentVertexMap = _currentIndexMap = default(MappedResource);
_currentIndexBuffer = _currentVertexBuffer = null;
_currentVertexOffset = _currentIndexOffset = 0;
_currentIndirectArguments = null;
_inBuffer = false;
return;
}
var bufferGroups = new List <BufferGroup>();
var indirectBuffer = new IndirectIndirectBuffer(_device, numInd * indSize);
uint indirOffset = 0;
foreach (var g in _currentIndirectArguments.GroupBy(x => new { x.Pipeline, x.Camera, x.HasTransparency, x.Binding }))
{
if (g.Key.HasTransparency)
{
foreach (var ia in g)
{
indirectBuffer.Update(indirOffset * indSize, ia.Arguments);
var bg = new BufferGroup(ia.Pipeline, ia.Camera, ia.Location, ia.Binding, indirOffset, 1);
bufferGroups.Add(bg);
indirOffset += 1;
}
}
else
{
var indir = g.Select(x => x.Arguments).ToArray();
var indirCount = (uint)indir.Length;
indirectBuffer.Update(indirOffset * indSize, indir);
var bg = new BufferGroup(g.Key.Pipeline, g.Key.Camera, g.Key.Binding, indirOffset, indirCount);
bufferGroups.Add(bg);
indirOffset += indirCount;
}
}
VertexBuffers.Add(_currentVertexBuffer);
IndexBuffers.Add(_currentIndexBuffer);
IndirectBuffers.Add(indirectBuffer);
IndirectBufferGroups.Add(bufferGroups);
#if DEBUG
AllocationInformation.Add(new BufferAllocation(_currentVertexBuffer.SizeInBytes, _currentVertexOffset, _currentIndexBuffer.SizeInBytes, _currentIndexOffset));
#endif
_currentVertexMap = _currentIndexMap = default(MappedResource);
_currentIndexBuffer = _currentVertexBuffer = null;
_currentVertexOffset = _currentIndexOffset = 0;
_currentIndirectArguments = null;
_inBuffer = false;
}
public Element(VertexBuffers owner, Definition parent, IO.XmlStream s) : base(parent, s)
{
string temp = string.Empty;
s.ReadAttribute("type", ref temp);
Type t = owner.TypeFind(temp) as Type;
if (t != null) this.Type = t;
else throw new Debug.ExceptionLog("'{0}' isn't a defined type (Owner: {1}/{2})", temp, parent.Opcode.ToString("X2"), parent.Name);
if (base.DeclarationType == DeclarationType.Skip)
s.ReadAttribute("usageIndex", 10, ref UsageIndex);
else
UsageIndex = 0;
}
/// <summary></summary>
/// <param name="c"></param>
/// <param name="section_info">Can be null if tag data doesn't have it</param>
/// <param name="gbi"></param>
/// <returns></returns>
internal bool Reconstruct(Blam.CacheFile c,
global_geometry_section_info_struct section_info,
geometry_block_info_struct gbi)
{
int index = 0;
int x;
byte[][] data = gbi.GeometryBlock;
if (data == null)
{
return(false);
}
foreach (geometry_block_resource_block gb in gbi.Resources)
{
using (IO.EndianReader er = new BlamLib.IO.EndianReader(data[index]))
{
switch (gb.Type.Value)
{
#region TagBlock
case (int)geometry_block_resource_type.TagBlock:
int count = gb.GetCount();
switch (gb.PrimaryLocater.Value)
{
case OffsetParts:
Parts.Resize(count);
Parts.Read(er);
break;
case OffsetSubparts:
Subparts.Resize(count);
Subparts.Read(er);
break;
case OffsetVisibilityBounds:
VisibilityBounds.Resize(count);
VisibilityBounds.Read(er);
break;
case OffsetStripIndices:
StripIndices.Resize(count);
StripIndices.Read(er);
break;
case OffsetMoppReorderTable:
MoppReorderTable.Resize(count);
MoppReorderTable.Read(er);
break;
case OffsetVertexBuffers:
VertexBuffers.Resize(count);
VertexBuffers.Read(er);
break;
}
break;
#endregion
#region TagData
case (int)geometry_block_resource_type.TagData:
switch (gb.PrimaryLocater.Value)
{
case OffsetVisibilityMoppCode:
VisibilityMoppCode.Reset(er.ReadBytes(gb.Size));
break;
}
break;
#endregion
#region VertexBuffer
case (int)geometry_block_resource_type.VertexBuffer:
var vb_defs = (c.TagIndexManager as InternalCacheTagIndex).kVertexBuffers;
var stream_readers = new Render.VertexBufferInterface.StreamReader[VertexBuffers.Count];
for (x = 0; x < VertexBuffers.Count; x++)
{
VertexBuffers[x].VertexBuffer.InitializeStreamReader(vb_defs, out stream_readers[x]);
}
if (RawVertices.Count == 0)
{
int vertex_count = section_info != null ?
section_info.TotalVertexCount :
gb.Size.Value / VertexBuffers[0].VertexBuffer.StrideSize;
RawVertices.Resize(vertex_count);
}
for (x = 0; x < RawVertices.Count; x++)
{
RawVertices[x].Reconstruct(section_info, gb,
er, stream_readers);
}
break;
#endregion
}
}
index++;
}
VertexBuffers.DeleteAll();
return(true);
}
bool ReconstructRawPcaData(Blam.CacheFile c,
geometry_block_info_struct gbi)
{
int index = 0;
int x;
byte[][] data = gbi.GeometryBlock;
if (data == null)
{
return(false);
}
foreach (geometry_block_resource_block gb in gbi.Resources)
{
using (IO.EndianReader er = new BlamLib.IO.EndianReader(data[index]))
{
switch (gb.Type.Value)
{
#region TagBlock
case (int)geometry_block_resource_type.TagBlock:
int count = gb.GetCount();
switch (gb.PrimaryLocater.Value)
{
case OffsetVertexBuffers:
VertexBuffers.Resize(count);
VertexBuffers.Read(er);
break;
}
break;
#endregion
#region VertexBuffer
case (int)geometry_block_resource_type.VertexBuffer:
var vb_defs = (c.TagIndexManager as InternalCacheTagIndex).kVertexBuffers;
// HACK: Figure out why we PRT stores the vertex buffer in the geometry block info's
// "section data" and not in a tag block resource
if (VertexBuffers.Count == 0 && !ReadVertexBufferHack(c, gbi))
{
break;
}
var stream_readers = new Render.VertexBufferInterface.StreamReader[VertexBuffers.Count];
for (x = 0; x < VertexBuffers.Count; x++)
{
VertexBuffers[x].VertexBuffer.InitializeStreamReader(vb_defs, out stream_readers[x]);
}
int vertex_count = gb.Size.Value / VertexBuffers[0].VertexBuffer.StrideSize;
if (RawPcaData.Count == 0)
{
RawPcaData.Resize(vertex_count * 5); // 5x as there are 5 fields in the Pca data
}
for (x = 0; x < vertex_count; x++)
{
ReconstructRawPcaData(x, gb, er, stream_readers);
}
break;
#endregion
}
}
index++;
}
VertexBuffers.DeleteAll();
return(true);
}
internal bool Reconstruct(Blam.CacheFile c,
lightmap_vertex_buffer_bucket_block buffer_bucket,
geometry_block_info_struct gbi)
{
int index = 0;
int x;
byte[][] data = gbi.GeometryBlock;
if (data == null)
{
return(false);
}
foreach (geometry_block_resource_block gb in gbi.Resources)
{
using (IO.EndianReader er = new BlamLib.IO.EndianReader(data[index]))
{
switch (gb.Type.Value)
{
#region TagBlock
case (int)geometry_block_resource_type.TagBlock:
int count = gb.GetCount();
switch (gb.PrimaryLocater.Value)
{
case OffsetVertexBuffers:
VertexBuffers.Resize(count);
VertexBuffers.Read(er);
break;
}
break;
#endregion
#region VertexBuffer
case (int)geometry_block_resource_type.VertexBuffer:
var vb_defs = (c.TagIndexManager as InternalCacheTagIndex).kVertexBuffers;
var stream_readers = new Render.VertexBufferInterface.StreamReader[VertexBuffers.Count];
for (x = 0; x < VertexBuffers.Count; x++)
{
VertexBuffers[x].VertexBuffer.InitializeStreamReader(vb_defs, out stream_readers[x]);
}
int vertex_count = gb.Size.Value / VertexBuffers[0].VertexBuffer.StrideSize;
if (buffer_bucket.RawVertices.Count == 0)
{
buffer_bucket.RawVertices.Resize(vertex_count);
}
for (x = 0; x < vertex_count; x++)
{
buffer_bucket.RawVertices[x].Reconstruct(buffer_bucket, gb,
er, stream_readers);
}
break;
#endregion
}
}
index++;
}
VertexBuffers.DeleteAll();
return(true);
}
protected abstract void DefinitionsRead(VertexBuffers owner, IO.XmlStream s);
protected override void DefinitionsRead(VertexBuffers owner, IO.XmlStream s)
{
Definitions = new List<Definition>(s.Cursor.ChildNodes.Count);
foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name != "definition") continue;
s.SaveCursor(node);
Definitions.Add(new Definition(owner, s));
s.RestoreCursor();
}
Definitions.TrimExcess();
}
public override void Read(BinaryReader reader, Resource resource)
{
reader.BaseStream.Position = Offset;
var vertexBufferOffset = reader.ReadUInt32();
var vertexBufferCount = reader.ReadUInt32();
var indexBufferOffset = reader.ReadUInt32();
var indexBufferCount = reader.ReadUInt32();
reader.BaseStream.Position = Offset + vertexBufferOffset;
for (var i = 0; i < vertexBufferCount; i++)
{
var vertexBuffer = default(VertexBuffer);
vertexBuffer.Count = reader.ReadUInt32(); //0
vertexBuffer.Size = reader.ReadUInt32(); //4
var decompressedSize = vertexBuffer.Count * vertexBuffer.Size;
var refA = reader.BaseStream.Position;
var attributeOffset = reader.ReadUInt32(); //8
var attributeCount = reader.ReadUInt32(); //12
//TODO: Read attributes in the future
var refB = reader.BaseStream.Position;
var dataOffset = reader.ReadUInt32(); //16
var totalSize = reader.ReadUInt32(); //20
vertexBuffer.Attributes = new List <VertexAttribute>();
reader.BaseStream.Position = refA + attributeOffset;
for (var j = 0; j < attributeCount; j++)
{
var previousPosition = reader.BaseStream.Position;
var attribute = default(VertexAttribute);
attribute.Name = reader.ReadNullTermString(Encoding.UTF8).ToUpperInvariant();
// Offset is always 40 bytes from the start
reader.BaseStream.Position = previousPosition + 36;
attribute.Type = (DXGI_FORMAT)reader.ReadUInt32();
attribute.Offset = reader.ReadUInt32();
// There's unusual amount of padding in attributes
reader.BaseStream.Position = previousPosition + 56;
vertexBuffer.Attributes.Add(attribute);
}
reader.BaseStream.Position = refB + dataOffset;
var vertexBufferBytes = reader.ReadBytes((int)totalSize);
if (totalSize == decompressedSize)
{
vertexBuffer.Buffer = vertexBufferBytes;
}
else
{
vertexBuffer.Buffer = MeshOptimizerVertexDecoder.DecodeVertexBuffer((int)vertexBuffer.Count, (int)vertexBuffer.Size, vertexBufferBytes);
}
VertexBuffers.Add(vertexBuffer);
reader.BaseStream.Position = refB + 4 + 4; //Go back to the vertex array to read the next iteration
}
reader.BaseStream.Position = Offset + 8 + indexBufferOffset; //8 to take into account vertexOffset / count
for (var i = 0; i < indexBufferCount; i++)
{
var indexBuffer = default(IndexBuffer);
indexBuffer.Count = reader.ReadUInt32(); //0
indexBuffer.Size = reader.ReadUInt32(); //4
var decompressedSize = indexBuffer.Count * indexBuffer.Size;
var unknown1 = reader.ReadUInt32(); //8
var unknown2 = reader.ReadUInt32(); //12
var refC = reader.BaseStream.Position;
var dataOffset = reader.ReadUInt32(); //16
var dataSize = reader.ReadUInt32(); //20
reader.BaseStream.Position = refC + dataOffset;
if (dataSize == decompressedSize)
{
indexBuffer.Buffer = reader.ReadBytes((int)dataSize);
}
else
{
indexBuffer.Buffer = MeshOptimizerIndexDecoder.DecodeIndexBuffer((int)indexBuffer.Count, (int)indexBuffer.Size, reader.ReadBytes((int)dataSize));
}
IndexBuffers.Add(indexBuffer);
reader.BaseStream.Position = refC + 4 + 4; //Go back to the index array to read the next iteration.
}
}
protected abstract void DefinitionsRead(VertexBuffers owner, IO.XmlStream s);
protected DefinitionBase(VertexBuffers owner, IO.XmlStream s)
{
if (!s.ReadAttributeOpt("name", ref Name)) Name = string.Empty;
s.ReadAttribute("opcode", 16, ref Opcode);
if (Name == "") Name = Opcode.ToString();
}
public override void Read(BinaryReader reader, Resource resource)
{
reader.BaseStream.Position = Offset;
var vertexOffset = reader.ReadUInt32();
var vertexCount = reader.ReadUInt32();
var indexOffset = reader.ReadUInt32();
var indexCount = reader.ReadUInt32();
reader.BaseStream.Position = Offset + vertexOffset;
for (var i = 0; i < vertexCount; i++)
{
var vertexBuffer = default(VertexBuffer);
vertexBuffer.Count = reader.ReadUInt32(); //0
vertexBuffer.Size = reader.ReadUInt32(); //4
var decompressedSize = vertexBuffer.Count * vertexBuffer.Size;
var refA = reader.BaseStream.Position;
var attributeOffset = reader.ReadUInt32(); //8
var attributeCount = reader.ReadUInt32(); //12
//TODO: Read attributes in the future
var refB = reader.BaseStream.Position;
var dataOffset = reader.ReadUInt32(); //16
var totalSize = reader.ReadUInt32(); //20
// TODO: underlords has compressed buffers
if (totalSize != decompressedSize)
{
throw new NotImplementedException($"Vertex buffer totalSize ({totalSize}) != decompressedSize ({decompressedSize})");
}
vertexBuffer.Attributes = new List <VertexAttribute>();
reader.BaseStream.Position = refA + attributeOffset;
for (var j = 0; j < attributeCount; j++)
{
var previousPosition = reader.BaseStream.Position;
var attribute = default(VertexAttribute);
attribute.Name = reader.ReadNullTermString(Encoding.UTF8);
// Offset is always 40 bytes from the start
reader.BaseStream.Position = previousPosition + 36;
attribute.Type = (DXGI_FORMAT)reader.ReadUInt32();
attribute.Offset = reader.ReadUInt32();
// There's unusual amount of padding in attributes
reader.BaseStream.Position = previousPosition + 56;
vertexBuffer.Attributes.Add(attribute);
}
reader.BaseStream.Position = refB + dataOffset;
vertexBuffer.Buffer = reader.ReadBytes((int)totalSize);
VertexBuffers.Add(vertexBuffer);
reader.BaseStream.Position = refB + 4 + 4; //Go back to the vertex array to read the next iteration
}
reader.BaseStream.Position = Offset + 8 + indexOffset; //8 to take into account vertexOffset / count
for (var i = 0; i < indexCount; i++)
{
var indexBuffer = default(IndexBuffer);
indexBuffer.Count = reader.ReadUInt32(); //0
indexBuffer.Size = reader.ReadUInt32(); //4
var decompressedSize = indexBuffer.Count * indexBuffer.Size;
var unknown1 = reader.ReadUInt32(); //8
var unknown2 = reader.ReadUInt32(); //12
var refC = reader.BaseStream.Position;
var dataOffset = reader.ReadUInt32(); //16
var dataSize = reader.ReadUInt32(); //20
if (dataSize != decompressedSize)
{
throw new NotImplementedException($"Index buffer dataSize ({dataSize}) != decompressedSize ({decompressedSize})");
}
reader.BaseStream.Position = refC + dataOffset;
indexBuffer.Buffer = reader.ReadBytes((int)dataSize);
IndexBuffers.Add(indexBuffer);
reader.BaseStream.Position = refC + 4 + 4; //Go back to the index array to read the next iteration.
}
}
public StreamReader(VertexBuffers.DefinitionBase stream_def)
{
definition = stream_def;
if (UsesNullDefinition) return;
elements = stream_def.GetElements();
declTypes = new DeclarationTypes.IDeclType[elements.Length];
streamedElements = new LowLevel.Math.real_quaternion[elements.Length];
for (int x = 0; x < elements.Length; x++)
{
var dt = (declTypes[x] = elements[x].DeclarationType.AllocateDeclType());
if (dt is DeclarationTypes.Skip)
(dt as DeclarationTypes.Skip).ByteCount = elements[x].GetUsageData();
}
}
public override void Read(BinaryReader reader, Resource resource)
{
reader.BaseStream.Position = Offset;
var vertexOffset = reader.ReadUInt32();
var vertexCount = reader.ReadUInt32();
reader.BaseStream.Position = Offset + vertexOffset;
for (var i = 0; i < vertexCount; i++)
{
var vertexBuffer = default(VertexBuffer);
vertexBuffer.Count = reader.ReadUInt32(); //0
vertexBuffer.Size = reader.ReadUInt32(); //4
var refA = reader.BaseStream.Position;
var attributeOffset = reader.ReadUInt32(); //8
var attributeCount = reader.ReadUInt32(); //12
//TODO: Read attributes in the future
var refB = reader.BaseStream.Position;
var dataOffset = reader.ReadUInt32(); //16
var totalSize = reader.ReadUInt32(); //20
vertexBuffer.Attributes = new List <VertexAttribute>();
reader.BaseStream.Position = refA + attributeOffset;
for (var j = 0; j < attributeCount; j++)
{
var previousPosition = reader.BaseStream.Position;
var attribute = default(VertexAttribute);
attribute.Name = reader.ReadNullTermString(Encoding.UTF8);
// Offset is always 40 bytes from the start
reader.BaseStream.Position = previousPosition + 36;
attribute.Type = (DXGI_FORMAT)reader.ReadUInt32();
attribute.Offset = reader.ReadUInt32();
// There's unusual amount of padding in attributes
reader.BaseStream.Position = previousPosition + 56;
vertexBuffer.Attributes.Add(attribute);
}
reader.BaseStream.Position = refB + dataOffset;
vertexBuffer.Buffer = reader.ReadBytes((int)vertexBuffer.Count * (int)vertexBuffer.Size);
VertexBuffers.Add(vertexBuffer);
reader.BaseStream.Position = refB + 4 + 4; //Go back to the vertex array to read the next iteration
//if(i > 0)break; // TODO: Read only first buffer
}
reader.BaseStream.Position = Offset + 4 + 4; //We are back at the header.
var indexOffset = reader.ReadUInt32();
var indexCount = reader.ReadUInt32();
reader.BaseStream.Position = Offset + 8 + indexOffset; //8 to take into account vertexOffset / count
for (var i = 0; i < indexCount; i++)
{
var indexBuffer = default(IndexBuffer);
indexBuffer.Count = reader.ReadUInt32(); //0
indexBuffer.Size = reader.ReadUInt32(); //4
var unknown1 = reader.ReadUInt32(); //8
var unknown2 = reader.ReadUInt32(); //12
var refC = reader.BaseStream.Position;
var dataOffset = reader.ReadUInt32(); //16
var dataSize = reader.ReadUInt32(); //20
reader.BaseStream.Position = refC + dataOffset;
indexBuffer.Buffer = reader.ReadBytes((int)indexBuffer.Count * (int)indexBuffer.Size);
IndexBuffers.Add(indexBuffer);
reader.BaseStream.Position = refC + 4 + 4; //Go back to the index array to read the next iteration.
//if(i > 0)break; // TODO: Read only first buffer
}
}
