def from_path(cls, path, force_creation=False):
"""
Returns a new transfer instance for the given path
:param path: str
:param force_creation: bool
:return: TransferObject
"""
t = cls()
t.set_path(path)
if not os.path.isfile(path) or force_creation:
filename = os.path.basename(path)
filedir = os.path.dirname(path)
if os.path.isfile(filedir):
# This happens when we open files not created with library tools
return t
else:
if not os.path.isdir(filedir):
os.makedirs(filedir)
fileio.create_file(filename, filedir)
t.read()
return t
def save(self, *args, **kwargs):
dependencies = dict()
filepath = self.format_identifier()
if not filepath.endswith(MayaAttributesData.EXTENSION):
filepath = '{}{}'.format(filepath, MayaAttributesData.EXTENSION)
if not filepath:
LOGGER.warning(
'Impossible to save Attributes file because save file path not defined!'
)
return
objects = kwargs.get('objects', None)
scope = self._get_scope(objects)
if not scope:
LOGGER.warning(
'Nothing selected to export attributes of. Please, select a mesh,'
' curve, NURBS surface or lattice with skin weights to export')
return False
LOGGER.debug('Saving {} | {}'.format(filepath, kwargs))
if not os.path.isdir(filepath):
attributes_folder = folder.create_folder(filepath)
dependencies[attributes_folder] = 'attributes_folder'
for obj in scope:
LOGGER.info('Exporting attributes of {}'.format(obj))
file_name = fileio.create_file('{}{}'.format(obj, self.EXTENSION),
filepath)
lines = list()
attributes_to_export = self._get_attributes(obj)
shapes = self._get_shapes(obj)
if shapes:
shape = shapes[0]
shape_attributes = self._get_shape_attributes(shape)
if shape_attributes:
attributes_to_export = list(
set(attributes_to_export).union(shape_attributes))
if not attributes_to_export:
continue
for attribute_to_export in attributes_to_export:
try:
value = dcc.get_attribute_value(obj, attribute_to_export)
except Exception:
continue
lines.append("[ '{}', {} ]".format(attribute_to_export, value))
write_file = fileio.FileWriter(file_name)
write_file.write(lines)
if file_name and os.path.isfile(file_name):
dependencies[file_name] = 'attribute'
LOGGER.info('Attributes data export operation completed successfully!')
return dependencies
def set_active_library(self, library_name, skip_extension=False):
if not skip_extension:
file_name = '{}{}'.format(library_name, self._extension)
else:
file_name = library_name
library_path = fileio.create_file(file_name, self._curves_data_path)
self._active_library = library_name
self._library_curves[library_name] = dict()
if skip_extension:
self.load_data_file(library_path)
else:
self.load_data_file()
def save(self, **kwargs):
lines = kwargs.get('lines', None)
file_path = fileio.create_file(self.format_identifier())
if not os.path.isfile(file_path):
return False, 'Was not possible to create Python file'
lines = lines or ["if __name__ == '__main__':\n\tpass"]
fileio.write_lines(file_path, lines)
return True, ''
def set_directory(self, directory, filename='settings.cfg'):
"""
Set the file that is used to stored settins on file
:param directory: str
:param filename: str
:return: str
"""
self.directory = directory
self.file_path = fileio.create_file(filename=filename, directory=directory)
self._read()
return self.file_path
def update_dependencies(self, dependencies=None, recursive=True):
if not dependencies or not isinstance(dependencies, dict):
dependencies = dict()
dependency_file_name = '{}.json'.format(self._db.get_uuid(self.format_identifier()))
dependency_path = path_utils.join_path(self._db.get_dependencies_path(), dependency_file_name)
if not os.path.isfile(dependency_path):
fileio.create_file(dependency_path)
all_dependencies = dict()
current_dependencies = jsonio.read_file(dependency_path) or dict()
for dependency_uuid, dependency_name in current_dependencies.items():
dependency = self._db.find_identifier_from_uuid(dependency_uuid)
if not dependency:
continue
all_dependencies.update({dependency: dependency_name})
if dependencies:
all_dependencies.update(dependencies)
for dependency, dependency_name in all_dependencies.items():
self._db.add_dependency(self.format_identifier(), dependency, dependency_name)
dependencies = self._db.get_dependencies(self.format_identifier(), as_uuid=True)
if not dependencies:
fileio.delete_file(dependency_path)
return
jsonio.write_to_file(dependencies, dependency_path)
# We update all related dependencies
if recursive:
for dependency, dependency_name in all_dependencies.items():
dependency_item = self._db.get(dependency)
if not dependency_item:
continue
dependency_item.update_dependencies(
dependencies={self.format_identifier(): self.type()}, recursive=False)
def __init__(self, session_path):
self._path = session_path
if not os.path.isfile(session_path):
session_path_dir = os.path.dirname(session_path)
if not os.path.isdir(session_path_dir):
folder.create_folder(session_path_dir)
valid = fileio.create_file(os.path.basename(session_path),
os.path.dirname(session_path))
if not valid:
LOGGER.warning(
'Impossible to create session file. Session functionality disabled ...'
)
return
with open(session_path, 'w') as fh:
fh.write('{}')
def set_directory(self, directory, filename='settings.json'):
self.directory = directory
# Check that given file name is a valid JSON file
if not filename.endswith('.json'):
old = path.join_path(directory, filename)
if path.is_file(old):
self.file_path = old
self._read()
return
self.file_path = fileio.create_file(filename=filename, directory=directory)
self._read()
return self.file_path
def _get_json_file(self):
"""
Internal function that returns JSON file where settings are stored
:return: str
"""
if not self.file_path:
return
settings_directory = path.get_dirname(self.file_path)
name = path.get_basename(self.file_path, with_extension=False)
file_path = fileio.create_file(name + '.json', settings_directory)
if not file_path:
test_path = path.join_path(settings_directory, name + '.json')
if path.is_file(test_path):
file_path = test_path
return file_path
def run(self, influence_index, skin, weights, file_path):
influence_name = dcc.client().get_skin_influence_at_index(
influence_index, skin)
if not influence_name or not dcc.client().node_exists(influence_name):
return None, None
weight_path = fileio.create_file('{}.weights'.format(influence_name),
file_path)
if not path_utils.is_file(weight_path):
logger.warning(
'"{}" is not a valid path to save skin weights into!'.format(
file_path))
return None, None
writer = fileio.FileWriter(weight_path)
writer.write_line(weights)
influence_position = dcc.client().node_world_space_translation(
influence_name)
return "{'%s' : {'position' : %s}}" % (
influence_name, str(influence_position)), weight_path
def save(self, *args, **kwargs):
"""
Saves NG Skin weights file
"""
dependencies = dict()
filepath = self.format_identifier()
if not filepath:
logger.warning(
'Impossible to save NGSkin Cluster Weights file because save file path not defined!'
)
return
objects = kwargs.get('objects', None)
if not objects:
objects = dcc.client().selected_nodes(full_path=True)
if not objects:
logger.warning(
'Nothing selected to export skin weights of. Please, select a mesh,'
' curve, NURBS surface or lattice with skin weights to export')
return False
logger.debug('Saving {} | {}'.format(filepath, kwargs))
try:
if not dcc.is_plugin_loaded('ngSkinTools2'):
dcc.load_plugin('ngSkinTools2')
import ngSkinTools2
from ngSkinTools2 import api as ngst_api
except ImportError:
logger.warning(
'NgSkinTools 2.0 is not installed. Impossible to export ngSkin data'
)
return False
valid_nodes = list()
# Check that all objects that we are going to export have at least one skin cluster node associated
# Make sure also that all objects skin output folder have been created
obj_dirs = OrderedDict()
skin_nodes = OrderedDict()
geo_paths = OrderedDict()
skin_weights = OrderedDict()
for obj in objects:
if dcc.client().node_is_a_shape(obj):
obj = dcc.client().node_parent(obj, full_path=True)
obj_filename = obj
if obj.find('|') > -1:
obj_filename = obj_filename.replace('|', '.')
if obj_filename.startswith('.'):
obj_filename = obj_filename[1:]
if obj_filename.find(':') > -1:
obj_filename = obj_filename.replace(':', '-')
skin = dcc.client().find_deformer_by_type(obj, 'skinCluster')
if not skin:
logger.warning(
'Skip skin weights export for object because no skinCluster found!'
.format(obj))
continue
valid_nodes.append((obj, obj_filename, skin))
if not valid_nodes:
logger.warning(
'Skin exported failed! No objects found with skinClusters applied!'
)
return False
# Create skin folder only is valid nodes are available
file_name = '.{}'.format(os.path.basename(filepath))
file_folder = path_utils.join_path(os.path.dirname(filepath),
file_name)
if not os.path.isdir(file_folder):
skin_folder = folder.create_folder(file_folder, make_unique=True)
dependencies[skin_folder] = 'skin_folder'
for node_data in valid_nodes:
obj, obj_filename, skin = node_data
geo_path = path_utils.join_path(file_folder, obj_filename)
if path_utils.is_dir(geo_path):
folder.delete_folder(obj_filename, file_folder)
geo_path = folder.create_folder(obj_filename, file_folder)
if not geo_path:
logger.error(
'Unable to create skin weights directory: "{}" in "{}"'.
format(obj_filename, file_folder))
return False
dependencies[geo_path] = 'geo_path'
weights = dcc.client().get_skin_weights(skin)
obj_dirs[obj] = obj_filename
skin_nodes[obj] = skin
geo_paths[obj] = geo_path
skin_weights[obj] = weights
for (obj, skin_node), (_, geo_path), (_, skin_weights) in zip(
skin_nodes.items(), geo_paths.items(), skin_weights.items()):
logger.info('Exporting weights: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
info_lines = list()
info_file = fileio.create_file('influence.info', geo_path)
for influence in skin_weights:
if influence is None or influence == 'None':
continue
weight_list = skin_weights[influence]
if not weight_list:
continue
influence_name = skin_utils.get_skin_influence_at_index(
influence, skin_node)
if not influence_name or not dcc.node_exists(influence_name):
continue
influence_position = dcc.node_world_space_translation(
influence_name)
influence_line = "{'%s' : {'position' : %s}}" % (
influence_name, str(influence_position))
info_lines.append(influence_line)
writer = fileio.FileWriter(info_file)
writer.write(info_lines)
settings_file = fileio.create_file('settings.info', geo_path)
setting_lines = list()
if shape_utils.has_shape_of_type(obj, 'mesh'):
self._export_mesh_obj(obj, geo_path)
setting_lines.append("['skinNodeName', '{}']".format(
dcc.node_short_name(skin_node)))
if dcc.attribute_exists(skin_node, 'blendWeights'):
blend_weights = skin_utils.get_skin_blend_weights(skin_node)
setting_lines.append(
"['blendWeights', {}]".format(blend_weights))
if dcc.attribute_exists(skin_node, 'skinningMethod'):
skin_method = dcc.get_attribute_value(skin_node,
'skinningMethod')
setting_lines.append(
"['skinningMethod', {}]".format(skin_method))
write_settings = fileio.FileWriter(settings_file)
write_settings.write(setting_lines)
ng_skin_file_name = os.path.join(geo_path, 'ngdata.json')
ngst_api.export_json(obj, file=ng_skin_file_name)
logger.info(
'Skin weights exported successfully: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
data_to_save = OrderedDict()
for obj, obj_filename in obj_dirs.items():
data_to_save[obj] = {'enabled': True, 'folder': obj_filename}
with open(filepath, 'w') as fh:
json.dump(data_to_save, fh)
logger.info('Skin weights export operation completed successfully!')
return True
def _create_comment_file(self):
self._comment_file = fileio.create_file('comments.txt',
self._version_folder)
def save(self):
file_path = self.format_identifier()
fileio.create_file(file_path)
self._db.sync()
def save(self, **kwargs):
file_path = self.format_identifier()
fileio.create_file(file_path)
def save(self, *args, **kwargs):
dependencies = dict()
filepath = self.format_identifier()
if not filepath.endswith(SkinWeightsData.EXTENSION):
filepath = '{}{}'.format(filepath, SkinWeightsData.EXTENSION)
if not filepath:
logger.warning(
'Impossible to save Maya Skin Weights file because save file path not defined!'
)
return
objects = kwargs.get('objects', None)
if not objects:
objects = dcc.client().selected_nodes(full_path=True)
if not objects:
logger.warning(
'Nothing selected to export skin weights of. Please, select a mesh,'
' curve, NURBS surface or lattice with skin weights to export')
return False
logger.debug('Saving {} | {}'.format(filepath, kwargs))
valid_nodes = list()
# Check that all objects that we are going to export have at least one skin cluster node associated
# Make sure also that all objects skin output folder have been created
obj_dirs = OrderedDict()
skin_nodes = OrderedDict()
geo_paths = OrderedDict()
skin_weights = OrderedDict()
for obj in objects:
if dcc.client().node_is_a_shape(obj):
obj = dcc.client().node_parent(obj, full_path=True)
obj_filename = obj
if obj.find('|') > -1:
obj_filename = obj_filename.replace('|', '.')
if obj_filename.startswith('.'):
obj_filename = obj_filename[1:]
if obj_filename.find(':') > -1:
obj_filename = obj_filename.replace(':', '-')
skin = dcc.client().find_deformer_by_type(obj, 'skinCluster')
if not skin:
logger.warning(
'Skip skin weights export for object because no skinCluster found!'
.format(obj))
continue
valid_nodes.append((obj, obj_filename, skin))
if not valid_nodes:
logger.warning(
'Skin exported failed! No objects found with skinClusters applied!'
)
return False
# Create skin folder only is valid nodes are available
file_name = '.{}'.format(os.path.basename(filepath))
file_folder = path_utils.join_path(os.path.dirname(filepath),
file_name)
if not os.path.isdir(file_folder):
skin_folder = folder.create_folder(file_folder, make_unique=True)
dependencies[skin_folder] = 'skin_folder'
for node_data in valid_nodes:
obj, obj_filename, skin = node_data
geo_path = path_utils.join_path(file_folder, obj_filename)
if path_utils.is_dir(geo_path):
folder.delete_folder(obj_filename, file_folder)
geo_path = folder.create_folder(obj_filename, file_folder)
if not geo_path:
logger.error(
'Unable to create skin weights directory: "{}" in "{}"'.
format(obj_filename, file_folder))
return False
dependencies[geo_path] = 'geo_path'
weights = dcc.client().get_skin_weights(skin)
obj_dirs[obj] = obj_filename
skin_nodes[obj] = skin
geo_paths[obj] = geo_path
skin_weights[obj] = weights
for (obj, skin_node), (_, geo_path), (_, skin_weights) in zip(
skin_nodes.items(), geo_paths.items(), skin_weights.items()):
logger.info('Exporting weights: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
info_lines = list()
info_file = fileio.create_file('influence.info', geo_path)
dependencies[info_file] = 'info_file'
for influence in skin_weights:
if influence is None or influence == 'None':
continue
weight_list = skin_weights[influence]
if not weight_list:
continue
thread = LoadWeightFileThread()
influence_line, weight_path = thread.run(
influence, skin_node, skin_weights[influence], geo_path)
if influence_line:
info_lines.append(influence_line)
if weight_path and os.path.isfile(weight_path):
dependencies[weight_path] = 'weight'
writer = fileio.FileWriter(info_file)
writer.write(info_lines)
settings_file = fileio.create_file('settings.info', geo_path)
dependencies[settings_file] = 'settings'
setting_lines = list()
if dcc.client().node_has_shape_of_type(obj, 'mesh'):
mesh_path = self._export_mesh_obj(obj, geo_path)
if mesh_path and os.path.isfile(mesh_path):
dependencies[mesh_path] = 'geo_file'
if dcc.client().attribute_exists(skin_node, 'blendWeights'):
blend_weights = dcc.client().get_skin_blend_weights(skin_node)
setting_lines.append(
"['blendWeights', {}]".format(blend_weights))
if dcc.client().attribute_exists(skin_node, 'skinningMethod'):
skin_method = dcc.client().get_attribute_value(
skin_node, 'skinningMethod')
setting_lines.append(
"['skinningMethod', {}]".format(skin_method))
write_settings = fileio.FileWriter(settings_file)
write_settings.write(setting_lines)
logger.info(
'Skin weights exported successfully: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
data_to_save = OrderedDict()
for obj, obj_filename in obj_dirs.items():
data_to_save[obj] = {'enabled': True, 'folder': obj_filename}
with open(filepath, 'w') as fh:
json.dump(data_to_save, fh)
logger.info('Skin weights export operation completed successfully!')
return dependencies
