Playback .ply Sequence Blender

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

Blender can do this, but it’s not as straightforward as video because a .ply sequence is just a series of static meshes. The basic idea is: import each frame and animate which one is visible.

Here are the main approaches, from simplest to more scalable.

Method 1 – Quick & Simple (small sequences)

Best if you have like 10–100 frames.

Put all your .ply files in one folder
Example:

frame_0001.ply
frame_0002.ply
frame_0003.ply
...

In Blender:
- File → Import → Stanford (.ply)
- Import all files at once (multi-select)
You’ll now have one object per frame.
Animate visibility:
- Select first object
- In Object Properties → Visibility
  - Keyframe Render and Viewport
- Frame 1: visible
- Frame 2: hide it, show object 2
- Repeat…

This works but is painful for long sequences.

Method 2 – Proper Way (Geometry Nodes, recommended)

This is the cleanest modern solution.

Idea

Load a different .ply file per frame using Geometry Nodes.

Steps

Add an empty object:
- Add → Mesh → Plane (or any dummy object)
Add Geometry Nodes modifier.
Build this node graph:

Scene Time → Frame
     |
     v
String Format → "frame_%04d.ply"
     |
     v
Import PLY

More detailed:

Add Scene Time node → use Frame
Add String Format node:
- Format: frame_%04d.ply
Add Import PLY node
Plug String → Import PLY → Output to Group Output

Set folder path in Import PLY node.

Now Blender loads a different point cloud each frame.

Result

Scrubbing the timeline plays your point cloud sequence like a video.

This scales to thousands of frames.

Method 3 – Python Script (batch animation)

Useful if you want more control.

import bpy
import glob

files = sorted(glob.glob("/path/to/plys/*.ply"))

for i, f in enumerate(files):
    bpy.ops.import_mesh.ply(filepath=f)
    obj = bpy.context.selected_objects[0]
    obj.hide_render = True
    obj.hide_viewport = True

    obj.keyframe_insert("hide_render", frame=i+1)
    obj.keyframe_insert("hide_viewport", frame=i+1)

    obj.hide_render = False
    obj.hide_viewport = False
    obj.keyframe_insert("hide_render", frame=i+2)
    obj.keyframe_insert("hide_viewport", frame=i+2)

Rendering Tips for Point Clouds

PLYs are usually just vertices, so:

Make them visible

Select object → Object Data Properties
Increase Point Size
Or use Geometry Nodes → Points to Spheres

Faster playback

Use Workbench or Eevee
Disable shadows
Use viewport shading: Solid

Best Practice Summary

Use case	Best method
< 50 frames	Manual import
100–10,000 frames	Geometry Nodes (Import PLY)
Complex logic	Python

Pro Tip (Real-time playback)

If your sequence is huge:

Convert .ply → .abc (Alembic)
Or .ply → .usd These formats stream much faster in Blender.

If you tell me:

How many frames?
File naming pattern?
Blender version?

I can give you an exact Geometry Nodes setup for your case.

Good question — this is the one non-obvious part of the Geometry Nodes setup.

Here’s the exact wiring.

Using current frame in String Format

You need the Scene Time node.

Steps (Blender 3.5+ / 4.x)

In Geometry Nodes, add:
- Scene Time
- String Format
- Import PLY
On Scene Time:
- Use the Frame output.
On String Format:
- Set Format to match your filenames, e.g.:
```
frame_%04d.ply
```
  (%04d = zero-padded 4-digit number)

Plug:

Scene Time → Frame  → String Format → Value
String Format → String → Import PLY → Path

That’s it. The current timeline frame is now driving the filename.

Common filename patterns

Files look like	String Format
frame_1.ply	`frame_%d.ply`
frame_0001.ply	`frame_%04d.ply`
scan_01234.ply	`scan_%05d.ply`
000123.ply	`%06d.ply`

Important gotcha: frame offset

If your sequence starts at frame_0000.ply
but Blender starts at frame 1:

Add a Math node:

Scene Time → Frame → Math (Subtract 1) → String Format

Debug tip

Add a Viewer node to the String output.
You’ll see the exact filename Blender is trying to load.

This is super useful when nothing shows up.

Typical full node layout

[ Scene Time ]
      |
   Frame
      |
[ Math ]  (optional offset)
      |
[ String Format ]   "frame_%04d.ply"
      |
[ Import PLY ]
      |
[ Group Output ]

Once wired like this, scrubbing the timeline = real point cloud playback. 🎥

This is the slightly confusing part because String Format works like Python’s % operator, not like f-strings.

You do not type the value into the format field.
You plug it in via the socket.

The key concept

The Format field is just the template
The Value input is where the number goes

Example:

Format:

frame_%04d.ply

Value (socket):

← Scene Time → Frame

So Blender internally does:

"frame_%04d.ply" % current_frame

Step-by-step (exact clicks)

