XeNTaX

Code: Select all

bs.seek(0x28)
nameForOffset = bs.readUInt()
bs.seek(nameForOffset)
bs.readFloat()

Code: Select all

bs.readFloat(bs.readUInt(0x28))

Code: Select all

#Noesis Python model import+export test module, imports/exports some data from/to a made-up format

from inc_noesis import *
import noesis
import rapi #rapi methods should only be used during handler callbacks

#registerNoesisTypes is called by Noesis to allow the script to register formats.
#Do not implement this function in script files unless you want them to be dedicated format modules!
def registerNoesisTypes():
    handle = noesis.register("Dead or Alive 3", ".xpr")
    noesis.setHandlerTypeCheck(handle, noepyCheckType)
    noesis.setHandlerLoadModel(handle, noepyLoadModel) #see also noepyLoadModelRPG
    noesis.logPopup()
        #print("The log can be useful for catching debug prints from preview loads.\nBut don't leave it on when you release your script, or it will probably annoy people.")
    return 1

loadDoA3Only = False #doa3 only or also doa2u and doax

#check if it's this type based on the data
def noepyCheckType(data):
    bs = NoeBitStream(data)
    if bs.readUInt() != 0x30525058: #'XPR0' magic
        print("no xpr0 magic(30525058)")
        return 0
    bs.seek(0x14) #Seek to MDL
    if bs.readUInt() != 0x4C444D: #'MDL' magic
        print("no mdl magic(4c444d)")
        return 0
    if loadDoA3Only:
        bs.seek(0x28)
        OBJoffset = bs.readUInt()
        bs.seek(OBJoffset + 8)
        if bs.readUInt() != 0:#OBJoffset + 8 = 0 for doa3 and 4 for doax doa2u
            print("no obj+8", OBJoffset + 8)
            return 0
    return 1

#load the model
def noepyLoadModel(data, mdlList):
    ctx = rapi.rpgCreateContext()
    bs = NoeBitStream(data)
    print("hi there")

    #importing code goes here
    bs.seek(0) #start from the file beginning
    xprMagic        = bs.readUInt()
    xprSize         = bs.readUInt()
    dataBlockOffset = bs.readUInt()

    #parse xbox1 xpr chunks
    vertexBuffersOffsets = []
    imagesInfos = []
    while True:
        chunkBase = bs.tell()
        chunkID = bs.readUInt()
        #80000000-MDL; 40001-texture; 800001-vbuf; 830001-???
        chunkSize = {0x800001:0xC, 0x40001:0x14, 0x830001:0xC}.get(chunkID, -1)

        if chunkID == 0x80000000:
            chunkSize = bs.readUInt() + 8

        elif chunkID == 0x800001:
            vertexBuffersOffsets.append(dataBlockOffset + bs.readUInt())

        elif chunkID == 0x40001:
            textureOffset  = bs.readUInt()
            unknownAlways0 = bs.readUInt()
            flags          = bs.readUInt()
            imagesInfos.append((dataBlockOffset + textureOffset, flags))#absolute offset and flags

        elif chunkID == 0xffffffff:
            break

        elif chunkID != 0x80000000:
            print("not a doa3 chunk %x"%chunkID)
            break

        bs.seek(chunkBase + chunkSize)#seek to next chunk

    #load images
    texList = []
    texNames = []
    cleanName = rapi.getInputName()
    cleanName = cleanName[cleanName.rfind("\\")+1: -4]#get the file name without extension
    for textureIndex, (textureOffset, flags) in enumerate(imagesInfos):
        doafmt =       (flags &     0xFF00) >> 8
        Width  = 1 << ((flags &   0xF00000) >> 20)
        Height = 1 << ((flags &  0xF000000) >> 24)
        bpp = {6:4, 0x28:2, 0x19:1,  0xC:0.5, 0xF:1}[doafmt]    #6-ARGB32  28-GB16  19-A8  C-DXT1  F-DXT5
        noMipSize = int(Width * Height * bpp)

        bs.seek(textureOffset)
        textureData = bs.readBytes(noMipSize)
        textureName = cleanName + "_%02d"%textureIndex

        if doafmt == 0xC:
            textureFormat = noesis.NOESISTEX_DXT1
        elif doafmt == 0xF:
            textureFormat = noesis.NOESISTEX_DXT5
        elif doafmt in (6, 0x28, 0x19):
            argbfmt = {6:"b8g8r8a8", 0x28:"b8g8", 0x19:"r8"}[doafmt]#why argb is reversed, big endian?
            untwid = bytearray()
            for x in range(Width):
                for y in range(Height):
                    idx = noesis.morton2D(x, y)
                    untwid += textureData[idx*bpp:idx*bpp+bpp]
            textureData = rapi.imageDecodeRaw(untwid, Width, Height, argbfmt)
            textureFormat = noesis.NOESISTEX_RGBA32
        else:
            print("Unsuported texture format - %x"%doafmt)

        texList.append(NoeTexture(textureName, Width, Height, textureData, textureFormat))
        texNames.append(textureName)

    #find doa version (3/2U/X)
    doaVesion = 0
    bs.seek(0x28)
    OBJoffset = bs.readUInt()
    bs.seek(OBJoffset + 8)
    if bs.readUInt() != 0:#[OBJoffset + 8] = 0 for doa3 and 4 for doax doa2u
        doaVersion = 3 #doa3
    else:
        doaVersion = 2 #doa2U (or doaX)

    if doaVersion != 3:#stop parsing if not doa3
        mdl = NoeModel([])
        mdl.setModelMaterials(NoeModelMaterials(texList, []))
        mdlList.append(mdl)
        rapi.rpgClearBufferBinds()
        return 1

    #test load the vertex buffers
    pass

    #end
    rapi.rpgClearBufferBinds()
    return 1

