MAXScript Language Reference > 3ds Max Objects > Node : MAXWrapper > Node Subclasses > GeometryClass : Node > Geometry - Particle Systems >

# PArray : GeometryClass

    PArray - superclass: GeometryClass; super-superclass:node - classID: #(238822837, 278730329)

Value > MAXWrapper > Node > GeometryClass > Particle Systems > PArray

| Geometry Objects - Quick Navigation

Constructor:

    parray...

Properties:

## Basic Parameters

    <PArray>.emitter Node default: undefined

The object which acts as an emitter.

    <PArray>.formation Integer default: 0 -- alias: Emitter_Distribution

Set the emitter distribution type:

0-Over Entire Surface (Emits particles randomly over the entire surface of the object-based emitter.)

1-Along Visible Edges (Emits particles randomly from the visible edges of the object.)

2-At All Vertices (Emits particles from the vertices of the object.)

3-At Distinct Points (Places a specified number of emitter points randomly over the surface of the object.)

4-At Face Centers (Emits particles from the center of each triangular face.)

    <PArray>.numDistinctPoints Integer default: 20 -- alias: Number_of_Emitters

The number of emitter points used when At Distinct Points is chosen.

    <PArray>.Use_Selected_Subobjects Integer default: 0 -- animatable

With mesh-based emitters, this limits the source of the particle stream to the sub-object selection passed up the modifier stack in the object-based emitter.

0- Off

1- On

    <PArray>.iconsize Float default: 20.0 -- alias: Emitter_Width

The width of the emitter icon.

    <PArray>.iconHidden Boolean default: false

When on, hides the emitter in viewports. When off, the emitter is displayed in viewports. The emitter is never rendered.

    <PArray>.viewType Integer default: 0

Set the display icon for particles in the viewport:

0-Dots (Displays the particles as dots.)

1-Ticks (Displays the particles as crosses.)

2-Mesh (Displays the particles as mesh objects. This results in slower viewport redraws.)

3-Bbox (For instanced geometry only, this displays each instanced particle, whether a single object, a hierarchy, or a group, as a bounding box.)

    <PArray>.viewPercent Float default: 10.0 -- percentage, alias: Percentage_Displayed

The percentage of particles displayed in the viewport.

## Particle Generation

    <PArray>.quantityMethod Integer default: 0

Set the method by which the number of particles is determined over time:

0- Use Rate (Specifies a fixed number of particles emitted per frame.)

1- Use Total (Specifies a total number of particles formed over the life of the system.)

Tip: Generally, Use Rate is best for a continuous flow of particles, like a trail of pixie dust, while Use Total is better for bursts of particles over a short period of time.

    <PArray>.Birth_Rate Integer default: 10 -- animatable

The number of particles emitted per frame.

    <PArray>.Total_Number Integer default: 100

The total number of particles to be emitted.

    <PArray>.speed Float default: 10.0 -- animatable

The velocity of the particle at birth, along the normal, in units traveled per frame.

    <PArray>.Speed_Variation Float default: 0.0 -- animatable, percentage

Percentage of variation to the speed of emission for each particle.

    <PArray>.Divergence_Angle Float default: 10.0 -- animatable, angle

Applies an angular degree of variation by which each particle's velocity can vary from the emitter normal.

    <PArray>.Emitter_Start Time default: 0f

The frame at which particles begin to exist in the scene.

    <PArray>.Emitter_Stop Time default: 30f

The last frame at which particles are emitted.

    <PArray>.Display_Until Time default: 100f

Time at which all particles will disappear, regardless of other settings.

    <PArray>.life Time default: 30f -- animatable

The lifespan of each particle from the time of creation.

    <PArray>.Life_Variation Time default: 0f -- animatable

The number of frames by which the life of each particle can vary from the norm.

    <PArray>.subsampleCreationTime Boolean default: false

When on, enables the addition of a time offset to the equations of motion that prevents puffing in time.

    <PArray>.subsampleEmitterTranslation Boolean default: true

If the object-based emitter is moving in space, particles are created at integral times at positions along the geometry's path between renderable positions. This prevents puffing in space.

    <PArray>.subsampleEmitterRotation Boolean default: true

If the emitter is rotating, turn this on to avoid puffing and produce smooth spiral effects.

    <PArray>.size Float default: 1.0 -- animatable

The target size for all particles in the system.

    <PArray>.Size_Variation Float default: 0.0 -- animatable, percentage

The percentage by which the size of each particle may vary from the norm.

    <PArray>.Growth_Time Time default: 10f

The number of intervals over which the particle grows from being very small (0.1a system constant) to the Size value.

    <PArray>.Fade_Time Time default: 10f

The number of intervals over which the particle will shrink to 1/10 th its Size setting prior to its death.

    <PArray>.seed Integer default: 0 -- alias: Random_Seed

