示例#1
0
def create_deltaMush(bindGeo, iterations = [5, 10, 20, 30, 40]):

    smoothGeo = pm.duplicate( bindGeo, rr=True, ic=True, name=bindGeo.name() + "_smooth") [0]
    smoothGeo.addAttr("envelope", at='long', min=0, max=1, dv=1, k=True)
    smoothGeo.addAttr("partitions", at='message')

    deltaGeo = pm.duplicate( bindGeo, rr=True, ic=False, name="BS_" + bindGeo.name() + "_delta") [0]

    pm.select(deltaGeo, smoothGeo)
    pm.mel.eval("CreateWrap")
  
    smoothNodes = []
    smoothNodeSets = []
    for i in range(0, len(iterations)):
        smoothNode = pm.deformer([smoothGeo], type='smooth')[0]
        smoothNode.iterations.set(iterations[i])
        smoothGeo.envelope >> smoothNode.envelope
        smoothNodes.append(smoothNode)
          
           
        smoothNodeSet = smoothNode.message.listConnections()[0]
        smoothNodeSet.clear()
        smoothNodeSets.append(smoothNodeSet)

    for smoothNodeSet in smoothNodeSets:
        smoothNodeSet.clear()
    partition = pm.partition(smoothNodeSets)
    partition.message >> smoothGeo.partitions

    skinCls = bindGeo.getShape().listConnections(type='skinCluster')[0]    
    joints = skinCls.getInfluence()
    assign_iteration_set(joints, bindGeo, skinCls, deltaGeo)
示例#2
0
def aw_muscleShrinkWrap(source, meshes):
	'''Attaches muscle objects to the source then targets and makes them conform to its shape
		Args:
			source (pm.PyNode): source object to get shape from
			targets (pm.PyNode): target objects to conform
		Returns (pm.nt.CMuscleSystem): muscle object that is created
		Usage: 
			aw_muscleShrinkWrap(pm.ls(sl=True)[0], pm.ls(sl=True)[1:])
	'''
	#convert target to muscle
	pm.select(source, r=True)
	eval('cMuscle_makeMuscle(0)')
	#apply muscle skin deformer to source
	pm.select(meshes, r=True)
	eval('cMuscle_makeMuscleSystem(1)')
	#connect the two systems
	pm.select([source,meshes], r=True)
	eval('cMuscle_connectToSystem()')
	#get the system:
	pm.select(meshes, r=True)
	systems = eval('cMuscle_getSelectedDeformers("cMuscleSystem")')
	for system in systems:
		system=pm.PyNode(system)
		deformeds = pm.deformer(system, q=True, geometry=True)
		#print 'setting weights for muscle system: %s'%system
		#print deformeds
		#system.shrinkWrap.set(1)
		system.enableSliding.set(1)
		for deformed in deformeds:
			deformedVerts = pm.polyListComponentConversion(deformed,tv=True)
示例#3
0
def gear_curveslide2_op(outcrv,
                        incrv,
                        position=0,
                        maxstretch=1,
                        maxsquash=1,
                        softness=0):
    """Apply a sn_curveslide2_op operator

    Arguments:
        outcrv (NurbsCurve): Out Curve.
        incrv (NurbsCurve):  In Curve.
        position (float): Default position value (from 0 to 1).
        maxstretch (float): Default maxstretch value (from 1 to infinite).
        maxsquash (float): Default maxsquash value (from 0 to 1).
        softness (float): Default softness value (from 0 to 1).

    Returns:
        pyNode: The newly created operator.
    """
    pm.select(outcrv)
    node = pm.deformer(type="mgear_slideCurve2")[0]

    pm.connectAttr(incrv + ".local", node + ".master_crv")
    pm.connectAttr(incrv + ".worldMatrix", node + ".master_mat")

    pm.setAttr(node + ".master_length", pm.arclen(incrv))
    pm.setAttr(node + ".slave_length", pm.arclen(incrv))
    pm.setAttr(node + ".position", 0)
    pm.setAttr(node + ".maxstretch", 1)
    pm.setAttr(node + ".maxsquash", 1)
    pm.setAttr(node + ".softness", 0)

    return node
示例#4
0
def cMuscle_setupSystemforRelative(ms):
	shapes = pm.deformer(ms, q=True, geometry=True)
	if shapes:
		shape = shapes[0]
		rels = cMuscle_getDeformers('cMuscleRelative', shape)
		if len(rels) >= 1:
			rel = rels[0]
		else:
			rels = pm.deformer(shape, type='cMuscleRelative', frontOfChain=True)
		
		skins = cMuscle_getDeformers('skinCluster', shape)
		rel.point.connect(ms.relativePoint)
		ms.relativeSticky.set(1)
		msg = mel.eval('uiRes("m_cMuscle.kSetupMuscleSystemForRelativeStickyDeformation")')
		pm.format(msg, stringArg=ms.name())
		print msg
		return rel
示例#5
0
def deformerSwap(master):
	sel = pm.ls(sl=True)
	master = sel[0]
	deformers=[]
	deformer_types=[pm.nt.NonLinear]
	for connection in master.getShape().listConnections():
		for deformer_type in deformer_types:
			if isinstance(connection,deformer_type):
				deformers.append(connection)
	print deformers
	for obj in sel[1:]:
		for deformer in deformers:
			print obj.getShape().listConnections()
			if not deformer in obj.getShape().listConnections():
				try:
					pm.deformer(deformer, e=True, g=obj)
				except:
					pm.warning('something was up with the deformer %s for obj %s' % (deformer, obj))

#deformerSwap(pm.PyNode('engine_L_cap2L'))
示例#6
0
def shrinkWrapDeformer(wrappedObj, wrapperObj):
    """
    Apply ShrinkWrap Deformer on selected mesh
    :param wrappedObjs: str
    :param wrapperObj: str
    :return: deformer node
    """
    shrinkWrapNode = pm.deformer(wrappedObj, type='shrinkWrap')[0]
    pm.PyNode(wrapperObj).worldMesh[0] >> shrinkWrapNode.targetGeom
    shrinkWrapNode.closestIfNoIntersection.set(True)
    return shrinkWrapNode
