Image: Geometry and Images#

Rasterizing and baking geometry; turning images back into geometry.

16 nodes.

Back to the reference index

Contents#

• COP Bake Textures (PCG) — Bakes geometry attributes and, optionally, high-poly detail into textures laid out by the low-poly mesh's UVs.
• COP Configure Stamps (PCG) — Writes sprite attributes (scale, rotation, colour, alpha, stamp index) onto points for use by stamping nodes.
• COP Geometry to Layer (PCG) — Converts volume primitives of a geometry into image layers by taking a slice, one voxel per pixel.
• COP HeightField to Mesh (PCG) — Converts a height layer into a Y-up grid mesh with one point per pixel center.
• COP Integrate Volume (PCG) — Casts one ray per pixel through a volume primitive and integrates, transmits, or takes the minimum or maximum of its samples.
• COP Layer from Attribute (PCG) — Writes a geometry attribute into an image, one element per pixel.
• COP Layer To Points (PCG) — Turns pixels of an image layer into points, sampling chosen layers as point attributes.
• COP Planar Inflate (PCG) — Inflates a mask into a height layer, like a pillow or soap bubble.
• COP Point Generate (PCG) — Adds new points to a point cloud, with the count taken from parameters or from a count attribute.
• COP Points From Blobs (PCG) — Converts each connected blob of a mask layer into one point with area, radius and bounding-box attributes.
• COP Rasterize Curves (PCG) — Draws the primitives of a geometry as anti-aliased lines into an image layer.
• COP Rasterize Splats (PCG) — Renders 3D Gaussian splat points orthographically onto a plane with front-to-back alpha compositing.
• COP Scatter Shapes (PCG) — Stamps copies of a shape into an image, either randomly scattered or placed from input geometry.
• COP Triplanar (PCG) — Projects a texture along the three axes using per-pixel world position and normal, blending by normal direction.
• COP UV Shape (PCG) — Generates interior UV coordinates, UV stretch and a mask for a disk or annulus shape.
• Render Pass (PCG) — Rasterizes geometry through a camera into COP layers: depth, mask, normals and more.

Nodes#

COP Bake Textures (PCG)#

PCG_COPBakeTextures · category PCG/cop · Houdini: Bake Pre-Process (SOP), Bake Geometry Textures (COP), Bake Geometry Textures 2.0 (COP), Bake Pre-Process (COP)

Bakes geometry attributes and, optionally, high-poly detail into textures laid out by the low-poly mesh's UVs.

The low-poly geometry is rasterized in UV space. Each texel is traced back to its surface point, and the following layers are written: P and N (world position and normal; the point normal is interpolated, or computed if missing), mask (texel is covered by a triangle), primid (original primitive number), tangent (dP/du, orthogonalised against N), bitangent (the third axis of the same frame, with the uv layout's handedness, so detail computed per texel can be written into normal_ts's frame exactly) and every point attribute listed in Attributes, interpolated barycentrically.

When a high mesh is connected, a ray is cast from each texel along +-N (or from the cage, see Tracing Mode) to find the high-poly surface. This adds normal_ts (high-poly normal expressed in the low-poly tangent space, unencoded -1..1), displacement (signed distance along N, positive when the high mesh is outside) and the High Attributes interpolated at the hit point. Optional passes are worldnormal, position, occlusion, height and alpha. All layers except mask are dilated outwards from the UV islands by Dilate texels to avoid mip-map bleeding.

The second output is a JSON report of the bake.

Inputs

Outputs

Parameters

Tracer

Texture Maps

Compared with Houdini

Covers Bake Geometry Textures (2.0) and Bake Pre-Process in one node. Tangent-space normals are written unencoded (-1..1) by default; encode them with COP Convert Normal if a game engine needs it.

Tips

• Keep Dilate at a few texels or more if the texture will be mip-mapped, otherwise island borders bleed.

COP Configure Stamps (PCG)#

PCG_COPConfigureStamps · category PCG/cop · Houdini: Configure Stamps (COP)

Writes sprite attributes (scale, rotation, colour, alpha, stamp index) onto points for use by stamping nodes.

