Go to: Synopsis. Return value. Related.
Flags. Python
examples.
emit([attribute=string], [floatValue=float], [object=string], [position=[float, float, float]],
[vectorValue=[float, float,
float]])
Note: Strings representing object names and
arguments must be separated by commas. This is not depicted in the
synopsis.
emit is undoable, NOT queryable, and NOT
editable.
The emit action allows users to add particles to an existing
particle object without the use of an emitter. At the same time, it
allows them to set any per-particle attribute for the particles
that are created with the action.The particles created do not
become a part of the initial state for the particle object, and
will disappear when the scene is rewound unless they are saved into
the initial state by the user explicitly. In addition, a particle
object will accept particles from an emit action ONLY at frames
greater than or equal to its start frame. For example, if you want
to use the emit action to create particles at frame -5, you must
set startFrame for that particle shape to -5 or less.Unlike many
commands or actions, the emit action uses the order of its flags as
important information as to how it works. The -object and
-position flags can appear anywhere in the argument list.
The -attribute and the value flags are interpreted based on
their order. Any value flags after an -attribute flag and before
the next -attribute flag will set the values for the attribute
specified by the closest -attribute flag before them in the
argument list. See the Examples section below for more
detail on how these flags work.Currently, no creation expression is
executed for the new particles unless they are created from within
a particle expression defined with the dynExpression command
or the Expression Editor. If you want any particular values put
into the particles at the time they are created, then those values
should be set using the -attribute, -vectorValue, and
-floatValue flags.
| int[] |
Integer array containing the list of the particleId attribute
values for the created particles in the same order that the
position flags were passed. |
particle
attribute, floatValue, object,
position, vectorValue
| Long name (short name) |
Argument types |
Properties |
object(o) |
string |
 |
|
This flag takes the name of a particleShape or the transform
directly above it in the DAG as its parent. It specifies which
object to add the particles to. This flag must be passed, as the
selection list is ignored for this action. |
|
position(pos) |
[float, float, float] |
 |
|
Specifies the positions in the particle object's space (usually
world space) where the particles are to be created. One particle is
created for each occurence of this flag. |
|
attribute(at) |
string |
|
|
Specifies the attribute on the particle object that any value
flags following it and before the next -attribute flag will be
associated with. The same attribute can be specified later in the
command to pick up where the first one left off. The attributes
used must be per-particle attributes. This will accept both long
and short names for the attributes. Note the per-particle attribute
must already exist on the particle object prior to being specified
via this command flag. |
|
vectorValue(vv) |
[float, float, float] |
|
|
Sets the vector value to be used for the "current" attribute of
the "current" particle. By current attribute, it is meant the
attribute specified by the most recent -attribute flag. By current
particle, it is meant the particle in the list of -position flags
that corresponds to the number of values that have been set for the
"current" attribute. If the current attribute is a
float-per-particle attribute, then the length of the vector
described by this flag will be used. The length is described as
SQR( xVal2 + yVal2 + zVal2
). |
|
floatValue(fv) |
float |
|
|
Sets the float value to be used for the "current" attribute of
the "current" particle. By current attribute, it is meant the
attribute specified by the most recent -attribute flag. By current
particle, it is meant the particle in the list of -position flags
that corresponds to the number of values that have been set for the
"current" attribute. If the current attribute is a
vector-per-particle attribute, then the float value specified will
be used for all three components of the vector. |
|
| Flag can appear in Create mode of
command |
 Flag can appear in Edit mode of command |
 Flag can appear in Query mode of command |
