def LoadVertex(self, Node, FileStream, Offset):
        try:
            Node.PointsCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.PointsCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.PointsTable.append(Vec)

            if Node.PointsCount:
                Node.CalculateLocalBoundingBox()

            Node.NormalsCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.NormalsCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.NormalsTable.append(Vec)

            Node.TangentTanCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.TangentTanCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Vec4 = datatypes.FVector4.FromVec3(Vec)
                Node.TangentTanTable.append(Vec4)

            Node.TangentBinCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.TangentBinCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.TangentBinTable.append(Vec)

            Node.TexCoordCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.TexCoordCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.TexCoordTable.append(Vec)
        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
    def LoadVisibilityKey(self, Node, FileStream, Offset=None):
        try:
            if globalvars.CurrentAniFileVersion >= raidflags.EXPORTER_ANI_VER5:
                VisCount = binaryreader.ReadInt(FileStream, 1)[0]
                Node.VisKeyTrack.Count = VisCount
                if VisCount:
                    for i in range(VisCount):
                        VisKey = datatypes.FVisKey()
                        VisKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        VisKey.Vis = binaryreader.ReadFloat(FileStream, 1)[0]
                        if VisKey.Vis < 0.0:
                            VisKey.Vis = 0.0
                        Node.VisKeyTrack.Data.append(VisKey)
                    return True
            else:
                VisCount = binaryreader.ReadInt(FileStream, 1)[0]
                Node.VisKeyTrack.Count = VisCount
                if VisCount:
                    for i in range(VisCount):
                        VisKey = datatypes.FVisKey()
                        VisKey.Vis = binaryreader.ReadFloat(FileStream, 1)[0]
                        if VisKey.Vis < 0.0:
                            VisKey.Vis = 0.0
                        VisKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        Node.VisKeyTrack.Data.append(VisKey)
                    return True
            return False

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
 def LoadVertexAniBoundingBox(self, Node, FileStream):
     try:
         Node.BoundingBox.vmin = datatypes.FVector(
             binaryreader.ReadFloat(FileStream, 3))
         Node.BoundingBox.vmax = datatypes.FVector(
             binaryreader.ReadFloat(FileStream, 3))
     except struct.error as err:
         errorhandling.HandleStructUnpackError(err)
 def LoadEtc(self, Node, FileStream, Offset):
     super().LoadEtc(Node, FileStream, Offset)
     try:
         Node.BoundingBox.vmin = datatypes.FVector(
             binaryreader.ReadFloat(FileStream, 3))
         Node.BoundingBox.vmax = datatypes.FVector(
             binaryreader.ReadFloat(FileStream, 3))
     except struct.error as err:
         errorhandling.HandleStructUnpackError(err)
    def LoadBoneAni(self, Node, FileStream, Offset=None):
        try:
            Node.Name = binaryreader.ReadWord(FileStream)
            if globalvars.CurrentAniFileVersion >= raidflags.EXPORTER_ANI_VER6:
                Node.ParentName = binaryreader.ReadWord(FileStream)

            Node.LocalMatrix = datatypes.FMatrix(
                binaryreader.ReadFloat(FileStream, 16))

            PosKeyNum = binaryreader.ReadInt(FileStream, 1)[0]
            if PosKeyNum:
                Node.PositionKeyTrack.Count = PosKeyNum + 1
                for i in range(PosKeyNum):
                    PosKey = datatypes.FVecKey()
                    PosKey.Vector = datatypes.FVector(
                        binaryreader.ReadFloat(FileStream, 3))
                    PosKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    Node.PositionKeyTrack.Data.append(PosKey)
                LastPosKey = Node.PositionKeyTrack.Data[PosKeyNum - 1]
                Node.PositionKeyTrack.Data.append(LastPosKey)

            RotKeyNum = binaryreader.ReadInt(FileStream, 1)[0]
            if RotKeyNum:
                Node.RotationKeyTrack.Count = RotKeyNum + 1
                for i in range(RotKeyNum):
                    QuatKey = datatypes.FQuatKey()
                    QuatKey.Quat = datatypes.FQuaternion(
                        binaryreader.ReadFloat(FileStream, 4))
                    QuatKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    Node.RotationKeyTrack.Data.append(QuatKey)
                LastQuatKey = Node.RotationKeyTrack.Data[RotKeyNum - 1]
                Node.RotationKeyTrack.Data.append(LastQuatKey)

            if globalvars.CurrentAniFileVersion >= raidflags.EXPORTER_ANI_VER5:
                ScaleCount = binaryreader.ReadInt(FileStream, 1)[0]
                if ScaleCount:
                    Node.ScaleKeyTrack.Count = ScaleCount
                    for i in range(ScaleCount):
                        ScaleKey = datatypes.FVecKey()
                        ScaleKey.Vector = datatypes.FVector(
                            binaryreader.ReadFloat(FileStream, 3))
                        ScaleKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        Node.ScaleKeyTrack.Data.append(ScaleKey)

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
    def LoadBoneAni(self, Node, FileStream, Offset=None):
        try:
            Node.Name = binaryreader.ReadWord(FileStream)
            Node.ParentName = binaryreader.ReadWord(FileStream)
            Node.LocalMatrix = datatypes.FMatrix(
                binaryreader.ReadFloat(FileStream, 16))

            AnimType_1 = datatypes.FAnimType(
                binaryreader.ReadInt(FileStream, 3))
            if AnimType_1.Count > 0:
                Node.PositionKeyTrack.Count = AnimType_1.Count + 1
                for i in range(AnimType_1.Count):
                    PosKey = datatypes.FVecKey()
                    PosKey.Vector = datatypes.FVector(
                        binaryreader.ReadFloat(FileStream, 3))
                    PosKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    Node.PositionKeyTrack.Data.append(PosKey)
                LastPosKey = Node.PositionKeyTrack.Data[AnimType_1.Count - 1]
                Node.PositionKeyTrack.Data.append(LastPosKey)

            AnimType_2 = datatypes.FAnimType(
                binaryreader.ReadInt(FileStream, 3))
            if AnimType_2.Count > 0:
                Node.RotationKeyTrack.Count = AnimType_2.Count + 1
                for i in range(AnimType_2.Count):
                    QuatKey = datatypes.FQuatKey()
                    QuatKey.Quat = datatypes.FQuaternion(
                        binaryreader.ReadFloat(FileStream, 4))
                    QuatKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    Node.RotationKeyTrack.Data.append(QuatKey)
                LastQuatKey = Node.RotationKeyTrack.Data[AnimType_2.Count - 1]
                Node.RotationKeyTrack.Data.append(LastQuatKey)

            AnimType_3 = datatypes.FAnimType(
                binaryreader.ReadInt(FileStream, 3))
            if AnimType_3.Count > 0:
                Node.ScaleKeyTrack.Count = AnimType_3.Count
                for i in range(AnimType_3.Count):
                    ScaleKey = datatypes.FVecKey()
                    ScaleKey.Vector = datatypes.FVector(
                        binaryreader.ReadFloat(FileStream, 3))
                    ScaleKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    Node.ScaleKeyTrack.Data.append(ScaleKey)

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
    def LoadInfo(self, Node, FileStream, Offset):
        try:
            Node.LocalMatrix = datatypes.FMatrix(
                binaryreader.ReadFloat(FileStream, 16))

            Node.BaseVisibility = binaryreader.ReadFloat(FileStream, 1)[0]
            Node.dwFlag = binaryreader.ReadUInt(FileStream, 1)[0]
            try:
                Node.MeshAlign = datatypes.RMeshAlign(
                    binaryreader.ReadInt(FileStream, 1)[0])
            except ValueError as er:
                Message = "Node.MeshAlign value is out of allowed range."
                filelogger.AddLog(globalvars.LogFileStream, Message,
                                  filelogger.LogType.LogType_Warning)
            Node.LODProjectIndex = binaryreader.ReadInt(FileStream, 1)[0]

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
    def LoadVisibilityKey(self, Node, FileStream, Offset=None):
        try:
            AnimType = datatypes.FAnimType(binaryreader.ReadInt(FileStream, 3))
            if AnimType.Count > 0:
                Node.VisKeyTrack.Count = AnimType.Count
                for i in range(AnimType.Count):
                    VisKey = datatypes.FVisKey()
                    VisKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    VisKey.Vis = binaryreader.ReadFloat(FileStream, 1)[0]
                    Node.VisKeyTrack.Data.append(VisKey)

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
    def LoadVertex(self, Node, FileStream, Offset):
        try:
            dwFVF = binaryreader.ReadUInt(FileStream, 1)[0]
            LightMapID = binaryreader.ReadInt(FileStream, 1)[0]

            Node.PointsCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.PointsCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.PointsTable.append(Vec)

            if Node.PointsCount:
                Node.CalculateLocalBoundingBox()

            Node.NormalsCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.NormalsCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.NormalsTable.append(Vec)

            Node.TangentTanCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.TangentTanCount):
                Vec = datatypes.FVector4(binaryreader.ReadFloat(FileStream, 4))
                Node.TangentTanTable.append(Vec)

            Node.TangentBinCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.TangentBinCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.TangentBinTable.append(Vec)

            Node.TexCoordCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.TexCoordCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.TexCoordTable.append(Vec)

            LightMapTexCoordTableCount = binaryreader.ReadInt(FileStream, 1)[0]
            FileStream.seek(FileStream.tell() +
                            3 * 4 * LightMapTexCoordTableCount)
        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
    def LoadVisibilityKey(self, Node, FileStream, Offset=None):
        try:
            VisCount = binaryreader.ReadInt(FileStream, 1)[0]
            if VisCount:
                Node.VisKeyTrack.Count = VisCount
                for i in range(VisCount):
                    VisKey = datatypes.FVisKey()
                    VisKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    VisKey.Vis = binaryreader.ReadFloat(FileStream, 1)[0]
                    Node.VisKeyTrack.Data.append(VisKey)
                return True
            return False

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
Exemple #11
0
    def LoadVertexAni(self, Node, FileStream, Offset=None):
        try:
            Node.Name = binaryreader.ReadWord(FileStream)
            Node.VertexCount = binaryreader.ReadInt(FileStream, 1)[0]
            print("Vertex Count: ", Node.VertexCount)
            Node.Vertex_V_Count = binaryreader.ReadInt(FileStream, 1)[0]
            print("Vertex V Count: ", Node.Vertex_V_Count)
            # if Node.VertexCount > 0:
            for i in range(Node.VertexCount):
                VertFrame = binaryreader.ReadUInt(FileStream, 1)[0]
                Node.VertexFrame.append(VertFrame)
            
            for i in range(Node.VertexCount):
                Node.VertexTable.append([])
                for j in range(Node.Vertex_V_Count):
                    Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                    Node.VertexTable[i].append(Vec)

            self.LoadVertexAniBoundingBox(Node, FileStream)
        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