Does not draw anything. It writes per-point attributes: spritescale (2 values), spriterot (degrees), Cd (colour), blend (alpha) and stamp (integer index of the stamp), and moves P with Jitter. Each property can be driven by a layer from the layers input, sampled at the point's position, and multiplied by a Mask amount, and can be randomized with Uniform, Variance or Min / Max modes. Randomness is a per-point hash of the point number and the relevant seed.

Points are mapped to layer uv using Plane and World Size (image width equals World Size, origin at the centre), the same convention as Layer to Points and Scatter Shapes. If any layer name is set, the layers input must be connected. A layer value blends the base value as base * (1 + (layer - 1) * mask).

Details: Scale percent_variance multiplies by 1 + variance * r and min_max by a random value between Min and Max; Stretch works the same per axis. Angle is Angle + AngleLayer * 360 * mask + atan2(direction.y, direction.x) * direction mask, then variance or min/max, and finally rounded to a multiple of Round To when that is above 0. Colour variance acts in HSV (hue wraps, saturation and value are clamped). Stamp selection: cycle uses point number modulo Stamp Count, random picks randomly, layer_select rounds layer value * (count - 1) and clamps.

Inputs

Outputs

Parameters

Jitter

Scale

Stretch

Angle

Color and Blending

Alpha

Stamp Selection

Compared with Houdini

Random-from-ramp options for colour and alpha are not implemented. Scatter Shapes in this plugin is a rasterizing stamp and reads pscale and Cd, not spritescale, so the attributes written here are meant for Stamp Points style nodes.

COP Geometry to Layer (PCG)#

PCG_COPGeoToLayer · category PCG/cop · Houdini: Geometry to Layer (COP)

Converts volume primitives of a geometry into image layers by taking a slice, one voxel per pixel.

Equivalent of Geometry to Layer. Each requested volume becomes one layer named after its primitive (output<N> if it has no name). 3D volumes are sliced in the chosen plane at the given offset, with one voxel mapped to one pixel. Names with a wildcard such as vel.* collect the matching volumes, sorted by name, into one multi-channel layer named without the .*.

All outputs must have the same resolution, since layers in one image share a resolution. With optional on, a requested volume that cannot be found is filled with the default value using the resolution of the size_ref image instead of raising an error.

Inputs

Outputs

Parameters

Compared with Houdini

VDB and camera primitives are not supported. The Slice Offset parameter is an extension; Houdini's node has no offset. Houdini outputs can have independent resolutions, while here all layers of one image share one.

COP HeightField to Mesh (PCG)#

PCG_COPHeightfieldToMesh · category PCG/cop · Houdini: Layer to Geometry (COP)

Converts a height layer into a Y-up grid mesh with one point per pixel center.

Each pixel center becomes a point; step thins the grid by taking every Nth pixel without resampling, so each point holds the exact pixel value. Mesh width is world_size and height is the layer value times strength.

v points toward -Z (north), so the height map reads correctly in a Houdini-style top view (X right, Z down). Points carry uv (pixel center, matching COP sampling) and height, so a later Scatter from Map or Attribute from Map lines up exactly with the terrain.

Point normals come from the height gradient (the same operator as COP Height to Normal), not from averaging mesh faces. Other layers can be carried over as point attributes.

Inputs

Outputs

Parameters

COP Integrate Volume (PCG)#

PCG_COPIntegrateVolume · category PCG/cop · Houdini: Integrate Volume (COP)

Casts one ray per pixel through a volume primitive and integrates, transmits, or takes the minimum or maximum of its samples.

For every pixel a view ray marches through the volume and produces one of:

• Integral: the line integral of density times step length.
• Transmittance: exp(-integral).
• Minimum / Maximum: the smallest or largest raw sample value along the ray (not mapped through the density settings). A ray that never touches the volume gives +inf (minimum) or -inf (maximum).

By default the view is orthographic: the pixel centre in image coordinates (long side -1 to 1) gives the x, y of a ray that runs along +Z over the whole line, with no start cut-off. If the layers input is connected and View Origin or View Direction layer names are given, each pixel uses its own ray (starting at the origin, t >= 0); Min Depth and Max Depth layers restrict the ray to a distance range.

