//
public override void Open(HSDReader Reader)
{
var modelGroupOffset = Reader.ReadUInt32();
var modelGroupCount = Reader.ReadInt32();
var unk1GroupOffset = Reader.ReadUInt32();
var unk1GroupCount = Reader.ReadInt32();
var unk2GroupOffset = Reader.ReadUInt32();
var unk2GroupCount = Reader.ReadInt32();
var lightGroupOffset = Reader.ReadUInt32();
var lightGroupCount = Reader.ReadInt32();
var unk4GroupOffset = Reader.ReadUInt32();
var unk4GroupCount = Reader.ReadInt32();
var unk5GroupOffset = Reader.ReadUInt32();
var unk5GroupCount = Reader.ReadInt32();
for (int i = 0; i < modelGroupCount; i++)
{
Reader.Seek(modelGroupOffset + (uint)(12 * i));
SBM_GrMapModelGroup mg = new SBM_GrMapModelGroup();
mg.Open(Reader);
ModelGroups.Add(mg);
}
for (int i = 0; i < modelGroupCount; i++)
{
Reader.Seek(lightGroupOffset + (uint)(i * 8));
SBM_GrMapLight mg = new SBM_GrMapLight();
mg.Open(Reader);
Lights.Add(mg);
}
}
public override void Open(HSDReader Reader)
{
Type = Reader.ReadInt16();
int PathPointCount = Reader.ReadInt16();
Tension = Reader.ReadSingle();
uint PointTableOffset = Reader.ReadUInt32();
TotalLength = Reader.ReadSingle();
uint segmentLengthOffset = Reader.ReadUInt32();
if (Reader.ReadInt32() != 0) // this is a pointer to a float array of length 5?
{
Console.WriteLine("Resave not supported"); //throw new NotSupportedException("Dat not supported");
}
Reader.Seek(PointTableOffset);
for (int i = 0; i < PathPointCount; i++)
{
Points.Add(new GXVector3(Reader.ReadSingle(), Reader.ReadSingle(), Reader.ReadSingle()));
}
Reader.Seek(segmentLengthOffset);
for (int i = 0; i < PathPointCount; i++)
{
SegmentLengths.Add(Reader.ReadSingle());
}
}
public override void Open(HSDReader Reader)
{
var boneTableOffset = Reader.ReadUInt32();
var matrixTableOffset = Reader.ReadUInt32();
var count = Reader.ReadUInt32();
if (boneTableOffset != 0)
{
Reader.Seek(boneTableOffset);
for (int i = 0; i < count; i++)
{
BoneIDs.Add(Reader.ReadInt32());
}
}
if (matrixTableOffset != 0)
{
Reader.Seek(matrixTableOffset);
for (int i = 0; i < count; i++)
{
HSD_Matrix3x3 mat = new HSD_Matrix3x3();
mat.Open(Reader);
Matrices.Add(mat);
}
}
}
public override void Open(HSDReader Reader)
{
base.Open(Reader);
uint BaseOffset = Reader.Position();
GroupsUnk2_1D = new HSD_Array <KAR_GrUnk2_1DModel>(Size);
Reader.Seek(Offset);
GroupsUnk2_1D.Open(Reader);
Reader.Seek(BaseOffset);
}
public override void Open(HSDReader Reader)
{
base.Open(Reader);
uint BaseOffset = Reader.Position();
DOBJIndices.Clear();
Reader.Seek(Offset);
for (int i = 0; i < Size; i++)
{
DOBJIndices.Add(Reader.ReadUInt16());
}
Reader.Seek(BaseOffset);
}
public override void Open(HSDReader Reader)
{
var off = Reader.ReadUInt32();
while (off != 0)
{
var temp = Reader.Position();
Reader.Seek(off);
HSD_Light light = new HSD_Light();
light.Open(Reader);
Lights.Add(light);
Reader.Seek(temp);
off = Reader.ReadUInt32();
}
}
public override void Open(HSDReader Reader)
{
base.Open(Reader);
ImageArray = new HSD_PointerArray <HSD_IOBJ>()
{
SetSize = _imagecount
};
Reader.Seek(ImageArrayOffset);
ImageArray.Open(Reader);
TlutArray = new HSD_PointerArray <HSD_Tlut>()
{
SetSize = _tlutcount
};
Reader.Seek(TlutArrayOffset);
TlutArray.Open(Reader);
}
public override void Open(HSDReader Reader)
{
base.Open(Reader);
GroupsUnk2_1 = new HSD_Array <KAR_GrUnk2_1Model>(Size);
Reader.Seek(Offset);
GroupsUnk2_1.Open(Reader);
}
public override void Open(HSDReader Reader)
{
Vertices.Clear();
Links.Clear();
AreaTables.Clear();
var vertexOffset = Reader.ReadUInt32();
var vertexCount = Reader.ReadInt32();
var linkOffset = Reader.ReadUInt32();
var linkCount = Reader.ReadInt32();
Unknown1 = Reader.ReadInt32();
Unknown2 = Reader.ReadInt32();
Unknown3 = Reader.ReadInt16();
Unknown4 = Reader.ReadInt16();
Unknown5 = Reader.ReadInt16();
Unknown6 = Reader.ReadInt16();
Unknown7 = Reader.ReadInt32();
var polyOffset = Reader.ReadUInt32();
var polyCount = Reader.ReadInt32();
Unknown8 = Reader.ReadInt32();
Reader.Seek(vertexOffset);
for (int i = 0; i < vertexCount; i++)
{
var v = new SBM_GrCollVertex();
v.Open(Reader);
Vertices.Add(v);
}
Reader.Seek(linkOffset);
for (int i = 0; i < linkCount; i++)
{
var v = new SBM_GrCollLink();
v.Open(Reader);
Links.Add(v);
}
Reader.Seek(polyOffset);
for (int i = 0; i < polyCount; i++)
{
var v = new SBM_GrCollAreaTable();
v.Open(Reader);
AreaTables.Add(v);
}
}
public override void Open(HSDReader Reader)
{
base.Open(Reader);
Reader.Seek(SubActionOffset);
for (int i = 0; i < 0x146; i++)
{
SBM_FighterSubAction sa = new SBM_FighterSubAction();
sa.Open(Reader);
FightSubActions.Add(sa);
}
Reader.Seek(WinSubActionOffset);
for (int i = 0; i < 0xE; i++)
{
SBM_FighterSubAction sa = new SBM_FighterSubAction();
sa.Open(Reader);
WinSubActions.Add(sa);
}
}
public override void Open(HSDReader Reader)
{
var start = Reader.Position();
var count = Reader.ReadInt32();
for (int i = 0; i < count; i++)
{
var off = Reader.ReadUInt32();
var temp = Reader.Position();
Reader.Seek(start + off);
SBM_GrMapSpriteSheet sheet = new SBM_GrMapSpriteSheet();
sheet.Open(Reader, start);
Sheets.Add(sheet);
Reader.Seek(temp);
}
// there is sometimes padding with values in it
// there is a 0xC section that has 0, 0x20, and some number
}
public override void Open(HSDReader Reader)
{
if (Reader.ReadInt32() != 0)
{
throw new NotSupportedException("Yaku all not supported");
}
var off = Reader.ReadUInt32();
while (off != 0)
{
var temp = Reader.Position();
Reader.Seek(off);
SBM_YakuAllNode node = new SBM_YakuAllNode();
node.Open(Reader);
Nodes.Add(node);
Reader.Seek(temp);
off = Reader.ReadUInt32();
}
}
public override void Open(HSDReader Reader)
{
base.Open(Reader);
Reader.Seek(TableOffset);
for (int i = 0; i < TableCount; i++)
{
var table = new SBM_GrGroundParamTable();
table.Open(Reader);
Tables.Add(table);
}
}
public override void Open(HSDReader Reader)
{
var vertexOffset = Reader.ReadUInt32();
var vertexCount = Reader.ReadInt32();
var faceOffset = Reader.ReadUInt32();
var faceCount = Reader.ReadInt32();
var jointOffset = Reader.ReadUInt32();
var jointCount = Reader.ReadInt32();
var zonevertexOffset = Reader.ReadUInt32();
var zonevertexCount = Reader.ReadInt32();
var zonefaceOffset = Reader.ReadUInt32();
var zonefaceCount = Reader.ReadInt32();
var zonejointOffset = Reader.ReadUInt32();
var zonejointCount = Reader.ReadInt32();
Reader.Seek(vertexOffset);
for (int i = 0; i < vertexCount; i++)
{
Vertices.Add(new GXVector3(Reader.ReadSingle(), Reader.ReadSingle(), Reader.ReadSingle()));
}
Reader.Seek(faceOffset);
for (int i = 0; i < faceCount; i++)
{
KAR_CollisionTriangle tri = new KAR_CollisionTriangle();
tri.Open(Reader);
Faces.Add(tri);
}
Reader.Seek(jointOffset);
for (int i = 0; i < jointCount; i++)
{
KAR_CollisionJoint joint = new KAR_CollisionJoint();
joint.Open(Reader);
Joints.Add(joint);
}
Reader.Seek(zonevertexOffset);
for (int i = 0; i < zonevertexCount; i++)
{
ZoneVertices.Add(new GXVector3(Reader.ReadSingle(), Reader.ReadSingle(), Reader.ReadSingle()));
}
Reader.Seek(zonefaceOffset);
for (int i = 0; i < zonefaceCount; i++)
{
KAR_ZoneCollisionTriangle tri = new KAR_ZoneCollisionTriangle();
tri.Open(Reader);
ZoneFaces.Add(tri);
}
Reader.Seek(zonejointOffset);
for (int i = 0; i < zonejointCount; i++)
{
KAR_ZoneCollisionJoint joint = new KAR_ZoneCollisionJoint();
joint.Open(Reader);
ZoneJoints.Add(joint);
}
}
public override void Open(HSDReader Reader)
{
Type = Reader.ReadInt32();
if (Type == -1)
{
MatAnimJoint = Reader.ReadObject <HSD_MatAnimJoint>(Reader.ReadUInt32());
}
else
{
Reader.ReadInt32(); // nothing
}
FrameCount = Reader.ReadSingle();
uint TrackCountOffset = Reader.ReadUInt32();
uint TrackOffset = Reader.ReadUInt32();
Reader.Seek(TrackCountOffset);
List <byte> TrackCounts = new List <byte>();
byte TrackCount;
while ((TrackCount = Reader.ReadByte()) != 0xFF)
{
TrackCounts.Add(TrackCount);
}
int track = 0;
for (int i = 0; i < TrackCounts.Count; i++)
{
HSD_AnimNode Node = new HSD_AnimNode();
Nodes.Add(Node);
for (int j = 0; j < TrackCounts[i]; j++)
{
Reader.Seek((uint)(TrackOffset + 0xC * track++));
HSD_Track t = new HSD_Track();
t.Open(Reader);
Node.Tracks.Add(t);
}
}
}
public override void Open(HSDReader Reader)
{
var offset = Reader.ReadUInt32();
var count = Reader.ReadInt32();
for (int i = 0; i < count; i++)
{
Reader.Seek(offset + (uint)(i * 0x18));
var spline = new KAR_GrSpline();
spline.Open(Reader);
Splines.Add(spline);
}
}
public override void Open(HSDReader Reader)
{
var offset = Reader.ReadUInt32();
var count = Reader.ReadInt32();
uint[] offsets = new uint[count];
Reader.Seek(offset);
for (int i = 0; i < count; i++)
{
offsets[i] = Reader.ReadUInt32();
}
for (int i = 0; i < count; i++)
{
if (offsets[i] == 0)
{
continue;
}
Reader.Seek(offsets[i]);
var path = new HSD_Spline();
path.Open(Reader);
Paths.Add(path);
}
}
public override void Open(HSDReader Reader)
{
Reader.PrintPosition();
base.Open(Reader);
ViewRegion = new HSD_Array <KAR_GrViewRegion>(SizeUnk1_1);
Reader.Seek(OffsetUnk1_1);
ViewRegion.Open(Reader);
GroupsUnk1_2 = new HSD_Array <KAR_GrModel_ModelUnk1_2>(SizeUnk1_2);
Reader.Seek(OffsetUnk1_2);
GroupsUnk1_2.Open(Reader);
GroupsUnk1_3 = new HSD_Array <KAR_GrBoundingBox>(SizeUnk1_3);
Reader.Seek(OffsetUnk1_3);
GroupsUnk1_3.Open(Reader);
DOBJIndices.Clear();
Reader.Seek(OffsetUnk1_4);
for (int i = 0; i < SizeUnk1_4; i++)
{
DOBJIndices.Add(Reader.ReadUInt16());
}
}
public override void Open(HSDReader Reader)
{
var rootNodeOffset = Reader.ReadUInt32();
var offset = Reader.ReadUInt32();
var count = Reader.ReadInt32();
RootNode = Reader.ReadObject <HSD_JOBJ>(rootNodeOffset);
Reader.Seek(offset);
for (int i = 0; i < count; i++)
{
SBM_GrMapModelTable table = new SBM_GrMapModelTable();
table.Open(Reader);
Tables.Add(table);
}
}
public override void Open(HSDReader Reader)
{
var offset = Reader.ReadUInt32();
var count = Reader.ReadInt32();
if (offset == 0)
{
return;
}
Reader.Seek(offset);
for (int i = 0; i < count; i++)
{
Indices.Add(Reader.ReadInt32());
}
}
public override void Open(HSDReader Reader)
{
var start = Reader.Position();
for (int i = 0; i < 4; i++)
{
Reader.Seek(start + (uint)(8 * i));
KAR_GrCourseSplineTable table = new KAR_GrCourseSplineTable();
if (table.Indices.Count == 0)
{
break;
}
table.Open(Reader);
Tables.Add(table);
}
}
public override void Open(HSDReader Reader)
{
var off1 = Reader.ReadUInt32();
var count1 = Reader.ReadInt32();
var count2 = Reader.ReadInt32();
var count3 = Reader.ReadInt32();
for (int i = 0; i < count1; i++)
{
Reader.Seek(off1 + (uint)(0x48 * i));
var region = new KAR_GrFogRegion();
region.Open(Reader);
FogRegions.Add(region);
}
if (count2 != -1 || count3 != -1)
{
throw new NotSupportedException("Fog format not supported");
}
}
public override void Open(HSDReader Reader)
{
var dataoff = Reader.ReadUInt32();
var datacount = Reader.ReadInt32();
var datastaticoff = Reader.ReadUInt32();
var datastaticcount = Reader.ReadInt32();
var datacommonoff = Reader.ReadUInt32();
var datacommoncount = Reader.ReadInt32();
Reader.Seek(dataoff);
for (int i = 0; i < datacount; i++)
{
var off = Reader.ReadUInt32();
var temp = Reader.Position();
Reader.Seek(off);
var v = new KAR_GrYakumonoData();
v.Open(Reader);
YakuData.Add(v);
Reader.Seek(temp);
}
Reader.Seek(datastaticoff);
for (int i = 0; i < datastaticcount; i++)
{
var off = Reader.ReadUInt32();
var temp = Reader.Position();
Reader.Seek(off);
var v = new KAR_GrYakumonoData();
v.Open(Reader);
YakuStaticData.Add(v);
Reader.Seek(temp);
}
for (int i = 0; i < datacommoncount; i++)
{
Reader.Seek(datacommonoff + (uint)(i * 12));
var com = new KAR_GrYakumonoCommonData();
com.Open(Reader);
YakuCommonData.Add(com);
}
}
public override void Open(HSDReader Reader)
{
var partitionPointer = Reader.ReadUInt32();
var partitionCount = Reader.ReadInt16();
Reader.ReadInt16();
{
var temp = Reader.Position();
Reader.Seek(partitionPointer);
uint[] pointers = new uint[partitionCount];
for (int i = 0; i < partitionCount; i++)
{
pointers[i] = Reader.ReadUInt32();
}
for (int i = 0; i < partitionCount; i++)
{
Reader.Seek(pointers[i]);
KAR_GrPartition p = new KAR_GrPartition();
p.Open(Reader);
Partitions.Add(p);
}
Reader.Seek(temp);
}
// now for a few sections
// there are 5
// 1 - collidable triangles
// 2 - ? related to pads
// 3 - ?
// 4 - ?
// 5 - ?
// 32 Data Type
// 32 pointer
// 16 count
// 16 padding
{
var dataType = Reader.ReadInt32();
var pointer = Reader.ReadUInt32();
var count = Reader.ReadInt16();
Reader.ReadInt16();
var temp = Reader.Position();
Reader.Seek(pointer);
for (int i = 0; i < count; i++)
{
CollidableTriangles.Add(Reader.ReadInt16());
}
Reader.Seek(temp);
}
{ //TODO:
var dataType = Reader.ReadInt32();
var pointer = Reader.ReadUInt32();
var count = Reader.ReadInt16();
Reader.ReadInt16();
var temp = Reader.Position();
Reader.Seek(pointer);
for (int i = 0; i < count; i++)
{
UnknownIndices.Add(Reader.ReadInt16());
}
Reader.Seek(temp);
}
{ //TODO:
var dataType = Reader.ReadInt32();
var pointer = Reader.ReadUInt32();
var count = Reader.ReadInt16();
Reader.ReadInt16();
var temp = Reader.Position();
Reader.Seek(pointer);
for (int i = 0; i < count; i++)
{
UnknownIndices2.Add(Reader.ReadInt16());
}
Reader.Seek(temp);
}
{ //TODO:
var dataType = Reader.ReadInt32();
var pointer = Reader.ReadUInt32();
var count = Reader.ReadInt16();
Reader.ReadInt16();
}
{ //TODO:
var dataType = Reader.ReadInt32();
var pointer = Reader.ReadUInt32();
var count = Reader.ReadInt16();
Reader.ReadInt16();
}
if (Reader.ReadInt32() != 0)
{
throw new NotSupportedException("Dat format not supported");
}
// one more bool section, usually all false?
{ //TODO:
var dataType = Reader.ReadInt32();
var pointer = Reader.ReadUInt32();
var count = Reader.ReadInt16();
Reader.ReadInt16();
var temp = Reader.Position();
Reader.Seek(pointer);
// TODO: bit reader
Reader.Seek(temp);
}
}
public List <FOBJKey> GetKeys(float FrameCount = -1)
{
List <FOBJKey> Keys = new List <FOBJKey>();
int clock = 0;
Reader.Seek(0);
while (Reader.Position() < FOBJ.Data.Length)
{
int type = Reader.ExtendedByte();
InterpolationType interpolation = (InterpolationType)((type) & 0x0F);
int numOfKey = ((type >> 4)) + 1;
if (interpolation == 0)
{
break;
}
for (int i = 0; i < numOfKey; i++)
{
double value = 0;
double tan = 0;
int time = 0;
switch (interpolation)
{
case InterpolationType.Step:
value = ReadVal(Reader, FOBJ.ValueFormat, FOBJ.ValueScale);
time = Reader.ExtendedByte();
break;
case InterpolationType.Linear:
value = ReadVal(Reader, FOBJ.ValueFormat, FOBJ.ValueScale);
time = Reader.ExtendedByte();
break;
case InterpolationType.HermiteValue:
value = ReadVal(Reader, FOBJ.ValueFormat, FOBJ.ValueScale);
time = Reader.ExtendedByte();
break;
case InterpolationType.Hermite:
value = ReadVal(Reader, FOBJ.ValueFormat, FOBJ.ValueScale);
tan = ReadVal(Reader, FOBJ.TanFormat, FOBJ.TanScale);
time = Reader.ExtendedByte();
break;
case InterpolationType.HermiteCurve:
tan = ReadVal(Reader, FOBJ.TanFormat, FOBJ.TanScale);
break;
case InterpolationType.Constant:
value = ReadVal(Reader, FOBJ.ValueFormat, FOBJ.ValueScale);
break;
default:
throw new Exception("Unknown Interpolation Type " + interpolation.ToString("X"));
}
//Console.WriteLine(clock + " " + value + " " + FOBJ.ValueFormat );
FOBJKey kf = new FOBJKey();
kf.InterpolationType = interpolation;
kf.Value = (float)value;
kf.Frame = clock;
kf.Tan = (float)tan;
Keys.Add(kf);
clock += time;
}
}
return(Keys);
}
public static GXVertex[] GetDecodedVertices(GXPrimitiveGroup PrimitiveGroup, HSD_AttributeGroup Group)
{
// Create Vertex List
List <GXVertex> Vertices = new List <GXVertex>();
// Prepare vertex buffers for reading
Dictionary <GXVertexBuffer, HSDReader> Buffers = new Dictionary <GXVertexBuffer, HSDReader>();
foreach (GXVertexBuffer buffer in Group.Attributes)
{
Buffers.Add(buffer, buffer.DataBuffer == null ? null : new HSDReader(new MemoryStream(buffer.DataBuffer)));
}
// Decode
foreach (GXIndexGroup ig in PrimitiveGroup.Indices)
{
GXVertex Vertex = new GXVertex();
for (int i = 0; i < Group.Attributes.Count; i++)
{
GXVertexBuffer Attr = Group.Attributes[i];
HSDReader VertexBuffer = Buffers[Attr];
int index = ig.Indices[i];
float[] f = new float[0];
if (VertexBuffer != null)
{
VertexBuffer.Seek((uint)(Attr.Stride * index));
f = Read(VertexBuffer, Attr.CompType, Attr.Stride);
}
switch (Attr.Name)
{
case GXAttribName.GX_VA_PNMTXIDX:
Vertex.PMXID = (ushort)index;
break;
case GXAttribName.GX_VA_TEX0MTXIDX:
Vertex.TEX0MTXIDX = (ushort)index;
break;
case GXAttribName.GX_VA_POS:
Vertex.Pos.X = f[0] / (float)Math.Pow(2, Attr.Scale);
Vertex.Pos.Y = f[1] / (float)Math.Pow(2, Attr.Scale);
Vertex.Pos.Z = f[2] / (float)Math.Pow(2, Attr.Scale);
break;
case GXAttribName.GX_VA_NRM:
Vertex.Nrm.X = f[0] / (float)Math.Pow(2, Attr.Scale);
Vertex.Nrm.Y = f[1] / (float)Math.Pow(2, Attr.Scale);
Vertex.Nrm.Z = f[2] / (float)Math.Pow(2, Attr.Scale);
break;
case GXAttribName.GX_VA_TEX0:
Vertex.TEX0.X = f[0] / (float)Math.Pow(2, Attr.Scale);
Vertex.TEX0.Y = f[1] / (float)Math.Pow(2, Attr.Scale);
break;
case GXAttribName.GX_VA_TEX1:
Vertex.TEX1.X = f[0] / (float)Math.Pow(2, Attr.Scale);
Vertex.TEX1.Y = f[1] / (float)Math.Pow(2, Attr.Scale);
break;
case GXAttribName.GX_VA_CLR0:
if (Attr.AttributeType == GXAttribType.GX_DIRECT)
{
Vertex.Clr0.R = ig.Clr0[0] / 255f;
Vertex.Clr0.G = ig.Clr0[1] / 255f;
Vertex.Clr0.B = ig.Clr0[2] / 255f;
Vertex.Clr0.A = ig.Clr0[3] / 255f;
}
if (Attr.AttributeType == GXAttribType.GX_INDEX8)
{
Vertex.Clr0.R = f[0];
Vertex.Clr0.G = f[1];
Vertex.Clr0.B = f[2];
Vertex.Clr0.A = f[3];
}
break;
case GXAttribName.GX_VA_CLR1:
if (Attr.AttributeType == GXAttribType.GX_DIRECT)
{
Vertex.Clr1.R = ig.Clr1[0] / 255f;
Vertex.Clr1.G = ig.Clr1[1] / 255f;
Vertex.Clr1.B = ig.Clr1[2] / 255f;
Vertex.Clr1.A = ig.Clr1[3] / 255f;
}
if (Attr.AttributeType == GXAttribType.GX_INDEX8)
{
Vertex.Clr1.R = f[0];
Vertex.Clr1.G = f[1];
Vertex.Clr1.B = f[2];
Vertex.Clr1.A = f[3];
}
break;
default:
Console.WriteLine("To be implemented: " + Attr.Name);
break;
}
}
Vertices.Add(Vertex);
}
foreach (var b in Buffers)
{
if (b.Value != null)
{
b.Value.Dispose();
}
}
return(Vertices.ToArray());
}