def ContactDeformer():
    sel = pm.ls(sl=True)
    if len(sel) is 2:
        collider = sel[0]
        target = sel[1]
        collidershape = pm.listRelatives(collider, s=True)[0]
        collisiondeformer = pm.deformer(target, type="ContactDeform", n="collisionDeformer")[0]
        pm.connectAttr(collidershape.worldMesh[0], collisiondeformer.collider, f=True)
        pm.connectAttr(collider.matrix, collisiondeformer.colliderMatrix, f=True)
        pm.connectAttr(collider.boundingBoxSize, collisiondeformer.colliderBBoxSize, f=True)
    else:
        print("Please select two meshes: first the collider mesh then the mesh that should be deformed.")
def create_deltaMush(bindGeo, iterations=10):

    smoothGeo = pm.duplicate( bindGeo, rr=True, ic=True, name=bindGeo.name() + "_smooth") [0]
    deltaGeo = pm.duplicate( bindGeo, rr=True, ic=False, name=bindGeo.name() + "_delta") [0]

    pm.select(deltaGeo, smoothGeo)
    pm.mel.eval("CreateWrap")

    smoothNode = pm.deformer([smoothGeo], type='smoothSimple')[0]
    smoothNode.iterations.set(iterations)

    newBaseGeo = pm.duplicate( smoothGeo, rr=True, ic=False, name=bindGeo.name() + "_smoothBase") [0]
    
    wrapNode = deltaGeo.inMesh.listConnections()[0]
    swap_wrap_deformer_base(wrapNode, newBaseGeo)
示例#9
0
def cMuscle_prepareRelax(mesh):
	hist = pm.listHistory(mesh, pdo=True, il=1)
	muscleSystems = pm.ls(hist, type='cMuscleSystem')
	muscleSystems = list(set(muscleSystems))
	for ms in muscleSystems:
		deformed = pm.deformer(ms, q=True, geometry=True)[0]
		
		if deformed.type() in ['nurbsSurface', 'mesh', 'subdiv']:
			ms.envelope.set(0)
			a, size = 0, 0
			for attr in ['smoothData.smoothEntry','smoothData.ptToPtEntry','relaxData.relaxSt','relaxData.relaxBd','relaxData.relaxTri']:
				for index in range(0, ms.attr(attr).get(size=True)-1):
					pm.removeMultiInstance(ms.attr(attr)[index])
			
			pm.cMuscleRelaxSetup(ms, gen=True)
			ms.envelope.set(1)
示例#10
0
def cMuscleSystemDeformer(obj, relativeSticky=True):
    """
    Apply cMuscleSystem Deformer on selected mesh
    :param obj: str
    :return: deformer node
    """
    deformerNode = None

    if relativeSticky:
        pm.select(obj)
        d = mel.eval('cMuscle_makeMuscleSystem(1);')
        deformerNode = pm.ls(d)[0]
    else:
        deformerNode = pm.deformer(obj, type='cMuscleSystem')[0]

    return deformerNode
示例#11
0
def createWrap(driver, tgts, 
               threshold=0, maxDistance=50, inflType=2, 
               exclusiveBind=True, autoWeightThreshold=True, 
               falloffMode=0):
	'''
	Args:
		driver (pm.nt.Transform): driver object for the wrap
		tgts [pm.nt.Transform]: List of target objects
		threshold (float): look in the docs
		maxDistance (float): look in the docs
		inflType (int): look in the docs
		exclusiveBind (boolean): look in the docs
		autoweightThreshold (boolean): look in the docs
		falloffMode (int): look in the docs
	Returns {'wraps':[pm.nt.wrap], 'driver':[pm.nt.Transform, pm.nt.Transform]}:
			Dictionary with the wrap deformers and the driver/base objects
	Usage:
		createWrap(driver, tgts, 0, 50, 2, True, True, 0)
	'''
	wraps=[]
	base=None
	#create or use the existing base object
	driverName = driver.name()+'BASE'
	if not pm.objExists( driverName ):
		base = pm.duplicate(driver, rr=True, n=driverName)[0]
		base.visibility.set(0)
	else:
		base = pm.PyNode(driverName)

	for target in tgts:
		wrap = pm.deformer(target, type='wrap', n = '%s_WRAP'%driver )[0]
		wraps.append( wrap )
		
		wrap.weightThreshold.set( threshold )
		wrap.maxDistance.set( maxDistance )
		wrap.exclusiveBind.set( exclusiveBind )
		wrap.autoWeightThreshold.set( autoWeightThreshold )
		wrap.falloffMode.set( falloffMode )
		wrap.inflType[0].set( inflType )
		wrap.dropoff[0].set( 4 )

		target.getShape().worldMatrix[0].connect( wrap.geomMatrix, f=True )
		base.getShape().worldMesh.connect( wrap.basePoints[0], f=True )
		driver.getShape().worldMesh.connect( wrap.driverPoints[0], f=True )
	return {'wraps':wraps, 'driver':[driver, base]}
