internal SdkMeshSubset(SdkMeshRawSubset rawSubset)
{
this.Name = rawSubset.Name;
this.MaterialIndex = rawSubset.MaterialIndex;
this.PrimitiveTopology = GetPrimitiveTopology(rawSubset.PrimitiveType);
this.IndexStart = (int)rawSubset.IndexStart;
this.IndexCount = (int)rawSubset.IndexCount;
this.VertexStart = (int)rawSubset.VertexStart;
this.VertexCount = (int)rawSubset.VertexCount;
}
internal static SdkMeshRawSubset Read(BinaryReader reader)
{
var subset = new SdkMeshRawSubset
{
Name = Encoding.UTF8.GetString(reader.ReadBytes(MaxSubsetName).TakeWhile(t => t != 0).ToArray()),
MaterialIndex = reader.ReadInt32(),
PrimitiveType = (SdkMeshPrimitiveType)reader.ReadInt64(),
IndexStart = reader.ReadInt64(),
IndexCount = reader.ReadInt64(),
VertexStart = reader.ReadInt64(),
VertexCount = reader.ReadInt64()
};
return(subset);
}
private void ComputeBoundingBox(SdkMeshRawFile rawFile, SdkMeshRawMesh rawMesh)
{
//this.BoundingBoxCenter = rawMesh.BoundingBoxCenter;
//this.BoundingBoxExtents = rawMesh.BoundingBoxExtents;
XMVector lower = XMVector.Replicate(float.MaxValue);
XMVector upper = XMVector.Replicate(float.MinValue);
int indsize;
if (rawFile.IndexBufferHeaders[rawMesh.IndexBuffer].IndexType == SdkMeshIndexType.IndexType32Bit)
{
indsize = 4;
}
else
{
indsize = 2;
}
for (int subset = 0; subset < rawMesh.NumSubsets; subset++)
{
SdkMeshRawSubset pSubset = rawFile.Subsets[rawMesh.SubsetsIndices[subset]];
SdkMeshPrimitiveType primType = pSubset.PrimitiveType;
Debug.Assert(primType == SdkMeshPrimitiveType.TriangleList, "Only triangle lists are handled.");
if (primType != SdkMeshPrimitiveType.TriangleList)
{
continue;
}
int indexCount = (int)pSubset.IndexCount;
int indexStart = (int)pSubset.IndexStart;
byte[] ind = rawFile.IndexBufferBytes[rawMesh.IndexBuffer];
byte[] verts = rawFile.VertexBufferBytes[rawMesh.VertexBuffers[0]];
int stride = (int)rawFile.VertexBufferHeaders[rawMesh.VertexBuffers[0]].StrideBytes;
for (int vertind = indexStart; vertind < indexStart + indexCount; vertind++)
{
int current_ind;
if (indsize == 2)
{
current_ind = BitConverter.ToInt16(ind, vertind * 2);
}
else
{
current_ind = BitConverter.ToInt32(ind, vertind * 4);
}
float x = BitConverter.ToSingle(verts, stride * current_ind);
float y = BitConverter.ToSingle(verts, stride * current_ind + 4);
float z = BitConverter.ToSingle(verts, stride * current_ind + 8);
lower = XMVector.Min(new XMVector(x, y, z, 1.0f), lower);
upper = XMVector.Max(new XMVector(x, y, z, 1.0f), upper);
}
}
XMVector half = upper - lower;
half *= 0.5f;
this.BoundingBoxCenter = lower + half;
this.BoundingBoxExtents = half;
}
public static SdkMeshRawFile FromStream(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
var file = new SdkMeshRawFile();
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
file.Header = SdkMeshRawHeader.Read(reader);
if (file.Header.Version != FileVersion)
{
throw new InvalidDataException();
}
if (stream.Position != file.Header.VertexStreamHeadersOffset)
{
throw new InvalidDataException();
}
stream.Seek(file.Header.VertexStreamHeadersOffset, SeekOrigin.Begin);
for (int i = 0; i < file.Header.NumVertexBuffers; i++)
{
SdkMeshRawVertexBufferHeader header = SdkMeshRawVertexBufferHeader.Read(reader);
file.VertexBufferHeaders.Add(header);
}
if (stream.Position != file.Header.IndexStreamHeadersOffset)
{
throw new InvalidDataException();
}
stream.Seek(file.Header.IndexStreamHeadersOffset, SeekOrigin.Begin);
for (int i = 0; i < file.Header.NumIndexBuffers; i++)
{
SdkMeshRawIndexBufferHeader header = SdkMeshRawIndexBufferHeader.Read(reader);
file.IndexBufferHeaders.Add(header);
}
if (stream.Position != file.Header.MeshDataOffset)
{
throw new InvalidDataException();
}
stream.Seek(file.Header.MeshDataOffset, SeekOrigin.Begin);
for (int i = 0; i < file.Header.NumMeshes; i++)
{
SdkMeshRawMesh mesh = SdkMeshRawMesh.Read(reader);
file.Meshes.Add(mesh);
}
if (stream.Position != file.Header.SubsetDataOffset)
{
throw new InvalidDataException();
}
stream.Seek(file.Header.SubsetDataOffset, SeekOrigin.Begin);
for (int i = 0; i < file.Header.NumTotalSubsets; i++)
{
SdkMeshRawSubset subset = SdkMeshRawSubset.Read(reader);
file.Subsets.Add(subset);
}
if (stream.Position != file.Header.FrameDataOffset)
{
throw new InvalidDataException();
}
stream.Seek(file.Header.FrameDataOffset, SeekOrigin.Begin);
for (int i = 0; i < file.Header.NumFrames; i++)
{
SdkMeshRawFrame frame = SdkMeshRawFrame.Read(reader);
file.Frames.Add(frame);
}
if (stream.Position != file.Header.MaterialDataOffset)
{
throw new InvalidDataException();
}
stream.Seek(file.Header.MaterialDataOffset, SeekOrigin.Begin);
for (int i = 0; i < file.Header.NumMaterials; i++)
{
SdkMeshRawMaterial material = SdkMeshRawMaterial.Read(reader);
file.Materials.Add(material);
}
foreach (SdkMeshRawMesh mesh in file.Meshes)
{
if (stream.Position != mesh.SubsetOffset)
{
throw new InvalidDataException();
}
stream.Seek(mesh.SubsetOffset, SeekOrigin.Begin);
for (int i = 0; i < mesh.NumSubsets; i++)
{
int index = reader.ReadInt32();
mesh.SubsetsIndices.Add(index);
}
if (stream.Position != mesh.FrameInfluenceOffset)
{
throw new InvalidDataException();
}
stream.Seek(mesh.FrameInfluenceOffset, SeekOrigin.Begin);
for (int i = 0; i < mesh.NumFrameInfluences; i++)
{
int index = reader.ReadInt32();
mesh.FrameInfluencesIndices.Add(index);
}
}
if (stream.Position != file.Header.HeaderSize + file.Header.NonBufferDataSize)
{
throw new InvalidDataException();
}
foreach (SdkMeshRawVertexBufferHeader buffer in file.VertexBufferHeaders)
{
stream.Seek(buffer.DataOffset, SeekOrigin.Begin);
byte[] bytes = reader.ReadBytes((int)buffer.SizeBytes);
file.VertexBufferBytes.Add(bytes);
}
foreach (SdkMeshRawIndexBufferHeader buffer in file.IndexBufferHeaders)
{
stream.Seek(buffer.DataOffset, SeekOrigin.Begin);
byte[] bytes = reader.ReadBytes((int)buffer.SizeBytes);
file.IndexBufferBytes.Add(bytes);
}
}
return(file);
}