By changing the Seed value, you achieve different results using otherwise identical particle settings.

## Particle Type

    <PArray>.particleType Integer default: 0

The type of particle emitted:

0-Standard Particle (Uses one of several standard particle types, such as triangle, cube, tetra, and so on.)

1-MetaParticles (Uses Metaball particles. These are particle systems in which the individual particles blend together in blobs or streams.)

2-Object Fragments (Creates particles out of fragments of an object.)

3-Instanced Geometry (Generates particles that are instances of either an object, a linked hierarchy of objects, or a group.)

    <PArray>.standardParticle Integer default: 0

Set the type of particle used when standard particles is selected:

0-Triangle (Renders each particle as a triangle. Use Triangle particles with noise opacity for steam or smoke.)

1-Cube (Renders each particle as a cube.)

2-Special (Each particle consists of three intersecting 2D squares. These are effective when you use a face-map material, optionally along with an opacity map, to create the effect of a three-dimensional particle.)

3-Facing (Renders each particle as a square that always faces the view. Use with an appropriate opacity map for bubbles or snowflakes.)

4-Constant (Provides a particle that remains the same size, in pixels, specified by thesizevalue. This size never changes, regardless of its distance from the camera. Note that this particle type can only be displayed in the viewports as a dot or a tick. If you turn on this option while Mesh is selected, the viewport display is automatically switched to Ticks.)

5-Tetra (Renders each particle as a mapped tetrahedron, whose tail points toward the normal vector of the emission, and whose head points away. Use Tetra particles for raindrops or sparks.)

6-SixPoint (Renders each particle as a six-pointed, two-dimensional star.)

7-Sphere (Renders each particle as a sphere.)

    <PArray>.Metaparticle_Tension Float default: 1.0 -- animatable

Determines the tightness of the particles, with regard to their tendency to blend with other particles. The higher the Tension, the harder the blobs, and the harder it is for them to merge.

    <PArray>.Metaparticle_Tension_Variation Float default: 0.0 -- animatable, percentage

The percent of variation of the Tension effect.

    <PArray>.metaballRenderCoarsness Float default: 0.5 -- alias: Metaparticle_Coarseness

The coarseness for metaparticles in the rendered scene.

    <PArray>.metaballViewCoarsness Float default: 1.0

The coarseness for the viewport display.

    <PArray>.metaballAutoCoarsness Boolean default: true

When this is on, the rendering coarseness is automatically set, based on the size of the particles, and the viewport coarseness is set to about twice that of the rendering coarseness.

    <PArray>.fragmentMethod Integer default: 0

Method for object fragment particles:

0-All Faces (Each face of the object becomes a particle. This results in triangular particles.)

1-Number of Chunks (The object breaks into irregular fragments.)

2-Smoothing Angle (The fragments are broken based on the angles between face normals, as specified in the fragSmoothingAngle value. Generally, the higher the value, the fewer the number of fragments.)

    <PArray>.Fragment_Thickness Float default: 1.0

Sets the thickness of the fragments. At 0, the fragments are single-sided with no thickness. When greater than 0, the fragments are extruded, at fragmentation time, by the amount specified. The outer and inner surfaces of the fragment use identical smoothing, which is picked up from the object-based emitter. The edges of the fragments are not smoothed.

    <PArray>.fragChunkMinimum Integer default: 100 -- alias: Fragment_Count

Determines a number of "seed" faces in the geometry. Each seed face collects connecting faces surrounding it until all available faces are exhausted. Any leftover faces become unique particles, thus increasing the minimum number of fragments.

    <PArray>.fragSmoothingAngle Float default: 0.0

Sets the amount of smoothing angle.

    <PArray>.instancingObject Node default: undefined

The object which is instanced.

    <PArray>.instanceSubTree Boolean default: false

Turn this on when you want to include the linked children of the picked object in the particle. If the picked object is a group, all children of the group are included.

    <PArray>.instanceKeyOffsetType Integer default: 0

Set the animation offset keying:

0-None (Each particle duplicates the timing of the original object. As a result, the animation of all particles will be identically timed.)

