Kanzi 4.0.0 ships with a fundamental rethink of how rendering pipelines are built, configured, and maintained. Prism Graphs are Kanzi's new node-based, visual rendering graph system — a first-class workflow for composing complex render pipelines directly inside Kanzi Studio, without touching a single line of XML render pass configuration.
Whether you are producing polished automotive instrument clusters, high-fidelity HMI experiences, or real-time post-processing effects like bloom and dynamic shadows, Prism Graphs give you an intuitive, visual interface for the full rendering pipeline — making advanced graphics techniques accessible to the entire team, not just your most senior graphics engineers.
A Prism Graph is a directed acyclic graph (DAG) that defines how a scene is rendered — from raw 3D geometry and lighting all the way through post-processing effects and final framebuffer output. Instead of manually configuring nested render pass hierarchies in XML or code, you build the rendering pipeline visually by connecting nodes in a graph editor inside Kanzi Studio.
Each node in the graph represents a discrete step in the rendering process. Data — geometry, light information, render targets, textures — flows through the graph along typed connections, making the rendering pipeline explicit, inspectable, and easy to modify.
A Prism Graph can include any combination of:
Scene Render Nodes — collect and rasterize 3D scene geometry
Composition Nodes — composite multiple render targets together
Post-Processing Nodes — apply full-screen effects (bloom, blur, color grading, tone mapping)
Shadow Map Nodes — generate and apply dynamic shadow maps
Render Target Nodes — off-screen framebuffer targets for multi-pass rendering
Blit Nodes — transfer texture data between render targets
Output Nodes — write final output to the display or a composition target
The Prism Graph Editor is the dedicated panel inside Kanzi Studio where you construct, inspect, and iterate on your rendering pipeline.
Drag connections between node output ports and input ports to define the data flow through your pipeline. Kanzi Studio enforces type-safe connections — a render target output will only connect to a node that expects a render target input, eliminating an entire class of configuration errors.
Click any node in the graph to inspect its properties in the Properties panel. Every parameter — texture format, clear color, depth settings, bloom threshold, shadow bias — is exposed as a live, editable property. Changes take effect immediately in the Preview viewport.
The graph is live. Add a bloom pass, a shadow caster, a post-processing step, or an entirely new render target while your project is running in Preview — the pipeline updates in real time. There is no compile step and no restart required.
One of the most visually impactful features available out of the box is a physically-correct bloom pipeline. With Prism Graphs, assembling a bloom effect becomes a matter of connecting the right nodes:
Render your scene to an HDR render target
Extract bright regions above a configurable luminance threshold
Apply a dual-pass Gaussian blur to the extracted highlights
Composite the blurred highlights back onto the base render with additive blending
The full pipeline is visible in the graph — no hidden magic, no opaque post-process stack. Every parameter is tunable: threshold, intensity, blur radius, and filter quality. The result is the kind of glowing headlight and instrument backlight effect that separates production-quality automotive UIs from everything else.
Prism render graphs support shadow map generation as a first-class pipeline stage. A shadow-casting pipeline in Kanzi 4.0.0 works by:
Rendering the scene from the perspective of each shadow-casting light into a depth render target (the shadow map)
Sampling that shadow map during the main scene render to determine per-fragment shadowing
Applying configurable shadow softening (PCF) for smooth, alias-free shadow edges
Because the shadow map node is part of the graph, you can inspect the shadow map texture directly in the Prism Graph Editor — an enormous help when debugging shadow acne, peter-panning, or projection artifacts. Shadow parameters like bias, PCF kernel size, and cascade count are live properties.
Prism Graphs make multi-pass rendering straightforward. Need to render a rearview mirror as a live texture inset on the cluster display? Create a second Scene Render node with its own camera, direct it to a render target, and wire that render target into your main composition node as an input texture. The entire multi-view pipeline is explicit in the graph — no hidden viewport stacks.
Previously, building a bloom pass or shadow pipeline in Kanzi required deep knowledge of render pass configuration and the underlying OpenGL rendering model. Prism Graphs expose the same power through a visual interface that any team member can navigate, inspect, and modify confidently.
When a rendering artifact appears, the graph is your debug map. Inspect intermediate render targets between any two nodes to isolate exactly where in the pipeline the problem originates. No more bisecting opaque render pass configurations.
Large programs building HMI systems across multiple sub-teams can define a canonical Prism Graph as the approved rendering architecture for a project. Any project that uses that graph gets the same rendering behavior — no divergence, no one-off shadow hacks bolted on at the last minute.
Because the Prism Graph is a project resource, it participates in Kanzi's version control workflow. Try a new post-processing approach, compare it against the reference, and revert cleanly if the result doesn't meet spec — all without touching application logic.
| Feature | Detail |
|---|---|
| Graph Type | Directed acyclic graph (DAG) of render nodes |
| Editor | Dedicated Prism Graph panel in Kanzi Studio |
| Connection Safety | Type-enforced port connections |
| Supported Effect Types | Bloom, blur, shadows (PCF), post-processing, multi-pass, color grading |
| Live Iteration | Parameter edits update Preview in real time |
| Intermediate Inspection | Click any render target node to inspect its framebuffer in the editor |
| Shadow Types | Single-pass, cascaded, with configurable bias and PCF kernel |
| Platform Targets | Windows, Linux, Android, QNX, INTEGRITY |
| Studio Integration | Full GUI, no XML render pass configuration required |
Before Prism Graphs (Kanzi 3.x)
Configuring a bloom render pipeline meant hand-authoring a nested XML render pass hierarchy — a fragile, verbose configuration that was difficult to read, harder to debug, and nearly impossible to hand off between team members. Adding a new pass meant editing raw XML and hoping you didn't break the carefully ordered pass execution.
After Prism Graphs (Kanzi 4.0.0)
The same bloom pipeline is a handful of connected nodes in the Prism Graph Editor. The data flow is visible at a glance, every parameter is a live property, intermediate framebuffers are inspectable by clicking a node, and the whole thing can be iterated on while the application is running in Preview.
Even with a visual editor, rendering pipelines have sharp edges. Here are the most common issues teams run into when adopting Prism Graphs, and how to resolve them quickly.
Likely cause: The Output node is not connected, or the final Composition node has no render target wired into it.
Fix: Trace the graph from the Output node backwards. Ensure every node in the chain has all required input ports connected. Unconnected required ports are highlighted in red in the editor — follow the red ports upstream until you find the break.
Likely cause 1: The object's material does not have shadow receiving enabled. Prism shadow map nodes write to a depth texture, but the receiving material must sample that texture. Verify that the material type used by the affected mesh references the shadow map render target as a uniform input.
Likely cause 2: The shadow-casting light is outside the shadow map's frustum, or the near/far planes are set too conservatively. Inspect the shadow map node's depth texture directly in the editor — if the depth buffer appears empty, the geometry never fell inside the projection.
Fix: Click the Shadow Map node, open its render target, and visually confirm that scene geometry appears in the depth buffer preview. Adjust the light's projection near/far planes and bias values accordingly.
Likely cause: The HDR render target's luminance values are not clamped before the bright-region extraction step, or the bloom intensity multiplier is set too high for the scene's average brightness.
Fix: Lower the luminance threshold on the Bright-Region Extract node first — start at 0.9 and work down. If the overall image still washes out, reduce the additive blend weight on the Composition node. A physically correct bloom should be barely perceptible at neutral exposure; if it is obvious at a glance, the threshold is almost certainly too low.
Likely cause: Two connected nodes expect different texture formats on a shared render target — for example, a shadow map node expecting a depth-only target receiving an RGBA8 target, or a bloom pass expecting a floating-point (HDR) target receiving a fixed-point one.
Fix: Kanzi Studio will flag mismatched port connections with a type error indicator on the connection line. Click the connection to inspect the expected and actual formats on each side. Render targets used for HDR bloom should use RGBA16F or RGBA32F format. Shadow maps require a depth-only format (DEPTH24 or DEPTH32F).
Likely cause: The Prism Graph resource was not included in the project's kzb export, or the deployed binary predates the graph changes.
Fix: Confirm the Prism Graph resource appears in the project's Resource Dictionary and is referenced by the active Viewport 3D node. Perform a clean kzb rebuild (Project > Export KZB) and redeploy. If using Asset Packages to distribute the rendering configuration, ensure the updated graph has been re-packed and re-deployed via KPM.
Full documentation, step-by-step tutorials, and node reference are available in the Kanzi 4.0.0 documentation:
Prism Graphs are available now as part of Kanzi 4.0.0. The Prism Graph Editor is integrated directly into Kanzi Studio and requires no additional installation. Navigate to your project's Viewport 3D node, select Edit Prism Graph, and the editor panel opens inside Kanzi Studio.
