Unreal material vertex positions

2026-01-12 12:26 UTC gpt-5-2 Open in ChatGPT ↗

In Unreal Engine materials, you can’t arbitrarily read mesh vertex buffers like in raw HLSL, but Unreal exposes specific nodes that give you vertex position data depending on space and shader stage.

Here’s how it works and what you can (and can’t) access.

1. Vertex Position (Object Space)

Node: `Absolute World Position` / `Object Position` / `Actor Position`

These are often confused, so the key one for mesh vertices is:

Node: `Absolute World Position`

In the vertex shader, this represents the current vertex position
In the pixel shader, it’s the interpolated position across the triangle

⚠️ Important:

If you want actual per-vertex values, you must use this in World Position Offset or calculations that feed into it.

Example:

Absolute World Position → Transform (World to Local)

This gives you the vertex position in object space.

2. Local / Object Space Vertex Position

Node: `Object Position`

Returns the object’s pivot location, not the vertex position
Not what you want for per-vertex data ❌

To get vertex local position:

Absolute World Position
→ Transform (World to Local)

3. Vertex Position in World Space (Vertex Shader Only)

Best Practice

Use:

Absolute World Position

Then plug your logic into:

World Position Offset
Tessellation displacement (if enabled)

This ensures you are operating in the vertex stage.

4. Pre-Skinned (Skeletal Mesh) Vertex Position

If this is a skeletal mesh, Unreal provides special nodes:

Node: `PreSkinned Local Position`

Position before skinning
Available only for skeletal meshes
Useful for effects that shouldn’t follow animation deformation

Also:

PreSkinned Local Normal

5. Per-Vertex Data via Custom UVs (Pixel Shader Access)

If you need vertex positions in the pixel shader (non-interpolated):

Calculate position in the vertex stage
Store it in a Custom UV channel
Read it back in the pixel shader

Example:

Vertex:
Absolute World Position → Custom UV0

Pixel:
Custom UV0 → use as vertex-derived data

⚠️ Note:

Custom UVs are interpolated, not exact per-vertex unless used carefully.

6. World Position vs Absolute World Position

Node	Meaning
World Position	Pixel position with WPO applied
Absolute World Position	Raw world position (before WPO)

For vertex operations → Absolute World Position

7. What You Cannot Do in Materials

❌ Access arbitrary vertex indices
❌ Read other vertices
❌ Loop over vertex buffers
❌ Random access mesh data

For that, you need:

Custom HLSL in a vertex factory
Compute shader
Niagara mesh data interface
Procedural mesh / runtime mesh

TL;DR (Most Common Use)

Static or Skeletal Mesh (vertex position):

Absolute World Position

Local space vertex position:

Absolute World Position → Transform (World → Local)

Skeletal mesh (pre-skin):

PreSkinned Local Position

If you tell me:

Static vs skeletal mesh
Vertex or pixel shader
What effect you’re building (wind, dissolve, deformation, masking, etc.)

I can give you a node graph or exact material setup tailored to your case.

Got it — to “scale the mesh by scaling its vertices” in a material, you do it in the vertex shader via World Position Offset (WPO). You can’t fetch a full vertex array, but you can get the current vertex position (per-vertex) and move it.

The vertex position you want

Use Absolute World Position (in the vertex stage it’s the vertex position).

Scale vertices around a pivot (most common)

If you scale world positions directly, you must scale relative to a pivot, then add the pivot back.

Node recipe (world-space scale):

AbsoluteWorldPosition (vertex position, WS)
ObjectPositionWS (pivot/center in WS)
Subtract: P = AbsoluteWorldPosition - ObjectPositionWS
Multiply: P_scaled = P * Scale (Scale is a ScalarParameter or VectorParameter)
Add: NewPos = P_scaled + ObjectPositionWS
World Position Offset = NewPos - AbsoluteWorldPosition

So the core math is: $ WPO = ( (PosWS - PivotWS) \cdot Scale + PivotWS ) - PosWS $

✅ This scales the mesh visually in the material.

