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; } } }