Attributes#

Create, edit, transfer and randomize attributes.

45 nodes.

Back to the reference index

Contents#

• Attribute Adjust (PCG) — Builds or edits one numeric attribute through a fixed pipeline of initialize, adjustment stack, remap and post-process.
• Attribute Adjust Color (PCG) — Generates or modifies a color attribute with constant, random, noise, attribute-driven or bounding-box patterns, then color-corrects and blends it.
• Attribute Adjust Float (PCG) — Sets, offsets or scales a float attribute using constant, random, noise or attribute-driven values.
• Attribute Adjust Integer (PCG) — Sets, offsets or scales an integer attribute using constant, random, noise or attribute-driven values.
• Attribute Adjust Vector (PCG) — Adjusts a vector attribute by direction and length, with constant, random, noise or attribute-driven values.
• Attribute Blur (PCG) — Smooths point or primitive attributes by diffusing them along mesh connectivity.
• Attribute Cast (PCG) — Changes the storage type of attributes between 32/64-bit float, 32/64-bit integer and string.
• Attribute Composite (PCG) — Composites a foreground attribute over a background attribute with a blend mode and alpha.
• Attribute Copy (PCG) — Copies attributes and groups from a source geometry to a destination, element by element.
• Attribute Create (PCG) — Creates attributes and writes a constant or expression value, optionally only on a group.
• Attribute Delete (PCG) — Deletes attributes by name pattern on each attribute class, or keeps only the matching ones.
• Attribute Fade (PCG) — Writes a spatial falloff attribute that is full inside a group and fades out with distance from it.
• Attribute Fade · Time (PCG) — Fades a point attribute in, holds it, and fades it out over time using per-point start frames.
• Attribute Fill (PCG) — Fills a point attribute from known points to the remaining points along mesh connectivity.
• Attribute from Camera (PCG) — Projects an image onto geometry through a camera, with visibility testing, and writes an attribute plus visible and mask groups.
• Attribute from Map (PCG) — Samples an image layer at the UVs of each element and writes the result as an attribute.
• Attribute from Pieces (PCG) — Assigns each element or piece a variant from a weighted library and writes it as an attribute.
• Attribute from Volume (PCG) — Samples a dense volume at point positions or primitive centers and writes the value as an attribute.
• Attribute Interpolate (PCG) — Interpolates source geometry attributes onto points using the source primitive each point lies on.
• Attribute Mirror (PCG) — Copies point attributes from one side of a plane to the mirrored points on the other side.
• Attribute Noise (PCG) — Adds noise to attributes such as position, color or any numeric attribute.
• Attribute Promote (PCG) — Moves attributes between point, vertex, primitive and detail classes, reducing values when several sources map to one target.
• Attribute Randomize (PCG) — Writes random values, directions or orientations into an attribute.
• Attribute Rename (PCG) — Renames attributes or groups using old:new pairs, with wildcard support.
• Attribute Reorient (PCG) — Rotates vector and quaternion point attributes to follow a deformation between a rest and a deformed pose.
• Attribute String Edit (PCG) — Finds and replaces text inside string attributes using substring, wildcard or regular-expression matching.
• Attribute Transfer (PCG) — Transfers attributes and groups from a source geometry to a destination by spatial proximity.
• Attribute Transfer by UV (PCG) — Transfers attributes between geometries by matching UV coordinates instead of positions.
• Attribute Transform Extract (PCG) — Computes one rigid transform per piece between a rest and an animated copy of the same geometry.
• Attribute Transform Extract · Houdini (PCG) — Decomposes 9- or 16-component matrix point attributes into translate, rotate and scale/shear/stretch attributes.
• Cluster Points (PCG) — Groups points into clusters with k-means and writes a cluster index, cluster centers and optional averaged points or boxes.
• Color (PCG) — Sets colors with a constant, random values, per-attribute random colors, a ramp over a scalar attribute, or an HSV adjustment.
• Distance along Geometry (PCG) — Distance from start points measured along the surface (geodesic or along edges).
• Distance from Geometry (PCG) — Writes each point's distance to a reference geometry: to its surface, its edges, or its nearest point.
• Edge Transport (PCG) — Propagates or accumulates a point attribute along a tree grown from root points over the edges.
• Enumerate (PCG) — Writes sequence numbers to elements or pieces, as integers or formatted names.
• Extract Centroid (PCG) — Reduces each piece of geometry to a single point at its centroid.
• Measure (PCG) — Measures area, perimeter, volume or curvature of primitives or points and optionally visualizes the result as color.
• Name (PCG) — Writes a string attribute (default name) based on group membership, with an optional text replacement.
• Normal (PCG) — Computes normals on points, vertices, primitives or the detail, with smoothing control.
• Orient Along Curve (PCG) — Writes a rotation-minimizing frame (tangent, up and orientation quaternion) on the points of curves.
• Point Velocity (PCG) — Computes point velocity (and optionally acceleration) from positions on neighbouring frames.
• PolyFrame (PCG) — Writes a local frame (N, tangentu, tangentv) on points or primitives.
• Tangent Field (PCG) — Computes the smoothest direction field with 1-, 2-, 4- or 6-fold symmetry on a surface.
• Wrangle (PCG) — Runs a short vectorized script over points, primitives, vertices or the detail, with VEX-style attribute syntax.

Nodes#

Attribute Adjust (PCG)#

PCG_AttribAdjust · category PCG/attribute · Houdini: Attribute Remap (SOP)

Builds or edits one numeric attribute through a fixed pipeline of initialize, adjustment stack, remap and post-process.