If you want local/object-space scaling (often cleaner)

Do it in local space then transform back:

PosLS = TransformPosition(AbsoluteWorldPosition, World → Local)
PosLS_scaled = PosLS * Scale
NewPosWS = TransformPosition(PosLS_scaled, Local → World)
WPO = NewPosWS - AbsoluteWorldPosition

This avoids weirdness with rotated objects.

Important limitations (so you don’t get surprised)

This does not change the actual mesh asset.
Collision, navmesh, physics won’t scale with WPO (it’s render-time deformation only).
LODs can behave differently if your scale is extreme.

Looking at your graph screenshot

You’re currently computing the bounds center using Object Local Bounds (Min/Max) → (Min+Max)/2. That’s basically a pivot/center — good. But the missing piece is: you still need to take the vertex position (AbsoluteWorldPosition), move it relative to that center, then output the delta into World Position Offset using the formula above.

If you tell me whether you want uniform scale (one value) or non-uniform (XYZ), I’ll map it to the exact nodes/parameters to drop into your graph.

Yep — local space is the right approach for what you’re doing, and the good news is: even if all tiles share the same material, each StaticMeshComponent evaluates the material with its own transform/bounds, so “scale around center” works per-tile.

Below is the clean setup that will scale each tile about its own center using World Position Offset.

Material setup: scale vertices in local space around the tile’s center

Nodes you need

Absolute World Position
TransformPosition (World → Local)
Object Local Bounds (Min, Max)
Parameters: Scale (Scalar or Vector)

Step-by-step (node graph logic)

1) Get the current vertex position in local space

AbsoluteWorldPosition
→ TransformPosition (World to Local)
Call this PosLS

2) Compute the mesh local-space center

Use:

Object Local Bounds Min and Max
CenterLS = (Min + Max) * 0.5

(What you already started doing in your first screenshot is basically this 👍)

3) Scale around that center (local)

Let Scale be:

ScalarParameter (uniform) or
VectorParameter (non-uniform XYZ)

Do:

OffsetLS = PosLS - CenterLS
ScaledOffsetLS = OffsetLS * Scale
NewPosLS = CenterLS + ScaledOffsetLS

4) Convert back to world and output WPO

NewPosWS = TransformPosition (Local to World) using NewPosLS
WPO = NewPosWS - AbsoluteWorldPosition
Plug WPO into World Position Offset

That’s it.

Why this keeps your tile arrangement intact

Because you’re scaling each component’s vertices around that component’s own bounds center, you’re not moving the component in the world — only deforming its vertices in-place. So neighboring tiles stay where they are.

This works especially well in your case: an FBX actor containing many StaticMeshComponents.

Driving different scales per tile

Materials can’t “know” which component they’re on, so if you want different scales per tile:

Blueprint approach (recommended):

On construction / begin play:
- For each StaticMeshComponent tile:
  - Create Dynamic Material Instance
  - Set Scalar/Vector Parameter Value (e.g. TileScale)
  - Apply it to that component

That gives you per-tile control while still using the same base material.

One gotcha

World Position Offset is render-only:

collision/physics won’t match the scaled shape.

If you need collision to scale too, you’ll have to scale the component transform (or generate collision another way).

If you want, paste what you want your scale control to be (uniform? XYZ? animated?) and I’ll tell you the exact parameter setup + the minimal Blueprint loop for “create DMI per component and set scale.”

That warning isn’t coming from your material/DMI logic — it’s about component mobility.

What the warning means

Unreal won’t let you attach a Static component to a parent that is Movable (or “not static”):

Parent: DefaultSceneRoot → not static (Movable)
Child you’re trying to attach: A_8X8___8_POINTS → Static
Result: attach is aborted.

So somewhere (often during FBX import / construction / Blueprint setup), the static mesh components are being attached under a root whose mobility isn’t Static.

Fix (recommended)

Make the root at least as “static” as the children.

Option A: Set the Root mobility to Static

In the actor Blueprint:

Select DefaultSceneRoot
In Details → Mobility
Set to Static (or Stationary)

