def mesh_uvToWorld(): '''{'path':'Polygons/EditMesh/mesh_uvToWorld( )ONLYSE', 'icon':':/mesh.svg', 'usage':""" #选择两个mesh物体,将第一个按uv匹配到第二个 $fun( )""", } ''' fromObj = cmds.ls(sl=True)[0] #'pPlane1' toObj = cmds.ls(sl=True)[1] #'pPlane2' iterVertex = om.MItMeshVertex(nameToNode(fromObj, old=True)) try: uv_util = om.MScriptUtil() uv_ptr = uv_util.asFloat2Ptr() uArray, vArray = [], [] posArray = [] while not iterVertex.isDone(): posArray.append(tuple(iterVertex.position(om.MSpace.kWorld))[:3]) iterVertex.getUV(uv_ptr) uArray.append(uv_util.getFloat2ArrayItem(uv_ptr, 0, 0)) vArray.append(uv_util.getFloat2ArrayItem(uv_ptr, 0, 1)) iterVertex.next() parName = cmds.particle()[1] cmds.goal(parName, g=toObj, w=1) cmds.setAttr(parName + '.goalSmoothness', 0) cmds.setAttr(parName + ".conserve", 0) startFrame = cmds.playbackOptions(q=True, min=True) cmds.setAttr(parName + ".startFrame", startFrame) cmds.currentTime(startFrame, e=True) parName = qm.qsEmit(object=parName, position=posArray, attributes=[("goalU", "floatValue", uArray), ("goalV", "floatValue", vArray)]) #cmds.setAttr(parName+".collide", 0) #cmds.setAttr(parName+".ignoreSolverGravity", 1) #cmds.setAttr(parName+".ignoreSolverWind", 1) #cmds.setAttr(parName+".drag", 0) #nculeus = cmds.listConnections(parName + '.nextState')[0] #startFrame = cmds.getAttr( nculeus+".startFrame") cmds.currentTime(startFrame, e=True) cmds.currentTime(int(startFrame + 1), e=True) targetPos = cmds.getParticleAttr(parName, at='position', array=True) targetPos = [ newom.MPoint(targetPos[i], targetPos[i + 1], targetPos[i + 2]) for i in range(0, len(targetPos), 3) ] fromMesh = newom.MFnMesh(nameToNode(fromObj)) fromMesh.setPoints(targetPos, newom.MSpace.kWorld) except: cmds.delete(cmds.listRelatives(parName, parent=True)) raise IOError('Got a error!') cmds.delete(cmds.listRelatives(parName, parent=True))
def simulation(object, target, conserve, weight): start = cmds.playbackOptions(min=True, query=True) end = cmds.playbackOptions(max=True, query=True) front = "{0}_temp_front_indicator".format(object) temp_cons = cmds.parentConstraint(object, target, n="temp_cons", maintainOffset=True) #temp_cons2 = cmds.parentConstraint(object , front, n = "temp_cons2",maintainOffset = True ) cmds.bakeResults(target, sb=1, t=(start, end), simulation=True) cmds.delete(temp_cons) temp_particle = cmds.particle(n="{0}_temp_particle".format(object), p=[0, 0, 0], c=conserve)[0] cmds.setAttr("{0}.particleRenderType".format(temp_particle), 4) #match position of particle to target matchTransform(temp_particle, target, True, True) #particle to move with target cmds.goal(temp_particle, g=target, w=weight) #partical will not be baked, a null need to creatge to transfer the animation data from particle to null target_control = cmds.spaceLocator( n="{0}_temp_target_control".format(object))[0] cmds.connectAttr("{0}.cachedWorldCentroid".format(temp_particle), '{0}.translate'.format(target_control)) object_parent = cmds.listRelatives(object, parent=True) if object_parent: cmds.parent(front, object_parent) new_constraint = cmds.aimConstraint(target_control, object, n="{0}_temp_aim".format(object), maintainOffset=True, worldUpType="object", worldUpObject=front) #new_constraint = cmds.aimConstraint(target_control, object , n = "{0}_temp_aim".format(object),maintainOffset = True,worldUpType = "scene") cmds.hide(target) cmds.hide(target_control)
def main_translate_logic(i): ## Create main logic ## cmds.spaceLocator(n = obj.goal_locator) cmds.matchTransform(obj.goal_locator, obj.list_objects[i], pos = True) objC = cmds.getAttr(obj.goal_locator + ".translate") cmds.nParticle(p = objC, n = obj.np_name, c = 1) cmds.goal(obj.np_name, w = obj.T_goal_weight, utr = 1, g = obj.goal_locator) cmds.parent(obj.goal_locator, obj.list_objects[i], r = True) # cmds.matchTransform(obj.goal_locator, obj.list_objects[i], pos = True) # cmds.duplicate(obj.goal_locator, rr = True, n = obj.goal_aim_locator) cmds.parent(obj.goal_aim_locator, w = True) cmds.connectAttr(obj.np_center, obj.goal_aim_locator_pos, f = True)
def translate_simulation(): ######## Need to remove obj.simState = obj.prefix_base_layer[1] obj.playback_range_initialization() obj.reset_range_time() obj.list_objects = cmds.ls(sl = True) obj.list_fixed = obj.list_objects[:] if (len(obj.list_objects) == 0): print obj.myError, "Need to select 1 or more objects" else: print obj.myMessage, "Selected {0} objects".format(len(obj.list_objects)) obj.setup_progressbar(len(obj.list_objects)) # start progress bar window obj.create_overlappy_layer() obj.replaceSymbols() for i in range(len(obj.list_fixed)): obj.main_set_names(i) #### Create main logic #### cmds.spaceLocator(n = obj.goal_locator) cmds.matchTransform(obj.goal_locator, obj.list_objects[i], pos = True) objC = cmds.getAttr(obj.goal_locator + ".translate") cmds.nParticle(p = objC, n = obj.np_name, c = 1) cmds.goal(obj.np_name, w = obj.T_goal_weight, utr = 1, g = obj.goal_locator) cmds.parent(obj.goal_locator, obj.list_objects[i], r = True) # cmds.matchTransform(obj.goal_locator, obj.list_objects[i], pos = True) # cmds.duplicate(obj.goal_locator, rr = True, n = obj.goal_aim_locator) cmds.parent(obj.goal_aim_locator, w = True) cmds.connectAttr(obj.np_center, obj.goal_aim_locator_pos, f = True) #### Layers, connections, baking, copy/paste #### obj.get_nonLocked_attributes(i) cmds.select(d = True) cmds.progressBar(obj.progressControl, edit = True, step = obj.progressBar_step_value) #### Select list in initial order, close progressbar #### for l in obj.list_objects: cmds.select (l, add = True) obj.close_progressbar() print obj.myMessage, obj.root_layer_name, "ends simulation" obj.simState = obj.prefix_base_layer[0]
def createParticleSystem_goal(): # Create a constant sized particle object following a deformed torus shape (using goal) cmds.file(new=True, force=True) # Create a torus, we will use it as goal xrez = 14 yrez = 8 goalTorus = cmds.polyTorus( r=1, sr=0.5, tw=0, sx=xrez, sy=yrez, ax=(0, 1, 0), cuv=1, ch=0)[0] # nParticle creation depends on an optoinVar value, make sure we use the default one cmds.optionVar( sv=("NParticleStyle","Points") ) # Emit a lot of particle, the actual number will be limited to the max particle attribute in the particleShape emitter = cmds.emitter(dx=1, dy=0, dz=0, sp=0.1, pos=(0, 5, 0),rate=2500)[0] particleSystem, particleSystemShape = cmds.nParticle(n="nParticle_test_goal") cmds.setAttr('%s.lfm' % particleSystemShape, 0) # live forever cmds.setAttr('%s.particleRenderType' % particleSystemShape, 7) # Blobby, to see radius cmds.setAttr('%s.maxCount' % particleSystemShape, xrez*yrez) # max count is the number of vertices on the torus cmds.connectDynamic( particleSystemShape, em=emitter) # Create Goal cmds.goal(particleSystem, w=1, utr=0, g=goalTorus); # Create Initial state to we start with the correct amount of particle # NOTE: When using this script in command line, the first frame is not correctly evaluated and the particleShape is empty # This doesn't happens in interactive maya for i in range(1, 10): cmds.currentTime(i) cmds.saveInitialState(particleSystemShape) cmds.currentTime(1) bend, bendHandle = cmds.nonLinear( goalTorus, type="bend", lowBound=-1, highBound=1, curvature=0) cmds.setAttr( "%s.rotateZ" % bendHandle, 90) cmds.setKeyframe( "%s.curvature" % bend, v=0, t=1, inTangentType="flat", outTangentType="flat") cmds.setKeyframe( "%s.curvature" % bend, v=-130, t=12, inTangentType="flat", outTangentType="flat") cmds.setKeyframe( "%s.curvature" % bend, v=130, t=24, inTangentType="flat", outTangentType="flat") # Make the bend animation loop cmds.setInfinity( bend, poi="oscillate", attribute="curvature") return particleSystem, particleSystemShape
def createParticleSystem_goal(): # Create a constant sized particle object following a deformed torus shape (using goal) cmds.file(new=True, force=True) # Create a torus, we will use it as goal xrez = 14 yrez = 8 goalTorus = cmds.polyTorus(r=1, sr=0.5, tw=0, sx=xrez, sy=yrez, ax=(0, 1, 0), cuv=1, ch=0)[0] # nParticle creation depends on an optoinVar value, make sure we use the default one cmds.optionVar(sv=("NParticleStyle", "Points")) # Emit a lot of particle, the actual number will be limited to the max particle attribute in the particleShape emitter = cmds.emitter(dx=1, dy=0, dz=0, sp=0.1, pos=(0, 5, 0), rate=2500)[0] particleSystem, particleSystemShape = cmds.nParticle(n="nParticle_test_goal") cmds.setAttr('%s.lfm' % particleSystemShape, 0) # live forever cmds.setAttr('%s.particleRenderType' % particleSystemShape, 7) # Blobby, to see radius cmds.setAttr('%s.maxCount' % particleSystemShape, xrez * yrez) # max count is the number of vertices on the torus cmds.connectDynamic(particleSystemShape, em=emitter) # Create Goal cmds.goal(particleSystem, w=1, utr=0, g=goalTorus); # Create Initial state to we start with the correct amount of particle # NOTE: When using this script in command line, the first frame is not correctly evaluated and the particleShape is empty # This doesn't happens in interactive maya for i in range(1, 10): cmds.currentTime(i) cmds.saveInitialState(particleSystemShape) cmds.currentTime(1) bend, bendHandle = cmds.nonLinear(goalTorus, type="bend", lowBound=-1, highBound=1, curvature=0) cmds.setAttr("%s.rotateZ" % bendHandle, 90) cmds.setKeyframe("%s.curvature" % bend, v=0, t=1, inTangentType="flat", outTangentType="flat") cmds.setKeyframe("%s.curvature" % bend, v=-130, t=12, inTangentType="flat", outTangentType="flat") cmds.setKeyframe("%s.curvature" % bend, v=130, t=24, inTangentType="flat", outTangentType="flat") # Make the bend animation loop cmds.setInfinity(bend, poi="oscillate", attribute="curvature") return particleSystem, particleSystemShape
def nparticle_locators(selection): n_locator_offsets = [] n_locators = [] n_particles = [] nucleus = None for index, transform in enumerate(selection): print transform init_pos = cmds.xform(transform, query=True, translation=True, ws=True) n_particle = cmds.nParticle(p=init_pos, name="particle_{}_{}".format( transform, index)) n_locator_offset = cmds.createNode( "transform", name='n_locator_offset_{}'.format(index)) n_locator = cmds.spaceLocator(name='n_locator_{}'.format(index)) cmds.parent(n_locator, n_locator_offset) nucleus = cmds.listConnections("{}.startFrame".format(n_particle[1]), source=True, type='nucleus', scn=True) cmds.setAttr("{}.gravity".format(nucleus[0]), 0) cmds.setAttr("{}.particleRenderType".format(n_particle[1]), 3) cmds.goal(n_particle[1], goal=transform, utr=True) cmds.connectAttr("{}.worldCentroid".format(n_particle[1]), "{}.translate".format(n_locator_offset)) n_locator_offsets.append(n_locator_offset) n_locators.append(n_locator[0]) n_particles.append(n_particle[0]) setup_group = cmds.createNode('transform', name='setup_group') cmds.parent(n_locator_offsets, n_particles, nucleus, setup_group) return n_locator_offsets, n_particles, nucleus, setup_group, n_locators
def main_rotate_logic(i): #### Create main logic #### if obj.aim_vector_reverse: obj.rotAimVector = -1 else: obj.rotAimVector = 1 ## Create locators ## cmds.spaceLocator(n = obj.base_locator) cmds.matchTransform(obj.base_locator, obj.list_objects[i], pos = True, rot = True) cmds.aimConstraint(obj.list_objects[i+1], obj.base_locator, w = 1, aim = (0, 1, 0), u = (0, 1, 0), wut = "vector", wu = (0, 0, 1)) cmds.delete(obj.base_locator + "_aimConstraint1") cmds.duplicate(obj.base_locator, n = obj.base_aim_locator) cmds.parent(obj.base_aim_locator, obj.base_locator, a = True) cmds.duplicate(obj.base_aim_locator, n = obj.offset_aim_locator) cmds.parentConstraint(obj.list_objects[i], obj.base_locator, mo = True, w = 1) cmds.spaceLocator(n = obj.goal_locator) cmds.matchTransform (obj.goal_locator, obj.list_objects[i + 1], pos = True, rot = True) cmds.parentConstraint(obj.list_objects[i + 1], obj.goal_locator, mo = True, w = 1) cmds.spaceLocator(n = obj.goal_aim_locator) ## Create particle and nucleus ## goal_position = cmds.getAttr(obj.goal_locator + ".translate") cmds.nParticle(p = goal_position, n = obj.np_name, c = 1) cmds.goal(obj.np_name, w = obj.T_goal_weight, utr = 1, g = obj.goal_locator) ## Create connections ## cmds.connectAttr(obj.np_center, obj.goal_aim_locator_pos, f = True) cmds.aimConstraint(obj.goal_aim_locator, obj.base_aim_locator, w = 1, aim = (0, obj.rotAimVector, 0), u = (0, 1, 0), wut = "vector", wu = (0, 1, 0), sk = "y") cmds.parentConstraint(obj.base_aim_locator, obj.offset_aim_locator, mo = True, st=["x","y","z"], w = 1)
def createParticleBucket(self,emitSurface,dressType,ptcCount): '''creates a particle system named after the surface that the particles emit from returns the emitter, particles, instancer created. This proc also builds the initial expressions that a modified by the UI''' firstFrame = cmds.playbackOptions( query = True, minTime = True ) print ("creating a new particle for ") #TODO build a data class that is easily edited outside the script to set #these default settings if dressType == 'all': emitSurfaceName = emitSurface + "_Dress" scaleMin = str(self.ptcMin) scaleMax = str(self.ptcMax) emitterName = emitSurfaceName +"_Emitter" ptcBktName = emitSurfaceName + "_Particles" insterName = emitSurfaceName + "_Instancer" cmds.select(emitSurface) #create the emitter emitter = cmds.emitter(type = 'surface', r=1000, nuv=True,spd = 0.01, sro = False, cye = 'none', cyi = 0, sp = 0, n = emitterName ) #create the particles emitSurfPtcs = cmds.particle( c = 1.0, name = ptcBktName ) cmds.goal(emitSurfPtcs, w=1,utr=0,g = emitSurface) emitSurfPtcsShape = emitSurfPtcs[-1] #add the per particle attributes cmds.select(emitSurfPtcsShape) #instance selection cmds.addAttr( ln ='indexPP',dt = 'doubleArray') #random scaling cmds.addAttr( ln ='scalePP',dt = 'vectorArray') #rotation vector around X axis based on surface normal cmds.addAttr( ln ='surfRotOffPP',dt = 'vectorArray') cmds.addAttr( ln ='surfRotPP',dt = 'vectorArray') #user specificied aim & user specified aim rotation around aim #not used in the example but can be leveraged for different behavior cmds.addAttr( ln ="aimVectorPP",dt = 'vectorArray') cmds.addAttr( ln ="aimRotOffPP",dt = 'vectorArray') cmds.addAttr( ln ="aimRotPP",dt = 'vectorArray') #Goal UV based attrs cmds.addAttr( ln ='goalWorldNormal0PP',dt = 'vectorArray') cmds.addAttr( ln ='goalU',dt = 'doubleArray') cmds.addAttr( ln ='goalU0',dt = 'doubleArray') cmds.addAttr( ln ='goalV',dt = 'doubleArray') cmds.addAttr( ln ='goalV0',dt = 'doubleArray') cmds.addAttr( ln ='parentU',dt = 'doubleArray') cmds.addAttr( ln ='parentU0',dt = 'doubleArray') cmds.addAttr( ln ='parentV',dt = 'doubleArray') cmds.addAttr( ln ='parentV0',dt = 'doubleArray') #custom attrs from the UI that change how the system behaves cmds.addAttr( ln = 'scaleMin', at ='double') cmds.addAttr( ln = 'scaleMax', at ='double') cmds.addAttr( ln = 'dressType', dt = 'string') cmds.addAttr( ln = 'randSeed', at = 'long') #update the attrs cmds.setAttr(emitSurfPtcsShape+'.scaleMin', float(scaleMin)) cmds.setAttr(emitSurfPtcsShape+'.scaleMax', float(scaleMax)) cmds.setAttr(emitSurfPtcsShape+'.dressType', str(dressType), typ = 'string') cmds.setAttr(emitSurfPtcsShape+'.seed[0]', random.randrange(100, 360,1)) cmds.setAttr(emitSurfPtcsShape+'.randSeed', random.randrange(100, 360,1)) cmds.setAttr(emitSurfPtcsShape+".maxCount",int(ptcCount)) cmds.setAttr(emitSurfPtcsShape+".startFrame", firstFrame) #return what was created return (emitSurface,emitter,emitSurfPtcs,emitSurfPtcsShape,insterName)
def create_jiggle_locator(position_object, base_name): """Create jiggle rig at the specified postion, you will then need to make sure this jiggle rig is hooked up to be driven by the source rig Usage: create_jiggle_locator('ball', 'my_jiggle') """ if cmds.objExists(position_object): # Get position of input object pos = cmds.xform(position_object, q=True, ws=True, t=True) # Create single particle part = cmds.particle(p=[pos[0], (pos[1]), pos[2]], c=1, name='{}_particle'.format(base_name)) cmds.setAttr("{}.particleRenderType".format(part[1]), 4) # Goal particle to source object cmds.goal(part[0], goal=position_object, w=0.5, utr=True) # Create output transform jiggle_output = cmds.spaceLocator(name="{}_ctl".format(base_name))[0] cmds.connectAttr("{}.worldCentroid".format(part[1]), '{}.translate'.format(jiggle_output)) # Create jiggle control for attr in ['rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']: cmds.setAttr('{}.{}'.format(jiggle_output, attr), k=False, lock=True) # Add gravity grav = \ cmds.gravity(name='{}_gravity'.format(base_name), pos=[0, 0, 0], m=100, att=0, dx=0, dy=-1, dz=0, mxd=-1)[ 0] # , vsh=none -vex 0 -vof 0 0 0 -vsw 360 -tsr 0.5 ; cmds.connectDynamic(part, f=grav) # Add attrs: isDynamic=on, conserve=1.0, goalWeight[0]=1.0, goalSmoothness=3, gravity=9.8 cmds.addAttr(jiggle_output, ln="JIGGLE", at="enum", en="__:") cmds.setAttr('{}.JIGGLE'.format(jiggle_output), cb=True) # Enabled cmds.addAttr(jiggle_output, ln="enabled", at="bool") cmds.setAttr('{}.enabled'.format(jiggle_output), k=True, l=False) cmds.setAttr('{}.enabled'.format(jiggle_output), 1) cmds.connectAttr('{}.enabled'.format(jiggle_output), '{}.isDynamic'.format(part[1])) # Dynamics Weight """ cmds.addAttr(jiggle_output, ln="dynamicsWeight", at="double", min=0, max=1, dv=1) cmds.setAttr('{}.dynamicsWeight'.format(jiggle_output), k=True, l=False) cmds.connectAttr('{}.dynamicsWeight'.format(jiggle_output), '{}.dynamicsWeight'.format(part[1])) """ # Conserve cmds.addAttr(jiggle_output, ln="conserve", at="double", min=0, max=1, dv=1) cmds.setAttr('{}.conserve'.format(jiggle_output), k=True, l=False) cmds.connectAttr('{}.conserve'.format(jiggle_output), '{}.conserve'.format(part[1])) # Goal Smoothness cmds.addAttr(jiggle_output, ln="goalSmoothness", at="double", min=0, dv=3) cmds.setAttr('{}.goalSmoothness'.format(jiggle_output), k=True, l=False) cmds.connectAttr('{}.goalSmoothness'.format(jiggle_output), '{}.goalSmoothness'.format(part[1])) # Goal Weight cmds.addAttr(jiggle_output, ln="goalWeight", at="double", min=0, max=1.0, dv=.5) cmds.setAttr('{}.goalWeight'.format(jiggle_output), k=True, l=False) cmds.connectAttr('{}.goalWeight'.format(jiggle_output), '{}.goalWeight[0]'.format(part[1])) cmds.addAttr(jiggle_output, ln="GRAVITY", at="enum", en="__:") cmds.setAttr('{}.GRAVITY'.format(jiggle_output), cb=True) # Gravity cmds.addAttr(jiggle_output, ln="gravityMagnitude", at="double", min=0, dv=100) cmds.setAttr('{}.gravityMagnitude'.format(jiggle_output), k=True, l=False) cmds.connectAttr('{}.gravityMagnitude'.format(jiggle_output), '{}.magnitude'.format(grav)) # Gravity Direction cmds.addAttr(jiggle_output, ln="gravityDirection", at="double3") cmds.addAttr(jiggle_output, ln="gravityDirectionX", at="double", p="gravityDirection", dv=0) cmds.addAttr(jiggle_output, ln="gravityDirectionY", at="double", p="gravityDirection", dv=-1) cmds.addAttr(jiggle_output, ln="gravityDirectionZ", at="double", p="gravityDirection", dv=0) cmds.setAttr('{}.gravityDirection'.format(jiggle_output), k=True, l=False) cmds.setAttr('{}.gravityDirectionX'.format(jiggle_output), k=True, l=False) cmds.setAttr('{}.gravityDirectionY'.format(jiggle_output), k=True, l=False) cmds.setAttr('{}.gravityDirectionZ'.format(jiggle_output), k=True, l=False) cmds.connectAttr('{}.gravityDirectionX'.format(jiggle_output), '{}.directionX'.format(grav)) cmds.connectAttr('{}.gravityDirectionY'.format(jiggle_output), '{}.directionY'.format(grav)) cmds.connectAttr('{}.gravityDirectionZ'.format(jiggle_output), '{}.directionZ'.format(grav)) # Cleanup jiggle_group = cmds.group(empty=True, name="{}All_grp".format(base_name)) cmds.parent(part[0], jiggle_output, grav, jiggle_group) cmds.select(jiggle_output) return jiggle_output
def set_goals(): sel = cmds.ls(sl=True, l=True) # make sure we have at least two items if len(sel) < 2: print 'Please select a nParticle system followed by the objects to set as goals' return elif len(sel) > 2: print 'For inital goal we want one particle system and one object to goal!' print 'Try again :)' return print sel # from the list make sure the first object is a nparticle system, get a handle on this # then remove from the list if not cmds.objectType(sel[0]) == 'nParticle': shape = cmds.listRelatives(sel[0])[0] if not cmds.objectType(shape) == 'nParticle': print 'Please select a nParticle system followed by objects to goal to!' return else: npSystem = sel.pop(0) npShape = shape else: npShape = sel.pop(0) npSystem = cmds.listRelatives(npShape, parent=True, f=True) obj = sel[0] selList = om.MSelectionList() selList.add(npShape) npDag = om.MDagPath() npMObj = om.MObject() selList.getDependNode(0, npMObj) selList.getDagPath(0, npDag) npNode = om.MFnDependencyNode(npMObj) npFnPart = omfx.MFnParticleSystem(npDag) if _get_goal(npDag): print 'Particle system already has goal. For now we are only supporting one goal!' return cmds.goal(npSystem, g=obj, w=1) set_initial_state(npNode, npFnPart) print '#------------------------------#' creation_dynExpression = ('.goalV = 0;\n' '.goalU = 0;\n' '.goalWeight0PP = .2;\n' '.verticalSpeedPP = rand(0.01, 0.1);\n' '.rotationRatePP = rand(0.03, 0.05);\n' '.jitterIntervalPP = 0;\n' '.jitterStepPP = 0;\n' '.jitterRangePP = 0;\n' '.lifespanPP = 5;') runtime_dynExpression = ('.goalV += .verticalSpeedPP;\n' '.goalU += .rotationRatePP;\n\n' 'if (.jitterIntervalPP > .jitterStepPP)\n' '{\n' '\t.jitterStepPP ++;\n' '}\n' 'else\n' '{\n' '\t.goalU += .jitterValuePP;\n' '\t$hiRange = rand(0, .jitterRangePP);\n' '\t$loRange = $hiRange * -1;\n' '\t.jitterValuePP = rand($loRange, $hiRange);\n' '\t.jitterStepPP = 0;\n' '}\n\n' 'if (.goalU > 1)\n' '{\n' '\t.goalU -= 1;\n' '}\n' 'else if(.goalU < 0)\n' '{\n' '\t.goalU += 1;\n' '}') cmds.dynExpression(npShape, creation=True, string=creation_dynExpression) cmds.dynExpression(npShape, rbd=True, string=runtime_dynExpression) # now we want to make our goal object a passive rigid body so that # the particles don't go through it cmds.select(obj) print 'Selection is: %s' % cmds.ls(sl=True) # make our goal object a passive rigid body so the particles # can collide with it cmd = 'makeCollideNCloth' rigidShape = mel.eval(cmd) # rigid shape is not created if it already exists! if rigidShape: # parent the rigid body to keep things tidy nRigid = cmds.listRelatives(rigidShape[0], parent=True, f=True) #cmds.parent(nRigid, dynamics_grp) # select our particle system to tidy things up cmds.select(npSystem)
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 doIt(self, args): # Procesar argumentos try: self.parseArgs(args) except Exception as e: print('[' + commandName + '] Sintaxis de flag invalida') return # Guardar seleccion de la superficie surface = cmds.ls(sl=True) ################################# Control maestro ############################### cmds.spaceLocator(name=self.controllerName) cmds.addAttr(ln='floor', at='double', defaultValue=self.floor) cmds.addAttr(ln='beginTolerance', at='double', defaultValue=0.3, minValue=0, maxValue=1) cmds.addAttr(ln='gravity', at='double', defaultValue=self.gravity) cmds.addAttr(ln='magnitudeTLow', at='double', defaultValue=self.turbulenceLow) cmds.addAttr(ln='magnitudeTHigh', at='double', defaultValue=self.turbulenceHigh) cmds.addAttr(ln='dewRate', at='double', defaultValue=self.dewRate, minValue=0) cmds.addAttr(ln='spumeRate', at='double', defaultValue=self.spumeRate, minValue=0) cmds.addAttr(ln='waterRate', at='double', defaultValue=self.waterRate, minValue=0) cmds.setAttr(self.controllerName + '.translateX', keyable=False) cmds.setAttr(self.controllerName + '.translateY', keyable=False) cmds.setAttr(self.controllerName + '.translateZ', keyable=False) cmds.setAttr(self.controllerName + '.rotateX', keyable=False) cmds.setAttr(self.controllerName + '.rotateY', keyable=False) cmds.setAttr(self.controllerName + '.rotateZ', keyable=False) cmds.setAttr(self.controllerName + '.scaleX', keyable=False) cmds.setAttr(self.controllerName + '.scaleY', keyable=False) cmds.setAttr(self.controllerName + '.scaleZ', keyable=False) cmds.setAttr(self.controllerName + '.floor', keyable=True) cmds.setAttr(self.controllerName + '.beginTolerance', keyable=True) cmds.setAttr(self.controllerName + '.gravity', keyable=True) cmds.setAttr(self.controllerName + '.magnitudeTLow', keyable=True) cmds.setAttr(self.controllerName + '.magnitudeTHigh', keyable=True) cmds.setAttr(self.controllerName + '.dewRate', keyable=True) cmds.setAttr(self.controllerName + '.spumeRate', keyable=True) cmds.setAttr(self.controllerName + '.waterRate', keyable=True) ################################ Campos de fuerza ############################### cmds.select(clear=True) cmds.gravity(name=self.gravityName, att=0, dx=0, dy=-1, dz=0) cmds.connectAttr(self.controllerName + '.gravity', self.gravityName + '.magnitude') cmds.select(clear=True) cmds.turbulence(name=self.turbulenceLowName, att=0, f=0.8, nsr=0.6) cmds.expression( s= "phaseX = rand(1,100)*10;\nphaseY = rand(1,100)*20;\nphaseZ = rand(1,100)*30;", o=self.turbulenceLowName, alwaysEvaluate=1) cmds.connectAttr(self.controllerName + '.magnitudeTLow', self.turbulenceLowName + '.magnitude') cmds.select(clear=True) cmds.turbulence(name=self.turbulenceHighName, att=0, f=0.8, nsr=0.7) cmds.expression( s= "phaseX = time*135.165;\nphaseY = time+10*135.165;\nphaseZ = time+767*135.165;", o=self.turbulenceHighName, alwaysEvaluate=1) cmds.connectAttr(self.controllerName + '.magnitudeTHigh', self.turbulenceHighName + '.magnitude') ##################################### Gotas ##################################### # Crear sistema y emisor cmds.select(surface) cmds.emitter(n=self.dewEmitterName, type='surface', rate=self.dewRate) cmds.particle(n=self.dewSystemName) cmds.connectDynamic(self.dewSystemShapeName, em=self.dewEmitterName) cmds.connectAttr(self.controllerName + '.dewRate', self.dewEmitterName + '.rate') # Agregar goal entre superficie y sistema cmds.select(self.dewSystemName, r=True) cmds.select(surface, add=True) cmds.goal(self.dewSystemName, g=surface, w=1, utr=0) cmds.connectDynamic(self.dewSystemName, f=self.gravityName) cmds.connectDynamic(self.dewSystemName, f=self.turbulenceLowName) cmds.connectDynamic(self.dewSystemName, f=self.turbulenceHighName) # Setear valores cmds.setAttr(self.dewSystemShapeName + ".conserve", 0.98) cmds.setAttr(self.dewSystemShapeName + ".lifespanMode", 3) # only LifespanPP cmds.setAttr(self.dewSystemShapeName + ".particleRenderType", 3) # points cmds.select(self.dewSystemShapeName) cmds.addAttr(ln='goalU', dt='doubleArray') cmds.addAttr(ln='goalU0', dt='doubleArray') cmds.addAttr(ln='goalV', dt='doubleArray') cmds.addAttr(ln='goalV0', dt='doubleArray') cmds.addAttr(ln='opacityPP', dt='doubleArray') cmds.addAttr(ln='opacityPP0', dt='doubleArray') cmds.dynExpression(self.dewSystemShapeName, s="goalV = 0;\ngoalU = rand(1);\nopacityPP = 0;", c=1) cmds.dynExpression( self.dewSystemShapeName, s="goalV += rand(0.1);\nif (goalV > " + self.controllerName + ".beginTolerance){\n\topacityPP = 1;\n}\nif (goalV > 0.99){\n\tgoalPP = 0;\n\tvector $pos = position;\n\tif ($pos.y < " + self.controllerName + ".floor){\n\t\tlifespanPP = 0;\n\t}\n}", rbd=1) ##################################### Espuma #################################### # Crear sistema y emisor cmds.select(surface) cmds.emitter(n=self.spumeEmitterName, type='surface', rate=self.spumeRate) cmds.particle(n=self.spumeSystemName) cmds.connectDynamic(self.spumeSystemShapeName, em=self.spumeEmitterName) cmds.connectAttr(self.controllerName + '.spumeRate', self.spumeEmitterName + '.rate') # Agregar goal entre superficie y sistema cmds.select(self.spumeSystemName, r=True) cmds.select(surface, add=True) cmds.goal(self.spumeSystemName, g=surface, w=1, utr=0) cmds.connectDynamic(self.spumeSystemName, f=self.gravityName) cmds.connectDynamic(self.spumeSystemName, f=self.turbulenceLowName) cmds.connectDynamic(self.spumeSystemName, f=self.turbulenceHighName) # Setear valores cmds.setAttr(self.spumeSystemShapeName + ".conserve", 0.98) cmds.setAttr(self.spumeSystemShapeName + ".lifespanMode", 3) # only LifespanPP cmds.setAttr(self.spumeSystemShapeName + ".particleRenderType", 6) # streaks cmds.select(self.spumeSystemShapeName) cmds.addAttr(ln='goalU', dt='doubleArray') cmds.addAttr(ln='goalU0', dt='doubleArray') cmds.addAttr(ln='goalV', dt='doubleArray') cmds.addAttr(ln='goalV0', dt='doubleArray') cmds.addAttr(ln='opacityPP', dt='doubleArray') cmds.addAttr(ln='opacityPP0', dt='doubleArray') cmds.dynExpression(self.spumeSystemShapeName, s="goalV = 0;\ngoalU = rand(1);\nopacityPP = 0;", c=1) cmds.dynExpression( self.spumeSystemShapeName, s="goalV += rand(0.1);\nif (goalV > " + self.controllerName + ".beginTolerance){\n\topacityPP = 1;\n}\nif (goalV > 0.99){\n\tgoalPP = 0;\n\tvector $pos = position;\n\tif ($pos.y < " + self.controllerName + ".floor){\n\t\tlifespanPP = 0;\n\t}\n}", rbd=1) ###################################### Agua ##################################### # Crear sistema y emisor cmds.select(surface) cmds.emitter(n=self.waterEmitterName, type='surface', rate=self.waterRate) cmds.particle(n=self.waterSystemName) cmds.connectDynamic(self.waterSystemShapeName, em=self.waterEmitterName) cmds.connectAttr(self.controllerName + '.waterRate', self.waterEmitterName + '.rate') # Agregar goal entre superficie y sistema cmds.select(self.waterSystemName, r=True) cmds.select(surface, add=True) cmds.goal(self.waterSystemName, g=surface, w=1, utr=0) cmds.connectDynamic(self.waterSystemName, f=self.gravityName) cmds.connectDynamic(self.waterSystemName, f=self.turbulenceLowName) cmds.connectDynamic(self.waterSystemName, f=self.turbulenceHighName) # Setear valores cmds.setAttr(self.waterSystemShapeName + ".conserve", 0.98) cmds.setAttr(self.waterSystemShapeName + ".lifespanMode", 3) # only LifespanPP cmds.setAttr(self.waterSystemShapeName + ".particleRenderType", 7) # Bubble cmds.select(self.waterSystemShapeName) cmds.addAttr(ln='threshold', at='float', defaultValue=0.75, minValue=0, maxValue=10) #cmds.addAttr(ln='radius',at='float',defaultValue=0.75,minValue=0,maxValue=20) cmds.addAttr(ln='radiusPP', dt='doubleArray') cmds.addAttr(ln='radiusPP0', dt='doubleArray') cmds.setAttr(self.waterSystemShapeName + ".threshold", 0.75) cmds.select(self.waterSystemShapeName) cmds.addAttr(ln='goalU', dt='doubleArray') cmds.addAttr(ln='goalU0', dt='doubleArray') cmds.addAttr(ln='goalV', dt='doubleArray') cmds.addAttr(ln='goalV0', dt='doubleArray') cmds.dynExpression( self.waterSystemShapeName, s= "goalV = 0;\ngoalU = rand(1);\nif (rand(1) < 0.25){\n\tradiusPP = rand(0.7);\n} else {\n\tradiusPP = rand(1,2);\n}", c=1) cmds.dynExpression( self.waterSystemShapeName, s="goalV += rand(0.1);\nif (goalV > 0.99){\n\tgoalPP = 0;\n\tvector $pos = position;\n\tif ($pos.y < " + self.controllerName + ".floor){\n\t\tlifespanPP = 0;\n\t}\n}", rbd=1) cmds.select(self.controllerName) # cmds.getAttr() self.dagModifier.doIt()
global partRwe; partRwe = tempPart + "Shape.goalWeight[0]" # Goal weight pull global partPos; partPos = tempPart + ".center" # nParticle center position pull global partNucl; partNucl = tempNucl + ".timeScale" # Time scale pull global nuclStart; nuclStart = tempNucl + ".startFrame" # Start frame of simulation nucleus node cmds.spaceLocator( n = tempLoc ) cmds.matchTransform( tempLoc, listObjects[i], pos=True ) objCenter = tempLoc + ".translate" objC = cmds.getAttr( objCenter ) locCenter = tempLoc + ".center" locTr = tempLoc + ".translate" cmds.nParticle( p = objC, n = tempPart , c = 1 ) cmds.goal( tempPart, w=goalW, utr=1, g = tempLoc ) cmds.select( tempLoc, r=True ) cmds.select( listObjects[i], add=True ) cmds.parent( r=True ) cmds.matchTransform( tempLoc, listObjects[i], pos=True ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr( partRtype, pShape ) cmds.setAttr( partRrad, pRad ) cmds.setAttr( partRsm, goalSmooth ) cmds.setAttr( partRwe, goalW ) cmds.setAttr( partNucl, timeScale ) cmds.setAttr( nuclStart, asT )
def translationStart(): global asT asT = cmds.playbackOptions(query=True, min=True) # Левая граница анимации global aeT aeT = cmds.playbackOptions(query=True, max=True) # Правая граница анимации resetLoopTime() global listObjects listObjects = cmds.ls(sl=True) # Список трансформов #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global listFixed listFixed = listObjects[:] for i in range(len(listFixed)): listFixed[i] = listFixed[i].replace("|", "_") #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global mainLayerName mainLayerName = "OVERLAPPER" # Имя главного слоя if (cmds.objExists(mainLayerName)): print "\n||| OVERLAPPER start |||\n" else: cmds.animLayer(mainLayerName) print "\n||| OVERLAPPER start ||| Layer created |||\n" #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| for i in range(len(listFixed)): # Основной цикл global aimLoc aimLoc = listFixed[i] + "_aim_loc" # Имя аим локатора global tempLoc tempLoc = listFixed[i] + "_temp_loc" # Имя физ локатора global tempPart tempPart = listFixed[i] + "_temp_part" # Имя физ частицы global tempNucl tempNucl = "nucleus1" # Имя физ ноды global partAimLoc partAimLoc = aimLoc + ".translate" # Обращение к позиции аим локатора global partRtype partRtype = tempPart + "Shape.particleRenderType" # Обращение к типу отображения частицы global partRrad partRrad = tempPart + "Shape.radius" # Обращение к размеру частицы global partRsm partRsm = tempPart + "Shape.goalSmoothness" # Обращение к мягкости физики global partRwe partRwe = tempPart + "Shape.goalWeight[0]" # Обращение к весу ноды global partPos partPos = tempPart + ".center" # Обращение к центру частицы global partNucl partNucl = tempNucl + ".timeScale" # Обращение к скейлу времени физ ноды global nuclStart nuclStart = tempNucl + ".startFrame" # Обращение к старту симуляции физ ноды cmds.spaceLocator(n=tempLoc) # Создаём физ локатор cmds.matchTransform(tempLoc, listObjects[i], pos=True) # Перемещаем локатор в пивот объекта objCenter = tempLoc + ".translate" # Обращение к центру объекта objC = cmds.getAttr(objCenter) # Записываем центр объекта locCenter = tempLoc + ".center" # Обращение к центру физ локатора locTr = tempLoc + ".translate" # Обращение к позиции физ локатора cmds.nParticle(p=objC, n=tempPart, c=1) # Создаём частицу в целевой позиции cmds.goal(tempPart, w=goalW, utr=1, g=tempLoc) # Создаём физическую связь cmds.select(tempLoc, r=True) # Выделяем физ локатор cmds.select(listObjects[i], add=True) # Выделяем целевого родителя cmds.parent(r=True) # Создаём иерархию cmds.matchTransform(tempLoc, listObjects[i], pos=True) # Перемещаем локатор в пивот объекта #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr(partRtype, pShape) cmds.setAttr(partRrad, pRad) cmds.setAttr(partRsm, goalSmooth) cmds.setAttr(partRwe, goalW) cmds.setAttr(partNucl, timeScale) cmds.setAttr(nuclStart, asT) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.duplicate(tempLoc, rr=True, n=aimLoc) # Дублируем локатор cmds.select(aimLoc, r=True) # Выделяем аим локатор cmds.parent(w=True) # Разбираем иерархию cmds.connectAttr(partPos, partAimLoc, f=True) # Привязываем аим локатор к частице global minLoopTime minLoopTime = aeT * -2 global maxLoopTime maxLoopTime = aeT * 2 if (cycle): cmds.setAttr(nuclStart, minLoopTime) cmds.bakeResults( aimLoc, t=(minLoopTime, maxLoopTime), sm=True, at="translate") # Запекание аим локатора для цикла cmds.delete(tempLoc, tempPart, tempNucl) # Удаляем объекты физики setTimeToMin() cmds.select(aimLoc, r=True) # Выделяем аим локатор как родителя cmds.select(listObjects[i], add=True) # Выделяем объект как подчиненного cmds.parentConstraint(mo=True, sr=["x", "y", "z"], w=1) # Создаём позиционный констрейн resetLoopTime() else: cmds.bakeResults( aimLoc, t=(asT, aeT), sm=True, at="translate") # Запекание аим локатора для линейной анимации cmds.delete(tempLoc, tempPart, tempNucl) # Удаляем объекты физики resetLoopTime() cmds.select(aimLoc, r=True) # Выделяем аим локатор как родителя cmds.select(listObjects[i], add=True) # Выделяем объект как подчиненного cmds.parentConstraint(mo=True, sr=["x", "y", "z"], w=1) # Создаём позиционный констрейн #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| layerBase = "translate_" # Имя базы слоя layerName = layerBase + listFixed[i] # Имя слоя layerComp = listFixed[i] + '_layer_{0}'.format( "0") # Имя компонента слоя if (cmds.objExists(layerName)): cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="translate") # Запекаем объект в слой cmds.select(listObjects[i], r=True) cmds.setInfinity(pri="cycle", poi="cycle") cmds.delete(aimLoc) # Удаляем объекты скрипта cmds.container("BakeResultsContainer", e=True, rc=True) # Удаляем контейнер cmds.animLayer( "BakeResults", e=True, p=layerName ) # Переносим слой с анимацией в основной слой объекта cmds.rename("BakeResults", layerComp) # Переименовываем слой resetLoopTime() else: cmds.animLayer( layerName) # Создаём пустой слой для всех оверлапов объекта cmds.animLayer( layerName, e=True, p=mainLayerName) # Переносим базу слоя в главный слой cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="translate") # Запекаем объект в слой cmds.select(listObjects[i], r=True) cmds.setInfinity(pri="cycle", poi="cycle") cmds.delete(aimLoc) # Удаляем объекты скрипта cmds.container("BakeResultsContainer", e=True, rc=True) # Удаляем контейнер cmds.animLayer( "BakeResults", e=True, p=layerName ) # Переносим слой с анимацией в основной слой объекта cmds.rename("BakeResults", layerComp) # Переименовываем слой resetLoopTime() cmds.select(d=True) # Деселект for l in listObjects: cmds.select(l, add=True) print "\n||| OVERLAPPER end |||\n"
def rotate_simulation(): ######## Need to remove obj.simState = obj.prefix_base_layer[2] obj.playback_range_initialization() obj.reset_range_time() obj.list_objects = cmds.ls(sl = True) obj.list_fixed = obj.list_objects [:] if (len(obj.list_objects) <= 1): print obj.myError, "Need to select 2 or more objects" else: print obj.myMessage, "Selected {0} objects (the last element is discarded)".format(len(obj.list_objects) - 1) obj.setup_progressbar(len(obj.list_objects) - 1) # start progress bar window obj.create_overlappy_layer() obj.replaceSymbols() for i in range(len(obj.list_fixed)-1): #### Set names #### ########## Need to create method obj.main_set_names(i) #### Create main logic #### if obj.aim_vector_reverse: obj.rotAimVector = -1 else: obj.rotAimVector = 1 ## Create locators ## cmds.spaceLocator(n = obj.base_locator) cmds.matchTransform (obj.base_locator, obj.list_objects[i], pos = True, rot = True) cmds.duplicate(obj.base_locator, n = obj.base_aim_locator) cmds.parent(obj.base_aim_locator, obj.base_locator, a = True) cmds.duplicate(obj.base_aim_locator, n = obj.offset_aim_locator) cmds.parentConstraint(obj.list_objects[i], obj.base_locator, mo = True, w = 1) cmds.spaceLocator(n = obj.goal_locator) cmds.matchTransform (obj.goal_locator, obj.list_objects[i + 1], pos = True, rot = True) cmds.parentConstraint(obj.list_objects[i + 1], obj.goal_locator, mo = True, w = 1) cmds.spaceLocator(n = obj.goal_aim_locator) ## Create particle and nucleus ## obj.goal_position = cmds.getAttr(obj.goal_locator + ".translate") cmds.nParticle(p = obj.goal_position, n = obj.np_name, c = 1) cmds.goal(obj.np_name, w = obj.T_goal_weight, utr = 1, g = obj.goal_locator) ## Create connections ## cmds.connectAttr(obj.np_center, obj.goal_aim_locator_pos, f = True) cmds.aimConstraint(obj.goal_aim_locator, obj.base_aim_locator, w = 1, aim = (0, obj.rotAimVector, 0), u = (0, 1, 0), wut = "vector", wu = (0, 1, 0), sk = "y") cmds.parentConstraint(obj.base_aim_locator, obj.offset_aim_locator, mo = True, st=["x","y","z"], w = 1) #### Layers, connections, baking, copy/paste #### obj.get_nonLocked_attributes(i) cmds.select(d = True) cmds.progressBar(obj.progressControl, edit = True, step = obj.progressBar_step_value) #### Select list in initial order, close progressbar #### for l in obj.list_objects: cmds.select (l, add = True) obj.close_progressbar() print obj.myMessage, obj.root_layer_name, "ends simulation" obj.simState = obj.prefix_base_layer[0]
# 3. Change or animate 'Goal Weight[0]' value (under 'luismiParticleShape') until # # you are happy with the result. # # 4. Execute SPRING BAKE script (by clicking on the shelf icon). # # # ####################################################################################### import maya.cmds as cmds minTime = cmds.playbackOptions(minTime=True, query=True) maxTime = cmds.playbackOptions(maxTime=True, query=True) sel = cmds.ls(selection=True) if len(sel) == 0: cmds.warning("Nothing Selected") elif cmds.objExists('luismiParticle'): cmds.warning("luismiParticle already EXISTS!") else: cmds.currentTime(minTime, edit=True) selLoc = cmds.spaceLocator(name='OriginalPosition_Loc') cmds.particle(p=[(0, 0, 0)], name='luismiParticle') tempConst = cmds.parentConstraint(sel, selLoc, mo=False) cmds.bakeResults(selLoc, t=(minTime, maxTime)) cmds.delete(tempConst) tempConst2 = cmds.parentConstraint(selLoc, 'luismiParticle', mo=False) cmds.delete(tempConst2) cmds.goal('luismiParticle', g=selLoc, w=.45) cmds.spaceLocator(name='physicsLoc') cmds.connectAttr('luismiParticleShape.worldCentroid', 'physicsLoc.translate') tempConst3 = cmds.pointConstraint('physicsLoc', sel, mo=True) cmds.select('luismiParticle')
def rotationStart(): global asT; asT = cmds.playbackOptions (query=True, min=True) global aeT; aeT = cmds.playbackOptions (query=True, max=True) resetLoopTime() global listObjects; listObjects = cmds.ls (sl=True) if( len( listObjects ) <= 1 ): print "\n||| Need to select two or more objects |||\n" else: #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global listFixed; listFixed = listObjects [:] for i in range( len( listFixed ) ): listFixed[i] = listFixed[i].replace( "|", "_" ) listFixed[i] = listFixed[i].replace( ":", "_" ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global mainLayerName; mainLayerName = "OVERLAPPY" if (cmds.objExists(mainLayerName)): print "\n||| OVERLAPPY start |||\n" else: cmds.animLayer (mainLayerName) print "\n||| OVERLAPPY start ||| Layer created |||\n" #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| for i in range(len(listFixed)): if ( i+1 != len(listFixed) ): global zeroLoc; zeroLoc = listFixed[i] + "_base_loc" global aimLoc; aimLoc = listFixed[i] + "_aim_loc" global tempLoc; tempLoc = listFixed[i] + "_temp_loc" global tempAimLoc; tempAimLoc = listFixed[i] + "_tempAim_loc" global tempPart; tempPart = listFixed[i] + "_temp_part" global tempNucl; tempNucl = "nucleus1" global partRtype; partRtype = tempPart + "Shape.particleRenderType" global partRrad; partRrad = tempPart + "Shape.radius" global partRsm; partRsm = tempPart + "Shape.goalSmoothness" global partRwe; partRwe = tempPart + "Shape.goalWeight[0]" global partNucl; partNucl = tempNucl + ".timeScale" global nuclStart; nuclStart = tempNucl + ".startFrame" if aimVectorReverse: rotAimVector = -1 else: rotAimVector = 1 #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.spaceLocator( n = zeroLoc ) cmds.spaceLocator( n = aimLoc ) cmds.spaceLocator( n = tempLoc ) cmds.matchTransform ( zeroLoc, listObjects[i], pos=True ) cmds.matchTransform ( tempLoc, listObjects[i+1], pos=True ) cmds.select( tempLoc, r=True ) cmds.duplicate( n = tempAimLoc ) cmds.select( listObjects[0], r=True ) cmds.select( zeroLoc, add=True ) cmds.parentConstraint( mo=True, w = 1 ) cmds.select( aimLoc, r=True ) cmds.select( zeroLoc, add=True ) cmds.parent( r=True ) cmds.select( listObjects[1], r=True ) cmds.select( tempLoc, add=True ) cmds.parentConstraint( mo=True, sr=["x", "y", "z"], w = 1 ) aimPosName = tempLoc + ".translate" partCenter = tempPart + ".center" aimLocPos = tempAimLoc + ".translate" aimPos = cmds.getAttr( aimPosName ) cmds.nParticle( p = aimPos , n = tempPart , c = 1 ) cmds.goal( tempPart, w=0.5, utr=1, g = tempLoc ) cmds.connectAttr( partCenter, aimLocPos, f=True ) cmds.select( tempAimLoc, r=True ) cmds.select( aimLoc, add=True ) cmds.aimConstraint( w=1, aim=(0, rotAimVector, 0), u=(0, 1, 0), wut="vector", wu=(0, 1, 0), sk="y" ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr (partRtype, pShape) cmds.setAttr (partRrad, pRad) cmds.setAttr (partRsm, goalSmoothRot) cmds.setAttr (partRwe, goalWRot) cmds.setAttr (partNucl, timeScaleRot) cmds.setAttr (nuclStart, asT) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global minLoopTime; minLoopTime = aeT * minLoopScale global maxLoopTime; maxLoopTime = aeT * maxLoopScale if (cycle): cmds.setAttr( nuclStart, minLoopTime ) cmds.bakeResults( zeroLoc, t = (asT, aeT), sm=True, at=( "translate", "rotate") ) cmds.bakeResults( aimLoc, t = (minLoopTime, maxLoopTime), sm=True, at="rotate" ) cmds.delete( tempAimLoc, tempLoc, tempPart, tempNucl ) zeroParent = zeroLoc + "_parentConstraint1" cmds.delete( zeroParent ) setTimeToMin() cmds.select( aimLoc, r=True ) cmds.select( listObjects[i], add=True ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||| attrX = listObjects[i] + '.rotateX' attrY = listObjects[i] + '.rotateY' attrZ = listObjects[i] + '.rotateZ' lockX = cmds.getAttr( attrX, lock=True ) lockY = cmds.getAttr( attrY, lock=True ) lockZ = cmds.getAttr( attrZ, lock=True ) if ( lockX != True ): cmds.parentConstraint( mo=True, st=["x","y","z"], sr=["y","z"], w = 1 ) if ( lockY != True ): cmds.parentConstraint( mo=True, st=["x","y","z"], sr=["x","z"], w = 1 ) if ( lockZ != True ): cmds.parentConstraint( mo=True, st=["x","y","z"], sr=["x","y"], w = 1 ) resetLoopTime() else: cmds.bakeResults( zeroLoc, t = (asT, aeT), sm=True, at=( "translate", "rotate") ) cmds.bakeResults( aimLoc, t = (asT, aeT), sm=True, at="rotate" ) cmds.delete( tempAimLoc, tempLoc, tempPart, tempNucl ) zeroParent = zeroLoc + "_parentConstraint1" cmds.delete( zeroParent ) resetLoopTime() cmds.select( aimLoc, r=True ) cmds.select( listObjects[i], add=True ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||| attrX = listObjects[i] + '.rotateX' attrY = listObjects[i] + '.rotateY' attrZ = listObjects[i] + '.rotateZ' lockX = cmds.getAttr( attrX, lock=True ) lockY = cmds.getAttr( attrY, lock=True ) lockZ = cmds.getAttr( attrZ, lock=True ) if ( lockX != True ): cmds.parentConstraint( mo=True, st=["x","y","z"], sr=["y","z"], w = 1 ) if ( lockY != True ): cmds.parentConstraint( mo=True, st=["x","y","z"], sr=["x","z"], w = 1 ) if ( lockZ != True ): cmds.parentConstraint( mo=True, st=["x","y","z"], sr=["x","y"], w = 1 ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| layerBase = "rotate_" layerName = layerBase + listFixed[i] layerComp = listFixed[i] + '_layer_{0}'.format("0") if ( cmds.objExists( layerName ) ): cmds.bakeResults( listObjects[i], t = (asT, aeT), sm=True, bol=True, at = "rotate" ) cmds.select( listObjects[i], r=True ) if (cycleInfinity): cmds.setInfinity( pri="cycle", poi="cycle" ) else: cmds.setInfinity( pri="constant", poi="constant" ) cmds.delete( aimLoc, zeroLoc ) cmds.container( "BakeResultsContainer", e=True, rc=True ) cmds.animLayer( "BakeResults", e=True, p = layerName ) cmds.rename( "BakeResults", layerComp ) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() else: cmds.animLayer( layerName ) cmds.animLayer( layerName, e=True, p = mainLayerName ) cmds.bakeResults( listObjects[i], t = (asT, aeT), sm=True, bol=True, at = "rotate" ) cmds.select( listObjects[i], r=True ) if (cycleInfinity): cmds.setInfinity( pri="cycle", poi="cycle" ) else: cmds.setInfinity( pri="constant", poi="constant" ) cmds.delete( aimLoc, zeroLoc ) cmds.container( "BakeResultsContainer", e=True, rc=True ) cmds.animLayer( "BakeResults", e=True, p = layerName ) cmds.rename( "BakeResults", layerComp ) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() cmds.select (d=True) for l in listObjects: cmds.select (l, add=True) print "\n||| OVERLAPPY end |||\n"
def translationStart(): global asT; asT = cmds.playbackOptions( query=True, min=True ) # Get min anim range global aeT; aeT = cmds.playbackOptions( query=True, max=True ) # Get max anim range resetLoopTime() global listObjects; listObjects = cmds.ls( sl=True ) # Get list of selected objects #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global listFixed; listFixed = listObjects [:] for i in range( len( listFixed ) ): listFixed[i] = listFixed[i].replace( "|", "_" ) listFixed[i] = listFixed[i].replace( ":", "_" ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global mainLayerName; mainLayerName = "OVERLAPPY" # Name of main layer if( cmds.objExists( mainLayerName ) ): print "\n||| OVERLAPPY start |||\n" else: cmds.animLayer( mainLayerName ) print "\n||| OVERLAPPY start ||| Layer created |||\n" #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| for i in range( len( listFixed ) ): global aimLoc; aimLoc = listFixed[i] + "_aim_loc" # Aim locator name global tempLoc; tempLoc = listFixed[i] + "_temp_loc" # Physical locator name global tempPart; tempPart = listFixed[i] + "_temp_part" # nParticle name global tempNucl; tempNucl = "nucleus1" # Nucleus node name global partAimLoc; partAimLoc = aimLoc + ".translate" # Aim locator position pull global partRtype; partRtype = tempPart + "Shape.particleRenderType" # nParticle render type pull global partRrad; partRrad = tempPart + "Shape.radius" # nParticle shape radius global partRsm; partRsm = tempPart + "Shape.goalSmoothness" # Goal smoothness pull global partRwe; partRwe = tempPart + "Shape.goalWeight[0]" # Goal weight pull global partPos; partPos = tempPart + ".center" # nParticle center position pull global partNucl; partNucl = tempNucl + ".timeScale" # Time scale pull global nuclStart; nuclStart = tempNucl + ".startFrame" # Start frame of simulation nucleus node cmds.spaceLocator( n = tempLoc ) cmds.matchTransform( tempLoc, listObjects[i], pos=True ) objCenter = tempLoc + ".translate" objC = cmds.getAttr( objCenter ) locCenter = tempLoc + ".center" locTr = tempLoc + ".translate" cmds.nParticle( p = objC, n = tempPart , c = 1 ) cmds.goal( tempPart, w=goalW, utr=1, g = tempLoc ) cmds.select( tempLoc, r=True ) cmds.select( listObjects[i], add=True ) cmds.parent( r=True ) cmds.matchTransform( tempLoc, listObjects[i], pos=True ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr( partRtype, pShape ) cmds.setAttr( partRrad, pRad ) cmds.setAttr( partRsm, goalSmooth ) cmds.setAttr( partRwe, goalW ) cmds.setAttr( partNucl, timeScale ) cmds.setAttr( nuclStart, asT ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.duplicate( tempLoc, rr=True, n = aimLoc ) cmds.select( aimLoc, r=True ) cmds.parent( w=True ) cmds.connectAttr( partPos, partAimLoc, f=True ) global minLoopTime; minLoopTime = aeT * minLoopScale global maxLoopTime; maxLoopTime = aeT * maxLoopScale if( cycle ): cmds.setAttr( nuclStart, minLoopTime ) cmds.bakeResults( aimLoc, t = ( minLoopTime, maxLoopTime ), sm=True, at = "translate") cmds.delete( tempLoc, tempPart, tempNucl ) setTimeToMin() cmds.select( aimLoc, r=True ) cmds.select( listObjects[i], add=True ) cmds.parentConstraint( mo=True, sr=["x", "y", "z"], w = 1 ) resetLoopTime() else: cmds.bakeResults( aimLoc, t = ( asT, aeT ), sm=True, at = "translate" ) cmds.delete( tempLoc, tempPart, tempNucl ) resetLoopTime() cmds.select( aimLoc, r=True ) cmds.select( listObjects[i], add=True ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||| attrX = listObjects[i] + '.translateX' attrY = listObjects[i] + '.translateY' attrZ = listObjects[i] + '.translateZ' lockX = cmds.getAttr( attrX, lock=True ) lockY = cmds.getAttr( attrY, lock=True ) lockZ = cmds.getAttr( attrZ, lock=True ) if ( lockX != True ): cmds.parentConstraint( mo=True, st=["y","z"], sr=["x","y","z"], w = 1 ) if ( lockY != True ): cmds.parentConstraint( mo=True, st=["x","z"], sr=["x","y","z"], w = 1 ) if ( lockZ != True ): cmds.parentConstraint( mo=True, st=["x","y"], sr=["x","y","z"], w = 1 ) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| layerBase = "translate_" layerName = layerBase + listFixed[i] layerComp = listFixed[i] + '_layer_{0}'.format("0") if ( cmds.objExists( layerName ) ): cmds.bakeResults( listObjects[i], t = (asT, aeT), sm=True, bol=True, at = "translate") cmds.select( listObjects[i], r=True ) if (cycleInfinity): cmds.setInfinity( pri="cycle", poi="cycle" ) else: cmds.setInfinity( pri="constant", poi="constant" ) cmds.delete( aimLoc ) cmds.container( "BakeResultsContainer", e=True, rc=True ) cmds.animLayer( "BakeResults", e=True, p = layerName ) cmds.rename( "BakeResults", layerComp ) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() else: cmds.animLayer (layerName) cmds.animLayer (layerName, e=True, p = mainLayerName) cmds.bakeResults (listObjects[i], t = (asT, aeT), sm=True, bol=True, at = "translate") cmds.select (listObjects[i], r=True) if (cycleInfinity): cmds.setInfinity( pri="cycle", poi="cycle" ) else: cmds.setInfinity( pri="constant", poi="constant" ) cmds.delete (aimLoc) cmds.container("BakeResultsContainer", e=True, rc=True) cmds.animLayer ("BakeResults", e=True, p = layerName) cmds.rename ("BakeResults", layerComp) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() cmds.select (d=True) for l in listObjects: cmds.select (l, add=True) print "\n||| OVERLAPPY end |||\n"
cmds.select('grass_grass' + str(i)) #select object cmds.polyUnite(muv=1, n='grass' + str(i)) #Combine and rename cmds.delete(ch=True) cmds.select('grass' + str(i)) #slect new shape ################################ Create FX ########################### cmds.lattice(dv=(7, 7, 7), oc=True) cmds.select("ffd" + str(x) + "Lattice") cmds.duplicate(n="ffd" + str(x) + "Lattice_goal") cmds.select("ffd" + str(x) + "Base") cmds.duplicate(n="ffd" + str(x) + "Base_goal") cmds.select("ffd" + str(x) + "Lattice") cmds.soft("ffd" + str(x) + "Lattice", c=True) cmds.goal("ffd" + str(x) + "LatticeParticle", g="ffd" + str(x) + "Lattice_goal", w=0.5) cmds.connectDynamic("ffd" + str(x) + "LatticeParticle", f='Grass_wind_FX') cmds.select('grass' + str(i), "ffd" + str(x) + "Lattice", "ffd" + str(x) + "Base", "ffd" + str(x) + "Lattice_goal", "ffd" + str(x) + "Base1", "ffd" + str(x) + "Base_goal") cmds.group(n='Dynamic_grass' + str(i)) x += 2 #increment l = 1 for i in range(109): cmds.select("ffd" + str(l) + "Lattice", "ffd" + str(l) + "Lattice_goal", "ffd" + str(l) + "Base1", "ffd" + str(l) + "Base_goal") cmds.hide(cs=True) l += 2
partNucl = tempNucl + ".timeScale" # Обращение к скейлу времени физ ноды global nuclStart nuclStart = tempNucl + ".startFrame" # Обращение к старту симуляции физ ноды cmds.spaceLocator(n=tempLoc) # Создаём физ локатор cmds.matchTransform(tempLoc, listObjects[i], pos=True) # Перемещаем локатор в пивот объекта objCenter = tempLoc + ".translate" # Обращение к центру объекта objC = cmds.getAttr(objCenter) # Записываем центр объекта locCenter = tempLoc + ".center" # Обращение к центру физ локатора locTr = tempLoc + ".translate" # Обращение к позиции физ локатора cmds.nParticle(p=objC, n=tempPart, c=1) # Создаём частицу в целевой позиции cmds.goal(tempPart, w=goalW, utr=1, g=tempLoc) # Создаём физическую связь cmds.select(tempLoc, r=True) # Выделяем физ локатор cmds.select(listObjects[i], add=True) # Выделяем целевого родителя cmds.parent(r=True) # Создаём иерархию cmds.matchTransform(tempLoc, listObjects[i], pos=True) # Перемещаем локатор в пивот объекта #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr(partRtype, pShape) cmds.setAttr(partRrad, pRad) cmds.setAttr(partRsm, goalSmooth) cmds.setAttr(partRwe, goalW) cmds.setAttr(partNucl, timeScale)
def _particleDyn(obj, weight, conserve, transfShapes, nucleus): "Metodo generico di dinamica basata sulla particella" c = obj cNoPath = c[c.rfind("|")+1:] dynName = cNoPath + "_DYN" partName = cNoPath + "_INIT" dynLocName = cNoPath + "_DYN_LOC" statLocName = cNoPath + "_STAT_LOC" revName = cNoPath + "_REV" exprName = cNoPath + "_Expression" octName = cNoPath + "Oct" # leggo la posizione dell'oggetto pos = cmds.xform(c, q=True, rp=True, ws=True) # creo la particella if nucleus: partic, partShape = cmds.nParticle(n=partName, p=pos) else: partic, partShape = cmds.particle(n=partName, p=pos) partShape = "%s|%s" % (partic, partShape) # sposto il pivot cmds.xform(partic, piv=pos, ws=True) # aggiungo uno shape alla particella octName = drawOct(octName, r=0.25, pos=pos) octShapeName = cmds.listRelatives(octName, s=True, pa=True)[0] cmds.setAttr(octShapeName + ".overrideEnabled", True) cmds.setAttr(octShapeName + ".overrideColor", 13) cmds.parent([octShapeName, partic], s=True, r=True) cmds.delete(octName) # creo i locator statLocGrp = cmds.group("|" + cmds.spaceLocator(n=statLocName)[0], n="g_" + statLocName) dynLocGrp = cmds.group("|" + cmds.spaceLocator(n=dynLocName)[0], n="g_" + dynLocName) cmds.setAttr("|%s|%s.overrideEnabled" % (dynLocGrp, dynLocName), True) cmds.setAttr("|%s|%s.overrideColor" % (dynLocGrp, dynLocName), 6) # se e' attivo transfer shapes uso un gruppo invece di creare il cubetto if transfShapes: dyn = cmds.group(n=dynName, em=True) else: # cubetto colorato di blu orientato secondo l'oggetto dyn = drawCube(dynName, l=0.5) cubeShape = cmds.listRelatives(dyn, s=True, pa=True)[0] cmds.setAttr(cubeShape + ".overrideEnabled", True) # colore cmds.setAttr(cubeShape + ".overrideColor", 6) # ruoto il cubetto e i locator (molto + carino) cmds.xform(["|" + statLocGrp, "|" + dynLocGrp, dyn], ro=cmds.xform(c, q=True, ro=True, ws=True), ws=True) cmds.xform(["|" + statLocGrp, "|" + dynLocGrp, dyn], t=pos, ws=True) dyn = cmds.parent([dyn, c])[0] cmds.makeIdentity(dyn, apply=True) # in questo modo il cubo assume le coordinate dell'oggetto pur essendo posizionato nel suo pivot # parento dyn allo stesso parente dell'oggetto parentObj = cmds.listRelatives(c, p=True, pa=True) if parentObj: dyn = cmds.parent([dyn, parentObj[0]])[0] else: dyn = cmds.parent(dyn, w=True)[0] c = cmds.parent([c, dyn])[0] cmds.parent(["|" + statLocGrp, "|" + dynLocGrp, dyn]) # aggiorna i nomi con i percorsi statLocGrp = "%s|%s" % (dyn, statLocGrp) dynLocGrp = "%s|%s" % (dyn, dynLocGrp) statLoc = "%s|%s" % (statLocGrp, statLocName) dynLoc = "%s|%s" % (dynLocGrp, dynLocName) # goal particella-loc statico cmds.goal(partic, g=statLoc, utr=True, w=weight) # nascondo locator cmds.hide([statLocGrp, dynLocGrp]) # rendo template la particella cmds.setAttr(partShape + '.template', True) # aggiungo l'attributo di velocita' cmds.addAttr(c, ln="info", at="enum", en=" ", keyable=True) cmds.setAttr(c + ".info", l=True) cmds.addAttr(c, ln="velocity", at="double3") cmds.addAttr(c, ln="velocityX", at="double", p="velocity", k=True) cmds.addAttr(c, ln="velocityY", at="double", p="velocity", k=True) cmds.addAttr(c, ln="velocityZ", at="double", p="velocity", k=True) # point oggetto tra i locator statico e dinamico pc = cmds.pointConstraint(statLoc, dynLoc, c, n=cNoPath + "_PC")[0] cmds.addAttr(dyn, ln="settings", at="enum", en=" ", keyable=True) cmds.setAttr(dyn + ".settings", l=True) cmds.addAttr(dyn, ln="dynamicsBlend", at="double", min=0.0, max=1.0, dv=1.0, keyable=True) cmds.addAttr(dyn, ln="weight", at="double", min=0.0, max=1.0, dv=weight, keyable=True) cmds.addAttr(dyn, ln="conserve", at="double", min=0.0, max=1.0, dv=conserve, keyable=True) rev = cmds.createNode("reverse", n=revName) cmds.connectAttr(dyn + ".dynamicsBlend", pc + ".w1") cmds.connectAttr(dyn + ".dynamicsBlend", rev + ".inputX") cmds.connectAttr(rev + ".outputX", pc + ".w0") cmds.connectAttr(dyn + ".weight", partShape + ".goalWeight[0]") cmds.connectAttr(dyn + ".conserve", partShape + ".conserve") # locco il point constraint [cmds.setAttr("%s.%s" % (pc, s), l=True) for s in ["offsetX", "offsetY", "offsetZ", "w0", "w1", "nodeState"]] # locco il reverse [cmds.setAttr("%s.%s" % (revName, s), l=True) for s in ["inputX", "inputY", "inputZ"]] # nParticle if nucleus: nucleusNode = cmds.listConnections(partShape + ".currentState")[0] cmds.setAttr(nucleusNode + '.gravity', 0.0) expr = """// rename if needed string $dynHandle = "%s"; string $particleObject = "%s"; string $dynLocator = "%s"; undoInfo -swf 0; $ast = `playbackOptions -q -ast`; if (`currentTime -q` - $ast < 2) { // %s.startFrame = $ast; // remove it if you don't want to change nucleus start time $destPiv = `xform -q -rp -ws $dynHandle`; $origPiv = `xform -q -rp -ws $particleObject`; xform -t ($destPiv[0]-$origPiv[0]) ($destPiv[1]-$origPiv[1]) ($destPiv[2]-$origPiv[2]) -r -ws $particleObject; } $zvPos = `getParticleAttr -at worldPosition ($particleObject + ".pt[0]")`; $currUnit = `currentUnit -q -linear`; if ($currUnit != "cm") { $zvPos[0] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[0])`; $zvPos[1] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[1])`; $zvPos[2] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[2])`; } xform -a -ws -t $zvPos[0] $zvPos[1] $zvPos[2] $dynLocator; $zvVel = `getParticleAttr -at velocity ($particleObject + ".pt[0]")`; // velocity relative to the particleObject %s.velocityX = $zvVel[0]; %s.velocityY = $zvVel[1]; %s.velocityZ = $zvVel[2]; undoInfo -swf 1;""" % (dyn, partic, dynLocName, nucleusNode, c, c, c) # particella standard else: cmds.setAttr(partic + ".visibility", False) expr = """// rename if needed string $dynHandle = "%s"; string $particleObject = "%s"; string $dynLocator = "%s"; undoInfo -swf 0; $ast = `playbackOptions -q -ast`; if (`currentTime -q` - $ast < 2) { %s.startFrame = $ast; $destPiv = `xform -q -rp -ws $dynHandle`; $origPiv = `xform -q -rp -ws $particleObject`; xform -t ($destPiv[0]-$origPiv[0]) ($destPiv[1]-$origPiv[1]) ($destPiv[2]-$origPiv[2]) -r -ws $particleObject; } $zvPos = `getParticleAttr -at worldPosition ($particleObject + ".pt[0]")`; $currUnit = `currentUnit -q -linear`; if ($currUnit != "cm") { $zvPos[0] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[0])`; $zvPos[1] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[1])`; $zvPos[2] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[2])`; } xform -a -ws -t $zvPos[0] $zvPos[1] $zvPos[2] $dynLocator; $zvVel = `getParticleAttr -at velocity ($particleObject + ".pt[0]")`; // velocity relative to the particleObject %s.velocityX = $zvVel[0]; %s.velocityY = $zvVel[1]; %s.velocityZ = $zvVel[2]; undoInfo -swf 1;""" % (dyn, partic, dynLocName, partShape, c, c, c) # crea l'espressione cmds.expression(n=exprName, s=expr) # se il check e' attivo trasferisci le geometrie nel nodo dinamico if transfShapes: shapes = cmds.listRelatives(c, s=True, pa=True) if shapes: cmds.parent(shapes + [dyn], r=True, s=True) # locks [cmds.setAttr(partic + s, k=False, cb=True) for s in [".tx", ".ty", ".tz", ".rx", ".ry", ".rz", ".sx", ".sy", ".sz", ".v", ".startFrame"]] return dyn
def rotationStart(): global asT asT = cmds.playbackOptions(query=True, min=True) # Левая граница анимации global aeT aeT = cmds.playbackOptions(query=True, max=True) # Правая граница анимации resetLoopTime() global listObjects listObjects = cmds.ls(sl=True) # Список трансформов #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global listFixed listFixed = listObjects[:] for i in range(len(listFixed)): listFixed[i] = listFixed[i].replace("|", "_") #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global mainLayerName mainLayerName = "OVERLAPPER" # Имя главного слоя if (cmds.objExists(mainLayerName)): print "\n||| OVERLAPPER start |||\n" else: cmds.animLayer(mainLayerName) print "\n||| OVERLAPPER start ||| Layer created |||\n" #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| for i in range(len(listFixed)): # Основной цикл if (i + 1 != len(listFixed)): global zeroLoc zeroLoc = listFixed[i] + "_base_loc" # Имя нулевого локатора global aimLoc aimLoc = listFixed[i] + "_aim_loc" # Имя следящего локатора global tempLoc tempLoc = listFixed[i] + "_temp_loc" # Имя физического локатора global tempAimLoc tempAimLoc = listFixed[i] + "_tempAim_loc" # Имя целевого локатора global tempPart tempPart = listFixed[i] + "_temp_part" # Имя частицы global tempNucl tempNucl = "nucleus1" # Имя физической ноды global partRtype partRtype = tempPart + "Shape.particleRenderType" # Обращение к типу отображения частицы global partRrad partRrad = tempPart + "Shape.radius" # Обращение к размеру частицы global partRsm partRsm = tempPart + "Shape.goalSmoothness" # Обращение к мягкости физики global partRwe partRwe = tempPart + "Shape.goalWeight[0]" # Обращение к весу ноды global partNucl partNucl = tempNucl + ".timeScale" # Обращение к скейлу времени физ ноды global nuclStart nuclStart = tempNucl + ".startFrame" # Обращение к старту симуляции физ ноды #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.spaceLocator(n=zeroLoc) # Создаём нулевой локатор cmds.spaceLocator(n=aimLoc) # Создаём следящий локатор cmds.spaceLocator(n=tempLoc) # Создаём физический локатор cmds.matchTransform( zeroLoc, listObjects[i], pos=True ) # Перемещаем нулевой локатор в пивот главного объекта cmds.matchTransform( tempLoc, listObjects[i + 1], pos=True ) # Перемещаем физический локатор в пивот целевого объекта cmds.select(tempLoc, r=True) # Выделяем физический локатор cmds.duplicate( n=tempAimLoc) # Дублируем его и создаём целевой локатор cmds.select(listObjects[0], r=True) # Выделяем главный объект cmds.select(zeroLoc, add=True) # Выделяем нулевой локатор cmds.parentConstraint(mo=True, w=1) # Создаём пэрент констрейн cmds.select(aimLoc, r=True) # Выделяем следящий локатор cmds.select(zeroLoc, add=True) # Выделяем нулевой локатор cmds.parent(r=True) # Создаём иерархию cmds.select(listObjects[1], r=True) # Выделяем целевой объект cmds.select(tempLoc, add=True) # Выделяем физический локатор cmds.parentConstraint(mo=True, sr=["x", "y", "z"], w=1) # Создаём позиционный констрейн aimPosName = tempLoc + ".translate" # Обращение к позиции физического локатора partCenter = tempPart + ".center" # Обращение к центру частицы aimLocPos = tempAimLoc + ".translate" # Обращение к позиции целевого локатора aimPos = cmds.getAttr( aimPosName) # Берём позицию физического локатора cmds.nParticle(p=aimPos, n=tempPart, c=1) # Создаём частицу в целевой позиции cmds.goal( tempPart, w=0.5, utr=1, g=tempLoc) # Создаём физическую связь с физическим локатором cmds.connectAttr(partCenter, aimLocPos, f=True) # Привязываем целевой локатор к частице cmds.select(tempAimLoc, r=True) # Выделяем целевой локатор cmds.select(aimLoc, add=True) # Выделяем следящий локатор cmds.aimConstraint(w=1, aim=(0, 1, 0), u=(0, 1, 0), wut="vector", wu=(0, 1, 0), sk="y") # Создаём аим констреён по двум осям #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr(partRtype, pShape) cmds.setAttr(partRrad, pRad) cmds.setAttr(partRsm, goalSmoothRot) cmds.setAttr(partRwe, goalWRot) cmds.setAttr(partNucl, timeScaleRot) cmds.setAttr(nuclStart, asT) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global minLoopTime minLoopTime = aeT * -2 global maxLoopTime maxLoopTime = aeT * 2 if (cycleRot): cmds.setAttr(nuclStart, minLoopTime) cmds.bakeResults( zeroLoc, t=(asT, aeT), sm=True, at=("translate", "rotate")) # Запекание нулевого локатора для цикла cmds.bakeResults( aimLoc, t=(minLoopTime, maxLoopTime), sm=True, at="rotate") # Запекание аим локатора для цикла cmds.delete(tempAimLoc, tempLoc, tempPart, tempNucl) # Удаляем объекты физики zeroParent = zeroLoc + "_parentConstraint1" cmds.delete(zeroParent) setTimeToMin() cmds.select(aimLoc, r=True) # Выделяем аим локатор как родителя cmds.select(listObjects[i], add=True) # Выделяем объект как подчиненного cmds.parentConstraint(mo=True, st=["x", "y", "z"], w=1) # Создаём ротэйт констрейн resetLoopTime() else: cmds.bakeResults( zeroLoc, t=(asT, aeT), sm=True, at=("translate", "rotate" )) # Запекание нулевого локатора для линейной анимации cmds.bakeResults( aimLoc, t=(asT, aeT), sm=True, at="rotate" ) # Запекание аим локатора для линейной анимации cmds.delete(tempAimLoc, tempLoc, tempPart, tempNucl) # Удаляем объекты физики zeroParent = zeroLoc + "_parentConstraint1" cmds.delete(zeroParent) resetLoopTime() cmds.select(aimLoc, r=True) # Выделяем аим локатор как родителя cmds.select(listObjects[i], add=True) # Выделяем объект как подчиненного cmds.parentConstraint(mo=True, st=["x", "y", "z"], w=1) # Создаём ротэйт констрейн #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| layerBase = "rotate_" # Имя базы слоя layerName = layerBase + listFixed[i] # Имя слоя layerComp = listFixed[i] + '_layer_{0}'.format( "0") # Имя компонента слоя if (cmds.objExists(layerName)): cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="rotate") # Запекаем объект в слой cmds.select(listObjects[i], r=True) cmds.setInfinity(pri="cycle", poi="cycle") cmds.delete(aimLoc, zeroLoc) # Удаляем объекты скрипта cmds.container("BakeResultsContainer", e=True, rc=True) # Удаляем контейнер cmds.animLayer( "BakeResults", e=True, p=layerName ) # Переносим слой с анимацией в основной слой объекта cmds.rename("BakeResults", layerComp) # Переименовываем слой resetLoopTime() else: cmds.animLayer( layerName ) # Создаём пустой слой для всех оверлапов объекта cmds.animLayer( layerName, e=True, p=mainLayerName) # Переносим базу слоя в главный слой cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="rotate") # Запекаем объект в слой cmds.select(listObjects[i], r=True) cmds.setInfinity(pri="cycle", poi="cycle") cmds.delete(aimLoc, zeroLoc) # Удаляем объекты скрипта cmds.container("BakeResultsContainer", e=True, rc=True) # Удаляем контейнер cmds.animLayer( "BakeResults", e=True, p=layerName ) # Переносим слой с анимацией в основной слой объекта cmds.rename("BakeResults", layerComp) # Переименовываем слой resetLoopTime() cmds.select(d=True) # Деселект for l in listObjects: cmds.select(l, add=True) print "\n||| OVERLAPPER end |||\n"
def positionStart(): cmds.currentTime(asT) # Установка времени в начало анимации listObjects = cmds.ls(sl=True) # Список трансформов mainLayer = "" # Имя глвыного слоя if (cmds.objExists("OVERLAPPER")): print "\n||| OVERLAPPER layer already exist |||\n" else: mainLayer = cmds.animLayer("OVERLAPPER") print "\n||| OVERLAPPER layer created |||\n" for i in range(len(listObjects)): # Основной цикл aimLoc = listObjects[i] + "_aim_loc" # Имя аим локатора tempLoc = listObjects[i] + "_temp_loc" # Имя физ локатора tempPart = listObjects[i] + "_temp_part" # Имя физ частицы tempNucl = "nucleus1" # Имя физ ноды partAimLoc = aimLoc + ".translate" # Обращение к позиции аим локатора partRtype = tempPart + "Shape.particleRenderType" # Обращение к типу отображения частицы partRrad = tempPart + "Shape.radius" # Обращение к размеру частицы partRsm = tempPart + "Shape.goalSmoothness" # Обращение к мягкости физики partRwe = tempPart + "Shape.goalWeight[0]" # Обращение к весу ноды partPos = tempPart + ".center" # Обращение к центру частицы partNucl = tempNucl + ".timeScale" # Обращение к скейлу времени физ ноды cmds.spaceLocator(n=tempLoc) # Создаём физ локатор cmds.matchTransform(tempLoc, listObjects[i], pos=True) # Перемещаем локатор в пивот объекта objCenter = tempLoc + ".translate" # Обращение к центру объекта objC = cmds.getAttr(objCenter) # Записываем центр объекта locCenter = tempLoc + ".center" # Обращение к центру физ локатора locTr = tempLoc + ".translate" # Обращение к позиции физ локатора cmds.nParticle(p=objC, n=tempPart, c=1) # Создаём частицу в целевой позиции cmds.goal(tempPart, w=goalW, utr=1, g=tempLoc) # Создаём физическую связь cmds.select(tempLoc, r=True) # Выделяем физ локатор cmds.select(listObjects[i], add=True) # Выделяем целевого родителя cmds.parent(r=True) # Создаём иерархию cmds.matchTransform(tempLoc, listObjects[i], pos=True) # Перемещаем локатор в пивот объекта cmds.setAttr(partRtype, pShape) cmds.setAttr(partRrad, pRad) cmds.setAttr(partRsm, goalSmooth) cmds.setAttr(partRwe, goalW) cmds.setAttr(partNucl, timeScale) cmds.duplicate(tempLoc, rr=True, n=aimLoc) # Дублируем локатор cmds.select(aimLoc, r=True) # Выделяем аим локатор cmds.parent(w=True) # Разбираем иерархию cmds.connectAttr(partPos, partAimLoc, f=True) # Привязываем аим локатор к частице if (cycle): cmds.bakeResults( aimLoc, t=(asT, aeT * 3), sm=True, at="translate") # Запекание аим локатора для цикла cmds.select(aimLoc, r=True) # Выделяем аим локатор cmds.keyframe(tc=-aeT, r=True) # Сдвигаем тройной цикл на один проход влево else: cmds.bakeResults( aimLoc, t=(asT, aeT), sm=True, at="translate") # Запекание аим локатора для линейной анимации cmds.delete(tempLoc, tempPart, tempNucl) # Удаляем объекты физики cmds.select(aimLoc, r=True) # Выделяем аим локатор как родителя cmds.select(listObjects[i], add=True) # Выделяем объект как подчиненного cmds.parentConstraint(mo=True, sr=["x", "y", "z"], w=1) # Создаём позиционный констрейн layerBase = "overlap_" # Имя базы слоя layerName = layerBase + listObjects[i] # Имя слоя layerComp = listObjects[i] + '_layer_{0}'.format( 0) # Имя компонента слоя if (cmds.objExists(layerName)): cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="translate") # Запекаем объект в слой cmds.delete(aimLoc) # Удаляем объекты скрипта cmds.container("BakeResultsContainer", e=True, rc=True) # Удаляем контейнер cmds.animLayer( "BakeResults", e=True, p=layerName ) # Переносим слой с анимацией в основной слой объекта cmds.rename("BakeResults", layerComp) # Переименовываем слой else: cmds.animLayer( layerName) # Создаём пустой слой для всех оверлапов объекта cmds.animLayer(layerName, e=True, p=mainLayer) # Переносим базу слоя в главный слой cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="translate") # Запекаем объект в слой cmds.delete(aimLoc) # Удаляем объекты скрипта cmds.container("BakeResultsContainer", e=True, rc=True) # Удаляем контейнер cmds.animLayer( "BakeResults", e=True, p=layerName ) # Переносим слой с анимацией в основной слой объекта cmds.rename("BakeResults", layerComp) # Переименовываем слой cmds.select(d=True) # Деселект for l in listObjects: cmds.select(l, add=True) print "\n||| The Overlapper just saved your time |||\n" ####################################################################################################################