示例#12
0
def create_wrap_deformer(influence, deformed, **kwargs):
    '''
    Create a wrap deformer object

    :param influence: pymel.PyNode influence object
    :param deformed: pymel.PyNode deformed object
    :param kwargs: Wrap attribute values
    '''


    pm.select(deformed, replace=True)

    kwargs.setdefault('weightThreshold', 0.0)
    kwargs.setdefault('maxDistance', 1.0)
    kwargs.setdefault('exclusiveBind', False)
    kwargs.setdefault('autoWeightThreshold', True)
    kwargs.setdefault('falloffMode', 1)

    wrap = pm.deformer(type='wrap')[0]
    for k, v in kwargs.iteritems():
        wrap.attr(k).set(v)

    if not influence.hasAttr('dropoff'):
        influence.addAttr('dropoff', sn='dr', dv=4, min=0, max=20, k=True)
    if not influence.hasAttr('smoothness'):
        influence.addAttr('smoothness', sn='smt', dv=0, min=0, k=True)
    if not influence.hasAttr('inflType'):
        influence.addAttr('inflType', sn='ift', at='short', dv=2, min=1, max=2)

    influence.dropoff.connect(wrap.dropoff[0])
    influence.smoothness.connect(wrap.smoothness[0])
    influence.inflType.connect(wrap.inflType[0])

    influence_shape = influence.getShape(noIntermediate=True)
    influence_shape.worldMesh.connect(wrap.driverPoints[0])

    base = influence.duplicate(name=influence + 'Shape', rc=True)[0]
    base_shape = base.getShape(noIntermediate=True)
    base.hide()
    base_shape.worldMesh.connect(wrap.basePoints[0])

    deformed.worldMatrix.connect(wrap.geomMatrix)

    return wrap, base
示例#13
0
def gear_curvecns_op(crv, inputs=[]):
    """
    create mGear curvecns node.

    Args:
        crv (nurbsCurve): Nurbs curve.
        inputs (List of dagNodes): Input object to drive the curve. Should be same number as crv points.
            Also the order should be the same as the points

    Returns:
        pyNode: The curvecns node.
    """
    pm.select(crv)
    node = pm.deformer(type="mgear_curveCns")[0]

    for i, item in enumerate(inputs):
        pm.connectAttr(item + ".worldMatrix", node + ".inputs[%s]" % i)

    return node
示例#14
0
def WrapDeformer(SEL):
    BaseMod = SEL[0]
    TargetMod = SEL[1]
    #for Group selection
    duplicateData = pm.duplicate(BaseMod, name=BaseMod + 'Base')
    BaseModShape = BaseMod.getChildren()[0]
    wrapData = pm.deformer(TargetMod, type='wrap', n=TargetMod + '_wrap')
    wrapNode = wrapData[0]
    wrapNode.setAttr('weightThreshold', 0.0)
    wrapNode.setAttr('maxDistance', 1.0)
    wrapNode.setAttr('exclusiveBind', False)
    wrapNode.setAttr('autoWeightThreshold', True)
    wrapNode.setAttr('falloffMode', 0)
    TargetMod.worldMatrix[0] >> wrapNode.geomMatrix
    # add influence
    base = duplicateData[0]
    shapes = base.getChildren()
    baseShape = shapes[0]
    base.hide()
    # create dropoff attr if it doesn't exist
    if not pm.attributeQuery('dropoff', n=BaseMod, exists=True):
        pm.addAttr(BaseMod, sn='dr', ln='dropoff', dv=4.0, min=0.0, max=20.0)
        pm.setAttr(BaseMod + '.dr', k=True)
    # # if type mesh
    # if pm.nodeType(BaseModShape) == 'mesh':
    # create smoothness attr if it doesn't exist
    if not pm.attributeQuery('smoothness', n=BaseMod, exists=True):
        pm.addAttr(BaseMod, sn='smt', ln='smoothness', dv=0.0, min=0.0)
        pm.setAttr(BaseMod + '.smt', k=True)
    # create the inflType attr if it doesn't exist
    if not pm.attributeQuery('inflType', n=BaseMod, exists=True):
        pm.addAttr(BaseMod,
                   at='short',
                   sn='ift',
                   ln='inflType',
                   dv=2,
                   min=1,
                   max=2)
    BaseModShape.worldMesh >> wrapNode.driverPoints[0]
    baseShape.worldMesh >> wrapNode.basePoints[0]
    BaseMod.inflType >> wrapNode.inflType[0]
    BaseMod.smoothness >> wrapNode.smoothness[0]
    BaseMod.dropoff >> wrapNode.dropoff[0]
示例#15
0
def move_skin(source, target):
    source_shape = get_deform_shape(source)
    source_dp = get_dag_path(source_shape.longName())
    source_skin = get_skin_cluster(source)
    source_mfn = get_mfn_skin(source_skin)
    source_mesh = get_mfn_mesh(get_deform_shape(source))
    components = get_complete_components(source_mesh)

    weights, influence_count = source_mfn.getWeights(source_dp, components)

    pm.select(cl=True)
    target_skin = pm.deformer(target,
                              type='skinCluster',
                              n='MERGED__' + source_skin.name())[0]

    ## copy over input values / connections
    bind_inputs = [(x.inputs(plugs=True)[0] if x.isConnected() else None)
                   for x in source_skin.bindPreMatrix]
    bind_values = [x.get() for x in source_skin.bindPreMatrix]
    mat_inputs = [(x.inputs(plugs=True)[0] if x.isConnected() else None)
                  for x in source_skin.matrix]
    mat_values = [x.get() for x in source_skin.matrix]

    for index, bind_value, mat_value in zip(xrange(influence_count),
                                            bind_values, mat_values):
        target_skin.bindPreMatrix[index].set(bind_value)
        target_skin.matrix[index].set(mat_value)

    for index, bind_input, mat_input in zip(xrange(influence_count),
                                            bind_inputs, mat_inputs):
        if bind_input:
            bind_input >> target_skin.bindPreMatrix[index]
        if mat_input:
            mat_input >> target_skin.matrix[index]

    ## copy over weights
    target_mfn = get_mfn_skin(target_skin)
    target_mesh = get_mfn_mesh(get_deform_shape(target))
    target_dp = get_dag_path(get_deform_shape(target).longName())
    components = get_complete_components(target_mesh)
    all_indices = om2.MIntArray(range(influence_count))

    target_mfn.setWeights(target_dp, components, all_indices, weights)
