Screen-Space Shortest Path Analysis

• Screen-space shortest path analysis is a GPU-accelerated method that computes exact Euclidean shortest path maps on 2D polygonal domains by propagating cost values directly on a pixel grid.
• It leverages modern OpenGL compute and graphics shaders to perform iterative propagation steps, including shadow-volume generation and cone rasterization, ensuring globally optimal paths.
• Empirical results demonstrate that this approach achieves up to 10–100× speedup over CPU methods, enabling efficient real-time navigation and multi-agent simulation in static environments.

Screen-space shortest path analysis refers to GPU-based methods for computing exact Euclidean shortest path maps (SPMs) over 2D polygonal domains, where obstacles and sources (points or segments) are projected and manipulated in screen coordinates. By leveraging modern OpenGL compute and graphics shader stages, these approaches propagate optimal cost information directly on a pixel grid, yielding region-based SPMs that are both query-efficient and globally optimal. The method efficiently partitions the environment such that each pixel’s region encodes the next-hop parent toward its closest source, enabling immediate path extraction for all agents in settings such as real-time virtual environments or multi-agent navigation. The algorithm presented in "Improved Shortest Path Maps with GPU Shaders" (Farias et al., 2018) exemplifies this paradigm, achieving high throughput, optimality, and suitability for dynamic simulation scenarios.

1. GPU-Based SPM Pipeline Architecture

The core GPU pipeline for screen-space shortest path map computation consists of an initialization phase and a sequence of iterative, parallelizable processing steps:

• Initialization: Key data structures are set up entirely on the GPU. An SSBO (Shader Storage Buffer Object) named “DataArray” is built to store obstacle vertices, source points, and segment entries, each with associated metadata. The polygonal obstacles’ edge list is loaded for geometry-based visibility operations. A 2D RGBA float framebuffer (FB) represents the solution domain, with channels encoding next-hop parent coordinates, the optimal accumulative distance ($\lambda^*$), and a binary reached flag. All setup scales with the sum of obstacle vertices and sources, $n_{total}$.
• Iterative Propagation: For $n_{total}$ steps, the pipeline performs:
  1. Search Compute Shader: Selects the unexpanded generator with minimum distance as $g_{cur}$.
  2. Shadow-Volume Generation: Geometry shaders emit stencil-marked “shadows” using front-facing obstacle edges to mask pixels occluded from $g_{cur}$.
  3. Cone Rasterization: Fragment shaders scan the screen, evaluating for each non-shadowed pixel whether $g_{cur}$ offers a lower path cost via a Euclidean update; parent and distance values are replaced when improved.
  4. Point-Distance Update: A parallel compute shader updates generator distances in DataArray, subject again to visibility.

The process guarantees that, upon completion, the framebuffer encodes exact shortest-path distances and next-hop data for every site, supporting rapid gradient-following navigation (Farias et al., 2018). No significant CPU-side data structures are required, and the method’s core computational burden is distributed across the GPU’s parallel execution resources.

2. Discrete Eikonal-Style Update Rule

At the mathematical core of screen-space SPM propagation lies a discrete analog of the Eikonal equation, instantiated via the following rule: for every receptive site $x$ (either a pixel or a DataArray vertex) and current generator $g$ with coordinates $x_g$ and distance $d(g)$,

$$d(x) \gets \min\bigl(d(x), \, d(g) + \|x - x_g\|_2\bigr)$$

This update propagates wavefronts akin to continuous Dijkstra/Carlier algorithms, subject to a line-of-sight (shadow) constraint. Only non-shadowed sites are considered for potential improvement. The result is global optimality, with distances decreasing monotonically until convergence. The approach can be viewed as a sequence of “height-swept cones” expanding from each generator, subject to obstacle occlusion, with cost values rasterized onto the screen-space grid (Farias et al., 2018).

3. Data Structures and Memory Organization

Efficient on-GPU memory layout is crucial:

• The DataArray SSBO contains all generators (sources and obstacle vertices), with each entry structurally defined as:

  struct DataElt { float x, y; int Status; // 0=SOURCE,1=OBSTACLE,2=EXPANDED,3=SOURCE_SEGMENT float Distance; // λ* value int ParentId; // index to next-hop // For segments: endpoints e1, e2 as needed };

• The framebuffer (FB) at each pixel encodes:

  • R,G: parent point’s $(x, y)$
  • B: current minimal $\lambda^*$
  • A: reached flag (0/1)
• The stencil buffer records shadowed status per pixel in each iteration.
• No major CPU arrays are maintained during inner iterations; data locality and parallel access are maximized for GPU throughput. All obstacle and generator accesses scale with $O(n_{total})$, while pixel operations are distributed over the screen’s $O(r)$ resolution (Farias et al., 2018).

4. Handling Multiple Point and Segment Sources

The system supports heterogeneous sets of sources:

• Points: Each point source is a DataArray entry (Status=SOURCE), initialized with Distance=0.
• Segments: Line-segment sources are pre-split at “critical points”, where visibility events from obstacles occur. Each sub-segment is an entry (Status=SOURCE_SEGMENT) with endpoints $e_1$, $e_2$. For any site $p$, distance to a segment generator is evaluated as:

$$d_{to\_seg}(p) = \min\left\{ \|p-e_1\|,\, \|p-e_2\|,\, \| p - (e_1 + ((p-e_1)\cdot dir)\,dir) \| \right\}$$

This naturally generates a frame partition where each region is the Voronoi cell of its unique closest source (point or segment), and every site’s ParentId chain recovers the corresponding optimal path (Farias et al., 2018).

5. Computational Complexity and Empirical Performance

The method's asymptotic and practical performance characteristics are as follows:

• Per-iteration costs:
  • Search step: $O(n_{total})$ (serial, lightweight—1–2% of runtime even for $n_{total}\sim 2000$).
  • Shadow and cone rasterization: $O(r)$ (fully parallelized across pixels).
  • Vertex update: $O(n_{total})$ (parallel per generator).
• Total cost: $n_{total}$ iterations, yielding $O(n_{total}^2 + n_{total}r)$ worst case.
• Empirical benchmarks: On an NVIDIA GTX 970, at $1000 \times 1000$ pixel resolution, $n_{total}\approx2000$ yields runtimes near 2.8 s. Simpler scenes ($n_{total}\approx 100$): $\approx 0.13$ s per SPM map.
• Efficiency: Compared to conventional CPU visibility-graph methods (worst-case $\Theta(n^2)$) and grid-search approaches, the shader-based SPM offers global optimality and is 10–100× faster. Bandwidth requirements—one 4-channel float texture read/write per pixel per iteration plus DataArray accesses—are well within modern GPU capabilities for real-time execution in moderate domains (Farias et al., 2018).

6. Limitations, Applicability, and Extensions

The method assumes static, polygonal obstacles and is inherently 2D:

• Resolution Limitation: Pixelization introduces at most a half-pixel error in region boundary localization; however, path-length error remains negligible due to use of exact coordinates.
• Obstacle and Source Dynamics: Only static geometry is natively supported. Dynamic scenarios require incremental re-computation or partial updating.
• Dimensionality: The algorithm is naturally formulated in 2D screen-space; true extension to 3D would necessitate a 3D voxel buffer and “cone” shaders, resulting in significant computational overhead.
• Animation and Interactivity: The method is well-suited for animation and multi-agent environments, as each agent can directly query its local parent-link and follow a gradient descent to its target region. Efficient updates can be implemented through dirty-region reprocessing or temporal coherence (push-pull strategies).
• Multi-Source Support: Multiple point and segment goals are handled in a single unified pass.
• Summary: This screen-space SPM framework presents a continuous-Dijkstra solver architecture optimized for the GPU graphics and compute pipeline, offering globally optimal distance and navigation fields for polygonal 2D spaces with static obstacles, enabling practical deployment in real-time and interactive environments (Farias et al., 2018).