animation-jx2

from os.path import *
from math import *
from inc_noesis import *
# created by jayn23 - Xentax forum/2D-3D Model
class FileData:

    def __init__(self):
        self.BoneID = []
        self.Weights = []

def registerNoesisTypes():
    handle = noesis.register("unk game", ".mesh")
    noesis.setHandlerTypeCheck(handle, noepyCheckType)
    noesis.setHandlerLoadModel(handle, noepyLoadModel)
    #opens debug console
    noesis.logPopup()
    return 1


def noepyCheckType(data):
    '''Verify that the format is supported by this plugin. Default yes'''
    #I preform my check while reading mesh data
    return 1

def noepyLoadModel(data, mdlList):
     meshName = "test"
     Positions = []
     Normals = []
     UV = []
     PolygonIndex = []
     meshes = []
     VertData = []

     bs = NoeBitStream(data, NOE_LITTLEENDIAN)

     bs.seek(140,0)
     numMesh = bs.readInt()
     # print("numMesh ",numMesh)
     numVerts = bs.readInt()
     # print("numVerts ",numVerts)
     numFace = bs.readInt()
     # print("numFace ",numFace)
     unk1 = bs.readInt()
     vertOff = bs.readInt()
     normOff = bs.readInt()
     unk2 = bs.readInt()
     UVOff = bs.readInt()
     unk3 = bs.readInt()
     unk4 = bs.readInt()
     faceoff = bs.readInt()
     unk5 = bs.readInt()
     boneOff = bs.readInt()
     # print("boneOff ",boneOff)

     bs.seek(vertOff,0)
     for i in range(numVerts):
        vx = bs.readFloat()
        vy = bs.readFloat()
        vz = bs.readFloat()
        VertData.append(FileData())
        # we need to invert the x coordinator to avoid facecull (inverted normal)
        Positions.append(NoeVec3([-vx,vy,vz]))

     bs.seek(normOff,0)
     for i in range(numVerts):
        nx = bs.readFloat()
        ny = bs.readFloat()
        nz = bs.readFloat()
        #print(str(nx ) + str(ny ) + str(nz))
        Normals.append(NoeVec3([nx, ny, nz]))

     bs.seek(UVOff,0)
     for i in range(numVerts):
        tu = bs.readFloat()
        tv = bs.readFloat()
        UV.append(NoeVec3([tu,tv,0.0]))

     bs.seek(faceoff,0)
     for j in range(numFace*3):
        PolygonIndex.append(bs.readInt())
     # list of NoeBone objects
     boneList = []
     parBoneMats = []
     bs.seek(boneOff,0)
     boneCount = bs.readUInt()

    # read bones loop
     for i in range(boneCount):
        # read bone name
        boneName = bs.readBytes(30).decode('ascii', 'ignore').replace('\x00','').replace('\xCD','')
        # read parent name of the current bone
        parentBoneName = bs.readBytes(30).decode('ascii', 'ignore').replace('\x00','').replace('\xCD','')
        # read the number of child bone
        numChildren = bs.readUInt()
        # read child bone name
        for j in range(numChildren):
            childBoneName = bs.readBytes(30).decode('ascii', 'ignore').replace('\x00','').replace('\xCD','')
        # read 4x4 bone matrix
        boneMat = NoeMat44.fromBytes( bs.readBytes(0x40), NOE_LITTLEENDIAN ).swapHandedness()
        # convert and inverse to 4x3 matrix
        boneMat43 = boneMat.toMat43().inverse()
        # read 4x4 parent bone matrix
        parentMat = NoeMat44.fromBytes( bs.readBytes(0x40), NOE_LITTLEENDIAN )
        # convert and inverse to 4x3 matrix
        parentMat43 = parentMat.toMat43().inverse()
        parBoneMats.append(parentMat43)

        # read the number of vertices deformed by this bone
        numVertices = bs.readUInt()
        if numVertices > 0:
            weightList = []
            VertexList = []
            weights = []
            # read vertex IDs
            for j in range(numVertices):
                vertexID = bs.readUInt()
                VertData[vertexID].BoneID.append(i)
                VertexList.append(vertexID)
            # read weights correspondent to vertex IDs
            for j in range(numVertices):
                weight = bs.readFloat()
                VertData[VertexList[j]].Weights.append(weight)
                weights.append(weight)

        # set bones for Noesis to display
        boneList.append(NoeBone(i, boneName, boneMat43, parentBoneName, parentIndex = -1))
     # correct parentIndex
     for bi in range(boneCount):
        if boneList[bi].parentName != 'Scene Root':
            boneList[bi].parentIndex = [boneList[x].name for x in range(boneCount)].index(boneList[bi].parentName)
     # print(boneList[:].__repr__())
     for k in range(numVerts):
        weightList.append(NoeVertWeight(VertData[k].BoneID, VertData[k].Weights))