示例#16
0
def create_poseDeformer(name, obj):
	'''Creates a deformer on an object
	Args:
		name (string): the name of the deformer
		obj (pm.PyNode): the object to apply to
	Returns (boolean): pm.nt.poseDeformer
	'''
	deformer = pm.deformer( obj, type='poseDeformer', n=name+'_POSD')[0]
	skinCluster = lib_sc.rig_getConnectedSkinCluster(obj)
	if skinCluster:
		influences = lib_sc.rig_getSkinClusterInfluences(skinCluster)
		i=0
		for influence in influences:
			influence.worldMatrix.connect( deformer.worldMatrix[i] )
			i+=1
		deformer.avgPoseSepRBF.set(30.0)
		return deformer
	else:
		pm.warning('No skinCluster detected attached to the mesh...not creating deformer %s on obj %s'%(name,obj))
示例#17
0
def apply_cage(target_mesh=None, cage_mesh=None):
    if not target_mesh or not cage_mesh:
        currently_selected = pm.selected()
        if len(currently_selected) != 2:
            warning('Select a target and cage mesh!')
            return None
        target_mesh, cage_mesh = currently_selected
    else:
        target_mesh = pm.PyNode(target_mesh)
        cage_mesh = pm.PyNode(cage_mesh)

    if not pm.pluginInfo('green_cage_deformer', loaded=True, query=True):
        pm.loadPlugin('green_cage_deformer')

    pm.select(target_mesh, r=True)
    cage_deformer = pm.deformer(type='green_cage_deformer')[0]
    cage_mesh.worldMesh[0] >> cage_deformer.cageMesh

    return cage_deformer
示例#18
0
def cMuscle_makeMuscleSystem(meshes, prompt):
	if len(meshes) <= 0:
		pm.warning('No meshes were provided...')
		return False
	
	for mesh in meshes:
		muscleDeformer = mesh.getShape().listConnections(s=True, d=False, type='cMuscleSystem')
		if len(muscleDeformer):
			pm.warning('Already have a muscle deformer on this mesh...')
			return False
		muscleDeformer = pm.deformer(mesh, type='cMuscleSystem')[0]
		pm.PyNode('time1').outTime.connect(muscleDeformer.inTime)
		
		path = pm.workspace(q=True, dir=True) + 'muscleCache/'
		if not os.path.exists(path):
			os.makedirs(path)
		
		muscleDeformer.cachePath.set(path+mesh+'.mus')
		
		for attr in ['STICKY','SLIDING','JIGGLE','DISPLACE','FORCE','RELAX','SMOOTH','COLLISION']:
			muscleDeformer.attr(attr).lock()
		
		#relax now
		cMuscle_prepareRelax(mesh)
		
		skins = cMuscle_getDeformers('skinCluster', mesh)
		
		if prompt and len(skins) >= 1:
			labelYes = mel.eval('uiRes("m_cMuscle.kYes")')
			labelYes = mel.eval('uiRes("m_cMuscle.kNo")')
			ret = pm.confirmDialog(t=mel.eval('uiRes("m_cMuscle.kSetupForRelativeDeformation")'),
			                       m=mel.eval('uiRes("m_cMuscle.kThisMeshAppearsToHaveSkinClusterApplied")'),
			                       button = [labelYes, labelNo],
			                       defaultButton = labelYes,
			                       cancelButton = labelNo,
			                       dismissString = labelNo)
			if ret == labelYes:
				cMuscle_setupSystemforRelative(muscleDeformer)
		
		msg = mel.eval('uiRes("m_cMuscle.kAddedDef")')
		print msg
		return muscleDeformer
 def wrapIt(self, *args):
     slMsh = cmds.ls(sl = True)
     mesh = []
     if len(slMsh) >=2:
         for each in slMsh:
             cmds.select(each, add=True )
         name = each+'_g'
         importedCombinedMesh = cmds.polyUnite( n=name )
         cmds.delete( importedCombinedMesh, ch = True )    
         mesh.append(name)
     else:
         for each in slMsh:
             cmds.select(each, add=True )            
             obj = cmds.ls(sl=True)
             print (obj)
             name = cmds.rename(obj[0], (each+'_g'))  
             mesh.append(name)  
     bbox = cmds.exactWorldBoundingBox(mesh[0])        
     x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(mesh[0])
     lowRes = mesh[0] + '_proxyGeo'
     proxymesh = cmds.polySphere(n = lowRes, subdivisionsX = 15, subdivisionsY = 15)
     print proxymesh
     xc = (x2 + x1) / 2.0
     yc = (y2 + y1) / 2.0
     zc = (z2 + z1) / 2.0
     xw = x2 - x1
     yw = y2 - y1
     zw = z2 - z1   
     cmds.move(xc, yc, zc, proxymesh)
     cmds.scale(xw, yw, zw, proxymesh) 
     shrinkWrapNode = pm.deformer(proxymesh, type='shrinkWrap')[0]
     pm.PyNode(name).worldMesh[0] >> shrinkWrapNode.targetGeom
     shrinkWrapNode.closestIfNoIntersection.set(True)   
     cmds.delete( proxymesh, ch = True )  
     cmds.select(clear = True)
     cmds.select(proxymesh[0]) 
     cmds.select(mesh[0], add = True)      
     self.copyPivot(mesh[0], proxymesh)
     return proxymesh[0]
示例#20
0
        plugin_fn.registerNode(CarpetRoll.TYPE_NAME, CarpetRoll.TYPE_ID,
                               CarpetRoll.creator, CarpetRoll.initialize,
                               ommpx.MPxNode.kDeformerNode)
    except:
        pm.displayError("Failed to register node {0}".format(
            CarpetRoll.TYPE_NAME))


def uninitializePlugin(plugin):

    plugin_fn = ommpx.MFnPlugin(plugin)
    try:
        plugin_fn.deregisterNode(CarpetRoll.TYPE_ID)
    except:
        pm.displayError("Failed to deregister node {0}".format(
            CarpetRoll.TYPE_NAME))


