Modifiers
Modifiers make changes to the transforms or other properties of packed primitives. They're commonly used to animate or otherwise manipulate objects in intuitive ways. If you need more control over primitives than what the built-in Modifiers give you, try using Tools nodes to get the exact result you're looking for.
The MOPs Aim Modifier orients copies towards a particular point in space, towards an object's centroid, or towards an individual point per-primitive (matched by the id attribute). The instances will have their "forward" or "aim" vector aligned to point directly to the target position, but you'll need to define an up vector yourself. You can either use the Up Vector parameter on the MOPs Aim Modifier, or define a v@up attribute on your primitives ahead of time (or use MOPs Extract Attributes to get it).
AKA MOPs Pivot. The MOPs Align Modifier moves the pivots of packed primitives relative to the individual bounding box of each primitive. This pivot adjustment can either be applied as a transformation of the primitive itself, or as an invisible adjustment of the pivot only. You can use this Modifier to ensure that the pivots of objects of different sizes and shapes are all scaling or rotating from the same relative positions. You can also explicitly set a pivot, either in local or world space. This allows for all kinds of interesting transformations with clever pivot use.
This node smoothly clips (cuts) geometry at a point attribute threshold. This means that if you have a polygon where the bottom points have @attr=0.0 and the top points have @attr=1.0, a threshold value of 0.5 will slice the polygon roughly down the middle. You can animate this threshold to smoothly grow or erode geometry in interesting ways. A built-in noise option can help break up the cut shapes into more organic forms.
The MOPs Color Modifier simply assigns colors from a ramp based on the value of each copy's @mops_falloff attribute.
Note: This node is being replaced by the MOPs Noise Modifier.
MOPs Curl Modifier pushes instances around based on a curl noise field. Curl noise is great for approximating liquid-like or gaseous-like effects because it's inherently non-divergent; meaning, the noise field itself doesn't self-intersect. In Simple mode, instances are just procedurally moved around by adding the value of the curl noise to @P. In Advect mode, instances are pushed along the noise field over time, like a solver. You can generate trails from the motion of your objects only in Advect mode.
The Aim Weight determines how quickly your objects rotate to match their direction of motion. The default value of 0.1 is a good starting point so that objects have a little momentum. Higher values will quickly snap your objects to the direction of motion.
If you're using Advect mode and you want the attributes of your copies to update over time, add those attributes to the "Update Attributes" parameter under Solver Settings. By default this will update @mops_falloff so that you can animate it before applying the curl noise.
MOPs Curve Toys is a catch-all operator designed to deform polyline curves in interesting ways. There are currently three operations: Rollup, Unroll, and Helix. Rollup (left) takes an input curve and rolls it up like a carpet. The amount of rolling, or the tightness of the spiral, can be controlled by Falloff attributes. Unroll (center) takes non-straight curves and forces them to straighten out, modulated by falloff. Helix (right) winds input curves into a corkscrew or wave pattern (depending on each axis of the Amplitude parameter).
These curve operations are very sensitive to the input orientation of the curve. If your curve doesn't already have an orientation, use MOPs Orient Curve or the Orientation Along Curve SOP to create one. If the resulting operation looks a little strange, for example your rolled-up curve isn't rolled up along a plane, try changing the "direction" of your curve orientation tool from "Next Edge" to "Previous Edge".
MOPs Deintersect uses the Bullet solver to force objects apart so they don't overlap. You can optionally constrain the packed primitives so that they will only translate or only rotate in order to resolve overlaps, or even constrain them to a surface as in the example above. Because MOPs Deintersect is using Bullet, it's important to make sure that your objects are comprised of convex hulls for predictable and fast results. MOPs Collision Geo or the Convex Decomposition SOP are both good choices to ensure that your objects will work with Bullet.
MOPs Delay offsets existing animation of instances in time, based on the @mops_falloff attribute. Higher falloff values mean a longer delay, with a falloff of 1 equivalent to a delay (in seconds) of the Delay Amount parameter. You can delay both the transforms of instances, or the timing of Packed Disk Sequences / Packed Alembics created via a MOPs Instancer if Do Sequence Delay is checked.
MOPs Delay is technically a solver, so if you see unexpected results, try hitting the "Reset Simulation" button to force the simulation to reload.
MOPs Edit is like the Edit SOP, but for packed primitives. While the regular Edit SOP can transform packed primitives as well as polygon geometry, MOPs Edit can do so in local space for each packed primitive. This can be handy for things like set dressing, if you need to quickly make fine adjustments to the transforms of lots of packed primitives at once. You can also switch the dropdown Edit Type to "duplicate", which will create copies of the selected primitive.
MOPs Edit has its own special handle that you can activate with the Enter key, just like other nodes. To cycle handles, press Y. To commit your changes, press ESC.
MOPs Filter applies a temporal filter to the transform attributes of a point or packed primitive. It can additionally filter any float, vector or vector4 attribute. This filtering smooths out animation, removing jittering or other sudden changes. The filter is driven by a simulation, not CHOPs, so it tends to scale well with higher point counts. A higher sample count will filter more samples, generally resulting in smoother motion. The Filter Types are listed roughly in order of how "smooth" they are, with Gauss filtering generally being the most aggressive. Changing the sample count requires resimulating, but you can change the Filter Type instantly.
MOPs Magnetize pushes or pulls objects towards or away from points in a point cloud. The influence of each point can be set using an optional weight attribute. Objects can optionally be made to aim in the direction of displacement, aiming more towards this vector depending on how much they're being pushed or pulled.
Your Search Distance should always be higher than your Effect Radius in order to avoid visible snapping behavior as objects move in and out of the maximum influence radius of the point cloud.
MOPs Move Along Mesh works in two phases: first, it attaches instances to the mesh based on proximity or random scattering; second, it pushes instances along the mesh based on the orientation of the mesh. The "up" vector of the chosen mesh acts as the "forward" vector for movement. This node works best in conjunction with the MOPs Orient Mesh node, which can easily generate these orientations for you along with options for swirling around the mesh, adding curl noise, and blurring the generated vectors for smoother motion.
The Aim Weight is similar to the same parameter in MOPs Curl Modifier; it determines how quickly an instance orients itself to the direction of motion. A value of 1.0 means each instance will immediately snap to its direction of motion on each timestep.
If your instances start crowding each other you can try to enable Relaxation, but this can be tricky on surfaces with very high curvature. In these situations you may need to implement some other kind of filtering, or consider using POPs or POP Grains with a self-repulsive force and then using MOPs Apply Attributes to snap your instances to the particle sim.
MOPs Move Along Spline moves objects along a path. There are a few presets available in the Tab menu to set up your instances to move as a group, or to simply distribute themselves evenly along the path. There's options for wrapping from the end of the path to the start, so you can get easy looping motion.
Move Along Spline has similar "attach" and "animation" steps as the Move Along Mesh modifier. In the Attach step, you can attach instances to the curve based on attributes, based on their proximity to the curve, or just based on an even distribution. You can even attach to multiple splines per-instance via a point attribute on the instances. The Offset controls determine how much of the original distance between each instance's starting position and the "attach" position is maintained.
The "Animation" step allows you to either procedurally move instances along the curve based on the Goal parameter, or push the instances per timestep in a solver. The Solver mode allows you to additionally create trails that emit from each instance.
The MOPs Noise Modifier pushes points or packed primitives around based on a variety of different noise fields. In Simple mode, instances are just procedurally moved around by adding the value of the curl noise to @P. In Advect mode, instances are pushed along the noise field over time, like a solver. You can generate trails from the motion of your objects only in Advect mode.
The Aim Weight determines how quickly your objects rotate to match their direction of motion. The default value of 0.1 is a good starting point so that objects have a little momentum. Higher values will quickly snap your objects to the direction of motion.
If you're using Advect mode and you want the attributes of your copies to update over time, add those attributes to the "Update Attributes" parameter under Solver Settings. By default this will update @mops_falloff so that you can animate it before applying the curl noise.
MOPs Orient Mesh computes orientation frames on input geometry. It's a little like the Polyframe SOP, but with some fancier options. This node is best used to prepare meshes before using them in the MOPs Move Along Mesh SOP. The visualized yellow vector is the "up" vector, which is used as the direction of motion for MOPs Move Along Mesh.
For easy "swirling" movement over a mesh, try setting the Compute Method to "N and Up" and enable "Cross Up Vector". This will "wrap" the yellow up vector along the surface of the mesh. You can optionally add curl noise to get more swirly behavior, or enable blurring to soften rough patches.
MOPs Physics Edit allows you to translate, rotate and scale packed primitives, and have other packed primitives collide with them in real time. The object you have selected while in the tool state will be immobilized, and other objects will follow the physics rules you've set up. This works well in conjunction with MOPs Collision Geo to create collider proxy geometry. You can cycle handle types (translate, rotate, scale) by pressing Y while in the tool state.
See MOPs Align.
MOPs+ Pre/Post-Roll allows you to automatically add pre- or post-roll animation to existing animation. This will analyze the movement at the beginning or end of the given time range, and extend it indefinitely in either direction to create easy handles for use in editorial or elsewhere. You can optionally ease the extended movement so that it gradually speeds up to match the start velocity, or slows down from the end velocity to zero. The individual interpolation of each object can be modulated by a falloff attribute.
MOPs Randomize adds randomness to the transforms (translate, rotate, scale) of your instances. It can also randomize the @mops_falloff attribute. The existing @mops_falloff attribute, if enabled, will affect the amount of randomness applied. You can tweak the amount of randomness per-axis, if you want to spin your instances around randomly over a single axis, for example.
MOPs Relax applies a "relaxation" algorithm on incoming instances to spread them apart and prevent overlaps. You can optionally provide a surface for the instances to stick to so that they don't end up flying off into space. Relaxation is fairly quick in 2D space (relaxing along a surface or a 2D plane), but even though there's an option to relax in 3D space, be warned that it can be incredibly slow.
If you want an accurate and fast alternative to MOPs Relax, try using MOPs+ Deintersect.
Like the MOPs Noise Modifier, but for KineFX joints.
Like the MOPs Spring Modifier, but for KineFX joints.
Like the MOPs Transform Modifier, but for KineFX joints. MOPs Rig Transform can apply procedural transforms in either world space or the local space of each joint.
The MOPs Spring Modifier applies spring forces to transforming instances. These forces can be applied to translation, rotation, or scale, or even the sequence frame for a sequence generated by the MOPs Instancer. The spring force is more or less Hooke's law, F=-kx, where F is the force needed to restore equilibrium, k is a stiffness coefficient, and x is the amount of displacement from the rest state.
A higher Mass setting means objects will have a harder time changing direction. The Spring Constant (k) is a measure of "stiffness", and high values will result in more rigid behavior. Low values will appear rubbery or wobbly. The Damping Coefficient is a sort of generic damping force; lower values will make the spring lose energy more quickly. A value of 1.0 is not advised, as the spring force would never decay.
If you want different primitives to have different values for any of these parameters, try creating those attributes ahead of time and then use a VEXpression to set each channel to the value of any of those attributes. The mops_falloff attribute will simply act as a scalar on the effect of the spring, if enabled.
The MOPs+ Stepper snaps the input transforms of packed primitives to fixed increments. You can snap translate (as shown on the right in the image above), rotate, scale, or any arbitrary float or vector attribute. Falloff attributes can be used to modulate the amount of snapping, per-primitive. If you're snapping rotations, be aware that the Euler rotations being computed here can result in unwanted flipping behavior if the rotation order isn't carefully chosen. If rotations look weird, try different rotate orders and see what works for your scene.
The MOPs Transform Modifier is one of the most common operators you'll use with MOPs. It simply acts as a transform on the instances, exactly the same as the Transform SOP, but it will also rotate and scale packed primitives. The MOPs Transform Modifier can optionally work in either world or local space when transforming. If the local axes of the instances aren't lined up the way you'd like them to be when transforming, you can try using a MOPs Reorient SOP to generate new local axes for each instance.