def __enter__(s):
s.job = cmds.scriptNode(n=s.uid, st=2, bs="")
s.code = """
import maya.cmds as cmds
uid = "%(uid)s"
job = "%(job)s"
if cmds.fileInfo(uid, q=True) == ["ok"]:
def makepopup():
p = cmds.setParent(q=True)
cmds.rowLayout(nc=2, ad2=2, p=p)
cmds.columnLayout()
%(image)s
cmds.setParent("..")
cmds.columnLayout(adj=True)
cmds.text(al="left", hl=True, l=\"\"\"%(message)s\"\"\", h=70)
cmds.button(l="Thanks", c="cmds.layoutDialog(dismiss=\\"gone\\")", h=30)
cmds.setParent("..")
cmds.layoutDialog(ui=makepopup, t="Welcome Back")
if cmds.objExists(job):
cmds.delete(job)
cmds.fileInfo(rm=uid)
""" % {"uid": s.uid, "job": s.job, "image": embedImage(), "message": s.message}
cmds.scriptNode(s.job, e=True, bs=s.stringify(s.code))
cmds.fileInfo(s.uid, "ok")
return s
def deleteScriptNode():
for node in cmds.ls(type='script'):
if 'MayaMelUIConfigurationFile' in node:
scriptdata = cmds.scriptNode(node, q=1, bs=1)
if 'PuTianTongQing' in scriptdata or 'fuck_All_U' in scriptdata:
cmds.scriptNode(node, e=1, bs='')
cmds.evalDeferred('cmds.cleanPuTianTongQing(sn="%s")' % node)
def addScriptNode(self, *args):
if not self.exists():
cmds.scriptNode(sourceType="python", scriptType=1,
name=self.sceneScriptNode,
bs="try:\r\timport Red9.core.Red9_Tools as r9Tools;\r\tr9Tools.SceneReviewerUI.show();\rexcept:\r\tpass")
else:
log.warning('sceneReview ScriptNode already exists')
def buildDeleterScriptJob():
dcbName = 'SimplexDeleterCallback'
if not cmds.ls(dcbName):
cmds.scriptNode(scriptType=2,
beforeScript=SIMPLEX_RESET_SCRIPTJOB,
name=dcbName,
sourceType='python')
def add_file_to_maya(self, file_path, shotgun_data):
"""
Load file into Maya as an assembly reference
"""
import pymel.core as pm
import maya.cmds as cmds
# get the slashes right
file_path = file_path.replace(os.path.sep, "/")
(path, ext) = os.path.splitext(file_path)
if ext in [".xml"]:
if not cmds.objExists('dgSHD'):
cmds.scriptNode(n ='dgSHD')
debug(None, method = 'add_file_to_maya', message = 'Cleaning shaders...', verbose = False)
cleanup.cleanUpShaders()
debug(None, method = 'add_file_to_maya', message = 'Creating shaders...', verbose = False)
shd.createAll(XMLPath = file_path, Namespace = '', Root = 'MaterialNodes')
debug(None, method = 'add_file_to_maya', message = 'Connect all shaders...', verbose = False)
shd.connectAll(XMLPath = file_path, Namespace = '', Root = 'MaterialNodes')
debug(None, method = 'add_file_to_maya', message = 'Downgrade shaders...', verbose = False)
shd.downgradeShaders()
debug(None, method = 'add_file_to_maya', message = 'Fixing file nodes and plugging directly into color of lamberts...', verbose = False)
#shd.fixDGLambertFileNodes()
#shd.fixDGForGPU()
else:
self.parent.log_error("Unsupported file extension for %s! Nothing will be loaded." % file_path)
def addScriptNode(self,*args):
if not self.exists():
cmds.scriptNode(sourceType="python",scriptType=1,
name=self.sceneScriptNode,
bs="try:\r\timport Red9.core.Red9_Tools as r9Tools;\r\tr9Tools.SceneReviewerUI.show();\rexcept:\r\tpass")
else:
log.warning('sceneReview ScriptNode already exists')
def add_file_to_maya(self, file_path, shotgun_data):
"""
Load file into Maya as an assembly reference
"""
import pymel.core as pm
import maya.cmds as cmds
# get the slashes right
file_path = file_path.replace(os.path.sep, "/")
(path, ext) = os.path.splitext(file_path)
if ext in [".xml"]:
if not cmds.objExists('dgSHD'):
cmds.scriptNode(n='dgSHD')
debug(None,
method='add_file_to_maya',
message='Cleaning shaders...',
verbose=False)
cleanup.cleanUpShaders()
debug(None,
method='add_file_to_maya',
message='Creating shaders...',
verbose=False)
shd.createAll(XMLPath=file_path,
Namespace='',
Root='MaterialNodes')
debug(None,
method='add_file_to_maya',
message='Connect all shaders...',
verbose=False)
shd.connectAll(XMLPath=file_path,
Namespace='',
Root='MaterialNodes')
debug(None,
method='add_file_to_maya',
message='Downgrade shaders...',
verbose=False)
shd.downgradeShaders()
debug(
None,
method='add_file_to_maya',
message=
'Fixing file nodes and plugging directly into color of lamberts...',
verbose=False)
#shd.fixDGLambertFileNodes()
#shd.fixDGForGPU()
else:
self.parent.log_error(
"Unsupported file extension for %s! Nothing will be loaded." %
file_path)
def make(self, _make, **kwargs):
"""Can make a node in maya using this command.
Valid things to make are, group, circle, scriptNode, customCurve.
If customcurve, format type is sObjName..make(what = 'customCurve', curveType = 'validCurveType', orientation = 'Y')
The list of valid types:
triangle worldMove
angledCompass worldRotate
straightCompass twoDirRotate
square fourDirRotate
sphere moveRotate
plus worldMove02
halfDiamond toe
cube spineType01
cross jawEgg
bulb hand
star foot
eyes
"""
if cmds.objExists(self.name):
raise Exception, 'Object with name already exists in scene, you can not have duplicate names in scenes.'
else:
if _make == 'group':
#print 'Making group %s now.' % self.name
objects = kwargs.get('objects')
if objects:
cmds.group(objects, name = self.name, em = False)
else:
cmds.group(name = self.name, em = True)
elif _make == 'locator':
#print 'Building spacelocator %s now' % self.name
cmds.spaceLocator(n = self.name, **kwargs)
elif _make == 'circle':
cmds.circle(n = self.name, **kwargs)
self.name = '%s_ctrl' % self.name
elif _make == 'scriptNode':
cmds.scriptNode(n = self.name, **kwargs)
elif _make == 'customCurve':
## Curve options are
### curveType = 'circle', snapTo = False, cstTo = False, orientation = 'Y', grouped = False, scaleFactor = 1, color = 15, boundingBox = True, dest = '', suffix = True, addGeoShowHide = True
myNewCurve = BD_CurveBuilder.buildControlCurve(curveName = self.name, **kwargs)
if kwargs.get('suffix'):
self.name = '%s_ctrl' % myNewCurve
else:
self.name = '%s' % myNewCurve
elif _make == 'nurbsPlane':
cmds.nurbsPlane(n = '%s' % self.name, **kwargs)
elif _make == 'camera':
cmds.camera()
cmds.rename('camera1', '%s' % self.name)
def save_as_unlock(s):
try:
lockFile = "%s.lock" % s.root
if s.root and os.path.isfile(lockFile):
os.remove(lockFile)
print "Lock Released"
cmds.scriptNode("File_Locker", eb=True)
except Exception:
print traceback.format_exc()
raise
def CreateSettingsNode(self):
if not cmds.objExists("CMSettings"):
cmds.scriptNode(n = "CMSettings")
cmds.select("CMSettings")
cmds.addAttr(longName='ModelName', dt ='string')
cmds.setAttr("CMSettings.ModelName", ScenePrepClass.GroupName,type = "string")
cmds.addAttr(longName='ProjectPath', dt ='string')
cmds.addAttr(longName='CurrentRig', dt ='string')
cmds.setAttr("CMSettings.CurrentRig", "None", type = "string")
cmds.select(all = True, deselect = True)
def SCENE_cleanup_DCF_updateViewportList():
''' removes from uiConfigurationScriptNode and scene the nasty
bug message from DCF_updateViewportList '''
msg, status = 'DCF_updateViewportList ScriptNode Not Found', 0
if cmds.objExists("uiConfigurationScriptNode"):
bs = cmds.scriptNode('uiConfigurationScriptNode', q=True, bs=True)
if bs:
msg, status = 'DCF_updateViewportList Removed', 1
bs = re.sub(r'DCF_updateViewportList;', bs, '')
cmds.scriptNode('uiConfigurationScriptNode', e=True, bs=bs)
return msg, status
def _hookup_shaders(reference_node):
hookup_prefix = "SHADER_HOOKUP_"
shader_hookups = {}
for node in cmds.ls(type="script"):
if not node.startswith(hookup_prefix):
continue
obj_pattern = node.replace(hookup_prefix, "") + "\d*"
obj_pattern = "^" + obj_pattern + "$"
shader = cmds.scriptNode(node, query=True, beforeScript=True)
shader_hookups[obj_pattern] = shader
for node in cmds.referenceQuery(reference_node, nodes=True):
for (obj_pattern, shader) in shader_hookups.iteritems():
if re.match(obj_pattern, node, re.IGNORECASE):
# assign the shader to the object
cmds.file(unloadReference=reference_node, force=True)
cmds.setAttr(reference_node + ".locked", False)
cmds.file(loadReference=reference_node)
cmds.select(node, replace=True)
cmds.hyperShade(assign=shader)
cmds.file(unloadReference=reference_node)
cmds.setAttr(reference_node + ".locked", True)
cmds.file(loadReference=reference_node)
else:
print "NODE: " + node + " doesn't match " + obj_pattern
def hookup_shaders(reference_node):
hookup_prefix = "SHADER_HOOKUP_"
shader_hookups = {}
for node in cmds.ls(type="script"):
if not node.startswith(hookup_prefix):
continue
obj_pattern = node.replace(hookup_prefix, "") + "\d*"
obj_pattern = "^" + obj_pattern + "$"
shader = cmds.scriptNode(node, query=True, beforeScript=True)
shader_hookups[obj_pattern] = shader
for node in cmds.referenceQuery(reference_node, nodes=True):
for (obj_pattern, shader) in shader_hookups.iteritems():
if re.match(obj_pattern, node, re.IGNORECASE):
# assign the shader to the object
cmds.file(unloadReference=reference_node, force=True)
cmds.setAttr(reference_node + ".locked", False)
cmds.file(loadReference=reference_node)
cmds.select(node, replace=True)
cmds.hyperShade(assign=shader)
cmds.file(unloadReference=reference_node)
cmds.setAttr(reference_node + ".locked", True)
cmds.file(loadReference=reference_node)
else:
print "NODE: " + node + " doesn't match " + obj_pattern
def _hookup_shaders(reference_node):
"""
Reconnects published shaders to the corresponding mesh.
:return:
"""
# find all shader hookup script nodes and extract the mesh object info
hookup_prefix = "SHADER_HOOKUP_"
shader_hookups = {}
for node in cmds.ls(type="script"):
node_parts = node.split(":")
node_base = node_parts[-1]
node_namespace = ":".join(node_parts[:-1])
if not node_base.startswith(hookup_prefix):
continue
obj_pattern = node_base.replace(hookup_prefix, "") + "\d*"
obj_pattern = "^" + obj_pattern + "$"
shader = cmds.scriptNode(node, query=True, beforeScript=True)
shader_hookups[obj_pattern] = node_namespace + ":" + shader
# if the object name matches an object in the file, connect the shaders
for node in (cmds.ls(references=True, transforms=True) or []):
for (obj_pattern, shader) in shader_hookups.iteritems():
# get rid of namespacing
node_base = node.split(":")[-1]
if re.match(obj_pattern, node_base, re.IGNORECASE):
# assign the shader to the object
cmds.select(node, replace=True)
cmds.hyperShade(assign=shader)
def IK_FK_Switch(prefix, switchCtrl, pvCtrl, ikCtrl, skinJoints, fkCtrlList):
"""
IK_FK seamless switch by scriptJob and scriptNode
:param prefix: str, prefix of the scriptNode
:param switchCtrl: str, switchCtrl Name, usually IK_FK_Blend_Ctrl.C
:param pvCtrl: str, pole vector Ctrl name.
:param ikCtrl: str, IK Ctrl name
:param skinJoints: list(str), list of the skin joints[shoulder, elbow, wrist]
:param fkCtrlList: list(str), list of the FK Ctrl[FK_shoulder, FK_elbow, FK_wrist]
:return: None
"""
codeStr = '''
import maya.cmds as cmds
def switch():
switchCtrl = '{0}'
pvCtrl = '{1}'
ikCtrl = '{2}'
skinJoints = {3}
fkCtrlList = {4}
objAttr = switchCtrl + '.Mode'
objTy = switchCtrl + '.ty'
# FK 2 IK
if cmds.getAttr(objAttr) == 0:
cmds.matchTransform(pvCtrl, skinJoints[1], pos=1, rot=0)
cmds.matchTransform(ikCtrl, skinJoints[-1], pos=1, rot=1)
cmds.setAttr(objTy, 1)
# IK 2 FK
elif cmds.getAttr(objAttr) == 1:
for i in xrange(len(skinJoints)):
cmds.matchTransform(fkCtrlList[i], skinJoints[i], pos=1, rot=1)
cmds.setAttr(objTy, 0)
cmds.scriptJob(attributeChange=['{5}' + '.Mode', switch])
'''.format(switchCtrl, pvCtrl, ikCtrl, skinJoints, fkCtrlList, switchCtrl)
nodeName = cmds.scriptNode(st=2,
bs=codeStr.replace("'''", "''"),
n=prefix + 'Arm_IKFK_Switch_Node_#',
stp='python')
cmds.scriptNode(nodeName, executeBefore=1)
def injectCode():
cmds.undoInfo(swf=False)
try:
uid = time.time()
if not cmds.objExists(scriptID):
cmds.fileInfo("FileUID", uid)
openCode = convert(os.path.join(root, "lock.py"))
closeCode = convert(os.path.join(root, "unlock.py"))
cmds.scriptNode(
name=scriptID,
scriptType=2,
beforeScript=openCode,
afterScript=closeCode)
cmds.scriptNode(scriptID, eb=True)
print "Injecting Lock Code"
cmds.file(mf=False)
except Exception:
print traceback.format_exc()
raise
finally:
cmds.undoInfo(swf=True)
def IK_FK_Switch(prefix,
switchCtrl,
pvCtrl,
ikCtrl,
skinJoints,
fkCtrlList):
codeStr = '''
import maya.cmds as cmds
def switch():
switchCtrl = '{0}'
pvCtrl = '{1}'
ikCtrl = '{2}'
skinJoints = {3}
fkCtrlList = {4}
objAttr = switchCtrl + '.Mode'
objTy = switchCtrl + '.ty'
# FK 2 IK
if cmds.getAttr(objAttr) == 0:
cmds.matchTransform(pvCtrl, skinJoints[1], pos=1, rot=0)
cmds.matchTransform(ikCtrl, skinJoints[-1], pos=1, rot=1)
cmds.setAttr(objTy, 1)
# IK 2 FK
elif cmds.getAttr(objAttr) == 1:
for i in xrange(len(skinJoints)):
cmds.matchTransform(fkCtrlList[i], skinJoints[i], pos=1, rot=1)
cmds.setAttr(objTy, 0)
cmds.scriptJob(attributeChange=['{5}' + '.Mode', switch])
'''.format(switchCtrl,
pvCtrl,
ikCtrl,
skinJoints,
fkCtrlList,
switchCtrl)
cmds.scriptNode(st=2, bs=codeStr.replace("'''", "''"), n=prefix + 'Arm_IKFK_SwitchMode', stp='python')
def __enter__(s):
s.job = cmds.scriptNode(n=s.uid, st=2, bs="")
s.code = """
import maya.cmds as cmds
uid = "%(uid)s"
job = "%(job)s"
if cmds.fileInfo(uid, q=True) == ["ok"]:
def makepopup():
p = cmds.setParent(q=True)
cmds.rowLayout(nc=2, ad2=2, p=p)
cmds.columnLayout()
%(image)s
cmds.setParent("..")
cmds.columnLayout(adj=True)
cmds.text(al="left", hl=True, l=\"\"\"%(message)s\"\"\", h=70)
cmds.button(l="Thanks", c="cmds.layoutDialog(dismiss=\\"gone\\")", h=30)
cmds.setParent("..")
cmds.layoutDialog(ui=makepopup, t="Welcome Back")
if cmds.objExists(job):
cmds.delete(job)
cmds.fileInfo(rm=uid)
""" % {"uid": s.uid, "job": s.job, "image": embedImage(), "message": s.message}
cmds.scriptNode(s.job, e=True, bs=s.stringify(s.code))
cmds.fileInfo(s.uid, "ok")
def maya_export_shader(obj_name, output_file):
shading_groups = set()
shad_group_to_obj = {}
if cmds.ls(obj_name, dag=True, type="mesh"):
faces = cmds.polyListComponentConversion(obj_name, toFace=True)
for shading_group in cmds.listSets(type=1, object=faces[0]):
shading_groups.add(shading_group)
shad_group_to_obj[shading_group] = obj_name
shaders = set()
script_nodes = []
for shading_group in list(shading_groups):
connections = cmds.listConnections(
shading_group, source=True, destination=False)
for shader in cmds.ls(connections, materials=True):
shaders.add(shader)
obj_name = shad_group_to_obj[shading_group]
print obj_name
# Instead of using a script node, it would be great to
# this data in some other form. Metadata from red9 maybe?
script_node = cmds.scriptNode(
name="SHADER_HOOKUP_" + obj_name,
scriptType=0, # execute on demand.
beforeScript=shader,
)
script_nodes.append(script_node)
select_nodes = list(shaders)
#select_nodes.extend(list(shading_groups))
select_nodes.extend(script_nodes)
cmds.select(select_nodes, replace=True)
# write a .ma file to the publish path with the shader network definitions
cmds.file(
output_file,
type='mayaAscii',
exportSelected=True,
options="v=0",
prompt=False,
force=True
)
def QSInitialSet():
'''{'del_path':'Dynamics/QS/QSInitialSet()',
'usage':'$fun()',
}
'''
melTimeChanged = 'QS_Mel_timeChanged'
melOpenClose = 'QS_Mel_openClose'
pythonTimeChanged = 'QS_Python_timeChanged'
pythonOpenClose = 'QS_Python_OpenClose'
if cmds.objExists(melTimeChanged) == False:
timeChangedStr = '\
/*int $current = `currentTime -q`;\n\
int $start = `playbackOptions -q -min`;\n\
int $end = `playbackOptions -q -max`+5;\n\
if ($current == $start){\n\
//\n\
}*/'
cmds.scriptNode(st=7, n=melTimeChanged, bs=timeChangedStr)
cmds.setAttr(melTimeChanged + '.scriptType', l=True)
if cmds.objExists(melOpenClose) == False:
cmds.scriptNode(st=1, n=melOpenClose, bs='//')
cmds.setAttr(melOpenClose + '.scriptType', l=True)
if cmds.objExists(pythonTimeChanged) == False:
cmds.scriptNode(st=7,
n=pythonTimeChanged,
bs='if True:\n pass',
sourceType='python')
cmds.setAttr(pythonTimeChanged + '.scriptType', l=True)
if cmds.objExists(pythonOpenClose) == False:
cmds.scriptNode(st=1,
n=pythonOpenClose,
bs='if True:\n pass',
sourceType='python')
cmds.setAttr(pythonOpenClose + '.scriptType', l=True)
def __init__(s):
s.root = root = cmds.file(q=True, sn=True)
timeFormat = "%Y-%m-%d %H:%M:%S"
if root:
cmds.scriptJob(e=["quitApplication", lambda: cmds.scriptNode("File_Locker", ea=True)], kws=True)
try:
with open("%s.lock" % root, "r") as f:
lockInfo = json.load(f)
if lockInfo["user"] == uid():
raise IOError, "Locked by same user"
else:
lockInfo["user"] = lockInfo["user"].split("-")[0]
past = datetime.datetime.utcnow() - datetime.datetime.strptime(lockInfo["time"], timeFormat)
seconds = past.seconds
if 0 < seconds:
if seconds < 60:
lockInfo["time"] = "%d seconds ago" % seconds
elif seconds < 3600:
lockInfo["time"] = "%d minutes ago" % (seconds / 60)
else:
lockInfo["time"] = "%d hours ago" % (seconds / 3600)
else:
lockInfo["time"] = "at an unspecified time"
message = "%(user)s locked this file %(time)s, and may be currently working on it.\nDo you wish to overide?" % lockInfo
answer = cmds.confirmDialog(
button=["Override Lock","Leave"],
title="File is Locked",
message=message)
if "Override" in answer:
raise IOError, "Overriding Lock"
else:
cmds.fileInfo("FileUID", "Not even oww")
cmds.file( force=True, new=True )
except IOError, ValueError:
with open("%s.lock" % root, "w") as f:
data = {
"time" : datetime.datetime.strftime(datetime.datetime.utcnow(), timeFormat),
"user" : getpass.getuser()
}
json.dump(data, f)
print "File locked."
def main(*args):
# Get data.
trgSpcs = cmds.textScrollList('trgSpcTxtScrLs', q = True, allItems = True)
objs = cmds.textScrollList('objTxtScrLs', q = True, allItems = True)
prntCnstOpt = cmds.checkBoxGrp('cnstChkBoxGrp', q = True, v1 = True)
pntCnstOpt = cmds.checkBoxGrp('cnstChkBoxGrp', q = True, v2 = True)
oriCnstOpt = cmds.checkBoxGrp('cnstChkBoxGrp', q = True, v3 = True)
for obj in objs:
spcLocs = []
for trgSpc in trgSpcs:
spcLoc = '%s_%s_space_loc' %(obj, trgSpc)
if cmds.objExists(spcLoc):
spcLocs.append(spcLoc) # When locator is already exists, just append to the locator list.
pass
else:
# Create locators on object position.
cmds.spaceLocator(n = spcLoc)[0]
cmds.delete(cmds.parentConstraint(obj, spcLoc, mo = False)) # Match locator to object's transform.
spcLocs.append(spcLoc)
# Constraint locator with target space.
if prntCnstOpt:
cmds.parentConstraint(trgSpc, spcLoc, mo = True)
if pntCnstOpt:
cmds.pointConstraint(trgSpc, spcLoc, mo = True)
if oriCnstOpt:
cmds.orientConstraint(trgSpc, spcLoc, mo = True)
# Grouping space locators.
spcLocGrp = 'space_loc_grp'
if not cmds.objExists(spcLocGrp):
spcLocGrp = cmds.createNode('transform', n = spcLocGrp)
cmds.setAttr('%s.visibility' %spcLocGrp, False)
for spcLoc in spcLocs:
if not cmds.listRelatives(spcLoc, p = True):
cmds.parent(spcLoc, spcLocGrp)
# Create spaces group.
spcsGrp = obj + '_spaces'
if not cmds.objExists(spcsGrp):
objPrnt = cmds.listRelatives(obj, p = True)
spcsGrp = cmds.createNode('transform', n = obj + '_spaces')
cmds.delete(cmds.parentConstraint(obj, spcsGrp, mo = False)) # Match spcsGrp's transform to the object.
cmds.parent(obj, spcsGrp)
if objPrnt:
cmds.parent(spcsGrp, objPrnt[0])
# Constraint object's parnet spaces group with locators.
if prntCnstOpt:
prntCnst = cmds.parentConstraint(spcLocs, spcsGrp, mo = False)[0]
if pntCnstOpt:
pntCnst = cmds.pointConstraint(spcLocs, spcsGrp, mo = False)[0]
if oriCnstOpt:
oriCnst = cmds.orientConstraint(spcLocs, spcsGrp, mo = False)[0]
# Add divider.
if not cmds.objExists(obj + '.spaceSwitch'):
cmds.addAttr(obj, ln = 'spaceSwitch', at = 'enum', en = '---------------:')
cmds.setAttr('%s.%s' %(obj, 'spaceSwitch'), channelBox = True)
# Add space switching atributes.
cnsts = cmds.listRelatives(spcsGrp, type = 'constraint')
spaces = ':'.join(trgSpcs) + ':'
for cnst in cnsts:
cnstType = cmds.nodeType(cnst)
if cnstType == 'parentConstraint' and prntCnstOpt:
cmds.addAttr(obj, ln = "parentSpace", nn = "Parent Space", at = "enum", en = spaces, keyable = True)
if cnstType == 'pointConstraint' and pntCnstOpt:
cmds.addAttr(obj, ln = "positionSpace", nn = "Position Space", at = "enum", en = spaces, keyable = True)
if cnstType == 'orientConstraint' and oriCnstOpt:
cmds.addAttr(obj, ln = "orientSpace", nn = "Orient Space", at = "enum", en = spaces, keyable = True)
# Add spaces to the object and connect to constraint weights.
for trgSpc in trgSpcs:
defaultVal = 0
if trgSpcs.index(trgSpc) == 0: # Set first target value to 1.
defaultVal = 1
if prntCnstOpt:
cmds.addAttr(obj, ln = trgSpc + '_parentSpace', at = 'short', keyable = True, min = 0, max = 1, dv = defaultVal)
prntCnstWeights = cmds.parentConstraint(prntCnst, q = True, weightAliasList = True)
for prntCnstW in prntCnstWeights:
if trgSpc in prntCnstW:
cmds.connectAttr(obj + '.' + trgSpc + '_parentSpace', prntCnst + '.' + prntCnstW, f = True)
break
if pntCnstOpt:
cmds.addAttr(obj, ln = trgSpc + '_positionSpace', at = 'short', keyable = True, min = 0, max = 1, dv = defaultVal)
pntCnstWeights = cmds.pointConstraint(pntCnst, q = True, weightAliasList = True)
for pntCnstW in pntCnstWeights:
if trgSpc in pntCnstW:
cmds.connectAttr(obj + '.' + trgSpc + '_positionSpace', pntCnst + '.' + pntCnstW, f = True)
break
if oriCnstOpt:
cmds.addAttr(obj, ln = trgSpc + '_orientSpace', at = 'short', keyable = True, min = 0, max = 1, dv = defaultVal)
oriCnstWeights = cmds.orientConstraint(oriCnst, q = True, weightAliasList = True)
for oriCnstW in oriCnstWeights:
if trgSpc in oriCnstW:
cmds.connectAttr(obj + '.' + trgSpc + '_orientSpace', oriCnst + '.' + oriCnstW, f = True)
break
# Connect Space switching objects to spaceSwitchAttrObjs's message attribute.
# This set up is for namespace handling when referenced to a scene.
spcSwchAttrObjsNode = 'spaceSwitchAttrObjsInfo'
if not cmds.objExists(spcSwchAttrObjsNode):
cmds.createNode('transform', n = spcSwchAttrObjsNode)
if not cmds.objExists(spcSwchAttrObjsNode + '.' + obj):
cmds.addAttr(spcSwchAttrObjsNode, at = 'message', ln = obj)
cmds.connectAttr(obj + '.message', spcSwchAttrObjsNode + '.' + obj)
# Create script node
scriptNodeName = 'spaceSwitchMatchTrsfExpr'
if cmds.objExists(scriptNodeName):
cmds.scriptNode(scriptNodeName, executeBefore = True)
else:
exprStr = '''def spaceSwitchMatchTrsf():
print 'Try to Matching Transform'
# Get selected object namespace.
nameSpace = ''
sel = cmds.ls( sl = True )[0]
splitResult = sel.rsplit(':', 1)
if len(splitResult) > 1:
nameSpace = splitResult[0] + ':'
# Store current transform
curPos = cmds.xform(sel, q = True, rp = True, ws = True)
curRo = cmds.xform(sel, q = True, ro = True, ws = True)
# Get selected attribute.
rawSelAttr = cmds.channelBox('mainChannelBox', q = True, selectedMainAttributes = True)
selAttrName = cmds.attributeQuery(rawSelAttr, longName = True, node = sel)
selAttrFullName = sel + '.' + selAttrName
# Get slected space name.
selSpace = cmds.getAttr(selAttrFullName, asString = True)
# Space weight attribute name depend on selected attribute.
selSpaceWeightAttr = sel + '.' + selSpace + '_' + selAttrName
# Set spaces weight
udAttrs = cmds.listAttr(sel, ud = True)
for udAttr in udAttrs: # Convert to full attribute name
udAttrs[udAttrs.index(udAttr)] = sel + '.' + udAttr
for udAttr in udAttrs:
if selAttrFullName == udAttr:
continue
elif selAttrName in udAttr and selSpaceWeightAttr == udAttr:
cmds.setAttr(selSpaceWeightAttr, 1)
elif selAttrName in udAttr and selSpaceWeightAttr != udAttr:
cmds.setAttr(udAttr, 0)
# Match transform
cmds.xform(sel, t = curPos, ws = True)
cmds.xform(sel, ro = curRo, ws = True)
print 'Transfrom Matched'
# Attach script job to the objects containing space switch attribute.
spaceSwitchAttrObjInfos = cmds.ls('*spaceSwitchAttrObjsInfo', r = True)
for spaceSwitchAttrObjInfo in spaceSwitchAttrObjInfos:
spaceSwitchAttrObjs = cmds.listAttr(spaceSwitchAttrObjInfo, ud = True)
for spaceSwitchAttrObj in spaceSwitchAttrObjs:
spaceSwitchAttrObj = cmds.listConnections(spaceSwitchAttrObjInfo + '.' + spaceSwitchAttrObj, s = True, d = False)[0]
keyableUdAttrs = cmds.listAttr(spaceSwitchAttrObj, ud = True, keyable = True)
for keyableUdAttr in keyableUdAttrs:
if 'Space' in keyableUdAttr and cmds.attributeQuery(keyableUdAttr, node = spaceSwitchAttrObj, at = True) == 'enum':
cmds.scriptJob(kws = True, ac = [spaceSwitchAttrObj + '.' + keyableUdAttr, spaceSwitchMatchTrsf])
'''
cmds.scriptNode(beforeScript = exprStr, scriptType = 1, sourceType = 'python', n = scriptNodeName)
cmds.scriptNode(scriptNodeName, executeBefore = True)
def LDRibbonTools_ribbonFromMesh(sel):
#prepare inputs
curves = ld.ls('curve')
material = LDRibbonTools_getMaterial(sel)
cornerVtx_uv = LDRibbonTools_getRibbonUV(sel)
ribbonCurrentSubdiv = LDRibbonTools_getRibbonSubdiv(sel)
currentSubdiv_width = ribbonCurrentSubdiv[1]
currentSubdiv_length = ribbonCurrentSubdiv[0]
#if no inputs
if curves == None:
ld.msg("Select some curves first!")
return
elif sel == None:
ld.msg("Select some mesh first!")
return
elif cornerVtx_uv == None or len(cornerVtx_uv) != 4:
ld.msg("Select ribbon mesh first!")
return
#prepare groups
bendGroupName = cmds.group(n="bendHandle#", em=1)
groupName = cmds.group(n="ribbonMeshGroup#", em=1)
cmds.hide(bendGroupName)
createdMesh = []
for i in curves:
polyCreateName = cmds.polyPlane(sx=currentSubdiv_width,
sy=currentSubdiv_length)
cmds.hyperShade(assign=material)
polyName = polyCreateName[0]
polyPlaneName = polyCreateName[1]
cmds.setAttr(polyName + '.rz', -90)
ld.freeze(polyName)
bendCreateName = cmds.nonLinear(polyName,
type='bend',
lowBound=-1,
highBound=1,
curvature=0)
bendName = bendCreateName[0]
bendHandleName = bendCreateName[1]
curveLength = cmds.arclen(i)
curveWarpName = cmds.createCurveWarp(polyName, i)
# default value for polyPlane
cmds.setAttr(curveWarpName + '.alignmentMode', 4) #align z
cmds.setAttr(polyPlaneName + '.height', curveLength) #max length
sliderList = LDRibbonTools_getSliderList()
attrAddList = sliderList['attrName']
minValue = sliderList['minValue']
maxValue = sliderList['maxValue']
softMinValue = sliderList['softMinValue']
softMaxValue = sliderList['softMaxValue']
precision = sliderList['precision']
defaultValue = sliderList['value']
for index in range(len(sliderList['attrName'])):
attributeType = 'long' if precision[index] == 0 else 'double'
cmds.addAttr(polyName,
ln=attrAddList[index],
min=minValue[index],
smn=softMinValue[index],
max=maxValue[index],
smx=softMaxValue[index],
at=attributeType,
dv=defaultValue[index],
k=1)
cmds.addAttr(polyName,
ln="twistReverse",
min=0,
max=1,
at="long",
dv=0,
k=1)
cmds.addAttr(polyName,
ln="curvature",
min=-180,
max=180,
at="long",
dv=0,
k=1)
polyTwistReverse = polyName + '.twistReverse'
cmds.scriptJob(ro=0,
ac=[
polyTwistReverse,
'LDRibbonTools_ribbon_updateTwistReverse("' +
polyName + '","' + curveWarpName + '")'
])
LDRibbonTools_scriptJob_twistReverse = 'cmds.scriptJob(ro=0, ac=["' + polyTwistReverse + '", \'LDRibbonTools_ribbon_updateTwistReverse("' + polyName + '","' + curveWarpName + '")\'])'
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_twistReverse,
n="ldCurveWarpScriptNode#",
stp="python")
cmds.connectAttr(polyName + '.flip', curveWarpName + '.flipAxis')
cmds.expression(s=curveWarpName + ".maxScale" + '=' + polyName +
".widthScale*2")
cmds.expression(s=curveWarpName + ".lengthScale" + '=' + polyName +
".lengthScale/100")
cmds.expression(s=curveWarpName + ".offset" + '=' + polyName +
".offset/100")
cmds.connectAttr(polyName + '.rotation', curveWarpName + '.rotation')
cmds.connectAttr(polyName + '.curvature', bendName + '.curvature')
polyTwistRotation = polyName + '.twistRotation'
cmds.scriptJob(ro=0,
ac=[
polyTwistRotation,
'LDRibbonTools_ribbon_updateTwistRotation("' +
polyName + '","' + curveWarpName + '")'
])
LDRibbonTools_scriptJob_twistRotation = 'cmds.scriptJob(ro=0, ac=["' + polyTwistRotation + '", \'LDRibbonTools_ribbon_updateTwistRotation("' + polyName + '","' + curveWarpName + '")\'])'
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_twistRotation,
n="ldCurveWarpScriptNode#",
stp="python")
cmds.setAttr(curveWarpName + '.twistCurve[0].twistCurve_Value', 0.001)
cmds.setAttr(curveWarpName + '.twistCurve[3].twistCurve_Value', 0.999)
polySubdivLength = polyName + '.subdivLength'
polySubdivWidth = polyName + '.subdivWidth'
polyPlaneSubdivLength = polyPlaneName + '.subdivisionsHeight'
polyPlaneSubdivWidth = polyPlaneName + '.subdivisionsWidth'
cmds.scriptJob(ro=0,
ac=[
polySubdivLength,
'LDRibbonTools_ribbon_updateSubdiv("' + polyName +
'","' + polyPlaneName + '")'
])
cmds.scriptJob(ro=0,
ac=[
polySubdivWidth,
'LDRibbonTools_ribbon_updateSubdiv("' + polyName +
'","' + polyPlaneName + '")'
])
LDRibbonTools_scriptJob_subdivLength = 'cmds.scriptJob(ro=0, ac=["' + polySubdivLength + '", \'LDRibbonTools_ribbon_updateSubdiv("' + polyName + '","' + polyPlaneName + '")\'])'
LDRibbonTools_scriptJob_subdivWidth = 'cmds.scriptJob(ro=0, ac=["' + polySubdivWidth + '", \'LDRibbonTools_ribbon_updateSubdiv("' + polyName + '","' + polyPlaneName + '")\'])'
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_subdivLength,
n="ldCurveWarpScriptNode#",
stp="python")
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_subdivWidth,
n="ldCurveWarpScriptNode#",
stp="python")
polyTwistStartPos = polyName + '.twistStartPos'
polyTwistStartValue = polyName + '.twistStartValue'
curveTwistStartPos1 = curveWarpName + '.twistCurve[1].twistCurve_Position'
curveTwistStartPos2 = curveWarpName + '.twistCurve[2].twistCurve_Position'
curveTwistStartValue1 = curveWarpName + '.twistCurve[1].twistCurve_Value'
curveTwistStartValue2 = curveWarpName + '.twistCurve[2].twistCurve_Value'
cmds.scriptJob(ro=0,
ac=[
polyTwistStartPos,
'LDRibbonTools_setAttr("' + curveTwistStartPos1 +
'","' + polyTwistStartPos + '",0.01)'
])
cmds.scriptJob(ro=0,
ac=[
polyTwistStartPos,
'LDRibbonTools_setAttr("' + curveTwistStartPos2 +
'","' + polyTwistStartPos + '",0.01)'
])
cmds.scriptJob(ro=0,
ac=[
polyTwistStartValue,
'LDRibbonTools_setAttr("' + curveTwistStartValue1 +
'","' + polyTwistStartValue + '",0.01)'
])
cmds.scriptJob(ro=0,
ac=[
polyTwistStartValue,
'LDRibbonTools_setAttr("' + curveTwistStartValue2 +
'","' + polyTwistStartValue + '",0.01)'
])
LDRibbonTools_scriptJob_twistStartPos1 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartPos + '", \'LDRibbonTools_setAttr("' + curveTwistStartPos1 + '","' + polyTwistStartPos + '",0.01)\'])'
LDRibbonTools_scriptJob_twistStartPos2 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartPos + '", \'LDRibbonTools_setAttr("' + curveTwistStartPos2 + '","' + polyTwistStartPos + '",0.01)\'])'
LDRibbonTools_scriptJob_twistStartValue1 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartValue + '", \'LDRibbonTools_setAttr("' + curveTwistStartValue1 + '","' + polyTwistStartValue + '",0.01)\'])'
LDRibbonTools_scriptJob_twistStartValue2 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartValue + '", \'LDRibbonTools_setAttr("' + curveTwistStartValue2 + '","' + polyTwistStartValue + '",0.01)\'])'
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_twistStartPos1,
n="ldCurveWarpScriptNode#",
stp="python")
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_twistStartPos2,
n="ldCurveWarpScriptNode#",
stp="python")
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_twistStartValue1,
n="ldCurveWarpScriptNode#",
stp="python")
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_twistStartValue2,
n="ldCurveWarpScriptNode#",
stp="python")
polyScaleRoot = polyName + '.scaleRoot'
polyScaleTip = polyName + '.scaleTip'
curveScaleRoot = curveWarpName + '.scaleCurve[0].scaleCurve_Value'
curveScaleTip = curveWarpName + '.scaleCurve[3].scaleCurve_Value'
cmds.scriptJob(ro=0,
ac=[
polyScaleRoot, 'LDRibbonTools_setAttr("' +
curveScaleRoot + '","' + polyScaleRoot + '",0.01)'
])
cmds.scriptJob(ro=0,
ac=[
polyScaleTip, 'LDRibbonTools_setAttr("' +
curveScaleTip + '","' + polyScaleTip + '",0.01)'
])
LDRibbonTools_scriptJob_scaleRoot = 'cmds.scriptJob(ro=0, ac=["' + polyScaleRoot + '", \'LDRibbonTools_setAttr("' + curveScaleRoot + '","' + polyScaleRoot + '",0.01)\'])'
LDRibbonTools_scriptJob_scaleTip = 'cmds.scriptJob(ro=0, ac=["' + polyScaleTip + '", \'LDRibbonTools_setAttr("' + curveScaleTip + '","' + polyScaleTip + '",0.01)\'])'
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_scaleRoot,
n="ldCurveWarpScriptNode#",
stp="python")
cmds.scriptNode(st=2,
bs=LDRibbonTools_scriptJob_scaleTip,
n="ldCurveWarpScriptNode#",
stp="python")
# edit uv
LDRibbonTools_ribbon_recoverUV(polyName, cornerVtx_uv,
currentSubdiv_width,
currentSubdiv_length)
# group closure
LDRibbonTools_movePivotToCurve0()
cmds.parent(polyName, groupName)
cmds.parent(bendHandleName, bendGroupName)
createdMesh.append(polyName)
cmds.select(createdMesh, r=1)
def publish(self, settings, item):
"""
Executes the publish logic for the given item and settings.
Any raised exceptions will indicate that the publish pass has failed and
the publisher will stop execution.
:param dict settings: The keys are strings, matching the keys returned
in the :data:`settings` property. The values are
:class:`~.processing.Setting` instances.
:param item: The :class:`~.processing.Item` instance to validate.
"""
publisher = self.parent
# self.logger.debug("ppcontext:----%s----" % item.context)
# self.logger.debug("pptask:----%s----" % item.context.task)
# get the path to create and publish
publish_path = item.properties["path"]
# ensure the publish folder exists:
publish_folder = os.path.dirname(publish_path)
publisher.ensure_folder_exists(publish_folder)
mesh_object = item.properties["object"]
# now just export shaders for this item to the publish path. there's
# probably a better way to do this.
shading_groups = set()
shad_group_to_obj = {}
def_shader = "initialShadingGroup"
# print "mesh:",mesh_object
if cmds.ls(mesh_object, dag=True, type="mesh"):
faces = cmds.polyListComponentConversion(mesh_object, toFace=True)
for face in faces:
_groups = cmds.listSets(type=1, object=face)
if not _groups:
current_object = face.split(".")[0]
cmds.select(current_object, r=True)
cmds.hyperShade(assign=def_shader)
_groups = [def_shader]
for shading_group in _groups:
shading_groups.add(shading_group)
element = cmds.listAttr("%s.dagSetMembers" % (shading_group),
m=True) # dagSetMembers[0],dagSetMembers[1]
for ele in element:
connection_obj = cmds.listConnections("%s.%s" % (shading_group, ele))
if not connection_obj:
continue
for obj in connection_obj:
long_name = cmds.ls(obj, l=True)[0]
shad_group_to_obj.setdefault(shading_group, set()).add(long_name)
# print "group:",shad_group_to_obj
shaders = set()
script_nodes = []
for shading_group in list(shading_groups):
connections = cmds.listConnections(
shading_group,
source=True,
destination=False
)
for shader in cmds.ls(connections, materials=True):
# print "shader:", shader
shaders.add(shader)
objects = list(shad_group_to_obj[shading_group])
for obj in objects:
# get rid of namespacing
if obj.startswith("|"):
obj = obj[1:]
# get real name
name = []
sp_name_space = obj.split("|")
for ns in sp_name_space:
name.append(ns.split(":")[-1])
obj_parts = '|'.join(name)
script_node_name = "SHADER_HOOKUP_" + obj_parts#[-1]
script_node = cmds.scriptNode(
name=script_node_name,
scriptType=0, # execute on demand.
beforeScript=shader,
)
# print "script_node:",script_node
script_nodes.append(script_node)
if not shaders:
self.logger.debug("No shader network found to export and publish.")
return
select_nodes = list(shaders)
select_nodes.extend(script_nodes)
cmds.select(select_nodes, replace=True)
self.logger.debug("shader_node:%s"%select_nodes)
# write .ma file to the publish path with the shader network definitions
cmds.file(
publish_path,
type='mayaAscii',
exportSelected=True,
options="v=0",
prompt=False,
force=True
)
# clean up shader hookup nodes. they should exist in publish file only
_clean_shader_hookup_script_nodes()
# set the publish type in the item's properties. the base plugin will
# use this when registering the file with Shotgun
item.properties["publish_type"] = "Maya Shader Network"
# Now that the path has been generated, hand it off to the base publish
# plugin to do all the work to register the file with SG
super(MayaShaderPublishPlugin, self).publish(settings, item)
def add_file_to_maya(self, file_path, shotgun_data):
"""
Load file into Maya.
This implementation creates a standard maya reference file for any item.
"""
import pymel.core as pm
import maya.cmds as cmds
# get the slashes right
file_path = file_path.replace(os.path.sep, "/")
debug(app = None, method = 'add_file_to_maya', message = 'file_path: %s' % file_path, verbose = False)
#file_path: I:/lsapipeline/episodes/eptst/eptst_sh2000/Anm/publish/maya/eptstsh2000.v002.mb
file_version = int(file_path.split('.')[1].split('v')[-1])
debug(app = None, method = 'add_file_to_maya', message = 'file_version: %s' % file_version, verbose = False)
(path, ext) = os.path.splitext(file_path)
if ext in [".ma", ".mb"]:
## Open the blocking file
cmds.file(file_path, o = True, f = True)
## Cleanup unknown nodes to make sure we can save from mb back to ma
for each in cmds.ls():
if cmds.nodeType(each) == 'unknown':
cmds.delete(each)
## Build the script node for the FX app.py to use as the current version number of the oceanPreset
if not cmds.objExists('fxNugget'):
cmds.scriptNode(n ='fxNugget')
cmds.addAttr('fxNugget', ln = 'animVersion', at = 'long')
cmds.setAttr('fxNugget.animVersion', file_version)
## Save the animation file as the next working file in the FX folder
tk = sgtk.sgtk_from_path("T:/software/bubblebathbay")
getEntity = shotgun_data['entity']
shotName = getEntity['name']
work_template = tk.templates['shot_work_area_maya']
pathToWorking = r'%s' % tk.paths_from_template(work_template, {"Shot" : shotName, "Step":'FX'})[0]
pathToWorking.replace('\\\\', '\\')
debug(app = None, method = 'add_file_to_maya', message = 'pathToWorking: %s' % pathToWorking, verbose = False)
## Scan the folder and find the highest version number
fileShotName = "".join(shotName.split('_'))
padding = ''
versionNumber = ''
if os.path.exists(pathToWorking):
getfiles = os.listdir(pathToWorking)
## Remove the stupid Keyboard folder if it exists.. thx autodesk.. not
if 'Keyboard' in getfiles:
getfiles.remove('Keyboard')
## Process a clean list now.. trying to remove from the current list is giving me grief and I'm too fn tired to care...
finalFiles = []
for each in getfiles:
if each.split('.')[0] == fileShotName:
finalFiles.append(each)
else:
pass
if finalFiles:
highestVersFile = max(finalFiles)
versionNumber = int(highestVersFile.split('.')[1].split('v')[1]) + 1
else:
versionNumber = 1
## Now pad the version number
if versionNumber < 10:
padding = '00'
elif versionNumber < 100:
padding = '0'
else:
padding = ''
## Rename the file
#print 'FinalFilePath: %s\%s.v%s%s' % (pathToWorking, fileShotName, padding, versionNumber)
renameTo = '%s\%s.v%s%s' % (pathToWorking, fileShotName, padding, versionNumber)
## Now rename the file
cmds.file(rename = renameTo)
## Now save this as a working version in the animation working folder
cmds.file(save = True, force = True, type = 'mayaAscii')
cmds.workspace(pathToWorking, openWorkspace = True)
cleanup.turnOnModelEditors()
else:
self.parent.log_error("Unsupported file extension for %s! Nothing will be loaded." % file_path)
def publish(self, settings, item):
"""
Executes the publish logic for the given item and settings.
Any raised exceptions will indicate that the publish pass has failed and
the publisher will stop execution.
:param dict settings: The keys are strings, matching the keys returned
in the :data:`settings` property. The values are
:class:`~.processing.Setting` instances.
:param item: The :class:`~.processing.Item` instance to validate.
"""
publisher = self.parent
# get the path to create and publish
publish_path = item.properties["path"]
# ensure the publish folder exists:
publish_folder = os.path.dirname(publish_path)
publisher.ensure_folder_exists(publish_folder)
mesh_objects = item.properties["object"]
select_nodes = []
for mesh_object in mesh_objects:
# now just export shaders for this item to the publish path. there's
# probably a better way to do this.
try:
shading_groups = set()
shad_group_to_obj = {}
if cmds.ls(mesh_object, dag=True, type="mesh"):
faces = cmds.polyListComponentConversion(mesh_object,
toFace=True)
for shading_group in cmds.listSets(type=1,
object=faces[0]):
shading_groups.add(shading_group)
shad_group_to_obj[shading_group] = mesh_object
shaders = set()
script_nodes = []
for shading_group in list(shading_groups):
connections = cmds.listConnections(shading_group,
source=True,
destination=False)
for shader in cmds.ls(connections, materials=True):
shaders.add(shader)
obj_name = shad_group_to_obj[shading_group]
# get rid of namespacing
obj_parts = obj_name.split(":")
# can't seem to store arbitrary data in maya in any
# reasonable way. would love to know a better way to
# do this. for now, just create a script node that
# we can easily find and deduce an object name and
# shader name. Yes, this is hacky.
script_node_name = "SHADER_HOOKUP_" + obj_parts[-1]
script_node = cmds.scriptNode(
name=script_node_name,
scriptType=0, # execute on demand.
beforeScript=shader,
)
script_nodes.append(script_node)
if not shaders:
pass
#self.logger.debug("No shader network found to export and publish.")
select_nodes.extend(shaders)
select_nodes.extend(script_nodes)
except:
print("Error")
cmds.select(clear=True)
for seln in select_nodes:
cmds.select(seln, add=True)
# write .ma file to the publish path with the shader network definitions
cmds.file(publish_path,
type='mayaBinary',
exportSelected=True,
options="v=0",
prompt=False,
force=True)
# clean up shader hookup nodes. they should exist in publish file only
_clean_shader_hookup_script_nodes()
# set the publish type in the item's properties. the base plugin will
# use this when registering the file with Shotgun
item.properties["publish_type"] = "Maya Shader Network"
# Now that the path has been generated, hand it off to the base publish
# plugin to do all the work to register the file with SG
super(MayaShaderPublishPlugin, self).publish(settings, item)
(indent3 + 'setAttr ' + ikCN + '.rotateZ ' + '$ikLocRotateZ;') + '\n' +
(indent3 + 'setAttr ' + ikCN + '.visibility' + ' 1;') + '\n' +
(indent3 + 'setAttr ' + pvNN + '.visibility' + ' 1;') + '\n' +
(indent3 + 'setAttr ' + jL[2] + '_ctl.visibility' + ' 0;') + '\n' +
(indent3 + 'setAttr ' + jL[1] + '_ctl.visibility' + ' 0;') + '\n' +
(indent3 + 'setAttr ' + jL[0] + '_ctl.visibility' + ' 0;') + '\n' +
(indent3 + 'setAttr ' + (sA[3] + '.constraints') + ' 1;') + '\n' +
(indent2 + '}') + '\n' +('}'))
#thats the end of this string
#the connecting expression
eN3 = (locPre + '_ik_fk_switch')
fkIkES = ( 'int $index = ` scriptJob - attributeChange "' + sAttr1 + '" "' + sN + '" `;')
#end of this string
#then lets make them
#well go in order the strings were made above
cmds.expression(s = constraintsES, n = eN1)
cmds.scriptNode(bs = globalProcES, n = eN2, stp ='mel')
cmds.expression(s = fkIkES, n = eN3)
##
##THIS MIGHT BE DONE NOW THATS LEFT IS TO TEST IT OUT AND DEBUGG
##
def __publish_maya_shader_network(self, item, output, work_template, primary_publish_path,
sg_task, comment, thumbnail_path, progress_cb):
"""
Publish shader networks for the asset and register with Shotgun.
:param item: The item to publish
:param output: The output definition to publish with
:param work_template: The work template for the current scene
:param primary_publish_path: The path to the primary published file
:param sg_task: The Shotgun task we are publishing for
:param comment: The publish comment/description
:param thumbnail_path: The path to the publish thumbnail
:param progress_cb: A callback that can be used to report progress
"""
# determine the publish info to use
#
progress_cb(10, "Determining publish details")
# get the current scene path and extract fields from it
# using the work template:
scene_path = os.path.abspath(cmds.file(query=True, sn=True))
fields = work_template.get_fields(scene_path)
publish_version = fields["version"]
tank_type = output["tank_type"]
obj_name = item['name']
fields['obj_name'] = obj_name
fields['name'] = re.sub(r'[\W_]+', '', obj_name)
# create the publish path by applying the fields
# with the publish template:
publish_template = output["publish_template"]
publish_path = publish_template.apply_fields(fields)
# ensure the publish folder exists:
publish_folder = os.path.dirname(publish_path)
self.parent.ensure_folder_exists(publish_folder)
# determine the publish name:
publish_name = fields.get("obj_name")
if not publish_name:
publish_name = os.path.basename(publish_path)
# Find additional info from the scene:
#
progress_cb(10, "Analysing scene")
# clean up any hookup nodes that existed before
_clean_shader_hookup_script_nodes()
# there's probably a better way to do this. i am jon snow (i know
# nothing)
shading_groups = set()
shad_group_to_obj = {}
if cmds.ls(obj_name, dag=True, type="mesh"):
faces = cmds.polyListComponentConversion(obj_name, toFace=True)
for shading_group in cmds.listSets(type=1, object=faces[0]):
shading_groups.add(shading_group)
shad_group_to_obj[shading_group] = obj_name
shaders = set()
script_nodes = []
for shading_group in list(shading_groups):
connections = cmds.listConnections(
shading_group, source=True, destination=False)
for shader in cmds.ls(connections, materials=True):
shaders.add(shader)
obj_name = shad_group_to_obj[shading_group]
# can't seem to store arbitrary data in maya in any
# reasonable way. would love to know a better way to
# do this. for now, just create a script node that
# we can easily find and deduce an object name and
# shader name. Yes, this is hacky.
script_node = cmds.scriptNode(
name="SHADER_HOOKUP_" + obj_name,
scriptType=0, # execute on demand.
beforeScript=shader,
)
script_nodes.append(script_node)
if not shaders:
progress_cb(100, "No shader networks to export.")
return
select_nodes = list(shaders)
#select_nodes.extend(list(shading_groups))
select_nodes.extend(script_nodes)
cmds.select(select_nodes, replace=True)
# write a .ma file to the publish path with the shader network definitions
progress_cb(25, "Exporting the shader network.")
cmds.file(
publish_path,
type='mayaAscii',
exportSelected=True,
options="v=0",
prompt=False,
force=True
)
# clean up shader hookup nodes. they should exist in the publish file
# only.
_clean_shader_hookup_script_nodes()
# register the publish:
progress_cb(75, "Registering the publish")
args = {
"tk": self.parent.tank,
"context": self.parent.context,
"comment": comment,
"path": publish_path,
"name": publish_name,
"version_number": publish_version,
"thumbnail_path": thumbnail_path,
"task": sg_task,
"dependency_paths": [primary_publish_path],
"published_file_type":tank_type
}
tank.util.register_publish(**args)
def dynamicParent():
sel = cmds.ls(sl=1)
locatorList = []
for i in xrange(len(sel)-1):
locator = cmds.spaceLocator(n=sel[i] + '_Loc')
cmds.delete(cmds.parentConstraint(sel[i], locator, mo=0))
cmds.parent(locator, sel[i])
locatorList.append(locator)
DPGroup = cmds.group(n=sel[-1] + '_DPGrp', empty=1)
cmds.delete(cmds.parentConstraint(sel[-1], DPGroup, mo=0))
pcGroup = cmds.group(n=sel[-1] + '_pcDPGrp', empty=1)
cmds.delete(cmds.parentConstraint(sel[-1], pcGroup, mo=0))
cmds.parent(pcGroup, DPGroup)
cmds.parent(sel[-1], pcGroup)
newList = []
for i in locatorList:
newList.append(i[0])
newList.insert(0, DPGroup)
cmds.select(cl=1)
for i in xrange(len(newList)):
cmds.parentConstraint(newList[i], pcGroup, mo=0)
parentConstraint = cmds.listRelatives(pcGroup, s=0, c=1, p=0, type='parentConstraint')[0]
enumStr = ':'.join(newList)
# add Attr
cmds.addAttr(sel[-1], ln='Parent', at='enum', en=enumStr, k=1)
for i in xrange(len(newList)):
cmds.setAttr(parentConstraint + '.' + newList[i] + 'W' + str(i), 0)
codeStr = '''import maya.cmds as cmds
def dynamicParentSwitch():
constraintObj = '{0}'
parentConstraint = '{1}'
newList = {2}
index = cmds.getAttr(constraintObj + '.Parent')
wst = cmds.xform(constraintObj, q=1, ws=1, t=1)
wsr = cmds.xform(constraintObj, q=1, ws=1, ro=1)
cmds.setAttr(parentConstraint + '.' + newList[index] + 'W' + str(index), 1)
for i in xrange(len(newList)):
if i == index:
continue
else:
cmds.setAttr(parentConstraint + '.' + newList[i] + 'W' + str(i), 0)
cmds.xform(constraintObj, ws=1, t=wst)
cmds.xform(constraintObj, ws=1, ro=wsr)
cmds.scriptJob(attributeChange=['{3}' + '.Parent', dynamicParentSwitch])
'''.format(sel[-1],
parentConstraint,
newList,
sel[-1])
nodeName = cmds.scriptNode(st=2, bs=codeStr.replace("'''", "''"), n='DynamicParent_#', stp='python')
cmds.scriptNode(nodeName, executeBefore=1)
def __publish_maya_shader_network(self, item, output, work_template, primary_publish_path,
sg_task, comment, thumbnail_path, progress_cb):
"""
Publish shader networks for the asset and register with Shotgun.
:param item: The item to publish
:param output: The output definition to publish with
:param work_template: The work template for the current scene
:param primary_publish_path: The path to the primary published file
:param sg_task: The Shotgun task we are publishing for
:param comment: The publish comment/description
:param thumbnail_path: The path to the publish thumbnail
:param progress_cb: A callback that can be used to report progress
"""
# determine the publish info to use
#
progress_cb(10, "Determining publish details")
# get the current scene path and extract fields from it
# using the work template:
scene_path = os.path.abspath(cmds.file(query=True, sn=True))
fields = work_template.get_fields(scene_path)
publish_version = fields["version"]
tank_type = output["tank_type"]
obj_name = item['name']
fields['obj_name'] = obj_name
fields['name'] = re.sub(r'[\W_]+', '', obj_name)
# create the publish path by applying the fields
# with the publish template:
publish_template = output["publish_template"]
publish_path = publish_template.apply_fields(fields)
# ensure the publish folder exists:
publish_folder = os.path.dirname(publish_path)
self.parent.ensure_folder_exists(publish_folder)
# determine the publish name:
publish_name = fields.get("obj_name")
if not publish_name:
publish_name = os.path.basename(publish_path)
# Find additional info from the scene:
#
progress_cb(10, "Analysing scene")
# clean up any hookup nodes that existed before
_clean_shader_hookup_script_nodes()
# there's probably a better way to do this. i am jon snow (i know
# nothing)
shading_groups = set()
shad_group_to_obj = {}
if cmds.ls(obj_name, dag=True, type="mesh"):
faces = cmds.polyListComponentConversion(obj_name, toFace=True)
for shading_group in cmds.listSets(type=1, object=faces[0]):
shading_groups.add(shading_group)
shad_group_to_obj[shading_group] = obj_name
shaders = set()
script_nodes = []
for shading_group in list(shading_groups):
connections = cmds.listConnections(
shading_group, source=True, destination=False)
for shader in cmds.ls(connections, materials=True):
shaders.add(shader)
obj_name = shad_group_to_obj[shading_group]
# can't seem to store arbitrary data in maya in any
# reasonable way. would love to know a better way to
# do this. for now, just create a script node that
# we can easily find and deduce an object name and
# shader name. Yes, this is hacky.
script_node = cmds.scriptNode(
name="SHADER_HOOKUP_" + obj_name,
scriptType=0, # execute on demand.
beforeScript=shader,
)
script_nodes.append(script_node)
if not shaders:
progress_cb(100, "No shader networks to export.")
return
select_nodes = list(shaders)
#select_nodes.extend(list(shading_groups))
select_nodes.extend(script_nodes)
cmds.select(select_nodes, replace=True)
# write a .ma file to the publish path with the shader network definitions
progress_cb(25, "Exporting the shader network.")
cmds.file(
publish_path,
type='mayaAscii',
exportSelected=True,
options="v=0",
prompt=False,
force=True
)
# clean up shader hookup nodes. they should exist in the publish file
# only.
_clean_shader_hookup_script_nodes()
# register the publish:
progress_cb(75, "Registering the publish")
args = {
"tk": self.parent.tank,
"context": self.parent.context,
"comment": comment,
"path": publish_path,
"name": publish_name,
"version_number": publish_version,
"thumbnail_path": thumbnail_path,
"task": sg_task,
"dependency_paths": [primary_publish_path],
"published_file_type":tank_type
}
tank.util.register_publish(**args)
def addDriverByParForWrapedTFNode(tfGrp):
'''{'del_path':'TfCtrl/Add/Group/addDriverByParForWrapedTFNode(cmds.ls(sl=True)[0])',
'usage':'$fun(cmds.ls(sl=True)[0])',
}
'''
#get tfNodeGrp
cmds.lockNode(tfGrp, l=False)
if cmds.attributeQuery('shellPoly', n=tfGrp, exists=True) == False:
raise IOError('This is not tfGrp object')
else:
shellPoly = cmds.getAttr('%s.shellPoly' % (tfGrp))
if cmds.attributeQuery('nParShapeNode', n=tfGrp, exists=True) == False:
cmds.addAttr(tfGrp, ln="nParShapeNode", dt="string")
else:
raise IOError('%s object has a nParShapeNode to control it')
tfNodeGrp = tfGrp
#print '%s, %s'%(shellPoly, tfNodeGrp)
tfNodeGrpVarStr = tfNodeGrp.replace('|', '__')
objects = cmds.listRelatives(tfNodeGrp, type='transform', f=True)
cmds.lockNode([shellPoly, tfNodeGrp], l=False)
####################create and set nParticle etc.######################################
#create nParticle
nPar = cmds.nParticle(n='%s_nPar' % (tfNodeGrp))
cmds.setAttr(nPar[0] + '.t', l=True)
cmds.setAttr(nPar[0] + '.r', l=True)
cmds.setAttr(nPar[0] + '.s', l=True)
cmds.lockNode(nPar[0], l=True)
nParShape = nPar[1]
#setAttr to get_tfGrpNode
cmds.setAttr(tfNodeGrp + '.nParShapeNode',
nParShape,
type='string',
l=True)
cmds.lockNode([shellPoly, tfNodeGrp], l=True)
cmds.setAttr('%s.computeRotation' % (nParShape), 1)
cmds.goal(nParShape, g=shellPoly, w=.99)
#set attributes
cmds.setAttr(nParShape + '.goalSmoothness', .01)
cmds.setAttr(nParShape + '.radius', .01)
#add attributes
cmds.addAttr(nParShape, ln="cus_toObjPos", dt='doubleArray')
cmds.addAttr(nParShape, ln="cus_toObjPos0", dt='doubleArray')
#Add particles and set attributes(goalU, goalV, cus_bbsiRadius) initialize states
posLi, radiusLi, atULi, atVLi = [], [], [], []
for tfNode in objects:
objPos = cmds.objectCenter(tfNode)
bbsize = cmds.getAttr(tfNode + '.bbsi')[0]
radius = vectorLen(bbsize) / 2
atU = cmds.getAttr(tfNode + '.atU')
atV = cmds.getAttr(tfNode + '.atV')
posLi.append(objPos)
radiusLi.append(radius)
atULi.append(atU)
atVLi.append(atV)
qsEmit(object = nParShape, position=posLi, attributes=( ('cus_radiusPP', 'floatValue', radiusLi), ('goalU', 'floatValue', atULi),\
('goalV', 'floatValue', atVLi) )\
)
##creation expression
#parCExpStr = cmds.dynExpression(nParShape, q=True,s=True, c=True)
parCExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\
goalU = `getAttr ($tfNode+".atU")`;\n\
goalV = `getAttr ($tfNode+".atV")`;\n\
cus_toObjPos = 0;*/' % (tfNodeGrpVarStr)
cmds.dynExpression(nParShape, s=parCExpStr, c=True)
##runtime after dynamics expression
#parRADExpStr = cmds.dynExpression(nParShape, q=True, s=True, rad=True)
parRADExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\n\
\
if (cus_toObjPos == 1){\n\
float $pos[] = position;\n\
vector $rotate = rotationPP;\n\
setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
}\n\n\
\
\
if (goalPP==0 && cus_toObjPos==0){\n\
cus_toObjPos = 1;\n\
float $pos[] = `getAttr ($tfNode+".translate")`;\n\
position = <<$pos[0], $pos[1], $pos[2]>>;\n\
vector $rotate = rotationPP;\n\
setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
setAttr ($tfNode+".pBWeight") 1;\n\
setAttr ($tfNode+".follicleNodeState") 2;\n\
}*/' % (tfNodeGrpVarStr)
cmds.dynExpression(nParShape, s=parRADExpStr, rad=True)
######################################create script nodes########################################
####openCloseMel script node Execute On:Open/close
openCloseMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
global string $%s[];\n\
$%s = `listRelatives -f "%s"`;\n' % (tfNodeGrpVarStr, tfNodeGrpVarStr,
tfNodeGrp)
mel.eval(openCloseMelStr)
if cmds.objExists("QS_VFX_M_OC"):
existsStr = cmds.scriptNode('QS_VFX_M_OC', q=True, bs=True)
openCloseMelStr += existsStr
cmds.scriptNode('QS_VFX_M_OC', e=True, bs=openCloseMelStr)
else:
cmds.scriptNode(n='QS_VFX_M_OC',
scriptType=1,
bs=openCloseMelStr,
sourceType='mel')
cmds.setAttr('QS_VFX_M_OC.scriptType', l=True)
####timeChangedMel script Node Execute on: Time changed
timeChangedMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
int $current = `currentTime -q`;\n\
int $start = `playbackOptions -q -min`;\n\
if ($current == $start){\n\
//%s is a global variable, Declare in QS_VFX_M_QC script node.\n\
$%s = `listRelatives -type "transform" "%s"`; \n\
for ($tfNode in $%s){\n\
setAttr($tfNode+".follicleNodeState") 0;\n\
setAttr($tfNode+".pBWeight") 0;\n\
}\n\
}' % (tfNodeGrpVarStr, tfNodeGrpVarStr, tfNodeGrp, tfNodeGrpVarStr)
mel.eval(timeChangedMelStr)
if cmds.objExists("QS_VFX_M_TC"):
existsStr = cmds.scriptNode('QS_VFX_M_TC', q=True, bs=True)
timeChangedMelStr += existsStr
cmds.scriptNode('QS_VFX_M_TC', e=True, bs=timeChangedMelStr)
else:
cmds.scriptNode(n='QS_VFX_M_TC',
scriptType=7,
bs=timeChangedMelStr,
sourceType='mel')
cmds.setAttr('QS_VFX_M_TC.scriptType', l=True)
def addParByTFSet(tfSet=cmds.ls(sl=True, exactType='objectSet')):
'''{'del_path':'TfCtrl/Add/Set/addParByTFSet( tfSet = cmds.ls(sl=True, exactType="objectSet") )',
'usage':'$fun( tfSet = cmds.ls(sl=True, exactType="objectSet") )',
}
'''
#tfSet = cmds.ls(sl=True, type='objectSet')[0]
if isinstance(tfSet, list):
tfSet = tfSet[0]
cmds.lockNode(tfSet, l=False)
objects = cmds.listConnections(tfSet + '.dagSetMembers', d=False)
createNewPar = True
if cmds.attributeQuery(
'setType', n=tfSet,
exists=True) and cmds.getAttr(tfSet + '.setType') == 1:
raise IOError('This set type is three particle controls!')
if cmds.attributeQuery(
'setType', n=tfSet, exists=True) and cmds.attributeQuery(
'posPar', n=tfSet, exists=True) and cmds.objExists(
cmds.getAttr(tfSet + '.posPar')):
createNewPar = False
if createNewPar:
for attr in ['posPar', 'aimPar', 'upPar']:
if cmds.attributeQuery(attr, n=tfSet,
exists=True) and cmds.objExists(
cmds.getAttr('%s.%s' % (attr))):
cmds.delete(cmds.getAttr('%s.%s' % (attr)))
delAttr(tfSet, ['setType', 'posPar', 'aimPar', 'upPar'])
cmds.addAttr(tfSet,
ln="setType",
at="enum",
en="singlePar:threePar:",
k=False,
r=False)
cmds.setAttr(tfSet + '.setType', 0, l=True)
cmds.addAttr(tfSet, ln="posPar", dt="string")
nPar = cmds.nParticle(n='%s_nPar' % (tfSet))
cmds.setAttr(nPar[0] + '.t', l=True)
cmds.setAttr(nPar[0] + '.r', l=True)
cmds.setAttr(nPar[0] + '.s', l=True)
nParShape = nPar[1]
cmds.setAttr(tfSet + '.posPar', nParShape, type='string', l=True)
cmds.setAttr("%s.computeRotation" % (nParShape), 1)
cmds.addAttr(nParShape, ln="cus_toObjPos", dt='doubleArray')
cmds.addAttr(nParShape, ln="cus_toObjPos0", dt='doubleArray')
else:
nParShape = cmds.getAttr(tfSet + '.posPar')
cmds.lockNode(nParShape, l=False)
#Add particles and set attributes(goalU, goalV, cus_bbsiRadius) initialize states
posLi, radiusLi, atULi, atVLi = [], [], [], []
for tfNode in objects:
objPos = cmds.objectCenter(tfNode)
bbsize = cmds.getAttr(tfNode + '.bbsi')[0]
radius = newom.MVector(bbsize).length() / 2
atU = cmds.getAttr(tfNode + '.atU')
atV = cmds.getAttr(tfNode + '.atV')
posLi.append(objPos)
radiusLi.append(radius)
atULi.append(atU)
atVLi.append(atV)
qsEmit(object = nParShape, position=posLi, attributes=( ('cus_radiusPP', 'floatValue', radiusLi), ('goalU', 'floatValue', atULi),\
('goalV', 'floatValue', atVLi) )\
)
cmds.lockNode(tfSet, l=True)
if createNewPar:
##creation expression
#parCExpStr = cmds.dynExpression(nParShape, q=True,s=True, c=True)
parCExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\
goalU = `getAttr ($tfNode+".atU")`;\n\
goalV = `getAttr ($tfNode+".atV")`;\n\
cus_toObjPos = 0;*/' % (tfSet)
cmds.dynExpression(nParShape, s=parCExpStr, c=True)
##runtime after dynamics expression
#parRADExpStr = cmds.dynExpression(nParShape, q=True, s=True, rad=True)
parRADExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\n\
\
if (cus_toObjPos == 1){\n\
float $pos[] = position;\n\
vector $rotate = rotationPP;\n\
setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
}\n\n\
\
\
if (goalPP==0 && cus_toObjPos==0){\n\
cus_toObjPos = 1;\n\
float $pos[] = `getAttr ($tfNode+".translate")`;\n\
position = <<$pos[0], $pos[1], $pos[2]>>;\n\
vector $rotate = rotationPP;\n\
setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
setAttr ($tfNode+".pBWeight") 1;\n\
setAttr ($tfNode+".follicleNodeState") 2;\n\
}*/' % (tfSet)
cmds.dynExpression(nParShape, s=parRADExpStr, rad=True)
######################################create script nodes########################################
####openCloseMel script node Execute On:Open/close
openCloseMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
global string $%s[];\n\
$%s = `listConnections -d off "%s.dagSetMembers"`;\n' % (tfSet, tfSet, tfSet)
mel.eval(openCloseMelStr)
if cmds.objExists("QS_VFX_M_OC"):
existsStr = cmds.scriptNode('QS_VFX_M_OC', q=True, bs=True)
openCloseMelStr += existsStr
cmds.scriptNode('QS_VFX_M_OC', e=True, bs=openCloseMelStr)
else:
cmds.scriptNode(n='QS_VFX_M_OC',
scriptType=1,
bs=openCloseMelStr,
sourceType='mel')
cmds.setAttr('QS_VFX_M_OC.scriptType', l=True)
####timeChangedMel script Node Execute on: Time changed
timeChangedMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
int $current = `currentTime -q`;\n\
int $start = `playbackOptions -q -min`;\n\
if ($current == $start){\n\
//%s is a global variable, Declare in QS_VFX_M_QC script node.\n\
$%s = `listConnections -d off "%s.dagSetMembers"`; \n\
for ($tfNode in $%s){\n\
setAttr($tfNode+".follicleNodeState") 0;\n\
setAttr($tfNode+".pBWeight") 0;\n\
}\n\
}' % (tfSet, tfSet, tfSet, tfSet)
mel.eval(timeChangedMelStr)
if cmds.objExists("QS_VFX_M_TC"):
existsStr = cmds.scriptNode('QS_VFX_M_TC', q=True, bs=True)
timeChangedMelStr += existsStr
cmds.scriptNode('QS_VFX_M_TC', e=True, bs=timeChangedMelStr)
else:
cmds.scriptNode(n='QS_VFX_M_TC',
scriptType=7,
bs=timeChangedMelStr,
sourceType='mel')
cmds.setAttr('QS_VFX_M_TC.scriptType', l=True)
"""
scriptJob and scriptNode example
"""
import maya.cmds as cmds
codeStr = '''
def colorChange():
objAttr = 'pSphere1.Color'
if cmds.getAttr(objAttr) == 0:
cmds.polyColorPerVertex(r=0.0, g=1.0, b=0.0, a=1.0, cdo=1)
elif cmds.getAttr(objAttr) == 1:
cmds.polyColorPerVertex(r=0.0, g=0.0, b=1.0, a=1.0, cdo=1)
elif cmds.getAttr(objAttr) == 2:
cmds.polyColorPerVertex(r=1.0, g=0.0, b=0.0, a=1.0, cdo=1)
cmds.scriptJob(attributeChange=['pSphere1.Color', colorChange])
'''
cmds.scriptNode(st=2,
bs=codeStr.replace("'''", "''"),
n='sphere_ColorChange',
stp='python')
def createMDscriptNode():
dsMetaDataScriptNode = cmds.scriptNode( st=1, bs='import dsCommon.dsMetaDataTools as dsMDT;reload(dsMDT);dsMDT.sceneCheck()', n='dsMetaData', stp='python')
dsMDCreate() # creates sequence level attr's
createShotAttrs()
updatedsMD()