if __name__ == "__main__":

    pm.newFile(f=1)
    plugin_name = "E:/Maya/MayaAPI/Deforner/CarpetRoll.py"
    if pm.pluginInfo(plugin_name, q=1, loaded=True):
        pm.unloadPlugin(os.path.basename(plugin_name), f=True)
    pm.loadPlugin(plugin_name)
    pplane_transform, pplane_shape = pm.polyPlane()
    pplane_shape.subdivisionsWidth.set(20)
    pplane_shape.subdivisionsHeight.set(20)
    pm.select(pplane_transform)
    pm.deformer(type="CarpetRoll")
示例#21
0
def create_wrap_deformer(influence_mesh, target_mesh, **kwargs):
    """
    Ryan Roberts - Wrap Deformer
    rr_wrap.py
    Description:
        Ryan Robers created a simple function to create a wrap deformer.
        The wrap deformer needs a little more than the deform command to get working.
        Michael Clavan
        I wanted to have the function also return the deformer to the user.  So, my contributions are pretty minor.
        I converted the wrap deformer into a pynode object type pm.nt.Wrap.
        Scott Clary
        Converted maya.cmds to pymel code so that we can pass PyNodes into this method.
    """
    influence_shape = influence_mesh.getShape()

    # create wrap deformer
    weight_threshold = kwargs.get('weightThreshold', 0.0)
    max_distance = kwargs.get('maxDistance', 1.0)
    exclusive_bind = kwargs.get('exclusiveBind', False)
    auto_weight_threshold = kwargs.get('autoWeightThreshold', True)
    falloff_mode = kwargs.get('falloffMode', 0)

    wrap_node = pm.deformer(target_mesh, type='wrap')[0]

    wrap_node.weightThreshold.set(weight_threshold)
    wrap_node.maxDistance.set(max_distance)
    wrap_node.exclusiveBind.set(exclusive_bind)
    wrap_node.autoWeightThreshold.set(auto_weight_threshold)
    wrap_node.falloffMode.set(falloff_mode)
    target_mesh = target_mesh.getShape()
    target_mesh.worldMatrix[0].connect(wrap_node.geomMatrix)

    # add influence
    base = pm.duplicate(influence_mesh,
                        name='{0}Base'.format(influence_mesh))[0]
    base_shape = base.getShape()
    base_shape.visibility.set(False)

    def safe_add_attr(node, long_name, keyable=True, **kwargies):
        try:
            # if the attribute already exists, do nothing otherwise create it
            node.attr(long_name).exists()
        except AttributeError:
            node.addAttr(long_name, **kwargies)
            if keyable:
                node.attr(long_name).set(keyable=True)

    # create dropoff attr if it doesn't exist
    safe_add_attr(influence_mesh,
                  'dropoff',
                  shortName='dr',
                  defaultValue=4.0,
                  min=0.0,
                  max=20.0)

    # if type mesh
    if isinstance(influence_shape, pm.nt.Mesh):
        # create smoothness attr if it doesn't exist
        safe_add_attr(influence_mesh,
                      'smoothness',
                      shortName='smt',
                      defaultValue=0.0,
                      min=0.0)
        # create the inflType attr if it doesn't exist
        safe_add_attr(influence_mesh,
                      'inflType',
                      keyable=False,
                      shortName='ift',
                      attributeType='short',
                      defaultValue=2,
                      min=1,
                      max=2)

        influence_shape.worldMesh.connect(wrap_node.driverPoints[0])
        base_shape.worldMesh.connect(wrap_node.basePoints[0])
        influence_mesh.inflType.connect(wrap_node.inflType[0])
        influence_mesh.smoothness.connect(wrap_node.smoothness[0])

    if isinstance(influence_shape, pm.nt.NurbsCurve) or isinstance(
            influence_shape, pm.nt.NurbsSurface):
        # create the wrapSamples attr if it doesn't exist
        safe_add_attr(influence_mesh,
                      'wrapSamples',
                      shortName='wsm',
                      attributeType='short',
                      defaultValue=10,
                      min=1)

        influence_shape.ws.connect(wrap_node.driverPoints[0])
        base_shape.ws.connect(wrap_node.basePoints[0])
        influence_mesh.wsm.connect(wrap_node.nurbsSamples[0])

    influence_mesh.dropoff.connect(wrap_node.dropoff[0])

    return wrap_node, base_shape