1-Birth (The firstborn particle is an instance of the current animation of the source object at the moment of that particle's birth. Each subsequent particle then use the same start time for the animation.)

2-Random (This option is the same as None when Frame Offset is set to 0. Otherwise, each particle is born using the same animation as the source object at the time of birth, but with a random offset of frames, based on the . instanceFrameOffset value.)

    <PArray>.instanceFrameOffset Integer default: 0 -- alias: Animation_Offset_Amount

The property value is the UI value times the number of ticks per frame. The number of ticks per frame is accessible via the ticksPerFrame system global variable.

    <PArray>.mappingType Integer default: 0

Specifies how a mapped material affects the particles:

0-Time (Maps particles over time.)

1-Distance (Maps particles over a distance.)

    <PArray>.Mapping_Time_Base Time default: 30f -- animatable

The number of frames from the birth of the particle that it takes to complete one mapping of the particle.

    <PArray>.Mapping_Distance_Base Float default: 100.0 -- animatable

The distance, in units, from the birth of the particle that it takes to complete one mapping of the particle.

    <PArray>.materialSource Integer default: 0

Updates the material carried by the particle system, using the source specified:

0-Icon (The particles use the material currently assigned to the particle system icon.)

1-Picked Emitter (The particles use the material assigned to the distribution object.)

2-Instanced Geometry (The particles use the material assigned to the instanced geometry.)

    <PArray>.fragOutsideMatID Integer default: 0

Specifies which face ID number is assigned to the outside faces of the fragments. This defaults to 0, which is not a valid ID number, forcing the outside of the particle fragments to use whatever material is currently assigned to the associated faces. Thus, if your distribution object already has several submaterials assigned to its outer faces, these materials are retained by using ID 0. If you want a single, specific submaterial, you can assign it by changing this value.

    <PArray>.fragEdgeMatID Integer default: 2

Specifies which submaterial ID number is assigned to the edges of the fragments.

    <PArray>.fragBackMatID Integer default: 3

Specifies which submaterial ID number is assigned to the back sides of the fragments.

## Rotation and Collision

    <PArray>.Spin_Time Time default: 0f -- animatable

The number of frames for one rotation of a particle. If set to 0, no rotation takes place.

    <PArray>.Spin_Time_Variation Float default: 0.0 -- animatable, percentage

The percent of variation of the Spin Time.

    <PArray>.Spin_Phase Float default: 0.0 -- animatable, angle

The initial particle rotation, in degrees.

    <PArray>.Spin_Phase_Variation Float default: 0.0 -- animatable, percentage

The percent of variation of the Phase.

    <PArray>.spinAxisType Integer default: 0

The spin axis for the particles:

0-Random (The spin axis for each of the particles is random.)

1-Direction of Travel/Mblur (Rotates the particles about a vector formed by the direction in which they're moving.)

2-User Defined (Uses a vector defined in the three X, Y, and Z spin vector values.)

    <PArray>.Blur_Stretch Integer default: 0 -- animatable

When greater than 0, the particles stretch along the travel axis, depending on their speed. Specifically, the Stretch value specifies the percent of their length per each unit of the Speed setting (in the Particle Motion group). Thus, if you set Stretch to 2 while Speed is set at 10, the particles are stretched 20 percent longer than their original size along the axis of their travel. This value is only available when you choose Direction of Travel/Mblur.

    <PArray>.X_Spin_Vector Float default: 1.0 -- animatable

Spin vector of the X-axis.

    <PArray>.Y_Spin_Vector Float default: 0.0 -- animatable

Spin vector of the Y-axis.

    <PArray>.Z_Spin_Vector Float default: 0.0 -- animatable

Spin vector of the Z-axis.

    <PArray>.Spin_Axis_Variation Float default: 0.0 -- animatable, angle

The amount, in degrees, by which the spin axis of each particle may vary from the specified X Axis, Y Axis, and Z Axis settings.

    <PArray>.Interparticle_Collisions_On Integer default: 0

Turn on/off interparticle collisions:

0- Off

1- On

    <PArray>.Interparticle_Collision_Steps Integer default: 2

The number of intervals per rendering interval, during which an inter-particle collision test is conducted. The higher the value, the more accurate the simulation, but the slower the simulation will run.

    <PArray>.Interparticle_Collision_Bounce Float default: 100.0 -- animatable, percentage

The degree to which speed is recovered after a collision.

    <PArray>.Interparticle_Collision_Bounce_Variation Float default: 0.0 -- animatable, percentage

The percentage of random variation of the Bounce value, applied to the particles.

## Object Motion Inheritance

    <PArray>.motionInfluence Float default: 100.0 -- animatable, alias: Object_Motion_Inheritance

The percent of particles that inherit the motion of the object-based emitter at the moment of particle formation.

    <PArray>.motionMultiplier Float default: 1.0 -- animatable, alias: Object_Motion_Multiplier

Modifies the amount by which the emitter motion affects the particle motion. This can be a positive or negative number.

    <PArray>.motionVariation Float default: 0.0 -- animatable, percentage; alias: Object_Motion_Multiplier_Variation

Percentage of variation of the Multiplier value.

## Bubble Motion

    <PArray>.Bubble_Amplitude Float default: 0.0 -- animatable

The distance the particle moves off its usual velocity vector as it travels.

    <PArray>.Bubble_Amplitude_Variation Float default: 0.0 -- animatable, percentage

The percent of Amplitude variation applied to each particle.

    <PArray>.Bubble_Period Time default: 100000f -- animatable

The cycle time for one complete oscillation of a particle through the bubble "wave". A recommended value might be 20-30 intervals.

    <PArray>.Bubble_Period_Variation Float default: 0.0 -- animatable, percentage

The percent of Period variation for each particle.

    <PArray>.Bubble_Phase Float default: 0.0 -- animatable, angle

The initial displacement of the bubble pattern along the vector.

    <PArray>.Bubble_Phase_Variation Float default: 0.0 -- animatable, percentage

The percent of Phase variation for each particle.

## Particle Spawn

    <PArray>.spawnType Integer default: 0

Determines what happens to particles at either collision or death:

0-None (Particles act as they normally would. That is, upon collision, they either bounce or stick, depending on Particle Bounce settings in the deflector, and on death they disappear.)

1-Die After Collision (Particles disappear when they strike a deflector to which they're bound, such as the SDeflector.)

2-Spawn on Collision (Spawn effects take place upon collision with a bound deflector.)

3-Spawn on Death (Spawn effects take place at the end of each particle's life.)

4-Spawn Trails (Particles are spawned from existing particles at each frame of that particle's life.)

    <PArray>.Die__X_frames_after_collision Time default: 0f -- animatable

The life, in frames, that the particle will persist after the collision. Setting this to 0 (the default) causes particles to vanish immediately after the collision.

    <PArray>.Die__X_frames_after_collision_variation Float default: 0.0 -- animatable, percentage

Varies the Persist value of each particle, when Persist is greater than 0. This lets you "feather" the dying off of the particle density.

    <PArray>.Spawn_Generations Integer default: 1

The number of spawns beyond the original particle generation. For example, if this is set to 1, and you're spawning at death, one spawning will occur beyond the original lifespan of each particle.

    <PArray>.Spawn_Affects Integer default: 100

The percentage of particles that will spawn. Reducing this reduces the number of particles that produce spawned particles.

    <PArray>.Spawn_Multiplier Integer default: 1

Multiplies the number of particles spawned at each spawning event.

    <PArray>.Spawn_Multiplier_Variation Float default: 0.0 -- percentage

Percentage range by which the Multiplier value will vary, frame by frame.

    <PArray>.Spawn_Direction_Chaos Float default: 0.0 -- animatable, percentage

The amount by which the direction of the spawned particle can vary from the direction of the parent particle. A setting of 0 means no variance. A setting of 100 causes the spawned particle to travel in any random direction. A setting of 50 causes the spawned particle to deviate from its parent's path by up to 90 degrees.

    <PArray>.Spawn_Speed_Chaos Float default: 0.0 -- animatable

Random percentage range of scaling of the spawned particles relative to their parents, and dependent on the options below.

    <PArray>.spawnSpeedType Integer default: 0

Sets the type of speed applied to spawn particles:

0-Slow (Applies the .spawn_Speed_Chaos value randomly to slow the speed of the spawned particles.)

1-Fast (Randomly speeds up particles based on the .spawn_Speed_Chaos value.)

2-Both (Some particles speed up, while others slow down, based on the .spawn_Speed_Chaos value.)

    <PArray>.spawnInheritVelocity Boolean default: false

When on, spawned particles inherit the speed of their parents, in addition to the effect of the .spawn_Speed_Chaos value.

    <PArray>.spawnSpeedFixed Boolean default: false

When on, uses the . spawn_Speed_Chaos value as a set value, rather than as a range applied randomly to each particle.

    <PArray>.Spawn_Scale_Chaos Float default: 0.0 -- animatable

The range of a percentage of change in the speed of the spawned particle relative to its parent. A value of 0 means no change.

    <PArray>.spawnScaleType Integer default: 0

The type of speed scaling for the spawned particles:

0-Slow (Applies the speed factor randomly to slow the speed of the spawned particles.)

1-Fast (Randomly speeds up particles based on the speed factor.)

2-Both (Some particles speed up, while others slow down, based on the speed factor.)

    <PArray>.spawnScaleFixed Boolean default: false

When on, uses the .spawn_Scale_Chaos value as a set value, rather than as a range applied randomly to each particle.

    <PArray>.lifespanValueQueue Array default: #()

lifespanValueQueue is an array of integers which correspond to lifespan values for each spawned generation of particles.

    <PArray>.Spawn_Lifespan Integer default: 0

Value that sets initial lifespan of spawned particles.

    <PArray>.objectMutationQueue Array default: #()

objectMutationQueue is an array of nodes which correspond to instanced-object particle types. Each generation of spawning will use the next node as its object type.

#### See Also

- Particle System Common Properties, Operators, and Methods

- Node Common Properties, Operators, and Methods

- MAXWrapper Common Properties, Operators, and Methods

- Value Common Properties, Operators, and Methods