For Integral and Transmittance the sample is remapped as (v - Min) / (Max - Min), clamped to 0-1 (Clamped Ramp) or wrapped to its fractional part (Periodic Ramp), then multiplied by Density Scale. The ray is clipped to the volume's bounding box and cut into slices of Integration Step Size, one sample per slice; the last slice may be shorter and is weighted by its real length. Several volumes selected at once (such as vel.*) become channels, each accumulated separately.

Inputs

Outputs

Parameters

Density

Quality

Rays

Compared with Houdini

Houdini works on VDB volumes; this node works on the plugin's dense volume primitives. The Density Ramp curve is not implemented (the ramp modes only clamp or wrap).

COP Layer from Attribute (PCG)#

PCG_COPLayerFromAttrib · category PCG/cop · Houdini: Layer from Attribute (COP)

Writes a geometry attribute into an image, one element per pixel.

Element k of the chosen attribute is stored in pixel k. The order is set by Data Ordering, or, if the index input is connected, every pixel reads the element number found in the Index Layer. The output layer has as many channels as the attribute has components; a detail attribute counts as one element.

With Resize Layer off, the resolution comes from size_ref (or Resolution when it is not connected) and the layer is added to size_ref. With Resize Layer on, the resolution is derived from the element count using Resize Shape and the output contains only this layer.

If there are more pixels than elements the extra pixels are 0; extra elements are dropped. Index values outside the attribute range (including negative) give 0. The index image must have the same resolution as the output.

Inputs

Outputs

Parameters

COP Layer To Points (PCG)#

PCG_COPLayerToPoints · category PCG/cop · Houdini: Layer to Points (COP)

Turns pixels of an image layer into points, sampling chosen layers as point attributes.

Each point also gets a uv attribute (its position on the image). Positions use the same plane + world mapping as HeightField to Mesh: the image width equals World Size, and Height Layer, if given, sets the coordinate on the axis perpendicular to the plane (Y for the XZ plane) to value times Height Scale. Layers listed in Layers to Attributes are sampled at each point's pixel and written as point attributes (C becomes Cd).

Methods:

• One Point per Pixel: a point at every pixel centre, thinned by Stride and filtered by Mask Layer (pixels where the mask is greater than Threshold are kept).
• Scatter by Density: Point Count random points, accepted in proportion to the Density Layer (uniform when empty). Positions are continuous inside the image, not only at pixel centres.
• Houdini-style methods read the Mask Layer as their source layer (empty uses C; the first channel is the value, except Non-Zero Pixels, which looks at all channels): Non-Zero Pixels gives a point for every non-zero pixel; Count per Pixel gives floor(value) points per pixel; Unique Values gives one point per distinct value, placed on the first pixel (lowest buffer offset) that holds it, optionally ignoring -1; Count from First Pixel and Count from Last Pixel take the total number of points from the first or last pixel's value. Those points are all at the origin because they have no pixel position, but uv and attributes come from the source pixel.

Output points are ordered by buffer offset x + y*xres, with row 0 at the bottom.

Inputs

Outputs

Parameters

Compared with Houdini

The first two methods (One Point per Pixel, Scatter by Density) are specific to this plugin; the other five follow Houdini's Method menu.

COP Planar Inflate (PCG)#

PCG_COPPlanarInflate · category PCG/cop · Houdini: Planar Inflate (COP)

Inflates a mask into a height layer, like a pillow or soap bubble.

Pixels of the mask above 0.5 are inflated, and the result is normalized so the highest point equals Height. It is a good starting point for relief, bevelled text and normal maps. An empty mask gives an error.

• Round: a circular-arc profile h = sqrt(2Rd - d^2) / R, where d is the distance to the boundary and R the largest inner distance. Edges are vertical and the middle is a flat top, like a pillow.
• Poisson (Soap Bubble): solves laplacian(h) = -1 with h = 0 on the boundary, using a coarse-to-fine Jacobi solver.

Inputs

Outputs

Parameters

COP Point Generate (PCG)#

PCG_COPPointGenerate · category PCG/cop · Houdini: Point Generate (COP)

