itdominator
/
Blender-ZeroEngine-MSH2-Plugin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Blender-ZeroEngine-MSH2-Plugin/src/blender_addon/io_mesh_msh2/msh2/msh2_data.py

2766 lines
95 KiB
Python
Raw Blame History

# -*- coding: utf-8 -*-
'''
ZeroEngine .msh model format.
Refer to
schlechtwetterfront.github.io/ze_filetypes/msh.html
for more information regarding the file format.
'''
import os
import itertools
import struct
import math
# import logging
from .Logger import Logger
logging = Logger("Msh2").get_logger()
try:
import bson
json = bson
except Exception as e:
import json
from . import msh2_crc
MODEL_TYPES = {'null': 0,
'geodynamic': 1,
'cloth': 2,
'bone': 3,
'geobone': 3,
'geostatic': 4,
'geoshadow': 6}
MODEL_TYPES_INT = ['null',
'geodynamic',
'cloth',
'bone',
'geostatic',
'',
'geoshadow']
class MSH2Error(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class Packer(object):
def pad_string(self, string):
'''Pads the given string with \x00s to fill a multiple of 4 length.'''
if string == b'':
return b''
i = 0
while len(string) >= i:
i += 4
return string.ljust(i, b'\x00')
def null_terminate(self, string):
'''Null-terminates the given string.'''
return string + b'\x00'
def pack_long_chunk(self, header, number):
'''Chunk with only one long int.'''
data = [header.encode("ascii")]
data.append(struct.pack('<L', 4))
data.append(struct.pack('<L', number))
return b''.join(data)
def pack_string_chunk(self, header, string):
'''String Chunk(NAME, TX0D...) packer.'''
data = [header.encode("ascii")]
comp_str = self.pad_string(string)
data.append(struct.pack('<L', len(comp_str)))
data.append(comp_str)
return b''.join(data)
def sum_seq(self, seq, start=0, end=None):
'''Sums the sequence items from start to end.
If end is None it will sum all items from start.'''
if end:
tosum = seq[start:end]
else:
tosum = seq[start:]
tosum = [len(item) for item in tosum]
return sum(tosum)
class Msh(Packer):
# is_shadowvolume bool
# info Info
# materials Material[]
# models Model[]
# animation Animation
def __init__(self):
self.info = None
self.has_shadowvolume = False
self.models = []
self.materials = []
self.animation = None
self.classname = 'Msh'
self.modulepath = ''
def dump(self, filepath):
'''Dumps .msh file information into a text file.'''
with open(filepath, 'w') as fh:
self.info.dump(fh)
self.materials.dump(fh)
self.models.dump(fh)
return True
def save(self, filepath):
with open(filepath, 'wb') as fh:
fh.write(self.pack())
def save_json(self, filepath):
'''Saves the .msh in JSON format.'''
data = {
'info': self.info.get_json(),
'models': self.models.get_json(),
'materials': self.materials.get_json(),
'has_shadowvolume': self.has_shadowvolume,
'animation': None,
}
with open(filepath, 'wb') as fh:
# fh.write(json.dumps(data, indent=4, separators=(',', ': ')))
fh.write(json.dumps(data))
return True
def save_segmented_json(self, folder, name=None):
# If no name argument was passed assume that a full path was passed.
if not name:
folder, name = os.path.dirname(folder), os.path.basename(folder)
name = name.split('.')[0]
if not os.path.isdir(folder):
os.mkdir(folder)
with open(os.path.join(folder, name + '.txt'), 'w') as fh:
fh.write(json.dumps({'has_shadowvolume': self.has_shadowvolume}))
with open(os.path.join(folder, name + ' nfo.txt'), 'w') as fh:
# fh.write(json.dumps(self.info.get_json(), indent=4, separators=(',', ': ')))
fh.write(json.dumps(self.info.get_json()))
for model in self.models:
model.save_segmented_json(folder, name)
for material in self.materials:
with open(os.path.join(folder, '{0} mtl {1}.txt'.format(name, material.name)), 'wb') as fh:
fh.write(json.dumps(material.get_json()))
# fh.write(json.dumps(material.get_json(), indent=4, separators=(',', ': ')))
@classmethod
def load_segmented_json(cls, folder, name):
model_start = '{0} mdl '.format(name)
material_start = '{0} mtl '.format(name)
msh = cls()
info_data = b''
with open(os.path.join(folder, '{0}.txt'.format(name)), 'r') as fh:
msh.has_shadowvolume = json.loads(fh.read())['has_shadowvolume']
with open(os.path.join(folder, '{0} nfo.txt'.format(name)), 'r') as fh:
info_data = json.loads(fh.read())
msh.info = SceneInfo.from_json(info_data)
materials = MaterialCollection(msh)
models = ModelCollection(msh)
for filename in os.listdir(folder):
if filename.startswith(model_start) and (not ' seg ' in filename):
models.add(Model.load_segmented_json(folder, filename.split('.')[0]))
elif filename.startswith(material_start):
with open(os.path.join(folder, filename), 'r') as fh:
materials.add(Material.from_json(json.loads(fh.read())))
msh.models = models
# Re-order models so that parents appear before their children.
models_map = {}
models = []
for model in msh.models:
if model.parent_name:
if not models_map.get(model.parent_name, None):
models_map[model.parent_name] = [model]
else:
models_map[model.parent_name].append(model)
else:
models.append(model)
new_models = []
for model in models:
new_models.extend(msh.get_children_ordered(model, models_map))
msh.models.replace(new_models)
msh.materials = materials
msh.animation = Animation(None, 'empty')
msh.set_indices()
return msh
def get_children_ordered(self, model, children_map):
models = []
models.append(model)
children = children_map.get(model.name, [])
for child in children:
models.extend(self.get_children_ordered(child, children_map))
return models
@classmethod
def load_json(cls, filepath):
data = b''
with open(filepath, 'rb') as fh:
data = fh.read()
data = json.loads(data)
msh = cls()
msh.info = SceneInfo.from_json(data['info'], msh)
msh.models = ModelCollection.from_json(data['models'], msh)
msh.materials = MaterialCollection.from_json(data['materials'], msh)
msh.has_shadowvolume = data['has_shadowvolume']
msh.animation = Animation(None, 'empty')
msh.set_indices()
return msh
def set_indices(self):
'''Set material and model indices (ie after json load).'''
for index, material in enumerate(self.materials):
material.index = index
for index, model in enumerate(self.models):
model.index = index
for seg in model.segments:
seg.material = self.get_mat_by_name(seg.mat_name)
def get_mat_by_name(self, name):
'''Get Material object by name.'''
dct = self.materials.get_matname_dict()
return dct[name]
def get_mat_by_index(self, index):
'''Get Material object by index into the colection.'''
return self.materials[index]
def pack_CL1L(self):
data = [b'CL1L']
data.append(struct.pack('<L', 0))
return b''.join(data)
def pack(self):
'''Packs data to .msh file structure and returns the data as a string.'''
data = [b'HEDR', 'size']
# First pack the MSH2 header with all its children chunks.
msh2_data = [b'MSH2', 'size']
msh2_data.append(self.info.pack())
msh2_data.append(self.materials.pack())
msh2_data.append(self.models.pack())
#msh2_data[1] = struct.pack('<L', len(msh2_data[2]) + len(msh2_data[3]) + len(msh2_data[4]))
msh2_data[1] = struct.pack('<L', self.sum_seq(msh2_data, 2))
# Finished MSH2.
data.append(b''.join(msh2_data))
# HEDR only has MSH2 and the animation chunks as children(and sometimes SHVO).
# We don't pack SHVO here so on to animation chunks.
data.append(self.animation.pack())
data.append(self.pack_CL1L())
# sum length of msh2 data + length of animation chunks.
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
def repack(self):
'''Will use stored binary data of cloth and shadow chunks instead
of recalculating it(not possible at the moment).'''
data = [b'HEDR', 'size']
# First pack the MSH2 header with all its children chunks.
msh2_data = [b'MSH2', 'size']
msh2_data.append(self.info.pack())
msh2_data.append(self.materials.pack())
msh2_data.append(self.models.repack())
#msh2_data[1] = struct.pack('<L', len(msh2_data[2]) + len(msh2_data[3]) + len(msh2_data[4]))
msh2_data[1] = struct.pack('<L', self.sum_seq(msh2_data, 2))
# Finished MSH2.
data.append(b''.join(msh2_data))
# HEDR only have MSH2 and the animation chunks as children(and sometimes SHVO).
# We don't pack SHVO here so on to animation chunks.
if self.animation:
data.append(self.animation.pack())
data.append(self.pack_CL1L())
# sum length of msh2 data + length of animation chunks.
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
class SceneInfo(Packer):
def __init__(self, msh=None):
# Reference to Msh.
self.msh = msh
self.name = b''
self.classname = 'SceneInfo'
self.frame_range = 0, 100
self.fps = 29.97
self.scale = 1.0, 1.0, 1.0
self.bbox = BBox()
def dump(self, fileh=None):
'''Dump information to open filehandler fileh.'''
if fileh:
fileh.write('--- SceneInfo ---\n')
fileh.write('\tSceneName: {0}\n'.format(self.name))
fileh.write('\tFrameRange: {0}-{1}\n'.format(*self.frame_range))
fileh.write('\tFPS: {0}\n'.format(self.fps))
def get_json(self):
data = {
'name': self.name,
'frame_range': self.frame_range,
'fps': self.fps,
'scale': self.scale,
'bbox': self.bbox.get_json()
}
return data
@staticmethod
def from_json(data, msh=None):
info = SceneInfo()
info.msh = msh
info.name = data['name']
info.frame_range = data['frame_range']
info.fps = data['fps']
info.scale = data['scale']
info.bbox = BBox.from_json(data['bbox'])
return info
def pack(self):
'''Packs the scene information data.'''
data = [b'SINF']
data.append('size_ind')
data.append(self.pack_NAME())
data.append(self.pack_FRAM())
data.append(self.bbox.pack())
data[1] = struct.pack('<L', len(data[2]) + len(data[3]) + len(data[4]))
return b''.join(data)
def pack_NAME(self):
'''Packs the scene name.'''
return self.pack_string_chunk('NAME', self.name)
def pack_FRAM(self):
'''Packs frame range and FPS into the FRAM chunk.'''
data = [b'FRAM']
data.append(struct.pack('<L', 12))
data.append(struct.pack('<L', self.frame_range[0]))
data.append(struct.pack('<L', self.frame_range[1]))
data.append(struct.pack('<f', self.fps))
return b''.join(data)
class Material(Packer):
# name: string
# index: int
# tex_0: string.tga
# tex_1: string.tga
# tex_2: string.tga
# tex_3: string.tga
# attr_0: int(0-255)
# attr_1: int(0-255)
# attr_2: int(0-255)
# attr_3: int(0-255)
# diff_color: (red, green, blue, alpha) floats
# ambt_color: (red, green, blue, alpha) floats
# spec_color: (red, green, blue, alpha) floats
# gloss: float
def __init__(self, coll=None):
# Reference to MaterialCollection
self.collection = coll
self.name = b''
self.classname = 'Material'
self.index = 0
self.tex0 = None
self.tex1 = None
self.tex2 = None
self.tex3 = None
self.flags = [['specular', False, 128],
['additive', False, 64],
['perpixel', False, 32],
['hard', False, 16],
['double', False, 8],
['single', False, 4],
['glow', False, 2],
['emissive', False, 1]]
self.render_type = 0
self.data0 = 0
self.data1 = 0
self.diff_color = Color()
self.ambt_color = Color()
self.spec_color = Color()
self.gloss = 70.0
def dump(self, fh):
'''Dump information to open filehandler fileh.'''
fh.write('\t--- Material ---\n')
fh.write('\t\tName: {0}\n'.format(self.name))
fh.write('\t\tTex0: {0}\n'.format(self.tex0))
fh.write('\t\tTex1: {0}\n'.format(self.tex1))
fh.write('\t\tTex2: {0}\n'.format(self.tex2))
fh.write('\t\tTex3: {0}\n'.format(self.tex3))
fh.write('\t\tFlags\n')
for flag in self.flags:
fh.write('\t\t\t{0}: {1}\n'.format(flag[0], flag[1]))
fh.write('\n')
fh.write('\t\tRenderType: {0}\n'.format(self.render_type))
fh.write('\t\tData0: {0}\n'.format(self.data0))
fh.write('\t\tData1: {0}\n'.format(self.data1))
fh.write('\t\tDiffuse: {0}\n'.format(self.diff_color))
fh.write('\t\tSpecular: {0}\n'.format(self.spec_color))
fh.write('\t\tAmbient: {0}\n'.format(self.ambt_color))
fh.write('\t\tGloss: {0}\n'.format(self.gloss))
def get_json(self):
data = {
'name': self.name,
'index': self.index,
'tex0': self.tex0,
'tex1': self.tex1,
'tex2': self.tex2,
'tex3': self.tex3,
'flags': self.flags,
'render_type': self.render_type,
'data0': self.data0,
'data1': self.data1,
'diffuse': self.diff_color.get_json(),
'specular': self.spec_color.get_json(),
'ambient': self.ambt_color.get_json(),
'gloss': self.gloss,
}
return data
@staticmethod
def from_json(data, collection=None):
material = Material()
material.collection = collection
material.name = data['name']
material.index = data['index']
material.tex0 = data['tex0']
material.tex1 = data['tex1']
material.tex2 = data['tex2']
material.tex3 = data['tex3']
material.flags = data['flags']
material.render_type = data['render_type']
material.data0 = data['data0']
material.data1 = data['data1']
material.diff_color = Color.from_json(data['diffuse'])
material.spec_color = Color.from_json(data['specular'])
material.ambt_color = Color.from_json(data['ambient'])
material.gloss = data['gloss']
return material
@property
def ATRB(self):
'''Sum ATRB byte value.'''
val = 0
for flag in self.flags:
if flag[1]:
val += flag[2]
return val
def pack(self):
'''Packs the material into a MATD chunk.'''
data = [b'MATD']
data.append('size_indicator')
data.append(self.pack_NAME())
data.append(self.pack_DATA())
data.append(self.pack_ATRB())
data.append(self.pack_textures())
data[1] = struct.pack('<L', len(data[2]) + len(data[3]) + len(data[4]) + len(data[5]))
return b''.join(data)
def flags_from_int(self, val):
'''Unpacks an int indicating the material flags into the
single flags.'''
# Decodes an int into flags.
place0 = val
flags = [('specular', True, 128),
('additive', True, 64),
('perpixel', True, 32),
('hard', True, 16),
('double', True, 8),
('single', True, 4),
('glow', True, 2),
('emissive', True, 1)]
new = place0
for index, flag in enumerate(flags):
new -= flag[2]
if new < 0:
flags[index] = flag[0], False, flag[2]
new += flag[2]
return flags
def pack_NAME(self):
'''Packs the materials name.'''
return self.pack_string_chunk('NAME', self.name)
def pack_DATA(self):
'''Packs the material's shader/color data.'''
data = [b'DATA']
data.append(struct.pack('<L', 52))
data.append(self.diff_color.pack('f'))
data.append(self.spec_color.pack('f'))
data.append(self.ambt_color.pack('f'))
data.append(struct.pack('<f', self.gloss))
return b''.join(data)
def pack_ATRB(self):
'''Packs the material render attributes.'''
data = [b'ATRB']
data.append(struct.pack('<L', 4))
data.append(struct.pack('<B', self.ATRB))
data.append(struct.pack('<B', self.render_type))
data.append(struct.pack('<B', self.data0))
data.append(struct.pack('<B', self.data1))
return b''.join(data)
def pack_textures(self):
'''Packs up to 4 textures in TX0D/TX1D/TX2D/TX3D chunks.'''
data = []
if self.tex0:
data.append(self.pack_string_chunk('TX0D', self.tex0))
if self.tex1:
data.append(self.pack_string_chunk('TX1D', self.tex1))
if self.tex2:
data.append(self.pack_string_chunk('TX2D', self.tex2))
if self.tex3:
data.append(self.pack_string_chunk('TX3D', self.tex3))
return b''.join(data)
class MaterialCollection(Packer):
def __init__(self, msh=None, materials=[]):
# Reference to Msh.
self.msh = msh
self.classname = 'MaterialCollection'
self.materials = materials
def dump(self, fh):
'''Dump information to open filehandler fileh.'''
fh.write('--- MaterialCollection ---\n')
fh.write('\tNumMaterials: {0}\n'.format(len(self.materials)))
for mat in self.materials:
mat.dump(fh)
def get_json(self):
data = {
'materials': [mat.get_json() for mat in self.materials],
}
return data
@staticmethod
def from_json(data, msh=None):
coll = MaterialCollection()
coll.msh = msh
for material_data in data['materials']:
coll.materials.append(Material.from_json(material_data))
return coll
def add(self, material):
'''Add Material to the collection and set
collection attribute.'''
material.collection = self
self.materials.append(material)
def remove(self, index):
'''Remove material at index index.'''
del self.materials[index]
def replace(self, materials):
'''Replace internal materials list.'''
self.materials = materials
def get_matname_dict(self):
'''Returns dict of 'materialname': material pairs.'''
matnamedict = {}
for mat in self.materials:
matnamedict[mat.name] = mat
return matnamedict
def assign_indices(self):
'''Assigns index attribute for every material.'''
for index, mat in enumerate(self.materials):
mat.index = index
def __str__(self):
return str(self.materials)
def __repr__(self):
return str(self.materials)
def __getitem__(self, key):
return self.materials[key]
def __len__(self):
return len(self.materials)
def pack(self):
'''Packs the material list + materials.'''
data = [b'MATL', 'size']
data.append(struct.pack('<L', len(self.materials)))
for material in self.materials:
data.append(material.pack())
data[1] = struct.pack('<L', self.sum_seq(data, 3) + 4)
return b''.join(data)
class Model(Packer):
collprim_by_index = {0: 'Sphere',
1: 'Sphere',
2: 'Cylinder',
4: 'Cube'}
collprim_by_name = {'Sphere': 0,
'Cylinder': 2,
'Cube': 4}
def __init__(self, collection=None):
# Ref to ModelCollection.
self.collection = collection
self.name = 'model'
self.classname = 'Model'
self.parent_name = None
self.index = 0
self.model_type = 'geostatic'
self.vis = 0
self.segments = SegmentCollection(self)
self.collprim = False
self.cloth_collprim = False
self.primitive = 4, 0.0, 0.0, 0.0
self.deformers = []
self.deformer_indices = []
self.bbox = BBox()
self.transform = Transform()
self.bone = None
self.msh = None
def get_json(self):
data = {
'name': self.name,
'parent': self.parent_name,
'model_type': self.model_type,
'visible': not self.vis, # vis == hidden
'segments': self.segments.get_json(),
'collprim': self.collprim,
'primitive': self.primitive,
'num_deformers': len(self.deformers),
'deformers': self.deformers,
'bbox': self.bbox.get_json(),
'transform': self.transform.get_json(),
}
return data
def save_segmented_json(self, folder, name):
data = self.get_json()
del data['segments']
with open(os.path.join(folder, '{0} mdl {1}.txt'.format(name, self.name)), 'w') as fh:
fh.write(json.dumps(data))
# fh.write(json.dumps(data, indent=4, separators=(',', ': ')))
for index, segment in enumerate(self.segments):
with open(os.path.join(folder, '{0} mdl {1} seg {2:0>3}.txt'.format(name, self.name, index)), 'w') as fh:
# fh.write(json.dumps(segment.get_json(), indent=4, separators=(',', ': ')))
fh.write(json.dumps(segment.get_json()))
@classmethod
def load_segmented_json(cls, folder, name):
logging.debug('LOADING SEGMENTED MODEL %s %s', folder, name)
with open(os.path.join(folder, '{0}.txt'.format(name)), 'r') as fh:
model = Model.from_json(json.loads(fh.read()))
seg_start = '{0} seg '.format(name)
segments = SegmentCollection(model)
for filename in os.listdir(folder):
if filename.startswith(seg_start):
with open(os.path.join(folder, filename), 'r') as fh:
data = json.loads(fh.read())
if data['type'] == 'SegmentGeometry':
segments.add(SegmentGeometry.from_json(data))
elif data['type'] == 'ClothGeometry':
segments.add(ClothGeometry.from_json(data))
elif data['type'] == 'ShadowGeometry':
segments.add(ShadowGeometry.from_json(data))
model.segments = segments
return model
@staticmethod
def from_json(data, collection=None):
model = Model()
model.collection = collection
model.name = data['name']
model.parent_name = data['parent']
model.model_type = data['model_type']
model.vis = data.get('visible', False)
model.vis = data.get('vis', model.vis) # Older format used that.
# In case this is loaded from a segmented json.
if data.get('segments', None):
model.segments = SegmentCollection.from_json(data['segments'], model)
model.collprim = data['collprim']
model.primitive = data['primitive']
model.deformers = data['deformers']
model.bbox = BBox.from_json(data['bbox'])
model.transform = Transform.from_json(data['transform'])
return model
def get_collprim_name(self):
return self.collprim_by_index[self.primitive[0]]
def get_collprim_index(self, name):
return self.collprim_by_name[name]
def dump(self, fh):
'''Dump information to open filehandler fileh.'''
fh.write('\t--- Model ---\n')
fh.write('\t\tName: {0}\n'.format(self.name))
fh.write('\t\tParent: {0}\n'.format(self.parent_name))
fh.write('\t\tType: {0}\n'.format(self.model_type))
fh.write('\t\tVisible: {0}\n'.format(self.vis))
fh.write('\t\tPos: {0}, {1}, {2}\n'.format(*self.transform.translation))
fh.write('\t\tRot: {0}, {1}, {2}, {3}\n'.format(*self.transform.rotation))
fh.write('\t\tScl: {0}, {1}, {2}\n'.format(*self.transform.scale))
if self.collprim:
fh.write('\t\tCollprim: {0}, {1}, {2}, {3}\n'.format(*self.primitive))
if 'geo' in self.model_type or self.model_type == 'cloth':
self.segments.dump(fh)
if self.deformers:
fh.write('\t\tDeformers:\n')
for deform in self.deformers:
fh.write('\t\t\t{0}\n'.format(deform))
def set_deformers_from_indices(self):
'''Sets deformers attribute to actual model names.'''
try:
for ind in self.deformer_indices:
self.deformers.append(self.collection[ind - 1].name)
except IndexError:
raise MSH2Error('Check C:\dump.dump!')
def pack(self):
'''Packs the MODL chunk. This should be used to retrieve the model in packed form.'''
data = [b'MODL', 'sizeind']
data.append(self.pack_MTYP())
data.append(self.pack_MNDX())
data.append(self.pack_NAME())
if self.parent_name:
data.append(self.pack_PRNT())
data.append(self.pack_FLGS())
data.append(self.transform.pack())
if 'geo' in self.model_type or self.model_type == 'cloth':
data.append(self.pack_GEOM())
if self.collprim:
data.append(self.pack_SWCI())
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
def pack_MTYP(self):
'''Packs the model type chunk.'''
return self.pack_long_chunk('MTYP', MODEL_TYPES[self.model_type])
def pack_MNDX(self):
'''Packs the model index chunk.'''
return self.pack_long_chunk('MNDX', self.index)
def pack_NAME(self):
'''Packs the model's name.'''
return self.pack_string_chunk('NAME', self.name)
def pack_PRNT(self):
'''Packs the model's parent's name.'''
return self.pack_string_chunk('PRNT', self.parent_name)
def pack_FLGS(self):
'''Packs the visibility.'''
return self.pack_long_chunk('FLGS', self.vis)
def pack_GEOM(self):
data = [b'GEOM']
data.append('size_indic')
data.append(self.bbox.pack())
data.append(self.segments.pack())
if self.deformers:
data.append(self.pack_ENVL())
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
def pack_ENVL(self):
data = [b'ENVL']
data.append(struct.pack('<L', len(self.deformers) * 4 + 4))
data.append(struct.pack('<L', len(self.deformers)))
for deformer in self.deformers:
index = self.collection.get_index(deformer)
data.append(struct.pack('<L', index))
return b''.join(data)
def pack_SWCI(self):
'''Packs the collision primitive chunk.'''
data = [b'SWCI']
data.append(struct.pack('<L', 16))
data.append(struct.pack('<Lfff', *self.primitive))
return b''.join(data)
def repack(self):
'''Repacks the MODL chunk. This should be used to retrieve the model in packed form.'''
data = [b'MODL', 'sizeind']
data.append(self.pack_MTYP())
data.append(self.pack_MNDX())
data.append(self.pack_NAME())
if self.parent_name:
data.append(self.pack_PRNT())
data.append(self.pack_FLGS())
data.append(self.transform.pack())
if 'geo' in self.model_type or self.model_type == 'cloth':
data.append(self.repack_GEOM())
if self.collprim:
data.append(self.pack_SWCI())
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
def repack_GEOM(self):
data = [b'GEOM']
data.append('size')
data.append(self.bbox.pack())
data.append(self.segments.repack())
if self.deformers:
data.append(self.pack_ENVL())
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
def get_vertex_by_index(self, vertex_index):
'''Get a Vertex from an index that is not relative to a segment.
Basically combines all vertices of all segments into one list to array into.'''
offset = 0
for segment in self.segments:
if vertex_index < len(segment.vertices) + offset:
return segment.vertices[vertex_index - offset]
offset += len(segment.vertices)
class ModelCollection(object):
def __init__(self, msh=None, models=None):
# Ref to Msh.
if msh:
self.msh = msh
else:
self.msh = None
self.classname = 'ModelCollection'
if models:
self.models = models
else:
self.models = []
self.msh = None
def get_json(self):
data = {
'models': [m.get_json() for m in self.models]
}
return data
@staticmethod
def from_json(data, msh=None):
coll = ModelCollection()
coll.msh = msh
for model_data in data['models']:
coll.models.append(Model.from_json(model_data, coll))
return coll
def dump(self, fh):
'''Dump information to open filehandler fh.'''
fh.write('--- ModelCollection ---\n')
fh.write('\tNumModels: {0}\n'.format(len(self.models)))
for model in self.models:
model.dump(fh)
def add(self, model):
'''Add Model object and set its collection attribute.'''
model.collection = self
self.models.append(model)
def remove(self, index):
del self.models[index]
def remove_multi(self, models):
'''Compares names between internal list and
models. If name of internal Model equals one in
models, remove the Model.'''
for index, model in enumerate(self.models):
if model.name in models:
del self.models[index]
def replace(self, new_models):
'''Replace internal model list with new_models.'''
self.models = new_models
def assign_indices(self):
'''Assign index attribute for every Model.'''
for index, model in enumerate(self.models):
model.index = index + 1
def assign_parents(self):
'''Assign collection attribute for every Model.'''
for model in self.models:
model.collection = self
def assign_cloth_collisions(self):
'''Assign collision data to every cloth that has collisions referenced.'''
cloth_collision_primitives = {}
for model in self.models:
if model.cloth_collprim:
cloth_collision_primitives[model.name] = model
for model in self.models:
for segment in model.segments:
if isinstance(segment, ClothGeometry):
for collision in segment.collisions:
collision.primitive_type = cloth_collision_primitives[collision.name].primitive[0]
collision.primitive_data = cloth_collision_primitives[collision.name].primitive[1:]
def get_index(self, modelname):
'''Get model.index for model with name modelname.'''
for model in self.models:
if model.name == modelname:
logging.debug('ModelCollection.get_index: {0} - {1}'.format(model.name, model.index))
return model.index
return 0
def by_name(self, name):
'''Get model by name.'''
for model in self.models:
if model.name == name:
return model
def get_names_list(self):
'''Get list of model names.'''
return [mdl.name for mdl in self.models]
def __str__(self):
return str(self.models)
def __repr__(self):
return str(self.models)
def __getitem__(self, key):
return self.models[key]
def __len__(self):
return len(self.models)
def pack(self):
data = [model.pack() for model in self.models]
return b''.join(data)
def repack(self):
data = [model.repack() for model in self.models]
return b''.join(data)
class SegmentCollection(object):
def __init__(self, model=None, segments=None):
# Reference to Model.
if model:
self.model = model
else:
self.model = None
self.classname = 'SegmentCollection'
if segments:
self.segments = segments
else:
self.segments = []
self.msh = None
def get_json(self):
data = {
'segments': [seg.get_json() for seg in self.segments],
}
return data
@staticmethod
def from_json(data, model=None):
coll = SegmentCollection()
coll.model = model
for segment_data in data['segments']:
if segment_data['type'] == 'SegmentGeometry':
coll.segments.append(SegmentGeometry.from_json(segment_data, coll))
elif segment_data['type'] == 'ClothGeometry':
coll.segments.append(ClothGeometry.from_json(segment_data, coll))
elif segment_data['type'] == 'ShadowGeometry':
coll.segments.append(ShadowGeometry.from_json(segment_data, coll))
return coll
def dump(self, fh):
'''Dump information to open filehandler fileh.'''
fh.write('\t\t--- SegmentCollection ---\n')
for seg in self.segments:
seg.dump(fh)
def num_vertices(self):
numv = 0
for segm in self.segments:
numv += len(segm.vertices)
return numv
def add(self, segment):
'''Adds SegmentGeometry, ClothGeometry or ShadowGeometry
to the collection and sets the collection attribute.'''
segment.collection = self
self.segments.append(segment)
def remove(self, index):
'''Removes Geometry at index index.'''
del self.segments[index]
def split(self, seg_index, poly_mat_inds, mat_names):
'''Splits the segment with index == seg_index.
poly_mat_inds is a list where the index represents
the index of the face/polygon and the content of the
list item represents the material index.
mat_names is a list of material names.
This function splits the segment into multiple
segments(one per material). The result segments
will be used as the .segments of this SegmentCollection.'''
polies_per_material = self._polies_per_material(poly_mat_inds)
# Segment to split.
segm = self.segments[seg_index]
segments = []
# Loop through materials.
for mat_index, mat_poly_indices in enumerate(polies_per_material):
if not mat_poly_indices:
continue
seg = SegmentGeometry(self)
facecoll = FaceCollection(seg)
vertcoll = VertexCollection(seg)
vertcoll.set_flags_from_vertcoll(segm.vertices)
# Loop through face indices.
for local_face_index, face_index in enumerate(mat_poly_indices):
master_face = segm.faces[face_index]
new_face = Face()
for vert_index in master_face.vertices:
# Add the vertex. As the vertex now holds UV, weights etc
# its not necessary anymore to do all the checking if
# the UV etc lists should be split, too.
vertcoll.add(segm.vertices[vert_index])
# Add last item in vertex collection to face.
new_face.add(len(vertcoll) - 1)
facecoll.add(new_face)
seg.vertices = vertcoll
seg.faces = facecoll
seg.mat_name = mat_names[mat_index]
seg.mat = self.msh.get_mat_by_name(segm.mat_name)
segments.append(seg)
self.segment = []
self.segments = segments
def assign_materials(self, material_coll):
'''Assign material object from material name.'''
mat_name_dict = material_coll.get_matname_dict()
for segment in self.segments:
segment.material = mat_name_dict[segment.mat_name]
def _polies_per_material(self, poly_inds):
'''Creates a list where each item represents a material and holds
all polygon indices mapped to that material.'''
largest_index = self._mat_largest_ind(poly_inds)
# Create sub-lists for every material.
list_ = [[] for n in range(largest_index + 1)]
for index, el in enumerate(poly_inds):
# Now add the polygon indices to the according mat list.
list_[el].append(index)
return list_
def _mat_largest_ind(self, inds):
'''Largest material index. Equals number of materials.'''
int_ = 0
for el in inds:
if el > int_:
int_ = el
return int_
def __str__(self):
return str(self.segments)
def __repr__(self):
return str(self.segments)
def __getitem__(self, key):
return self.segments[key]
def __len__(self):
return len(self.segments)
def pack(self):
data = []
logging.debug(type(self.segments))
logging.debug(self.segments)
for segment in self.segments:
data.append(segment.pack())
return b''.join(data)
def repack(self):
data = [bsegment.repack() for segment in self.segments]
return b''.join(data)
class SegmentGeometry(Packer):
# mat_name: string
# mat_index: int
# vert_list: list (Vertex)
# face_list: list (Face)
def __init__(self, collection=None):
#Reference to SegmentCollection.
self.collection = collection
self.classname = 'SegmentGeometry'
self.mat_name = None
self.material = None
self.vertices = None
self.faces = None
self.msh = None
self.index_map = None
def get_json(self):
data = {
'type': self.classname,
'material': self.material.name.decode().encode('utf-8'),
'num_vertices': len(self.vertices),
'vertices': self.vertices.get_json(),
'num_faces': len(self.faces),
'faces': self.faces.get_json(),
}
return data
@staticmethod
def from_json(data, collection=None):
geo = SegmentGeometry()
geo.collection = collection
geo.mat_name = data['material'].decode().encode('utf-8')
geo.vertices = VertexCollection.from_json(data['vertices'], geo)
geo.faces = FaceCollection.from_json(data['faces'], geo)
return geo
def clear_doubles(self):
'''Clears Vertices appearing more than once.'''
self.index_map = dict()
new_vertices = []
# Use a set to quickly check if we have a duplicate.
new_vertices_set = set()
len_new_verts = 0
num_cleared_vertices = 0
for index, vert in enumerate(self.vertices):
if vert in new_vertices_set:
index_original = new_vertices.index(vert)
# Insert into indices map.
self.index_map[index] = index_original
num_cleared_vertices += 1
else:
new_vertices.append(vert)
new_vertices_set.add(vert)
self.index_map[index] = len_new_verts
len_new_verts += 1
self.vertices.vertices = new_vertices
logging.debug('Cleared %s doubles.', num_cleared_vertices)
def dump(self, fh):
'''Dump information to open filehandler fileh.'''
fh.write('\t\t\t--- SegmentGeometry ---\n')
fh.write('\t\t\t\tMaterial: {0}\n'.format(self.material))
fh.write('\t\t\t\tVertices: {0}\n'.format(len(self.vertices)))
fh.write('\t\t\t\tFaces: {0}\n'.format(len(self.faces or '')))
fh.write('\t\t\t\tUVed: {0}\n'.format(self.vertices.uved))
fh.write('\t\t\t\tColored: {0}\n'.format(self.vertices.colored))
fh.write('\t\t\t\tWeighted: {0}\n'.format(self.vertices.weighted))
fh.write(str(self.index_map))
def pack_MATI(self):
return self.pack_long_chunk('MATI', self.material.index)
def pack(self):
'''Packs the SEGM chunk. This should be used to retrieve the segment in packed form.'''
data = [b'SEGM']
data.append('size')
data.append(self.pack_MATI())
data.append(self.vertices.pack())
data.append(self.faces.pack())
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
def repack(self):
return self.pack()
class ShadowGeometry(Packer):
def __init__(self, collection=None):
self.collection = collection
self.classname = 'ShadowGeometry'
self.data = ''
self.positions = []
self.edges = []
def get_json(self):
data = {
'type': self.classname,
'num_positions': len(self.positions),
'positions': self.positions,
'num_edges': len(self.edges),
'edges': self.edges,
}
return data
@staticmethod
def from_json(data, collection=None):
geo = ShadowGeometry()
geo.collection = collection
geo.positions = data['positions']
geo.edges = data['edges']
return geo
def dump(self, fh):
'''Dump information to open filehandler fileh.'''
fh.write('\t\t\t--- ShadowGeometry ---\n')
fh.write('\t\t\t\tNo data available.\n')
def repack(self):
data = [b'SHDW', 'size', self.data]
data[1] = struct.pack('<L', len(self.data))
return b''.join(data)
def pack(self):
data = [b'SHDW', 'size']
data.append(struct.pack('<L', len(self.positions)))
for pos in self.positions:
data.append(struct.pack('<fff', *pos))
data.append(struct.pack('<L', len(self.edges)))
for edge in self.edges:
data.append(struct.pack('<HHHH', *edge))
data[1] = struct.pack('<L', 4 + 4 + 6 * len(self.edges) + 12 * len(self.positions))
return b''.join(data)
class ClothCollision(Packer):
def __init__(self, cloth_geo=None):
self.cloth = cloth_geo
self.name = ''
self.parent = ''
# 0: Sphere, 1: Cylinder
self.primitive_type = 0
self.primitive_data = 4, 4, 4
def get_json(self):
data = {
'name': self.name,
'parent': self.parent,
'primitive_type': self.primitive_type,
'primitive_data': self.primitive_data,
}
return data
@classmethod
def from_json(cls, data, cloth=None):
cc = cls()
cc.cloth = cloth
cc.name = data['name']
cc.parent = data['parent']
cc.primitive_type = data['primitive_type']
cc.primitive_data = data['primitive_data']
return cc
def pack(self):
data = [self.name + '\x00',
self.parent + '\x00',
struct.pack('<L', self.primitive_type),
struct.pack('<fff', *self.primitive_data)]
return b''.join(data)
class ClothGeometry(Packer):
def __init__(self, collection=None):
self.collection = collection
self.classname = 'ClothGeometry'
self.texture = b'no_texture'
self.vertices = None
self.faces = None
self.stretch = b''
self.stretch_constraints = set()
self.cross = b''
self.cross_constraints = set()
self.bend = b''
self.bend_constraints = set()
self.collision = b''
self.collisions = []
def get_json(self):
data = {
'type': self.classname,
'texture': self.texture,
'num_vertices': len(self.vertices),
'vertices': self.vertices.get_json(),
'num_faces': len(self.faces),
'faces': self.faces.get_json(),
'stretch': self.stretch_constraints,
'cross': self.cross_constraints,
'bend': self.bend_constraints,
'collisions': [c.get_json() for c in self.collisions],
}
return data
@staticmethod
def from_json(data, collection=None):
geo = ClothGeometry()
geo.collection = collection
geo.vertices = ClothVertexCollection.from_json(data['vertices'], geo)
geo.faces = FaceCollection.from_json(data['faces'], geo)
geo.stretch_constraints = data['stretch']
geo.cross_constraints = data['cross']
geo.bend_constraints = data['bend']
geo.collisions = [ClothCollision.from_json(collision, geo) for collision in data['collisions']]
return geo
def dump(self, fh):
'''Dump information to open filehandler fileh.'''
fh.write('\t\t\t--- ClothGeometry ---\n')
fh.write('\t\t\t\tVertices: {0}\n'.format(len(self.vertices)))
fh.write('\t\t\t\tFaces: {0}\n'.format(len(self.faces)))
def assign_parents(self):
'''Assign segment attribute for every collection.'''
self.vertices.segment = self
self.faces.segment = self
def create_constraints(self):
''' Creates constraints between faces and vertices so the cloth
simulation can keep the cloth's shape
'''
def is_fixed(idx):
return self.vertices[idx].is_fixed
# Note that the Pandemic exporter does _not_ constrain fixed points to each other (which
# really doesn't make any sense). So we don't do it either
for face in self.faces:
# p1 ┌────┐ p2
# │ │
# │ │
# p4 └────┘ p3
last_vert_idx = face.vertices[-1]
# Stretch constraints, along the boundary of the polygon
# p1-p2, p2-p3, p3-p4, p4-p1
# This allows for any amount of sides to the polygon
for vert_idx in face.vertices:
both_fixed = is_fixed(vert_idx) and is_fixed(last_vert_idx)
if both_fixed:
continue
# Check both possible orders, we only want one connection between two vertices
a_b_exists = (last_vert_idx, vert_idx) in self.stretch_constraints
b_a_exists = (vert_idx, last_vert_idx) in self.stretch_constraints
if not (a_b_exists or b_a_exists):
self.stretch_constraints.add((last_vert_idx, vert_idx))
last_vert_idx = vert_idx
# Cross constraints, diagonally across _quads_
# p1-p3, p2-p4
# Only works for quads currently
if len(face.vertices) == 4:
pair_1 = (face.vertices[0], face.vertices[2])
pair_2 = (face.vertices[1], face.vertices[3])
# Only add constraint if either or both vertices are dynamic
if not (is_fixed(pair_1[0]) and is_fixed(pair_1[1])):
self.cross_constraints.add(pair_1)
if not (is_fixed(pair_2[0]) and is_fixed(pair_2[1])):
self.cross_constraints.add(pair_2)
# Bend constraints
# Supposed to keep the overall shape of the cloth from overbending
#
# p1 p2 p3
# ┌─────┬─────┐
# │ │ │
# │ p8 │ p9 │ p4
# ├─────┼─────┤
# │ │ │
# │ │ │
# └─────┴─────┘
# p7 p6 p5
#
# p1-p3, p3-p5, p5-p7, p7-p1, p8-p4, p2-p6
# Connects all faces in this pattern
for face2 in self.faces:
if face is face2:
continue
# Vertices shared between the current two faces
shared_vertices = [v for v in face2.vertices if v in face.vertices]
if not shared_vertices:
continue
shared_vertex = shared_vertices[0]
# get_connections gets all vertices in a face that connect to the given one. So in
# the drawing above if we pass p8 to get_connections of the top-left face we will
# get [p1, p9]
# Shared vertices will be filtered out, so p1 remains
connections1 = []
for connection_vertex in face.get_connections(shared_vertex):
if connection_vertex not in shared_vertices:
connections1.append(connection_vertex)
# Same as above, assuming we pass p8 of the bottom-left face we will get [p9, p7]
# Shared vertices will be filtered out, so p7 remains
connections2 = []
for connection_vertex in face2.get_connections(shared_vertex):
if connection_vertex not in shared_vertices:
connections2.append(connection_vertex)
# Zip the two resulting lists ([p1] and [p7]) creating pair p1-p7
for vert_idx_1, vert_idx_2 in zip(connections1, connections2):
# Again, a constraint between two fixed points does not make sense. In this case
# we need to consider the case of fixed-dynamic _spanning_ a fixed point needs
# to be considered, too (e.g. p1-p7 where p1 and p8 are fixed). These should be
# kept
both_fixed = is_fixed(vert_idx_1) and is_fixed(vert_idx_2)
if both_fixed:
continue
a_b_exists = (vert_idx_1, vert_idx_2) in self.bend_constraints
b_a_exists = (vert_idx_2, vert_idx_1) in self.bend_constraints
if not (a_b_exists or b_a_exists):
self.bend_constraints.add((vert_idx_1, vert_idx_2))
def pack_stretch(self):
data = [b'SPRS', struct.pack('<LL', 4 + 4 * len(self.stretch_constraints), len(self.stretch_constraints))]
for item in self.stretch_constraints:
data.append(struct.pack('<HH', *item))
return b''.join(data)
def repack_stretch(self):
data = [b'SPRS', 'size']
# Just append the data we read when this .msh was loaded.
data.append(self.stretch)
data[1] = struct.pack('<L', len(self.stretch))
return b''.join(data)
def pack_cross(self):
data = [b'CPRS', struct.pack('<LL', 4 + 4 * len(self.cross_constraints), len(self.cross_constraints))]
for item in self.cross_constraints:
data.append(struct.pack('<HH', *item))
return b''.join(data)
def repack_cross(self):
data = [b'CPRS', 'size']
data.append(self.cross)
data[1] = struct.pack('<L', len(self.cross))
return b''.join(data)
def pack_bend(self):
data = [b'BPRS', struct.pack('<LL', 4 + 4 * len(self.bend_constraints), len(self.bend_constraints))]
for item in self.bend_constraints:
data.append(struct.pack('<HH', *item))
return b''.join(data)
def repack_bend(self):
data = [b'BPRS', 'size']
data.append(self.bend)
data[1] = struct.pack('<L', len(self.cross))
return b''.join(data)
def pack_collision(self):
data = [b'COLL', 'size', struct.pack('<L', len(self.collisions))]
# Length of size indicator = 4.
size = 4
for coll in self.collisions:
data.append(coll.pack())
size += len(data[-1])
# Make the length of the chunk a multiple of 4.
while size % 4 != 0:
size += 1
data.append('\x00')
data[1] = struct.pack('<L', size)
return b''.join(data)
def repack_collision(self):
data = [b'COLL', 'size']
data.append(self.collision)
data[1] = struct.pack('<L', len(self.collision))
return b''.join(data)
def pack(self):
data = [b'CLTH', 'size']
if self.texture:
data.append(self.pack_string_chunk('CTEX', self.texture))
else:
data.append(self.pack_string_chunk('CTEX', 'no_texture'))
data.append(self.vertices.pack_pos())
data.append(self.vertices.pack_uvs())
data.append(self.vertices.pack_fixed())
data.append(self.vertices.pack_weights())
data.append(self.faces.pack_cloth())
data.append(self.pack_stretch())
data.append(self.pack_cross())
data.append(self.pack_bend())
data.append(self.pack_collision())
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
def repack(self):
data = [b'CLTH', 'size']
if self.texture:
data.append(self.pack_string_chunk('CTEX', self.texture))
else:
data.append(self.pack_string_chunk('CTEX', 'no_texture'))
data.append(self.vertices.pack_pos())
data.append(self.vertices.pack_uvs())
data.append(self.vertices.pack_fixed())
data.append(self.vertices.pack_weights())
data.append(self.faces.pack_cloth())
data.append(self.repack_stretch())
data.append(self.repack_cross())
data.append(self.repack_bend())
data.append(self.repack_collision())
data[1] = struct.pack('<L', self.sum_seq(data, 2))
return b''.join(data)
class Face(object):
'''Keeps the indices of the vertices forming this face.'''
# Params:
# - vertices: a list of indices forming this face.
# - coll: the FaceCollection.
def __init__(self, vertices=None, coll=None):
# List of vertex indices(ints).
if vertices:
self.vertices = vertices
else:
self.vertices = None
# Reference to the FaceCollection.
if coll:
self.collection = coll
else:
self.collection = None
self.classname = 'Face'
def get_json(self):
data = {
'vertices': self.vertices,
}
return data
@staticmethod
def from_json(data, collection=None):
face = Face()
face.collection = collection
face.vertices = data['vertices']
return face
def get_connections(self, vertex):
''' Get all vertices that connect to the given vertex in this face'''
index = self.vertices.index(vertex)
connections = []
# Get the vertex before the given one Underflow -> take last one
if index - 1 < 0:
connections.append(self.vertices[-1])
else:
connections.append(self.vertices[index - 1])
# Get the vertex after the given one Overflow -> take first one
if index + 1 == len(self.vertices):
connections.append(self.vertices[0])
else:
connections.append(self.vertices[index + 1])
return connections
def replace(self, verts):
'''Replaces the local vertices list with a new one.'''
self.vertices = verts
def reverse_order(self):
'''Reverses the triangle order. Only works with tris.'''
self.vertices = self.vertices[0], self.vertices[2], self.vertices[1]
def add(self, vert_index):
'''Adds a vertex index to the local vertices.'''
if not self.vertices:
self.vertices = [vert_index]
return
self.vertices.append(vert_index)
def i(self, index):
'''Returns the vertex index at index index of the local vertices.'''
return self.vertices[index]
def SIindices(self):
'''Returns the face in CCW order for XSI importing.'''
if self.sides == 4:
return self.i(0), self.i(1), self.i(3), self.i(2)
else:
return self.i(0), self.i(1), self.i(2)
@property
def sides(self):
'''Returns the number of sides/vertices this face is constructed of.'''
return len(self.vertices)
def pack(self):
'''Packs the vertex indices for the STRP chunk.'''
index_map = None
if self.collection:
if self.collection.segment:
index_map = self.collection.segment.index_map
if (self.sides == 4) and (index_map is not None):
logging.debug(f"Vertex indices for the STRP index_map chunk are: {self.sides}...")
return struct.pack('<HHHH', index_map[self.vertices[0]] + 0x8000,
index_map[self.vertices[1]] + 0x8000,
index_map[self.vertices[2]],
index_map[self.vertices[3]])
elif (self.sides == 3) and (index_map is not None):
logging.debug(f"Vertex indices for the STRP index_map chunk are: {self.sides}...")
return struct.pack('<HHH', index_map[self.vertices[0]] + 0x8000,
index_map[self.vertices[1]] + 0x8000,
index_map[self.vertices[2]])
elif (self.sides == 4) and (index_map is None):
logging.debug(f"Vertex indices for the STRP chunk are: {self.sides}...")
return struct.pack('<HHHH', self.vertices[0] + 0x8000,
self.vertices[1] + 0x8000,
self.vertices[2],
self.vertices[3])
elif (self.sides == 3) and (index_map is None):
logging.debug(f"Vertex indices for the STRP chunk are: {self.sides}...")
return struct.pack('<HHH', self.vertices[0] + 0x8000,
self.vertices[1] + 0x8000,
self.vertices[2])
else:
logging.debug("Vertex indices for the STRP chunk are empty...")
return b''
def pack_tris(self):
'''Packs the vertex indices as tris for the CMSH chunk.'''
# index_map = self.collection.segment.index_map
# if (self.sides == 4) and (index_map is not None):
# return (struct.pack('<LLL', index_map[self.vertices[0]],
# index_map[self.vertices[1]],
# index_map[self.vertices[2]]),
# struct.pack('<LLL', index_map[self.vertices[0]],
# index_map[self.vertices[2]],
# index_map[self.vertices[3]]))
# elif (self.sides == 3) and (index_map is not None):
# return (struct.pack('<LLL', index_map[self.vertices[0]],
# index_map[self.vertices[1]],
# index_map[self.vertices[2]]),)
# elif (self.sides == 4) and (index_map is None):
# return (struct.pack('<LLL', self.vertices[0],
# self.vertices[1],
# self.vertices[2]),
# struct.pack('<LLL', self.vertices[0],
# self.vertices[2],
# self.vertices[3]))
# elif (self.sides == 3) and (index_map is None):
# return (struct.pack('<LLL', self.vertices[0],
# self.vertices[1],
# self.vertices[2]),)
# else:
# return ()
# Make sure everything returned has a length for correct size calculation.
if self.sides == 4:
return (struct.pack('<LLL', self.vertices[0],
self.vertices[1],
self.vertices[2]),
struct.pack('<LLL', self.vertices[0],
self.vertices[2],
self.vertices[3]))
elif self.sides == 3:
return (struct.pack('<LLL', self.vertices[0],
self.vertices[1],
self.vertices[2]), )
else:
return ()
def get_edges(self):
'''Returns unique edges.'''
if self.sides == 4:
return ((self.vertices[0], self.vertices[1]),
(self.vertices[1], self.vertices[2]),
(self.vertices[2], self.vertices[3]),
(self.vertices[3], self.vertices[0]))
elif self.sides == 3:
return ((self.vertices[0], self.vertices[1]),
(self.vertices[1], self.vertices[2]),
(self.vertices[2], self.vertices[3]))
else:
return []
def __repr__(self):
return 'Face({0})'.format(str(self.vertices))
def __str__(self):
return 'Face({0})'.format(str(self.vertices))
class FaceCollection(object):
def __init__(self, segm=None):
# List of Face objects.
self.faces = []
# Ref to parent(SegmentGeometry).
if segm:
self.segment = segm
else:
self.segment = None
self.classname = 'FaceCollection'
def get_json(self):
data = {
'faces': [face.get_json() for face in self.faces],
}
return data
@staticmethod
def from_json(data, segment=None):
coll = FaceCollection()
coll.segment = segment
coll.faces = [Face.from_json(face_data, coll) for face_data in data['faces']]
return coll
def get_faces(self):
'''Returns faces as vertex indices.'''
faces = []
for face in self.faces:
faces.extend([vertex for vertex in face.vertices])
return faces
def de_ngonize(self, only_tris=False):
'''Makes all n-gons to tris or quads. only_tris defines if the algorithm should try to fit quads in, too.'''
if only_tris:
return self._triangulate_ngons()
new_faces = []
for ndx, face in enumerate(self.faces):
# If the face has more than 4 sides, cut it into multiple faces.
# Only 3 and 4 sided faces are supported.
if face.sides > 4:
nface = Face(self)
numtris = face.sides - 2
numquads = numtris / 2.0
# 4.0 == int(4.0) but 4.5 != int(4.5).
# So, if it's possible to cut the current face into multiple quads, do it.
# Otherwise triangulate it.
if int(numquads) == numquads:
for n in range(int(numquads)):
nface = Face(self)
nface.vertices = face.vertices[n * 2:n * 2 + 4]
new_faces.append(nface)
else:
for n in range(int(numtris)):
# Reverse every 2nd tri so every tri is CCW.
if n / 2 != n / 2.0:
nface = Face(self)
nface.vertices = face.vertices[n:n + 3]
nface.reverse_order()
new_faces.append(nface)
continue
nface = Face(self)
nface.vertices = face.vertices[n:n + 3]
new_faces.append(nface)
else:
new_faces.append(face)
self.faces = new_faces
def _triangulate_ngons(self):
'''Triangulates n-gons of every face and sets the faces to the newly calculated ones.'''
new_faces = []
for ndx, face in enumerate(self.faces):
if face.sides > 3:
nface = Face(self)
numtris = face.sides - 2
# Just triangulate every face with more than 4 sides.
for n in range(int(numtris)):
# Reverse every 2nd tri so every tri is CCW.
if n / 2 != n / 2.0:
nface = Face(self)
nface.vertices = face.vertices[n:n + 3]
nface.reverse_order()
new_faces.append(nface)
continue
nface = Face(self)
nface.vertices = face.vertices[n:n + 3]
new_faces.append(nface)
else:
new_faces.append(face)
self.faces = new_faces
def add(self, face):
'''Adds a face to the collection.'''
face.collection = self
if not self.faces:
self.faces = [face]
return
self.faces.append(face)
def pack(self):
'''Packs vertex indices for every face into the STRP chunk.'''
data = [b'STRP', 'size', 'numitems']
faces = 0
for face in self.faces:
faces += face.sides
if face.sides == 4 or face.sides == 3:
data.append(face.pack())
data[1] = struct.pack('<L', faces * 2 + 4)
data[2] = struct.pack('<L', faces)
return b''.join(data)
def pack_cloth(self):
'''Packs triangles of every face into the cloth CMSH chunk.'''
data = [b'CMSH', 'size', 'num']
num = 0
for face in self.faces:
facetris = face.pack_tris()
num += len(facetris)
data.extend(facetris)
# Number of tris * number of points * size of float + size indicator size.
data[1] = struct.pack('<L', num * 3 * 4 + 4)
data[2] = struct.pack('<L', num)
return b''.join(data)
def stretch_edges(self):
'''Gets edges for SPRS cloth chunk.'''
edges = []
for face in self.faces:
face_edges = face.get_edges()
for edge in face_edges:
if not edge in edges and not (edge[1], edge[0]) in edges:
edges.append(edge)
for index, edge in enumerate(edges):
if self.segment.vertices[edge[0]].is_fixed and self.segment.vertices[edge[1]].is_fixed:
edges.pop(index)
return edges
def cross_edges(self):
'''Gets edges for CPRS cloth chunk.'''
edges = []
for face in self.faces:
if face.sides == 4:
# Append edges which cross the quad.
edges.append((face.i(0), face.i(2)))
edges.append((face.i(1), face.i(3)))
return edges
def bend_edges(self):
'''Get edges for BPRS cloth chunk.'''
return ()
def __str__(self):
return str(self.faces)
def __repr__(self):
return str(self.faces)
def __getitem__(self, key):
return self.faces[key]
def __len__(self):
return len(self.faces)
class Vertex(object):
def __init__(self, pos=(0, 0, 0), normal=None, coll=None):
# Reference to parent(VertexCollection).
self.collection = coll
self.classname = 'Vertex'
self.index = 0
self.x = pos[0]
self.y = pos[1]
self.z = pos[2]
if normal:
self.nx = normal[0]
self.ny = normal[1]
self.nz = normal[2]
else:
self.nx = 1.0
self.ny = 1.0
self.nz = 1.0
self.u, self.v = 0.0, 0.0
self.color = Color()
self.deformers = ['none', 'none', 'none', 'none']
self.deformer_indices = [0, 0, 0, 0]
self.weights = [1.0, 0.0, 0.0, 0.0]
def get_json(self):
data = {
'position': self.pos,
'uv': self.uv,
'normal': self.normal,
'deformers': self.deformers,
'weights': self.weights,
'color': self.color.get_json()
}
return data
@staticmethod
def from_json(data, coll=None):
vert = Vertex()
vert.collection = coll
vert.pos = data['position']
vert.normal = data['normal']
vert.uv = data['uv']
vert.color = Color.from_json(data['color'])
vert.deformers = data['deformers']
vert.weights = data['weights']
return vert
def dump(self, fh):
fh.write('\t\tVERTEX\n')
fh.write('\t\t\tPos: {0:3}, {1:3}, {2:3}\n'.format(*self.pos))
fh.write('\t\t\tUV: {0:3}, {1:3}\n'.format(*self.uv))
def __hash__(self):
return hash((self.x, self.y, self.z, self.u, self.v, self.nx, self.ny, self.nz))
def __eq__(self, other):
if (self.x == other.x) and (self.y == other.y) and (self.z == other.z):
if (self.u == other.u) and (self.v == other.v):
if (self.nx == other.nx) and (self.ny == other.ny) and (self.nz == other.nz):
return True
return False
def __repr__(self):
return 'Vertex({0}, {1}, {2})'.format(*self.pos)
@property
def pos(self):
return self.x, self.y, self.z
@pos.setter
def pos(self, value):
self.x, self.y, self.z = value
@property
def uv(self):
return self.u, self.v
@uv.setter
def uv(self, value):
self.u, self.v = value
@property
def normal(self):
return self.nx, self.ny, self.nz
@normal.setter
def normal(self, value):
self.nx, self.ny, self.nz = value
def translate(self, vector3):
self.x += vector3[0]
self.y += vector3[1]
self.z += vector3[2]
def pack_pos(self):
return struct.pack('<fff', *self.pos)
def pack_normal(self):
return struct.pack('<fff', *self.normal)
def pack_uvs(self):
return struct.pack('<ff', *self.uv)
def pack_weights(self):
data = []
for index, weight in itertools.izip(self.deformer_indices, self.weights):
data.append(struct.pack('<Lf', index, weight))
return b''.join(data)
def pack_color(self):
return self.color.pack_bgra('B')
class VertexCollection(object):
def __init__(self, segm=None):
# Ref to parent SegmentGeometry.
if segm:
self.segment = segm
else:
self.segment = None
self.vertices = []
self.classname = 'VertexCollection'
self.colored = False
self.weighted = False
self.uved = False
def get_json(self):
data = {
'vertices': [v.get_json() for v in self.vertices],
'colored': self.colored,
'weighted': self.weighted,
'uved': self.uved,
}
return data
@staticmethod
def from_json(data, segment=None):
coll = VertexCollection()
coll.segment = segment
for vdata in data['vertices']:
coll.vertices.append(Vertex.from_json(vdata, coll))
coll.colored = data['colored']
coll.weighted = data['weighted']
coll.uved = data['uved']
return coll
def dump(self, fh):
for v in self.vertices:
v.dump(fh)
def set_flags_from_vertcoll(self, vertcoll):
'''Transfers flags from the given VertexCollection vertcoll to this one.'''
self.colored = vertcoll.colored
self.weighted = vertcoll.weighted
self.uved = vertcoll.uved
def get_positions(self):
'''Yield all positions.'''
for vertex in self.vertices:
yield vertex.pos
def pack_positions(self):
data = [b'POSL']
data.append(struct.pack('<L', len(self.vertices) * 4 * 3 + 4))
data.append(struct.pack('<L', len(self.vertices)))
for vertex in self.vertices:
data.append(vertex.pack_pos())
return b''.join(data)
def get_normals(self):
'''Yield all normals.'''
for vertex in self.vertices:
yield vertex.normal
def pack_normals(self):
data = [b'NRML']
data.append(struct.pack('<L', len(self.vertices) * 4 * 3 + 4))
data.append(struct.pack('<L', len(self.vertices)))
for vertex in self.vertices:
data.append(vertex.pack_normal())
return b''.join(data)
def get_uvs(self):
'''Yield all UVs.'''
for vertex in self.vertices:
yield vertex.uv
def get_uv_list(self):
return [vertex.uv for vertex in self.vertices]
def pack_uvs(self):
data = [b'UV0L']
data.append(struct.pack('<L', len(self.vertices) * 4 * 2 + 4))
data.append(struct.pack('<L', len(self.vertices)))
for vertex in self.vertices:
data.append(vertex.pack_uvs())
return b''.join(data)
def set_uvs(self, uv_list):
for uv, vertex in itertools.izip(uv_list, self.vertices):
vertex.u = uv[0]
vertex.v = uv[1]
def get_colors(self):
'''Yield all color values.'''
for vertex in self.vertices:
yield vertex.color.get()
def set_colors(self, color_list):
for color, vertex in itertools.izip(color_list, self.vertices):
vertex.color = color
def pack_colors(self):
data = [b'CLRL']
data.append(struct.pack('<L', len(self.vertices) * 4 + 4))
data.append(struct.pack('<L', len(self.vertices)))
for vertex in self.vertices:
data.append(vertex.pack_color())
return b''.join(data)
def get_weights(self):
weights = []
for vertex in self.vertices:
weights.append(vertex.deformers[0])
weights.append(vertex.weights[0])
weights.append(vertex.deformers[1])
weights.append(vertex.weights[1])
weights.append(vertex.deformers[2])
weights.append(vertex.weights[2])
weights.append(vertex.deformers[3])
weights.append(vertex.weights[3])
return weights
def set_weights(self, weights, deformers, indices):
for weight, deformer_tuple, index_tpl, vertex in itertools.izip(weights, deformers, indices, self.vertices):
vertex.weights = weight
vertex.deformers = deformer_tuple
vertex.deformer_indices = index_tpl
def pack_weights(self):
data = [b'WGHT']
data.append(struct.pack('<L', len(self.vertices) * 4 * 8 + 4))
data.append(struct.pack('<L', len(self.vertices)))
for vertex in self.vertices:
data.append(vertex.pack_weights())
return b''.join(data)
def pack(self):
data = [self.pack_positions(),
self.pack_normals()]
if self.uved:
data.append(self.pack_uvs())
if self.colored:
data.append(self.pack_colors())
if self.weighted:
data.append(self.pack_weights())
return b''.join(data)
def add(self, vertex):
'''Adds a vertex to the collection and sets
its collection property.'''
vertex.collection = self
self.vertices.append(vertex)
def __str__(self):
return str(self.vertices)
def __repr__(self):
return str(self.vertices)
def __getitem__(self, key):
return self.vertices[key]
def __len__(self):
return len(self.vertices)
class ClothVertex(object):
def __init__(self, pos, coll=None):
if coll:
self.collection = coll
else:
self.collection = None
self.classname = 'ClothVertex'
self.index = 0
self.x = pos[0]
self.y = pos[1]
self.z = pos[2]
self.u, self.v = 0.0, 0.0
self.deformer = ''
self.is_fixed = False
def get_json(self):
data = {
'position': self.pos,
'uv': self.uv,
'deformer': self.deformer,
'is_fixed': self.is_fixed,
}
return data
@staticmethod
def from_json(data, collection=None):
v = ClothVertex()
v.collection = collection
v.pos = data['position']
v.uv = data['uv']
v.deformer = data['deformer']
v.is_fixed = data['is_fixed']
return v
@property
def pos(self):
return self.x, self.y, self.z
@pos.setter
def pos(self, value):
self.x, self.y, self.z = value
@property
def uv(self):
return self.u, self.v
@uv.setter
def uv(self, value):
self.u, self.v = value
def pack_pos(self):
'''Returns x, y, z packed into 3 floats.'''
return struct.pack('<fff', *self.pos)
def pack_uvs(self):
'''Returns u, v packed into 2 floats.'''
return struct.pack('<ff', *self.uv)
class ClothVertexCollection(Packer):
def __init__(self, segm=None, verts=None):
if segm:
self.segment = segm
else:
self.segment = None
if verts:
self.vertices = verts
else:
self.vertices = []
self.classname = 'ClothVertexCollection'
self.uved = True
def get_json(self):
data = {
'vertices': [v.get_json() for v in self.vertices],
'uved': self.uved,
}
return data
@staticmethod
def from_json(data, segment=None):
coll = ClothVertexCollection()
coll.segment = segment
coll.uved = data['uved']
coll.vertices = [ClothVertex.from_json(vdata, coll) for vdata in data['vertices']]
return coll
def fixed(self):
return [point for point in self.vertices if point.is_fixed]
def fixed_indices(self):
return [index for index, point in enumerate(self.vertices) if point.is_fixed]
def get_deformers(self):
return [point.deformer for point in self.vertices if point.deformer]
def add(self, vert):
'''Adds a vertex to the collection and sets its collection property.'''
vert.collection = self
self.vertices.append(vert)
def pack_pos(self):
'''Packs vertex positions into CPOS chunk.'''
data = [b'CPOS']
data.append(struct.pack('<L', len(self.vertices) * 4 * 3 + 4))
data.append(struct.pack('<L', len(self.vertices)))
for vert in self.vertices:
data.append(vert.pack_pos())
return b''.join(data)
def pack_uvs(self):
data = [b'CUV0']
data.append(struct.pack('<L', len(self.vertices) * 4 * 2 + 4))
data.append(struct.pack('<L', len(self.vertices)))
for vert in self.vertices:
data.append(vert.pack_uvs())
return b''.join(data)
def pack_fixed(self):
data = [b'FIDX', 'size', 'num']
num = 0
for index, vert in enumerate(self.vertices):
if vert.is_fixed:
data.append(struct.pack('<L', index))
num += 1
data[1] = struct.pack('<L', num * 4 + 4)
data[2] = struct.pack('<L', num)
return b''.join(data)
def pack_weights(self):
data = [b'FWGT', 'size', 'num']
num = 0
data2 = []
for index, vert in enumerate(self.vertices):
if vert.is_fixed and vert.deformer:
data2.append(self.null_terminate(vert.deformer))
num += 1
data.append(b''.join(data2))
data[1] = struct.pack('<L', len(data[3]) + 4)
data[2] = struct.pack('<L', num)
return b''.join(data)
def __str__(self):
return str(self.vertices)
def __repr__(self):
return str(self.vertices)
def __getitem__(self, key):
return self.vertices[key]
def __len__(self):
return len(self.vertices)
class Animation(Packer):
# Params:
# - parent: Parent class(Msh)
# - empty: Empty animation?
# 'empty' = empty animation
# 'maybe_empty' = check .bones and .cycle before packing
def __init__(self, msh=None, empty=None):
# Ref to Msh.
self.msh = msh
self.bones = None
self.cycle = None
self.cycles = []
self.classname = 'Animation'
if empty == 'empty':
# If the animation export is disabled, replace pack function.
self.pack = self.pack_empty
elif empty == 'maybe_empty':
self.pack = self.pack_check
@property
def empty(self):
'''Checks if this animation has any bones or cycle.'''
if self.bones and self.cycle:
return False
return True
def pack_check(self):
if self.bones and self.cycle:
return self.pack()
else:
return self.pack_empty()
def pack(self):
data = []
data.append(self.bones.pack_SKL2())
data.append(self.bones.pack_BLN2())
data.append('ANM2')
data.append('size')
data.append(self.cycle.pack())
data.append(self.bones.pack_KFR3())
data[3] = struct.pack('<L', self.sum_seq(data, 4))
return b''.join(data)
def pack_empty(self):
return b''
class Cycle(object):
# animation: parent Animation
# name: string
# fps: float
# style: int
# frames: tuple2 (frame_start, frame_end)
def __init__(self, animation=None):
# Ref to Animation.
self.animation = animation
self.name = b'fullanimation'
self.classname = 'AnimCycle'
self.fps = 30
self.style = 0
self.frames = (1, 100)
def numframes(self):
return self.frames[1] - (self.frames[0] - 1)
def animname(self):
return self.name.ljust(64, '\x00')
def pack(self):
data = [b'CYCL', struct.pack('<L', 84), struct.pack('<L', 1)]
data.append(self.animname())
data.append(struct.pack('<f', self.fps))
data.append(struct.pack('<L', self.style))
data.append(struct.pack('<LL', *self.frames))
return b''.join(data)
class Bone(object):
# Params:
# - collection: class(BoneCollection)
def __init__(self, collection=None):
# Parent BoneCollection.
self.collection = collection
self.classname = 'Bone'
# Name of the bone(and it's accompanying Model).
self.name = ''
# CRC checksum of the bone.
self.CRC = '' # msh2_crc.crc(self.name)
# The purpose of the following parameters is unclear.
self.bone_type = 0
self.constrain = 1.0
self.bone1len = 0.0
self.bone2len = 0.0
self.blend_factor = 0
self.keyframe_type = 0
# List of position frames(x, y, z).
self.pos_keyframes = None
self.pos_keyframe_indices = None
# List of rotation frames(x, y, z, w).
self.rot_keyframes = None
self.rot_keyframe_indices = None
def dump(self, fh):
w = fh.write
w('BONE - {0}\n'.format(self.name))
w('\tRotation:\n')
for rot in self.rot_keyframes:
w('\t\t{0}\n'.format(rot))
w('\tTransform:\n')
for pos in self.pos_keyframes:
w('\t\t{0}\n'.format(pos))
def recrc(self):
'''Calculates a Zero CRC from the name.'''
self.CRC = msh2_crc.strcrc(self.name)
def set_name_from_crc(self):
'''Tries to reverse-engineer the CRC into a name
via comparing to the CRCs of all models in this .msh.'''
if not self.CRC:
raise MSH2Error('Bone doesnt have a CRC applied for reverse-engineering.')
names = self.collection.get_check_names_list()
name = msh2_crc.compare_crc_adv(names, self.CRC)
if name:
self.name = name
self.collection.remove_check_name(name)
def pack_SKL2(self):
'''Packs attributes for the SKL2 chunk.'''
data = [self.CRC,
struct.pack('<L', self.bone_type),
struct.pack('<f', self.constrain),
struct.pack('<L', self.bone1len),
struct.pack('<L', self.bone2len)]
return b''.join(data)
def pack_BLN2(self):
'''Packs attributes for the BLN2 chunk.'''
data = [self.CRC,
struct.pack('<L', self.blend_factor)]
return b''.join(data)
def pack_KFR3(self):
'''Packs position and rotation frames for the KFR3 chunk.'''
data = [self.CRC,
struct.pack('<L', self.keyframe_type),
struct.pack('<L', len(self.pos_keyframes)),
struct.pack('<L', len(self.rot_keyframes))]
for ndx, frame in enumerate(self.pos_keyframes):
data.append(struct.pack('<L', ndx + self.collection.animation.cycle.frames[0]))
data.append(struct.pack('<fff', *frame))
for ndx, frame in enumerate(self.rot_keyframes):
data.append(struct.pack('<L', ndx + self.collection.animation.cycle.frames[0]))
data.append(struct.pack('<ffff', *frame))
return b''.join(data)
class BoneCollection(Packer):
# Params:
# - animation: class(Animation)
def __init__(self, animation=None):
if animation:
self.animation = animation
else:
self.animation = None
self.classname = 'BoneCollection'
self.bones = []
self.check_names = None
def add(self, bone):
'''Adds bone to the collection and sets its
collection attribute.'''
bone.collection = self
self.bones.append(bone)
def remove(self, index):
'''Remove bone at index index.'''
del self.bones[index]
def replace(self, bones):
'''Replace internal bones list with bones.'''
self.bones = bones
def get_by_name(self, name):
'''Get bone by name.'''
for bone in self.bones:
if name == bone.name:
return bone
def get_check_names_list(self):
'''Returns list of all bone names.
This list will be reduced if the name of a bone is found
to maximize performance. It's used to calculate the name
of a bone by comparing the CRC in the .msh file and a
newly generated CRC of every bone in this list.'''
if not self.check_names:
self.check_names = self.animation.msh.models.get_names_list()
return self.check_names
def remove_check_name(self, name):
'''If the name of a bone is matched with a CRC, remove
the name from the list to reduce iteration time.'''
self.check_names.remove(name)
def __str__(self):
return str(self.bones)
def __repr__(self):
return str(self.bones)
def __getitem__(self, key):
return self.bones[key]
def __len__(self):
return len(self.bones)
def pack_SKL2(self):
data = [b'SKL2']
data.append(struct.pack('<L', len(self.bones) * 20 + 4))
data.append(struct.pack('<L', len(self.bones)))
for bone in self.bones:
data.append(bone.pack_SKL2())
return b''.join(data)
def pack_BLN2(self):
data = [b'BLN2']
data.append(struct.pack('<L', len(self.bones) * 8 + 4))
data.append(struct.pack('<L', len(self.bones)))
for bone in self.bones:
data.append(bone.pack_BLN2())
return b''.join(data)
def pack_KFR3(self):
data = [b'KFR3', 'size']
data.append(struct.pack('<L', len(self.bones)))
for bone in self.bones:
data.append(bone.pack_KFR3())
data[1] = struct.pack('<L', self.sum_seq(data, 3) + 4)
return b''.join(data)
class Color(object):
def __init__(self, color=None):
if color:
self.red = color[0]
self.green = color[1]
self.blue = color[2]
self.alpha = color[3]
else:
self.red = 128
self.green = 128
self.blue = 128
self.alpha = 255
self.classname = 'Color'
def get_json(self):
data = {
'rgba': self.rgba,
}
return data
@staticmethod
def from_json(data):
col = Color()
col.rgba = data['rgba']
return col
@property
def rgba(self):
return self.red, self.green, self.blue, self.alpha
@rgba.setter
def rgba(self, value):
self.red, self.green, self.blue, self.alpha = value
def get_f(self):
if isinstance(self.red, float):
return self.red, self.green, self.blue, self.alpha
else:
return ((self.red / 255.), (self.green / 255.),
(self.blue / 255.), (self.alpha / 255.))
def get_b(self):
if isinstance(self.red, float):
return (int(self.red * 255), int(self.green * 255),
int(self.blue * 255), int(self.alpha * 255))
else:
return self.red, self.green, self.blue, self.alpha
def get(self):
return self.red, self.green, self.blue, self.alpha
def set(self, r, g, b, a=255):
self.red = r
self.green = g
self.blue = b
self.alpha = a
def __str__(self):
return '{0}, {1}, {2}, {3}'.format(self.red, self.green, self.blue, self.alpha)
def __repr__(self):
return self.__str__()
def pack(self, mode='B'):
'''Packs color channels, default type is B(bool).
No converting is done, so if you pass f for mode
but the values are from 0-255 you will get that
value as float.'''
return struct.pack('<{0}'.format(mode * 4),
self.red,
self.green,
self.blue,
self.alpha)
def pack_bgra(self, mode='B'):
'''Same as pack but packs into BGRA ordering.'''
return struct.pack('<{0}'.format(mode * 4),
self.blue,
self.green,
self.red,
self.alpha)
class Transform(object):
def __init__(self, tra=None, rot=None, sca=None):
if rot:
self.rotation = rot
else:
self.rotation = 0.0, 0.0, 0.0, 1.0
if tra:
self.translation = tra
else:
self.translation = 0.0, 0.0, 0.0
if sca:
self.scale = sca
else:
self.scale = 1.0, 1.0, 1.0
self.classname = 'Transform'
def get_json(self):
data = {
'position': self.translation,
'rotation': self.euler_angles(),
'scale': self.scale,
}
return data
@classmethod
def from_json(cls, data):
tr = cls()
tr.translation = data['position']
tr.rotation = tr.euler_to_quaternion(data['rotation'])
tr.scale = data['scale']
return tr
def __str__(self):
return 'Pos({0}), Rot({1}), Scl({2})'.format(', '.join([str(i) for i in self.translation]),
', '.join([str(i) for i in self.rotation]),
', '.join([str(i) for i in self.scale]))
def __repr__(self):
return 'Pos({0}), Rot({1}), Scl({2})'.format(', '.join([str(i) for i in self.translation]),
', '.join([str(i) for i in self.rotation]),
', '.join([str(i) for i in self.scale]))
def pack(self):
data = [b'TRAN', struct.pack('<L', 40)]
data.append(struct.pack('<fff', *self.scale))
data.append(struct.pack('<ffff', *self.rotation))
data.append(struct.pack('<fff', *self.translation))
return b''.join(data)
def euler_angles(self):
'''Returns the internal Quaternion in Euler Angles(radians).'''
test = self.rotation[0] * self.rotation[1] + self.rotation[2] * self.rotation[3]
if test > 0.499:
heading = 2 * math.atan2(self.rotation[0], self.rotation[3])
attitude = math.pi / 2
bank = 0
return math.degrees(heading), math.degrees(attitude), math.degrees(bank)
elif test < -0.499:
heading = -2 * math.atan2(self.rotation[0], self.rotation[3])
attitude = -1 * math.pi / 2
bank = 0
return math.degrees(heading), math.degrees(attitude), math.degrees(bank)
sqx = self.rotation[0] * self.rotation[0]
sqy = self.rotation[1] * self.rotation[1]
sqz = self.rotation[2] * self.rotation[2]
heading = math.atan2((2 * self.rotation[1] * self.rotation[3] -
2 * self.rotation[0] * self.rotation[2]),
1 - 2 * sqy - 2 * sqz)
attitude = math.asin(2 * test)
bank = math.atan2((2 * self.rotation[0] * self.rotation[3] -
2 * self.rotation[1] * self.rotation[2]),
1 - 2 * sqx - 2 * sqz)
return math.degrees(heading), math.degrees(attitude), math.degrees(bank)
def euler_to_quaternion(self, euler):
c1 = math.cos(math.radians(euler[0] / 2))
s1 = math.sin(math.radians(euler[0] / 2))
c2 = math.cos(math.radians(euler[1] / 2))
s2 = math.sin(math.radians(euler[1] / 2))
c3 = math.cos(math.radians(euler[2] / 2))
s3 = math.sin(math.radians(euler[2] / 2))
c1c2 = c1 * c2
s1s2 = s1 * s2
w = c1c2 * c3 - s1s2 * s3
x = c1c2 * s3 + s1s2 * c3
y = s1 * c2 * c3 + c1 * s2 * s3
z = c1 * s2 * c3 - s1 * c2 * s3
self.rotation = x, y, z, w
return x, y, z, w
def reversed_quaternion(self):
'''Returns the Quaternion as W, X, Y, Z.'''
return self.rotation[3], self.rotation[0], self.rotation[1], self.rotation[2]
class BBox(Transform):
def __init__(self):
self.rotation = 0.0, 0.0, 0.0, 1.0
self.extents = 4.0, 4.0, 4.0
self.center = 0.0, 0.0, 0.0
self.radius = 6.92
self.classname = 'BBox'
def get_json(self):
data = {
'rotation': self.euler_angles(),
'extents': self.extents,
'center': self.center,
'radius': self.radius,
}
return data
@staticmethod
def from_json(data):
b = BBox()
b.rotation = b.euler_to_quaternion(data['rotation'])
b.extents = data['extents']
b.center = data['center']
b.radius = data['radius']
return b
def pack(self):
data = [b'BBOX', struct.pack('<L', 44)]
data.append(struct.pack('<ffff', *self.rotation))
data.append(struct.pack('<fff', *self.center))
data.append(struct.pack('<fff', *self.extents))
data.append(struct.pack('<f', self.radius))
return b''.join(data)
Reference in New Issue View Git Blame Copy Permalink