PCG recipes: two ways to read paint inside a graph.

The custom nodes call UTerraInkSubsystem::SamplePaintAt directly, so they read the same paint state the rest of the plugin uses. The user parameters surface the underlying RT and let you sample it manually with stock PCG nodes.

TerraInk Sample Paint

Per input point, samples one paint layer at the point's world position and writes the result as a float metadata attribute on each output point.

Both properties are PCG-overridable, so you can drive Layer from upstream attributes if you need a graph that reads different layers per dispatch.

TerraInk Sample All Layers

Same node, but samples all five paint layers (R, G, B, A, Secondary) per point in one pass and writes five float attributes.

Use this for territory-control or biome graphs where each point needs to know about every layer (e.g., spawn a contested-zone mesh where R and B both exceed a threshold).

Recipe: density-driven scatter (with the node)

Goal: sample paint per point, keep only points whose layer intensity is above a threshold, spawn meshes there.

[Get Spatial Data Bounds]
       │
       ▼
[Surface Sampler]
   Iterations / density configured to taste
       │
       ▼
[TerraInk Sample Paint]
   Layer:               PaintLayer_R   (or whichever)
   OutputAttributeName: Intensity
       │
       ▼
[Filter Points by Attribute]
   keep where Intensity >= 0.1   (your gameplay threshold)
       │
       ▼
[Static Mesh Spawner]

Three nodes plus the spawner. No UV math.

Recipe: density gradient

Goal: scatter density falls off from a "core" of high paint intensity to sparse at the edges.

Same as the previous recipe, but instead of filtering hard:

• After TerraInk Sample Paint, copy the Intensity attribute onto the point's Density attribute (one Attribute Transfer or Attribute Copy node).
• Use a Density Filter node before the spawner. PCG drops points stochastically based on density – higher intensity gives denser scatter, lower intensity gives sparser.

Smooth gradient out of the box, no math.

Recipe: layer-routed meshes (with the multi-layer node)

Goal: one graph, multiple layers, route each point to the mesh set for whichever layer dominates that point.

[Surface Sampler] -> [TerraInk Sample All Layers]
                            │
                            ▼
              [branch on max(Paint_R, Paint_G, Paint_B, Paint_A, Paint_Secondary)]
                            │
              ┌────────────┬────────────┐
              ▼             ▼             ▼
         [SMSpawner: R] [SMSpawner: G] [SMSpawner: B] ...

PCG doesn't ship a one-shot "argmax" node, but the standard approach works: chain attribute math nodes that compare each layer attribute and tag the point with a winner enum or int. Filter into one branch per layer and spawn from the right mesh set.

Recipe: tier-aware density

The bridge passes LayerIndex, TierIndex, and Seed via the dispatch context. Seed is wired into UPCGComponent::Seed automatically and graph nodes that randomize honor it. LayerIndex and TierIndex are not exposed as graph parameters today. Three options:

When a cell promotes to a tier with PCG graphs configured, the bridge:

Declare these in your PCG graph via Graph Editor » User Parameters with the exact names and types below.

Recipe: density-driven scatter (raw RT path)

Same goal as the easy path, but sampling the RT directly.

[Get Spatial Data Bounds]
       │
       ▼
[Surface Sampler]
       │
       ▼
[Add Attribute From Property]
   New attribute: UV (Vector2)
   Per point:  uv.x = (position.x - ArenaMin.x) / ArenaSize.x
               uv.y = (position.y - ArenaMin.y) / ArenaSize.y
       │
       ▼
[PCG Texture Sampler]
   Texture: PaintRT
   UV input: UV attribute from the previous node
   Output:   SampledColor (RGBA per point)
       │
       ▼
[Add Attribute From Property]
   New attribute: Intensity (float)
   Per point:    intensity = dot(SampledColor, ChannelMask)
       │
       ▼
[Filter Points by Attribute]
   keep where Intensity >= 0.1
       │
       ▼
[Static Mesh Spawner]

The Add Attribute From Property nodes do the math. In practice you wire a Get Property node plus a small expression chain.

• Wrong parameter name.

  paintRT (lowercase p) won't bind. Match case exactly.

• Wrong parameter type.

  PaintRT declared as Texture2D won't bind to the bridge's UTextureRenderTarget2D*; both are UObject derivatives, but PCG's property bag uses concrete typing. Declare as Object Reference (UObject*) and cast inside the graph.

• Sampling a render target.

  UTextureRenderTarget2D works with PCGTextureSampler, but make sure your sampler's source is set to the parameter, not a hardcoded asset.

• UV math.

  If your ArenaSize is wrong (e.g., zero on one axis), UVs go to infinity and the texture sampler returns garbage. The bridge initializes ArenaSize = ArenaBounds.GetSize() which is always positive for a valid FBox.

• Layer mismatch.

  The dispatch fires per layer. If your graph reads ChannelMask and the dispatch was for layer R, you'll only get R-channel intensity. To compose multiple layers in one graph, use TerraInk Sample All Layers instead, or dispatch a separate combined graph and plumb additional channel masks.

The PCG dispatch fires on cell tier promotion. When the cell's tier later changes (demote, exit, or override by another layer), the bridge cleans up the spawned volume via FTerraInkPCGHooks::Cleanup. Your graph doesn't need to handle teardown; it runs once per promotion and the bridge tears down the spawn on demote.

Cross-layer override: if layer B paints over layer A, A's tier demotes only when A's ChannelMask intensity drops in the zone-map RT, which requires B's brush material to honor SubtractRate (default 0.5). Without subtraction, A's PCG content stays alive even though B's paint is now visible on the surface. See the Paint Config notes in the main documentation for the SubtractRate knob.

• FTerraInkPCGDispatchContext (TerraInkPCGHooks.h) – the dispatch payload (cell index, layer, tier, owner actor, paint RT, arena bounds, channel mask).
• UTerraInkScatterManager::ScatterPaintLayerTierInCell – populates the context and fires FTerraInkPCGHooks::Dispatch().Execute(Ctx).
• TerraInkPCGBridgeModule::HandleDispatch – receives the context, spawns the volume, calls FPCGGraphParameterExtension::SetGraphParameter against the graph instance's user-parameter property bag for each of the four parameters, then schedules Generate().
• PCGTerraInkSampleNode.cpp – the two custom nodes (FPCGTerraInkSamplePaintElement, FPCGTerraInkSampleAllLayersElement); each walks input points, calls UTerraInkSubsystem::SamplePaintAt(WorldPos, Layer), writes a float metadata attribute.