示例#22
0
def wrap_create(*args,**kwargs):
    '''
    Args:
        *args [source (pm.nt.Transform), target (pm.nt.Transform)]: source and target objects
    Returns [pm.nt.Deformer, pm.nt.Transform]: resulting wrap deformer
    Usage:
        wrap_create(pm.ls(sl=True)[0],pm.ls(sl=True)[1])
    '''
    influence, surface = args[0], args[1]
    influenceShape = influence.listRelatives(shapes=True)[0]
    surfaceShape = pm.listRelatives(surface,shapes=True)[0]

    #create wrap deformer
    weightThreshold = kwargs.get('weightThreshold',0.0)
    maxDistance = kwargs.get('maxDistance',1.0)
    exclusiveBind = kwargs.get('exclusiveBind',False)
    autoWeightThreshold = kwargs.get('autoWeightThreshold',True)
    falloffMode = kwargs.get('falloffMode',0)
    attr_sets = [weightThreshold, maxDistance, exclusiveBind, autoWeightThreshold, falloffMode]
	
    wrapData = pm.deformer(surface, type='wrap')
    wrapNode = wrapData[0]
    
    pm.setAttr(wrapNode+'.weightThreshold',weightThreshold)
    pm.setAttr(wrapNode+'.maxDistance',maxDistance)
    pm.setAttr(wrapNode+'.exclusiveBind',exclusiveBind)
    pm.setAttr(wrapNode+'.autoWeightThreshold',autoWeightThreshold)
    pm.setAttr(wrapNode+'.falloffMode',falloffMode)
 
    pm.connectAttr(surface+'.worldMatrix[0]',wrapNode+'.geomMatrix')
    
    #add influence
    base = pm.duplicate(influence,name=influence+'Base')[0]
    baseShape = base.listRelatives(shapes=True)[0]
    baseShape.visibility.set(0)
    
    #create dropoff attr if it doesn't exist
    if not pm.attributeQuery('dropoff',n=influence,exists=True):
        pm.addAttr( influence, sn='dr', ln='dropoff', dv=4.0, min=0.0, max=20.0  )
        pm.setAttr( influence+'.dr', k=True )
    
    #if type mesh
    if pm.nodeType(influenceShape) == 'mesh':
        #create smoothness attr if it doesn't exist
        if not pm.attributeQuery('smoothness',n=influence,exists=True):
            pm.addAttr( influence, sn='smt', ln='smoothness', dv=0.0, min=0.0  )
            pm.setAttr( influence+'.smt', k=True )
 
        #create the inflType attr if it doesn't exist
        if not pm.attributeQuery('inflType',n=influence,exists=True):
            pm.addAttr( influence, at='short', sn='ift', ln='inflType', dv=2, min=1, max=2  )
 
        pm.connectAttr(influenceShape+'.worldMesh',wrapNode+'.driverPoints[0]')
        pm.connectAttr(baseShape+'.worldMesh',wrapNode+'.basePoints[0]')
        pm.connectAttr(influence+'.inflType',wrapNode+'.inflType[0]')
        pm.connectAttr(influence+'.smoothness',wrapNode+'.smoothness[0]')
 
    #if type nurbsCurve or nurbsSurface
    if pm.nodeType(influenceShape) == 'nurbsCurve' or pm.nodeType(influenceShape) == 'nurbsSurface':
        #create the wrapSamples attr if it doesn't exist
        if not pm.attributeQuery('wrapSamples',n=influence,exists=True):
            pm.addAttr( influence, at='short', sn='wsm', ln='wrapSamples', dv=10, min=1  )
            pm.setAttr( influence+'.wsm', k=True )
 
        pm.connectAttr(influenceShape+'.ws',wrapNode+'.driverPoints[0]')
        pm.connectAttr(baseShape+'.ws',wrapNode+'.basePoints[0]')
        pm.connectAttr(influence+'.wsm',wrapNode+'.nurbsSamples[0]')
 
    pm.connectAttr(influence+'.dropoff',wrapNode+'.dropoff[0]')
    
    return [wrapNode, base]
示例#23
0
import pymel.core as pymel

pymel.mel.eval('CreateWrap;')

pymel.deformer('pSphere2',type='wrap')

src = pymel.PyNode('src')

if not pymel.attributeQuery('influence', n=src, exists=True):
    src.addAttr('influence', keyable=True, defaultValue=2)
    
if not pymel.attributeQuery('smoothness', n=src, exists=True):
    src.addAttr('smoothness', keyable=True, defaultValue=0)

if not pymel.attributeQuery('dropoff', n=src, exists=True):
    src.addAttr('dropoff', keyable=True, defaultValue=0)
示例#24
0
def connectAlembic(alembicFile, roots, namespace=':'):
    """Connects alembic cache to an hierarchy

    # TODO: Currently blend shape is used and the process is messy and not reliable
    """
    # Read archive and find all deformed geometry
    meshTransforms = []
    excludeFilter = []
    for g in alembic_utils.listArchive(Abc.IArchive(str(alembicFile)),
                                       AbcGeom.IPolyMesh):
        tName = g.getParent().getName().split(':')[-1]
        gName = g.getName().split(':')[-1]
        # Determine what to import from alembic based on shape name and is deformations present
        if g.getSchema().isConstant() and not gName == tName + 'ShapeDeformed':
            excludeFilter.append(g.getParent().getFullName() + '/')
        else:
            meshTransforms.extend(
                pm.ls(namespace + ':' + tName, transforms=True))

    excludeFilter = ' '.join(excludeFilter)
    # Do alembic cache import
    with namespaceContext(namespace):
        # NOTE: Unlock reference transforms attributes if locked
        #       as alembic will automatically create connections for transforms in hierarchy below
        for c in roots + pm.listRelatives(
                roots, allDescendents=True, typ='transform'):
            for a in 'tx|ty|tz|sx|sy|sz|rx|ry|rz'.split('|'):
                getattr(c, a).__apimplug__().setLocked(False)

        pm.mel.AbcImport(
            str(preparePath(alembicFile).replace('\\', '/')),
            ct=[r.longName() for r in roots],
            excludeFilterObjects=excludeFilter,
            # HACK: Create deformed geometry to make out
            #       poly plug evaluate its data as there is a bug
            crt=True)

        # Connect alembic cache with blendShape on to target geometry
        for t in meshTransforms:
            if len(t.getShapes()) == 1:
                logger.warn('Failed to connect cache for {} '
                            'there is not deformed shape'.format(t.longName()))
                continue
            destinationMeshPlug = t.getShape().inMesh
            deformedShape = t.getShapes()[1]
            if deformedShape.inMesh.listConnections(p=1):
                sourceMeshPlug = deformedShape.inMesh.listConnections(p=1)[0]
            else:
                sourceMeshPlug = deformedShape.outMesh
                deformedShape.intermediateObject.set(1)
                for sp, dp in deformedShape.outputs(p=1, c=1):
                    if dp.node().nodeType() == 'shadingEngine':
                        sp.disconnect(dp)
            try:
                blendShape = pm.deformer(destinationMeshPlug.node(),
                                         type='blendShape',
                                         before=True)[0]
                pm.connectAttr(
                    sourceMeshPlug, blendShape.inputTarget[0].
                    inputTargetGroup[0].inputTargetItem[6000].inputGeomTarget)
                blendShape.weight[0].set(1)
            except Exception as e:
                logger.debug(
                    'Failed to connect cache for {} exception: {}'.format(
                        t.longName(), traceback.format_exc()))
                pass

        # NOTE: Force refresh
        # TODO: Can pm.refresh be used?
        pm.currentTime(pm.playbackOptions(q=True, animationStartTime=True) + 1)
        pm.currentTime(pm.playbackOptions(q=True, animationStartTime=True) - 1)

        alembicNodes = pm.ls(regex=re.escape(namespace) + ':.+',
                             typ='AlembicNode')
        # Geometry Cache is not static
        if alembicNodes:
            # NOTE: Delete shapes created by alembic
            #       as we connected outMeshData directly in too blend shape
            for i in alembicNodes[0].outPolyMesh.getArrayIndices():
                pm.delete(
                    pm.listConnections(alembicNodes[0].outPolyMesh[i],
                                       shapes=True,
                                       t='mesh'))
        return alembicNodes