If the root is a DefaultSceneRoot and you can’t change it easily, replace it with a SceneComponent you control:

Option B: Replace DefaultSceneRoot

Add a Scene Component
Right-click it → Make Root
Set that new root’s Mobility = Static
Ensure your imported tile components are attached under it.

Alternative fix (if the actor must move)

If you actually need to move the actor at runtime, then the children can’t be Static.

Option C: Set child meshes to Movable

Select your tile StaticMeshComponents (or do it in construction script):

Set Mobility = Movable

This will silence the warning, but it changes lighting behavior (static lighting, HISM batching assumptions, etc.).

Why you’re seeing it in your setup

FBX “scene import” often produces:

one root (movable default scene root)
many mesh components marked Static

As soon as the blueprint tries to attach/organize those components, Unreal complains.

One more thing about your Blueprint graph (unrelated but important)

In your top loop you are calling Set Material and then Create Dynamic Material Instance.

You don’t need both, and doing both can cause confusion about what’s actually assigned.

Do this instead (per component):

Create Dynamic Material Instance (Target = mesh component, Element Index = 0, Source Material = your base material)
Store the returned MID
Don’t call Set Material separately unless you’re not using “Create DMI” on the component.

Then in Tick (or whenever), set parameter on the stored MID.

Also: make sure the array index you use to GET from MIDs matches the component in the loop (use the loop index consistently).

Quick “best” wiring

BeginPlay: ForEach (TileMeshes):

MID = CreateDynamicMaterialInstance(Target = TileMesh, Element 0, Source = ScalerMat)
Add MID to MIDs array (same order as TileMeshes)

Tick (or update): For i in range:

SetScalarParameterValue(Target = MIDs[i], Name=“Scale”, Value=TileScale[i] or TileScale)

If you tell me whether your actor needs to be movable in-game (yes/no), I’ll tell you which mobility option to use so you don’t break lighting or performance.

Your material graph is almost right — the main reason you’re seeing no scaling is this:

✅ You’re subtracting the wrong thing at the very end

Your last Subtract (the one plugged into World Position Offset) is doing:

A = NewPosWS
B = ??? (looks like it’s the output of the first TransformPosition / local position)

But World Position Offset expects a world-space delta:

$ WPO = NewPosWS - CurrentPosWS $

So the B input of that final subtract must be Absolute World Position (world space), not a local-space position.

Fix your last node

Change the final Subtract to:

A = output of TransformPosition (Local → World) (your NewPosWS)
B = Absolute World Position

Then plug that into World Position Offset.

That one mismatch (world vs local) will make the offset essentially nonsense / cancel out.

Your graph in “equation form” (what you want)

You already built this (just wire it correctly):

PosLS = Transform(World → Local, AbsoluteWorldPosition)
CenterLS = (BoundsMin + BoundsMax) * 0.5
NewPosLS = CenterLS + (PosLS - CenterLS) * Scale
NewPosWS = Transform(Local → World, NewPosLS)
WPO = NewPosWS - AbsoluteWorldPosition

Two more quick checks (common gotchas)

1) Make sure the material is actually used on the mesh

In your Blueprint, if you create a MID but the mesh is still using another material slot, you won’t see it. Easiest sanity check:

Temporarily set Base Color to something obvious (bright red) in this material and see if the mesh changes.

2) WPO is disabled in some cases

If this is a Nanite mesh: WPO support depends on UE version/settings and can be limited.
- Quick test: in the static mesh asset, temporarily disable Nanite and see if WPO starts working.

What to do right now

Rewire final subtract: B = Absolute World Position
Compile, apply
If still nothing: test by disabling Nanite on one tile mesh

If you want, screenshot just the rightmost part after you rewire it (the two TransformPosition nodes + final subtract), and I’ll confirm it’s correct.

Nice — that’s a good next step. You basically want one scale value per tile, driven by sampling a black/white mask texture at the tile’s location.

There are two solid ways to do it. The best one depends on whether your tiles all use the same UV layout.

