def getElementData(reader: ByteReader, element_count: int,
vert_count: int) -> list:
vertices = []
datatypes = []
for _ in range(element_count):
datatypes.append(reader.getUint32())
reader.skip(5)
for _ in range(vert_count):
vertex = Vertex()
for datatype in datatypes:
if datatype == 1:
vertex.position = GeomLoader.getFloatList(reader, 3)
elif datatype == 2:
vertex.normal = GeomLoader.getFloatList(reader, 3)
elif datatype == 3:
if not vertex.uv:
vertex.uv = [GeomLoader.getFloatList(reader, 2)]
else:
vertex.uv.append(GeomLoader.getFloatList(reader, 2))
elif datatype == 4:
vertex.assignment = GeomLoader.getByteList(reader, 4)
elif datatype == 5:
vertex.weights = GeomLoader.getFloatList(reader, 4)
elif datatype == 6:
vertex.tangent = GeomLoader.getFloatList(reader, 3)
elif datatype == 7:
vertex.tagvalue = GeomLoader.getByteList(reader, 4)
elif datatype == 10:
vertex.vertex_id = [reader.getUint32()]
vertices.append(vertex)
return vertices
def getChunkInfo(reader: ByteReader) -> dict:
info = {'position': None, 'size': None}
info['position'] = reader.getUint32()
info['size'] = reader.getUint32()
return info
def getTGI(reader: ByteReader) -> dict:
tgi = {'type': None, 'group': None, 'instance': None}
tgi['type'] = Globals.padded_hex(reader.getUint32(), 4)
tgi['group'] = Globals.padded_hex(reader.getUint32(), 4)
tgi['instance'] = Globals.padded_hex(reader.getUint64(), 8)
return tgi
def getBones(reader: ByteReader) -> list:
bones = []
count = reader.getUint32()
for _ in range(count):
bones.append(Globals.get_bone_name(reader.getUint32()))
return bones
def getGroupData(reader: ByteReader) -> list:
faces = []
reader.skip(5)
numfacepoints = reader.getUint32()
for _ in range(int(numfacepoints / 3)):
faces.append(
[reader.getInt16(),
reader.getInt16(),
reader.getInt16()])
return faces
def rigFromData(rigdata: bytes) -> dict:
reader = ByteReader(rigdata)
rig = {'name': "replaceme", 'bones': []}
# Skip Version data
reader.skip(8)
bonecount = reader.getUint32()
for _ in range(bonecount):
bone = {}
# Position
px = reader.getFloat()
py = reader.getFloat()
pz = reader.getFloat()
bone['position'] = (px, py, pz)
# Rotation
rx = reader.getFloat()
ry = reader.getFloat()
rz = reader.getFloat()
rw = reader.getFloat()
bone['rotation'] = (rw, rx, ry, rz)
# Scale
sx = reader.getFloat()
sy = reader.getFloat()
sz = reader.getFloat()
bone['scale'] = (sx, sy, sz)
# Bone Name
bone['name'] = reader.getString(reader.getInt32())
# Mirror Index
bone['mirror_index'] = reader.getInt32()
# Parent Index
bone['parent_index'] = reader.getInt32()
# Bone Hash
bone['namehash'] = hex(reader.getUint32())
# Bone Flags
bone['flags'] = hex(reader.getUint32())
rig['bones'].append(bone)
# Skeleton Name
rig['name'] = reader.getString(reader.getUint32())
return rig
def getByteList(reader: ByteReader, count: int) -> list:
data = []
for _ in range(count):
data.append(reader.getByte())
return data
def readGeom(filepath: str) -> Geom:
geomdata = None
with open(filepath, "rb") as f:
geomdata = f.read()
meshdata = Geom()
reader = ByteReader(geomdata)
# RCOL Header Starts here
reader.skip(12)
_external_count = reader.getUint32()
_internal_count = reader.getUint32()
meshdata.internal_chunks = []
for _ in range(_internal_count):
meshdata.internal_chunks.append(GeomLoader.getITG(reader))
meshdata.external_resources = []
for _ in range(_external_count):
meshdata.external_resources.append(GeomLoader.getITG(reader))
meshdata.internal_locations = []
for _ in range(_internal_count):
meshdata.internal_locations.append(GeomLoader.getChunkInfo(reader))
# GEOM Chunk Starts here
reader.skip(16)
_embeddedID = reader.getUint32()
meshdata.embeddedID = hex(_embeddedID)
if _embeddedID != 0:
meshdata.embeddedID = Globals.get_shader_name(_embeddedID)
reader.skip(4 * 4)
_shader_param_count = reader.getUint32()
meshdata.shaderdata = GeomLoader.getShaderParamaters(
reader, _shader_param_count)
meshdata.merge_group = reader.getUint32()
meshdata.sort_order = reader.getUint32()
vertex_count = reader.getUint32()
element_count = reader.getUint32()
meshdata.element_data = GeomLoader.getElementData(
reader, element_count, vertex_count)
meshdata.faces = GeomLoader.getGroupData(reader)
meshdata.skin_controller_index = reader.getUint32()
meshdata.bones = GeomLoader.getBones(reader)
tgicount = int(reader.getUint32())
meshdata.tgi_list = []
for _ in range(tgicount):
meshdata.tgi_list.append(GeomLoader.getTGI(reader))
return meshdata
def getShaderParamaters(reader: ByteReader, count: int) -> list:
parameters = []
for _ in range(count):
entry = {'name': None, 'type': None, 'size': None, 'data': None}
entry['name'] = Globals.get_shader_name(reader.getUint32())
entry['type'] = reader.getUint32()
entry['size'] = reader.getUint32()
reader.skip(4)
parameters.append(entry)
for entry in parameters:
if entry['type'] == Globals.FLOAT:
data = []
for _ in range(entry['size']):
data.append(reader.getFloat())
entry['data'] = data
elif entry['type'] == Globals.INTEGER:
data = []
for _ in range(entry['size']):
data.append(reader.getInt32())
entry['data'] = data
elif entry['type'] == Globals.TEXTURE:
if entry['size'] == 4:
entry['data'] = reader.getUint32()
reader.skip(12)
elif entry['size'] == 5:
# entry['data'] = reader.getRaw(20)
reader.skip(20)
return parameters