示例#25
0
    def generateLODS(self):
        x = self.ui.selectedGeo_groupBox.title()
        x = (x.replace('Selected Mesh:  ', ''))
        fullPath = str(cmds.ls(x, long=True)[0])
        if fullPath:
            print fullPath
            obSl = fullPath
            if len(obSl) == 0:
                cmds.confirmDialog(
                    title='Error:',
                    message='No objects selected for polygon reduction')
            else:
                print('\n')
                cmds.select(obSl)
                lods = []
                LOD01_Val = []
                LOD02_Val = []
                LOD03_Val = []
                currentIndex = self.whatTab()
                print currentIndex
                if currentIndex == 0:
                    LOD1_Number = int(self.ui.LOD1_num.text())
                    LOD2_Number = int(self.ui.LOD2_num.text())
                    LOD3_Number = int(self.ui.LOD3_num.text())
                    LOD3_Number = int(self.ui.LOD3_num.text())
                    LOD01_Val.append(LOD1_Number)
                    LOD02_Val.append(LOD2_Number)
                    LOD03_Val.append(LOD3_Number)
                else:
                    LOD01_Percent = self.ui.LOD1_horizontalSlider.value()
                    LOD02_Percent = self.ui.LOD2_horizontalSlider.value()
                    LOD03_Percent = self.ui.LOD3_horizontalSlider.value()
                    currentMeshPolyGonCount = cmds.polyEvaluate(f=True)
                    print currentMeshPolyGonCount
                    LOD01_PolyPercent = (LOD01_Percent *
                                         currentMeshPolyGonCount) / 100
                    LOD02_PolyPercent = (LOD02_Percent *
                                         currentMeshPolyGonCount) / 100
                    LOD03_PolyPercent = (LOD03_Percent *
                                         currentMeshPolyGonCount) / 100
                    LOD01_Val.append(LOD01_PolyPercent)
                    LOD02_Val.append(LOD02_PolyPercent)
                    LOD03_Val.append(LOD03_PolyPercent)

                LOD0_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD0'))
                lods.append(LOD0_LOD)
                #print LOD01_Val,LOD02_Val,LOD03_Val
                if self.ui.LOD1_chkBox.isChecked():
                    LOD1_Num = LOD01_Val[0]
                    LOD1_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD1'))
                    self.genFunction(LOD1_LOD, LOD1_Num)
                    lods.append(LOD1_LOD)
                    print('"__LOD1"__LOD__generated__Successfully :~- ' +
                          str(LOD1_LOD))
                if self.ui.LOD2_chkBox.isChecked():
                    LOD2_Num = LOD02_Val[0]
                    LOD2_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD2'))
                    self.genFunction(LOD2_LOD, LOD2_Num)
                    lods.append(LOD2_LOD)
                    print('"__LOD2"__LOD__generated__Successfully :~- ' +
                          str(LOD2_LOD))
                if self.ui.LOD3_chkBox.isChecked():
                    LOD3_Num = LOD03_Val[0]
                    LOD3_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD3'))
                    self.genFunction(LOD3_LOD, LOD3_Num)
                    lods.append(LOD3_LOD)
                    print('"__LOD3"__LOD__generated__Successfully :~- ' +
                          str(LOD3_LOD))

                if self.ui.WRAP_chkBox.isChecked():
                    WRAP_Num = str(self.ui.wrap_comboBox.currentText())
                    print WRAP_Num
                    LOD5_LOD = cmds.CreatePolygonSoccerBall(n=obSl + '__LOD4')
                    newMesh = cmds.rename(LOD5_LOD, (obSl + '__LOD4'))
                    if WRAP_Num == '180':
                        cmds.polySmooth(newMesh, divisions=1)
                    if WRAP_Num == '720':
                        cmds.polySmooth(newMesh, divisions=2)
                    if WRAP_Num == '2880':
                        cmds.polySmooth(newMesh, divisions=3)
                    cmds.delete(newMesh, ch=True)
                    bbox = cmds.exactWorldBoundingBox(obSl)
                    x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(obSl)
                    xc = (x2 + x1) / 2.0
                    yc = (y2 + y1) / 2.0
                    zc = (z2 + z1) / 2.0
                    xw = x2 - x1
                    yw = y2 - y1
                    zw = z2 - z1
                    cmds.move(xc, yc, zc, newMesh)
                    cmds.scale(xw, yw, zw, newMesh)
                    shrinkWrapNode = pm.deformer(newMesh, type='shrinkWrap')[0]
                    pm.PyNode(obSl).worldMesh[0] >> shrinkWrapNode.targetGeom
                    shrinkWrapNode.closestIfNoIntersection.set(True)
                    cmds.delete(newMesh, ch=True)
                    cmds.select(clear=True)
                    cmds.select(newMesh)
                    cmds.select(obSl, add=True)
                    self.copyPivot()
                    lods.append(newMesh)
                if self.ui.BBOX_chkBox.isChecked():
                    print('make a bounding box')
                    cmds.select(obSl)
                    box = self.MakeCube()
                    newmeshBox = cmds.rename(box, (obSl + '__LOD5'))
                    lods.append(newmeshBox)
                    cmds.select(obSl)
                    cmds.select(newmeshBox, add=True)
                    self.copyPivot()
                cmds.select(clear=True)
                if lods == []:
                    pass
                else:
                    grp = (obSl + '__LOD_grp')
                    if cmds.objExists(grp):
                        pass
                    else:
                        lod_grp = cmds.group(n=grp, em=True)
                    print grp
                    for lod in lods:
                        print lod
                        cmds.parent(lod, grp)
                print('\n')
                cmds.inViewMessage(amg="LOD generated successfully",
                                   pos="botCenter",
                                   fade=True)
                print('Done')
        else:
            cmds.confirmDialog(
                title='Error:',
                message='No objects selected for polygon reduction')