Flag can have multiple arguments, passed
either as a tuple or a list. |
import maya.cmds as cmds
cmds.particle()
cmds.emit( object='particle1', position=(1, 1, 1) )
# This will create one particle at position <<1,1,1>> in the
# already-existing particle object <i>particle1</i>.
#
cmds.particle()
cmds.emit( object='particle1', position=((1, 1, 1), (2, 2, 2)), attribute=('velocity', 'rgbPP'), vectorValue=((1, 2, 3), (2, 3, 4), (.5, 1, 0)), floatValue=.1 )
# This will create two particles at positions <<1,1,1>> and <<2,2,2>> in
# the already-existing particle object <i>particle1</i>. Then the velocity
# attribute of those particles is set to <<1,2,3>> and <<2,3,4>>,
# respectively. Also, the rgbPP values are set to <<.5,1,0>> and
# <<.1,.1,.1>>, respectively. Notice that the rgbPP value for the
# second particle was set with the -floatValue flag, even though rgbPP
# is a vector attribute. The single value was converted into a vector.
cmds.particle()
cmds.emit( object='particle1', position=((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4), (5, 5, 5)), attribute=('velocity', 'mass', 'velocity'), vectorValue=((1, 2, 3), (2, 3, 4), (.1, .2, .3), (3, 4, 5)), floatValue=.5)
# This will create five particles in <i>particle1</i>. The values
# for their attributes are:
#
# Attribute Particle1 Particle2 Particle3 Particle4 Particle5
# ----------+-----------+-----------+-----------+-----------+---------
# position <<<<1,1,1>>>> <<<<2,2,2>>>> <<<<3,3,3>>>> <<<<4,4,4>>>> <<<<5,5,5>>>>
# velocity <<<<1,2,3>>>> <<<<2,3,4>>>> <<<<3,4,5>>>> <b><<<<3,4,5>>>> <<<<3,4,5>>>></b>
# mass .5 .3742 <b>.3742 .3742 .3742</b>
#
# Notice that the second value for mass was seet with the -vectorValue
# flag, even though mass is a float attribute. The vector was
# converted into a float by taking its length. Also, notice the <b>bold</b>
# values in the table. The values for those attribute values were not
# explicitly set in the command. If there are fewer values given for
# an attribute than there are position flags, the remaining unset
# values are set to the last value set for that attribute. This
# allows the user to set many of the values to be the same without
# having to use multiple value flags. One last note. Notice that the
# attribute flag was passed twice for the attribute velocity. The value
# flags for repeated attributes pick up where the previous ones left
# off.
x = rand(1)
y = rand(1)
z = rand(1)
p = sphrand(5)
cmds.emit( object='particle1', pos=((x, y, z), ('($p.x)', '($p.y)', '($p.z)')) )
# This is a piece of Python code that could be put in a script or
# even in an expression. It adds a random number of particles
# to the already-existing particle object <i>particle1</i>. Since
# the number of particles as well as the positions and velocities
# of the particles are random, it would be impossible to just have
# the emit action itself in the expression or script. It must be
# built as a string and then sent to the command processor with the
# <b>eval</b> or <b>evalEcho</b> commands. Notice that when appending
# the vector variables to the string, it is not necessary to append
# each component of the vectors separately. When they are converted
# from a vector to a string, the three components get separated with
# a space automatically, thus formatting them in the desired way.
# An example of a possible result from this "script" could be:
cmds.emit( object='particle1', pos=((1.899864198, -6.721569708, 0.585203937), (8.103957656, -4.042442985, 2.047724209), (-1.392914569, -0.109724376, 8.62265813), (1.960103537, -3.203145195, -7.6892516), (2.564072614, -6.049536895, 1.334818295), (-5.603376821, 4.33595058, 6.952385447), (-2.478591746, 6.286855715, 6.851659059), (2.424670276, -4.083412217, 6.320538621), (6.440800453, 3.405519296, 5.462135819), (2.445192551, 1.397203422, 3.443755853)), at='velocity', vv=((-2.348796409, 4.022130218, 0.5316172944), (4.149667117, -1.023146404, 1.97965556), (-0.08429132578, -0.5518495233, 1.591812495), (2.597930963, 1.033536331, -1.398351383), (-3.102859272, 3.423569856, 0.7895603241), (-2.519331228, -2.5684916, -1.530779154), (-2.645169119, -0.3186551381, 0.9164776099), (-0.6183816487, -1.060784068, -0.8748223942), (-0.2460372256, 3.567980747, -2.007567372), (1.735044809, -3.660099445, -1.765401859)) )
# The spacing in the string is just for formatting reasons and does
# not affect how the action executes or compiles.