A single-node alternative to Houdini's Attribute Adjust Float, Integer and Vector. Values are always handled as an array with one to four components, so one node covers all three; the component count is taken from the existing attribute, or from size when the attribute is created.

The four stages always run in the same order: Initialize, then the Adjustments stack, then Remap, then Post-Process. The order matters: Remap needs to see the final distribution to pick its automatic input range, and rounding must come last (rounding before a multiply by 2 would give even numbers). Only elements in group are processed, and the automatic remap range looks only at the elements in the group, so outliers outside the group cannot squash the contrast. Elements outside the group keep their original value.

The Adjustments parameter is a text stack with one step per line, because ComfyUI widgets cannot grow like a Houdini multiparm. Each line is <operation> <source> [mask=<source>]; text after # is a comment:

mul   2.0
add   @curvature
mul   rand(0.8, 1.2)
add   noise(perlin, 2.0, 0.3)
mix   1.0 mask=@occlusion
set   (@P.y * 0.1)

Operations are set add sub mul div min max pow mix. A source is a number, a comma-separated vector, @attribute, rand(min, max), noise(type, size, amplitude), or a wrangle expression in parentheses. A single value is spread over all components. mask= is per step and controls how much of that step is applied (0..1); for mix the mask is the interpolation factor itself (0.5 if omitted). div raises an error naming the line if any divisor is zero, and pow errors on negative bases with non-integer exponents instead of producing NaN.

Inputs

Outputs

Parameters

Initialize

Adjustments

Remap

Post-Process

Compared with Houdini

Combines Attribute Adjust Float, Integer and Vector in one node and uses its own Initialize / Adjustments / Remap / Post-Process model instead of Houdini's Operation and Pattern Type. For the Houdini-style behaviour use the dedicated Attribute Adjust Float, Integer, Vector and Color nodes.

Tips

• Because a missing attribute with Initialize = Off is an error, set Initialize to Constant when you only want to create an attribute.
• Use mask= on a step to apply an operation only where an attribute (for example occlusion) is high.

Attribute Adjust Color (PCG)#

PCG_AttribAdjustColor · category PCG/attribute · Houdini: Attribute Adjust Color (SOP)

Generates or modifies a color attribute with constant, random, noise, attribute-driven or bounding-box patterns, then color-corrects and blends it.

Follows the Houdini Attribute Adjust Color workflow. Stages in order: optional overwrite of the initial color, the adjustment color (from the pattern type) combined with the existing color by the operation, color correction (hue, saturation, value, brightness, gain, contrast, gamma, in that order), post-process (minimum, maximum, complement) and finally blend with the original input. Blend is last, so a blend of 0 really means no change, including the correction and post-process stages.

Random and Noise patterns use a separate random or noise value per RGB channel when interpolating between a min and max color. With a color ramp, a single value indexes the ramp. With Specific Colors, a single value picks one color from the list or scheme, weighted by w=. Noise values are not equalized, so they cluster around the middle of the range.

Elements outside group keep their original color. The attribute is created as a float color if it does not exist.

Inputs

Outputs

Parameters

Pre-Process

Adjustment Value

Random

Noise Pattern

Color Correction

Post-Process

Compared with Houdini

The Color Map pattern (texture sampling) and the viewport-handle Line / Radial gradients are not implemented, and the color-correction parameters have no per-attribute variant. Color Correction order, the Overlay and Screen formulas and the 5 Shades / 5 Tints steps are fixed choices of this plugin. The Color SOP equivalent is the separate Color node.

Tips

• Use Remap Attribute with a float attribute such as curvature to color geometry through a ramp.
• Set Delete Other Colors when a point color is hiding the primitive color you just wrote.

Attribute Adjust Float (PCG)#

PCG_AttribAdjustFloat · category PCG/attribute · Houdini: Attribute Adjust Float (SOP)

Sets, offsets or scales a float attribute using constant, random, noise or attribute-driven values.

Follows the Houdini Attribute Adjust Float model. An adjustment value is generated by the Pattern Type (Constant, Random, Noise, Attribute) and merged into the existing value by the Operation. The result is blended with the original (constant or per-element amount) and optionally clamped with Minimum / Maximum. Elements outside group keep their value.

Random and Noise first produce a value u in 0..1 which Range Values maps to the final range. Random is uniform and keyed on the element number (or a custom attribute). Noise is the fractal noise mapped from -1..1 to 0..1; it is not equalized, so noise-driven values cluster in the middle of the range and rarely reach the ends. With Specific Values the same u selects from a weighted value list, so in Noise mode the discrete values appear in coherent patches.

If the attribute does not exist it is created as a float, and every operation (including Set Initial) just writes the adjustment value. A component suffix such as v.x edits one component; a vector attribute named without suffix gets its length adjusted.

Inputs

Outputs

Parameters

Adjustment Value

Random

Noise Pattern

Post-Process

Compared with Houdini

Unit Settings, VEXpression, Animate Noise, Warping and Default Value are not implemented. Middle +- Range Length uses half the length on each side (as Attribute Adjust does; Attribute Noise defines the same mode with the full width). Houdini does not document whether noise is equalized; here it is not. The Specific Values list is written one group per line with the group's weight as the selection probability. Outlier extension in Multiplicative mode is measured in range lengths so that a range starting at 0 can still extend.

Tips

• Set Outlier Attribute to get a mask of the elements that were sent outside the range.

Attribute Adjust Integer (PCG)#

PCG_AttribAdjustInteger · category PCG/attribute · Houdini: Attribute Adjust Integer (SOP)

