/// <summary>
/// Reads keyframes at an address, starting with the keyframe array header.
/// </summary>
/// <param name="kf">The array to set decoded frames to.</param>
/// <param name="dataAddr">The address of the keyframe array header.</param>
public static void DecodeKeyframes(KeyframeArray kf, VoidPtr dataAddr)
{
SCN0KeyframesHeader *header = (SCN0KeyframesHeader *)dataAddr;
SCN0KeyframeStruct * entry = header->Data;
for (int i = 0; i < header->_numFrames; i++, entry++)
{
kf.SetFrameValue((int)entry->_index, entry->_value, true)._tangent = entry->_tangent;
}
}
protected override bool OnInitialize()
{
base.OnInitialize();
starts = new List <SCN0Keyframe>();
ends = new List <SCN0Keyframe>();
colors = new List <RGBAPixel>();
flags = (SCN0FogFlags)Data->_flags;
density = Data->_density;
if (Name != "<null>")
{
if (flags.HasFlag(SCN0FogFlags.FixedStart))
{
starts.Add(new Vector3(Data->_start, 0, 0));
}
else
{
SCN0KeyframeStruct *addr = Data->startKeyframes->Data;
for (int i = 0; i < Data->startKeyframes->_numFrames; i++)
{
starts.Add(*addr++);
}
}
if (flags.HasFlag(SCN0FogFlags.FixedEnd))
{
ends.Add(new Vector3(Data->_end, 0, 0));
}
else
{
SCN0KeyframeStruct *addr = Data->endKeyframes->Data;
for (int i = 0; i < Data->endKeyframes->_numFrames; i++)
{
ends.Add(*addr++);
}
}
if (flags.HasFlag(SCN0FogFlags.FixedColor))
{
colors.Add(Data->_color);
}
else
{
RGBAPixel *addr = Data->colorEntries;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
colors.Add(*addr++);
}
}
}
return(false);
}
public static void EncodeFrames(KeyframeArray kf, ref VoidPtr dataAddr)
{
SCN0KeyframesHeader *header = (SCN0KeyframesHeader *)dataAddr;
*header = new SCN0KeyframesHeader(kf._keyCount);
KeyframeEntry frame, root = kf._keyRoot;
SCN0KeyframeStruct *entry = header->Data;
for (frame = root._next; frame._index != -1; frame = frame._next)
{
*entry++ = new SCN0KeyframeStruct(frame._tangent, frame._index, frame._value);
}
*(bint *)entry = 0;
dataAddr = ((VoidPtr)entry) + 4;
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
base.OnRebuild(address, length, force);
SCN0Fog *header = (SCN0Fog *)address;
if (colors.Count > 1)
{
*((bint *)header->_color.Address) = (int)lightAddr - (int)header->_color.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < colors.Count)
{
*lightAddr++ = colors[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
flags &= ~SCN0FogFlags.FixedColor;
}
else
{
flags |= SCN0FogFlags.FixedColor;
if (colors.Count == 1)
{
header->_color = colors[0];
}
else
{
header->_color = new RGBAPixel();
}
}
if (starts.Count > 1)
{
*((bint *)header->_start.Address) = (int)keyframeAddr - (int)header->_start.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)starts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < starts.Count; i++)
{
*addr++ = starts[i];
}
keyframeAddr += 4 + starts.Count * 12;
flags &= ~SCN0FogFlags.FixedStart;
}
else
{
flags |= SCN0FogFlags.FixedStart;
if (starts.Count == 1)
{
header->_start = starts[0]._value;
}
else
{
header->_start = 0;
}
}
if (ends.Count > 1)
{
*((bint *)header->_end.Address) = (int)keyframeAddr - (int)header->_end.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)ends.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < ends.Count; i++)
{
*addr++ = ends[i];
}
keyframeAddr += 4 + ends.Count * 12;
flags &= ~SCN0FogFlags.FixedEnd;
}
else
{
flags |= SCN0FogFlags.FixedEnd;
if (ends.Count == 1)
{
header->_end = ends[0]._value;
}
else
{
header->_end = 0;
}
}
header->_flags = (byte)flags;
header->_density = density;
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
base.OnRebuild(address, length, force);
SCN0Camera *header = (SCN0Camera *)address;
header->_pad1 = 0;
header->_flags2 = (ushort)_flags2;
header->_pad2 = 0;
header->_camSettings = vec2;
Bin16 flags = new Bin16();
flags[0] = Vec1Flags.HasFlag(SCN0CameraVectorFlags.Unknown);
if (v1x.Count > 1)
{
*((bint *)header->_vec1._x.Address) = (int)keyframeAddr - (int)header->_vec1._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v1x.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v1x.Count; i++)
{
*addr++ = v1x[i];
}
keyframeAddr += 4 + v1x.Count * 12;
flags[1] = false;
}
else
{
flags[1] = true;
if (v1x.Count == 1)
{
header->_vec1._x = v1x[0]._value;
}
else
{
header->_vec1._x = 0;
}
}
if (v1y.Count > 1)
{
*((bint *)header->_vec1._y.Address) = (int)keyframeAddr - (int)header->_vec1._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v1y.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v1y.Count; i++)
{
*addr++ = v1y[i];
}
keyframeAddr += 4 + v1y.Count * 12;
flags[2] = false;
}
else
{
flags[2] = true;
if (v1y.Count == 1)
{
header->_vec1._y = v1y[0]._value;
}
else
{
header->_vec1._y = 0;
}
}
if (v1z.Count > 1)
{
*((bint *)header->_vec1._z.Address) = (int)keyframeAddr - (int)header->_vec1._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v1z.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v1z.Count; i++)
{
*addr++ = v1z[i];
}
keyframeAddr += 4 + v1z.Count * 12;
flags[3] = false;
}
else
{
flags[3] = true;
if (v1z.Count == 1)
{
header->_vec1._z = v1z[0]._value;
}
else
{
header->_vec1._z = 0;
}
}
flags[4] = Vec4Flags.HasFlag(SCN0CameraVectorFlags.Unknown);
if (v4x.Count > 1)
{
*((bint *)header->_vec4._x.Address) = (int)keyframeAddr - (int)header->_vec4._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v4x.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v4x.Count; i++)
{
*addr++ = v4x[i];
}
keyframeAddr += 4 + v4x.Count * 12;
flags[5] = false;
}
else
{
flags[5] = true;
if (v4x.Count == 1)
{
header->_vec4._x = v4x[0]._value;
}
else
{
header->_vec4._x = 0;
}
}
if (v4y.Count > 1)
{
*((bint *)header->_vec4._y.Address) = (int)keyframeAddr - (int)header->_vec4._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v4y.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v4y.Count; i++)
{
*addr++ = v4y[i];
}
keyframeAddr += 4 + v4y.Count * 12;
flags[7] = false;
}
else
{
flags[7] = true;
if (v4y.Count == 1)
{
header->_vec4._y = v4y[0]._value;
}
else
{
header->_vec4._y = 0;
}
}
if (v4z.Count > 1)
{
*((bint *)header->_vec4._z.Address) = (int)keyframeAddr - (int)header->_vec4._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v4z.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v4z.Count; i++)
{
*addr++ = v4z[i];
}
keyframeAddr += 4 + v4z.Count * 12;
flags[6] = false;
}
else
{
flags[6] = true;
if (v4z.Count == 1)
{
header->_vec4._z = v4z[0]._value;
}
else
{
header->_vec4._z = 0;
}
}
flags[8] = Vec3Flags.HasFlag(SCN0CameraVectorFlags.Unknown);
if (v3x.Count > 1)
{
*((bint *)header->_vec3._x.Address) = (int)keyframeAddr - (int)header->_vec3._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v3x.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v3x.Count; i++)
{
*addr++ = v3x[i];
}
keyframeAddr += 4 + v3x.Count * 12;
flags[9] = false;
}
else
{
flags[9] = true;
if (v3x.Count == 1)
{
header->_vec3._x = v3x[0]._value;
}
else
{
header->_vec3._x = 0;
}
}
if (v3y.Count > 1)
{
*((bint *)header->_vec3._y.Address) = (int)keyframeAddr - (int)header->_vec3._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v3y.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v3y.Count; i++)
{
*addr++ = v3y[i];
}
keyframeAddr += 4 + v3y.Count * 12;
flags[10] = false;
}
else
{
flags[10] = true;
if (v3y.Count == 1)
{
header->_vec3._y = v3y[0]._value;
}
else
{
header->_vec3._y = 0;
}
}
if (v3z.Count > 1)
{
*((bint *)header->_vec3._z.Address) = (int)keyframeAddr - (int)header->_vec3._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v3z.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v3z.Count; i++)
{
*addr++ = v3z[i];
}
keyframeAddr += 4 + v3z.Count * 12;
flags[11] = false;
}
else
{
flags[11] = true;
if (v3z.Count == 1)
{
header->_vec3._z = v3z[0]._value;
}
else
{
header->_vec3._z = 0;
}
}
flags[12] = Vec2Flags.HasFlag(SCN0CameraVectorFlags.Unknown);
if (v2x.Count > 1)
{
*((bint *)header->_vec2._x.Address) = (int)keyframeAddr - (int)header->_vec2._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v2x.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v2x.Count; i++)
{
*addr++ = v2x[i];
}
keyframeAddr += 4 + v2x.Count * 12;
flags[13] = false;
}
else
{
flags[13] = true;
if (v2x.Count == 1)
{
header->_vec2._x = v2x[0]._value;
}
else
{
header->_vec2._x = 0;
}
}
if (v2y.Count > 1)
{
*((bint *)header->_vec2._y.Address) = (int)keyframeAddr - (int)header->_vec2._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v2y.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v2y.Count; i++)
{
*addr++ = v2y[i];
}
keyframeAddr += 4 + v2y.Count * 12;
flags[14] = false;
}
else
{
flags[14] = true;
if (v2y.Count == 1)
{
header->_vec2._y = v2y[0]._value;
}
else
{
header->_vec2._y = 0;
}
}
if (v2z.Count > 1)
{
*((bint *)header->_vec2._z.Address) = (int)keyframeAddr - (int)header->_vec2._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)v2z.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < v2z.Count; i++)
{
*addr++ = v2z[i];
}
keyframeAddr += 4 + v2z.Count * 12;
flags[15] = false;
}
else
{
flags[15] = true;
if (v2z.Count == 1)
{
header->_vec2._z = v2z[0]._value;
}
else
{
header->_vec1._z = 0;
}
}
header->_flags1 = flags.data;
}
//[Category("Camera Vector 1"), TypeConverter(typeof(Vector3StringConverter))]
//public Vector3 Vec1 { get { return vec1; } set { vec1 = value; SignalPropertyChange(); } }
//[Category("Camera Vector 2"), TypeConverter(typeof(Vector3StringConverter))]
//public Vector3 Vec2 { get { return vec3; } set { vec3 = value; SignalPropertyChange(); } }
//[Category("Camera Vector 3"), TypeConverter(typeof(Vector3StringConverter))]
//public Vector3 Vec3 { get { return vec4; } set { vec4 = value; SignalPropertyChange(); } }
//[Category("Camera Vector 4"), TypeConverter(typeof(Vector3StringConverter))]
//public Vector3 Vec4 { get { return vec5; } set { vec5 = value; SignalPropertyChange(); } }
protected override bool OnInitialize()
{
base.OnInitialize();
_flags1 = Data->_flags1;
_flags2 = Data->_flags2;
vec1 = Data->_vec1;
vec2 = Data->_camSettings;
vec3 = Data->_vec2;
vec4 = Data->_vec3;
vec5 = Data->_vec4;
v1x = new List <SCN0Keyframe>();
v1y = new List <SCN0Keyframe>();
v1z = new List <SCN0Keyframe>();
v2x = new List <SCN0Keyframe>();
v2y = new List <SCN0Keyframe>();
v2z = new List <SCN0Keyframe>();
v3x = new List <SCN0Keyframe>();
v3y = new List <SCN0Keyframe>();
v3z = new List <SCN0Keyframe>();
v4x = new List <SCN0Keyframe>();
v4y = new List <SCN0Keyframe>();
v4z = new List <SCN0Keyframe>();
if (Vec1Flags.HasFlag(SCN0CameraVectorFlags.FixedX))
{
v1x.Add(new Vector3(0, 0, Data->_vec1._x));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v1xKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v1x.Add(*addr++);
}
}
}
if (Vec1Flags.HasFlag(SCN0CameraVectorFlags.FixedY))
{
v1y.Add(new Vector3(0, 0, Data->_vec1._y));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v1yKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v1y.Add(*addr++);
}
}
}
if (Vec1Flags.HasFlag(SCN0CameraVectorFlags.FixedZ))
{
v1z.Add(new Vector3(0, 0, Data->_vec1._z));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v1zKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v1z.Add(*addr++);
}
}
}
if (Vec2Flags.HasFlag(SCN0CameraVectorFlags.FixedX))
{
v2x.Add(new Vector3(0, 0, Data->_vec2._x));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v2xKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v2x.Add(*addr++);
}
}
}
if (Vec2Flags.HasFlag(SCN0CameraVectorFlags.FixedY))
{
v2y.Add(new Vector3(0, 0, Data->_vec2._y));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v2yKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v2y.Add(*addr++);
}
}
}
if (Vec2Flags.HasFlag(SCN0CameraVectorFlags.FixedZ))
{
v2z.Add(new Vector3(0, 0, Data->_vec2._z));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v2zKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v2z.Add(*addr++);
}
}
}
if (Vec3Flags.HasFlag(SCN0CameraVectorFlags.FixedX))
{
v3x.Add(new Vector3(0, 0, Data->_vec3._x));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v3xKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v3x.Add(*addr++);
}
}
}
if (Vec3Flags.HasFlag(SCN0CameraVectorFlags.FixedY))
{
v3y.Add(new Vector3(0, 0, Data->_vec3._y));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v3yKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v3y.Add(*addr++);
}
}
}
if (Vec3Flags.HasFlag(SCN0CameraVectorFlags.FixedZ))
{
v3z.Add(new Vector3(0, 0, Data->_vec3._z));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v3zKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v3z.Add(*addr++);
}
}
}
if (Vec4Flags.HasFlag(SCN0CameraVectorFlags.FixedX))
{
v4x.Add(new Vector3(0, 0, Data->_vec4._x));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v4xKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v4x.Add(*addr++);
}
}
}
if (Vec4Flags.HasFlag(SCN0CameraVectorFlags.FixedZ)) //Z for Y?
{
v4y.Add(new Vector3(0, 0, Data->_vec4._y));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v4yKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v4y.Add(*addr++);
}
}
}
if (Vec4Flags.HasFlag(SCN0CameraVectorFlags.FixedY)) //Y for Z?
{
v4z.Add(new Vector3(0, 0, Data->_vec4._z));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->v4zKfs;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
v4z.Add(*addr++);
}
}
}
return(false);
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
SCN0Light *header = (SCN0Light *)address;
base.OnRebuild(address, length, force);
if (_name != "<null>")
{
header->_unk1 = _unk1;
header->_unk2 = _unk2;
header->_unk5 = _unk5;
header->_unk6 = _unk6;
header->_unk7 = _unk7;
header->_unk8 = _unk8;
header->_unk9 = _unk9;
header->_unk10 = _unk10;
header->_unk12 = _unk12;
if (_lighting1.Count > 1)
{
*((bint *)header->_lighting1.Address) = (int)lightAddr - (int)header->_lighting1.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < _lighting1.Count)
{
*lightAddr++ = _lighting1[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
_flags1[6] = false;
}
else
{
_flags1[6] = true;
if (_lighting1.Count == 1)
{
header->_lighting1 = _lighting1[0];
}
else
{
header->_lighting1 = new RGBAPixel();
}
}
if (_lighting2.Count > 1)
{
*((bint *)header->_lighting2.Address) = (int)lightAddr - (int)header->_lighting2.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < _lighting2.Count)
{
*lightAddr++ = _lighting2[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
_flags1[14] = false;
}
else
{
_flags1[14] = true;
if (_lighting2.Count == 1)
{
header->_lighting2 = _lighting2[0];
}
else
{
header->_lighting2 = new RGBAPixel();
}
}
if (xEnds.Count > 1)
{
*((bint *)header->_vec1._x.Address) = (int)keyframeAddr - (int)header->_vec1._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)xEnds.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < xEnds.Count; i++)
{
*addr++ = xEnds[i];
}
keyframeAddr += 4 + xEnds.Count * 12;
_flags1[3] = false;
}
else
{
_flags1[3] = true;
if (xEnds.Count == 1)
{
header->_vec1._x = xEnds[0]._value;
}
else
{
header->_vec1._x = 0;
}
}
if (yEnds.Count > 1)
{
*((bint *)header->_vec1._y.Address) = (int)keyframeAddr - (int)header->_vec1._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)yEnds.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < yEnds.Count; i++)
{
*addr++ = yEnds[i];
}
keyframeAddr += 4 + yEnds.Count * 12;
_flags1[4] = false;
}
else
{
_flags1[4] = true;
if (yEnds.Count == 1)
{
header->_vec1._y = yEnds[0]._value;
}
else
{
header->_vec1._y = 0;
}
}
if (zEnds.Count > 1)
{
*((bint *)header->_vec1._z.Address) = (int)keyframeAddr - (int)header->_vec1._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)zEnds.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < zEnds.Count; i++)
{
*addr++ = zEnds[i];
}
keyframeAddr += 4 + zEnds.Count * 12;
_flags1[5] = false;
}
else
{
_flags1[5] = true;
if (zEnds.Count == 1)
{
header->_vec1._z = zEnds[0]._value;
}
else
{
header->_vec1._z = 0;
}
}
if (xStarts.Count > 1)
{
*((bint *)header->_vec2._x.Address) = (int)keyframeAddr - (int)header->_vec2._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)xStarts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < xStarts.Count; i++)
{
*addr++ = xStarts[i];
}
keyframeAddr += 4 + xStarts.Count * 12;
_flags1[7] = false;
}
else
{
_flags1[7] = true;
if (xStarts.Count == 1)
{
header->_vec2._x = xStarts[0]._value;
}
else
{
header->_vec2._x = 0;
}
}
if (yStarts.Count > 1)
{
*((bint *)header->_vec2._y.Address) = (int)keyframeAddr - (int)header->_vec2._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)yStarts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < yStarts.Count; i++)
{
*addr++ = yStarts[i];
}
keyframeAddr += 4 + yStarts.Count * 12;
_flags1[8] = false;
}
else
{
_flags1[8] = true;
if (yStarts.Count == 1)
{
header->_vec2._y = yStarts[0]._value;
}
else
{
header->_vec2._y = 0;
}
}
if (zStarts.Count > 1)
{
*((bint *)header->_vec2._z.Address) = (int)keyframeAddr - (int)header->_vec2._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)zStarts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < zStarts.Count; i++)
{
*addr++ = zStarts[i];
}
keyframeAddr += 4 + zStarts.Count * 12;
_flags1[9] = false;
}
else
{
_flags1[9] = true;
if (zStarts.Count == 1)
{
header->_vec2._z = zStarts[0]._value;
}
else
{
header->_vec2._z = 0;
}
}
header->_flags1 = _flags1.data;
header->_flags2 = _flags2.data;
}
}
protected override bool OnInitialize()
{
base.OnInitialize();
_unk1 = Data->_unk1;
_unk2 = Data->_unk2;
_flags1 = new Bin16(Data->_flags1);
_flags2 = new Bin16(Data->_flags2);
_unk5 = Data->_unk5;
_unk6 = Data->_unk6;
_unk7 = Data->_unk7;
_unk8 = Data->_unk8;
_unk9 = Data->_unk9;
_unk10 = Data->_unk10;
_unk12 = Data->_unk12;
_lighting1 = new List <RGBAPixel>();
_lighting2 = new List <RGBAPixel>();
xEnds = new List <SCN0Keyframe>();
yEnds = new List <SCN0Keyframe>();
zEnds = new List <SCN0Keyframe>();
xStarts = new List <SCN0Keyframe>();
yStarts = new List <SCN0Keyframe>();
zStarts = new List <SCN0Keyframe>();
if (Flags1[3])
{
xEnds.Add(new Vector3(0, 0, Data->_vec1._x));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->xEndKeyframes;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
xEnds.Add(*addr++);
}
}
}
if (Flags1[4])
{
yEnds.Add(new Vector3(0, 0, Data->_vec1._y));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->yEndKeyframes;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
yEnds.Add(*addr++);
}
}
}
if (Flags1[5])
{
zEnds.Add(new Vector3(0, 0, Data->_vec1._z));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->zEndKeyframes;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
zEnds.Add(*addr++);
}
}
}
if (Flags1[6])
{
_lighting1.Add(Data->_lighting1);
}
else
{
if (Name != "<null>")
{
RGBAPixel *addr = Data->light1Entries;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
_lighting1.Add(*addr++);
}
}
}
if (Flags1[7])
{
xStarts.Add(new Vector3(0, 0, Data->_vec2._x));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->xStartKeyframes;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
xStarts.Add(*addr++);
}
}
}
if (Flags1[8])
{
yStarts.Add(new Vector3(0, 0, Data->_vec2._y));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->yStartKeyframes;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
yStarts.Add(*addr++);
}
}
}
if (Flags1[9])
{
zStarts.Add(new Vector3(0, 0, Data->_vec2._z));
}
else
{
if (Name != "<null>")
{
SCN0KeyframesHeader *keysHeader = Data->zStartKeyframes;
SCN0KeyframeStruct * addr = keysHeader->Data;
for (int i = 0; i < keysHeader->_numFrames; i++)
{
zStarts.Add(*addr++);
}
}
}
if (Flags1[14])
{
_lighting2.Add(Data->_lighting2);
}
else
{
if (Name != "<null>")
{
RGBAPixel *addr = Data->light2Entries;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
_lighting2.Add(*addr++);
}
}
}
return(false);
}
