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"
####################################################################################################################