Adds new points to a point cloud, with the count taken from parameters or from a count attribute.

The number of new points comes from one of three sources:

• Parameters: Number of Points + Points per Second * Time Step. Any fractional part is rounded up or down at random according to Seed. The two terms are added, which is this plugin's reading of Houdini's behaviour.
• Point Attribute: each source point is copied floor(count) times (negative counts give none). Point attributes matching Copy Attributes are copied from the source point; all other attributes of the new points are 0.
• Detail Attribute: an integer detail attribute gives the count (floored; the fractional part is not randomized).

The source is ref when connected, otherwise points. New points sit at the origin unless P is copied. If points has an id attribute, new points continue the numbering from the detail attribute nextid (updated afterwards) when present, otherwise from max(id) + 1, with a step of the detail attribute idstep or 1. With Append Points on, the output is the input points (primitives are discarded) plus the new points.

Inputs

Outputs

Parameters

Compared with Houdini

Time Step is an explicit parameter because the plugin has no simulation time. Houdini's Layer to Points is a different node (see COP Layer To Points).

COP Points From Blobs (PCG)#

PCG_COPPointsFromBlobs · category PCG/cop · Houdini: Points from Blobs (COP)

Converts each connected blob of a mask layer into one point with area, radius and bounding-box attributes.

Thresholds the mask layer, labels its connected components and emits one point per blob at the blob's centroid. Each point carries area (pixels), world_area, radius (radius of the circle with the same area, usable directly as pscale), blob_id and the blob's bounding box. If a Value Layer is given, the mean of that layer inside the blob is written as an extra point attribute.

The second output is the number of blobs that survived the Min Area filter.

Inputs

Outputs

Parameters

Tips

• Feed radius into a copy-to-points step as pscale to place a shape matching each blob's size.

COP Rasterize Curves (PCG)#

PCG_COPRasterizeCurves · category PCG/cop · Houdini: Layer from Curves (COP), Mask from Curves (COP), Rasterize Curves (COP)

Draws the primitives of a geometry as anti-aliased lines into an image layer.

Each primitive is drawn as a polyline with the given pixel width; the width can be multiplied per point by an attribute. With Fill enabled, closed curves are filled using the even-odd rule. A Rasterize Attribute is interpolated along the lines into an additional layer.

Inputs

Outputs

Parameters

Projection

COP Rasterize Splats (PCG)#

PCG_COPRasterizeSplats · category PCG/cop · Houdini: Rasterize GSplats (COP)

Renders 3D Gaussian splat points orthographically onto a plane with front-to-back alpha compositing.

Reads P, scale, orient, Cd and opacity from the points (missing attributes fall back to defaults), projects the Gaussians orthographically onto the chosen plane and composites them front to back. The result is an RGB layer plus an alpha layer named <Output Layer>_alpha. The second output is the number of splats drawn.

There is no perspective camera and no spherical harmonics, so this is meant for baking top-down views and textures.

Inputs

Outputs

Parameters

Projection

COP Scatter Shapes (PCG)#

PCG_COPScatterShapes · category PCG/cop · Houdini: Scatter Shapes (COP), Scatter on Curves (COP), Stamp Points (COP)

Stamps copies of a shape into an image, either randomly scattered or placed from input geometry.

Without geometry, Count shapes are scattered at random; the Density Layer filters them by probability and Minimum Distance spaces them apart (as a fraction of the image width). With geometry connected, Spacing 0 puts one stamp on every point (pscale multiplies the size and Cd is used as the colour); Spacing above 0 takes evenly spaced points along the curves, and Align to Curve rotates each stamp along the tangent. Plane and Mapping control how geometry maps onto the image (XZ plus World Size matches HeightField to Mesh).

With Shape set to Stamp Input Layer, the Stamp Layer of the stamp input is used as the shape. Besides the main layer, <Output Layer>_id, <Output Layer>_color and <Output Layer>_rand are written. The second output is the number of stamps drawn.

Inputs

Outputs

Parameters

Random Scatter

Geometry

COP Triplanar (PCG)#

PCG_COPTriplanar · category PCG/cop · Houdini: Triplanar (COP), Triplanar Hex Tile (COP), Triplanar UV (COP)

