protected override void OnParse(VoidPtr address) { bfloat *floatval = (bfloat *)address; bint intval1 = *(bint *)(address + 80); floatEntries = new float[20]; for (int i = 0; i < floatEntries.Length; i++) { floatEntries[i] = floatval[i]; } intEntry1 = intval1; }
protected override void OnParse(VoidPtr address) { _unks = new List <float>(); _hops = new List <float>(); sMultiJump *hdr = (sMultiJump *)address; _unk1 = hdr->_unk1; _unk2 = hdr->_unk2; _unk3 = hdr->_unk3; _horizontalBoost = hdr->_horizontalBoost; if (hdr->hopFixed) { _hops.Add(*(bfloat *)hdr->_hopListOffset.Address); } else { bfloat *addr = (bfloat *)(BaseAddress + hdr->_hopListOffset); for (int i = 0; i < (_offset - hdr->_hopListOffset) / 4; i++) { _hops.Add(*addr++); } } if (hdr->unkFixed) { _unks.Add(*(bfloat *)hdr->_unkListOffset.Address); } else { bfloat *addr = (bfloat *)(BaseAddress + hdr->_unkListOffset); for (int i = 0; i < ((hdr->hopFixed ? _offset : (int)hdr->_hopListOffset) - hdr->_unkListOffset) / 4; i++) { _unks.Add(*addr++); } } if (hdr->turnFixed) { _turnFrames = *(bfloat *)hdr->_turnFrameOffset.Address; } else { _turnFrames = hdr->_turnFrameOffset; } }
public override bool OnInitialize() { entries.Clear(); if (_name == null || _name == "") { _name = ((int)Header->_ID).ToString("X"); } bfloat *part2 = Header->part2; while (part2 < (System.bfloat *)((VoidPtr)Header) + WorkingUncompressed.Length) { entries.Add(*part2); part2++; } id = Header->_ID; EventsOffset = Header->_EventsOffset; part2Offset = Header->_part2Offset; unknown = Header->_unknown; _name = TrueID; return(true); }
protected override void OnWrite(VoidPtr address) { int off = 0; if (_hops.Count > 1) { off += _hops.Count * 4; } if (_unks.Count > 1) { off += _unks.Count * 4; } sMultiJump *header = (sMultiJump *)(address + off); RebuildAddress = header; bfloat *addr = (bfloat *)address; if (_unks.Count > 1) { header->_unkListOffset = Offset(addr); if (header->_unkListOffset > 0) { Lookup(&header->_unkListOffset); } foreach (float f in _unks) { *addr++ = f; } } else if (_unks.Count == 1) { *((bfloat *)&header->_unkListOffset) = _unks[0]; } else { *((bfloat *)&header->_unkListOffset) = 0; } if (_hops.Count > 1) { header->_hopListOffset = Offset(addr); if (header->_hopListOffset > 0) { Lookup(&header->_hopListOffset); } foreach (float f in _hops) { *addr++ = f; } } else if (_hops.Count == 1) { *((bfloat *)&header->_hopListOffset) = _hops[0]; } else { *((bfloat *)&header->_hopListOffset) = 0; } header->_unk1 = _unk1; header->_unk2 = _unk2; header->_unk3 = _unk3; header->_horizontalBoost = _horizontalBoost; if (header->turnFixed) { *(bfloat *)&header->_turnFrameOffset = _turnFrames; } else { header->_turnFrameOffset = (int)_turnFrames; } }
public static KeyframeCollection DecodeSRT0Keyframes(SRT0TextureEntry *entry, int numFrames) { KeyframeCollection kf = new KeyframeCollection(5, numFrames, 1, 1); if (entry == null) { return(kf); } bfloat * sPtr = (bfloat *)entry->Data; SRT0Code code = entry->Code; if (!code.NoScale) { if (code.ScaleIsotropic) { if (code.FixedScaleX) { kf[0, 0, 1] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, AnimDataFormat.I12, 0, 1); } } else { if (code.FixedScaleX) { kf[0, 0] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, AnimDataFormat.I12, 0); } if (code.FixedScaleY) { kf[0, 1] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, AnimDataFormat.I12, 1); } } } if (!code.NoRotation) { if (code.FixedRotation) { kf[0, 2] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, AnimDataFormat.I12, 2); } } if (!code.NoTranslation) { if (code.FixedX) { kf[0, 3] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, AnimDataFormat.I12, 3); } if (code.FixedY) { kf[0, 4] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, AnimDataFormat.I12, 4); } } return(kf); }
private static void DecodeFrames(KeyframeCollection kf, void *dataAddr, AnimDataFormat format, params int[] arrays) { int fCount; float vStep, vBase; switch (format) { case AnimDataFormat.I4: { I4Header *header = (I4Header *)dataAddr; fCount = header->_entries; vStep = header->_step; vBase = header->_base; foreach (int x in arrays) { I4Entry *entry = header->Data; for (int i = 0; i < fCount; i++, entry++) { kf.SetFrameValue(x, entry->FrameIndex, vBase + entry->Step * vStep, true)._tangent = entry->Tangent; } } break; } case AnimDataFormat.I6: { I6Header *header = (I6Header *)dataAddr; fCount = header->_numFrames; vStep = header->_step; vBase = header->_base; foreach (int x in arrays) { I6Entry *entry = header->Data; for (int i = 0; i < fCount; i++, entry++) { kf.SetFrameValue(x, entry->FrameIndex, vBase + entry->_step * vStep, true)._tangent = entry->Tangent; } } break; } case AnimDataFormat.I12: { I12Header *header = (I12Header *)dataAddr; fCount = header->_numFrames; foreach (int x in arrays) { I12Entry *entry = header->Data; for (int i = 0; i < fCount; i++, entry++) { kf.SetFrameValue(x, (int)entry->_index, entry->_value, true)._tangent = entry->_tangent; } } break; } case AnimDataFormat.L1: { L1Header *header = (L1Header *)dataAddr; vStep = header->_step; vBase = header->_base; foreach (int x in arrays) { byte *sPtr = header->Data; for (int i = 0; i < kf.FrameLimit; i++) { kf.SetFrameValue(x, i, vBase + *sPtr++ *vStep, true).GenerateTangent(); } } break; } case AnimDataFormat.L2: { L1Header *header = (L1Header *)dataAddr; vStep = header->_step; vBase = header->_base; foreach (int x in arrays) { bushort *sPtr = (bushort *)header->Data; for (int i = 0; i < kf.FrameLimit; i++) { kf.SetFrameValue(x, i, vBase + *sPtr++ *vStep, true).GenerateTangent(); } } break; } case AnimDataFormat.L4: { foreach (int x in arrays) { bfloat *sPtr = (bfloat *)dataAddr; for (int i = 0; i < kf.FrameLimit; i++) { kf.SetFrameValue(x, i, *sPtr++, true).GenerateTangent(); } } break; } } }
public static KeyframeCollection DecodeCHR0Keyframes(CHR0Entry *entry, int numFrames) { KeyframeCollection kf = new KeyframeCollection(9, numFrames, 1, 1, 1); if (entry == null) { return(kf); } bfloat * sPtr = (bfloat *)entry->Data; AnimationCode code = entry->Code; AnimDataFormat format; if (code.HasScale) { format = code.ScaleDataFormat; if (code.IsScaleIsotropic) { if (code.IsScaleZFixed) { kf[0, 0, 1, 2] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 0, 1, 2); } } else { if (code.IsScaleXFixed) { kf[0, 0] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 0); } if (code.IsScaleYFixed) { kf[0, 1] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 1); } if (code.IsScaleZFixed) { kf[0, 2] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 2); } } } if (code.HasRotation) { format = code.RotationDataFormat; if (code.IsRotationIsotropic) { if (code.IsRotationZFixed) { kf[0, 3, 4, 5] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 3, 4, 5); } } else { if (code.IsRotationXFixed) { kf[0, 3] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 3); } if (code.IsRotationYFixed) { kf[0, 4] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 4); } if (code.IsRotationZFixed) { kf[0, 5] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 5); } } } if (code.HasTranslation) { format = code.TranslationDataFormat; if (code.IsTranslationIsotropic) { if (code.IsTranslationZFixed) { kf[0, 6, 7, 8] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 6, 7, 8); } } else { if (code.IsTranslationXFixed) { kf[0, 6] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 6); } if (code.IsTranslationYFixed) { kf[0, 7] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 7); } if (code.IsTranslationZFixed) { kf[0, 8] = *sPtr++; } else { DecodeFrames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, 8); } } } return(kf); }
private static int EncodeEntry(int index, AnimDataFormat format, KeyframeCollection kf, VoidPtr addr) { int numFrames = kf.FrameLimit; KeyframeEntry frame, root = kf._keyArrays[index]._keyRoot; bfloat * pVal = (bfloat *)addr; float val, frameScale = numFrames <= 1 ? 1 : 1.0f / (numFrames - 1); float min, max, stride, step; int span, i; int keyCount = kf._keyArrays[index]._keyCount; if (format == AnimDataFormat.L4) { //Use all frames, just in case not all frames are key. for (i = 0; i < numFrames; i++) { *pVal++ = kf[i, index]; } return(numFrames * 4); } if (format == AnimDataFormat.I12) { I12Header *header = (I12Header *)addr; * header = new I12Header(keyCount, frameScale); I12Entry *entry = header->Data; for (frame = root._next; frame._index != -1; frame = frame._next) { *entry++ = new I12Entry(frame._index, frame._value, frame._tangent); } return(keyCount * 12 + 8); } //Get floor/ceil/stride min = float.MaxValue; max = float.MinValue; for (frame = root._next; frame != root; frame = frame._next) { val = frame._value; if (val > max) { max = val; } if (val < min) { min = val; } } stride = max - min; if (format == AnimDataFormat.L1) { //Find best span span = EvalSpan(255, 32, min, stride, root, true); step = stride / span; L1Header *header = (L1Header *)addr; * header = new L1Header(step, min); byte *dPtr = header->Data; for (i = 0; i < numFrames; i++) { *dPtr++ = (byte)((kf[i, index] - min) / step + 0.5f); } //Fill remaining bytes while ((i++ & 3) != 0) { *dPtr++ = 0; } return((8 + numFrames).Align(4)); } if (format == AnimDataFormat.I4) { //Find best span span = EvalSpan(4095, 32, min, stride, root, false); step = stride / span; I4Header *header = (I4Header *)addr; * header = new I4Header(keyCount, frameScale, step, min); I4Entry *entry = header->Data; for (frame = root._next; frame._index != -1; frame = frame._next) { val = (frame._value - min) / step; val += val < 0 ? -0.5f : 0.5f; *entry++ = new I4Entry(frame._index, (int)val, frame._tangent); } return(keyCount * 4 + 16); } if (format == AnimDataFormat.I6) { //Find best span span = EvalSpan(65535, 32, min, stride, root, false); step = stride / span; I6Header *header = (I6Header *)addr; * header = new I6Header(keyCount, frameScale, step, min); I6Entry *entry = header->Data; for (frame = root._next; frame._index != -1; frame = frame._next) { val = (frame._value - min) / step; val += val < 0 ? -0.5f : 0.5f; *entry++ = new I6Entry(frame._index, (int)val, frame._tangent); } //Fill remaining bytes if ((keyCount & 1) != 0) { entry->_data = 0; } return((keyCount * 6 + 16).Align(4)); } return(0); }
public static KeyframeCollection DecodeCHR0Keyframes(CHR0Entry *entry, int numFrames) { KeyframeCollection kf = new KeyframeCollection(numFrames); bfloat * sPtr = (bfloat *)entry->Data; AnimationCode code = entry->Code; AnimDataFormat format; if (code.HasScale) { format = code.ScaleDataFormat; if (code.IsScaleIsotropic) { if (code.IsScaleZFixed) { kf[KeyFrameMode.ScaleXYZ, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.ScaleXYZ); } } else { if (code.IsScaleXFixed) { kf[KeyFrameMode.ScaleX, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.ScaleX); } if (code.IsScaleYFixed) { kf[KeyFrameMode.ScaleY, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.ScaleY); } if (code.IsScaleZFixed) { kf[KeyFrameMode.ScaleZ, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.ScaleZ); } } } if (code.HasRotation) { format = code.RotationDataFormat; if (code.IsRotationIsotropic) { if (code.IsRotationZFixed) { kf[KeyFrameMode.RotXYZ, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.RotXYZ); } } else { if (code.IsRotationXFixed) { kf[KeyFrameMode.RotX, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.RotX); } if (code.IsRotationYFixed) { kf[KeyFrameMode.RotY, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.RotY); } if (code.IsRotationZFixed) { kf[KeyFrameMode.RotZ, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.RotZ); } } } if (code.HasTranslation) { format = code.TranslationDataFormat; if (code.IsTranslationIsotropic) { if (code.IsTranslationZFixed) { kf[KeyFrameMode.TransXYZ, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.TransXYZ); } } else { if (code.IsTranslationXFixed) { kf[KeyFrameMode.TransX, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.TransX); } if (code.IsTranslationYFixed) { kf[KeyFrameMode.TransY, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.TransY); } if (code.IsTranslationZFixed) { kf[KeyFrameMode.TransZ, 0] = *sPtr++; } else { DecodeCHR0Frames(kf, (VoidPtr)entry + *(buint *)sPtr++, format, KeyFrameMode.TransZ); } } } return(kf); }
public static KeyframeCollection DecodeSRT0Keyframes(SRT0TextureEntry *entry, int numFrames) { KeyframeCollection kf = new KeyframeCollection(numFrames); bfloat * sPtr = (bfloat *)entry->Data; SRT0Code code = entry->Code; if (!code.NoScale) { if (code.ScaleIsotropic) { if (code.FixedScaleX) { kf[KeyFrameMode.ScaleXYZ, 0] = *sPtr++; } else { DecodeSRT0Frames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, KeyFrameMode.ScaleXYZ); } } else { if (code.FixedScaleX) { kf[KeyFrameMode.ScaleX, 0] = *sPtr++; } else { DecodeSRT0Frames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, KeyFrameMode.ScaleX); } if (code.FixedScaleY) { kf[KeyFrameMode.ScaleY, 0] = *sPtr++; } else { DecodeSRT0Frames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, KeyFrameMode.ScaleY); } } } if (!code.NoRotation) { if (code.FixedRotation) { kf[KeyFrameMode.RotX, 0] = *sPtr++; } else { DecodeSRT0Frames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, KeyFrameMode.RotX); } } if (!code.NoTranslation) { if (code.FixedX) { kf[KeyFrameMode.TransX, 0] = *sPtr++; } else { DecodeSRT0Frames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, KeyFrameMode.TransX); } if (code.FixedY) { kf[KeyFrameMode.TransY, 0] = *sPtr++; } else { DecodeSRT0Frames(kf, (VoidPtr)sPtr + *(buint *)sPtr++, KeyFrameMode.TransY); } } return(kf); }
private static void DecodeCHR0Frames(KeyframeCollection kf, void *dataAddr, AnimDataFormat format, KeyFrameMode mode) { int fCount; float vStep, vBase; switch (format) { case AnimDataFormat.I4: { I4Header *header = (I4Header *)dataAddr; fCount = header->_entries; vStep = header->_step; vBase = header->_base; I4Entry *entry = header->Data; for (int i = 0; i < fCount; i++, entry++) { kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->Step * vStep))._tangent = entry->Tangent; } break; } case AnimDataFormat.I6: { I6Header *header = (I6Header *)dataAddr; fCount = header->_numFrames; vStep = header->_step; vBase = header->_base; I6Entry *entry = header->Data; for (int i = 0; i < fCount; i++, entry++) { kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->_step * vStep))._tangent = entry->Tangent; } break; } case AnimDataFormat.I12: { I12Header *header = (I12Header *)dataAddr; fCount = header->_numFrames; I12Entry *entry = header->Data; for (int i = 0; i < fCount; i++, entry++) { kf.SetFrameValue(mode, (int)entry->_index, entry->_value)._tangent = entry->_tangent; } break; } case AnimDataFormat.L1: { L1Header *header = (L1Header *)dataAddr; vStep = header->_step; vBase = header->_base; byte *sPtr = header->Data; for (int i = 0; i < kf.FrameCount; i++) { kf[mode, i] = vBase + (*sPtr++ *vStep); } KeyframeEntry root = kf._keyRoots[(int)mode & 0xF]; for (KeyframeEntry entry = root._next; entry != root; entry = entry._next) { entry.GenerateTangent(); } break; } case AnimDataFormat.L2: { L1Header *header = (L1Header *)dataAddr; vStep = header->_step; vBase = header->_base; bushort *sPtr = (bushort *)header->Data; for (int i = 0; i < kf.FrameCount; i++) { kf[mode, i] = vBase + (*sPtr++ *vStep); } KeyframeEntry root = kf._keyRoots[(int)mode & 0xF]; for (KeyframeEntry entry = root._next; entry != root; entry = entry._next) { entry.GenerateTangent(); } break; } case AnimDataFormat.L4: { bfloat *sPtr = (bfloat *)dataAddr; for (int i = 0; i < kf.FrameCount; i++) { kf[mode, i] = *sPtr++; } KeyframeEntry root = kf._keyRoots[(int)mode & 0xF]; for (KeyframeEntry entry = root._next; entry != root; entry = entry._next) { entry.GenerateTangent(); } break; } } }