The Elastic Graph

The Elastic Graph is the rules-based compiler of the Spatial Experience SDK. It is a highly optimized node-based visual scripting interface used to ingest real-world geographic datasets, evaluate mathematical modifiers, and compile procedural terrains and object coordinates dynamically in real-time as a vehicle moves.

Using the project folder’s context menu (Create > holoride > Elastic Graph), you can instantiate a new graph. You can open and edit graphs inside our dedicated window, adding nodes by pressing the Spacebar or using the Right-click context menu.

Same-colored ports represent matching data types (such as Map float arrays or Pose lists) and can be connected by dragging wires. Small exclamation marks next to input ports depict missing mandatory parameters.

---
config:
  flowchart:
    subGraphTitleMargin:
      bottom: 30
---
flowchart TD
    subgraph Editor_Interface ["1. Visual Graph Compilation"]
        CreateGraph["Create Graph <br> (Context Menu)"]
        SpacebarNode["Spacebar / Right-Click <br> (Add Node)"]
        ConnectPorts("Drag Wires <br> (Match Port Colors)")
        
        CreateGraph --> SpacebarNode
        SpacebarNode --> ConnectPorts
    end

    subgraph Core_Evaluation ["2. Runtime Scene Ingestion"]
        ESG["Elastic Scene Generator <br> (ESG Component)"]
        ESD["Elastic Scene Definition <br> (Core Definition Node)"]
        GIS["GIS OSM Caches <br> (Geographic Ingestion)"]
        
        ConnectPorts -->|Saves Graph Asset| ESD
        ESD -->|Assigns Reference| ESG
        GIS -->|Telemetry Stream| ESG
    end

    subgraph Procedural_Output ["3. Dynamic Cell Compilation"]
        DeformTerrain("Deform Terrain <br> (Compute height & texture maps)")
        PoolObjects("Instantiate Prefabs <br> (Pool objects on Moving Grid)")
        
        ESG -->|Compiles Cells on Threads| DeformTerrain & PoolObjects
    end

    %% Styling (Vibrant, borderless theme)
    style Editor_Interface fill:#e0f2fe,stroke-width:0px
    style CreateGraph fill:#0284c7,stroke-width:0px,color:#fff
    style SpacebarNode fill:#0ea5e9,stroke-width:0px,color:#fff
    style ConnectPorts fill:#06b6d4,stroke-width:0px,color:#fff
    
    style Core_Evaluation fill:#f3e8ff,stroke-width:0px
    style ESG fill:#7c3aed,stroke-width:0px,color:#fff
    style ESD fill:#9c27b0,stroke-width:0px,color:#fff
    style GIS fill:#8b5cf6,stroke-width:0px,color:#fff
    
    style Procedural_Output fill:#dcfce7,stroke-width:0px
    style DeformTerrain fill:#16a34a,stroke-width:0px,color:#fff
    style PoolObjects fill:#15803d,stroke-width:0px,color:#fff

It is important to understand that the environment the Elastic Graph produces is always based on an initial set of geographic data, which is then modified based on functions the user defines in the graph system. There are two major types of source nodes to generate initial data sets, and associated modifier nodes to alter these data sets:

Map Nodes: These operate on 2D grayscale float grids representing continuous spatial features (such as heightmaps, slopes, masks, or road clearances).
Pose Set Nodes: These represent discrete coordinate points containing Position-Rotation tuples, used as target markers for spawning props or scenery.

Other nodes such as Spawners utilize these modified maps and pose sets to define how physical engine game objects are instantiated and pooled at runtime.

Tip

Every node in the Elastic Graph system can be renamed to your liking via a right-click context menu.

Elastic Scene Definition

The Elastic Scene Definition is the core master node of every Elastic Graph. This is where all the data lines end. Ultimately, it compiles all the graph outputs and exposes them to the runtime scene.

Data Aggregation: The node acts as the collection point for your graph's distinct pipelines, exposing specific ports for your main Heightmap, Grass/Texturing weights (Texture Layers), custom Spawners, and dynamic coordinate filters.
ESG Pipeline Bindings: The compiled Elastic Graph asset must be linked directly to your active Elastic Scene Generator (ESG) component in your Unity scene to begin real-time compilation.

Important

An Elastic Graph is completely inert and does not execute unless referenced on an active, enabled Elastic Scene Generator component.

Using the Graph in the Scene

The Elastic Scene Generator (ESG) is the central MonoBehaviour component that executes your graph at playtime. It serves as the bridge between your real-world geographic telemetry stream and the Unity rendering thread:

Continuous Origin Shifting: As the player's physical vehicle drives, the ESG tracks its localization offset, translating, rotating, and shifting the active world cells to stay pinned under the player.
Asynchronous Generation Threads: The ESG processes height maps and deforms Unity terrain tiles on background CPU threads, preventing costly bottlenecks on the main rendering thread to guarantee stutter-free 90Hz+ framerates.

Terrain Sculpting

In order to keep things procedural, the terrain’s appearance can be modeled by using map nodes in contrast to traditional manual terrain painting. Maps can contain any float value and therefore be used to define the heights and texture weights (aka control texture) of a Unity Terrain.

The Spatial Experience SDK utilizes Unity’s default Terrain Layer assets referenced by Texture Layer nodes. The heightmap can also be used to determine the spawn height of objects that should spawn on the terrain surface.

Settings Window

The Graph Settings window can be accessed from the top-left corner of the graph editor. It contains options related to the preview functionality and the processing state of the nodes, which is indicated by flashing when enabled.

The WorldExtents, FilterResolution, and Location are independent from the scene the graph is used in. If an Elastic Scene Generator is using an opened graph, the previews will be replaced by the actual buffers that are used during play mode.

Terrain Sculpting & Map Processing (Sub-Chapters)

To master procedural terrain sculpting and grayscale map math, complete the following child chapters:

Map Nodes – Detailed introduction to generating, scaling, and processing maps.
Distances & Heights – Learn how to compute continuous road clearances and sculpt rolling hills with Perlin Noise.
Masks & Texture Layers – Master procedural multi-texture blending, slope-dependent layers, and the critical Sum-of-1 rule.

Map Nodes ❯