Exemple #12
0
    def LoadInfo(self, Node, FileStream, Offset):
        try:
            Node.dwFlag = binaryreader.ReadUInt(FileStream, 1)[0]
            try:
                Node.MeshAlign = datatypes.RMeshAlign(
                    binaryreader.ReadInt(FileStream, 1)[0])
            except ValueError as er:
                Message = "Node.MeshAlign value is out of allowed range."
                filelogger.AddLog(globalvars.LogFileStream, Message,
                                  filelogger.LogType.LogType_Warning)

            if globalvars.CurrentEluFileVersion < raidflags.EXPORTER_MESH_VER11:
                # Unused data
                AniPartsType = binaryreader.ReadInt(FileStream, 1)[0]
                PartsPosInfoType = binaryreader.ReadInt(FileStream, 1)[0]
                PartsType = binaryreader.ReadInt(FileStream, 1)[0]

            Node.LocalMatrix = datatypes.FMatrix(
                binaryreader.ReadFloat(FileStream, 16))
            if globalvars.CurrentEluFileVersion >= raidflags.EXPORTER_MESH_VER11:
                Node.BaseVisibility = binaryreader.ReadInt(FileStream, 1)[0]

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
    def LoadBoneAni(self, Node, FileStream, Offset=None):
        try:
            Node.Name = binaryreader.ReadWord(FileStream)

            Node.BaseTranslation = datatypes.FVector(
                binaryreader.ReadFloat(FileStream, 3))
            Node.BaseRotation = datatypes.FQuaternion(
                binaryreader.ReadFloat(FileStream, 4))
            Node.BaseScale = datatypes.FVector(
                binaryreader.ReadInt(FileStream, 3))

            AnimType_1 = datatypes.FAnimType(
                binaryreader.ReadInt(FileStream, 3))
            if AnimType_1.Count > 0:
                Node.PositionKeyTrack.Count = AnimType_1.Count + 1
                if AnimType_1.CountType == 10:
                    for i in range(AnimType_1.Count):
                        Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        ShortTuple = binaryreader.ReadUShort(FileStream, 3)
                        FloatTuple = datatypes.ConvertShortToFloat(ShortTuple)
                        PosKey = datatypes.FVecKey()
                        PosKey.Frame = Frame
                        PosKey.Vector = datatypes.FVector(FloatTuple)
                        Node.PositionKeyTrack.Data.append(PosKey)
                    LastPosKey = Node.PositionKeyTrack.Data[AnimType_1.Count -
                                                            1]
                    Node.PositionKeyTrack.Data.append(LastPosKey)
                elif AnimType_1.CountType == 16:
                    for i in range(AnimType_1.Count):
                        PosKey = datatypes.FVecKey()
                        PosKey.Vector = datatypes.FVector(
                            binaryreader.ReadFloat(FileStream, 3))
                        PosKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        Node.PositionKeyTrack.Data.append(PosKey)
                    LastPosKey = Node.PositionKeyTrack.Data[AnimType_1.Count -
                                                            1]
                    Node.PositionKeyTrack.Data.append(LastPosKey)
                else:
                    Message = "{0} node error: RAnimType_1.CountType is incorrect.".format(
                        Node.Name)
                    filelogger.AddLog(globalvars.LogFileStream, Message,
                                      filelogger.ELogMessageType.Log_Error)
                    return

            AnimType_2 = datatypes.FAnimType(
                binaryreader.ReadInt(FileStream, 3))
            if AnimType_2.Count > 0:
                Node.RotationKeyTrack.Count = AnimType_2.Count + 1
                if AnimType_2.CountType == 10:
                    for i in range(AnimType_2.Count):
                        Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        ShortTuple = binaryreader.ReadUShort(FileStream, 3)
                        X, Y, Z = datatypes.ConvertShortToFloat(ShortTuple)
                        W = 0
                        FTol = X * X + Y * Y + Z * Z
                        if FTol <= 1.0:
                            Sub1 = 1.0 - FTol
                            FSqrt = math.sqrt(Sub1)
                            W = FSqrt
                        QuatKey = datatypes.FQuatKey()
                        QuatKey.Frame = Frame
                        QuatKey.Quat = datatypes.FQuaternion((X, Y, Z, W))
                        Node.RotationKeyTrack.Data.append(QuatKey)
                    LastQuatKey = Node.RotationKeyTrack.Data[AnimType_2.Count -
                                                             1]
                    Node.RotationKeyTrack.Data.append(LastQuatKey)
                elif AnimType_2.CountType == 16:
                    for i in range(AnimType_2.Count):
                        Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        X, Y, Z = binaryreader.ReadFloat(FileStream, 3)
                        W = 0
                        FTol = X * X + Y * Y + Z * Z
                        if FTol <= 1.0:
                            Sub1 = 1.0 - FTol
                            FSqrt = math.sqrt(Sub1)
                            W = FSqrt
                        QuatKey = datatypes.FQuatKey()
                        QuatKey.Frame = Frame
                        QuatKey.Quat = datatypes.FQuaternion((X, Y, Z, W))
                        Node.RotationKeyTrack.Data.append(QuatKey)
                    LastQuatKey = Node.RotationKeyTrack.Data[AnimType_2.Count -
                                                             1]
                    Node.RotationKeyTrack.Data.append(LastQuatKey)
                elif AnimType_2.CountType == 20:
                    for i in range(AnimType_2.Count):
                        QuatKey = datatypes.FQuatKey()
                        QuatKey.Quat = datatypes.FQuaternion(
                            binaryreader.ReadFloat(FileStream, 4))
                        QuatKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                        Node.RotationKeyTrack.Data.append(QuatKey)
                    LastQuatKey = Node.RotationKeyTrack.Data[AnimType_2.Count -
                                                             1]
                    Node.RotationKeyTrack.Data.append(LastQuatKey)
                else:
                    Message = "{0} node error: RAnimType_2.CountType is incorrect.".format(
                        Node.Name)
                    filelogger.AddLog(globalvars.LogFileStream, Message,
                                      filelogger.ELogMessageType.Log_Error)
                    return

            AnimType_3 = datatypes.FAnimType(
                binaryreader.ReadInt(FileStream, 3))
            if AnimType_3.Count > 0:
                Node.ScaleKeyTrack.Count = AnimType_3.Count
                for i in range(AnimType_3.Count):
                    ScaleKey = datatypes.FVecKey()
                    ScaleKey.Vector = datatypes.FVector(
                        binaryreader.ReadFloat(FileStream, 3))
                    ScaleKey.Frame = binaryreader.ReadInt(FileStream, 1)[0]
                    Node.ScaleKeyTrack.Data.append(ScaleKey)

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
Exemple #14
0
    def LoadEtc(self, Node, FileStream, Offset):
        try:
            PrimitiveType = binaryreader.ReadInt(FileStream, 1)[0]

            Node.VertexIndexCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.VertexIndexCount):
                VertexIndex = datatypes.FVertexIndex()
                UnsignedShorts = binaryreader.ReadUShort(FileStream, 6)
                VertexIndex.p = UnsignedShorts[0]
                VertexIndex.n = UnsignedShorts[1]
                VertexIndex.uv = UnsignedShorts[2]
                VertexIndex.uv2 = UnsignedShorts[3]
                VertexIndex.n_tan = UnsignedShorts[4]
                VertexIndex.n_bin = UnsignedShorts[5]
                Node.VertexIndexTable.append(VertexIndex)

            Node.BoneCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.BoneCount):
                Matrix = datatypes.FMatrix(
                    binaryreader.ReadFloat(FileStream, 16))
                Node.BoneTable.append(Matrix)

            for i in range(Node.BoneCount):
                BoneIndex = binaryreader.ReadUShort(FileStream, 1)[0]
                Node.BoneTableIndices.append(BoneIndex)

            Node.MaterialInfoCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.MaterialInfoCount):
                MtrlTableInfo = datatypes.FMtrlTableInfo()
                if globalvars.CurrentEluFileVersion < raidflags.EXPORTER_MESH_VER9:
                    MtrlTableInfo.MaterialID = binaryreader.ReadInt(
                        FileStream, 1)[0]
                    MtrlTableInfo.Offset = binaryreader.ReadUShort(
                        FileStream, 1)[0]
                    MtrlTableInfo.Count = binaryreader.ReadUShort(
                        FileStream, 1)[0]
                    MtrlTableInfo.SubMaterialIDForDrawMasking = binaryreader.ReadInt(
                        FileStream, 1)[0]
                else:
                    MtrlTableInfo.MaterialID = binaryreader.ReadInt(
                        FileStream, 1)[0]
                    MtrlTableInfo.Offset = binaryreader.ReadUShort(
                        FileStream, 1)[0]
                    MtrlTableInfo.Count = binaryreader.ReadUShort(
                        FileStream, 1)[0]
                    MtrlTableInfo.SubMaterialIDForDrawMasking = binaryreader.ReadInt(
                        FileStream, 1)[0]
                Node.MaterialInfoTable.append(MtrlTableInfo)

            Node.FaceIndexCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.FaceIndexCount):
                FaceIndex = binaryreader.ReadUShort(FileStream, 1)[0]
                Node.FaceIndexTable.append(FaceIndex)

            # @todo GetBipID
            Node.BoundingBox.vmin = datatypes.FVector(
                binaryreader.ReadFloat(FileStream, 3))
            Node.BoundingBox.vmax = datatypes.FVector(
                binaryreader.ReadFloat(FileStream, 3))

            # @todo fix bounding box
        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)
