Stamp Circle CVT UE5

2026-01-09 16:24 UTC gpt-5-2-thinking Open in ChatGPT ↗

In UE 5.5 the usual way to “stamp” a shape into a Runtime Virtual Texture (people sometimes say “CVT” loosely) is: make a writer component whose material outputs to an RVT, then move / spawn that writer at the target Actor’s world position. The “circle” is just a mask you compute in the stamp material from world position vs stamp center.

Below is a clean, reliable setup that works for footprints, paint splats, scanning circles, etc.

1) Set up the RVT (the “canvas”)

Create an RVT asset: Content Browser → Texture → Runtime Virtual Texture.
Place a RuntimeVirtualTextureVolume in the level and assign that RVT asset.
Make sure the volume bounds cover the area you want to stamp.

Epic’s RVT workflow is centered around materials using Runtime Virtual Texture Output to write, and RVT Sample to read. citeturn0search8

2) Make your “receiver” material sample the RVT

Whatever surface should show the stamp (Landscape, ground mesh material, etc.) needs to sample the RVT and blend it into its shading.

In the receiver material:

Add Runtime Virtual Texture Sample (point it at your RVT asset)
Blend the sampled result into BaseColor / Normal / Roughness (whatever you stored)

(If you only need a mask, you can store it in BaseColor or a spare channel depending on your RVT layout.)

A good practical walkthrough of writing + sampling is here. citeturn0search15

3) Create a “stamp writer” Actor (the thing that draws into the RVT)

Create BP_RVTStamp with:

A StaticMeshComponent (usually a Plane / Quad)
Enable Draw in Virtual Textures on that mesh component and add your RVT asset to the list (so it actually renders into the RVT)
Assign a Stamp material that uses Runtime Virtual Texture Output to write

Important behavior note: RVTs are rendered from current writers in the world.
If you destroy the writer actor, the stamp will typically disappear on the next RVT update because it’s not “baked” permanently. For permanent painting, you usually use a Render Target workflow instead. (RVT stamping is perfect for “live” effects, or if you keep stamp instances around.)

4) Build the circle mask in the stamp material (core idea)

In the stamp material (applied to the plane), do this:

Inputs you want as parameters

Radius (world units)
Hardness (edge softness)
StampColor (or a scalar “ink” value)

Circle math (world-space)

P = AbsoluteWorldPosition
C = StampCenterWorld (usually just the stamp actor’s location)
d = length( (P - C).xy )
mask = 1 - smoothstep(Radius - Hardness, Radius, d)

Then write it via Runtime Virtual Texture Output (BaseColor, etc.). Epic’s doc shows the RVT Output node is the intended path for writing. citeturn0search8

How to get `StampCenterWorld` into the material

Pick one of these:

Option A (simplest): use the stamp actor’s own position

If your stamp is a plane centered on the actor, you can use the material node Actor Position (or Object Position) as C, and AbsoluteWorldPosition as P.
That makes the circle always centered on the stamp actor.

Option B (more flexible): Dynamic Material Instance parameter

Add a Vector parameter StampCenterWorld
In Blueprint, create a Dynamic Material Instance for the stamp mesh and set StampCenterWorld every time you move the stamp.

5) Drive the stamp from another Actor’s position (Blueprint)

In the Actor that controls stamping (or in the stamp itself):

“Follow and stamp” (continuous)

On Tick (or at some interval):
- TargetPos = TargetActor.GetActorLocation()
- BP_RVTStamp.SetActorLocation(TargetPos)
- (Optional) set radius/color parameters

“Stamp once” (spawn)

When you want a mark:
- SpawnActor BP_RVTStamp at TargetActor location
- Set radius/color
- Keep it alive (or pool them) as long as you want the mark visible in RVT

Common gotchas

Nothing shows up: the writer mesh must have Draw in Virtual Textures enabled and include the RVT asset; and the writer material must actually use Runtime Virtual Texture Output. citeturn0search8
Stamp is clipped / disappears: RVTVolume bounds too small or stamp plane outside the volume.
You wanted “permanent paint”: use a Render Target painting approach instead (RVT isn’t a persistent storage by itself).
Many circles at once: consider a Niagara Grid2D / RT approach for batching hundreds of circles efficiently. citeturn0search16