Option A (most common): Sample the BW texture in world-space

This works even if your tiles have different UVs, and it keeps the pattern aligned across the whole grid.

In the material

Pick coordinates to sample the mask:
- Use Absolute World Position
- Take XY (or XZ if your tiles lie on XZ)
- Divide by a TilingSize scalar parameter (world units per texture repeat)
Feed that into your BW texture’s UVs.
Use the sampled value to build a scale.

Node flow:

AbsoluteWorldPosition → ComponentMask (R,G) (XY)
UV = (XY / TilingSize) (ScalarParameter, e.g. 400, 800, etc.)
Mask = TextureSample(BWTexture, UV).r
Optional: Mask = Pow(Mask, Contrast) and/or Lerp(Min, Max, Mask)
Use that Scale = Lerp(ScaleMin, ScaleMax, Mask) in your scaling math.

Use it in your existing local-space scaling:

Replace your uniform Scale parameter with the computed scale:

Scale = Lerp(ScaleMin, ScaleMax, Mask)

If you only want to scale in-plane (not height), use a Vector scale:

ScaleVec = (Scale, Scale, 1) for Z-up tiles (or whichever axis is “up”)

Option B: Sample using the tile’s local UVs

Use this if your BW texture is authored per-tile and you want the same mask repeated on each tile.

Use TextureCoordinate (UV0) → TextureSample
Then drive scale from that

But this will make every tile read the same part of the texture unless the UVs are uniquely packed.

Make it “tile-wise” (each tile a single scale, not varying across the tile)

If you sample by vertex/pixel position, the scale can vary within a tile (corners different than center). If you want the whole tile to scale uniformly based on the BW texture:

Sample at the tile center (best)

You already compute CenterLS. Do this:

CenterWS = TransformPosition(Local → World, CenterLS)
Use CenterWS.xy / TilingSize as UV
Sample texture once (it’ll still be evaluated per-vertex, but constant across tile)

That gives one mask value per tile.

Recommended parameter setup

MaskTex (Texture2D parameter)
TilingSize (Scalar) – world units per repeat
ScaleMin (Scalar) – e.g. 0.2
ScaleMax (Scalar) – e.g. 1.0
Optional: Contrast (Scalar) or Pow exponent

Quick formula

Mask = TextureSample(MaskTex, CenterWS.xy / TilingSize).r
Scale = lerp(ScaleMin, ScaleMax, Mask)

Then plug Scale into your existing tile-center scaling network.

If you tell me:

Are your tiles laid out in XY or XZ?
Do you want scale to affect XY only or uniform XYZ?

…I’ll tell you exactly which component mask to use and what the ScaleVec should be.

Great, this screenshot helps a lot 👍
You’re very close conceptually, but there are two fundamental issues in what you tried that explain why it “kind of works / kind of doesn’t”.

I’ll break it down cleanly.

What you were trying to do (and why it makes sense)

You tried to:

Use Object Local Bounds to build UVs
Normalize the position inside the tile (0–1)
Sample a BW texture
Use that to affect scale

That idea is valid, but there are two problems:

❌ Problem 1: You’re sampling the texture per-vertex, not per-tile

You are feeding vertex-dependent coordinates into the texture sample.

That means:

Every vertex on the same tile samples a different mask value
The scale factor varies across the tile
Vertices no longer move uniformly
Result: warping / collapsing / “not really scaling”

Why this breaks scaling

Scaling math assumes:

Scale is constant for all vertices of the tile

But your graph does:

Scale = f(vertex position)

So corners scale differently than the center.

✅ Correct mental model

If you want each tile to scale as a rigid piece:

Sample the texture once per tile, using the tile center

Materials don’t have “per-object execution”, but you can fake it by sampling using the bounds center, which is constant per component.

❌ Problem 2: Your UV normalization is overcomplicated and fragile

You’re:

Splitting Min/Max
Subtracting per-axis
Dividing by extents
Saturating

This does give normalized coordinates — but in local space, and they reset per tile.

That means:

