private List <BSA_Type3> ParseType3(int hdrOffset, int offset, int count)
{
if (count > 0)
{
List <BSA_Type3> Type = new List <BSA_Type3>();
for (int i = 0; i < count; i++)
{
Type.Add(new BSA_Type3()
{
I_00 = BitConverter.ToUInt16(rawBytes, offset + 0),
I_02 = BitConverter.ToUInt16(rawBytes, offset + 2),
I_04 = BitConverter.ToUInt16(rawBytes, offset + 4),
I_06_a = Int4Converter.ToInt4(rawBytes[offset + 6])[0],
I_06_b = Int4Converter.ToInt4(rawBytes[offset + 6])[1],
I_06_c = Int4Converter.ToInt4(rawBytes[offset + 7])[0],
I_06_d = Int4Converter.ToInt4(rawBytes[offset + 7])[1],
F_08 = BitConverter.ToSingle(rawBytes, offset + 8),
F_12 = BitConverter.ToSingle(rawBytes, offset + 12),
F_16 = BitConverter.ToSingle(rawBytes, offset + 16),
F_20 = BitConverter.ToSingle(rawBytes, offset + 20),
F_24 = BitConverter.ToSingle(rawBytes, offset + 24),
F_28 = BitConverter.ToSingle(rawBytes, offset + 28),
F_32 = BitConverter.ToSingle(rawBytes, offset + 32),
F_36 = BitConverter.ToSingle(rawBytes, offset + 36),
F_40 = BitConverter.ToSingle(rawBytes, offset + 40),
F_44 = BitConverter.ToSingle(rawBytes, offset + 44),
I_48 = BitConverter.ToUInt16(rawBytes, offset + 48),
I_50 = BitConverter.ToUInt16(rawBytes, offset + 50),
I_52 = BitConverter.ToUInt16(rawBytes, offset + 52),
I_54 = BitConverter.ToUInt16(rawBytes, offset + 54),
I_56 = BitConverter.ToUInt16(rawBytes, offset + 56),
FirstHit = BitConverter.ToUInt16(rawBytes, offset + 58),
MultipleHits = BitConverter.ToUInt16(rawBytes, offset + 60),
LastHit = BitConverter.ToUInt16(rawBytes, offset + 62),
StartTime = BitConverter.ToUInt16(rawBytes, hdrOffset + 0),
Duration = GetTypeDuration(BitConverter.ToUInt16(rawBytes, hdrOffset + 0), BitConverter.ToUInt16(rawBytes, hdrOffset + 2)),
});
hdrOffset += 4;
offset += 64;
}
return(Type);
}
else
{
return(null);
}
}
public void RemoveColorAnimations(List <IUndoRedo> undos = null)
{
if (undos == null)
{
undos = new List <IUndoRedo>();
}
//Parse the byte array and for all Type0 Animations that have Color Component R,G,B, change keyframes/floats to 0.
int section1Count = BitConverter.ToInt16(Bytes, 12);
int section1Offset = BitConverter.ToInt32(Bytes, 16);
for (int i = 0; i < section1Count; i++)
{
int type0Offset = BitConverter.ToInt32(Bytes, section1Offset + 172);
int type0Count = BitConverter.ToInt16(Bytes, section1Offset + 170);
if (type0Count > 0 && type0Offset > 0)
{
type0Offset += 168 + section1Offset;
for (int a = 0; a < type0Count; a++)
{
byte parameter = Bytes[type0Offset + 0];
byte component = Int4Converter.ToInt4(Bytes[type0Offset + 2])[0];
if (parameter == 0)
{
//Color Factor
if (component == 0 || component == 1 || component == 2)
{
//Create undoable steps
undos.Add(new UndoableArrayChange <byte>(Bytes, type0Offset + 6, Bytes[type0Offset + 6], 0));
undos.Add(new UndoableArrayChange <byte>(Bytes, type0Offset + 7, Bytes[type0Offset + 7], 0));
//Nullify keyframe count
Bytes[type0Offset + 6] = 0;
Bytes[type0Offset + 7] = 0;
}
}
type0Offset += 16;
}
}
section1Offset += 176;
}
}
public void RemoveColorAnimations()
{
//Parse the byte array and for all Type0 Animations that have Color Component R,G,B, change keyframes/floats to 0.
int section1Count = BitConverter.ToInt16(Bytes, 12);
int section1Offset = BitConverter.ToInt32(Bytes, 16);
for (int i = 0; i < section1Count; i++)
{
int type0Offset = BitConverter.ToInt32(Bytes, section1Offset + 172);
int type0Count = BitConverter.ToInt16(Bytes, section1Offset + 170);
if (type0Count > 0 && type0Offset > 0)
{
type0Offset += 168 + section1Offset;
for (int a = 0; a < type0Count; a++)
{
byte parameter = Bytes[type0Offset + 0];
byte component = Int4Converter.ToInt4(Bytes[type0Offset + 2])[0];
if (parameter == 0)
{
//Color Factor
if (component == 0 || component == 1 || component == 2)
{
//Nullify keyframe count
Bytes[type0Offset + 6] = 0;
Bytes[type0Offset + 7] = 0;
}
}
type0Offset += 16;
}
}
section1Offset += 176;
}
}
private void ParseBsa()
{
int count = BitConverter.ToInt16(rawBytes, 18);
int offset = BitConverter.ToInt32(rawBytes, 20);
bsaFile.I_08 = BitConverter.ToInt64(rawBytes, 8);
bsaFile.I_16 = BitConverter.ToInt16(rawBytes, 16);
bsaFile.BSA_Entries = new List <BSA_Entry>();
for (int i = 0; i < count; i++)
{
int entryOffset = BitConverter.ToInt32(rawBytes, offset);
if (entryOffset != 0)
{
bsaFile.BSA_Entries.Add(new BSA_Entry()
{
Index = i.ToString(),
I_00 = BitConverter.ToInt32(rawBytes, entryOffset + 0),
I_16_a = Int4Converter.ToInt4(rawBytes[entryOffset + 16])[0],
I_16_b = Int4Converter.ToInt4(rawBytes[entryOffset + 16])[1],
I_17 = rawBytes[entryOffset + 17],
I_18 = BitConverter.ToInt32(rawBytes, entryOffset + 18),
I_22 = BitConverter.ToUInt16(rawBytes, entryOffset + 22),
I_24 = BitConverter.ToUInt16(rawBytes, entryOffset + 24),
Expires = BitConverter.ToUInt16(rawBytes, entryOffset + 26),
ImpactProjectile = BitConverter.ToUInt16(rawBytes, entryOffset + 28),
ImpactEnemy = BitConverter.ToUInt16(rawBytes, entryOffset + 30),
ImpactGround = BitConverter.ToUInt16(rawBytes, entryOffset + 32),
I_40 = BitConverter_Ex.ToInt32Array(rawBytes, entryOffset + 40, 3)
});
int thisEntry = bsaFile.BSA_Entries.Count() - 1;
int Unk1Count = BitConverter.ToInt16(rawBytes, entryOffset + 4);
int Unk2Count = BitConverter.ToInt16(rawBytes, entryOffset + 6);
if (Unk1Count != 0 || Unk2Count != 0)
{
bsaFile.BSA_Entries[thisEntry].SubEntries = new BSA_SubEntries()
{
CollisionEntries = ParseUnk1(BitConverter.ToInt16(rawBytes, entryOffset + 8) + entryOffset, BitConverter.ToInt16(rawBytes, entryOffset + 4)),
ExpirationEntries = ParseUnk2(BitConverter.ToInt16(rawBytes, entryOffset + 12) + entryOffset, BitConverter.ToInt16(rawBytes, entryOffset + 6))
};
}
//Types
int typesOffset = BitConverter.ToInt16(rawBytes, entryOffset + 36) + entryOffset;
int typesCount = BitConverter.ToInt16(rawBytes, entryOffset + 34);
if (typesCount > 0)
{
for (int a = 0; a < typesCount; a++)
{
int type = BitConverter.ToInt16(rawBytes, typesOffset + 0);
int hdrOffset = BitConverter.ToInt32(rawBytes, typesOffset + 8) + typesOffset;
int dataOffset = BitConverter.ToInt32(rawBytes, typesOffset + 12) + typesOffset;
switch (type)
{
case 0:
bsaFile.BSA_Entries[thisEntry].Type0 = ParseType0(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 1:
bsaFile.BSA_Entries[thisEntry].Type1 = ParseType1(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 2:
bsaFile.BSA_Entries[thisEntry].Type2 = ParseType2(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 3:
bsaFile.BSA_Entries[thisEntry].Type3 = ParseType3(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 4:
bsaFile.BSA_Entries[thisEntry].Type4 = ParseType4(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 6:
bsaFile.BSA_Entries[thisEntry].Type6 = ParseType6(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 7:
bsaFile.BSA_Entries[thisEntry].Type7 = ParseType7(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 8:
bsaFile.BSA_Entries[thisEntry].Type8 = ParseType8(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
default:
Console.WriteLine(String.Format("Undefined BSA Type encountered: {0}, at offset: {1}", type, typesOffset));
Console.ReadLine();
break;
}
typesOffset += 16;
}
}
}
offset += 4;
}
}
public static EMA_Command Read(byte[] rawBytes, int offset, float[] values, EMA_File emaFile, EmaType _emaType)
{
EMA_Command command = new EMA_Command();
command.emaType = _emaType;
if (emaFile.HasSkeleton)
{
command.BoneName = emaFile.GetBoneName(BitConverter.ToUInt16(rawBytes, offset + 0));
}
else
{
//This ema has no skeleton, thus no bones
command.BoneName = null;
}
command.I_02 = rawBytes[offset + 2];
BitArray flags_b = new BitArray(new byte[1] {
Int4Converter.ToInt4(rawBytes[offset + 3])[1]
});
BitArray flags_a = new BitArray(new byte[1] {
Int4Converter.ToInt4(rawBytes[offset + 3])[0]
});
command.I_03_b1 = flags_b[0];
command.I_03_b2_Int16ForTime = flags_b[1];
command.I_03_b3_Int16ForValueIndex = flags_b[2];
command.I_03_b4 = flags_b[3];
command.I_03_a4 = flags_a[3];
flags_a[3] = false;
command.I_03_a = Int4Converter.GetByte(Utils.ConvertToByte(flags_a), 0);
command.Keyframes = new ObservableCollection <EMA_Keyframe>();
ushort keyframeCount = BitConverter.ToUInt16(rawBytes, offset + 4);
ushort indexOffset = BitConverter.ToUInt16(rawBytes, offset + 6);
for (int i = 0; i < keyframeCount; i++)
{
ushort time;
float value;
string value2 = null;
string value3 = null;
string value4 = null;
KeyframeFlags flags;
if (command.I_03_b2_Int16ForTime)
{
time = BitConverter.ToUInt16(rawBytes, offset + 8 + (i * 2));
}
else
{
time = rawBytes[offset + 8 + i];
}
if (command.I_03_b3_Int16ForValueIndex)
{
value = values[BitConverter.ToUInt16(rawBytes, offset + indexOffset + (i * 4))];
flags = (KeyframeFlags)BitConverter.ToUInt16(rawBytes, offset + indexOffset + 2 + (i * 4));
int extraOffset = 0;
if (flags.HasFlag(KeyframeFlags.QuadraticBezier))
{
ushort idx = (ushort)(BitConverter.ToUInt16(rawBytes, offset + indexOffset + (i * 4)) + 1);
//idx might be out of range due to a bug with an older version of the parser... so in that case set it to value
if (idx <= values.Length - 1)
{
value2 = values[idx].ToString();
}
else
{
value2 = value.ToString();
}
extraOffset++;
}
if (flags.HasFlag(KeyframeFlags.CubicBezier))
{
ushort idx = (ushort)(BitConverter.ToUInt16(rawBytes, offset + indexOffset + (i * 4)) + 1 + extraOffset);
//idx might be out of range due to a bug with an older version of the parser... so in that case set it to value
if (idx + 1 <= values.Length - 1)
{
value3 = values[idx].ToString();
value4 = values[idx + 1].ToString();
}
else
{
value3 = value.ToString();
value4 = value.ToString();
}
extraOffset++;
}
}
else
{
value = values[rawBytes[offset + indexOffset + (i * 2)]];
flags = (KeyframeFlags)rawBytes[offset + indexOffset + 1 + (i * 2)];
int extraOffset = 0;
if (flags.HasFlag(KeyframeFlags.QuadraticBezier))
{
byte idx = (byte)(rawBytes[offset + indexOffset + (i * 2)] + 1);
if (idx <= values.Length - 1)
{
value2 = values[idx].ToString();
}
else
{
value2 = value.ToString();
}
}
if (flags.HasFlag(KeyframeFlags.CubicBezier))
{
byte idx = (byte)(rawBytes[offset + indexOffset + (i * 2)] + 1 + extraOffset);
if (idx + 1 <= values.Length - 1)
{
value3 = values[idx].ToString();
value4 = values[idx + 1].ToString();
}
else
{
value3 = value.ToString();
value4 = value.ToString();
}
}
}
command.Keyframes.Add(new EMA_Keyframe()
{
Time = time,
Value = value,
Flags = flags,
Value2 = value2,
CubicBezier_1 = value3,
CubicBezier_2 = value4
});
}
return(command);
}
private void Parse()
{
ecfFile.I_12 = BitConverter.ToUInt16(rawBytes, 12);
if (totalMainEntries > 0)
{
ecfFile.Entries = new List <ECF_Entry>();
for (int i = 0; i < totalMainEntries; i++)
{
ecfFile.Entries.Add(new ECF_Entry());
ecfFile.Entries[i].I_52 = (PlayMode)BitConverter.ToInt16(rawBytes, mainEntryOffset + 52);
ecfFile.Entries[i].F_00 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 0);
ecfFile.Entries[i].F_04 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 4);
ecfFile.Entries[i].F_08 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 8);
ecfFile.Entries[i].F_12 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 12);
ecfFile.Entries[i].F_16 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 16);
ecfFile.Entries[i].F_20 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 20);
ecfFile.Entries[i].F_24 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 24);
ecfFile.Entries[i].F_28 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 28);
ecfFile.Entries[i].F_32 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 32);
ecfFile.Entries[i].F_36 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 36);
ecfFile.Entries[i].F_40 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 40);
ecfFile.Entries[i].F_44 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 44);
ecfFile.Entries[i].F_48 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 48);
ecfFile.Entries[i].I_54 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 54);
ecfFile.Entries[i].I_56 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 56);
ecfFile.Entries[i].I_58 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 58);
ecfFile.Entries[i].I_60 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 60);
ecfFile.Entries[i].I_62 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 62);
ecfFile.Entries[i].I_64 = new UInt16[14];
for (int a = 0; a < 28; a += 2)
{
ecfFile.Entries[i].I_64[a / 2] = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 64 + a);
}
ecfFile.Entries[i].I_96 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 96);
//Type0 data
int Type0_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 100) + 96 + mainEntryOffset;
int Type0_Count = BitConverter.ToInt16(rawBytes, mainEntryOffset + 98);
if (Type0_Count > 0)
{
ecfFile.Entries[i].Type0 = new List <Type0>();
for (int a = 0; a < Type0_Count; a++)
{
int startOffset = BitConverter.ToInt32(rawBytes, Type0_Offset + 8) + Type0_Offset;
int floatOffset = BitConverter.ToInt32(rawBytes, Type0_Offset + 12) + Type0_Offset;
ecfFile.Entries[i].Type0.Add(new Type0()
{
I_00 = (ECF.Type0.Parameter)rawBytes[Type0_Offset + 0],
I_01_a = Type0.GetComponent((ECF.Type0.Parameter)rawBytes[Type0_Offset + 0], Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[0]),
I_01_b = BitConverter_Ex.ToBoolean(Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[1]),
I_02 = (rawBytes[Type0_Offset + 2] == 0)? false : true,
I_03 = rawBytes[Type0_Offset + 3],
I_04 = BitConverter.ToUInt16(rawBytes, Type0_Offset + 4),
Keyframes = ParseKeyframes(BitConverter.ToInt16(rawBytes, Type0_Offset + 6), startOffset, floatOffset)
});
Type0_Offset += 16;
}
}
//Unk_Str
int Str_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 92) + mainEntryOffset;
if (Str_Offset != 0)
{
ecfFile.Entries[i].Unk_Str = Utils.GetString(bytes, Str_Offset);
}
else
{
ecfFile.Entries[i].Unk_Str = String.Empty;
}
mainEntryOffset += 104;
}
}
}
private ParticleEffect ParseEffect(int mainEntryOffset)
{
ParticleEffect newEffect = ParticleEffect.GetNew((parserMode == ParserMode.Tool) ? true : false);
//Flags and Offsets for extra data
int FLAG_36 = rawBytes[mainEntryOffset + 36];
int FLAG_37 = rawBytes[mainEntryOffset + 37];
int Type0_Count = BitConverter.ToInt16(rawBytes, mainEntryOffset + 138);
int Type0_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 140) + 136 + mainEntryOffset;
int Type1_Count = BitConverter.ToInt16(rawBytes, mainEntryOffset + 144);
int Type1_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 148) + mainEntryOffset;
//Main Entry values
newEffect.Component_Type = ParticleEffect.GetComponentType(new int[2] {
FLAG_36, FLAG_37
});
newEffect.Name = Utils.GetString(rawBytes.ToList(), mainEntryOffset, 32);
BitArray compositeBits_I_32 = new BitArray(new byte[1] {
rawBytes[mainEntryOffset + 32]
});
BitArray compositeBits_I_33 = new BitArray(new byte[1] {
rawBytes[mainEntryOffset + 33]
});
BitArray compositeBits_I_34 = new BitArray(new byte[1] {
rawBytes[mainEntryOffset + 34]
});
newEffect.I_32_0 = compositeBits_I_32[0];
newEffect.I_32_1 = compositeBits_I_32[1];
newEffect.I_32_2 = compositeBits_I_32[2];
newEffect.I_32_3 = compositeBits_I_32[3];
newEffect.I_32_4 = compositeBits_I_32[4];
newEffect.I_32_5 = compositeBits_I_32[5];
newEffect.I_32_6 = compositeBits_I_32[6];
newEffect.I_32_7 = compositeBits_I_32[7];
newEffect.I_33_0 = compositeBits_I_33[0];
newEffect.I_33_1 = compositeBits_I_33[1];
newEffect.I_33_2 = compositeBits_I_33[2];
newEffect.I_33_3 = compositeBits_I_33[3];
newEffect.I_33_4 = compositeBits_I_33[4];
newEffect.I_33_5 = compositeBits_I_33[5];
newEffect.I_33_6 = compositeBits_I_33[6];
newEffect.I_33_7 = compositeBits_I_33[7];
newEffect.I_34_0 = compositeBits_I_34[0];
newEffect.I_34_1 = compositeBits_I_34[1];
newEffect.I_34_2 = compositeBits_I_34[2];
newEffect.I_34_3 = compositeBits_I_34[3];
newEffect.I_34_4 = compositeBits_I_34[4];
newEffect.I_34_5 = compositeBits_I_34[5];
newEffect.I_34_6 = compositeBits_I_34[6];
newEffect.I_34_7 = compositeBits_I_34[7];
newEffect.I_35 = (ParticleEffect.AutoOrientationType)rawBytes[mainEntryOffset + 35];
newEffect.I_38 = BitConverter.ToInt16(rawBytes, mainEntryOffset + 38);
newEffect.I_40 = BitConverter.ToInt16(rawBytes, mainEntryOffset + 40);
newEffect.I_42 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 42);
newEffect.I_44 = rawBytes[mainEntryOffset + 44];
newEffect.I_45 = rawBytes[mainEntryOffset + 45];
newEffect.I_46 = rawBytes[mainEntryOffset + 46];
newEffect.I_47 = rawBytes[mainEntryOffset + 47];
newEffect.I_48 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 48);
newEffect.I_50 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 50);
newEffect.I_52 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 52);
newEffect.I_54 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 54);
newEffect.I_56 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 56);
newEffect.I_58 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 58);
newEffect.I_60 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 60);
newEffect.I_62 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 62);
newEffect.F_64 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 64);
newEffect.F_68 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 68);
newEffect.F_72 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 72);
newEffect.F_76 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 76);
newEffect.F_80 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 80);
newEffect.F_84 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 84);
newEffect.F_88 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 88);
newEffect.F_92 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 92);
newEffect.F_96 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 96);
newEffect.F_100 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 100);
newEffect.F_104 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 104);
newEffect.F_108 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 108);
newEffect.F_112 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 112);
newEffect.F_116 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 116);
newEffect.F_120 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 120);
newEffect.F_124 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 124);
newEffect.F_128 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 128);
newEffect.F_132 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 132);
newEffect.I_136 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 136);
if (Type0_Count > 0 || Type1_Count > 0)
{
//Type0
if (Type0_Count > 0)
{
newEffect.Type_0 = new ObservableCollection <Type0>();
for (int a = 0; a < Type0_Count; a++)
{
int idx = newEffect.Type_0.Count();
newEffect.Type_0.Add(new Type0()
{
I_01_b = BitConverter_Ex.ToBoolean(Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[1]),
I_02 = BitConverter_Ex.ToBoolean(rawBytes, Type0_Offset + 2),
I_03 = rawBytes[Type0_Offset + 3],
F_04 = BitConverter.ToSingle(rawBytes, Type0_Offset + 4),
I_08 = BitConverter.ToInt16(rawBytes, Type0_Offset + 8),
Keyframes = ParseKeyframes <Type0_Keyframe>(BitConverter.ToInt16(rawBytes, Type0_Offset + 10), BitConverter.ToInt32(rawBytes, Type0_Offset + 12) + Type0_Offset)
});
newEffect.Type_0[idx].SetParameters(rawBytes[Type0_Offset + 0], Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[0], newEffect.IsScale2Enabled());
Type0_Offset += 16;
}
}
//Type1
if (Type1_Count > 0)
{
newEffect.Type_1 = new ObservableCollection <Type1_Header>();
for (int a = 0; a < Type1_Count; a++)
{
int entryCount = BitConverter.ToInt16(rawBytes, Type1_Offset + 2);
int entryOffset = BitConverter.ToInt32(rawBytes, Type1_Offset + 4) + Type1_Offset;
newEffect.Type_1.Add(new Type1_Header());
newEffect.Type_1[a].I_00 = rawBytes[Type1_Offset];
newEffect.Type_1[a].I_01 = rawBytes[Type1_Offset + 1];
newEffect.Type_1[a].Entries = new ObservableCollection <Type0>();
for (int d = 0; d < entryCount; d++)
{
int subEntryCount = BitConverter.ToInt16(rawBytes, entryOffset + 10);
newEffect.Type_1[a].Entries.Add(new Type0());
newEffect.Type_1[a].Entries[d].SetParameters(rawBytes[entryOffset + 0], Int4Converter.ToInt4(rawBytes[entryOffset + 1])[0], newEffect.IsScale2Enabled());
newEffect.Type_1[a].Entries[d].I_01_b = BitConverter_Ex.ToBoolean(Int4Converter.ToInt4(rawBytes[entryOffset + 1])[1]);
newEffect.Type_1[a].Entries[d].I_02 = BitConverter_Ex.ToBoolean(rawBytes, entryOffset + 2);
newEffect.Type_1[a].Entries[d].I_03 = rawBytes[entryOffset + 3];
newEffect.Type_1[a].Entries[d].F_04 = BitConverter.ToSingle(rawBytes, entryOffset + 4);
newEffect.Type_1[a].Entries[d].I_08 = BitConverter.ToInt16(rawBytes, entryOffset + 8);
newEffect.Type_1[a].Entries[d].Keyframes = ParseKeyframes <Type0_Keyframe>(BitConverter.ToInt16(rawBytes, entryOffset + 10), BitConverter.ToInt32(rawBytes, entryOffset + 12) + entryOffset);
entryOffset += 16;
}
Type1_Offset += 8;
}
}
}
//Extra Parts
//If no extra parts exist, this code wont execute
if (FLAG_37 != 0)
{
switch (FLAG_37)
{
case 1:
switch (FLAG_36)
{
case 0:
newEffect.FloatPart_00_01 = ParseFloatPart8 <FloatPart_0_1>(mainEntryOffset + 160);
break;
case 1:
newEffect.FloatPart_01_01 = ParseFloatPart4 <FloatPart_1_1>(mainEntryOffset + 160);
break;
case 2:
newEffect.FloatPart_02_01 = ParseFloatPart_2_1(mainEntryOffset + 160);
break;
case 3:
newEffect.FloatPart_03_01 = ParseFloatPart_3_1(mainEntryOffset + 160);
break;
}
break;
case 2:
switch (FLAG_36)
{
case 0:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.FloatPart_00_02 = ParseFloatPart4 <FloatPart_0_2>(mainEntryOffset + 160 + 112);
break;
case 1:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
break;
case 2:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.FloatPart_02_02 = ParseFloatPart8 <FloatPart_2_2>(mainEntryOffset + 160 + 112);
break;
case 3:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.Type_Struct3 = ParseStruct3(mainEntryOffset + 160 + 112, mainEntryOffset);
break;
case 4:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.Type_Model = ParseModelStruct(mainEntryOffset + 160 + 112, mainEntryOffset);
break;
case 5:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.Type_Struct5 = ParseStruct5(mainEntryOffset + 160 + 112, mainEntryOffset);
break;
}
break;
}
}
return(newEffect);
}
void EffectParser()
{
eepkFile.Effects = new List <Effect>();
List <ushort> effectIds = new List <ushort>(); //all lists are in sync with each other
List <int> effectOffsets = new List <int>();
List <short> effectSize = new List <short>();
List <int> effectInfoOffsets = new List <int>();
for (int i = 0; i < totalEffects * 4; i += 4)
{
//Getting ID List data
int current = BitConverter.ToInt32(rawBytes, i + pointerSectionLocation);
if (current != 0)
{
effectIds.Add((Convert.ToUInt16(i / 4)));
effectOffsets.Add(BitConverter.ToInt32(rawBytes, i + pointerSectionLocation));
}
}
for (int i = 0; i < effectIds.Count(); i++)
{
//Getting EffectInfo data, and making the representation instances
effectSize.Add(BitConverter.ToInt16(rawBytes, effectOffsets[i] + 10));
effectInfoOffsets.Add(BitConverter.ToInt32(rawBytes, effectOffsets[i] + 12));
eepkFile.Effects.Add(new Effect());
eepkFile.Effects[i].EffectParts = new ObservableCollection <EffectPart>();
eepkFile.Effects[i].IndexNum = effectIds[i];
eepkFile.Effects[i].I_02 = BitConverter.ToUInt16(rawBytes, effectOffsets[i] + 2);
int addedOffset = 0;
for (int a = 0; a < effectSize[i]; a++)
{
//Fill in the Effect Info fields, adding a new entry per size
BitArray composite_I_32 = new BitArray(new byte[1] {
rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 32]
});
BitArray composite_I_39 = new BitArray(new byte[1] {
rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 39]
});
BitArray composite_I_36 = new BitArray(new byte[1] {
rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 36]
});
BitArray composite_I_37 = new BitArray(new byte[1] {
rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 37]
});
eepkFile.Effects[i].EffectParts.Add(new EffectPart());
eepkFile.Effects[i].EffectParts[a].I_00 = BitConverter.ToUInt16(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset);
eepkFile.Effects[i].EffectParts[a].I_02 = (AssetType)rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 2];
eepkFile.Effects[i].EffectParts[a].I_03 = (EffectPart.Attachment)rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 3];
eepkFile.Effects[i].EffectParts[a].I_04 = rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 4];
eepkFile.Effects[i].EffectParts[a].I_05 = (EffectPart.DeactivationMode)rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 5];
eepkFile.Effects[i].EffectParts[a].I_06 = rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 6];
eepkFile.Effects[i].EffectParts[a].I_07 = rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 7];
eepkFile.Effects[i].EffectParts[a].I_08 = BitConverter.ToInt32(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 8);
eepkFile.Effects[i].EffectParts[a].I_12 = BitConverter.ToInt32(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 12);
eepkFile.Effects[i].EffectParts[a].I_16 = BitConverter.ToInt32(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 16);
eepkFile.Effects[i].EffectParts[a].I_20 = BitConverter.ToInt32(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 20);
eepkFile.Effects[i].EffectParts[a].F_24 = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 24);
eepkFile.Effects[i].EffectParts[a].I_28 = BitConverter.ToUInt16(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 28);
eepkFile.Effects[i].EffectParts[a].I_30 = BitConverter.ToUInt16(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 30);
eepkFile.Effects[i].EffectParts[a].I_32_0 = composite_I_32[0];
eepkFile.Effects[i].EffectParts[a].I_32_1 = composite_I_32[1];
eepkFile.Effects[i].EffectParts[a].I_32_2 = composite_I_32[2];
eepkFile.Effects[i].EffectParts[a].I_32_3 = composite_I_32[3];
eepkFile.Effects[i].EffectParts[a].I_32_4 = composite_I_32[4];
eepkFile.Effects[i].EffectParts[a].I_32_5 = composite_I_32[5];
eepkFile.Effects[i].EffectParts[a].I_32_6 = composite_I_32[6];
eepkFile.Effects[i].EffectParts[a].I_32_7 = composite_I_32[7];
eepkFile.Effects[i].EffectParts[a].I_34 = BitConverter.ToInt16(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 34);
eepkFile.Effects[i].EffectParts[a].I_36_0 = composite_I_36[0];
eepkFile.Effects[i].EffectParts[a].I_36_1 = composite_I_36[1];
eepkFile.Effects[i].EffectParts[a].I_36_2 = composite_I_36[2];
eepkFile.Effects[i].EffectParts[a].I_36_3 = composite_I_36[3];
eepkFile.Effects[i].EffectParts[a].I_36_4 = composite_I_36[4];
eepkFile.Effects[i].EffectParts[a].I_36_5 = composite_I_36[5];
eepkFile.Effects[i].EffectParts[a].I_36_6 = composite_I_36[6];
eepkFile.Effects[i].EffectParts[a].I_36_7 = composite_I_36[7];
eepkFile.Effects[i].EffectParts[a].I_37_0 = composite_I_37[0];
eepkFile.Effects[i].EffectParts[a].I_37_1 = composite_I_37[1];
eepkFile.Effects[i].EffectParts[a].I_37_2 = composite_I_37[2];
eepkFile.Effects[i].EffectParts[a].I_37_3 = composite_I_37[3];
eepkFile.Effects[i].EffectParts[a].I_37_4 = composite_I_37[4];
eepkFile.Effects[i].EffectParts[a].I_37_5 = composite_I_37[5];
eepkFile.Effects[i].EffectParts[a].I_37_6 = composite_I_37[6];
eepkFile.Effects[i].EffectParts[a].I_37_7 = composite_I_37[7];
eepkFile.Effects[i].EffectParts[a].I_38_a = HexConverter.GetHexString(Int4Converter.ToInt4(rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 38])[0]);
eepkFile.Effects[i].EffectParts[a].I_38_b = HexConverter.GetHexString(Int4Converter.ToInt4(rawBytes[effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 38])[1]);
eepkFile.Effects[i].EffectParts[a].I_39_0 = composite_I_39[0];
eepkFile.Effects[i].EffectParts[a].I_39_1 = composite_I_39[1];
eepkFile.Effects[i].EffectParts[a].I_39_2 = composite_I_39[2];
eepkFile.Effects[i].EffectParts[a].I_39_3 = composite_I_39[3];
eepkFile.Effects[i].EffectParts[a].I_39_4 = composite_I_39[4];
eepkFile.Effects[i].EffectParts[a].I_39_5 = composite_I_39[5];
eepkFile.Effects[i].EffectParts[a].I_39_6 = composite_I_39[6];
eepkFile.Effects[i].EffectParts[a].I_39_7 = composite_I_39[7];
eepkFile.Effects[i].EffectParts[a].POSITION_X = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 40);
eepkFile.Effects[i].EffectParts[a].POSITION_Y = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 44);
eepkFile.Effects[i].EffectParts[a].POSITION_Z = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 48);
eepkFile.Effects[i].EffectParts[a].F_52 = (float)Utils.ConvertRadiansToDegrees(BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 52));
eepkFile.Effects[i].EffectParts[a].F_56 = (float)Utils.ConvertRadiansToDegrees(BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 56));
eepkFile.Effects[i].EffectParts[a].F_60 = (float)Utils.ConvertRadiansToDegrees(BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 60));
eepkFile.Effects[i].EffectParts[a].F_64 = (float)Utils.ConvertRadiansToDegrees(BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 64));
eepkFile.Effects[i].EffectParts[a].F_68 = (float)Utils.ConvertRadiansToDegrees(BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 68));
eepkFile.Effects[i].EffectParts[a].F_72 = (float)Utils.ConvertRadiansToDegrees(BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 72));
eepkFile.Effects[i].EffectParts[a].SIZE_1 = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 76);
eepkFile.Effects[i].EffectParts[a].SIZE_2 = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 80);
eepkFile.Effects[i].EffectParts[a].F_84 = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 84);
eepkFile.Effects[i].EffectParts[a].F_88 = BitConverter.ToSingle(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 88);
eepkFile.Effects[i].EffectParts[a].I_92 = BitConverter.ToUInt16(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 92);
eepkFile.Effects[i].EffectParts[a].I_94 = BitConverter.ToUInt16(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 94);
int eskOffset = BitConverter.ToInt32(rawBytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + 96);
if (eskOffset != 0)
{
//Get ESK string if it exists, otherwise put it as "NULL"
try
{
eepkFile.Effects[i].EffectParts[a].ESK = Utils.GetString(bytes, effectOffsets[i] + effectInfoOffsets[i] + addedOffset + eskOffset);
}
catch
{
throw new ArgumentOutOfRangeException("Unable to get string!");
}
}
else
{
eepkFile.Effects[i].EffectParts[a].ESK = "NULL";
}
addedOffset += 100;
}
}
}