Projects a texture along the three axes using per-pixel world position and normal, blending by normal direction.

Reads the world-space position P and world-space normal N per pixel (the layers produced by Render Pass). The texture is projected onto the YZ, XZ and XY planes using P x Scale as coordinates (always wrapping), and the three projections are blended with weights |N|^Sharpness, normalised to sum to 1. The texture period is 1 / Scale world units.

With Hex on, every projection uses hex-tiling: three overlapping hex cells are blended, each with a random offset and a random rotation, which hides visible repetition. If UV Layer is set, an extra layer is written with the projected UVs (0-1) of the dominant axis.

Inputs

Outputs

Parameters

Hex Tiling

COP UV Shape (PCG)#

PCG_COPUVShape · category PCG/cop · Houdini: UV Shape (COP)

Generates interior UV coordinates, UV stretch and a mask for a disk or annulus shape.

Outputs where each pixel lies in the shape's own parametric coordinate system, so that a square image can be mapped into the shape with UV Sample. This is not the same as COP Shape, which outputs a signed distance field.

Coordinates are centred and normalised by the short side of the image (short side from -0.5 to 0.5), as in COP Shape. Three layers are written (empty name = not written):

• uv: two channels with the interior coordinates, by default in the range -1 to 1 as in Houdini.
• uvscale: how fast the UV changes per pixel (largest singular value of the Jacobian, measured in -1 to 1 units and clamped to UV Filter Bound); use it to pick a filter width in UV Sample.
• mask: 1 inside the shape and 0 outside, decided at the pixel centre without anti-aliasing.

The shape's UVs are first computed, then sheared (u += Shear x v), rotated by Angle, offset, and finally multiplied by the U and V scales. Border modes then fold values outside -1 to 1.

Disk modes: Linear (radial stretch to a square, most distortion on the diagonals), Polar (U = angle/pi, V = 2r - 1), Equal Area (area preserving concentric mapping), Squircle (little distortion near the axes), Elliptic Arc. Annulus modes: Polar (V linear in radius) and Log (V proportional to ln of the radius, which keeps cells conformal so they do not flatten towards the outside).

Inputs

Outputs

Parameters

Transform

UV

Compared with Houdini

Only Disk (Linear, Polar, Equal Area, Squircle, Elliptic Arc) and Annulus (Polar, Log) are implemented. Disk Conformal, Square, Horseshoe, Spiral and Fishscale are not. The transform is applied before the U/V scale; Houdini does not state the order.

Render Pass (PCG)#

PCG_RenderPass · category PCG/cop · Houdini: Rasterize Geometry (COP)

Rasterizes geometry through a camera into COP layers: depth, mask, normals and more.

Renders geometry into raw (unclamped) data layers, which are the exact conditions a ControlNet needs, computed analytically instead of guessed. Packing into 0-1 is the job of Control Image, as that step is tied to the ControlNet conventions.

Layers written, depending on the pass toggles:

• mask: 1 where geometry was hit.
• depth: camera-space distance (scene units).
• N: unit normal, signed. In Camera space the third axis is -forward (+Z points to the viewer), so a face looking at the camera is (0, 0, 1), the classic light blue after packing.
• P: world-space position.
• uv: interpolated UV (from the vertex or point attribute).
• id: integer ID from a primitive attribute (string attributes are numbered in order of appearance); background is -1.
• facing: how much a surface faces the camera, |N . forward|.
• C: simple headlight shading for a quick look at the shape (not a final render).

Rasterization (scan conversion with a z-buffer) is O(covered pixels), much cheaper than ray casting, which matters for per-frame rendering. Triangles crossing the near plane are clipped. With Far > 0, triangles lying completely beyond it are dropped.

With camera mode Frame Geometry the distance or orthographic size is set automatically from the bounding sphere, so the object fills the image. If a camera is connected, all camera parameters on the node are ignored so that the render and later back-projection are guaranteed to use the same camera.

Inputs

Outputs

Parameters

Camera

Passes

Passes › More Passes

Attributes

Compared with Houdini

Corresponds to Rasterize Geometry.