If you tell me what you mean by “CVT” in your project (Runtime Virtual Texture? a specific plugin? “continuous virtual texture”/clipmap?), and whether you want the stamp to be persistent after the writer is removed, I can tailor the exact node graph + Blueprint steps to that workflow.

Got it — Canvas Render Texture in UE = typically CanvasRenderTarget2D (UCanvasRenderTarget2D) (or a “canvas” you draw on with UCanvas), not RVT.

To “stamp a circle” at an Actor’s world position you need two pieces:

A way to convert world position → UV/pixel coordinates on the texture
Draw a circle into the CanvasRenderTarget2D at that pixel

Below are two solid workflows (Blueprint-first), plus the key math.

A. Blueprint workflow (CanvasRenderTarget2D) — stamp circles

1) Create the render target

Content Browser → Materials & Textures → Canvas Render Target 2D
Name it CRT_Paint
Set size (e.g. 1024×1024)

2) Create a material that draws a circle (for stamping)

Make a material M_CircleStamp:

Material Domain: Surface (works fine for drawing to canvas)
Blend Mode: Translucent (or Masked)
Shading Model: Unlit
Output only Emissive Color and Opacity

Parameters:

Radius01 (Scalar, 0–0.5 typically)
Feather01 (Scalar, small like 0.01)
Color (Vector)

Node logic (in UV space):

UV = TextureCoordinate
d = length(UV - float2(0.5,0.5))
mask = 1 - smoothstep(Radius01, Radius01 + Feather01, d)
Emissive = Color * mask
Opacity = mask

This material assumes you draw it into a square where the circle is centered.

3) Make a Blueprint that updates the CanvasRenderTarget2D

Create BP_PaintCanvas with:

Variable CanvasRT (Canvas Render Target 2D)
Variable StampMID (Material Instance Dynamic of M_CircleStamp)
Variable WorldBounds (Box or 2 vectors Min/Max) defining what area the texture represents in the world

In BeginPlay:

StampMID = CreateDynamicMaterialInstance(M_CircleStamp)
CanvasRT = Create Canvas Render Target 2D (or reference the asset)
Bind / use the Canvas RT’s OnCanvasRenderTargetUpdate event (in BP, open the CanvasRenderTarget2D asset and implement Receive Update OR call UpdateResource after setting variables)

4) Convert Actor world position → texture pixel

Decide what your paint texture “covers” in the world.

Common approach: define a world rectangle (Min, Max) on X/Y plane.

Let:

Min = (MinX, MinY)
Max = (MaxX, MaxY)
P = ActorLocation

Compute UV:

U = (P.X - MinX) / (MaxX - MinX)
V = (P.Y - MinY) / (MaxY - MinY)

Then pixel:

Px = U * Width
Py = (1 - V) * Height (flip if needed depending on how you interpret Y)

Clamp U,V to [0..1].

5) Draw the circle into the canvas at that pixel

In the CanvasRenderTarget2D Receive Update event you get Canvas and Width/Height.

To stamp at (Px, Py):

Decide stamp size in pixels, e.g. StampSizePx
Compute top-left:
- X = Px - StampSizePx/2
- Y = Py - StampSizePx/2

Then call Draw Material:

Canvas->K2_DrawMaterial(StampMID, X, Y, StampSizePx, StampSizePx, 0,0,1,1)

Before drawing, set params on StampMID:

Radius01 (like 0.5 for “fill the quad” circle, or smaller)
Feather01
Color

Finally, when you want to add a stamp:

Store the Actor position (or a list of stamps)
Call CanvasRT->UpdateResource() (Blueprint node: Update Resource)

Stamping multiple circles

Because Receive Update redraws the whole texture each time, you usually:

Keep an array of stamp data (UV + size + color)
In Receive Update, loop and draw each stamp material call
(Optional) first clear with K2_DrawBox or draw a “clear” material

If you want “true accumulation” without redrawing history every update, Canvas RT alone won’t magically preserve unless you do a ping-pong (see section C).

B. “One stamp per update” (quick and dirty)

If you only need occasional stamps and can afford redrawing:

Maintain an array of stamp positions
Redraw all stamps each update

This is the simplest and most reliable in Blueprint.