Sets, offsets or scales an integer attribute using constant, random, noise or attribute-driven values.

Same structure as Attribute Adjust Float (Pattern Type, Range Values, Operation, outliers, stepping), with integer behaviour: random integers are drawn uniformly from Min..Max including both ends, Stepping counts from Min (range 1..9 with step 2 gives 1 3 5 7 9), outliers are integers at least 1 outside the range, and the final result is rounded. A new attribute is created as int32. There is no Blend. Elements outside group keep their value.

In Middle +- Range Length mode the half-width is half the length, and bounds that fall between integers are pulled inwards (center 0, length 3 gives -1..1).

Inputs

Outputs

Parameters

Adjustment Value

Random

Noise Pattern

Post-Process

Compared with Houdini

Same unimplemented options as the Float node (Unit Settings, VEXpression, Animate Noise, Warping, Default Value). Noise values are not equalized, so noise-driven integers cluster around the middle of the range.

Attribute Adjust Vector (PCG)#

PCG_AttribAdjustVector · category PCG/attribute · Houdini: Attribute Adjust Vector (SOP)

Adjusts a vector attribute by direction and length, with constant, random, noise or attribute-driven values.

Follows the Houdini Attribute Adjust Vector workflow: Pre-Process (optionally overwrite the starting vector, reverse it, normalize it, scale its length), the adjustment (per Adjustment For and Operation), then Post-Process (blend with the original, length scale, minimum and maximum length, unit length and an optional length attribute). Elements outside group keep their vector.

In Direction & Length mode the adjustment is a vector, produced by Adjust With: a constant, an attribute, or random / noise values drawn per component with independent random streams (so vectors are not confined to the diagonal). Direction Only and Length Only use a scalar adjustment (length, angle or bias) taken from the Float-style Range Values settings. Direction Only operations keep the original length; zero vectors stay zero for Direction Only and Length Only.

The outlier attribute, if named, is written as an integer 0/1 mask.

Inputs

Outputs

Parameters

Pre-Process

Adjustment Value

Random

Noise Pattern

Post-Process

Compared with Houdini

Zero Centered vectors follow the Houdini documentation: values are shifted to -0.5..0.5 and then multiplied by Amplitude. The azimuth for Spread, and the formulas of Spherical blend, are this plugin's choices where Houdini does not specify them. Selecting an operation that does not match Adjustment For is an error rather than a silent substitution.

Attribute Blur (PCG)#

PCG_AttribBlur · category PCG/attribute · Houdini: Attribute Blur (SOP)

Smooths point or primitive attributes by diffusing them along mesh connectivity.

Not a spatial blur: values spread along edges (points) or across shared edges (primitives), so two pieces of geometry that are not connected never influence each other, however close they are. Typical uses are feathering scatter density maps, softening masks and turning hard Connectivity blocks into gradients.

Each iteration does v += step * mask * (neighbour_average - v), an explicit heat diffusion. step is clamped to 0..1 because larger values oscillate and diverge; for a wider blur add iterations rather than increasing the step. There is deliberately no radius parameter: on a mesh with uneven edge lengths the same radius would be one step in sparse areas and ten in dense ones. The spread is roughly proportional to the square root of iterations * step edge lengths.

Elements outside group, or with a zero mask, are frozen (not written) but still contribute to their neighbours' averages, so the border of a blurred region is not held back by its own value. String attributes are skipped.

Inputs

Outputs

Parameters

Tips

• Add iterations, not step, for a softer result.
• Blur a mask attribute before using it as a scatter density to avoid hard edges.

Attribute Cast (PCG)#

PCG_AttribCast · category PCG/attribute · Houdini: Attribute Cast (SOP)

Changes the storage type of attributes between 32/64-bit float, 32/64-bit integer and string.

Converts the data type of every attribute matching the name pattern in the chosen class. float64 gives more precision at twice the memory, int32 halves it, and string attributes are handy for tagging. Float to integer rounds to the nearest integer rather than truncating (2.9 becomes 3), because truncation tends to look like an upstream error.

Converting to string writes the components of each element as a space-separated text. Converting a string attribute to a number parses the text and errors out on values that cannot be read as numbers. Strings are left alone when the target is also string.

Inputs

Outputs

Parameters

Attribute Composite (PCG)#

PCG_AttribComposite · category PCG/attribute · Houdini: Attribute Composite (SOP)

Composites a foreground attribute over a background attribute with a blend mode and alpha.

Blends attribute B (foreground) into attribute A (background) like image layers. The result is A + alpha * (blend(A, B) - A), where alpha is the Alpha value multiplied by an optional per-element alpha attribute read from the foreground. The background comes from geo; the foreground comes from the fg input, or from geo itself when fg is not connected.

Foreground elements are paired with background elements by element number, or by the value of a match attribute (typically id; the first foreground element with that value is used). Background elements without a partner are left unchanged. Blend modes: over (take B), add, subtract, multiply, divide (A is kept where B is 0), screen, overlay (decided by A: below 0.5 multiplies, above screens), min, max, difference (absolute), average.

A single-component attribute is spread over the components of the other side. String attributes only support Over, in which case the foreground value is taken where alpha exceeds 0.5. The report output lists how many elements matched.

Inputs

Outputs

Parameters

Compared with Houdini

Foreground and background are attributes of geometry rather than image layers; the blend formulas are the common layer-blend equations.

Attribute Copy (PCG)#

PCG_AttribCopy · category PCG/attribute · Houdini: Attribute Copy (SOP), Group Copy (SOP)

Copies attributes and groups from a source geometry to a destination, element by element.