Every tile samples the same part of the texture
You never get a world-aligned mask
Adjacent tiles don’t line up with the BW texture

This defeats the purpose of using a global mask.

✅ The correct solution (simple + robust)

Because your tiles are arranged on XY, do this:

Step 1: Compute the tile center (you already do this)

CenterLS = (BoundsMin + BoundsMax) * 0.5
CenterWS = TransformPosition(Local → World, CenterLS)

This gives one world-space position per tile.

Step 2: Use world XY to sample the BW texture

UV = CenterWS.xy / TilingSize
Mask = TextureSample(MaskTex, UV).r

Where:

TilingSize = world units per texture repeat (scalar parameter)

Step 3: Convert mask → scale

Scale = lerp(ScaleMin, ScaleMax, Mask)

Optional:

Mask = pow(Mask, Contrast)

Step 4: Use Scale in your existing scaling math

Replace your uniform Scale parameter with this computed value.

If you want XY-only scaling:

ScaleVec = (Scale, Scale, 1)

🔧 Why this works

CenterWS is constant for all vertices in a tile
Texture sampling becomes “per-tile”
Tiles scale uniformly
Mask aligns perfectly across the grid
No warping, no shearing

🧠 Key rule to remember

Any value that affects vertex scaling must be identical for all vertices of the mesh component.

If it depends on vertex position → you get deformation, not scaling.

Minimal node list you actually need

You can delete all of this:

SplitComponents chains
Per-axis normalization
Saturate nodes
Bounds-based UV math

And keep only:

Object Local Bounds → center
TransformPosition
Absolute World Position (already in your graph)
TextureSample
Lerp

If you want, next I can:

Redraw your graph exactly as it should look (node-for-node)
Help you clamp / threshold the BW texture for stepped tile heights
Show how to animate scale smoothly without popping

Totally fair question — this is a conceptual thing, not a built-in Unreal value, and that’s why it feels confusing 👍
Once it clicks, it’s very simple.

What “Tiling Size” actually means (plain English)

Tiling Size = how many world units one full texture repeat covers

That’s it.

It is not something Unreal gives you automatically.
It’s a Scalar Parameter you create, because only you know how big your tiles / grid are.

Concrete example (XY tiles)

Let’s say:

Each tile is 400 × 400 Unreal units
Your BW texture is meant to line up one pixel pattern per tile

Then:

TilingSize = 400

Now when you do:

UV = WorldPosition.xy / 400

Result:

Tile at (0,0) samples UV (0,0)
Tile at (400,0) samples UV (1,0)
Tile at (800,0) samples UV (2,0) → the texture repeats exactly once per tile

Why division, not multiplication?

Textures expect UVs in texture space, where:

0 → 1 = one full texture
1 = repeats

World space is in centimeters, so we divide to convert:

world units → texture units

Where you create it

In your material:

Add a Scalar Parameter
Name it: TilingSize
Default value: something sensible (e.g. 400 or 800)

Then:

CenterWS.xy
÷
TilingSize
→ TextureSample UVs

How to know the correct value

Option A (most common)

Use your tile size:

If tiles are 400×400 → TilingSize = 400
If tiles are 1000×1000 → TilingSize = 1000

Option B (art-driven)

Adjust it in a Material Instance until the mask visually lines up the way you want.

There’s no “wrong” value — it’s a mapping scale.

Why Unreal doesn’t provide this automatically

Because:

Meshes can be any size
Tiles can be non-uniform
Artists may want multiple tiles per texture or vice versa

So Unreal gives you positions, not intent.

Quick mental model

Think of it like this:

“How many centimeters on the ground equal one texture square?”

That number = Tiling Size

TL;DR

❌ It is not an engine-provided value
✅ It is a Scalar Parameter you define
✅ Usually set to your tile size in world units
✅ You can tweak it in a Material Instance

If you want, tell me:

Tile size (world units)
How many tiles across your texture should cover

…and I’ll give you the exact numeric value to use.

You’re thinking about it the right way, but there are two different “sizes” people mean here:

How big is one tile in world units? (tile size)
How big is the whole grid/arrangement? (grid extents)

For the approach we discussed (sample at tile center in world XY), you do not need the whole grid size to normalize. You only need a mapping from world XY → UV, which can be:

tile size (for “one texture cell per tile”), or
grid size (for “texture spans the whole arrangement once”), depending on the look you want.

Which one do you want?

A) Texture repeats every tile (most “tile mask” setups)

Use TileSize:

UV = CenterWS.xy / TileSize

This makes the mask align to your tile lattice. If you change tile size later, you update TileSize.

B) One texture covers the entire arrangement once

Use GridSize:

UV = (CenterWS.xy - GridMin.xy) / GridSize.xy

This gives UV in 0–1 across the whole layout, regardless of world position.

This is the one that truly needs “normalization”.

Yes: you can compute it in Blueprint and pass it to the material

You have two good mechanisms:

1) Dynamic Material Instance parameters (per tile/component)

Compute the number(s) in BP
Call SetScalarParameterValue / SetVectorParameterValue on the MID(s)

2) Material Parameter Collection (global)

If all tiles should share the same mapping:

Put TileSize, or GridMin/GridSize into an MPC
Set MPC values once from BP
Every material reading the MPC updates automatically

Blueprint: compute grid extents automatically

Since your actor contains many tile mesh components, you can compute the grid bounds from their component bounds.

What to compute

GridMinXY
GridMaxXY
GridSizeXY = GridMaxXY - GridMinXY

Then pass:

GridMinXY (Vector2 packed in a VectorParameter as X,Y,0)
GridSizeXY (Vector2 packed similarly)

BP logic (high level)

Get all tile StaticMeshComponents
For each:
- GetComponentBounds (Origin, BoxExtent)
- Min = Origin - BoxExtent
- Max = Origin + BoxExtent
- Accumulate global min/max (XY only)
After loop:
- GridSize = Max - Min
Set material params (MID or MPC)

Material side for “texture covers whole arrangement once”

Use the tile center in world (constant per tile), then:

UV = (CenterWS.xy - GridMin.xy) / GridSize.xy

Then sample your BW texture with UV.

Important: avoid divide-by-zero

Clamp GridSize:

SafeGridSize = Max(GridSize, 1) (or 0.001)

Because you said tile counts/sizes will change a lot:

✅ Use GridMinXY + GridSizeXY computed in Blueprint
✅ Put them in a Material Parameter Collection
✅ Sample using CenterWS.xy and normalize to 0–1 across the current layout

That way whenever you change the tile arrangement, you just recompute and the mask stays correct without hand-tuning.

Practical note about per-tile centers

In the material, compute:

CenterLS = (LocalBoundsMin + LocalBoundsMax) * 0.5
CenterWS = TransformPosition(Local→World, CenterLS)

That gives you the right “one value per tile” to sample with.

If you want, I can write the exact Blueprint node sequence to:

compute GridMin/GridMax from your tile components,
then set them into either (a) an MPC or (b) each tile MID.

Tell me which you prefer: MPC (global) or MID per tile (per-instance).

Yep — Option B is exactly “texture spans the whole grid once” and each tile reads the mask at its own center to decide its scale.

Here’s the clean setup.

1) Blueprint: compute the grid bounds and pass to the material

What you need to pass

GridMinXY (Vector2)
GridSizeXY (Vector2)

Best way: Material Parameter Collection (MPC) so all tiles share the same values.

Blueprint logic (Construction Script is ideal so it updates in editor)

For each tile StaticMeshComponent:

GetComponentBounds → returns:
- Origin (world)
- BoxExtent (world)
Compute:
- CompMin = Origin - BoxExtent
- CompMax = Origin + BoxExtent
Accumulate global:
- GridMin = Min(GridMin, CompMin)
- GridMax = Max(GridMax, CompMax)

After the loop:

GridSize = GridMax - GridMin

Only care about X and Y.

Then set MPC params