C. If you need persistent paint efficiently: Ping-pong accumulation

CanvasRenderTarget2D update is “paint the frame” style. To accumulate without replaying all stamps:

Have two render targets: RT_A, RT_B
On each stamp:
- Draw previous RT (A) onto canvas first (full-screen)
- Draw your new circle on top
- Output into RT_B
- Swap A/B

You do the “draw previous texture” step by using a material that samples RT_A and outputs it, then draw that material full-screen on the canvas before drawing the new stamp.

The only tricky part: mapping world → UV

If your “canvas” is literally a mesh (like a plane you paint on), you can avoid bounds math by doing a trace:

LineTrace to the canvas mesh
Use Find Collision UV on the hit result (requires “Support UV From Hit Results” project setting + mesh collision settings)
UV → pixel → stamp

That’s often the nicest workflow if the paintable surface isn’t a simple axis-aligned world rectangle.

Minimal “recipe” summary

CanvasRT ReceiveUpdate:
- (Optionally) draw previous RT (for persistence)
- For each stamp:
  - world → UV (bounds or collision UV)
  - UV → pixel
  - K2_DrawMaterial(StampMID, X, Y, Size, Size, …)

If you tell me which mapping you’re using:

(1) fixed world rectangle (min/max), or
(2) paint on a specific mesh via trace + collision UV,

…I can give you the exact Blueprint node chain (with variable names) for that case.

To “stamp” (actually draw) onto a Canvas Render Target you do it inside the render target’s Receive Update event, using Draw Material (or Draw Texture). The stamp happens when you call Update Resource.

Here’s the simplest working Blueprint pattern.

1) Make a stamp material

Create M_CircleStamp (Unlit, Translucent):

Circle mask in UV space (centered at 0.5,0.5)
Output Emissive = Color * Mask, Opacity = Mask

(So drawing the material as a square puts a circle inside it.)

2) Create a Canvas Render Target 2D BP

Create BP_CRT derived from CanvasRenderTarget2D (Blueprint Class → search CanvasRenderTarget2D).

Inside BP_CRT:

Add variables:
- PendingStampUV (Vector2D)
- PendingStampSizePx (float)
- PendingStampColor (LinearColor)
- StampMID (MaterialInstanceDynamic)

Event: BeginPlay (or OnInitialized equivalent)

StampMID = CreateDynamicMaterialInstance(M_CircleStamp)

Event: Receive Update (this is where drawing happens)

You’ll get Canvas and Width, Height.

Do:

Convert UV → pixel:
- Px = PendingStampUV.X * Width
- Py = (1 - PendingStampUV.Y) * Height (flip Y if needed)
Compute top-left:
- X = Px - PendingStampSizePx * 0.5
- Y = Py - PendingStampSizePx * 0.5
Set StampMID params:
- SetVectorParameterValue(Color, PendingStampColor)
- (Optional) radius/feather params
Draw the stamp:
- Canvas -> K2_DrawMaterial(StampMID, X, Y, PendingStampSizePx, PendingStampSizePx, 0,0,1,1)

That’s the stamp.

3) Trigger a stamp from an Actor position

In the actor that wants to stamp:

A) Convert Actor world position → UV

If your texture represents a world rectangle (Min/Max on X/Y):

U = (WorldX - MinX) / (MaxX - MinX)
V = (WorldY - MinY) / (MaxY - MinY)
Clamp U,V to 0..1
UV = (U,V)

B) Send it to the CRT and update

Set BP_CRT.PendingStampUV = UV
Set BP_CRT.PendingStampSizePx = 64 (example)
Set BP_CRT.PendingStampColor = (1,0,0,1) (example)
Call Update Resource on the Canvas Render Target instance

Calling Update Resource is what causes Receive Update to run and actually draw.

Important note about “multiple stamps”

If you call Update Resource again with a new UV, by default you’ll redraw from scratch unless you also redraw previous content.

Two easy options:

Store an array of stamps (UV/size/color) and in Receive Update loop through and draw them all every time.
Ping-pong (RT_A, RT_B): first draw RT_A fullscreen, then draw the new circle, output to RT_B, then swap.

If you’re stamping onto a mesh (best UV mapping)

Do a LineTrace to the mesh and use Find Collision UV → that gives UV directly, then do the same “PendingStampUV + Update Resource” flow.