Moves attributes from source onto dest by element number, one to one. It is meant for the case where both sides were originally the same geometry (two branches that each computed something and are merged back). If topology has changed so numbers no longer line up, either match by an id attribute or use Attribute Transfer to look up by distance.

Elements whose number is beyond the source range keep their current value instead of being zero-filled; zero-filling would make an element-count mismatch look like a region of genuine zeros. With a match attribute, destination elements take the value from the first source element with the same value; those without a match are left alone. Groups listed in groups are copied with the same pairing.

Inputs

Outputs

Parameters

Compared with Houdini

Covers Attribute Copy and Group Copy together (the groups field).

Attribute Create (PCG)#

PCG_AttribCreate · category PCG/attribute · Houdini: Attribute Create (SOP)

Creates attributes and writes a constant or expression value, optionally only on a group.

Creates one or more attributes (names separated by spaces) of the chosen class and type and fills them with a value. If group is set, only the selected elements are written and the rest keep their existing value, or zero for a new attribute. This is the usual way to tag a subset of elements.

With Use Expression on, the value comes from a one-line wrangle expression evaluated per element (for example @P.y or @ptnum % 3) instead of the constant. The node exists to make the graph self-documenting: a named node reads better than another anonymous wrangle.

Types: Float and Integer use size components; Vector has 3 and Vector4 has 4; String writes string_value. Integer values are rounded. An existing attribute of a different component count is replaced.

Inputs

Outputs

Parameters

Attribute Delete (PCG)#

PCG_AttribDelete · category PCG/attribute · Houdini: Attribute Delete (SOP)

Deletes attributes by name pattern on each attribute class, or keeps only the matching ones.

Each class has its own name pattern field. Patterns accept wildcards (uv* matches everything starting with uv) and exclusions (* ^P ^N means all but P and N). An empty field leaves that class untouched, which matters especially with Delete Non Selected: an empty field is not interpreted as select-all. The point position P is never deleted, since geometry without positions is invalid.

Inputs

Outputs

Parameters

Attribute Fade (PCG)#

PCG_AttribFade · category PCG/attribute

Writes a spatial falloff attribute that is full inside a group and fades out with distance from it.

Starting from group, each element receives a value based on how far it is from the group. Elements inside the group get Inside Value; elements farther than radius get Outside Value; in between, the distance d is converted to 1 - d / radius, shaped by the falloff ramp, and interpolated between Outside and Inside Value. Distance is measured either in edge steps or in world units along the surface, depending on Metric.

The usual use is a mask for Transform, Attribute Adjust or Noise ("lift only this area, with a smooth edge"). The ramp defaults to Smooth rather than Linear because a linear ramp has a slope discontinuity at the group border that shows up as a visible ridge when displaced.

With From Boundary on, the falloff runs on the inside of the group instead: the ring of elements touching the boundary is 0 and values rise toward 1 in the interior (full value beyond radius from the boundary); everything outside the group is 0. That produces a soft selection that is only full in the centre.

The group must select at least one element, otherwise the node errors (an empty group is treated as the empty set, not as all elements).

Inputs

Outputs

Parameters

Falloff

Tips

• Plug the fade attribute into a mask-aware node such as Attribute Adjust or Transform to get smooth localized edits.

Attribute Fade · Time (PCG)#

PCG_AttribFadeTime · category PCG/attribute · Houdini: Attribute Fade (SOP)

Fades a point attribute in, holds it, and fades it out over time using per-point start frames.

Time-based fade, following the Houdini Attribute Fade SOP. For each point the local time is t = Frame - start, where start = start_attribute * start_retime + frame_offset (0 if the start attribute is missing). Then:

• 0 <= t < fade_in: fading in, evaluated through the Fade In Ramp at t / fade_in.
• fade_in <= t < fade_in + hold: fully on (1), where hold = fade_hold * holdscale (scale is 1 if the attribute is missing).
• Next fade_out frames: fading out through the Fade Out Ramp.
• Before the start or after the end: 0.

The result is original * fade; if the attribute does not exist it is created from 1, so it holds the fade itself. Only points in group are changed; others keep their value (or 1 for a newly created attribute). Phases with zero length are skipped.

The second and third inputs can supply the start frame and the hold scale instead of reading them from geo; they are matched by point number, so the point counts must be equal. The report output counts points at zero, fully on and mid-fade.

Inputs

Outputs

Parameters

Attributes

Timings

Compared with Houdini

The current frame is an explicit parameter instead of the global time. Both ramps hold the actual fade value (fade-out is not reversed internally). Start Frame Retime is a single multiplier rather than a from/to pair. Spatial falloff from a group is the separate Attribute Fade node.

Attribute Fill (PCG)#

PCG_AttribFill · category PCG/attribute · Houdini: Attribute Fill (SOP)

Fills a point attribute from known points to the remaining points along mesh connectivity.

The attribute is meaningful only on the known points (the known_group; if empty, the points whose attribute is not all zero). Values are propagated to the other points through the mesh edges, so disconnected pieces never exchange values. Points not connected to any known point keep their value (Poisson writes 0 there, Eikonal writes Unreachable Time).

Methods:

• Harmonic solves a Laplace equation with the known values as boundary conditions (conjugate gradient). The result is smooth and has no overshoot; extremes occur only on known points.
• Nearest copies the value of the closest known point measured along edges.
• Diffuse runs iterations of weighted averaging with the known points pinned. Few iterations give a soft transition near the known points; many converge to Harmonic.
• Eikonal writes the travel time along edges from the Boundary Group (edge length / speed at the departing point). It does not read the input values and requires a group. It follows edges, it is not a fast-marching solver.
• Poisson is a harmonic fill with edge weights 1 / edge length, optionally guided by the gradient of Attribute to Match.
• Diffusion performs one implicit diffusion step from the current values; known points act as fixed sources. Without a group nothing is fixed. Repeat the node for more steps.
• Extrapolate copies values outward from the known points along shortest paths, either as plain scalars or, for vectors, by parallel transport of the tangential part.

The report output lists how many points were known, filled and unreachable.

Inputs

Outputs

Parameters

Compared with Houdini

Harmonic, Nearest and Diffuse are this plugin's methods; Eikonal, Poisson, Diffusion and Extrapolate correspond to Houdini's modes. Eikonal travels along mesh edges, so the result is edge-path distance rather than a surface-accurate fast-marching time. Where Houdini does not specify the guide strength on edges for Poisson, the average of the two endpoint weights is used.

Attribute from Camera (PCG)#

PCG_AttribFromCamera · category PCG/attribute · Houdini: Position Sample (COP)

Projects an image onto geometry through a camera, with visibility testing, and writes an attribute plus visible and mask groups.

Samples an image layer at the screen position of each element as seen by the camera. It does not need UVs, which makes it suitable for freshly imported meshes. A typical use is turning an AI-generated mask into a group: render a pass, feed it to a diffusion model, project the result back, and use mask_group to drive Blast, Fracture, PolyExtrude or Scatter, so the AI only decides where and the rest of the graph stays deterministic.

Plain camera projection ignores occlusion, so the back of a sphere would get the same color as the front. This node has four visibility levels: All (no test), Frustum (inside the image and in front of the camera), Front (adds a facing test against normal_attrib), and Full (adds occlusion, the default). Occlusion rasterizes the whole geometry from the camera, so objects outside group still hide others; group only limits what is written. Occlusion passes when the triangle visible at the element's pixel (searched in a 3x3 pixel neighbourhood) contains the element, or when its depth is within the bias of the visible depth.

Two groups are the point of the node: visible_group holds the elements the camera can see (for coverage checks across several cameras), mask_group holds visible elements whose written value reaches threshold. The test uses the value after scale and offset.

Elements that are not visible are handled by Missing: keep the old value (what multi-camera accumulation needs), write zero, or write a fixed value. The three extra outputs report the visible count, the coverage fraction and a text summary of the elements rejected (outside the frame, back-facing, occluded).

Inputs

Outputs

Parameters

Sampling

Visibility

Visibility › Not Visible

Output

Compared with Houdini

Corresponds to a Position Sample in a COP network combined with a camera projection, with visibility, occlusion and group creation built in.

Tips

• Use visibility Full with Missing = Keep Original to accumulate paint from several cameras without the second pass erasing the first.
• The depth bias is relative to model size, so imported meshes of any scale work with the default.

Attribute from Map (PCG)#

PCG_AttribFromMap · category PCG/attribute · Houdini: Attribute from Map (SOP), Attribute from Layer (COP), Geometry Attribute from Layer (COP)

Samples an image layer at the UVs of each element and writes the result as an attribute.

The main way to bring an image (for example a mask or color map generated by a diffusion model) back onto geometry. The image comes from a COP network, the UVs from a uv attribute on the geometry.

UVs live on vertices, so writing to points is ambiguous at UV seams, where one point has several UVs. The class decides what happens: Vertex uses the vertex UV directly (recommended, no ambiguity); Point uses the UV of the first incident vertex (not an average, since averaging u=0 and u=1 at a seam would sample the middle of the image); Primitive averages the UVs of all its vertices. The info output reports how many points lie on seams.

Bilinear sampling reconstructs the image exactly in the interior; the half-pixel at the borders is governed by the border mode. Remember to use sRGB to Linear when treating the image as numeric data.

Inputs

Outputs

Parameters

Color

Filter

UV

Compared with Houdini

Also covers sampling an image layer in a COP network (Attribute from Layer, Geometry Attribute from Layer) since the image is taken from a COP input. UV scale and offset are built in so a texture can be tiled without a separate UV Transform.

Attribute from Pieces (PCG)#

PCG_AttribFromPieces · category PCG/attribute · Houdini: Attribute From Pieces (SOP)

Assigns each element or piece a variant from a weighted library and writes it as an attribute.

Chooses a variant for every element (or for every piece, when a piece attribute is given) and writes it to output. Connected to Copy to Points as its piece attribute, it gives "several rocks scattered by weight".

Variants come from the library input: each distinct value of library_attribute is one variant (in order of first appearance), weighted by weight_attribute. Without a library, the variants are the integers 0 to Count-1 and the weights are typed into Weights. Random choices use a hash keyed on the element's id (if present) or its number, or on the piece key, so they are stable when upstream elements are added or removed.

Modes:

• Random: weighted random.
• Cycle: variants in turn (element k gets variant k mod N); with Use ID Attribute the id value replaces k.
• By Attribute (Map Attribute): the variant is looked up from input_attribute according to Map Pieces From.
• Patches: points in the same Worley noise cell share a variant, chosen by weight.
• Noise: the noise value, mapped to 0..1, is quantized through the cumulative weights, so variants form coherent clusters.
• VEXpression: each line of Rules is piece names : expression; the first line whose expression is non-zero decides.

Order is affected by Piece Filter, Shuffle and Offset, which matters for Cycle, Automatic ranges and the index output. Elements that match no rule get Unmatched Piece. Copy Attributes aggregates library attributes per piece (with the promotion method) and writes them onto the elements that picked that piece. The report output lists how many elements each variant received.