Add String Format node.
In the node:
- Set Format to:
```
frame_%04d.ply
```
Drag a wire:
- From Scene Time → Frame
- Into String Format → Value

That’s it. You never type the number.

If you don’t see a “Value” socket

Make sure:

You’re using String Format (not “Join Strings”)
In Geometry Nodes, not Shader Nodes
Blender ≥ 3.4 (older versions don’t have this node)

Multiple values (advanced)

If you had something like:

scan_%02d_%04d.ply

Then you’d plug:

first number → Value 1
second number → Value 2

Debug trick (super useful)

Add a Viewer node to the String output.
You’ll literally see:

frame_0025.ply

for frame 25.

This is the best way to verify it’s working.

Ah — that explains the confusion. You’re probably seeing the single-letter sockets like f, g, etc. on the String Format node. That’s normal, and yes, it’s badly labeled.

Those letters correspond to format specifiers inside your format string.

Why you see `f`, `g`, etc.

In the String Format node:

Each letter socket = one placeholder in the format
The letters come from old C-style formatting:
- %d → integer → shows up as socket d
- %f → float → socket f
- %g → generic number → socket g

So Blender auto-creates sockets based on what you write in Format.

The correct setup for frame numbers

Your filenames:

frame_0001.ply

In String Format:

Format:

frame_%04d.ply

Now the node will show a socket called:

That d is where you plug the frame.

Wire it:

Scene Time → Frame → String Format (d)

Ignore f, g, etc. — you only use the one that matches your format.

What each letter means (practically)

Format code	Socket letter	Use
`%d`	`d`	integer (frames) ✅
`%f`	`f`	float
`%g`	`g`	auto
`%s`	`s`	string

For animation frames you almost always want %d.

Mental model (important)

Blender is literally doing:

"frame_%04d.ply" % d

Where d is that socket.

So:

You define the pattern in text
You feed the number into the letter socket

Minimal working graph

[ Scene Time ]
      |
   Frame
      |
      v
[ String Format ]  Format: frame_%04d.ply
         |
         v
[ Import PLY ]

Plug Frame → d.

That’s the whole trick. Once you get this, the node suddenly makes sense.

This is a real limitation you’ve hit, and you’re understanding it correctly.

Short version first:

Named Attribute does not work on geometry that is loaded dynamically (Import PLY / OBJ / etc).
Those attributes exist, but they are anonymous inside the node tree.

So you must capture the attribute immediately after import.

The core rule (very important)

For dynamically imported geometry:

You can only access attributes by name in the same evaluation branch, right after import, using Capture Attribute.

You cannot:

Use Named Attribute later
Use it in another node tree
Use it after instancing

Correct pattern (the only one that works)

Import PLY
   |
Capture Attribute (Color)
   |
(then do instancing / points / etc)

How to capture PLY color

Most PLY files store color as:

color
or Col
or Cd

You need to inspect which one.

Step 1 — Inspect attribute names

Add a Spreadsheet panel:

Select the Geometry Nodes object
Open Spreadsheet → Geometry Nodes
Look at Point / Vertex attributes

You’ll see something like:

color (float3)

red, green, blue

Case A: single `color` attribute (best case)

Node setup

After Import PLY
Add Capture Attribute
- Domain: Point
- Type: Color
Add Named Attribute
- Name: color
Plug Named Attribute → Capture Attribute (Value)

Now you have a captured color output socket.

Case B: separate R G B attributes

Some PLYs store:

red
green
blue

Then you do:

Three Named Attribute nodes:
- red
- green
- blue
Combine Color
Plug into Capture Attribute

Then: use color for instancing

Example: points → spheres

Import PLY
  |
Capture Attribute (Color)
  |
Points to Spheres
  |
Set Material

In the material:

Use Attribute node with name:

capture_attribute

(or whatever the socket name is)

The golden rule (why yours failed)

This fails:

Import PLY → Instance → Named Attribute

Because:

Instancing breaks attribute access
Dynamic geometry has no global attribute registry

Correct mental model

Dynamic imports are like a private data stream.

You must:

Grab attributes immediately
Store them via Capture Attribute
Then you’re free to instance / realize / modify

Pro-level workflow (robust)

The most stable production pattern:

Import PLY
   |
Capture Attribute (color, normal, id, etc)
   |
Realize Instances (if needed)
   |
Everything else

This makes attributes behave like “real” geometry.

Debug trick (extremely useful)

Insert Store Named Attribute right after import:

Import PLY → Store Named Attribute ("debug_color")

Then open Spreadsheet — now it becomes visible globally.

Why Blender is like this (deep reason)

Imported geometry:

Is evaluated lazily
Has no persistent attribute namespace
Lives only inside that node branch

Named Attribute works only on:

Real mesh datablocks
Or attributes already stored upstream

Summary (the rule you’ll remember)

Dynamic geometry: Capture first, ask questions later.
If you don’t capture right after Import PLY, the attribute is gone forever.