If you tell me which case you’re doing:

stamping into a world-rect map (min/max), or
stamping onto a specific mesh (trace UV),

…I’ll write the exact node-by-node Blueprint steps for that setup.

Fair reaction 😄 — this part is genuinely confusing in Unreal, and the wording people use makes it worse.
Let me reset and explain exactly what “stamping” means in Canvas Render Target terms, without hand-wavy engine speak.

The ONE rule you must understand

You never draw directly.
You ask Unreal to update the Canvas Render Target, and Unreal calls a function where you are allowed to draw.

That function is Receive Update.

Nothing else draws. Ever.

There are ONLY two valid ways to draw to a Canvas Render Target

✅ Way 1 (Blueprint-only, RECOMMENDED)

Subclass CanvasRenderTarget2D and override Receive Update.

Step-by-step (no ambiguity)

1️⃣ Create a Blueprint class

Add → Blueprint Class
Search for CanvasRenderTarget2D
Name it BP_PaintRT

This is not a normal Actor.
This is the render target itself.

2️⃣ Open `BP_PaintRT`

You will see this event:

🟢 Event → Receive Update

This event:

Is called by the engine
Gives you a Canvas
This is the ONLY place you can draw

3️⃣ Draw inside `Receive Update`

Example minimal stamp:

Event ReceiveUpdate(Canvas, Width, Height)
 ├─ Draw Material (your circle material)
 └─ done

Blueprint node:

Draw Material / K2_DrawMaterial

If you do NOT draw here → nothing happens.

4️⃣ Trigger a stamp (THIS is what people mean by “bind / call update”)

From ANY OTHER Blueprint:

BP_PaintRT → Update Resource

That’s it.

Calling Update Resource:

Clears the render pass
Calls Receive Update
Lets you draw again

You are not “binding” anything.
You are just telling Unreal:
“Run Receive Update now.”

❌ Way 2 (DO NOT DO THIS unless you hate yourself)

Creating a CanvasRenderTarget2D asset and trying to “bind” a delegate in BP.

This exists in C++ but is:

awkward in Blueprint
poorly documented
unnecessary

Ignore it.

So what was that confusing sentence actually saying?

“Bind / use the Canvas RT’s OnCanvasRenderTargetUpdate event”

Translated into plain English:

“Put your drawing code inside Receive Update,
then call Update Resource when you want to stamp.”

That’s all.

ACTUAL STAMP FLOW (REAL, SIMPLE)

1) Somewhere in gameplay code:

Set StampPosition
Set StampSize
PaintRT → Update Resource

2) Engine does:

→ Receive Update
→ You draw the circle
→ Texture updates

Why your Actor position matters

You do NOT draw from the Actor.

You:

Convert Actor world position → UV / pixel
Store that value on BP_PaintRT
Call Update Resource
Receive Update uses that stored value to draw

If you want MULTIPLE stamps

You must store them.

Array<StampData>

Then in Receive Update:

ForEach Stamp
 └─ Draw circle

Canvas RT does not remember previous frames unless you redraw them.

Mental model (this will save you later)

Canvas RT = a printer
Receive Update = the print job
Update Resource = pressing “Print”
Actor = just telling the printer what to print

If you want, next I can:

draw the exact Blueprint node graph (node names, order)
explain how to stamp onto a mesh using collision UV
explain ping-pong accumulation visually

Just tell me which one.

Good question. This part is actually simple mechanically, it’s just rarely explained cleanly.

You’re asking about ping-ponging (swapping) two Canvas Render Targets so paint accumulates.

I’ll explain it step by step, no jargon, no magic.

What “swap Texture A and B” really means

You have two render targets:

RT_A → holds the previous paint
RT_B → you draw the new paint into

After drawing:

RT_B becomes the new “previous”
RT_A becomes the next write target

You do NOT copy pixels manually.
You swap references.

1️⃣ Create the two render targets

Create two Blueprint subclasses of CanvasRenderTarget2D:

BP_PaintRT_A
BP_PaintRT_B

They should be identical.

Each has:

Receive Update
Draw logic inside it

2️⃣ Create a manager (Actor or GameInstance)

Create BP_PaintManager (Actor is easiest).