Inputs

Outputs

Parameters

Pieces

Source Points

Patches / Noise

Random

Map Attribute

Tips

• Feed a noise attribute to By Attribute with Weighted Unit to get clustered variants.
• Use Piece Attribute to give a whole connected chunk the same variant.

Attribute from Volume (PCG)#

PCG_AttribFromVolume · category PCG/attribute · Houdini: Attribute from Volume (SOP), Volume Sample (SOP), VDB Sample Points (SOP)

Samples a dense volume at point positions or primitive centers and writes the value as an attribute.

Looks up the volume at each point position (or primitive center) and stores the result. Modes: Trilinear interpolates between voxels, Nearest takes the closest voxel, Gradient writes a 3-component gradient vector (on an SDF this points along the surface normal direction). Outside the volume bounds, Clamp uses the value at the nearest edge, Constant writes Outside Value, and Keep does not write the element.

The volume must be a dense volume primitive (use Convert to make volume_sdf or volume_fog). A newly created attribute has one component, or three for Gradient. The report output gives the volume resolution and how many elements were sampled or outside.

Inputs

Outputs

Parameters

Compared with Houdini

Covers Attribute from Volume and Volume Sample.

Attribute Interpolate (PCG)#

PCG_AttribInterpolate · category PCG/attribute · Houdini: Attribute Interpolate (SOP)

Interpolates source geometry attributes onto points using the source primitive each point lies on.

Typically placed after Scatter or Ray: each point has sourceprim recording which primitive of source it belongs to. The node computes where the point lies in that primitive and interpolates the source attributes there.

By default the barycentric coordinates are recovered from the point's position within the primitive's triangles, which is exact for any polygon. A (u, v) pair is ambiguous for quads (the same pair is valid in both triangles of a quad), and scatter on quad meshes is the most common case; on such meshes a linear attribute interpolated via UV was off by up to 0.97 in tests while the position-based path was exact to about 1e-6. Turn on Use UV Attribute for Houdini's behaviour, where the UV attribute holds the coordinates and its third component selects the triangle inside the primitive.

Points whose sourceprim is out of range, or outside group, are unchanged.

Inputs

Outputs

Parameters

Attribute Mirror (PCG)#

PCG_AttribMirror · category PCG/attribute · Houdini: Attribute Mirror (SOP)

Copies point attributes from one side of a plane to the mirrored points on the other side.

Defines a mirror plane by origin and normal direction. Points on the Source Side keep their values (points exactly on the plane are not modified). For every point on the other side, the position is mirrored across the plane and the attribute value is fetched there: Closest Point takes the value of the nearest source-side point; Surface interpolates on the source-side triangles with barycentric weights (requires triangles with all corners on the source side).

Vector attributes listed in Vectors are reflected through the plane; quaternion attributes listed in Quaternions are mirrored as H*R*H, which stays a proper rotation. String attributes are copied from the nearest point. Only point attributes are handled. P is never copied. The report output lists the attributes, the number of mirrored points and the number rejected by Max Distance.

Inputs

Outputs

Parameters

Attribute Noise (PCG)#

PCG_AttribNoise · category PCG/attribute · Houdini: Attribute Noise (SOP), Mountain (SOP)

Adds noise to attributes such as position, color or any numeric attribute.

Noise is a pure function of position: lattice values come from a hash of integer cell coordinates, so the same world position always gives the same value regardless of point order or upstream edits, and two meshes meet seamlessly. Several noise bases and fractal modes are provided, with optional domain warping and a time axis for animation.

Processing order: sample position (position + Offset + VEXpression) / Element Size, optional warp, fractal noise in -1..1, Bias/Gain, Gamma, Contrast, remap ramp (all in 0..1 space so they stay valid when the amplitude changes), absolute and invert, mapping to the range, optional normalize to a target range over the selected elements, then the operation, clamping, unit length and blend. Elements outside group are unchanged.

With Noise Along Vector on, a single scalar noise is pushed along a direction attribute, typically N; a grid becomes a mountain. Fractal modes differ in where detail is added: Standard is evenly rough, while Terrain and Hybrid Terrain multiply octaves so high areas become rougher and valleys flatter.

Inputs

Outputs

Parameters

Noise Value

Noise Value › Value Correction

Noise Value › Post-Process

Noise Value

Noise Value › Post-Process

Noise Pattern

Noise Pattern › Use VEXpression

Noise Pattern › Fractal

Noise Pattern › Warping

Animation › Animation

Compared with Houdini

Covers Attribute Noise and Mountain (Noise Along Vector with N). In Middle +- Range Length the range extends Range Length to each side of Middle, which is different from the Attribute Adjust nodes where the length is the total width.

Attribute Promote (PCG)#

PCG_AttribPromote · category PCG/attribute · Houdini: Attribute Promote (SOP)

Moves attributes between point, vertex, primitive and detail classes, reducing values when several sources map to one target.

Works by first building a table of (source element, target element) pairs and then reducing each target's values with the chosen method. When expanding (for example point to vertex) each target has a single source, so the method has no effect; when reducing (vertex to point) it combines the values. This lets all class combinations share one code path.

If a piece attribute is given, values are reduced per piece instead of per target element: all target elements with the same piece value receive the same result. The piece attribute is read from the New Class and must be integer or string; it is ignored for detail targets.

original_name accepts name patterns (uv*, * ^P) to move several attributes at once. In the new name, * is replaced by the original attribute name, which allows batch renaming. Integer attributes stay integer and are rounded rather than truncated after averaging. String attributes can only use Mode, First Match and Last Match when values have to be combined.