Code: Select all

mesh = NoeMesh(faces, vertices, meshName, meshName)

Code: Select all

rapi.rpgBindPositionBufferOfs(VertBuff, noesis.RPGEODATA_FLOAT, 0x20, 0)
rapi.rpgBindNormalBufferOfs(VertBuff, noesis.RPGEODATA_FLOAT, 0x20, 12)
rapi.rpgBindUV1BufferOfs(VertBuff, noesis.RPGEODATA_FLOAT, 0x20, 24)
rapi.rpgCommitTriangles(facesdata, noesis.RPGEODATA_USHORT, int(len(facesdata)/2), noesis.RPGEO_TRIANGLE, 1)

Code: Select all

mdl:
  obj1:
      vertex buffer 1 (pos,normal,uv):
          number of verteices
          vertex buffer offset
          number of indices
          tristrip buffer offset
      vertex buffer 2 (?)
      vertex buffer 3 (pos,color,uv)
      vertex buffer 4 (?)
      material 1:
          material color
          texture index
          used vertex buffer
          range of used tristrip indices(startindex, number of indices)
      material 2
      material 3 
  obj2
  obj3

Code: Select all

import math
#-----------------
#Calculate the cross product of two vectors
def cross(a, b):
    c = [a[1]*b[2] - a[2]*b[1],
         a[2]*b[0] - a[0]*b[2],
         a[0]*b[1] - a[1]*b[0]]
    return c

def sub(u, v):
    return [ u[i]-v[i] for i in range(len(u)) ]

def normalize(v):
    magnitude = math.sqrt(sum(v[i]*v[i] for i in range(len(v))))
    return [ v[i]/magnitude  for i in range(len(v)) ]

#Calculates the angle between two vectors
def angle(a,b):
    dotproduct = sum([a[i]*b[i] for i in range(len(a))])
    veclengtha = sum([a[i] for i in range(len(a))])**.5 #Calculates the size of a vector
    veclengthb = sum([b[i] for i in range(len(b))])**.5 #Calculates the size of a vector
    print(dotproduct/(veclengtha*veclengthb),dotproduct,veclengtha,veclengthb)
    return math.acos(min(max(dotproduct/(veclengtha*veclengthb),1),-1))# (dotproduct/(veclengtha*veclengthb) is a complex number and i don't now what to do

def getwinding(v):
    print(v)
    #generate a normal from triangle winding
    windnorm = normalize(cross(sub(v[2][0],v[0][0]), sub(v[1][0],v[0][0])))
    #compare generated normal to each of three vertice's normals(if angle is higher than 90 for more then one vertices then CCW)
    if sum([(1 if (angle(windnorm,v[i][1]) * 57.2957795) < 90 else -1) for i in range(3)]) > 0: return True
    return False

def main():
    face = [((-0.05612413212656975, 0.09935212135314941, -0.03539071977138519), #position1
            (-0.8244166374206543, -0.3322310745716095, -0.45821359753608704)),  #normal1
            ((-0.06070474162697792, 0.12217497825622559, -0.038759298622608185),#position2
            (-0.8547890186309814, -0.10589562356472015, -0.5080569386482239)),  #normal2
            ((-0.07193990796804428, 0.12713682651519775, -0.005527373403310776),#position3
            (-0.9910546541213989, -0.08559581637382507, -0.10239160805940628))] #normal3

    winding = getwinding(face)

if __name__ == '__main__':
    main()