public void WriteEffectNormals(FileWriter writer, HsfFile header)
{
if (Meshes.Count == 0)
{
return;
}
List <EffectMesh> readMeshes = new List <EffectMesh>();
var ObjectsSorted = Objects.OrderBy(x => x.VertexIndex).ToList();
for (int i = 0; i < ObjectsSorted.Count; i++)
{
if (ObjectsSorted[i].VertexIndex >= 0 && Meshes.Count > ObjectsSorted[i].VertexIndex)
{
var effectMesh = Meshes[ObjectsSorted[i].VertexIndex];
int index = Objects.IndexOf(ObjectsSorted[i]);
if (!readMeshes.Contains(effectMesh))
{
writer.Align(0x20);
effectMesh.NormalOffset = (uint)writer.Position;
for (int j = 0; j < effectMesh.Normals.Count; j++)
{
writer.Write(effectMesh.Normals[j]);
}
readMeshes.Add(effectMesh);
}
var obj = Objects[index];
obj.NormalsOffset = (int)effectMesh.NormalOffset;
}
}
}
public override void Read(FileReader reader, HsfFile header)
{
Attributes = reader.ReadMultipleStructs <AttributeData>(this.Count);
for (int i = 0; i < Attributes.Count; i++)
{
AttributeNames.Add(header.GetString(reader, Attributes[i].NameOffset));
}
}
public override void Read(FileReader reader, HsfFile header)
{
Objects = reader.ReadMultipleStructs <ObjectData>(this.Count);
for (int i = 0; i < Objects.Count; i++)
{
ObjectNames.Add(header.GetString(reader, Objects[i].StringOffset));
}
}
public override void Read(FileReader reader, HsfFile header)
{
List <ComponentData> Components = reader.ReadMultipleStructs <ComponentData>(this.Count);
long pos = reader.Position;
var ExtOffset = pos;
foreach (var att in Components)
{
ExtOffset += att.DataCount * 48;
}
foreach (var comp in Components)
{
List <PrimitiveObject> primatives = new List <PrimitiveObject>();
reader.SeekBegin(pos + comp.DataOffset);
for (int i = 0; i < comp.DataCount; i++)
{
var prim = new PrimitiveObject();
primatives.Add(prim);
prim.Type = (PrimitiveType)reader.ReadUInt16();
prim.Flags = reader.ReadUInt16();
prim.MaterialIndex = prim.Flags & 0xFFF;
prim.FlagValue = prim.Flags >> 12;
int primCount = 3;
if (prim.Type == PrimitiveType.Triangle || prim.Type == PrimitiveType.Quad)
{
primCount = 4;
}
prim.Vertices = reader.ReadMultipleStructs <VertexGroup>(primCount).ToArray();
if (prim.Type == PrimitiveType.TriangleStrip)
{
primCount = reader.ReadInt32();
var offset = reader.ReadUInt32();
var temp = reader.Position;
reader.Position = ExtOffset + offset * 8;
var verts = reader.ReadMultipleStructs <VertexGroup>(primCount).ToArray();
reader.Position = temp;
prim.TriCount = prim.Vertices.Length;
var newVert = new VertexGroup[prim.Vertices.Length + primCount + 1];
//Copy the first 3 group to the full vertex group
Array.Copy(prim.Vertices, 0, newVert, 0, prim.Vertices.Length);
//Make the 4th group set as the second group
newVert[3] = newVert[1];
//Copy the rest of the groups in the strip
Array.Copy(verts, 0, newVert, prim.Vertices.Length + 1, verts.Length);
prim.Vertices = newVert;
}
prim.NbtData = reader.ReadVec3();
}
header.AddPrimitiveComponent(Components.IndexOf(comp), primatives);
}
}
public override void Write(FileWriter writer, HsfFile header)
{
for (int i = 0; i < Objects.Count; i++)
{
var obj = Objects[i];
obj.StringOffset = (uint)header.GetStringOffset(ObjectNames[i]);
writer.WriteStruct(obj);
}
}
public override void Write(FileWriter writer, HsfFile header)
{
for (int i = 0; i < Attributes.Count; i++)
{
var mat = Attributes[i];
mat.NameOffset = (uint)header.GetStringOffset(AttributeNames[i]);
writer.WriteStruct(mat);
}
writer.Align(4);
}
public override void Write(FileWriter writer, HsfFile header)
{
for (int i = 0; i < header.Materials.Count; i++)
{
var mat = header.Materials[i];
mat.MaterialData.NameOffset = (uint)header.GetStringOffset(mat.Name);
writer.WriteStruct(mat.MaterialData);
}
writer.Align(4);
}
public override void Read(FileReader reader, HsfFile header)
{
List <MaterialObject> Materials = reader.ReadMultipleStructs <MaterialObject>(this.Count);
for (int i = 0; i < Materials.Count; i++)
{
string name = header.GetString(reader, Materials[i].NameOffset);
header.AddMaterial(Materials[i], name);
}
}
internal void ReadEffectMeshes(FileReader reader, HsfFile header)
{
var primitives = header.GetPrimitiveList();
//Read additional custom effect meshes
List <uint> readMeshes = new List <uint>();
for (int i = 0; i < Objects.Count; i++)
{
if (Objects[i].PositionsOffset == 0 || Objects[i].VertexIndex < 0 ||
readMeshes.Contains((uint)Objects[i].PositionsOffset))
{
continue;
}
EffectMesh mesh = new EffectMesh();
mesh.ObjectParent = Objects[i];
Meshes.Add(mesh);
if (Objects[i].FaceIndex != -1 && Objects[i].FaceIndex < primitives.Count)
{
mesh.Primitive = primitives[Objects[i].FaceIndex];
}
readMeshes.Add((uint)Objects[i].PositionsOffset);
var comp = header.PositionData.Components[Objects[i].VertexIndex];
mesh.Name = header.GetString(reader, comp.StringOffset);
using (reader.TemporarySeek(Objects[i].PositionsOffset, System.IO.SeekOrigin.Begin))
{
for (int j = 0; j < comp.DataCount; j++)
{
mesh.Positions.Add(reader.ReadVec3());
}
}
if (Objects[i].NormalIndex >= 0)
{
var normalData = header.NormalData.Components[Objects[i].NormalIndex];
using (reader.TemporarySeek(Objects[i].NormalsOffset, System.IO.SeekOrigin.Begin))
{
for (int j = 0; j < normalData.DataCount; j++)
{
mesh.Normals.Add(reader.ReadVec3());
}
}
}
}
}
internal T ReadSection <T>(FileReader reader, HsfFile header) where T : HSFSection, new()
{
T instance = new T();
instance.Offset = reader.ReadUInt32();
instance.Count = reader.ReadUInt32();
if (instance.Offset == 0)
{
return(instance);
}
using (reader.TemporarySeek(instance.Offset, System.IO.SeekOrigin.Begin)) {
instance.Read(reader, header);
}
return(instance);
}
public override void Read(FileReader reader, HsfFile header)
{
Components = reader.ReadMultipleStructs <ComponentData>(this.Count);
long startingOffset = reader.Position;
TypeFlag = DataType.Float;
if (Components.Count >= 2)
{
var pos = startingOffset + Components[0].DataOffset + Components[0].DataCount * 3;
if (pos % 0x20 != 0)
{
pos += 0x20 - (pos % 0x20);
}
if (Components[1].DataOffset == pos - startingOffset)
{
TypeFlag = DataType.Sbyte;
}
}
else
{
TypeFlag = DataType.Sbyte;
}
foreach (var comp in Components)
{
reader.SeekBegin(startingOffset + comp.DataOffset);
var normals = new List <Vector3>();
for (int i = 0; i < comp.DataCount; i++)
{
if (TypeFlag == DataType.Sbyte)
{
normals.Add(new Vector3(
reader.ReadSByte() / (float)sbyte.MaxValue,
reader.ReadSByte() / (float)sbyte.MaxValue,
reader.ReadSByte() / (float)sbyte.MaxValue));
}
else
{
normals.Add(new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()));
}
}
header.AddNormalComponent(Components.IndexOf(comp), normals);
}
}
public override void Write(FileWriter writer, HsfFile header)
{
var meshes = header.Meshes.Where(x => x.Positions.Count > 0).ToList();
long posStart = writer.Position;
foreach (var mesh in meshes)
{
writer.Write(header.GetStringOffset(mesh.Name));
writer.Write(mesh.Normals.Count);
writer.Write(uint.MaxValue);
}
if (meshes.Count == 1)
{
TypeFlag = DataType.Sbyte;
}
long dataPos = writer.Position;
for (int i = 0; i < meshes.Count; i++)
{
meshes[i].ObjectData.NormalIndex = i;
writer.Align(0x20);
writer.WriteUint32Offset(posStart + 8 + (i * 12), dataPos);
for (int j = 0; j < meshes[i].Normals.Count; j++)
{
if (TypeFlag == DataType.Sbyte)
{
writer.Write((sbyte)(meshes[i].Normals[j].X * sbyte.MaxValue));
writer.Write((sbyte)(meshes[i].Normals[j].Y * sbyte.MaxValue));
writer.Write((sbyte)(meshes[i].Normals[j].Z * sbyte.MaxValue));
}
else
{
writer.Write(meshes[i].Normals[j]);
}
}
}
writer.Align(4);
}