# load animation -------------------------------------------------------------------
     anims = rapi.loadPairedFile("JX2 ani", ".ani")
     aniF = NoeBitStream(anims)
     signature = aniF.readBytes(8)
     numAnims = aniF.readUInt()
     # print('numAnims: ', numAnims)
     frameRate = aniF.readUInt()
     # print('frameRate: ', frameRate)
     #animName may not be read correctly since it is Chinese string when using ascii or utf-8,
     animName = aniF.readBytes(30).decode('ascii', 'ignore').replace('\x00','').replace('\xCD','')
     # print('animName: ', animName)
     numBones = aniF.readUInt()
     # print('numBones: ', numBones)
     numFrames = aniF.readUInt()
     # print('numFrames: ', numFrames)
     unk6 = aniF.readBytes(4)

     animBones = []
     animFrameMats = []

     MatIndex = []
     MatIndex2 = []

     for i in range(numBones):
        animBoneName = aniF.readBytes(30).decode('ascii', 'ignore').replace('\x00','').replace('\xCD','')
        #print(animBoneName)
        for j in range(len(boneList)):
            if animBoneName == boneList[j].name:
                MatIndex.append(j)
                MatIndex2.append(i)
                #print(boneList[j].name)
                #print("boneList[j].index",boneList[j].index)
                break

     for i in range(numFrames):

        TempMat = []

        for j in range(len(boneList)):
            # if boneList[j].parentIndex != -1:
                # parentMatrix = boneList[boneList[j].parentIndex].getMatrix()
                # TempMat.append(boneList[j].getMatrix().__mul__(parentMatrix.inverse()))
            # else:
            TempMat.append(boneList[j].getMatrix())
        for k in range(len(MatIndex)):
            frameMat44 = NoeMat44.fromBytes(aniF.readBytes(64))
            frameMat43 = frameMat44.toMat43()
            if k in MatIndex2:
                # print(k)
                TempMat[MatIndex[k]] =  TempMat[MatIndex[k]].__mul__(frameMat43.inverse())
        # try to create right hierachy bones with parent above children
        # for k in range(0, len(MatIndex) - 1):
            # for l in range(k + 1, len(MatIndex)):
                # if ((k in MatIndex2) and (l in MatIndex2)):
                    # if boneList[MatIndex[k]].parentIndex == boneList[MatIndex[l]].index:
                        # SwapMat = TempMat[MatIndex[k]]
                        # TempMat[MatIndex[k]] = TempMat[MatIndex[l]]
                        # TempMat[MatIndex[l]] =  SwapMat

        # for k in range(len(MatIndex)):
            # if k in MatIndex2:
                # TempMat[MatIndex[k]] = TempMat[boneList[MatIndex[k]].parentIndex].inverse() * TempMat[MatIndex[k]]
        # print(TempMat)
        animFrameMats += TempMat

     anim = NoeAnim(animName, boneList, numFrames, animFrameMats, frameRate)
     animList = []
     animList.append(anim)
     # --------------- set elements of the model
     mesh = NoeMesh(PolygonIndex, Positions, meshName)
     mesh.setWeights(weightList)
     mesh.setNormals(Normals)
     mesh.setUVs(UV)
     meshes.append(mesh)
     mdl = NoeModel(meshes)
     mdl.setBones(boneList)
     #animation testing
     # panims = [NoeProceduralAnim("Bip01 L Thigh", -30.0, 1, 0.1), NoeProceduralAnim("Bip01 R Thigh", 30.0, 1, 0.1)]
     # animList = rapi.createProceduralAnim(boneList, panims, 100)
     mdl.setAnims(animList)
     #end of animation testing
     mdlList.append(mdl)

     return 1