示例#26
0
	
	#create root_j_manip
	root_j_manip = pm.circle(r = 1.3, nr = (0.0,1.0,0.0), n = 'root_j_manip', ch = False)[0]
	pm.select(cl = True)
	root_j_manip_grp = pm.group(root_j_manip, n = 'root_j_manip_grp')
	pm.select(cl = True)
	
	#constrain j to manip
	pm.parentConstraint(root_j_manip, root_j_grp , mo = True)
	pm.scaleConstraint(root_j_manip, root_j_grp , mo = True)
	pm.select(cl = True)
	

	#Create Deformer
	pm.select(sphereTrans, r = True)
	rbRollNode = pm.deformer(type = 'RbRoll')[0]
	pm.setAttr(rbRollNode.radius, 1.0)
	pm.select(cl = True)
	
	#create skincluster
	skincluster = pm.skinCluster( root_j, sphereTrans, foc = False)
	pm.select(cl = True)
	
	#create frameCache nodes
	frameCacheX = pm.createNode('frameCache')
	pm.select(cl = True)
	pm.rename(frameCacheX, 'frameCacheX')
	pm.select(cl = True)
	
	frameCacheZ = pm.createNode('frameCache')
	pm.select(cl = True)
def wrapDeformer(_HiRez=pm.selected(), _LoRez=pm.selected()):
    """
    Custom wrapDeformer
    Select target - HiRez first, then the source - LoRez
    @param Hirez: Target which will receive the wrap : str or selection
    @param Lorez: Source : str of selection   
    
    ## EXTERIOR CLASS BUILD
    #------------------------
    import adb_utils.Script__WrapDeformer as adbWrap
    reload(adbWrap)

    #or
    from adb_utils.Script__WrapDeformer import wrapDeformer              
    """
    ## Define Variable type
    if isinstance(_HiRez, str) and isinstance(_LoRez, str):
        print('a')
        HiRez = _HiRez
        LoRez = _LoRez

    elif len(_HiRez) == 2:
        print('b')
        HiRez = _HiRez[0]
        LoRez = _LoRez[1]

    else:
        print('c')
        HiRez = _HiRez
        LoRez = _LoRez

    ## get Orig node
    orig_node = adb.getShapeOrig(LoRez)
    if orig_node == None:
        cls = pm.cluster(LoRez)
        pm.delete(cls)
        orig_node = adb.getShapeOrig(LoRez)
        # raise RuntimeError("No 'Orig' Node for: {}".format(LoRez))

    ## Wrap Node creation
    pm.select(HiRez, r=True)
    pm.select(LoRez, add=True)
    wrapData = pm.deformer(HiRez,
                           name='{}_{}'.format(HiRez, 'wrap'),
                           type='wrap')[0]

    pm.PyNode(wrapData).maxDistance.set(1)
    pm.PyNode(wrapData).autoWeightThreshold.set(1)
    pm.PyNode(wrapData).exclusiveBind.set(0)
    pm.PyNode(wrapData).falloffMode.set(0)

    ## add custom attribute on LoRez mesh
    if adb.attrExist(LoRez, 'dropoff'):
        pass
    else:
        LoRez_node = adbAttr.NodeAttr([LoRez])
        LoRez_node.addAttr('dropoff', 4)
        LoRez_node.addAttr('smoothness', 0)
        LoRez_node.addAttr('inflType', 2)

    ## Connections
    (pm.PyNode(LoRez).getShape()
     ).worldMesh[0] >> pm.PyNode(wrapData).driverPoints[0]
    (pm.PyNode(HiRez).getShape()
     ).worldMatrix[0] >> pm.PyNode(wrapData).geomMatrix
    pm.PyNode(LoRez).dropoff >> pm.PyNode(wrapData).dropoff[0]
    pm.PyNode(LoRez).inflType >> pm.PyNode(wrapData).inflType[0]
    pm.PyNode(LoRez).smoothness >> pm.PyNode(wrapData).smoothness[0]
    pm.PyNode(orig_node).worldMesh[0] >> pm.PyNode(wrapData).basePoints[0]

    ## Clean Up)
    pm.PyNode(LoRez).v.set(0)

    sys.stdout.write('custom wrap deformer created \n')

    return wrapData


# wrapDeformer()
示例#28
0
import pymel.core as pm
import os

MAYA_APP_DIR = mel.eval('getenv ("MAYA_APP_DIR")')
pluginName = "dsAttractDeformer"

pm.newFile(f=1)
try:
    pm.unloadPlugin(pluginName)
except:
    pass
pm.loadPlugin(
    os.path.join(
        MAYA_APP_DIR,
        "scripts\dsNodes\dsAttractDeformer\plugins\{0}.py".format(pluginName)))
pm.openFile(os.path.join(
    MAYA_APP_DIR,
    "scripts\dsNodes\dsAttractDeformer\\tests\\dsAttractDeformerTest.ma"),
            f=1)

#### TEST ####
dsAttractDeformer = pm.deformer("pTorus1", typ="dsAttract")[0]
pm.connectAttr("sticky_CRVShape.local", dsAttractDeformer + ".inputShape")
pm.connectAttr("sticky_CRV.worldMatrix[0]", dsAttractDeformer + ".inputMatrix")