def clean_scene():
'''
Clean up a maya scene of orphaned and unused objects
'''
# Delete orphaned controller tags
controller_tags = [x for x in pm.ls(type='controller') if x.exists() and not x.controllerObject.listConnections()]
if controller_tags:
pm.delete(controller_tags)
v1_core.v1_logging.get_logger().info("Scene Cleanup Deleted Controller Tags : \n{0}".format(controller_tags))
# Delete unused shader nodes
temp_cube = None
try:
# Since Maya 2020 an error is thrown when running Delete Unused Nodes if the StandardSurface default shader is unassigned
# So we create a temporary object, assign the default StandardSurface material to it, then delete Unused and delete the sphere
temp_cube = pm.polyCube(name="TEMP_StandardSurface_Assignment")[0]
temp_standard_shader = pm.sets( renderable=True, noSurfaceShader=True, empty=True, name="standardSurface1SG" )
standard_material = pm.PyNode("standardSurface1")
standard_material.outColor >> temp_standard_shader.surfaceShader
pm.sets(temp_standard_shader, edit=True, forceElement=temp_cube)
pm.mel.eval('hyperShadePanelMenuCommand("hyperShadePanel1", "deleteUnusedNodes");')
except Exception, e:
v1_core.v1_logging.get_logger().info("Failed To Delete Unused Nodes:")
v1_core.v1_logging.get_logger().info("{0}".format(e))
pass
def createRGBShaders():
search = pm.ls('redAxisSG', type='shadingEngine')
if search:
xShadingGrp = search[0]
else:
xShader = pm.shadingNode("blinn", asShader=True, name='redAxis')
xShadingGrp = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name='redAxisSG')
xShader.outColor >> xShadingGrp.surfaceShader
xShader.color.set([1, 0, 0])
search = pm.ls('greenAxisSG', type='shadingEngine')
if search:
yShadingGrp = search[0]
else:
yShader = pm.shadingNode("blinn", asShader=True, name='greenAxis')
yShader.color.set([0, 1, 0])
yShadingGrp = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name='greenAxisSG')
yShader.outColor >> yShadingGrp.surfaceShader
search = pm.ls('blueAxisSG', type='shadingEngine')
if search:
zShadingGrp = search[0]
else:
zShader = pm.shadingNode("blinn", asShader=True, name='blueAxis')
zShader.color.set([0, 0, 1])
zShadingGrp = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name='blueAxisSG')
zShader.outColor >> zShadingGrp.surfaceShader
return [xShadingGrp, yShadingGrp, zShadingGrp]
def binMeshAssignShader(creatorShape=None,
shadingGroupList=[],
perFaceAssingments=[]):
if not creatorShape:
log.error("binMeshAssignShader: No creator shape")
return
if pm.PyNode(creatorShape).type() != "mtap_standinMeshNode":
log.error(
"binMeshAssignShader: Node {0} is not a creator shape".format(
creatorShape))
return
log.debug("binMeshAssignShader: creatorShape {0}".format(creatorShape))
polyShapeList = getConnectedPolyShape(creatorShape)
for polyShape in polyShapeList:
log.debug("binMeshAssignShader: polyShape {0}".format(polyShape))
for index, shadingGroup in enumerate(shadingGroupList):
binMeshCheckAndCreateShadingGroup(shadingGroup)
assignments = perFaceAssingments[index]
print assignments
faceSelection = []
for polyId in assignments:
faceSelection.append(polyId)
print "meshShape has", polyShape.numFaces(), "faces. Edeff."
fs = polyShape.f[faceSelection]
print "pm.sets('{0}', e=True, forceElement={1})".format(
shadingGroup, str(fs))
pm.sets(shadingGroup, e=True, forceElement=str(fs))
def move_face_shell(faces, u=0, v=0):
""" Move all uvs related to arg faces by u and v values
"""
udim = uv_udim_convert([u,v])
uvs = pm.polyListComponentConversion(faces, tuv=True)
pm.polyEditUV(uvs, u=-(u-1), v=-(v-1))
pm.sets(faces, n=set_name%str(udim))
def useVRayMtl(currentPage, texture1):
shdr, sg = pm.createSurfaceShader( 'VRayMtl', currentPage[0]+"_shdr" )
pm.sets( sg, forceElement=currentPage )
filenode = pm.createNode('file', name=currentPage[0]+"_file")
filenode.fileTextureName.set(texture1)
pm.connectAttr( filenode+".outColor", shdr.color , force=1)
placement = pm.shadingNode('place2dTexture', asUtility=1, name='placeTextureName')
pm.connectAttr(placement.outUV, filenode.uvCoord, f=1)
pm.connectAttr(placement.outUvFilterSize, filenode.uvFilterSize, f=1)
pm.connectAttr(placement.coverage, filenode.coverage, f=1)
pm.connectAttr(placement.translateFrame, filenode.translateFrame, f=1)
pm.connectAttr(placement.rotateFrame, filenode.rotateFrame, f=1)
pm.connectAttr(placement.mirrorU, filenode.mirrorU, f=1)
pm.connectAttr(placement.mirrorV, filenode.mirrorV, f=1)
pm.connectAttr(placement.stagger, filenode.stagger, f=1)
pm.connectAttr(placement.wrapU, filenode.wrapU, f=1)
pm.connectAttr(placement.wrapV, filenode.wrapV, f=1)
pm.connectAttr(placement.repeatUV, filenode.repeatUV, f=1)
pm.connectAttr(placement.vertexUvOne, filenode.vertexUvOne, f=1)
pm.connectAttr(placement.vertexUvTwo, filenode.vertexUvTwo, f=1)
pm.connectAttr(placement.vertexUvThree, filenode.vertexUvThree, f=1)
pm.connectAttr(placement.vertexCameraOne, filenode.vertexCameraOne, f=1)
pm.connectAttr(placement.noiseUV, filenode.noiseUV, f=1)
pm.connectAttr(placement.offset, filenode.offset, f=1)
pm.connectAttr(placement.rotateUV, filenode.rotateUV, f=1)
pm.setAttr(placement.rotateFrame, 90)
pm.setAttr(placement.repeatU, -1)
def assign_material(mtl_or_sg, *nodes):
'''Assign a material to a bunch of nodes
:param mtl_or_sg: The material or shadingEngine to assign
:param nodes: The nodes to be assigned to
'''
class_ = mtl_or_sg.classification()
if 'shadingEngine' in class_:
sg = mtl_or_sg
elif 'shader/surface' in class_:
sgs = pmc.listConnections(mtl_or_sg, type='shadingEngine')
if sgs:
sg = sgs[0]
else:
sg = pmc.sets(
empty=True,
renderable=True,
name=str(mtl_or_sg) + 'SG'
)
mtl_or_sg.outColor.connect(sg.surfaceShader)
else:
raise TypeError('{} not a shader or shadingEngine'.format(mtl_or_sg))
for node in nodes:
pmc.sets(sg, forceElement=node)
def NSphere(self):
shaderName = self._baseName + '_mtl'
crv = pm.sphere(r=self.radius, n=self.name)
#### set invisible to render
crvShape = crv[0].getShape()
crvShape.castsShadows.set(False)
crvShape.receiveShadows.set(False)
crvShape.motionBlur.set(False)
crvShape.primaryVisibility.set(False)
crvShape.smoothShading.set(False)
crvShape.visibleInReflections.set(False)
crvShape.visibleInRefractions.set(False)
crvShape.doubleSided.set(False)
#### set Shader
shdr_name = '{}_{}'.format(shaderName, self.name)
sg_name = '{}{}'.format(shdr_name, 'SG')
if pm.objExists(shdr_name) or pm.objExists(sg_name):
try:
pm.delete(shdr_name)
pm.delete(sg_name)
except:
pass
shdr, sg = pm.createSurfaceShader('surfaceShader')
pm.rename(shdr, shdr_name)
pm.rename(sg, sg_name)
shdr.outColor.set(self.color.rgb)
shdr.outTransparency.set([self.color.a for i in range(3)])
pm.sets(sg, fe=crv[0])
return crv[0]
def makeLightSelectSet(sel=None):
try:
lgt = select.shapes(sel, xf=True, do=True)
except:
pass
_go = pm.promptDialog(title='New Light Group:',
message='Enter Name:',
button=['OK', 'Cancel'],
tx='lg_',
defaultButton='OK',
cancelButton='Cancel',
dismissString='Cancel')
if _go == 'OK':
name = pm.promptDialog(query=True, text=True)
_lg = pm.PyNode(pm.Mel.eval(
'vrayAddRenderElement LightSelectElement;')) # make the light grou
pm.rename(_lg, name)
_lg.vray_name_lightselect.set(name)
else:
return None
if sel:
for obj in sel:
pm.sets(_lg, edit=True, forceElement=obj)
return _lg
def create(self):
"""creates Maya objects
"""
import pymel.core as pm
self.parent_node = self.get_parent()
self.shape_node = pm.nt.Mesh(name='%sShape' % self.node_name)
self.transform_node = self.shape_node.getParent()
self.transform_node.rename(self.node_name)
self.rs_proxy_node = \
pm.nt.RedshiftProxyMesh(name='%sRsProxy' % self.node_name)
self.rs_proxy_node.outMesh >> self.shape_node.inMesh
self.rs_proxy_node.fileName.set(self.instance_file)
# self.transform_node.t.set(self.pos)
# self.transform_node.r.set(self.rot)
# self.transform_node.s.set([self.sca, self.sca, self.sca])
self.parent_node.t.set(self.pos)
self.parent_node.r.set(self.rot)
self.parent_node.s.set([self.sca, self.sca, self.sca])
# assign default shader
lambert1 = pm.ls('lambert1')[0]
lambert1_shading_group = \
lambert1.outputs(type='shadingEngine')[0]
pm.sets(lambert1_shading_group, fe=self.transform_node)
pm.parent(self.transform_node, self.parent_node, r=1)
def copyMMAT(src, tgt):
src = getMeshNode(src)
tgt = getMeshNode(tgt)
assert src and tgt, "select to mesh objects"
for sg in src.listSets(t=1):
print "Preparing to duplicate:", sg.name(
stripNamespace=True), sg.name()
if sg.name(stripNamespace=True) != "initialShadingGroup":
newname = "COPY_" + sg.name(stripNamespace=True)
try:
matinscene = pym.PyNode(newname)
except Exception as e:
matinscene = None
if matinscene:
newSG = matinscene
else:
newSG = pym.duplicate(sg,
n=newname,
rr=True,
un=True,
renameChildren=True)[0]
for memb in sg.members():
if type(memb) == pym.general.MeshFace:
if memb.node() == src:
indx = memb.indices()
if indx:
pym.sets(newSG, forceElement=tgt.faces[indx])
elif type(memb) == pym.nodetypes.Mesh and memb == src:
pym.sets(newSG, forceElement=tgt)
def set_default_shader(input_node):
"""Assign initialShadingGroup to specified node.
:arg input_node: PyNode need to be assign with initialShadingGroup.
:type input_node: pm.PyNode
"""
pm.sets('initialShadingGroup', edit=True, forceElement=input_node)
def createObjectSet(setName,
objLst=[],
exclusiveness=False,
partition=None,
increment=False):
'''
create an objectSet.
@param setName string : This objectSet's name.
@param objLst list : Objects which belongs this objectSet.
@param exclusiveness bool : Whether is this objectSet mutually exclusive with another objectSet in one partition.
@param partition node or string : When exclusiveness flag is True, partitin should be assigned a partition node. Ignore when exclusiveness flag is False.
@param increment bool : Whether to use the existed one or create an increment one When the named objectSet has been existed.
If the existed objectSet will be used, ignore exclusiveness flag and partition flag.
@result node
'''
useExisted = False
if not pm.objExists(setName):
objSet = pm.sets(em=1, name=setName)
elif pm.objExists(setName) and increment:
setName = name.compileNodeName(setName)
objSet = pm.sets(em=1, name=setName)
else:
objSet = pm.PyNode(setName)
useExisted = True
if not useExisted and exclusiveness:
partition.addMember(objSet)
if objLst:
#objSet.addMembers(objLst)
pm.sets(objSet, e=1, forceElement=objLst)
return objSet
def doExecution(*args):
is_find = pm.checkBox( UI_name[0], q=True, value=True )
is_fix = pm.checkBox( UI_name[1], q=True, value=True )
is_fixLayer = pm.checkBox( UI_name[2], q=True, value=True )
shader_info_all_layers = []
if( is_find ):
findErrorShape()
if( is_fixLayer ):
#// collect shaders info in each layer
shader_info_all_layers = collectShaderInfoInLayer()
if( is_fix ):
fixComponentShading()
if( is_fixLayer ):
for shd_layer in shader_info_all_layers:
#// switch to a specified layer
curr_layer = shd_layer[0]
pm.editRenderLayerGlobals( currentRenderLayer=curr_layer )
#// parsing string for mesh & shader from list
#// assign shader to mesh from list
for shd in shd_layer[1]:
obj = shd[0]
SG = shd[1]
pm.sets( SG, edit=True, forceElement=obj )
pm.editRenderLayerGlobals( currentRenderLayer='defaultRenderLayer' )
return 1
def applyShaderToSelected(self):
List = pm.ls(sl=True)
for object in List:
pm.select(object)
pm.hyperShade(a=self.Shader)
pm.sets(self.Set, e=True, forceElement=True)
self.listObjectsAppliedTo.append(object)
def binMeshAssignShader(creatorShape=None,
shadingGroupList=[],
perFaceAssingments=[]):
if not creatorShape:
return
if pm.PyNode(creatorShape).type() != "mtap_standinMeshNode":
log.error(
"binMeshAssignShader: Node {0} is not a creator shape".format(
creatorShape))
return
polyShapeList = getConnectedPolyShape(creatorShape)
for polyShape in polyShapeList:
for index, shadingGroup in enumerate(shadingGroupList):
binMeshCheckAndCreateShadingGroup(shadingGroup)
assignments = perFaceAssingments[index]
print assignments
faceSelection = []
for polyId in assignments:
faceSelection.append(polyId)
fs = polyShape.f[faceSelection]
pm.sets(shadingGroup, e=True, forceElement=str(fs))
def txShow(
): # GET TEXTURE FROM CUSTOM ATTR AND ASIGN MATERIAL TO OBJ WITH TEXTURE
pm.pickWalk(d="down")
sel = pm.ls(sl=1) # get shapes of selection
for i in sel:
if getTXShape(i): # Check, if attribute has value
texturePath, textureName = getTXShape(
i) # get texture name with path, texture name
if textureName: # Check, if attribute has value
if pm.objExists('PREV_' + textureName):
pm.sets(('PREV_' + str(textureName) + 'SG'),
forceElement=i)
else:
previewShader = pm.shadingNode('lambert',
asShader=True,
n='PREV_' + textureName)
previewIF = pm.shadingNode('file',
asTexture=True,
n='PREV_IF_' + textureName)
previewSG = pm.sets(renderable=True,
noSurfaceShader=True,
empty=True,
n=previewShader + 'SG')
previewIF.fileTextureName.set('sourceimages/' +
str(texturePath))
previewIF.outColor >> previewShader.color
previewShader.outColor >> previewSG.surfaceShader
pm.sets(previewSG, forceElement=i)
def binMeshAssignShader(creatorShape = None, shadingGroupList=[], perFaceAssingments=[]):
if not creatorShape:
log.error("binMeshAssignShader: No creator shape")
return
if pm.PyNode(creatorShape).type() != "mtap_standinMeshNode":
log.error("binMeshAssignShader: Node {0} is not a creator shape".format(creatorShape))
return
log.debug("binMeshAssignShader: creatorShape {0}".format(creatorShape))
polyShapeList = getConnectedPolyShape(creatorShape)
for polyShape in polyShapeList:
log.debug("binMeshAssignShader: polyShape {0}".format(polyShape))
for index, shadingGroup in enumerate(shadingGroupList):
binMeshCheckAndCreateShadingGroup(shadingGroup)
assignments = perFaceAssingments[index]
print assignments
faceSelection = []
for polyId in assignments:
faceSelection.append(polyId)
print "meshShape has", polyShape.numFaces(), "faces. Edeff."
fs = polyShape.f[faceSelection]
print "pm.sets('{0}', e=True, forceElement={1})".format(shadingGroup,str(fs))
pm.sets(shadingGroup, e=True, forceElement=str(fs))
def createObjectSet(setName, objLst = [], exclusiveness = False, partition = None, increment = False):
'''
create an objectSet.
@param setName string : This objectSet's name.
@param objLst list : Objects which belongs this objectSet.
@param exclusiveness bool : Whether is this objectSet mutually exclusive with another objectSet in one partition.
@param partition node or string : When exclusiveness flag is True, partitin should be assigned a partition node. Ignore when exclusiveness flag is False.
@param increment bool : Whether to use the existed one or create an increment one When the named objectSet has been existed.
If the existed objectSet will be used, ignore exclusiveness flag and partition flag.
@result node
'''
useExisted = False
if not pm.objExists(setName):
objSet = pm.sets(em=1, name = setName)
elif pm.objExists(setName) and increment :
setName = name.compileNodeName(setName)
objSet = pm.sets(em=1, name = setName)
else:
objSet = pm.PyNode(setName)
useExisted = True
if not useExisted and exclusiveness :
partition.addMember(objSet)
if objLst:
#objSet.addMembers(objLst)
pm.sets(objSet, e=1, forceElement = objLst)
return objSet
def custom_sets(self, *args):
self.log.clear()
self.log.insertText('Create Custom Sets...\n')
self.log.insertText('\nFind all controls under the groups: \n "Placer", "rig_arc", and "Face_UI|Panels"\n\nGenerate two sets as result : \n "ctrlSet" contains all tagged controls\n "_NON_TAGGED_CURVES" contains all non-tagged controls\n')
ctrlSets = pm.ls("*ctrlSet")
if not ctrlSets:
self.controlSet = pm.sets(empty=True, name = "ctrlSet")
grps = [grp for grp in ['Placer', 'rig_arc'] if pm.objExists(grp)]
pm.select(grps, hi=True)
all_curve = pm.ls(sl=True, type="nurbsCurve")
pm.select(clear=True)
all_ctrl = [ctrl.getParent() for ctrl in all_curve]
if pm.objExists('Panels'):
pm.select('Panels', hi=True)
all_facial_curve = pm.ls(sl=True, type="nurbsCurve")
pm.select(clear=True)
all_ctrl.extend([curve.getParent() for curve in all_facial_curve if curve.getParent().tz.isLocked()])
#pm.sets(all_ctrl, name="_ALL_CURVES")
no_tags = [ctrl for ctrl in all_ctrl if not pm.attributeQuery ('ClientAnimCtrl', node= ctrl, ex=True)]
pm.sets(no_tags, name="_NON_TAGGED_CURVES")
tags = [ctrl for ctrl in all_ctrl if pm.attributeQuery ('ClientAnimCtrl', node= ctrl, ex=True)]
self.controlSet.addMembers(tags)
def createJntTweak(mesh, jntParent, ctlParent):
"""Create a joint tweak
Args:
mesh (mesh): The object to deform with the tweak
jntParent (dagNode): The parent for the new joint
ctlParent (dagNode): The parent for the control.
"""
if not isinstance(mesh, list):
mesh = [mesh]
name = "_".join(jntParent.name().split("_")[:3])
# create joints
jointBase = primitive.addJoint(jntParent,
name + "_tweak_jnt_lvl",
jntParent.getMatrix(worldSpace=True))
resetJntLocalSRT(jointBase)
joint = primitive.addJoint(jointBase,
name + "_tweak_jnt",
jntParent.getMatrix(worldSpace=True))
resetJntLocalSRT(joint)
# hiding joint base by changing the draw mode
# pm.setAttr(jointBase+".drawStyle", 2)
try:
defSet = pm.PyNode("rig_deformers_grp")
except TypeError:
pm.sets(n="rig_deformers_grp")
defSet = pm.PyNode("rig_deformers_grp")
pm.sets(defSet, add=joint)
controlType = "circle"
iconBase = icon.create(ctlParent,
name + "_base_tweak_ctl",
ctlParent.getMatrix(worldSpace=True),
13,
controlType,
w=.8,
ro=datatypes.Vector(0, 0, 1.5708))
attribute.addAttribute(iconBase, "isCtl", "bool", keyable=False)
o_icon = icon.create(iconBase, name + "_tweak_ctl",
ctlParent.getMatrix(worldSpace=True),
17,
controlType,
w=.5,
ro=datatypes.Vector(0, 0, 1.5708))
attribute.addAttribute(o_icon, "isCtl", "bool", keyable=False)
for t in [".translate", ".scale", ".rotate"]:
pm.connectAttr(iconBase + t, jointBase + t)
pm.connectAttr(o_icon + t, joint + t)
# magic of doritos connection
for m in mesh:
pre_bind_matrix_connect(m, joint, jointBase)
def addSupportJoint(oSel=None, *args):
if not oSel:
oSel = pm.selected()
elif not isinstance(oSel, list):
oSel = [oSel]
for x in oSel:
if x.name().split("_")[0] == "blend":
children = [
item for item in pm.selected()[0].listRelatives(ad=True,
type="joint")
]
i = len(children)
name = x.name().replace("blend", "blendSupport_%s" % str(i))
jnt = pm.createNode('joint', n=name, p=x)
jnt.attr('radius').set(1.5)
jnt.attr("overrideEnabled").set(1)
jnt.attr("overrideColor").set(17)
try:
defSet = pm.PyNode("rig_deformers_grp")
except:
pm.sets(n="rig_deformers_grp")
defSet = pm.PyNode("rig_deformers_grp")
pm.sets(defSet, add=jnt)
else:
pm.displayWarning(
"Support Joint can't be added to: %s. Because is not blend joint"
% x.name())
def rtb_create_retopo_shader():
''' '''
try:
sel = [
obj for obj in pm.ls(sl=True)
if obj.getShape() and obj.getShape().nodeType() == 'mesh'
]
except:
pm.warning('Please select some geometry')
return
shaderName = 'lcRetopo'
if not pm.objExists(shaderName):
shader = pm.shadingNode('lambert', asShader=True, name=shaderName)
SG = shaderName + 'SG'
if not pm.objExists(SG):
pm.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=(shader + 'SG'))
pm.connectAttr(shader + '.outColor', SG + '.surfaceShader', force=True)
shader.color.set(1, 0, 0)
shader.transparency.set(0.5, 0.5, 0.5)
if sel:
pm.select(sel, replace=True) #grab the stored selection
pm.hyperShade(assign=shaderName) #assign shader to selection
def extract_controls(*args):
"""Extract the selected controls from the rig to use it in the new build
The controls shapes are stored under the controller_org group.
The controls are renamed witht "_controlBuffer" suffix
Args:
*args: None
"""
oSel = pm.selected()
try:
cGrp = pm.PyNode("controllers_org")
except TypeError:
cGrp = False
mgear.log(
"Not controller group in the scene or the group is not unique",
mgear.sev_error)
for x in oSel:
try:
old = pm.PyNode(cGrp.name() + "|" + x.name().split("|")[-1] +
"_controlBuffer")
pm.delete(old)
except TypeError:
pass
new = pm.duplicate(x)[0]
pm.parent(new, cGrp, a=True)
pm.rename(new, x.name() + "_controlBuffer")
toDel = new.getChildren(type="transform")
pm.delete(toDel)
try:
pm.sets("rig_controllers_grp", remove=new)
except TypeError:
pass
def ar_findDuplicates():
"""
@ brief Check for nodes with duplicate name and add them to errors node.
Returns:
bool.
"""
duplicateNames = list()
for node in pm.ls():
if "|" in str(node):
if not node.isInstanced():
duplicateNames.append(str(node))
else:
if len(pm.ls(node)) > 1:
duplicateNames.append(str(node))
if not duplicateNames:
ar_qui.ar_displayMessage('success', 'No duplicates in scene...')
return True
pm.select(cl=True)
if pm.objExists('SET_duplicate_names'):
pm.delete('SET_duplicate_names')
pm.sets(n='SET_duplicate_names', em=True).union(duplicateNames)
ar_qui.ar_displayMessage(
'success',
'%s duplicate objects has been found and put in the "SET_duplicate_names".'
% len(duplicateNames)),
return False
def create_dominant_color_shader(dag, tex_name_surfix=['co', 'color', 'diffuse', 'dif', 'base'],
sample_rate=None, max_auto_sample=50,
default_shader='aiStandardSurface', default_channel='baseColor'):
"""
Create an auto average-color lambert shader and assign it to input object.
Maybe does not work with TIFF texture ( cannot extract color ).
"""
if type(dag) == pm.nodetypes.Transform:
mesh = dag.getShape()
if not type(mesh) == pm.nodetypes.Mesh:
return None
elif type(dag) == pm.nodetypes.Mesh:
mesh = dag
else:
return None
avg_color = _detect_dominant_color(mesh, tex_name_surfix, sample_rate,
max_auto_sample, default_shader, default_channel)
if not avg_color:
return None
color_shader, sg = pm.createSurfaceShader('lambert')
color_shader.color.set(avg_color)
pm.connectAttr(color_shader.color, sg.surfaceShader, f=1)
pm.sets(sg, forceElement=mesh)
return color_shader
def create_obj_sets(json_data, ove=None):
if ove is None:
ove = False
objsets = []
chk_success = True
for objset, items in json_data.items():
ls_items = pm.ls(items)
chk_exists = len(items) == len(ls_items)
if not chk_exists:
chk_success = False
abs_items = [x for x in items if not pm.objExists(x)]
print "\n (i) {0}: Some objects not found".format(objset),
print "\n > ", abs_items,
if pm.objExists(objset):
if ove:
pm.delete(objset)
if not pm.objExists(objset):
pm.sets(n=objset, em=1)
pm.sets(objset, add=ls_items)
objsets.append(objset)
if chk_success:
print "\n ^_^",
return objsets
def extractControls(self, *args):
oSel = pm.selected()
try:
cGrp = pm.PyNode("controllers_org")
except:
cGrp = False
mgear.log(
"Not controller group in the scene or the group is not unique",
mgear.sev_error)
for x in oSel:
try:
old = pm.PyNode(cGrp.name() + "|" + x.name().split("|")[-1] +
"_controlBuffer")
pm.delete(old)
except:
pass
new = pm.duplicate(x)[0]
pm.parent(new, cGrp, a=True)
pm.rename(new, x.name() + "_controlBuffer")
toDel = new.getChildren(type="transform")
pm.delete(toDel)
try:
pm.sets("rig_controllers_grp", remove=new)
except:
pass
def create(self):
"""creates Maya objects
"""
import pymel.core as pm
self.parent_node = self.get_parent()
self.shape_node = pm.nt.Mesh(name='%sShape' % self.node_name)
self.transform_node = self.shape_node.getParent()
self.transform_node.rename(self.node_name)
self.rs_proxy_node = \
pm.nt.RedshiftProxyMesh(name='%sRsProxy' % self.node_name)
self.rs_proxy_node.outMesh >> self.shape_node.inMesh
self.rs_proxy_node.fileName.set(self.instance_file)
# self.transform_node.t.set(self.pos)
# self.transform_node.r.set(self.rot)
# self.transform_node.s.set([self.sca, self.sca, self.sca])
self.parent_node.t.set(self.pos)
self.parent_node.r.set(self.rot)
self.parent_node.s.set([self.sca, self.sca, self.sca])
# assign default shader
lambert1 = pm.ls('lambert1')[0]
lambert1_shading_group = \
lambert1.outputs(type='shadingEngine')[0]
pm.sets(lambert1_shading_group, fe=self.transform_node)
pm.parent(self.transform_node, self.parent_node, r=1)
def sphere_generator(source_sphrs, source_verts, gen_bones, settings):
spheres = []
for i in range(len(source_sphrs)):
sphere = source_sphrs[i]
core_vert = source_verts[sphere.vertex]
coords = [core_vert.x, core_vert.y, core_vert.z]
poly_transform, poly_sphere = pm.polySphere(
name="Sphere" + str(i),
r=sphere.size * WORLD_SCALE,
sx=settings.sphere_resolution,
sy=settings.sphere_resolution)
poly_transform.translate.set(coords)
poly_transform.rotate.set([90, 0, 0])
poly_shape = poly_transform.getShape()
if settings.use_palette:
sg = "paletteSG" + str(sphere.colour)
pm.sets(sg, edit=True, forceElement=poly_transform)
pm.polySoftEdge(a=180)
if settings.use_rigging:
pm.skinCluster(gen_bones[core_vert.bone], poly_shape, tsb=True)
spheres.append(poly_shape)
return spheres
def LoadRs(rsFile):
rsName = rsFile.split('/')[-1].split('.')[0]
geoName = '{0}_RS'.format(rsName)
print "GeoName is :", geoName
transform = pm.group(empty=True, name=geoName)
print 'transform Grp is:', transform
Shape = pm.createNode('mesh',
name='{0}Shape'.format(transform.name()),
p=transform)
print 'Shape is: ', Shape
RS = pm.createNode('RedshiftProxyMesh',
name='{0}RSProxy'.format(transform.name()))
print 'Rs is :', RS
RS.fileName.set(rsFile)
print 'file name set: ', rsFile
pm.connectAttr(RS.outMesh, Shape.inMesh)
print 'connection done: Rs.outMesh to Shape.inMesh'
pm.sets('initialShadingGroup', e=True, forceElement=Shape)
return transform
def createCTL(type="square", child=False, *args):
"""Create a control for each selected object.
The newly create control can be parent or child of the object.
Args:
type (str): The shape of the control.
child (bool): if True, the control will be created as a
child of the object.
"""
iconList = []
if child:
if len(pm.selected()) > 0:
for x in pm.selected():
oChilds = [
item for item in x.listRelatives(ad=True, type="transform")
if item.longName().split("|")[-2] == x.name()
]
o_icon = icon.create(None,
x.name() + "_ctl", None, [1, 0, 0], type)
iconList.append(o_icon)
o_icon.setTransformation(x.getMatrix(worldSpace=True))
pm.parent(o_icon, x)
for child in oChilds:
pm.parent(child, o_icon)
else:
o_icon = icon.create(None, type + "_ctl", datatypes.Matrix(),
[1, 0, 0], type)
iconList.append(o_icon)
else:
if len(pm.selected()) > 0:
for x in pm.selected():
oParent = x.getParent()
o_icon = icon.create(oParent,
x.name() + "_ctl", x.getMatrix(),
[1, 0, 0], type)
iconList.append(o_icon)
o_icon.setTransformation(x.getMatrix())
pm.parent(x, o_icon)
else:
o_icon = icon.create(None, type + "_ctl", datatypes.Matrix(),
[1, 0, 0], type)
iconList.append(o_icon)
for ico in iconList:
attribute.addAttribute(ico, "isCtl", "bool", keyable=False)
try:
defSet = pm.PyNode("rig_controllers_grp")
for ico in iconList:
pm.sets(defSet, add=ico)
except TypeError:
print("No rig_controllers_grp found")
pass
def copyMat(src, tgt):
shps = src.listRelatives(type="shape")
if shps:
shp = shps[0]
SE = shp.listConnections(type="shadingEngine", et=True, d=True)[0]
tgtShape = tgt.listRelatives(shapes=True)[0]
if SE:
pym.sets(SE, e=True, forceElement=tgtShape)
def set_material(ob, SG):
if type(SG) == pm.nt.ShadingEngine:
try:
pm.sets(SG, forceElement=ob)
except:
print "cannot apply %s to %s" % (SG.name(), ob.name())
else:
print "There is no %s" % SG.name()
def _restoreShaders(self, shadersDict):
objsInScene = set(map(str, pm.ls()))
for obj, shs in shadersDict.iteritems():
if (str(obj) in objsInScene):
for shader in shs:
if (str(shader) in objsInScene):
pm.select(obj)
pm.sets(shader, fe=1)
def sel_faces(self,
sel_shd_label,
type='dst'): # select faces based on selected labels.
if type == 'dst':
sel_sg = self.action_data('r', 'dst')[sel_shd_label].values()[0]
pm.select(pm.sets(sel_sg, q=True), r=True)
else:
sel_sg = self.action_data('r', 'src')[sel_shd_label].values()[0]
pm.select(pm.sets(sel_sg, q=True), r=True)
def assignTriPlanarShader(objA, tX=None, tY=None, tZ=None):
shdNode, shdGrp, placement = createTriPlanarShader(txtX=tX, txtY=tY, txtZ=tZ)
pm.sets(shdGrp, edit=True, forceElement=objA)
pm.mel.eval("source AEplace3dTextureTemplate.mel;")
for i in placement:
try:
pm.mel.eval("PSfitPlacementToGroup %s;" % i.name())
except pm.MelUnknownProcedureError:
pass
def bs_shotBuild(epi, seq, shot, startTime, endTime, assetPaths):
"""
@
Args:
epi (str): episode name like "ep001"
seq (str): sequence name like "sq001"
shot (str): shot name like "sh001"
startTime (int): animation start time.
endTime (int): animation end time.
assetPaths (list): all assets path in list.
Returns:
None.
"""
# set current time and unit.
pm.currentUnit(time='pal')
pm.playbackOptions(ast=startTime,
aet=endTime,
maxTime=endTime,
minTime=startTime)
pm.currentTime(startTime)
# create Hierarchy.
shotGroup = pm.createNode('transform', n='shot_grp', ss=True)
charGroup = pm.createNode('transform', n='char_grp', ss=True)
propGroup = pm.createNode('transform', n='prop_grp', ss=True)
setGroup = pm.createNode('transform', n='set_grp', ss=True)
vehicleGroup = pm.createNode('transform', n='vehicle_grp', ss=True)
fxGroup = pm.createNode('transform', n='fx_grp', ss=True)
pm.parent(charGroup, propGroup, setGroup, vehicleGroup, fxGroup, shotGroup)
# import camera.
camFilePath = bs_pathGenerator.bs_getConfigPaths(
) + 'mayaFiles/shot_cam.ma'
bs_mayaFile.bs_importFile(camFilePath)
pm.parent('cam_grp', shotGroup)
# add attributes.
pm.addAttr(shotGroup, ln='bsw_episode', dt='string', k=True)
pm.addAttr(shotGroup, ln='bsw_sequence', dt='string', k=True)
pm.addAttr(shotGroup, ln='bsw_shot', dt='string', k=True)
pm.addAttr(shotGroup, ln='bsw_stage', dt='string', k=True)
# set Values.
pm.setAttr(shotGroup + '.bsw_episode', epi)
pm.setAttr(shotGroup + '.bsw_episode', l=True)
pm.setAttr(shotGroup + '.bsw_sequence', seq)
pm.setAttr(shotGroup + '.bsw_sequence', l=True)
pm.setAttr(shotGroup + '.bsw_shot', shot)
pm.setAttr(shotGroup + '.bsw_shot', l=True)
pm.setAttr(shotGroup + '.bsw_stage', 'lay')
pm.setAttr(shotGroup + '.bsw_stage', l=True)
# add assets sets in one categorized set.
pm.select(cl=True)
mainSet = pm.sets(n='Assets_Set')
charSet = pm.sets(n='Char_Set')
propSet = pm.sets(n='Prop_Set')
setSets = pm.sets(n='Set_Sets')
vehicleSets = pm.sets(n='Vehicle_Sets')
mainSet.addMembers([charSet, propSet, setSets, vehicleSets])
bs_referenceAssetsInCurrentShot(assetPaths)
def applyMatToSelection(pMaterial, pSelection):
shader = pm.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name="thisSurfaceShader")
pMaterial.outColor >> shader.surfaceShader
mySel = pm.ls(sl=True)
pm.sets(shader, edit=True, forceElement=pSelection)
def addMixer(self):
self.Mixer = pm.shadingNode('PxrLayerMixer',
asTexture=True,
n='MIX_' + self.TreeName)
pm.connectAttr(self.Mixer + '.pxrMaterialOut',
self.Shader + '.inputMaterial',
f=True)
pm.select(self.Mixer, r=True)
pm.sets(self.TreeSet, e=True, forceElement=True)
def listExsistingMaterialsInSets():
exsistingMaterials = []
Sets = pm.sets(GlobalNodeName, q=True)
for x in Sets:
list = pm.sets(x, q=True)
for y in list:
if pm.objectType(y) == 'PxrSurface':
exsistingMaterials.append(y)
return exsistingMaterials
def rig_crankshaft():
#cmds.file("/jobs/pennzoilPennzoilNaturalGas_5402237/build/piston/release/work/mayaScene/pistonBuild/vLatest/mayaScene_pistonBuild_vLatest.ma",
# i=True, type="mayaAscii", ignoreVersion=True,rpr="mayaScene_pistonBuild_vLatest",options="v=0",pr=True,loadReferenceDepth="all")
#setup variables for existing nodes
global_ctrl=pm.PyNode('global_CTRL')
global_loc=pm.PyNode('global_LOC')
crankshaft_ctrl = pm.PyNode('crankshaft_CTRL')
crankshaft_loc = pm.PyNode('crankshaft_LOC')
display_ctrl = mpc.rig_makeCtrlLabel('display')
#create piston controls
for piston in range(0,global_loc.numPistons.get()):
ctrl_offset = mpc.rig_ctrlDuplicate(crankshaft_ctrl, 'piston'+string.uppercase[piston]+'_mover')
weight_loc = pm.PyNode('weight%s_LOC'%string.uppercase[piston])
rod_loc = pm.PyNode('rod%s_LOC'%string.uppercase[piston])
head_loc = pm.PyNode('head%s_LOC'%string.uppercase[piston])
piston_loc = pm.PyNode('piston%s_LOC'%string.uppercase[piston])
if ctrl_offset[0]:
pm.delete( pm.parentConstraint(weight_loc, ctrl_offset[0] ) )
ctrl_offset[0].rx.set(90)
pm.parentConstraint(ctrl_offset[2], piston_loc, mo=True)
else:
pm.delete( pm.parentConstraint(weight_loc, ctrl_offset[1] ) )
pm.parentConstraint(ctrl_offset[2], piston_loc, mo=True)
mpc.rig_ctrlLock([ctrl_offset[1]], ['tx','ty','tz','rz','ry','sx','sy','sz','v'], setKeyable=False, lock=True)
mpc.rig_ctrlColor(ctrl_offset[1], 15)
#setup connections
pm.delete( pm.parentConstraint( crankshaft_ctrl.getParent(), crankshaft_loc ) )
pm.parentConstraint( crankshaft_ctrl, crankshaft_loc, mo=True )
#parent + create groups + lock down ctrls
grp_csr = pm.group(em=True,n='crankshaftRig_GRP')
grp_model = pm.group(em=True,n='model_GRP')
grp_nodes = pm.group(em=True,n='nodes_GRP')
grp_model.setParent(grp_csr)
grp_nodes.setParent(grp_csr)
global_ctrl.getParent().setParent(grp_csr)
global_loc.setParent(grp_nodes)
global_loc.visibility.set(0)
display_ctrl.getParent().setParent(global_ctrl)
display_ctrl.getParent().ty.set(pm.xform('headA_LOC', q=True , t=True, ws=True)[1])
mpc.rig_ctrlLock([crankshaft_ctrl], ['tx','ty','tz','rz','ry','sx','sy','sz','v'], setKeyable=False, lock=True)
pm.scaleConstraint( global_ctrl, grp_nodes, mo=True )
display_ctrl.addAttr('displayLocators', at='long', min=0,max=1, k=True)
display_ctrl.displayLocators.connect(global_loc.v, f=True)
if pm.objExists('pistons_lodA_GRP'):
pm.PyNode('pistons_lodA_GRP').setParent(grp_model)
#Create Sets
rp_set = mpc.rig_setsCreateHubSet([grp_csr], 'crankshaft', 'rigPuppet')
ac_set = mpc.rig_setsCreateHubSet(pm.ls('*CTRL'), 'crankshaft','animCurves')
gc_set = mpc.rig_setsCreateHubSet(pm.ls('*GEO'), 'crankshaft','geometryCache')
pm.delete('hubMayaScenePistonBuildSet')
pm.sets(rp_set, add=(ac_set, gc_set))
def matAsign(): # ASIGN MATERIAL FOR ALL OBJECTS
listAtrRoot = pm.ls('*.mtoa_constant_mMat')
listAtrRef = pm.ls('*:*.mtoa_constant_mMat')
listAtr = set(listAtrRef + listAtrRoot) # combine lists for REFERENCED and ROOT geo
for i in listAtr:
object = pm.PyNode(i.split('.')[0]) # Create object based on << mMat >>
ins = pm.ls(object, ap = 1, dag = 1 ) # select instances
if i.get():
if pm.objExists((i.get()+ 'SG')):
pm.sets((i.get()+ 'SG'), forceElement = ins)
def cbsTrans(*args, **kwargs):
sculptTrans = kwargs.setdefault('sculptTrans', pm.ls(sl=True)[0])# (string) The mesh to get the tweak edits extracted from
shape = kwargs.setdefault('shape') # (string) The shape node of the sculptTrans node
tweak = kwargs.setdefault('tweak') # (string) The tweak node that is going to be cleared
skin = kwargs.setdefault('skin') # (string) The skinCluster node that drives the base mesh
base = kwargs.setdefault('base') # (string) The base mesh for the character
#get some info
sculptTrans, shape, tweak, skin = gatherInfo(sculptTrans, shape, tweak, skin)
if not 'baseTransform' in pm.listAttr(sculptTrans, ud=True):
pm.error('This model has not been prepared for sculpting. If you accidentally started, simply run Clear Tweaks to extract what has been done')
if not base:
base = sculptTrans.baseTransform.get()
baseRef = sculptTrans.baseReference.get()
#turn off a couple things that might mess with things
pm.symmetricModelling(e=True, symmetry= False)
pm.softSelect(e=True, softSelectEnabled=False)
#first, let's unlock the guys from the old function
pm.lockNode(base, l=False)
pm.lockNode(sculptTrans, l=False)
pm.setAttr('%s.v'%base, True)
#extract from the sculpted shape
newShape = clearTweaks(base=base, tweak=tweak)
pm.delete(sculptTrans)
newOrig = pm.duplicate(base, n='%s_editReference'%base)[0]
pm.connectAttr(('%s.outMesh' %newOrig.getShapes()[1]), ('%s.inMesh' %newOrig.getShape()))
pm.select(cl=True)
deviation = False
for v in range(pm.polyEvaluate(base, v=True)):
refPos = pm.xform('%s.vtx[%i]'%(baseRef, v), q=True, t=True)
adjPos = pm.xform('%s.vtx[%i]'%(newOrig, v), q=True, t=True)
if not refPos == adjPos:
deviation=True
pm.move('%s.vtx[%i]' %(newShape, v), (refPos[0]-adjPos[0], refPos[1]-adjPos[1], refPos[2]-adjPos[2]), r=True)
pm.move('%s.vtx[%i]'%(base, v), (refPos[0]-adjPos[0], refPos[1]-adjPos[1], refPos[2]-adjPos[2]), os=True, r=True)
pm.select('%s.vtx[%i]' %(base, v), add=True)
if deviation:
pm.warning('It appears there were issues extracting from the mesh, steps have been taken to try and remedy, but unexpected results may occur')
#apply a texture to the new shape.
pm.select(newShape, r=True)
pm.sets('initialShadingGroup', e=True, forceElement=True)
pm.delete(newOrig, baseRef)
return newShape
def __mirrorShapes__(elts, across='x', direction='L_'):
if elts==None:
# get each element inside CONTROL
if pmc.objExists('CONTROLS'):
elts = pmc.sets('CONTROLS', query=True)
i=0
while i<len(elts):
if pmc.objectType(elts[i]) == 'objectSet':
elts.extend(pmc.sets(elts[i], query=True))
elts.pop(i)
i -= 1
i += 1
# delete element at center meaning without L_ or R_
for i in reversed(range(len(elts))):
if (elts[i].name().startswith(direction)==False):
elts.pop(i)
else:
vp.vPrint('No CONTROLS set funded', 1)
else:
# delete element at center meaning without L_ or R_
for i in reversed(range(len(elts))):
if (elts[i].name().startswith('L_')==False) and (elts[i].name().startswith('R_')==False):
elts.pop(i)
# creating the vector inverse depending on the across variable
if across=='x':
vectInverse = [-1,1,1]
if across=='y':
vectInverse = [1,-1,1]
if across=='z':
vectInverse = [1,1,-1]
# loop into each element
for elt in elts:
# finding the opposite transform
if elt.startswith('L_'):
eltInv = various.checkObj( elt.name().replace('L_', 'R_'), type=['transform', 'joint'] )
else:
eltInv = various.checkObj( elt.name().replace('R_', 'L_'), type=['transform', 'joint'] )
if eltInv:
# getting atoms from both element
atoms = various.getAtoms(elt, flat=False)
atomsInv = various.getAtoms(eltInv, flat=False)
# finding the smallest object just in case one has less atoms than the other
if len(atoms) > len(atomsInv):
size = len(atomsInv)
else:
size = len(atoms)
# working on each atoms
for i in range(size):
pmc.move(atomsInv[i], atoms[i].getPosition(space='world')*vectInverse, absolute=True)
def lowerBell(allCtrl):
lowerBellCtrls = []
lowerBellJoints = []
for dict_ in lowerBellLocs:
loc = dict_.keys()[0]
attrs = dict_.values()[0]
name = loc.split('_')[0]
loc = pm.PyNode(loc)
parentJoint = utils.placeXform(name=name + '_%s' % defines.BIND,
mtype='joint',
matrix=loc.getMatrix(worldSpace=True),
worldSpace=True)
parent = attrs['parent']
if parent:
parent = parent + '_%s' % defines.BIND
parentJoint.setParent(parent)
parentCtrl = InlineOffset(
parentJoint, controlRadius=1, controlShape='circle',
controlColor=attrs['color']).controls[0]
lowerBellCtrls.append(parentCtrl)
lowerBellJoints.append(parentJoint)
children = loc.listRelatives(children=True, type='transform')
for endloc in children:
endname = endloc.name().split('_')[0]
endjoint = utils.placeXform(
name=endname+'_%s'%defines.BIND,mtype='joint',
matrix=endloc.getMatrix(worldSpace=True),
worldSpace=True)
ikjoint = pm.duplicate(
parentJoint,
name=endname+'_%s'%(defines.IK+defines.JOINT.title()),
parentOnly=True)[0]
ikjoint = pm.PyNode(ikjoint)
ikjoint.setParent(parentJoint)
endjoint.setParent(ikjoint)
ik = IkSC(startJoint=ikjoint, endJoint=endjoint,
name=endname, controlColor=attrs['color'],
controlRadius=0.5)
lowerBellCtrls.extend(ik.controls)
ik.controls[0].getParent().setParent(parentJoint)
lowerBellJoints.append(endjoint)
pm.addAttr(allCtrl, longName='lowerBellCtrls',
attributeType='bool', defaultValue=True, keyable=True)
for ctrl in lowerBellCtrls:
allCtrl.lowerBellCtrls >> ctrl.visibility
ctrls.extend(lowerBellCtrls)
pm.sets(lowerBellCtrls,name='lowerBellCtrls')
return {'ctrls':lowerBellCtrls, 'joints':lowerBellJoints}
def makeIdSets(i=None):
if not i:
i = checkMaskLayers()
sel = pm.ls(sl=True)
pm.select(clear=True)
name = 'aiMask' + str(i)
rSet = pm.sets(n=name + '_red')
gSet = pm.sets(n=name + '_green')
bSet = pm.sets(n=name + '_blue')
pm.sets(rSet, gSet, bSet, n=name)
pm.select(sel)
return rSet, gSet, bSet
def delAllShaders(geos):
# 删除所有材质球
#
# 参数geos: 模型对象
try:
defaultShader = pm.PyNode("lambert1")
defaultSG = pm.PyNode("initialShadingGroup")
except:
defaultShader, defaultSG = pm.createSurfaceShader("lambert", name="lambert1")
pm.waitCursor(state=1)
pm.sets(defaultSG, forceElement=geos)
pm.mel.MLdeleteUnused()
pm.waitCursor(state=0)
def revertToLambert(cls, shader, textureSampler='.diffuseMapSampler', *args, **kwargs):
""" create lambert copies of all the cgfx shaders and connect the diffuse texture """
if pm.getAttr(shader+'.shader'):
diffuseTexNode = pm.connectionInfo(shader+textureSampler, sourceFromDestination=True)
lambert = pm.shadingNode('lambert', asShader=True, name='L_'+shader )
lambertSG = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name='L_'+shader+'SG' )
pm.connectAttr(lambert+'.outColor', lambertSG+'.surfaceShader', force=True)
if diffuseTexNode:
pm.connectAttr(diffuseTexNode, lambert+'.color', force=True)
pm.hyperShade(objects=shader)
pm.sets(lambertSG, edit=True, forceElement=True)
pm.select(clear=True)
def assignShader (cls, shader, objs, *args, **kwargs):
''' assign the shader to the list '''
shadingGroup = pm.connectionInfo(shader.outColor, dfs=True)
try:
shadingGroup = shadingGroup[0].split('.')[0]
except:
pm.warning('This Shader has no Shading Group')
if objs:
for obj in objs:
pm.select(obj, r=True)
pm.sets(shadingGroup, edit=True, forceElement=True)
pm.select(clear=True)
def updateHighlight(faces):
'''
faces - list of faces to add to shadingEngine
if None, just hide the mesh
TODO: implement different types of highlights, for
ik, fk, tweaks, etc
'''
# mesh = pm.PyNode('CT_mesh_hilight_shd')
sg = pm.PyNode('lambert3SG')
pm.sets(sg, add=faces)
pm.refresh()
def createRenderNode(self, nodeType=None):
log.debug("createRenderNode callback for renderer {0} with node: {1}".format(self.rendererName.lower(), nodeType))
if nodeType == "TheaMaterial":
mat = pm.shadingNode("TheaMaterial", asShader=True)
bsdf = pm.shadingNode("BasicBSDF", asShader=True)
bsdf.outColor >> mat.bsdf
shadingGroup = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name="{0}SG".format(mat))
mat.outColor >> shadingGroup.surfaceShader
return
mat = pm.shadingNode(nodeType, asShader=True)
shadingGroup = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name="{0}SG".format(mat))
mat.outColor >> shadingGroup.surfaceShader
def createStandIn(path=None):
if not pm.objExists('ArnoldStandInDefaultLightSet'):
pm.createNode("objectSet", name="ArnoldStandInDefaultLightSet", shared=True)
pm.lightlink(object='ArnoldStandInDefaultLightSet', light='defaultLightSet')
standIn = pm.createNode('aiStandIn', n='ArnoldStandInShape')
# temp fix until we can correct in c++ plugin
cmds.setAttr('%s.visibleInReflections' % standIn.name(), True)
cmds.setAttr('%s.visibleInRefractions' % standIn.name(), True)
pm.sets('ArnoldStandInDefaultLightSet', add=standIn)
if path:
standIn.dso.set(path)
return standIn
def assignShader(obj, shader, sg):
#给物体赋予材质球
#
#参数obj: 模型对象
#
#参数shader: 材质球对象
#
#参数sg: shadingEngine对象
#
#创建节点
pm.waitCursor(state=1)
pm.sets(sg, forceElement = obj)
pm.waitCursor(state=0)
return shader
def wrapped(self, *args, **kwargs):
# check if the module can be created
if not self.check:
vp.vPrint('missing or wrong data in module, skip building process', 1)
return False
# create hierarchy group
kwargs['hierarchy'] = arHierarchy.createHierarchy()
kwargs['framework'] = {
'CONTROLS': {},
'PICK': {},
}
#args.append(hierarchy, _work)
result = method(self, *args, **kwargs)
# unselect everything
pmc.select(clear=True)
if not result:
return result
# #
# Create Set #
# #
# loop per set
for elts in sorted(kwargs['framework']['CONTROLS'].keys()):
if elts == '':
pmc.sets(kwargs['hierarchy']['CONTROLS'], addElement=kwargs['framework']['CONTROLS'][elts])
else:
# create and fill the set
elt = elts.split('|')
set = pmc.sets(name=elt[-1])
pmc.sets(set, addElement=kwargs['framework']['CONTROLS'][elts])
# parent the set
if len(elt)==1:
pmc.sets(kwargs['hierarchy']['CONTROLS'], addElement=set)
else:
pmc.sets(elt[-2], addElement=set)
# unselect
pmc.select(clear=True)
return result
def addToSet( object_list, set_name ):
if not isinstance( object_list, tuple ) and not isinstance( object_list, list ):
object_list = [object_list]
if not pm.objExists( set_name ):
pm.select( cl=1 )
pm.sets( name=set_name )
sel_set = pm.PyNode( set_name )
sel_set.addMembers( object_list )
print "# Set", set_name, "includes:", ", ".join( [o.nodeName() for o in object_list] )
def innerTentacles(allCtrl, rootCtrl):
innerTentacleCtrls = []
pm.addAttr(allCtrl, longName='innerTentacleGeo',
attributeType='bool', defaultValue=True, keyable=True)
pm.addAttr(allCtrl, longName='innerTentacleCtrls',
attributeType='bool', defaultValue=True, keyable=True)
for dict_ in innerTentacleLocs:
group = dict_.keys()[0]
attrs = dict_.values()[0]
meshName = group.split('_')
name = meshName[0] + meshName[-1]
print "Building RibbonIK for", name
ribbon = RibbonIk(
startLoc = attrs['start_loc'],
endLoc = attrs['end_loc'],
name = name + "_ribbonIk",
numSpans = 9,
numJoints = 20)
print "Building Driver for", name
drivers = LinearSkin(
mesh = ribbon.ribbonIkPlane,
startLoc = attrs['start_loc'],
endLoc = attrs['end_loc'],
numControls = 6,
name = name,
controlColor = attrs['color'],
parent = attrs['parent'])
innerTentacleCtrls.extend(drivers.controls)
geoGrp = "%s%s" % (NAMESPACE,group)
geo = pm.listRelatives(geoGrp, children=True, path=True)
joints = [x.name() for x in ribbon.bindJoints]
for node in geo:
skinDict[NAMESPACE][skin.SMOOTH].update(
{node.name():joints})
ctrlGrp = pm.group(ribbon.ribbonIkPlane,
drivers.controls[0], name='%s_ctrlGrp' % group)
ribbon.follicleGrp.setParent(ctrlGrp)
ctrlGrp.setParent(rootCtrl.controls[0])
allCtrl.innerTentacleGeo >> pm.PyNode(NAMESPACE+group).visibility
for joint in ribbon.bindJoints:
allCtrl.innerTentacleCtrls >> joint.visibility
for ctrl in innerTentacleCtrls:
allCtrl.innerTentacleCtrls >> ctrl.visibility
ctrls.extend(innerTentacleCtrls)
pm.sets(innerTentacleCtrls,name="innerTentacleCtrls")
def create_cube_1():
mesh = OpenMaya.MFnMesh() #(1)
mesh.create( #(2)
len(vert_positions),
len(poly_counts ),
vert_pos_array,
poly_counts_array,
poly_conns_array
)
mesh.setUVs(uarray, varray) #(3)
mesh.assignUVs(poly_counts_array, poly_conns_array) #(4)
mesh.updateSurface() #(5)
pmc.sets(
'initialShadingGroup',
edit=True, forceElement=mesh.name()) #(6)
def _createSets(shaders=None):
''' Create partition and then sets from shaders.
Returns: list of set names '''
# Create main partition
#part = pm.partition(name='BlendRegionsPartition')
sets = []
for shader in shaders:
pm.select(_vertsFromShader(shader=shader),r=1)
setName = '%s_set'%shader
pm.sets(n=setName)
#pm.mel.eval('$createSetResult = `sets -name "%s" -em`;'%(setName) +\
# 'partition -e -addSet %s $createSetResult;'%(part) +\
# 'sets -edit -forceElement $createSetResult;')
sets.append(setName)
return sets
def __restorePosingRIG__(elts):
if elts==None:
# get each objects from rigShapesSet
if pmc.objExists('RIG_bindPose'):
elts = pmc.sets('RIG_bindPose', query=True)
fromSelection=False
else:
fromSelection=True
if elts:
for elt in elts:
if fromSelection:
if pmc.objExists(elt.name()+'_storedPos'):
obj = elt.name()+'_storedPos'
attrs = pmc.listAttr(elt, keyable=True)
for i in range(len(attrs)):
try:
pmc.PyNode(elt+'.'+attrs[i]).set(pmc.PyNode(obj+'.'+attrs[i]+'_stored').get())
except:
vp.vPrint('No data founded from %s in rigPosingSet set' % elt.name(), 1)
else:
vp.vPrint('Object %s doesn\'t exist' % (elt.name()+'_storedPos'), 1)
else:
if pmc.objExists(elt.name().replace('_storedPos', '')):
obj = pmc.PyNode(elt.name().replace('_storedPos', ''))
attrs = pmc.listAttr(obj, keyable=True)
for i in range(len(attrs)):
try:
pmc.PyNode(obj+'.'+attrs[i]).set(pmc.PyNode(elt+'.'+attrs[i]+'_stored').get())
except:
vp.vPrint('No data founded from %s in rigPosingSet set' % elt.name(), 1)
else:
vp.vPrint('Object %s doesn\'t exist' % elt.name().replace('_storedPos', ''), 1)
