def __init__(self, f):
self.version = readU32(f)
self.ID = f.read(4).decode("utf-8-sig")
self.padding = readU64(f)
self.pointersOffs = readU64(
f) # uint64 pointersOffs <format=hex>; // AssetsPointer in Tyrant
self.colOffs = readU64(
f) # uint64 colOffs <format=hex>; // UnkPointer
self.motListNameOffs = readU64(
f) # uint64 motListNameOffs <format=hex>; //NamePointer
if self.version != 60:
self.padding = readU64(f) #uint64 padding; //UnkPointer01
self.numOffs = readU32(f) # AssetCount
f.seek(self.motListNameOffs)
self.motListName = read_wstring(f)
#pos = f.tell()
#--gather pointers and pointer names:
f.seek(self.pointersOffs)
self.POINTERS = []
for i in range(0, self.numOffs):
if self.version == 13 or self.version == 14:
self.POINTERS.append(PointerMcam(f))
else:
self.POINTERS.append(Pointer(f))
print(str(i) + "_" + self.POINTERS[i].motName)
def __init__(self, f, start):
self.boneNameOffs = readU64(f)
position = f.tell()
f.seek(self.boneNameOffs + start)
self.boneName = read_wstring(f)
f.seek(position)
self.parentOffs = readU64(f)
self.childOffs = readU64(f)
self.nextSiblingOffs = readU64(f)
self.translation = [
readFloat(f),
readFloat(f),
readFloat(f),
readFloat(f)
]
self.quaternion = [
readFloat(f),
readFloat(f),
readFloat(f),
readFloat(f)
]
self.Index = readU32(f)
self.boneHash = readU32(f) # uint //MurMur3
self.padding = readU64(f)
def __init__(self, f):
self.zero = readU64(f)
self.s1 = readUShort(f)
self.s2 = readUShort(f)
self.numFrames = readU32(f)
self.framerate = readU32(f)
self.endFrame = readFloat(f)
#//?
self.framesOffset = readU64(f)
self.dataOffset = readU64(f)
def __init__(self, f, start):
self.boneHdrOffs = readU64(f)
self.boneHdrCount = readU64(f)
if (self.boneHdrCount <= 1000):
self.BONE_HEADER = []
for i in range(0, self.boneHdrCount):
self.BONE_HEADER.append(BoneHeader(f, start))
self.BONE_NAME = []
for i in range(0, self.boneHdrCount):
self.BONE_NAME.append(BoneName(f, start))
def __init__(self, f, start):
self.version = readU32(f) # uint version;
self.ID = f.read(4).decode("utf-8-sig") # uint32 magic;
f.seek(8, 1) #FSkip(8);
self.motionTrackStartOffset = readU64(f)
self.zoomStartOffset = readU64(f)
self.thirdOffset = readU64(f)
self.forthOffset = readU64(f)
self.nameStringOffset = readU64(f)
self.uknShort = readUShort(f)
self.frameRate = readUShort(f)
self.frameCount = readFloat(f)
self.blending = readFloat(f)
def __init__(self, f, start, version):
if version == 14:
## ZOOM START
a1 = readU32(f)
b1 = readU32(f)
## ZOOM
self.zoomHdr = TrackHeader(f)
else:
s = readUShort(f)
s = readUShort(f)
i = readU32(f)
ukn = readU32(f)
ukn2 = readU32(f)
offsetStart = readU64(f)
self.zoomHdr = TrackHeaderRE2(f)
## ZOOM Framelist
if (self.zoomHdr.framesOffset > 0):
f.seek(self.zoomHdr.framesOffset + start)
self.ZOOM_TIMES = [
readUByte(f) for _ in range(self.zoomHdr.numFrames)
]
## ZOOM DATA
f.seek(self.zoomHdr.dataOffset + start)
self.ZOOM_DATA = [Vector3(f) for _ in range(self.zoomHdr.numFrames)]
def __init__(self, f):
self.Address = readU64(f)
##get string and return
pos = f.tell()
self.motName = read_wstring(f, address=self.Address + 68)
f.seek(pos)
if self.Address == 0:
self.motName = ""
def __init__(self, f, MOT):
start = MOT.start
MOT_HEADER = MOT.MOT_HEADER
self.flags = readU32(
f) #<format=binary>; //track compression among them
self.keyCount = readU32(f)
if (MOT_HEADER.version == 78): #//40 bytes RE2, 20 bytes RE3
self.frameIndOffs = readU32(f) # <format=hex>;uint32
self.frameDataOffs = readU32(f) # <format=hex>;uint32
self.unpackDataOffs = readU32(f) # <format=hex>uint32
else:
self.frameRate = readU32(f)
self.maxFrame = readFloat(f) #float
self.frameIndOffs = readU64(f) # <format=hex>; uint64
self.frameDataOffs = readU64(f) # <format=hex>; uint64
self.unpackDataOffs = readU64(f) # <format=hex>; uint64
cmprssn = self.flags >> 20 # local ubyte cmprssn <name="Track compression type"> = flags >> 20;
keyFrameDataType = self.flags & 0xF00000 # local uint keyFrameDataType <format=hex> = flags & 0xF00000;
compression = self.flags & 0xF00000 # local uint compression <format=hex> = flags & 0xFF000;
unkFlag = self.flags & 0xFFF # local uint unkFlag <format=hex> = flags & 0xFFF;
def __init__(self, f, start):
self.version = readU32(f) #uint
self.ID = f.read(4).decode("utf-8-sig") #readU32(f) # char
self.ukn00 = readU32(f) # uint32
self.uknOffs = readU32(f) #uint32
self.offsToBoneHdrOffs = readU64(f) #uint64 #BoneBaseDataPointer
self.boneClipHdrOffs = readU64(
f) #uint64 FSkip(16) = readU32(f) #BoneDataPointer
f.seek(16, 1)
self.clipFileOffset = readU64(f) #uint64
self.Offs1 = readU64(f) # uint64
f.seek(8, 1)
self.Offs2 = readU64(f) #uint64
self.namesOffs = readU64(f) #uint64 #namePointer
self.frameCount = readFloat(f) #frameCount
self.blending = readFloat(f)
self.uknFloat = readFloat(f)
self.uknFloat = readFloat(f)
self.boneCount = readUShort(f) #ushort
self.boneClipCount = readUShort(f) #ushort
self.uknPointer2Count = readUByte(f) #ubyte
self.uknPointer3Count = readUByte(f) # ubyte
self.FrameRate = readUShort(f)
self.uknPointerCount = readUShort(f)
self.uknShort = readUShort(f)
f.seek(self.namesOffs + start)
self.MOT_NAME = read_wstring(f)
def __init__(self, f, MOT):
start = MOT.start
MOT_HEADER = MOT.MOT_HEADER
BONE_HEADERS = MOT.BONE_HEADERS
MOT_LIST = MOT.MOT_LIST
if (MOT_HEADER.version == 65):
self.boneIndex = readUShort(f)
#ushort
self.trackFlags = readUShort(f)
#trckFlg_t #// flags for type: translations ?+ rotations xor scales
self.boneHash = readU32(f)
#uint32 # // MurMur3
self.uknFloat = readFloat(f)
#float # // always 1.0?
self.padding = readI32(f)
#uint32
self.trackHdrOffs = readU64(f)
#uint64 # //keysPointer
elif (MOT_HEADER.version == 78 or MOT_HEADER.version == 43):
self.boneIndex = readUShort(f)
#ushort
self.trackFlags = readUShort(f)
#trckFlg_t #// flags for type: translations ?+ rotations xor scales
self.boneHash = readU32(f)
#uint32 # // MurMur3
if MOT_HEADER.version == 43:
self.trackHdrOffs = readU64(f)
else:
self.trackHdrOffs = readU32(f)
if hasattr(BONE_HEADERS, 'BONE_HEADER'):
for x in BONE_HEADERS.BONE_HEADER:
if x.boneHash == self.boneHash:
self.name = x.boneName
break
else:
for x in MOT_LIST[boneHeadersIdx].BONE_HEADERS.BONE_HEADER:
if x.boneHash == self.boneHash:
self.name = x.boneName
break
def __init__(self, f, start, version):
## ROTATE AND TRANSLATE START
if version == 14:
a1 = readU32(f)
b1 = readU32(f)
self.translateHdr = TrackHeader(f)
self.rotateHdr = TrackHeader(f)
else:
s = readUShort(f)
s = readUShort(f)
i = readU32(f)
ukn = readU32(f)
ukn2 = readU32(f)
offsetStart = readU64(f)
self.translateHdr = TrackHeaderRE2(f)
self.rotateHdr = TrackHeaderRE2(f)
## TRANSLATE Framelist
if (self.translateHdr.framesOffset > 0):
f.seek(self.translateHdr.framesOffset + start)
self.TRANSLATE_TIMES = [
readUByte(f) for _ in range(self.translateHdr.numFrames)
]
## TRANSLATE DATA
f.seek(self.translateHdr.dataOffset + start)
self.TRANSLATE_DATA = [
Vector3(f) for _ in range(self.translateHdr.numFrames)
]
## ROTATE Framelist
if (self.rotateHdr.framesOffset > 0):
f.seek(self.rotateHdr.framesOffset + start)
self.ROTATE_TIMES = [
readUByte(f) for _ in range(self.rotateHdr.numFrames)
]
## ROTATE DATA
f.seek(self.rotateHdr.dataOffset + start)
self.ROTATE_DATA = [Quat(f) for _ in range(self.rotateHdr.numFrames)]
def __init__(self, f, MOT, keyCount, flags, frame, framedatarot,
CUR_BONE_NAME): #uint32 keyCount, uint32 flags
start = MOT.start
self.RotationTypeString = get_rotation_type(flags, MOT)
self.CUR_BONE_NAME = CUR_BONE_NAME
if hasattr(framedatarot, 'unpackData'):
MinUnpackX = framedatarot.unpackData[4]
MinUnpackY = framedatarot.unpackData[5]
MinUnpackZ = framedatarot.unpackData[6]
MinUnpackW = framedatarot.unpackData[7]
MaxUnpackX = framedatarot.unpackData[0]
MaxUnpackY = framedatarot.unpackData[1]
MaxUnpackZ = framedatarot.unpackData[2]
MaxUnpackW = framedatarot.unpackData[3]
else:
pass
#print("find unpack? should be LoadVector3sFull")
MOT_HEADER = MOT.MOT_HEADER
##unpackData = framedatarot.unpackData
if hasattr(framedatarot, 'KEYS'):
self.inverse = False
self.Time = framedatarot.KEYS.frameIndex[frame]
flagsEval = flags & 0xFF000
if (flagsEval == 0x00000): #//LoadQuaternionsFull
self.RotationX = readFloat(f)
self.RotationY = readFloat(f)
self.RotationZ = readFloat(f)
self.RotationW = readFloat(f)
return
# case 0x00000:
# float RotationX, RotationY, RotationZ, RotationW;
# break;
if (flagsEval == 0xB0000 or flagsEval
== 0xC0000): # //LoadQuaternions3Component
self.RotationX = readFloat(f)
self.RotationY = readFloat(f)
self.RotationZ = readFloat(f)
#if (SKIP) break;
self.RotationW = wRot(self)
# local float
return
if (flagsEval == 0x20000): # //LoadQuaternions5Bit RE3
RotationData = readUShort(f) #ushort #if (SKIP) return;
self.RotationX = (MaxUnpackX * ((RotationData >> 00) & 0x1F) *
(1.0 / 0x1F)) + MinUnpackX
self.RotationY = (MaxUnpackY * ((RotationData >> 05) & 0x1F) *
(1.0 / 0x1F)) + MinUnpackY
self.RotationZ = (MaxUnpackZ * ((RotationData >> 10) & 0x1F) *
(1.0 / 0x1F)) + MinUnpackZ
self.RotationW = wRot(self)
return
#BiLinearSCQuat3_16bitController in revilmax
if (
flagsEval == 0x21000
): # //LoadQuaternionsXAxis16Bit ##static constexpr uint32 ID1 = 0x21112; Revilmax
#RotationData = readUShort(f)#ushort #if (SKIP) return;
RotationData = readUShort(f) #ushort #if (SKIP) return;
self.RotationX = MaxUnpackX * (RotationData /
65535.0) + MaxUnpackY
##CHANGED LOOK INTO
self.RotationY = 0.0
self.RotationZ = 0.0
self.RotationW = wRot(self)
# check = 1.0 - (self.RotationX * self.RotationX + self.RotationY * self.RotationY + self.RotationZ * self.RotationZ)
# if check < 0:
# self.inverse = True
# self.RotationW = 2.0
return
if (flagsEval == 0x22000): # //LoadQuaternionsYAxis16Bit
RotationData = readUShort(f) #ushort #if (SKIP) return;
self.RotationX = 0.0
self.RotationY = MaxUnpackX * (RotationData /
65535.0) + MaxUnpackY
##CHANGED LOOK INTO
self.RotationZ = 0.0
self.RotationW = wRot(self)
return
if (flagsEval == 0x23000): # //LoadQuaternionsZAxis16Bit
RotationData = readUShort(f) #ushort #if (SKIP) return;
self.RotationX = 0.0
self.RotationY = 0.0
self.RotationZ = MaxUnpackX * (RotationData /
65535.0) + MaxUnpackY
##CHANGED LOOK INTO
self.RotationW = wRot(self)
return
if (flagsEval == 0x30000): # //LoadQuaternions10Bit RE2
if (MOT_HEADER.version == 78): #/LoadQuaternions8Bit RE3
RotationDataX = readUByte(
f
) #ubyte RotationDataX, RotationDataY, RotationDataZ; #if (SKIP) return;
RotationDataY = readUByte(f)
RotationDataZ = readUByte(f)
componentMultiplier = 1.0 / 0xff
self.RotationX = (
(RotationDataX * componentMultiplier) * MaxUnpackX
) + MinUnpackX #(MaxUnpackX * (RotationDataX * 0.000015259022)) + MinUnpackX;
self.RotationY = (
(RotationDataY * componentMultiplier) * MaxUnpackY
) + MinUnpackY #(MaxUnpackY * (RotationDataY * 0.000015259022)) + MinUnpackY;
self.RotationZ = (
(RotationDataZ * componentMultiplier) * MaxUnpackZ
) + MinUnpackZ #(MaxUnpackZ * (RotationDataZ * 0.000015259022)) + MinUnpackZ;
self.RotationX = self.RotationX * 1.0
self.RotationY = self.RotationY * 1.0
self.RotationZ = self.RotationZ * 1.0
self.RotationW = wRot(self)
return
if (flagsEval == 0x40000
or (MOT_HEADER.version == 65 and flagsEval == 0x30000)
): # //LoadQuaternions10Bit RE3 #TEETH ROT
RotationData = readU32(f) #uint32 #if (SKIP) return;
componentMultiplier = 1.0 / 0x3FF
self.RotationX = (MaxUnpackX * (
(RotationData >> 00) & 0x3FF) / 1023.0) + MinUnpackX
self.RotationY = (MaxUnpackY * (
(RotationData >> 10) & 0x3FF) / 1023.0) + MinUnpackY
self.RotationZ = (MaxUnpackZ * (
(RotationData >> 20) & 0x3FF) / 1023.0) + MinUnpackZ
self.RotationW = wRot(self)
return
if (flagsEval == 0x31000 or flagsEval
== 0x41000): # //LoadQuaternionsXAxis
self.RotationX = readFloat(f) #float
self.RotationY = 0.0
self.RotationZ = 0.0
#if (SKIP) return;
self.RotationW = wRot(self)
return
if (flagsEval == 0x32000 or flagsEval
== 0x42000): # //LoadQuaternionsYAxis
self.RotationX = 0.0
self.RotationY = readFloat(f)
self.RotationZ = 0.0
#if (SKIP) return;
self.RotationW = wRot(self)
return
if (flagsEval == 0x33000 or flagsEval
== 0x43000): # //LoadQuaternionsZAxis
self.RotationX = 0.0
self.RotationY = 0.0
self.RotationZ = readFloat(f)
#if (SKIP) return;
self.RotationW = wRot(self)
return
if (flagsEval == 0x50000): # //LoadQuaternions16Bit RE2
if (MOT_HEADER.version == 78): #//LoadQuaternions13Bit RE3
#uint64 RotationData : 40;
# RotationData = readU64(f)
# f.seek(-3, 1); #if (SKIP) return;
rd = f.read(5)
RotationData = (
(ord(rd[0]) | 0x0000000000000000) << 32) | (
(ord(rd[1]) | 0x0000000000000000) << 24) | (
(ord(rd[2]) | 0x0000000000000000) << 16) | (
(ord(rd[3]) | 0x0000000000000000) << 8) | (
(ord(rd[4]) | 0x0000000000000000) << 0)
self.RotationX = ((MaxUnpackX * (
(RotationData >> 00) & 0x1FFF) * 0.00012208521) +
MinUnpackX)
self.RotationY = ((MaxUnpackY * (
(RotationData >> 13) & 0x1FFF) * 0.00012208521) +
MinUnpackY)
self.RotationZ = ((MaxUnpackZ * (
(RotationData >> 26) & 0x1FFF) * 0.00012208521) +
MinUnpackZ)
self.RotationW = wRot(self)
return
if (flagsEval == 0x60000
or (MOT_HEADER.version == 65 and flagsEval
== 0x50000)): # //LoadQuaternions16Bit RE3
#ushort RotationDataX, RotationDataY, RotationDataZ; #if (SKIP) return;
RotationDataX = readUShort(f)
RotationDataY = readUShort(f)
RotationDataZ = readUShort(f)
self.RotationX = (MaxUnpackX * (RotationDataX / 65535.0) +
MinUnpackX)
self.RotationY = (MaxUnpackY * (RotationDataY / 65535.0) +
MinUnpackY)
self.RotationZ = (MaxUnpackZ * (RotationDataZ / 65535.0) +
MinUnpackZ)
self.RotationW = wRot(self)
return
if (flagsEval == 0x70000): # //LoadQuaternions21Bit RE2
if (MOT_HEADER.version == 78): #//LoadQuaternions18Bit RE3
#uint64 RotationData : 56;
# RotationData = readU64(f)
# f.skip(-1,1)#FSkip(-1); #if (SKIP) return;
rd = f.read(7)
RotationData = (
(ord(rd[0]) | 0x0000000000000000) << 48
) | ((ord(rd[1]) | 0x0000000000000000) << 40) | (
(ord(rd[2]) | 0x0000000000000000) << 32) | (
(ord(rd[3]) | 0x0000000000000000) << 24) | (
(ord(rd[4]) | 0x0000000000000000) << 16) | (
(ord(rd[5]) | 0x0000000000000000) << 8) | (
(ord(rd[6]) | 0x0000000000000000) << 0)
self.RotationX = (MaxUnpackX *
((RotationData >> 00) & 0x1FFF) *
0.00012208521) + MinUnpackX
self.RotationY = (MaxUnpackY *
((RotationData >> 13) & 0x1FFF) *
0.00012208521) + MinUnpackY
self.RotationZ = (MaxUnpackZ *
((RotationData >> 26) & 0x1FFF) *
0.00012208521) + MinUnpackZ
self.RotationW = wRot(self)
return
if (flagsEval == 0x80000
or (MOT_HEADER.version == 65 and flagsEval
== 0x70000)): # //LoadQuaternions21Bit RE3
RotationData = readU64(f)
#uint64 #if (SKIP) return;
self.RotationX = (MaxUnpackX * (
(RotationData >> 00) & 0x1FFFFF) / 2097151.0) + MinUnpackX
self.RotationY = (MaxUnpackY * (
(RotationData >> 21) & 0x1FFFFF) / 2097151.0) + MinUnpackY
self.RotationZ = (MaxUnpackZ * (
(RotationData >> 42) & 0x1FFFFF) / 2097151.0) + MinUnpackZ
self.RotationW = wRot(self)
return
print("uh oh")
def __init__(self, f, MOT, keyCount, flags, frame,
FrameDataTrns): #uint32 keyCount, uint32 flags
start = MOT.start
MOT_HEADER = MOT.MOT_HEADER
if hasattr(FrameDataTrns, 'unpackData'):
unpackData = FrameDataTrns.unpackData
else:
pass
#print("find unpack? should be LoadVector3sFull")
##unpackData = FrameDataTrns.unpackData
if hasattr(FrameDataTrns, 'KEYS'):
Time = FrameDataTrns.KEYS.frameIndex[frame]
flagsEval = flags & 0xFF000
if (flagsEval == 0x00000): #//LoadVector3sFull
self.X = VectorFull(readFloat(f)).VectorRead()
self.Y = VectorFull(readFloat(f)).VectorRead()
self.Z = VectorFull(readFloat(f)).VectorRead()
return
#'VectorFull TranslationX, TranslationZ, TranslationY;
if (flagsEval == 0x20000):
self.TranslationData = readUShort(
f) #if (SKIP) break; # ushort
if (MOT_HEADER.version == 65
or MOT_HEADER.version == 43): #//LoadVector3s5BitA RE2
self.X = unpackData[0] * (
((self.TranslationData >> 00) & 0x1F) *
(1.0 / 0x1F)) + unpackData[4] #local float
self.Y = unpackData[1] * (
((self.TranslationData >> 05) & 0x1F) *
(1.0 / 0x1F)) + unpackData[5] #local float
self.Z = unpackData[2] * (
((self.TranslationData >> 10) & 0x1F) *
(1.0 / 0x1F)) + unpackData[6] #local float
else: # //LoadVector3s5BitB RE3
self.X = unpackData[0] * (
((self.TranslationData >> 00) & 0x1F) *
(1.0 / 0x1F)) + unpackData[3] #local float
self.Y = unpackData[1] * (
((self.TranslationData >> 05) & 0x1F) *
(1.0 / 0x1F)) + unpackData[4] #local float
self.Z = unpackData[2] * (
((self.TranslationData >> 10) & 0x1F) *
(1.0 / 0x1F)) + unpackData[5] #local float
return
if (flagsEval == 0x34000):
if (MOT_HEADER.version == 65): #//LoadScalesXYZ RE2
self.X = readFloat(f) #float X;
self.Y = self.X #local float Y = X;
self.Z = self.X #local float Z = X;
return #break;
if (flagsEval == 0x30000): #//LoadVector3s10BitA RE2
if (MOT_HEADER.version == 78): #//LoadVector3s5BitB RE3
self.TranslationData = readUShort(f)
# #if (SKIP) break;
self.X = unpackData[0] * ((
(self.TranslationData >> 00) & 0x1F) *
(1.0 / 0x1F)) + unpackData[3]
self.Y = unpackData[1] * ((
(self.TranslationData >> 05) & 0x1F) *
(1.0 / 0x1F)) + unpackData[4]
self.Z = unpackData[2] * ((
(self.TranslationData >> 10) & 0x1F) *
(1.0 / 0x1F)) + unpackData[5]
return
if (flagsEval == 0x40000):
self.TranslationData = readU32(f) #uint32 #if (SKIP) break;
if (MOT_HEADER.version == 65 or MOT_HEADER.version
== 43): #//LoadVector3s10BitA RE2
self.X = unpackData[0] * ((
(self.TranslationData >> 00) & 0x3FF) *
(1.0 / 0x3FF)) + unpackData[4]
self.Y = unpackData[1] * ((
(self.TranslationData >> 10) & 0x3FF) *
(1.0 / 0x3FF)) + unpackData[5]
self.Z = unpackData[2] * ((
(self.TranslationData >> 20) & 0x3FF) *
(1.0 / 0x3FF)) + unpackData[6]
else: # //LoadVector3s10BitB RE3
self.X = unpackData[0] * ((
(self.TranslationData >> 00) & 0x3FF) *
(1.0 / 0x3FF)) + unpackData[3]
self.Y = unpackData[1] * ((
(self.TranslationData >> 10) & 0x3FF) *
(1.0 / 0x3FF)) + unpackData[4]
self.Z = unpackData[2] * ((
(self.TranslationData >> 20) & 0x3FF) *
(1.0 / 0x3FF)) + unpackData[5]
return
if (flagsEval == 0x70000): # //LoadVector3s21BitA RE2
self.TranslationData = readU64(f) #uint64 #if (SKIP) break;
self.X = unpackData[0] * ((
(self.TranslationData >> 00) & 0x1FFFFF) /
2097151.0) + unpackData[4]
self.Y = unpackData[1] * ((
(self.TranslationData >> 21) & 0x1FFFFF) /
2097151.0) + unpackData[5]
self.Z = unpackData[2] * ((
(self.TranslationData >> 42) & 0x1FFFFF) /
2097151.0) + unpackData[6]
return
if (flagsEval == 0x80000): # //LoadVector3s21BitB RE3
self.TranslationData = readU64(f) #uint64 #if (SKIP) break;
self.X = unpackData[0] * ((
(self.TranslationData >> 00) & 0x1FFFFF) /
2097151.0) + unpackData[3]
self.Y = unpackData[1] * ((
(self.TranslationData >> 21) & 0x1FFFFF) /
2097151.0) + unpackData[4]
self.Z = unpackData[2] * ((
(self.TranslationData >> 42) & 0x1FFFFF) /
2097151.0) + unpackData[5]
return
if (flagsEval == 0x31000 or flagsEval == 0x41000
): # //LoadVector3sXAxis RE2 // RE3
self.X = readFloat(f)
self.Y = unpackData[1]
self.Z = unpackData[2]
return
if (flagsEval == 0x32000 or flagsEval == 0x42000
): # //LoadVector3sYAxis RE2 // RE3
self.X = unpackData[0]
self.Y = readFloat(f) # float
self.Z = unpackData[2]
return
if (flagsEval == 0x33000 or flagsEval == 0x43000
): # //LoadVector3sZAxis RE2 // RE3
self.X = unpackData[0]
self.Y = unpackData[1]
self.Z = readFloat(f) #float
return
if (flagsEval == 0x21000): # //LoadVector3sXAxis16Bit
self.TranslationData = readUShort(
f) # ushort #if (SKIP) break;
self.X = unpackData[0] * (self.TranslationData /
65535.0) + unpackData[1]
self.Y = unpackData[2]
self.Z = unpackData[3]
return
if (flagsEval == 0x22000): # //LoadVector3sYAxis16Bit
self.TranslationData = readUShort(f) # #if (SKIP) break;
self.X = unpackData[1]
self.Y = unpackData[0] * (self.TranslationData /
65535.0) + unpackData[2]
self.Z = unpackData[3]
return
if (flagsEval == 0x23000
): # //LoadVector3sZAxis16Bit
self.TranslationData = readUShort(f) # #if (SKIP) break;
self.X = unpackData[1]
self.Y = unpackData[2]
self.Z = unpackData[0] * (self.TranslationData /
65535.0) + unpackData[3]
return
if (flagsEval == 0x24000): # //LoadVector3sXYZAxis16Bit RE3
self.TranslationData = readUShort(f) # #if (SKIP) break;
self.X = unpackData[0] * (self.TranslationData /
65535.0) + unpackData[3]
self.Y = self.X
self.Z = self.X
return
if (flagsEval == 0x44000): # //LoadVector3sXYZAxis RE3
self.TranslationData = readFloat(f)
self.X = self.TranslationData
self.Y = self.TranslationData
self.Z = self.TranslationData
return
print("uh oh")