Add variables:

Name	Type
`RT_Read`	CanvasRenderTarget2D
`RT_Write`	CanvasRenderTarget2D

At BeginPlay:

RT_Read  = BP_PaintRT_A
RT_Write = BP_PaintRT_B

3️⃣ In the WRITE RT, draw the previous texture first

Inside RT_Write → Receive Update:

Draw order matters:

1️⃣ Draw the previous texture FULLSCREEN
2️⃣ Draw the new circle stamp ON TOP

How to draw the previous texture

Create a material M_CopyRT:

Unlit
Emissive = TextureSample (parameter SourceRT)
Opacity = 1

In Receive Update:

Set M_CopyRT.SourceRT = RT_Read
Draw Material (M_CopyRT, 0,0, Width, Height)

This copies RT_Read → RT_Write.

4️⃣ Draw the new stamp

After copying:

Draw Material (CircleStamp, X, Y, Size, Size)

Now RT_Write contains:

Old paint + new paint

5️⃣ Swap the references (THIS IS THE “SWAP”)

After calling:

RT_Write → Update Resource

Immediately swap:

Blueprint swap logic

Temp = RT_Read
RT_Read = RT_Write
RT_Write = Temp

That’s it.

No textures moved.
No pixels copied.
Just pointer swapping.

6️⃣ Use RT_Read everywhere else

Your materials, meshes, UI, etc. should always sample RT_Read.

Never sample RT_Write.

Visual timeline (important)

Initial

RT_Read  = A
RT_Write = B

Stamp 1

B = A + stamp
swap
RT_Read  = B
RT_Write = A

Stamp 2

A = B + stamp
swap
RT_Read  = A
RT_Write = B

Paint accumulates forever.

Common mistakes (very important)

❌ Sampling the write target
→ causes feedback artifacts

❌ Forgetting to draw the old RT first
→ paint resets every update

❌ Clearing the canvas automatically
→ you wipe history

Minimal blueprint call sequence (correct)

From gameplay code:

Set StampData
RT_Write → Update Resource
Swap RT_Read / RT_Write

Mental model (lock this in)

RT_Read = “what I see”
RT_Write = “what I’m writing into”
Swap = “turn the page”

If you want, next I can:

show how to do this inside ONE blueprint instead of two
explain how to avoid feedback loops on GPU
show how to stamp hundreds of circles efficiently

Just say which one.

Fair. Here’s exactly how to swap two render targets in Blueprint nodes, no pseudo code.

Goal

You have two variables in a Blueprint (usually a manager Actor):

RT_Read (type: Texture Render Target 2D or Canvas Render Target 2D)
RT_Write (same type)

You want to swap them after each stamp.

The exact Blueprint nodes

1) Create a temp variable

In the Blueprint variables panel:

Add variable RT_Temp
Type: same as RT_Read / RT_Write (Texture Render Target 2D or Canvas Render Target 2D)

2) Make a “Swap” Custom Event (or Function)

In Event Graph:

Add Custom Event → name it SwapRTs

Inside it, place these nodes in this exact order:

Get RT_Read → Set RT_Temp
Get RT_Write → Set RT_Read
Get RT_Temp → Set RT_Write

That’s the swap.

Concretely, the node sequence looks like:

Set RT_Temp (Value pin from Get RT_Read)
Set RT_Read (Value pin from Get RT_Write)
Set RT_Write (Value pin from Get RT_Temp)

Wire execution pins straight through in that order.

Where to call it

After you finish drawing into the write target:

RT_Write → Update Resource (node: Update Resource if it’s a CanvasRenderTarget2D)
Then immediately call SwapRTs

So the chain is:

Stamp Event → Update Resource (RT_Write) → SwapRTs

If your variables are “TextureRenderTarget2D” not “CanvasRenderTarget2D”

Swapping is identical.

The only difference is how you update/draw.
But swapping the references is the same 3 Set nodes.

Quick sanity check

After swap:

Whatever was in RT_Write is now in RT_Read
Your materials/UI should always sample RT_Read

If you tell me what class your variables are ( TextureRenderTarget2D vs CanvasRenderTarget2D ), I’ll name the exact node you should use to update the write target in your version (5.5), because the “Update Resource” node only appears for Canvas RTs.