Exemple #15
0
    def LoadVertexInfo(self, Node, FileStream, Offset):
        try:
            Node.PointColorCount = binaryreader.ReadInt(FileStream, 1)[0]
            for i in range(Node.PointColorCount):
                Vec = datatypes.FVector(binaryreader.ReadFloat(FileStream, 3))
                Node.PointColorTable.append(Vec)

            if Node.PointsCount == 0 or Node.FaceCount == 0:
                Node.AddFlag(raidflags.RM_FLAG_DUMMY_MESH)

            Node.MaterialID = binaryreader.ReadInt(FileStream, 1)[0]
            Node.PhysiqueCount = binaryreader.ReadInt(FileStream, 1)[0]

            if Node.PhysiqueCount:
                try:
                    assert Node.PointsCount == Node.PhysiqueCount, \
                    "Assertion Failed: Points Count is not same as Physique Count - {0}".format(Node.NodeName)
                except AssertionError as err:
                    errorhandling.HandleAssertionError(err)
                for i in range(Node.PhysiqueCount):
                    Size = binaryreader.ReadInt(FileStream, 1)[0]
                    PhysiqueInfo = datatypes.FPhysiqueInfo()
                    for j in range(Size):
                        PhysiqueSubData = datatypes.FPhysiqueSubData()
                        PhysiqueSubData.cid = binaryreader.ReadUShort(
                            FileStream, 1)[0]
                        PhysiqueSubData.pid = binaryreader.ReadUShort(
                            FileStream, 1)[0]
                        PhysiqueSubData.weight = binaryreader.ReadFloat(
                            FileStream, 1)[0]
                        PhysiqueInfo.PhysiqueSubDatas.append(PhysiqueSubData)
                    PhysiqueInfo.Num = len(PhysiqueInfo.PhysiqueSubDatas)
                    Node.PhysiqueTable.append(PhysiqueInfo)

                    if Size > raidflags.PHYSIQUE_MAX_WEIGHT:
                        for m in range(Size):
                            for n in range(m + 1, Size):
                                if PhysiqueInfo.PhysiqueSubDatas[
                                        m].weight < PhysiqueInfo.PhysiqueSubDatas[
                                            n].weight:
                                    Temp = datatypes.FPhysiqueSubData()
                                    Temp = PhysiqueInfo.PhysiqueSubDatas[m]
                                    PhysiqueInfo.PhysiqueSubDatas[
                                        m] = PhysiqueInfo.PhysiqueSubDatas[n]
                                    PhysiqueInfo.PhysiqueSubDatas[n] = Temp

                        fSum3 = sum(PhysiqueSubData.weight for PhysiqueSubData
                                    in PhysiqueInfo.PhysiqueSubDatas)
                        PhysiqueInfo.PhysiqueSubDatas[
                            0].weight = PhysiqueInfo.PhysiqueSubDatas[
                                0].weight / fSum3
                        PhysiqueInfo.PhysiqueSubDatas[
                            1].weight = PhysiqueInfo.PhysiqueSubDatas[
                                1].weight / fSum3
                        PhysiqueInfo.PhysiqueSubDatas[
                            2].weight = PhysiqueInfo.PhysiqueSubDatas[
                                2].weight / fSum3
                        PhysiqueInfo.Num = 3

        except struct.error as err:
            errorhandling.HandleStructUnpackError(err)