def tile_uv_val(self, sh, U, V, Uval, Vval, inc, uText, vText):
tex = pm.PyNode(sh + "_2dTex")
if not pm.objExists(tex):
pm.displayError("texture does not exist")
return None
if U:
if Uval:
u_val = float(Uval.getText())
tex.repeatU.set(u_val)
else:
u_val = tex.repeatU.get()
if inc:
tex.repeatU.set(u_val + 1)
else:
if (u_val - 1) > 0:
tex.repeatU.set(u_val - 1)
if V:
if Vval:
v_val = float(Vval.getText())
tex.repeatV.set(v_val)
else:
v_val = tex.repeatV.get()
if inc:
tex.repeatV.set(v_val + 1)
else:
if (v_val - 1) > 0:
tex.repeatV.set(v_val - 1)
if uText or vText:
self.disp_uv_tile_val(sh, uText, vText)
return None
def rename_selection(self, **kwargs):
new_name = kwargs.get("new_name", "")
sel_items = self.get_selection_from_list()[0]
sel_items = self.get_stripped_text(ip_txt=sel_items)
check_exists = self.check_exists_in_list(
existing_list=self.shapes_list, new_text=new_name)
if check_exists == self.EXISTS:
pm.displayError("Shape name already exists")
return None
new_lst = []
for ln in self.shapes_list:
check = self.get_stripped_text(ip_txt=ln)
if check == sel_items:
new_lst.append(new_name + "\n")
else:
new_lst.append(ln)
new_lst[-1] = self.get_stripped_text(ip_txt=new_lst[-1])
self.rewrite_file(file_name=self.list_path, txt=new_lst)
self.shapes_script = self.read_file(file_name=self.shape_path)
new_txt = []
check_txt = "def " + sel_items + "(self):"
for ln in self.shapes_script:
if ln.find(check_txt) > -1:
ln = ln.replace(sel_items, new_name)
new_txt.append(ln)
new_txt[-1] = (new_txt[-1].replace("\n", "")).replace("\r", "")
self.rewrite_file(file_name=self.shape_path, txt=new_txt)
import Shapes
reload(Shapes)
self.shapes_list = self.read_file(file_name=self.list_path)
self.populate_shape_list()
return None
def place_objects(self, **kwargs):
interval = kwargs.get("skip", 0)
if not self.loop:
pm.displayError("no Loops received")
return None
if interval > len(self.loop):
pm.displayError(
"Skipping value larger than number of edges present")
return self.FAIL
jnt_lst = []
index = 0
max_len = len(self.loop)
while index < max_len:
pos = CustomScripts.midPos(selected_items=self.loop[index])
jnt_lst.append(pm.joint(position=pos))
if len(jnt_lst) > 1:
pm.parent(jnt_lst[-1], jnt_lst[-2])
pm.joint(jnt_lst[-2],
edit=True,
orientJoint='xyz',
secondaryAxisOrient='yup',
zeroScaleOrient=True)
index += interval + 1
pm.select(jnt_lst[-2], jnt_lst[-1])
CustomScripts.CopyJntOri()
return jnt_lst
def run(self):
skip_count = self.skip_val.getText()
if not skip_count:
skip_count = 0
try:
skip_count = int(skip_count)
except ValueError:
pm.displayError("invalid data type")
return None
extract = self.extract_loops()
if extract == self.FAIL:
self.init_var()
return None
joints_placed = self.place_objects(skip=skip_count)
vtx = []
for edg in self.loop:
vertices = self.get_vertices(edges=edg)
if vertices == self.FAIL:
pm.displayError("Extracting Vertices failed at " + str(edg))
self.init_var()
return None
vtx.append(vertices)
if self.skn_chk.getValue():
self.skin(joints=joints_placed, vert_lst=vtx, skip=skip_count)
self.init_var()
return None
def rename_ctrl_from_obj(self, **kwargs):
obj = kwargs.get("cur_obj", None)
ctrl = kwargs.get("ctr", None)
replace_from_str = kwargs.get("replace_from_str", "")
replace_to_str = kwargs.get("replace_to_str", "")
if not (obj) or not (ctrl):
pm.displayError("Object and Control needed as input")
return None
ctr_nm = str(obj).replace(replace_from_str, replace_to_str)
pm.rename(ctrl, ctr_nm)
return None
def rename_ui(self, **kwargs):
self.rename_ip = pm.promptDialog(title="Rename Object",
message="Enter name",
button=["Ok", "Cancel"],
cancelButton="Cancel",
dismissString="Cancel")
if self.rename_ip == "Ok":
txt = pm.promptDialog(query=True, text=True)
txt = self.get_stripped_text(ip_txt=txt)
if txt.find(" ") > -1:
pm.displayError("Names cannot contain spaces")
return None
self.rename_selection(new_name=txt)
def extract_loops(self, **kwargs):
max_count = kwargs.get("max", 0)
if not max_count:
max_count = 2
prev_con_edg = kwargs.get("prev_con_edg", [])
selected_edges = kwargs.get("next_edg", [])
self.safe_count += 1
if self.safe_count > max_count:
pm.displayWarning("Loop not ending")
return self.FAIL
if not selected_edges:
selected_edges = pm.ls(orderedSelection=True, flatten=True)
if self.init_flag:
if len(selected_edges) < 2:
pm.displayError("Minimum 2 edge selection needed")
return self.FAIL
if len(selected_edges) > 3:
pm.displayError("More than 3 edges selected")
return self.FAIL
if len(selected_edges) == 3:
self.stop_edge = selected_edges.pop(2)
self.transform_node, self.shape_node = self.get_transform_from_component(
comp=selected_edges[0])
max_count = len(
pm.ls(str(self.transform_node) + ".e[*]", flatten=True))
next_edge = None
for sel_edg in selected_edges:
loop = self.get_loop_from_edge(edg=sel_edg,
obj=self.transform_node)
self.loop.append(loop)
con_edg = pm.ls(sel_edg.connectedEdges(), flatten=True)
if self.init_flag:
self.init_flag = False
prev_con_edg = con_edg
self.init_loop = loop
continue
next_edge = self.get_next_edge(edg_con=con_edg,
edg_loop=loop,
prev_edg_con=prev_con_edg)
if self.stop_edge in loop:
return None
if next_edge and len(next_edge) == 1:
if next_edge[0] in self.init_loop:
return None
self.extract_loops(prev_con_edg=con_edg,
next_edg=next_edge,
max=max_count)
return self.SUCCESS
def add_ctr(self, **kwargs):
cmd = kwargs.get("cmd", "")
nm = kwargs.get("nm", "")
if not nm:
pm.displayError("Please enter Shape name")
return None
if not cmd:
pm.displayError("Please enter mel command to create shape")
return None
btn_exist = self.read_file(file_name=self.list_path)
nm = self.get_stripped_text(ip_txt=nm)
if nm.find(" ") > -1:
pm.displayError("Names cannot contain spaces")
return None
check_name = self.check_exists_in_list(existing_list=btn_exist,
new_text=nm)
if check_name == self.EXISTS:
pm.displayError("Shape name already exists")
return None
ind = " "
cmd_str = "\n\n" + ind + "def " + nm + "(self):\n "
cmd_str += ind + "shp = mel.eval('" + cmd + "')\n"
cmd_str += ind + " return shp"
shape_file = open(self.shape_path, "a")
shape_file.write(cmd_str)
shape_file.close()
list_file = open(self.list_path, "a")
list_file.write("\n")
list_file.write(nm)
list_file.close()
import Shapes
reload(Shapes)
self.shapes_list = self.read_file(file_name=self.list_path)
self.populate_shape_list()
return None
def set_parent_node(self, parent=None):
if parent is not None:
assert isinstance(parent, SupraNode), "parent is not a SupraNode: %s" % parent
if not self.exists():
pm.displayError("SupraNode::set_parent_node: object does not exist (%s)" % self.name)
return
# users can pass None to disconnect from the parent.
if parent is None:
self.parent.disconnect()
return
if not parent.exists():
pm.displayError("SupraNode::set_parent_node: parent object does not exist (%s)" % parent)
return
self.parent.disconnect()
parent.children.connect(self.parent)
def add_ctr(self, **kwargs):
cmd = kwargs.get("cmd", "")
nm = kwargs.get("nm", "")
if not nm:
pm.displayError("Please enter Shape name")
return None
if not cmd:
pm.displayError("Please enter mel command to create shape")
return None
btn_exist = self.read_shapes()
if nm in btn_exist:
pm.displayError("Shape name already exists")
return None
ind = " "
cmd_str = "\n\n" + ind + "def " + nm + "(self):\n "
cmd_str += ind + "shp = mel.eval('" + cmd + "')\n"
cmd_str += ind + " return shp"
shape_file = open(self.shape_script_path, "a")
shape_file.write(cmd_str)
shape_file.close()
list_file = open(self.shape_list_path, "a")
list_file.write("\n")
list_file.write(nm)
reload(Shapes)
return None
def scale_ctr_to_obj(self, **kwargs):
obj = kwargs.get("cur_obj", None)
ctr = kwargs.get("ctr", None)
size_offset = kwargs.get("size_offset", 0.5)
dup_obj = None
attr_ip_chk = self.check_attr_input(chk_obj=obj)
if attr_ip_chk:
dup_obj = pm.duplicate(obj)[0]
ch_nd = dup_obj.getChildren()
sh_nd = dup_obj.getShape()
for nd in ch_nd:
if not nd == sh_nd:
pm.delete(nd)
obj = dup_obj
obj_bnd_bx = obj.getBoundingBox()
obj_x_y_z_param = self.get_bound_parameters(bound=obj_bnd_bx)
if obj_x_y_z_param == self.FAIL:
pm.displayError("Bound parameters not obtained")
return None
ctr_bnd_bx = ctr.getBoundingBox()
ctr_x_y_z_param = self.get_bound_parameters(bound=ctr_bnd_bx)
if ctr_x_y_z_param == self.FAIL:
pm.displayError("Bound parameters not obtained")
return None
scale_val = [1, 1, 1]
for index in range(len(ctr_x_y_z_param)):
if round(float(ctr_x_y_z_param[index]), 2) > 0:
scale_val[index] = float(obj_x_y_z_param[index] /
ctr_x_y_z_param[index]) + size_offset
else:
scale_val[index] = 1
if dup_obj:
pm.delete(dup_obj)
pm.scale(ctr, scale_val, objectCenterPivot=True, worldSpace=True)
pm.makeIdentity(ctr, apply=True, scale=True)
return None
def create_switching(self):
# Create setDrivenKey on layered texture
sel_switch = self.text_lst.getSelectItem()[0]
enum_attr_list = pm.attributeQuery(sel_switch,
node=self.ctr,
listEnum=True)
enum_attr_list = enum_attr_list[0].split(":")
self.lyr_tex_sel = pm.ls(selection=True)
if not self.lyr_tex_sel:
pm.displayError("Please select layered texture node")
return None
self.lyr_tex_sel = self.lyr_tex_sel[0]
if not isinstance(self.lyr_tex_sel, pm.LayeredTexture):
pm.displayError("Please select layered texture node type")
return None
lyr_attr_lst = self.get_tex_layer_attrs()
if not lyr_attr_lst:
return None
if not len(enum_attr_list) == len(lyr_attr_lst):
pm.displayError("Switch and Layers number mismatch")
return None
driver_attr = self.ctr + "." + sel_switch
for driver_index in range(len(enum_attr_list)):
for driven_index in range(len(lyr_attr_lst)):
driven_attr = self.lyr_tex_sel + "." + lyr_attr_lst[
driven_index]
driven_val = 0
if driver_index == driven_index:
driven_val = 1
pm.setDrivenKeyframe(driven_attr,
currentDriver=driver_attr,
driverValue=driver_index,
value=driven_val)
return None
def run(self, **kwargs):
obj = kwargs.get("cur_obj", None)
ctrl = kwargs.get("cur_ctrl", None)
ctr_mode = kwargs.get("ctr_mode", None).lower()
con_opn = kwargs.get("con_opn", None)
connect_ctrl = kwargs.get("connect_ctrl", None)
from_txt = kwargs.get("from_txt", "")
to_txt = kwargs.get("to_txt", "")
ctrl_nm_opn = kwargs.get("ctrl_nm_opn", None)
ctrl_nm_txt = kwargs.get("ctrl_nm_txt", "")
ctrl_sufx = kwargs.get("ctrl_sfx_txt", "")
zero_node_opn = kwargs.get("zero_node_opn", None)
zero_node_nm = kwargs.get("zero_nd_nm", "")
lock_scl_opn = kwargs.get("lock_scl_opn", None)
scale_check = kwargs.get("scale_check", False)
ctrl_sz_offset = str(kwargs.get("ctrl_sz_offset", "0.5"))
id_num = str(kwargs.get("id_num", ""))
position_flag = kwargs.get("obj_pos_flag", False)
pos_sel_lbl = kwargs.get("pos_sel_lbl", None)
try:
ctrl_sz_offset = float(ctrl_sz_offset)
except ValueError:
pm.displayError("invalid input for size offset value")
return None
z_frm_txt = ""
if ctrl_nm_opn:
z_frm_txt = ctrl_sufx
else:
z_frm_txt = to_txt
self.set_control_position(cur_obj=obj, ctr=ctrl)
if not position_flag:
bound_box = obj.getBoundingBox()
pos = self.get_boundary_position(bnd_bx=bound_box,
pos_sel=pos_sel_lbl)
ctr_pos = pm.xform(ctrl,
query=True,
translation=True,
worldSpace=True)
if pos_sel_lbl.find("X") > -1:
ctr_pos[0] = pos
elif pos_sel_lbl.find("Y") > -1:
ctr_pos[1] = pos
elif pos_sel_lbl.find("Z") > -1:
ctr_pos[2] = pos
#base_location = (bound_box[0])[1]
ctrl.translate.set(ctr_pos)
if scale_check:
self.scale_ctr_to_obj(cur_obj=obj,
ctr=ctrl,
size_offset=ctrl_sz_offset)
else:
self.scale_uniform(ctr=ctrl, size_offset=ctrl_sz_offset)
if not ctrl_nm_opn:
self.rename_ctrl_from_obj(cur_obj=obj,
ctr=ctrl,
replace_from_str=from_txt,
replace_to_str=to_txt)
else:
self.name_control(ctr=ctrl,
ctrl_nm=ctrl_nm_txt,
ctrl_sfx=ctrl_sufx,
id_val=id_num)
if zero_node_opn:
self.create_zero_group(ctr=ctrl,
from_nm=z_frm_txt,
zero_nm=zero_node_nm)
if connect_ctrl:
if ctr_mode == "skin":
self.skin(cur_obj=obj, ctr=ctrl)
else:
if con_opn[0]:
pm.parentConstraint(ctrl, obj, maintainOffset=True)
if con_opn[1]:
pm.scaleConstraint(ctrl, obj, maintainOffset=True)
if lock_scl_opn:
self.lock_scale_vis_rad(ctr=ctrl)
return None
def rescale_uv(self, **kwargs):
# if no reference shell is selected stop execution
if not self.ref_shell:
pm.displayWarning("Reference shell not set")
return None
sel_shell_lst = []
skipped_selection = []
mesh_check = self.ch_bx.getValue()
# if the selection is object get the faces of the object
if mesh_check:
print("SELECT MESH")
sel_obj = pm.ls(selection=True)
for obj in sel_obj:
if isinstance(obj.getShape(), pm.Mesh):
obj_faces = pm.ls(str(obj) + ".f[*]", flatten=True)
sel_shell_lst += obj_faces
else:
skipped_selection.append(obj)
else:
sel_shell_lst = pm.ls(selection=True)
if not sel_shell_lst:
pm.displayWarning("No face selected")
return None
# convert all faces to UV selection
mel.eval('ConvertSelectionToUVs')
all_uv = pm.ls(selection=True, flatten=True)
if not isinstance(sel_shell_lst[0], pm.MeshFace):
pm.displayWarning("Please select shells")
return None
ref_count = len(all_uv)
# call shell split function to get a list of separate shells
run_shellp_split = self.split_shells(all_uv, ref_count, count=0)
# if the self.split_shells runs more than
# the number ofvertices, terminate
if run_shellp_split == "Infinite loop":
pm.displayError("MAX COUNT REACHED, Shell separation FAIL!!!!!!")
return None
# for each shell, find the required area ratio to
# match with the reference area ratio
# scale the shell to tha amount needed
for ref_uv in self.uv_shells_list:
sel_faces = pm.ls(self.uv_shells_list[ref_uv])
mesh_areaCUR, uv_areaCUR, ratioCUR = self.get_area_ratio(
flag="CUR", sel_face=sel_faces)
if not self.ratioREF == ratioCUR:
needed_area = mesh_areaCUR / self.ratioREF
scaleval = math.sqrt(needed_area / uv_areaCUR)
pm.select(ref_uv)
ref = pm.polyEditUVShell(ref_uv,
query=True,
pivotU=True,
pivotV=True)
pm.polyEditUVShell(pivotU=ref[0],
pivotV=ref[1],
scaleU=scaleval,
scaleV=scaleval)
self.uv_shells_list = {}
if skipped_selection:
print "########Objects skipped########"
for obj in skipped_selection:
print obj
pm.displayWarning("objects have been skipped, check script editor")
return None
def setup_motion_path(self):
setup_name = self.get_setup_name()
path_name = self.get_path_name()
sample_obj = self.get_sample_objects()
duplicate_flag = self.get_duplicate_flag()
placement_type = self.get_placement_type()
division_count = self.get_division_count()
if setup_name == self.INVALID_INPUT_FAIL:
pm.displayError("Invalid Input Entered for setup name")
return None
if path_name == self.INVALID_INPUT_FAIL:
pm.displayError("Invalid Input Entered for path name")
return None
if path_name == self.NO_OBJECT_FAIL:
pm.displayError("path Curve does not exist")
return None
if path_name == self.DATA_TYPE_FAIL:
pm.displayError("Path can be only Nurb Curves")
return None
if division_count == self.INVALID_INPUT_FAIL:
pm.displayError("Invalid Input Entered for divisions")
return None
if division_count == self.DATA_TYPE_FAIL:
pm.displayError("Divisions can take only integer values")
return None
if sample_obj == self.NO_OBJECT_FAIL:
pm.displayError("Sample Object not found")
return None
obj_list = []
path_anim_list = []
sel_objs = pm.ls(selection=True)
if duplicate_flag:
path_name = self.get_duplicate_path(path_crv=path_name)
path_name = pm.rename(path_name, setup_name + "_path_CRV")
if placement_type == "uniform":
obj_list, path_anim_list = self.uniform_distribution(
name=setup_name,
path=path_name,
sample=sample_obj,
divisions=division_count)
else:
if not sel_objs:
pm.displayError("No Objects selected")
for obj in sel_objs:
if not pm.objExists(obj):
pm.displayWarning(str(obj), "does not exist")
return None
obj_list, path_anim_list = self.at_selection(
name=setup_name,
path=path_name,
sample=sample_obj,
selection_list=sel_objs)
loc_pos = CustomScripts.midPos(selected_items=path_name)
loc = pm.spaceLocator(name=setup_name + "_up_loc")
pm.xform(loc, translation=loc_pos)
control_crv = pm.circle(name=setup_name + "CTRL",
normalX=1,
normalY=0,
normalZ=0)
pm.xform(control_crv[0], translation=loc_pos, worldSpace=True)
pm.select(clear=True)
# add run and speed attributes on parent nurb curve
pm.addAttr(control_crv[0],
longName="run",
attributeType="float",
keyable=True)
pm.addAttr(control_crv[0],
longName="speed",
attributeType="float",
keyable=True,
minValue=0.0,
defaultValue=0.5)
# edit the existing motion path to assign up locator
for mtPth in path_anim_list:
pm.pathAnimation(mtPth,
edit=True,
worldUpType="object",
worldUpObject=loc)
# parent the setup under the parent nurb curve
pm.parent(path_name, control_crv[0])
pm.parent(loc, control_crv[0])
pm.select(clear=True)
gp = pm.group(name=setup_name + "GP")
pm.xform(gp, translation=loc_pos)
pm.select(clear=True)
obj_gp = pm.group(obj_list, name=setup_name + "object_GP")
pm.parent(control_crv[0], gp)
pm.parent(obj_gp, gp)
# call to create expression function
self.createTreadExpression(mtnPth=path_anim_list,
runAttr=str(control_crv[0]) + ".run",
speedAttr=str(control_crv[0]) + ".speed",
exp_nm=setup_name)
return None