Blender (Geometry Nodes)

⚠️

The Blender add-on was recently released. While it can technically use all features of PRC, the goal is not to have feature-parity with Grasshopper, but to look at a Blender-relevant feature set. Your feedback is appreciated.

PRC.Integrations/Blender Geometry Nodes at main · jbraumann/PRC.Integrations

Various integrations of Parametric Robot Control into other software packages / programming languages - jbraumann/PRC.Integrations

https://github.com/jbraumann/PRC.Integrations/tree/main/Blender%20Geometry%20Nodes

• Blender 5.0.0 or later. Earlier versions (4.3 and below) are not supported — the add-on uses Blender 4.4+ Geometry Nodes APIs and won’t load on older builds.

• Blender 5.2.0+ is required for the Insert Code action node, which depends on string-typed Geometry Nodes attributes that landed in 5.2. On 5.0 / 5.1 every other feature works; the Insert Code entry simply doesn’t appear in the Add menu.

• Platforms: Windows x64, Linux x64, macOS arm64, macOS x64. The bundled gRPC / protobuf wheels target CPython 3.13 (the interpreter shipped with Blender 5.x).

• PRC server running on https://127.0.0.1:5001.

• The prc_blender add-on installed and enabled (Edit → Preferences → Add-ons).

1. Set Client ID (any stable string, default PRC_Blender).

2. Pick a Driver (e.g. KUKA KSS (KRL)). The Robot dropdown auto-filters to that brand.

3. Pick a Robot from the filtered list.

4. (Optional) In the Tool box, set the TCP — Position (mm) and Rotation. The rotation fields adapt to the driver convention (ZYX degrees for KUKA, RPY for NEURA, axis-angle for UR, quaternion for ABB). The Tool ID determines which dictionary slot the TCP lives at.

5. Click Setup Robot.

• Generate Geometry Node Groups — creates all PRC node groups (motion commands, helpers, modifiers, task) and stamps the starter tree on the PRC_Program carrier.

plain text
AXIS Move 1 ──┐
              ├── Join Geometry ── PTP Motion Group ── PRC Task ── Output
AXIS Move 2 ──┘

1. Click Load Task from Geometry Nodes. The status line confirms the task duration. A toolpath tube appears in the viewport (white = OK, red = alarm).

2. Drag the Simulation slider — the robot animates along the toolpath.

plain text
[motion commands or helpers] → Join Geometry → [optional modifiers] → PRC Task → Output

plain text
LIN_1  ──┐
LIN_2  ──┤── Join Geometry ── PRC Cartesian Motion Group ── PRC Task ── Output
LIN_3  ──┘

plain text
PTP MG  ──┐
LIN MG  ──┤── Join Geometry ── PRC Task ── Output
LIN MG  ──┘

Don’t mix motion types inside a single Motion Group. A PRC PTP Motion Group may only contain AXIS and PTP commands; a PRC Cartesian Motion Group may only contain LIN commands. The reader rejects mismatched wiring with a clear error message.

• First as PTP = False → N Cartesian motion groups, all LIN. One group per spline.

• First as PTP = True → For each spline, two motion groups: a PTP Motion Group containing only the first sample, then a Cartesian Motion Group with the remaining samples as LIN. A 3-spline curve emits 6 motion groups (3 PTP + 3 CP) in spline order.

• Use Normal = False → orientation taken from the Orientation object’s rotation.

• Use Normal = True → orientation derived from each vertex’s normal (works on faces). Local +Z aligns to the normal; rotation around the normal is arbitrary — chain PRC Orient to Point after this if you need controlled X.

• PTP = True wraps in a PTP Motion Group, else Cartesian Motion Group.

• Tool ID picks which entry of the robot’s tool dictionary the resulting motion group runs with. Leave at 0 to use the default tool you configured in the panel; set to a non-zero number to reference an additional tool you’ve registered on the server.

• Posture only applies when PTP = True — it’s the joint-configuration code (zero-padded to 3 digits at submit time, e.g. 010) used by the PTP waypoints.

plain text
LIN moves → Join → CP Motion Group ─┐
LIN moves → Join → CP Motion Group ─┼── Join Geometry ── Approach Retract ── PRC Task
LIN moves → Join → CP Motion Group ─┘

plain text
... motion groups ...  ─┐
                        ├── Join ── PRC Task ── Output
PRC Insert Code     ───┤

1. Pick an animated Object (typically an Empty with keyframes).

2. Set Frame Start / End / Step.

3. Choose Mode: All LIN, All PTP, or First PTP, rest LIN.

4. Set Speed (m/s for LIN), Tool ID, and Posture (PTP only).

5. Click Bake Animation — produces PRC_AnimPath_<name>.

1. Pick a Grease Pencil object.

2. Set Layer Index / Frame Index.

3. Optionally set Sample Distance (resample by arc length, 0 = use raw stroke points).

4. Choose Orient: Tangent + World Up or Tangent + Up Object (point the Up Object slot at any object — its +Z becomes the up reference).

5. Choose Mode, set Speed, Tool ID, Posture.

6. Click Bake Grease Pencil — produces PRC_GPPath_<name>.

1. Set Target Name (default PRC_RobotAnim). If a collection of this exact name already exists, its contents are replaced; otherwise nothing in the file is touched.

2. Read the live label: Duration: …s · FPS: … · Frames: …. Override FPS Override if you want a different sampling rate (0 = use scene FPS).

3. Set Frame Start (default 1).

4. Toggle Set Scene Range to expand the scene’s playback range over the bake.

5. Click Bake Robot Animation.

1. Set Floor Radius (multiplier on the robot’s horizontal extent) and Wall Height (multiplier on the robot’s height).

2. Set Key Power (overhead light, watts), Rim Count (lights in the ring), and Rim Power (per-light watts).

3. Click Build Studio Environment — produces a PRC_Studio collection containing the backdrop and a nested PRC_Studio_Lights sub-collection. Re-running rebuilds cleanly.

1. Setup Robot, configure your tool TCP, Setup Robot.

2. Generate Geometry Node Groups.

3. In the scene: a Curve object with three splines tracing the paint passes, plus an Empty whose +Z is the desired tool axis.

4. Open the PRC_Program GN tree and wire:

plain text
Curve (3 splines) ──► PRC Curve Helper ──► PRC Approach Retract ──► PRC Task ──► Output
                       │                       │
       Orientation Empty                  Offset Start = 0.05
       Divisions    = 30                  Offset End   = 0.05
       Speed        = 0.05
       First as PTP = ☑
       Posture      = 10

1. Click Load Task. Drag the simulation slider to verify each pass.

2. Toggle Auto-simulate on Edit; tweak Divisions / Speed interactively until the path looks right.

3. Open the Robot Animation sub-panel, set Target Name = paint_pass_v1, click Bake Robot Animation.

4. Save the .blend. The paint_pass_v1 collection is now a self-contained baked animation — render it, share it, export to glTF/Alembic, all without needing PRC running.