Inputs

Outputs

Parameters

Compared with Houdini

Houdini's Array of All Values and Array of Unique Values methods are not available, because attributes here are always fixed-size arrays and cannot hold variable-length arrays.

Attribute Randomize (PCG)#

PCG_AttribRandomize · category PCG/attribute · Houdini: Attribute Randomize (SOP)

Writes random values, directions or orientations into an attribute.

Used after scattering to add variation to pscale, orient, color and so on. The random stream is keyed on an id attribute when given, so inserting, deleting or sorting upstream points does not reshuffle the existing values.

Three modes: Value fills each component independently from a distribution; Direction produces unit vectors on a sphere, in a cone, in a disc or along a line, optionally with random length; Orientation produces quaternions, either a fully random rotation or a rotation about an axis by a random angle.

Directions are not made by randomizing each component and normalizing, which would favour the corners of the cube. Sphere and cone directions are uniform in the cosine of the polar angle, and fully random orientations use Shoemake's method, so they are uniform over all rotations (random Euler angles would cluster near the poles).

Inputs

Outputs

Parameters

Distribution

Distribution › Value

Distribution › Direction / Orient

Options

Compared with Houdini

Houdini's Constant, Two Values, Uniform (Discrete), Exponential, Log-Normal, Cauchy, Custom Discrete and Inside Sphere distributions reuse the Min, Max, Mean and Standard Deviation fields as described on the parameters.

Attribute Rename (PCG)#

PCG_AttribRename · category PCG/attribute · Houdini: Attribute Rename (SOP), Group Rename (SOP)

Renames attributes or groups using old:new pairs, with wildcard support.

Each pair is written old:new (an = also works) and pairs are separated by spaces. A wildcard in the old name carries the matched part over to the * in the new name: uv*:tex* renames uv1 to tex1 and uvSet to texSet. Renaming a name that does not exist is an error that lists the available names. With Rename Groups on, group names are renamed instead of attributes (groups do not exist on the detail class).

Inputs

Outputs

Parameters

Compared with Houdini

Covers Attribute Rename and Group Rename in one node.

Attribute Reorient (PCG)#

PCG_AttribReorient · category PCG/attribute · Houdini: Attribute Reorient (SOP)

Rotates vector and quaternion point attributes to follow a deformation between a rest and a deformed pose.

After a deformation, attributes such as N, up, v and orient still describe the undeformed shape. For each point the node estimates a local rotation from the one-ring neighbourhood of the point in the rest and deformed positions (Kabsch fit). Vector attributes (3 components) are rotated by it and orientation quaternions (4 components) are rotated by left multiplication. On a collinear neighbourhood (curves, end points) the roll about the tangent is undetermined, so the minimum rotation between the two tangents is used.

The attributes are read from the deformed geometry, or from the rest geometry if missing there. Both inputs must have the same point count. Other component counts and string attributes are skipped; P is never modified. The report output lists the processed attributes.

Inputs

Outputs

Parameters

Attribute String Edit (PCG)#

PCG_AttribStringEdit · category PCG/attribute · Houdini: Attribute String Edit (SOP)

Finds and replaces text inside string attributes using substring, wildcard or regular-expression matching.

Edits the values of one or more string attributes (names separated by spaces, wildcards allowed). Modes: Substring replaces every occurrence of Find; Wildcard matches the whole string against a pattern containing *, and what each * captured is placed in order into the * of Replace (piece*_old with chunk* turns piece12_old into chunk12); Regex uses regular-expression substitution, where \1 refers to groups. Values that do not match stay as they are. Only distinct values are processed, so large geometry with few names is fast. The report output summarizes the edits.

Inputs

Outputs

Parameters

Attribute Transfer (PCG)#

PCG_AttribTransfer · category PCG/attribute · Houdini: Attribute Transfer (SOP), Group Transfer (SOP)

Transfers attributes and groups from a source geometry to a destination by spatial proximity.

For each destination point, source points within distance_threshold are collected (the nearest max_sample_count of them, optionally only those with a matching match_attribute value). Their attribute values are averaged with the chosen kernel to give a target value. How much of that target replaces the original value is a separate quantity: an alpha derived from the distance of the nearest source point, which is 1 inside the threshold and falls to 0 over the last blend_width of distance. The result is lerp(original, target, alpha). With Blend Width 0 this is a hard switch: reachable points are fully replaced, others untouched.

The two are separate so that smoothing (number of samples and kernel) and softness of the influence edge (blend width) can be tuned independently. Primitive attributes are matched by primitive centers. String attributes and groups cannot be averaged, so they take the value from the nearest source element (strings are left alone when alpha is below 0.5). P is not transferred. Detail attributes are copied as they are.

Inputs

Outputs

Parameters

Attributes

Conditions

Compared with Houdini

Covers Attribute Transfer and Group Transfer. Vertex attributes are not transferred.

Attribute Transfer by UV (PCG)#

PCG_AttribTransferByUV · category PCG/attribute · Houdini: Attribute Transfer by UV (SOP)

Transfers attributes between geometries by matching UV coordinates instead of positions.

For each destination point or vertex the node finds the source UV triangle that contains its UV and interpolates the source attribute with the barycentric coordinates there. The two geometries may differ in topology and position as long as their UV layouts match: baked high-resolution colors can be moved to a low-resolution mesh, and transferring P wraps one geometry onto another via UV space.

