def find_unique_name(obj_names=None, include_last_number=True, do_rename=False):
def _find_unique_name(obj_name):
node = node_utils.get_pymxs_node(obj_name)
if not node:
return obj_name
unique = FindUniqueName(obj_name)
unique.get_last_number(include_last_number)
unique_name = unique.get()
unique_name = rt.uniquename(unique_name)
if do_rename:
node.name = unique_name
return node.name
else:
return unique_name
if not obj_names:
obj_names = [obj.name for obj in list(rt.selection)]
if isinstance(obj_names, (tuple, list)):
unique_names = list()
for obj in enumerate(obj_names):
unique_names.append(_find_unique_name(obj))
return python.remove_dupes(unique_names)
else:
return rt.uniquename(obj_names)
def _load_registered_paths_toolsets(self, package_name,
toolsets_file_paths):
"""
Loads all toolsets found in registered paths
"""
if not toolsets_file_paths:
return
toolsets_file_paths = python.remove_dupes(
python.force_list(toolsets_file_paths))
# Load toolsets data
for registered_path in toolsets_file_paths:
if not registered_path or not os.path.isdir(registered_path):
continue
for pth in folder.get_files_with_extension(
toolset.ToolsetWidget.EXTENSION,
registered_path,
full_path=True,
recursive=True):
try:
toolset_data = yamlio.read_file(pth, maintain_order=True)
except Exception:
logger.warning(
'Impossible to read toolset data from: "{}!'.format(
pth))
continue
if package_name not in self._toolset_groups:
self._toolset_groups[package_name] = list()
toolset_type = toolset_data.get('type')
toolset_not_added = True
for pkg_name, toolset_groups in self._toolset_groups.items():
for toolset_group in toolset_groups:
if toolset_type == toolset_group[
'type'] and pkg_name == package_name:
toolset_not_added = False
break
if not toolset_not_added:
break
if toolset_not_added:
self._toolset_groups[package_name].append(toolset_data)
def get_reference_paths(objects, without_copy_number=False):
"""
Returns the reference paths for the given objects
:param objects: str or list(str)
:param without_copy_number: bool
:return: list(str)
"""
paths = list()
objects = python.force_list(objects)
for obj in objects:
if not is_referenced(obj):
continue
paths.append(
maya.cmds.referenceQuery(obj,
filename=True,
wcn=without_copy_number))
return python.remove_dupes(paths)
def get_deformer_list(node_type='geometryFilter',
affected_geometry=[],
regex_filter=''):
"""
Returns a list of deformers that match the input criteria
You can list deformers connected to a specific geometry, by type and filer the results using regular expressions
:param node_type: str, Deformer type as string. Optional arg, only return deformers of specified type
:param affected_geometry: list(str), Affected geometry list. Optional arg, will list deformers connected to the
specific geometry
:param regex_filter: str, Regular expression as string. Optional arg, will filter results
"""
deformer_nodes = maya.cmds.ls(type=node_type)
# Filter by affected geometry
if affected_geometry:
if type(affected_geometry) == str:
affected_geometry = [affected_geometry]
history_nodes = maya.cmds.listHistory(affected_geometry,
groupLevels=True,
pruneDagObjects=True)
deformer_nodes = maya.cmds.ls(history_nodes, type=node_type)
# Remove duplicated, tweak and transferAttributes nodes
deformer_nodes = python.remove_dupes(deformer_nodes)
tweak_nodes = maya.cmds.ls(deformer_nodes, type='tweak')
if tweak_nodes:
deformer_nodes = [x for x in deformer_nodes if x not in tweak_nodes]
transfer_attr_nodes = maya.cmds.ls(deformer_nodes,
type='transferAttributes')
if transfer_attr_nodes:
deformer_nodes = [
x for x in deformer_nodes if x not in transfer_attr_nodes
]
# Filter results
if regex_filter:
reg_filter = re.compile(regex_filter)
deformer_nodes = filter(reg_filter.search, deformer_nodes)
return deformer_nodes
def register_package_toolsets(self, package_name, toolsets_file_path,
toolsets_paths):
self._load_registered_paths_toolsets(package_name, toolsets_file_path)
if not toolsets_paths:
return
toolsets_paths = python.remove_dupes(python.force_list(toolsets_paths))
self.register_paths(toolsets_paths, package_name=package_name)
if package_name not in self._toolsets:
self._toolsets[package_name] = list()
toolset_data = self.plugins(package_name)
if not toolset_data:
return True
for toolset in self.plugins(package_name=package_name):
if not toolset:
continue
if not toolset.PACKAGE:
toolset.PACKAGE = package_name
for tool_set in toolset_data:
if tool_set.ID not in self._toolsets[package_name]:
toolset_config = configs.get_tool_config(
tool_set.ID, package_name=package_name)
if not toolset_config:
logger.warning(
'No valid configuration file found for toolset: "{}" in package: "{}"'
.format(tool_set.ID, package_name))
continue
tool_set.CONFIG = toolset_config
self._toolsets[package_name].append({tool_set.ID: tool_set})
return True
def add_joints(self, joints_list):
self._joints.extend(joints_list)
self._joints = python.remove_dupes(self._joints)