Set Vector Parameter Value (MPC): GridMin = (GridMinX, GridMinY, 0)
Set Vector Parameter Value (MPC): GridSize = (GridSizeX, GridSizeY, 0)

Tip: initialize GridMin to a huge number (e.g. 1e9) and GridMax to -1e9 before the loop.

2) Material: sample the BW texture once per tile (tile center), normalized across the grid

A) Get tile center in world space (constant per tile)

Object Local Bounds Min/Max → CenterLS = (Min + Max) * 0.5
CenterWS = TransformPosition(Local → World, CenterLS)

B) Normalize to 0–1 across the whole grid

Read MPC vectors: GridMin, GridSize
UV = (CenterWS.xy - GridMin.xy) / GridSize.xy

Safety:

SafeSize = Max(GridSize.xy, (1,1)) (or 0.001) to avoid divide-by-zero

C) Sample mask

Mask = TextureSample(MaskTex, UV).r

D) Turn mask into scale

Scale = Lerp(ScaleMin, ScaleMax, Mask)

If you want the tile to scale only in XY (stay flat in Z):

ScaleVec = (Scale, Scale, 1)

E) Plug ScaleVec into your existing local-space scaling math

Where you currently multiply by a uniform Scale, multiply by ScaleVec.

Quick “sanity test” before scaling

To confirm your UVs are right, temporarily preview the mask:

Plug Mask into Base Color (grayscale)
You should see the BW texture mapped across the whole grid (each tile should be a flat value if you sample at center).

If you see the texture smear within a tile, you’re accidentally sampling using vertex positions instead of the tile center.

Common gotchas

Sampler Address Mode: set the BW texture to Clamp if you don’t want repeats outside 0–1.
GridSize is in world units: if your tiles are rotated/scaled as components, GetComponentBounds already accounts for that.
Put the bounds compute in Construction Script so it updates when you edit the actor.

If you want, I can give you an exact node-by-node Blueprint layout for the bounds accumulation + MPC set (no C++), but the above is the exact algorithm you need.

You pass ColorA and ColorB exactly the same way you’re already passing Bounds / GridBox: as Vector (or LinearColor) parameters on the MID.

1) In the material (MI_Scaler’s parent)

Create two parameters:

Vector Parameter ColorA
Vector Parameter ColorB

Then use them in the graph wherever you need (e.g. for debug coloring, remapping, etc.).
If you don’t create parameters with those exact names, Blueprint can’t set them.

2) In the Blueprint: set them on the MID after you create it

Use either of these nodes (both work):

Set Vector Parameter Value (Target is Material Instance Dynamic)
or
Set Vector Parameter Value (Linear Color) (depending on your UE version)

Wiring:

Target = MI_Scaler (your MID variable)
Parameter Name = "ColorA"
Value = your ColorA variable (type Color/LinearColor)

Repeat for "ColorB".

So you’ll have two nodes:

Set Vector Param Value → ColorA
Set Vector Param Value → ColorB

Where in your graph to do it

Do it where you currently set GridBox, Input, and Scale (same execution chain), right after the MID exists.

In your screenshot, you’re already calling:

Set Vector Parameter Value (GridBox)
Set Texture Parameter Value (Input)
Set Vector Parameter Value (Scale)

Just add two more Set Vector Parameter Value nodes in that same chain.

One important gotcha in your screenshot

Your ColorA / ColorB variables are Color, but your Bounds variable is Linear Color. Make sure you’re consistent:

If your material param is a Vector Parameter, Blueprint will accept either, but sometimes you need a conversion:
- use LinearColor → Vector (or just use the LinearColor setter node)

Simplest: keep ColorA and ColorB as Linear Color variables in BP.

If you meant “pass them to every tile MID”

Right now you’re setting params on MI_Scaler only. If each tile has its own MID (recommended), you’d do:

ForEach MIDs:

Set Vector Param ColorA
Set Vector Param ColorB

Same nodes, just target = MIDs[ArrayIndex].

If you tell me whether MI_Scaler is a single global MID or one MID per tile, I’ll tell you the exact place to wire it so it affects the right instances.