Sources can be point, vertex or primitive attributes; strings take the value of the dominant corner. A transferred N is renormalized. Where a destination UV lies outside every UV island, Nearest uses the closest UV triangle (limited by Max Distance) and Keep leaves the element untouched. The report output includes the number of queries inside UV islands, resolved to the nearest triangle, missed, and falling into overlapping UV regions.

Inputs

Outputs

Parameters

Attribute Transform Extract (PCG)#

PCG_AttribTransformExtract · category PCG/attribute

Computes one rigid transform per piece between a rest and an animated copy of the same geometry.

Both inputs must have identical topology. Points are grouped into pieces by the name style attribute (primitive attribute first, otherwise point attribute), and for each piece a rigid fit (rotation plus translation, no scaling) from rest to animated points is computed. Pieces with fewer than 3 points use translation only.

Two point clouds are produced, one point per piece: template has the piece center moved by the transform plus an orient quaternion, and rest_points has the rest piece center with an identity orient. Plug them into the template and rest inputs of Transform Pieces to make another geometry (for example high-resolution debris) follow each piece exactly. The piece key is copied onto both outputs. The report output gives the number of pieces and the largest fit error (RMS).

Inputs

Outputs

Parameters

Compared with Houdini

Piece-wise version of Extract Transform. For decomposing matrix attributes use Attribute Transform Extract (Houdini).

Attribute Transform Extract · Houdini (PCG)#

PCG_AttribTransformExtractHou · category PCG/attribute · Houdini: Attribute Transform Extract (SOP)

Decomposes 9- or 16-component matrix point attributes into translate, rotate and scale/shear/stretch attributes.

Splits matrix attributes (9 components = 3x3, 16 components = 4x4 with translation in the last row; same convention as Transform by Attribute) into separate attributes. Two decompositions are offered. Polar writes rotation as Euler angles (degrees) plus a symmetric stretch 3x3 matrix, with H3 = Stretch * R. Crack writes rotation, scale and shear, and is the inverse of what the Transform SOP builds for the chosen transform order. Translation is written only for 16-component matrices.

A rotation matrix has several equivalent Euler angle triples. The Euler filter picks, per point, the solution closest to a reference angle: the already filtered angle of its parent in the chosen hierarchy, or the Hint for points without a parent. Points outside group receive defaults (translation 0, rotation 0, scale 1, shear 0, identity stretch). If no attribute matches, the geometry passes through and the report explains why.

Output names are built as prefix + matrix name + suffix.

Inputs

Outputs

Parameters

Euler Filter

Transform

Compared with Houdini

Matrices are read in Houdini's convention (row vectors, translation in the fourth row of 16-component attributes), the same as everywhere else in the plugin. The rest/animated rigid fit per piece is the separate Attribute Transform Extract node.

Cluster Points (PCG)#

PCG_ClusterPoints · category PCG/attribute · Houdini: Cluster (SOP), Cluster Points (SOP)

Groups points into clusters with k-means and writes a cluster index, cluster centers and optional averaged points or boxes.

Runs k-means on the chosen attribute (default P, but color or any numeric attribute works) with k-means++ initialization; a fixed seed reproduces the result. Each point receives an integer cluster number in the attribute named name; if a cluster loses all its points the farthest point becomes its new center. Additional control attributes can be added to the feature vector, each multiplied by its own weight.

The main output is chosen by Output: the original points with the cluster attribute, one averaged point per cluster (position = mean, size_attribute = bounding box size including padding), both merged (in groups clusterpoints and averagepoints), or one bounding box per cluster. Cluster Filter keeps only listed clusters. The second output is always a point cloud of cluster centers with cluster and count attributes.

With Build Clusters off, no k-means is run: the existing integer attribute name defines the clusters. Points outside group get cluster -1 (or keep their previous value).

Inputs

Outputs

Parameters

Cluster Settings

Averaging Settings

Compared with Houdini

Combines Cluster and Cluster Points.

Color (PCG)#

PCG_Color · category PCG/attribute · Houdini: Color (SOP)

Sets colors with a constant, random values, per-attribute random colors, a ramp over a scalar attribute, or an HSV adjustment.

Writes a 3-component color attribute (default Cd) on selected elements; others keep their color (or white if the attribute is new).

• Constant: one color for all.
• Random: one random color per element, keyed on id if it exists or on the element number.
• Random by Attribute: the same attribute value gets the same color (for example color pieces by name).
• Ramp by Attribute: a scalar (or the length of a vector) attribute is normalized to 0..1 and looked up in the ramp. With Auto Range the range is the minimum and maximum over the selected elements.
• Adjust: modifies the existing colors in HSV (hue shift, saturation and value multipliers) and adds optional random variation; with an attribute set the variation is shared per piece.

Inputs

Outputs

Parameters

Adjust

Compared with Houdini

Combines the Color SOP with the HSV-adjust behaviour of Attribute Adjust Color. For the full Houdini Attribute Adjust Color semantics use Attribute Adjust Color.

Distance along Geometry (PCG)#

PCG_DistanceAlongGeometry · category PCG/attribute · Houdini: Distance along Geometry (SOP)

Distance from start points measured along the surface (geodesic or along edges).

Measures how far every point is from the start points when travelling on the geometry, not through space: the distance around a sphere, along a winding road mesh, across a character's skin.

Geodesic uses the heat method: it diffuses heat from the start points for a short time, normalises the heat gradient and solves for a distance with that gradient. The result follows the surface smoothly. Edges finds the shortest path along edges; it is exact along edges but overestimates diagonals across faces (up to 41% across a quad grid).

Points not connected to any start point get -1.

Inputs

Outputs

Parameters

Mask