Technical Notes Series

A method for importing and drawing SHP files in Unreal Engine1

David Caballero

Despite the recent efforts to integrate ESRI solutions into Unreal Engine through a dedicated SDK
and a plug-in, there is still a lack of a straightforward method to render the content of SHP files as
three-dimensional points and lines.

Abstract
In recent years, the digital game development engine Unreal Engine (UE), developed by Epic Games, has
garnered significant attention in the fields of science and technology. Various developers of Building
Information Modelling (BIM), Geographic Information System (GIS), or digital twin solutions rely on this
powerful tool. The SHP format, developed by ESRI, has established itself as one of the most widely used
formats for the exchange of geographic information. ESRI recently released its latest version of the Software
Development Kit (SDK) for integrating their solutions into Unreal. However, there is still a lack of an easy and
direct method to load and render the content of SHP files as three-dimensional points and lines, considered as
objects within the virtual environments. This paper presents an approach that partially addresses this
requirement, along with some of its potential applications. To achieve this, an external plug-in is used to read
SHP and DBF files and load them into data structures (Struct) within Unreal. From these structures, and by
applying Procedural Meshes, it is possible to generate objects representing polylines. To improve drawing
performance, it is suggested to convert the result to static geometry and then apply Nanite. This procedure
allows integrating GIS layers as independent objects that can be used in other Blueprints and exported to other
applications. Additionally, it is possible to read and draw point elements such as toponymy and represent them
simply as spheres or include name labels as well.

1
CABALLERO, D. (2024) A method for importing and drawing SHP files in Unreal Engine. Technical Notes Series.
Self-published, January.

1
Introduction conceived to efficiently adopt and utilise geographic coordinate
systems. This limitation restricts their use to relatively small
It's overwhelming to witness the quality and realism of some of portions of the territory where distances in rectangular coordinate
the latest titles in recent digital gaming, such as Alan Wake 2, systems are reasonably similar to their geographic counterparts.
Lords of the Fallen, Bright Memory Infinite, or Halo Reach, to To address this limitation for extensive game domains, the
name a few examples. Lighting, precision in the graphical landscape is divided into sections associated with game levels.
depiction of environments, special effects, character behaviour Players seamlessly navigate these levels thanks to an efficient data
and physics, and acoustic resources have evolved tremendously, loading process. In this sense, Unreal Engine implements an
and nowadays it's easy to be convinced that what is happening on efficient world segmentation system (World Partition) that enables
the screen is real. All of this is largely thanks to the spectacular the creation of maps for large regions and automatically manages
advancements in game development engines, such as Unity, data and level transition based upon distance.
Godot, Amazon Lumberyard, CryEngine, and, above all, Unreal
Engine. Fortunately, Unreal Engine also features a georeferencing plug-in
that allows specifying the coordinates of the origin for each level
Indeed, Unreal Engine2 (UE), developed by Epic Games, has associated with a planetary coordinate reference system (CRS).
emerged in recent years as a promising platform for visualisation Additionally, it easily converts coordinates between different
in the scientific and technical fields, as well as for model CRS. This functionality enables precise localization of any actor
integration, always with a strong graphical component, to a specific geographic position or referencing a Cartesian
particularly amongst architecture studios [1]. In 2020, the coordinate system of a scene to a particular geographical location.
Architectural Visualization Rendering Survey [2] over a total of We will explore this aspect of coordinate systems in more detail
2529 users from CG Architect community who responded to the later on.
questions was indicating quite relevant results: 19.6% used Unreal
as rendering engine in production, positioning UE in fourth place CESIUM4 is a service that provides a digital version of the world
after V-Ray, Corona and Lumion; and 43.3% were testing or and is seamlessly integrated with Unreal Engine. One of the
experimenting with Unreal as production platform. Nowadays, significant advantages of CESIUM is that it delivers its geometry
according also to CG Architect, Unreal has come to dominate the as objects (Assets) in UE scenes, allowing them to be used in
ArchViz3 landscape, even when separated from Twinmotion more complex structures and adding functionality, such as serving
responses, and over its direct competitors Corona, Lumion and as components in Blueprints. As can be understood, CESIUM
V-Ray. However, UE requires a steep learning curve and may not adopts and utilises global geographic coordinate systems, enabling
always have native procedures for accepting external data, which the precise location and positioning of any object on the Earth's
could be a reason why it is not as popular as other simpler globe. Therefore, CESIUM, offered as a plug-in in UE, brilliantly
visualisation solutions, such as Paraview. Although the graphical addresses the joint use of geographic coordinates for the accurate
results may not be as realistic, the representation methods offered georeferencing of objects and game coordinates in a rectangular
by these latter applications are sufficient, and the methods are system by incorporating georeferenced anchor points that serve as
straightforward and universal, largely accepting the most local coordinate origins for game development. Since as many
commonly used exchange formats. local origins as needed can be established, it is an efficient way to
navigate literally through the world while simultaneously placing
One of the most notable advantages of UE is its lighting engine game scene components in the desired geographical position. The
(Lumen), which underlies many of the photorealistic results so altitudes refer to the reference geoid.
useful and interesting in the field of architecture and also
compelling for presenting engineering solutions. Additionally, the And, even more interestingly, recently CESIUM has reached an
use of its Foliage sub-engine is particularly promising, allowing agreement with Google for the free and open publication of its
the coverage of vast areas with complex vegetation structures, three-dimensional geometry (tiles), achieved with great precision
following rules of dissemination and competition through in an unprecedented photogrammetric modelling effort. This
procedural generation methods. As can be understood, these opens up endless possibilities, as the entire world is literally
capabilities are of great utility for territorial planning and digitised in great detail, including cities, buildings, installations,
landscape architecture, provided it is possible to incorporate trees, and other geographical elements, serving as a foundation for
external geographic information. the development of sophisticated immersive experiences in
reality-captured environments.
UE also features Nanite, an in-house technology for highly
efficient rendering of millions of polygons with minimal impact In the same vein, ESRI, aware of the evolution of these platforms
on the frames per second rate. This aspect is particularly relevant and their immediate utility in the fields of engineering and
when aiming to represent hundreds of thousands of trees and architecture, has made a serious commitment to releasing a
shrubs, each spanning tens or hundreds of thousands of polygons Software Development Kit (SDK). This SDK enables, for
in their digital models. Indeed, the coupling of Nanite technology example, the integration of results created in their ArcGIS
with Foliage in the latest version of the engine (5.3 at press time) solutions into Unreal Engine by means of a plug-in, aiming to
has been a significant leap forward. enhance the integration of spatial data and increase the realism
and fidelity of graphical representation in scenarios, especially in
A distinctive feature of digital game development engines is that the pursuit of creating digital twins. The latest update of this SDK
their coordinate system is not initially designed to cover (1.0.4, December 2023) allows for the creation of other interactive
continuous landscapes over large areas; thus, they are not visualisations of geographic data, the use of multiple reference
systems, the performance of spatial analyses, seamless integration
2
of BIM projects, and ultimately the creation of immersive
Unreal Engine https://www.unrealengine.com/ environments for the exploration and analysis of geographic data.
3
The term ArchViz (derived from Architectural Visualization)
refers to a specific domain of Computer Generated Images (CGI)
dedicated to rendering photorealistic images and videos, applied
4
specifically to architecture. CESIUM The Platform for 3D Geospatial https://cesium.com/

2
These undeniable advancements enable the recreation of highly origin at the centre of the planet (ECEF6 scheme) or by
realistic copies of the world with minimal programming effort, placing the origin of the level at an arbitrary point on the
providing a solid foundation for visualising models and planet's surface, expressing the coordinates in a projected
geographic data in the same environment, using UE as an CRS. The Z-axis is assumed to be perpendicular to the surface
integration platform. However, despite the capabilities offered by of the ellipsoid at the selected point. This will be the preferred
the ESRI SDK and plug-in, there is still a lack of some basic system for georeferencing smaller spaces across the entire
routines to load and render the content of universally used SHP surface of the planet, choosing the UTM (Universal
files, such as three-dimensional points and lines as independent Transverse Mercator) projection for the selected Earth region.
assets to work with in Unreal Engine. On the contrary, the ESRI This approach will allow us to describe the position of the
UE plug-in provides only rasterized captures (snapshots) of the objects in the scene in Cartesian coordinates in metres relative
original feature layers, stored as tiles and offered through a tile to the local axis.
data service, which have limited utility in UE scenes. And
overcoming this obstacle is precisely the purpose of this In this case, the reference system used for geographic data in SHP
publication. format is ETRS89, and the selected projection is UTM Zone 31N;
therefore, all three dimensions are expressed in metres. The
To integrate geographical elements such as lines and points into bottom-left corner of the study area in this case has the
three-dimensional scenarios in Unreal Engine has multiple coordinates UTMXo=423030 and UTMYo=4585060. This point
applications: delineating geographic or administrative boundaries will serve as a reference for the precise positioning of all objects
on the digital terrain model, drawing contour levels, representing in the scene. In addition, the minimum altitude in the domain is
three-dimensional curved paths in space, such as aircraft flight Zmin=171.16 metres ASL, and it is the reference for the rest of the
paths, serving as a foundation for the movement of objects altitudes. This approach will greatly facilitate the integration of
(vehicles), and other elements (cameras, lights, etc.), or indicating geographic data with other objects in UE scenarios. For
points of interest or reference, among others. illustrative purposes, the current example refers to a localised area
of the territory, specifically a study area covering 3 km by 3 km, in
In this publication, we explore a straightforward method for the Rectoret area, in the Barcelona municipality.
reading these SHP files, converting them into data structures
within Unreal Engine, utilising Procedural Meshes, and exporting In the technical and scientific geospatial domain, coordinates are
them as objects that can be used like any other element in the often expressed in ‘right-hand’ reference systems, where the +X
scenes, including their nanitization5, material assignment, axis denotes East, the +Y axis denotes North, and the +Z axis
interaction with other objects, etc. The developments presented points upward. Conversely, Unreal Engine employs a ‘left-hand’
have been part of the WUICOM-BCN research project, funded by reference system, where +Y signifies North, and the +X axis
the Barcelona City Council. denotes West and +Z is up. It is essential to consider this
peculiarity when referencing coordinates appropriately, for
example, by changing the sign of the X-coordinate of the input
The Workspace data, as will be seen later.

On the other hand, distances in Unreal Engine are measured in

Coordinate Systems and Spatial Scope centimetres. This requires applying a scaling transformation
(multiplying by 100) to the input geographic data (here expressed
As argued before, game development engines, such as Unreal
in metres) to convert the dimensions to centimetres and achieve
Engine, are not initially designed to handle geographic coordinates
1:1 scale models in the scene.
over large areas. However, UE features a georeferencing plug-in
that enables specifying the origin coordinates used in a level with
If, on the other hand, the coordinates from the original files
respect to a planetary Coordinate Reference System (CRS),
(expressed in metres as argued before) are interpreted as
allowing the placement of objects and the scene within a level at
centimetres, a 1:100 scale is being applied. This is convenient for
an exact geographical position.
the type of virtual reality experiences targeted, namely, a room
where the user sees a 1:100 scale model of the area of interest, as
There are two approaches for defining the position of actors in
is the case at hand.
scenes:

● Considering a flat planet, where the environment in which the

scene unfolds is sufficiently small (distances less than a
The Digital Terrain Model (DTM)
hundred kilometres) to assimilate it to a flat surface.
Although it is not the central theme of this publication, it is
Therefore, the coordinates of objects are Cartesian coordinates
necessary to mention the Digital Terrain Model (DTM), the object
referred to the origin. This is the usual solution in most games.
that will represent the topography and upon which the SHP layers
● Considering a round planet, especially for environments that
will sit, all within the same Unreal Engine scene. A terrain model
unfold over large expanses (several hundred or thousand
is an idealisation of the landscape, built from a mesh of points,
kilometres). It is necessary to take into account the curvature
each with an elevation above sea level. In Unreal Engine, there are
of the planet (the vertical must follow the axis connecting to
at least two ways to load this data and represent it in the scene:
the centre of the Earth). For these cases, it is assumed that the
geometry of the scene is situated on a spherical or ellipsoidal
planet, and a geographic CRS is used, either by placing the
6
Acronym for the term ‘Earth-Centred-Earth-Fixed’. It is a
coordinate reference system in which the X-coordinate is in the
Earth's equatorial plane with reference to the Greenwich prime
5
We use the term ‘nanitization’ here to refer to the process of meridian. The Z-axis points to the North Pole. The Y-axis is in the
incorporating a Static Mesh into the Nanite visualisation equatorial plane at 90° from the X-axis. This orientation forms a
optimization routines in Unreal Engine. right-handed X-Y-Z coordinate system.

3
● By using a raster heightmap, stored as a 16-bit grayscale Planet Earth, we must georeference the point using the existing
image. This image is loaded as a texture in Unreal Engine and plug-in for that purpose.
applied to a Landscape object.
● By using a 3D object as a mesh of triangular facets, where the For the DTM, the same reference system (ETRS89) and projection
vertices correspond to X, Y, Z points in space. This option will (UTM 31N) will be used as in the case of the geometry of SHP
be preferred in the current case study, as it allows it to be used files. This way, the resulting geometry will fit accurately onto the
as a Static Mesh in the scene, thus having the possibility of DTM. Additionally, this strategy of local coordinates avoids using
applying Nanite. This aspect is especially interesting for large large numbers, typical of UTM projection, for example, as
and high-resolution DTM resulting in hundreds of thousands positions are expressed in metres relative to the local origin. It is
of facets. necessary to remember that platforms like Unreal do not handle
double-precision floating-point numbers very efficiently,
In geographic information systems (GIS) like ArcMap, DTM is especially in this case. Therefore, using geographic coordinates
stored as raster maps, i.e., arrays of square cells where the centre with large numbers would result in a loss of final precision.
refers to the reference height. In order to more accurately depict
the placement of lines and points resulting from the import of SHP
maps into the Unreal Engine scene, it is suggested to calculate, Preparation of SHP Layers
through linear interpolation, the values of the heights of the
vertices of this lattice, based on the central values of the cells. The The present case study aims to exemplify the methodology for
following rule is suggested for this: generating and drawing polylines from a SHP file in an Unreal
Engine scenario. As an illustrative example, the road layer of the
● For the interior vertices of the mesh, each vertex will have a study area has been chosen, including highways, roads, streets,
height that is the average of the centres of the four paths, and trails. Railway tracks have been excluded for this
surrounding cells. specific case.
● For the vertices on the edges of the study area, each vertex
will be the average of the heights of the two surrounding cells. For this purpose, the SHP files were obtained from the download
● For the corner vertices, the height will be equal to the height service of the Cartographic and Geological Institute of Catalonia
of the corresponding corner cell. (ICGC). The reference system is ETR89, and the projection is
UTM 31N. This is the main reason why this reference system and
In this case study, a simple routine has been programmed to projection have been chosen for the entire case study.
convert an ArcMap GRD-format DTM into a three-dimensional
object in OBJ format. The triangular facets of the object are based The SHP road file is associated with a corresponding DBF table
on the vertices of the interpolated mesh, as explained earlier, but that includes the following fields:
with the X-coordinate sign changed to adapt it to the coordinate
system of Unreal Engine. In the generation of this DTM, a skirt Index Field Description
and a bottom are optionally added, based on the minimum 0 FID Identification field
Z-coordinate (Zmin) found in the data file, in order to improve the 1 Shape Type of geometric element (in this case,
final appearance of the object. Since the base bottom will be the Polyline ZM)
reference altitude (i.e., Z-coordinate = 0), all Z-coordinates of the 2 CAS Cases denoting the typology of the road. It
input data must consider these two quantities, i.e.: is a 5-character code, and the complete list
is detailed in Annex 1
Z’ = Z – Zmin + skirt
As can be seen in the annex, there is a wide range of
For this particular example, a skirt of 10 m is considered.
transportation network typologies, also detailing whether if each
section is paved, if it is a link or access road, or if it is covered.
For this case study, and to simplify, a duplicate of this SHP layer
has been created using a much simpler DBF table, with an integer
field (TIPO), and with the following simplified values:

TIPO Description Grouped typologies

1 Road, street VIA01, VIA02 and VIA03, avoiding
margins
2 Highway VIA06, VIA07, VIA08, VIA09,
VIA10 and VIA11, avoiding margins
3 Track, dirt VIA16, VIA17 and VIA18, avoiding
road margins
4 Trail VIA21, VIA22 and VIA23, avoiding
margins

The result has been saved with the file names viasim.SHP and
viasim.DBF, and these will be used in the demonstration of the
Note that the lower-left corner of the study domain in the UE methodology.
scene will be the origin of the local coordinate system, to which
we will refer to the position of the points and lines resulting from It is important to ensure that the geometry of the lines is
the import of SHP files. For convenience, it will coincide with the three-dimensional, meaning that it includes the Z-coordinate for
origin of the flat world (World Origin), that is, 0,0,0. If, on the altitude, in this case expressed in metres above sea level. In this
other hand, it is desired to locate that origin in its exact position on case study, the source SHP files downloaded from the ICGC are of

4
type Polyline ZM, meaning they contain the Z-coordinate and an The ReadObject node will be responsible for reading the sections
additional M value (for ‘measure’) that is not used in this case. that make up the geometry in the SHP file, each with its index,
Using the same data source (in this case, ICGC) for both vector starting at 0. Shapefile Object type variables will be used as
SHP layers and the DTM generally ensures that the resulting references to these sections and will also be employed in node
geometry will be correctly aligned with the terrain. Additionally, programming within the Blueprints. Indeed, using a Shapefile
in some specific cases, such as tunnels and underground passages, Object type variable, it is possible to retrieve (via a Get node):
the alignment of the lines will follow their exact three-dimensional
path, even if it is below ground level (this aspect can be observed ● Shapefile Type: the type of geometry
in this specific case for the section of the Vallvidrera Tunnel in the ● Max Bound: maximum coordinates of the segment's bounding
study area). box
● Min Bound: minimum coordinates of the segment's bounding
The same considerations apply to other layers of information, such box
as cadastral parcels or contour lines. If these layers do not have the ● Shape Id: the internal identifier of the segment, as it appears in
Z-coordinate incorporated, it is possible to project their geometry its table
onto the DTM and then save them as a three-dimensional Polyline ● Vertices (array): the array of vertices of the segment
ZM type SHP file. In the ESRI ArcMap application, there is a tool ● Parts (array): the array of parts of the segment, which, in this
for this purpose called Interpolate Shape. case, is not used
● A Close Object node, to close the object when we finish
It is important to remember that the main goal pursued in this reading it
methodology is the drawing of lines corresponding to the
geometry of SHP layers, using them as a visual reference. Similarly, this plug-in includes an Open DBF node that allows
However, as will be seen, the scope can be more ambitious since, opening the DBF file associated with the SHP geometry. It is
in addition to a graphical representation, independent objects (line managed through variables of the DBF Handler type, which will
segments) are obtained, each with its associated information. This serve as references to the opened file and enable access to the
greatly expands the possibilities of their use in simulation models contained information. To achieve this, the following associated
and information systems in Unreal Engine. nodes can be utilised:

● Get Field Info: to extract information about the name, width,

The Shapefile Reader plug-in and decimals of the fields
● Read Double Attribute: for reading numeric fields
Shapefile Reader7 is a C++ plug-in developed by Isara Tech ● Read String Attribute: for reading alphanumeric (String) fields
(https://isaratech.com/), experts in software development with a
● A Close Handler node to close the file
strong background in CGI and simulation. Among their
accomplishments, they have created other plug-ins for Unreal
Unfortunately, this plug-in does not include nodes for drawing
Engine, such as Procedural Landscape Generator, Noise Library,
lines and points in three dimensions, an aspect suggested for
or Android Sensors API.
development in future versions. In the meantime, we will address
this using the methodology explained below.
The Shapefile Reader plug-in enables the reading of SHP, SHX,
and DBF files in Unreal Engine for subsequent use in Blueprints
or C++ code. The plug-in introduces a set of nodes designed for
use in functions within Blueprints. The primary node is Open Polyline Reading and Drawing
Shapefile, allowing access to data from an SHP file through a
handler for use in other functions. Shapefile Reader is compatible Method overview
with Unreal Engine versions 4.18 to 5.1.
The proposed method for utilising SHP files is aimed at creating
The local variables of the Shapefile Handler type will serve as independent objects in UE for each segment present in each SHP
references to the open SHP file and its content, and they will be file, allowing them to be used directly in the scene or as
used in Blueprint programming. Naturally, this type of variable components of Blueprints. This SHP file has another associated
will be available in UE only when the plug-in is loaded. Through a DBF file that stores attributes corresponding to each element of
Shapefile Handler variable, it is possible to obtain (via a Get the geometry. The SHP and DBF files are read only once when the
node): game starts and are stored in memory in arrays of structure type
(Struct). Therefore, each map has two associated arrays: one for
● Entities Count: the total number of entities (segments), useful geometry and another for attributes.
for the For Loop nodes
● Max Bound: maximum coordinates of the bounding box The proposed overall procedure is as follows:
● Min Bound: minimum coordinates of the bounding box, useful
for referring to the local origin ● An array of structure (Array Struct) named TR_Geom is
● Shape Type: the type of geometry included in the SHP file, created to store the geometry information of all segments.
such as 2D POINT, 2D ARC, 2D POLYGON: 3D POINT, 3D Each segment stores an index, the number of vertices, and an
POLYGON, etc. array of vertices, as read from the SHP file.
● A Read Object node ● An array of structure named TR_Atrib is created to store
● A Close Handler node alphanumeric attribute information read from the DBF file. To
achieve this, the number and type of attributes must be known.
The index used will match the index of the geometry for each
segment. This is the way in which the geometry of a segment
7
is associated with the corresponding alphanumeric
Shapefile Reader is available in the Epic Games Marketplace: information.
https://www.unrealengine.com/marketplace/shapefile-reader

5
● A game mode called GM_ModoJuego is created, where the Field Type Description
newly created arrays of structure are loaded and stored as TR_i Int Segment index, starting at 0
variables. These variables are then exposed as public variables TR_NV Int Number of vertices in each segment
to be accessible by functions and Blueprints. ert
● In the project properties, the created game mode, TR_Ver Array Array of X Y Z coordinates and M
GM_ModoJuego, is specified as the default game mode. t Vector4 measure
● In this game mode, functionality is added to read the
corresponding SHP and DBF files for each SHP map, storing As seen, each segment has a unique identifier that will also be
them in the geometry and attribute arrays. This functionality is used to link it to the alphanumeric information specified in the
incorporated into the Construction Script of the game mode. attributes. These attributes will vary depending on the structure
● This way, first, a function for reading SHP files (LeeSHP) is defined at the source, so it will be necessary to know it in advance.
created in the Blueprint of the game mode, so that it reads an For illustrative purposes, in this case, it will be considered that the
SHP file, whose path is specified, into a Struct geometry array. attribute file has only two fields, one corresponding to the type of
● Similarly, a second function for reading DBF files (LeeDBF) section and another including a descriptor. Therefore, for this
is created in the Blueprint of the game mode specific case, the following attribute structure named TR_Atrib
(GM_ModoJuego) to store attribute information in a Struct will be created:
array of attributes.
● Subsequently, the geometry and attribute arrays are used in Field Type No. Description
different Blueprints to draw each of the objects (segments),
TR_i Integer - Segment index, starting at 0
with a specific colour, and, if desired, incorporate labels (with
TR_Tipo Integer [0] General road type
panels) for the attributes. This working method dissociates the
reading of the SHP file from the use of information and also TR_Descriptor String [1] Segment descriptor (i.e.
allows working with the objects (segments) independently. name)
● Each Blueprint will have an associated Procedural Mesh
component for each loaded SHP layer (e.g., roads, plots, Public Variables
buildings, etc.), where the lines are stored as a 3D procedural
mesh for each vector layer. This allows working with multiple In order for the information about the geometry and attributes of
layers independently. In other words, the vector layers stored the loaded SHP file in Unreal, as well as the minimum reference
as Procedural Mesh components are generated and drawn in coordinates, to be usable in both reading functions and functions
the Blueprints. included in the Blueprint for generating and drawing lines, it is
● Additionally, each segment of the vector layer will be stored necessary for the variables housing this information to be public.
in these procedural meshes as sections, meaning each segment To achieve this, these variables will be described in the game
can be treated as an independent object (you only need to mode (GM_ModoJuego), as detailed in the following table:
specify the index of the corresponding section in the
procedural mesh of the desired layer. This index will match Variable Type Description
the segment index). AtribViarios TR_Atrib Where the attributes are
● Finally, the generated procedural geometries will be exported [Array] stored
as static meshes, already incorporating colours (materials) GeomViarios TR_Geom Where the geometry is
assigned based upon attribute values. These generated assets [Array] stored
can subsequently be nanitized, thus significantly improving MinCoordNomin Vector Minimum coordinates of
drawing performance, as they are typically composed of reference
thousands of polygons. Additionally, being static mesh assets, PathAtribViarios String Relative path of the DBF
they can be duplicated, transformed, copied, migrated, etc., file
following the usual procedures for these components in the PathGeomViarios String Relative path of the SHP
UE editor. file

This approach provides a lot of flexibility, as it allows displaying,

hiding, selecting, or changing the colour of each segment of a Functions for Reading Geometry and Attribute Files
layer or entire layers and working with multiple layers
simultaneously. Let's examine each of the steps in more detail. Within the Construction Script of the game mode
(GM_ModoJuego), the functions for reading both geometry and
attributes will be defined. Both functions are triggered only once
Data Structures and Public Variables upon loading the game from the Construction Script node; this
way, the data is loaded efficiently only once. For illustrative
Data structures purposes, in this case, a roads, streets, and paths SHP file will be
read and utilised, but the process could be repeated as many times
The first step in the procedure inside Unreal is to create two data as there are layers of information, always associating the
structures (Struct): one for geometry (TR_Geom) and another for corresponding variables.
attributes (TR_Atrib), which will be responsible for storing all the
information from the SHP files in UE. Regarding geometry, since Geometry (SHP) Reading Function
the information of the polylines will be stored per segment, the
following fields are specified: The goal of this function is to load the data of each segment
(index, number of vertices, array of vertices) into the geometry
structure (TR_Geom). It is important to remember that the first
segment has an index of 0. To achieve this, we first create a
Geometry Reading Function for the SHP file, which we call
LeeSHP. Then, we describe the inputs and outputs of the function:

6
 A loop is added with a For Loop node. The first index will be 0,
Inputs: and the last index will be NTramos-1. Therefore, this loop will
● FilePath (String): Full path of the SHP file iterate over all segments in the SHP file. The SHP file also stores
Outputs: existing parts in each segment, but to simplify the process, this
● GeomArray (Array TR_Geom): Loaded geometry information will be ignored and all vertices of the segment will be
● NumTramos (Integer): Number of segments in the file read directly. This also streamlines the data structure and its
reading. For this purpose, the loop index (Index pin) is first stored
Within the function, the local variables that LeeSHP will use are as a variable called iTramo, as it will be used later as the segment
created: index. From the Index pin of the previous node, a Read Object
node is also connected, with SHPHandler as the Target. This node
Variable Type Description is crucial because it extracts the geometry information.
Geometria Array Local Struct array that stores the
TR_Geom geometry To make it more convenient, the output of this Read Object node
iTramo Integer Index of the current segment, is saved in a variable called SHPObject of type Shapefile Object,
starting at 0 which is where the information for each segment is extracted. A
NTramos Integer Number of segments in the SHP Get Vertices node is added, with its target being precisely the
file SHPObject just created. This extracts the array of all vertices of
NVert Integer Number of vertices in the current the segment, which will be of type Vector 4 (remember that these
segment are the X, Y, Z coordinates, and the M measure, which is not used
in this case). Next, the number of vertices in the current segment
SHPHandler Shapefile Reference to the SHP file
is obtained with a Length node and stored in a variable called
Handler
NVert of integer type. Then, a new element is created in the
SHPObject Shapefile Reference to the SHP object
geometry structure array with a Make TR_Geom node, with the
Object (segment)
following considerations:
An OpenShapefile node is added, included in the Shapefile Reader ● The TR_i input pin will be the value of iTramo.
plug-in. The FilePath function input is connected to the Path pin ● The TR_NVert input pin will be the value of NVert.
of the OpenShapefile node. It is essential to ensure that the file ● The TR_Vert array pin will be the array of vertices obtained
exists. For this purpose, a Branch node is added with the condition (Vertices).
being the Return Value pin of the OpenShapefile node. If it is
TRUE, the SHP file handler is set to the SHPHandler variable,
which has been created and will be used throughout the Blueprint.
Here, all the information from the SHP file will be reflected.

Now, an Add Item to Array node is added, with the target being
precisely the geometry array created as a variable (Geometria).
Finally, the segment (object) is closed with a Close Object node to
It is crucial to ensure that there is at least one segment in the SHP set all values to zero for the next iteration of the loop.
file. To achieve this, we obtain the number of segments (Get
Entities Count) from the SHP Handler (acting as the Target). A
greater-than (>) node is connected here with the value 0. A Branch
node is connected with the above condition, using only the TRUE
pin in the subsequent steps. The variable NTramos is set based on
the Entities Count node. This returns the count of segments in the
SHP file.

The next step is to clear the temporary array Geometria that will
store information about the geometry, using a Clear node. This
ensures that the array is empty and has no elements before starting
to load.

Once all interactions in the loop are finished, a Close Handler

node is added with SHPHandler as its target, connected to the
Completed pin of the main loop. This closes the file and sets the
transient variables to zero. Next, the Return Node is connected,
with the values of the GeomArray pin precisely being the values
from the loaded array (Geometria), and where NumTramos is the

7
integer NTramos. These are the values returned by the function. segment (iTramo) is first set, which will be used to read the
Using a local geometry array allows the function to be used corresponding record for each segment. Then, the two fields that,
multiple times to load different layers of information. in this case, make up each record are read: a numeric field
corresponding to the segment class (Tipo) and a text field that
Attributes (DBF) Reading Function includes its name (Descriptor). To do this, we first request the
information contained in the DBF file with a Get Field Info node,
The goal now is to read the attribute file in DBF format and which will return the name of each field for the current index.
transfer it to an attribute structure that can be used by Blueprints First, the field's content is interpreted as a numeric attribute with a
in UE. The problem is that there is no predefined structure, as the Read Double Attribute node, which is then converted to an integer
number and type of attributes change with each file. Therefore, it with a Truncate node. This value is stored in the Tipo local
is necessary to describe it for each specific case (attribute data variable, which corresponds to the current segment. Next, a
structure in the SHP file), which requires prior knowledge. This similar process is followed to read the second field, the name of
aspect is a notable point for improvement in future developments. the current segment. A Read String Attribute node is used for this,
and the result is stored in the Descriptor local variable.
As explained earlier, in this case, a DBF file with only two
attributes is considered, the type (integer) and the descriptor
(string). These two attributes are sufficient to demonstrate the
reading and drawing methodology that is the subject of this
publication, but additional attributes can be included in the DBF
file reading process, read into data structures, and used later.

Once again, to read the data in the DBF file, we work in the Game
Mode (GM_ModoJuego), where a DBF file reading function is
created (LeeDBF).

This function (LeeDBF) begins by checking that there is at least

one segment in the geometry loaded from the SHP file. For this,
the NumTramos variable, obtained in the geometry reading
function, is invoked, and a Branch node is inserted to which the
result of the conditional >0 is connected. From here, only the
TRUE branch is used, triggering an OpenDBF node corresponding
to the file located at the specified DBFFilePath.

With these two variables for each segment, Tipo and Descriptor, a
new data structure entry of attributes (TR_Atrib) is created,
It is necessary also to ensure that the DBF file exists. For this, a making sure that the record index matches the segment index;
new Branch node is added with the condition based on the Return hence the iTramo variable has been created, which will be used in
Value output pin of the OpenDBF node. If it is TRUE, the handler the Make TR_Atrib node, including class and name. Other fields
of the DBF file is set to the DBFHandler variable that has been can also be included, such as direction or vehicle type, following
created and will be used throughout the Blueprint. Here, all the the same procedure. As seen, for the sake of simplicity in this
information contained in the DBF file will be reflected. example, only the Tipo and Descriptor fields have been
considered.
The next step is to clear the temporary array (Atributos) that will
store the information read from the DBF file, using a Clear node.
This ensures consistency between the number of geometry and
attribute records.

The main iteration loop is a For Loop node that will iterate
through all the segments. Since the index starts at 0, the loop will Finally, an Add node adds the created record to the local array of
end at NumTramos-1. In this main loop, the index of the active data structure Atributos. When the loop iteration is complete, the

8
DBF file handler is closed, and the resulting array of attribute data E:\01_Mis_Asuntos\UE5\Proyectos\WUICOM_VR_2\Cartografia
structure (Atributos) is returned through the Atrib Array pin. \Rectoret3x3\Viarios\viasim.shp
E:\01_Mis_Asuntos\UE5\Proyectos\WUICOM_VR_2\Cartografia
\Rectoret3x3\Viarios\viasim.dbf

o For runtime (where the compiled .exe file is located):

D:\temp\WUICOM_VR_2\Windows\Cartografia\Rectoret3x3\Via
rios\viasim.shp
D:\temp\WUICOM_VR_2\Windows\Cartografia\Rectoret3x3\Via
rios\viasim.dbf

Moreover, the LaunchDir node is used to obtain the launch path of

the program, both during editing and execution time. For instance,
LaunchDir returns:

o During editing time (where the .uproject file is located):

Implementation of Reading Functions E:\01_Mis_Asuntos\UE5\Proyectos\WUICOM_VR_2\
As mentioned, the implementation of the functions to read the
o During runtime (where the compiled .exe file is located):
geometry from the SHP file and the attributes from the DBF file is
done in the Construction Script of the game mode
D:\temp\WUICOM_VR_2\Windows\
(GM_ModoJuego). This ensures that the files are read only once,
at the start of the game. Before beginning the reading process, it is
Later, an Append node (from the String group) is inserted to
necessary to assign the default value to the variable
append the relative path of the SHP file to the launch path, thus
PathGeomViarios, which is the path where the SHP file is located,
obtaining the absolute path. After that, the LeeSHP function is
but relative to the program's launch point, for example:
triggered from the Construction Script node, connecting the result
of the Append to the File Path pin. Finally, the outputs are
Cartografia\Rectoret3x3\Viarios\viasim.shp
connected to the variables that will store them (Set node), namely
GeomViarios and MinCoordViarios. As already mentioned these
Similarly, the default value of the variable PathAtribViarios is
variables are public and can be used by other Blueprints.
assigned, which is the path where the DBF file is located, relative
to the program's launch point, for example:

Cartografia\Rectoret3x3\Viarios\viasim.dbf

This approach requires us to:

● Launch the project execution for editing it from the .uproject

file in the corresponding project directory, not from the Epic
Games Hub, for example:

E:\01_Mis_Asuntos\UE5\Proyectos\WUICOM_VR_2\WUICOM
_VR_2.uproject The same process is applied to the DBF attribute file, that is: an
Append node is inserted to obtain the absolute path of the DBF
● Save the SHP and DBF files in a subdirectory below the file; the LeeDBF function is triggered, connecting the result of the
program's launch point: append to the FilePath pin; and finally, the output is connected to
the AtribViarios variable, which will be public and can be used by
o For editing time, it will be in a directory below the other Blueprints.
project's launch directory .uproject, for example:

E:\01_Mis_Asuntos\UE5\Proyectos\WUICOM_VR_2\

o For runtime, it will be in a directory below the application

.exe launch directory, for example:

D:\temp\WUICOM_VR_2\Windows\

● Therefore, a copy of the subdirectory containing all the

geometric (SHP) and attribute (DBF) data must be made
This implementation approach can be repeated in a sequence of
below the project launch directory, and another copy in the
triggers (Sequence node) to load other SHP layers (parcels,
application launch directory. This ensures that both during
buildings, etc.) in the same way. The information would then be
editing and runtime, the program always finds the files below
stored in similar variables, one per layer.
its directory. For example:
o For editing (where the .uproject file is located):

9
Drawing SHP Geometries
Thus, in the construction graph, a Make Array node of vector type
Unreal Engine lacks native functionality to draw lines and points is first added to define the coordinates of each vertex of the
in three dimensions in scenes. This limitation needs to be triangle. The destination will be the array of vectors, Vertices.
addressed by employing a workaround that generates a set of flat Then, similarly, a Make Array node of integer type is added to
facets between every two points in a sequence of vertices along a define the order of the vertices of the triangle (following the
curved line with a sufficiently small width to visually represent a right-hand rule). Consequently, the destination will be the array of
linear element. To implement this strategy, the generation of integers, Triangulos.
procedural geometries (Procedural Meshes) is highly useful, for
which UE has specific functionality.

Procedural Meshes. Basic Triangle Generation

Procedural geometry (Procedural Meshes) is a highly flexible way

to generate complex 3D models, composed of triangular facets, at
runtime in Unreal Engine.

The basic procedure, therefore, is the generation of triangular

facets based on the description of their three vertices. In particular,
this basic method, explained below, will serve as the foundation
Now, a Create Mesh Section node is used, which will be
for drawing segments between two consecutive points and, from
responsible for generating procedural geometry using the arrays of
there, through concatenation, for more complex three-dimensional
vertices and triangles. In this node:
lines.
● Target: It is the procedural object being created.
To generate triangular facets, the first step is to create a Blueprint
● Vertices: It is the array of vectors with X, Y, Z positions that
that includes a Procedural Mesh Component, which we'll call
define the vertices. Remember that indices start at 0, so the
MiTriangulo in this case. This component will receive the result
first vertex will have an index of 0.
(generated geometry) of the Create Mesh Section node, as will be
● Triangles: It is an array of indices indicating which vertices
seen later on.
constitute each triangle. The array has columns V1, V2, and
V3, which are the vertices of each triangle, and rows represent
Next, also within the Blueprint, an array variable of vector type is
the number of triangles. Remember again that indices start at
created, which we will call Vertices, and it will store the X, Y, Z
0. It is essential to be very careful with the order of vertices,
positions of the vertices. The index of each vertex (IndV) is
following the right-hand rule, to ensure that the normals point
significant, as it will be used later to construct the triangles. An
outward.
example of a vector array that stores the vertices of the triangles
● Normals: This is an optional array of vectors for each vertex.
would look like this:
If specified, it must be the same size as the vertices array.
● UV0: It is an optional array of texture coordinates for each
IndV X Y Z
vertex. If specified, it must be the same size as the vertices
[0] 0 0 0 array.
[1] 10 0 0 ● Vertex Colors: This is an optional array of colours for each
[2] 10 10 10 vertex.
[3] 0 10 0 ● Tangents: This is an optional array of tangent vectors for each
: : : : vertex.
● Create Collision: It is a Boolean input indicating whether the
Then, an array variable of integer type is created, which we will section will have an associated collision or not. It is important
call Triangulos. This is where the V1, V2, and V3 vertices of each to emphasise that if this option is activated, it can significantly
triangle will be stored sequentially. That is, in this array, indices increase computational cost.
[0], [1], and [2] correspond to the 3 vertices of the first triangle; ●
indices [3], [4], and [5] to the 3 vertices of the second triangle, and
so on. As can be seen, the minimum length of this array would be
3 (the three vertices of at least one triangle). An array of triangles
would look like this:

IndT IndV Description

[0] 0 V1 of triangle 1
[1] 2 V2 of triangle 1
[2] 1 V3 of triangle 1
[3] 0 V1 of triangle 2
[4] 3 V2 of triangle 2
[5] 2 V3 of triangle 2
: : :

In the Blueprint Construction Script, the procedural geometry

generation function is included. This function incorporates both Subsequently, a reference to the array of vertices (Vertices) is
the information of the vertices and triangles (in the form of arrays) obtained and connected to the Vertices pin of the Create Mesh
and the main procedural geometry generation node. Section node. Similarly, a reference to the array of triangles

10
(Triangulos) is obtained and connected to the Triangles pin of the scene as a set of triangular facets. This function will be detailed
Create Mesh Section node. If the right-hand rule has been below.
followed, meaning vertices are ordered counter clockwise, the
normals will point outward.
Materials
Once the Blueprint is placed in the scene, the generated triangle
will show up. Each generated line type can be associated with a colour. To
achieve this, we will define as many materials as colours to be
To generate a plane with two triangles, the process follows a used. In order to enhance efficiency, we will outline a base
similar approach by introducing an additional vertex (in this material incorporating all the parameters describing them, with the
instance, vertex [3] 0,10,0) and forming another triangle, detailing colour parameter designed as a variable for its application in
the vertex sequence within the triangles array. The importance of creating material instances. Subsequently, numerous material
adhering to the right-hand rule is underscored once more, ensuring instances will be generated from this foundational material,
the accurate derivation of normals. according to the desired colours. Hence, if there is a need to alter
the remaining characteristics common to all of them, only the base
As demonstrated, this basic procedure provides a broad range of material will require modification.
possibilities. For example, an external file of vertices can be read
into an array and subsequently converted into a 3D object in It is recommended to use the following colour combination
Unreal Engine using procedural geometry. This approach is specifically for the road layer:
especially useful for rendering lines as a sequence of segments
between two points, each delineated by two planes intersecting at Type Colour Material Category
90 degrees. 0 White M_Unlit_White Default material
1 Red M_Unlit_Red Roads and streets
2 Magenta M_Unlit_Pink Highways
Blueprint for Generation and Drawing: Components and 3 Orange M_Unlit_Orange Tracks and dirty
Variables roads
4 Yellow M_Unlit_Yellow Paths, trails
The way to implement procedural geometry generation is by
preparing a Blueprint that hosts the drawing functions, as well as It is also suggested to avoid any kind of shading in the material
the necessary variables and components to carry it out. used to represent three-dimensional lines to enhance their
representation on the digital terrain model. Therefore, it is
Firstly, the Blueprint that will generate the GIS layers recommended to use an Unlit shading model. This will also
(BP_GeneraCapas) will have a Procedural Mesh component improve drawing efficiency as it avoids the usual ray tracing
called PM_Viarios. This component will receive all the segments methods for calculating reflections, shadows, etc. It is the simplest
created with procedural geometry for the road layer and store and most efficient material that can be used. The colour, naturally,
them in order. You could add as many procedural components as will be connected to the emissive colour pin of this shading
desired, such as contour lines or cadastral parcels. This is an model.
efficient way to manage the resulting layers separately.

The Blueprint will also have some local variables that will be used
Drawing Function
for the implementation of the functions, namely:
The purpose of this function is to generate and render a Procedural
Variable Type Description Mesh representing each of the segments stored in the geometry
Ancho Float Drawing width of the current data structures, applying a colour based on the specifications
segment outlined in the attribute data structure. To achieve this, we work in
IndiceP1 Integer Index of point 1 in the the event graph of the Blueprint using an EventBeginPlay event
geometry array node. This peculiarity causes the Blueprint to activate once it is
MaterialInstancia Material Material of the current segment placed in the scene and the game starts running.
Instance
MinCoord Vector Minimum reference coordinates The first step is to retrieve the minimum coordinates to which the
SegVert Vector Vertices of the triangles in the generated geometry will refer. For this, a node invoking the game
(Array) current segment P1-P2 mode is incorporated, specifically a Cast To node pointing to
SegTriang Integer Triangles in the current segment GM_ModoJuego, whose reference object will be the result of a
(Array) P1-P2 Get Game Mode node. From this casting, we will invoke the Min
SP1 Vector Position of point P1 in the Coord Nomin variable that stores these reference coordinates, and
current segment for convenience, they will be stored in a local variable of type
SP2 Vector Position of point P2 in the Vector3, called MinCoord.
current segment
FVec Vector Unit Forward vector
RVec Vector Unit Right vector
UVec Vector Unit Upward vector

Finally, the Blueprint will feature a specific function

(GeneraTramo) that will generate each segment of the polyline
layer and store it in the corresponding Procedural Mesh variable
(e.g., PM_Viarios). Additionally, the result will be drawn in the

11
In the same way, a casting to the game mode will be performed to To facilitate the implementation, the generation function for each
retrieve the array variables containing information about the section has been programmed as a separate code within the
geometry and attributes of the SHP file, previously loaded. For Blueprint, and is detailed below.
this purpose, a Cast To node is used for GM_ModoJuego, pointing
to the result of the Get Game Mode node. In this case, the array Segment Drawing Function
variables GeomViarios, with geometry data, and AtribViarios, with
attribute data, are recovered. The function GeneraTramo will generate a segment with vertices
provided in the form of a vertex array. The function also takes a
line thickness specified in relation to locally defined axes
represented by the MinCoord vector (local origin), a material
(colour) specified as well, and as a segment of a procedural mesh
(Mapa) whose index is specified. Therefore, the input variables
are:

Input Type Description

VerticesTramo Array Vector 4 Vertices that make up the
segment
Ancho F Float Drawing line thickness
A loop is added with a For Each Loop node that will iterate MinCoord F Vector Minimum coordinates of
through all the elements contained in the geometry array. From local axis
this loop, first, the attribute information of each section is Tramo F Integer Order number of the
extracted, that is, the type and the descriptor, although the latter, segment (segment)
for this example, is not used. With the type value, a Switch on Int MaterialTramo Material Instance Drawing material
option selection node is activated, which will serve as a distributor (instance)
for selecting the material (colour) assigned to each typology. For Mapa Procedural Mesh Procedural mesh where it
this purpose, for each option, a node specifying which material is stored
instance is considered at each moment is connected and stored in
the local variable MaterialInstancia. Right after, the line width As seen, the function generates an object composed of a chain of
associated with each type is specified, expressed in centimetres. In lines represented each by two planes that intersect at 90º between
this specific case, the assignment is done directly, but it could each pair of consecutive points P1 and P2 in the vertex array that
have been associated with one of the attributes obtained in the makes up the segment. The function will, therefore, determine the
DBF file. forward (FVec), right (RVec), and upward (UVec) orientation
vectors and build 4 triangles on them, two for each plane. The
On the other hand, the geometry of each section is extracted, dimensions of these triangles are determined by the distance
specifically the section index (TR_i), the number of vertices it between points P1 and P2 and the specified line thickness. This
comprises (TR_Nvert), and the array of vertices that make it up necessitates finding the corresponding 8 vertices that constitute
(TR_Vert). This information is obtained from a Break node applied them, as shown in the figure.
to the loaded geometry element TR_Geom.

The last step is to invoke the section drawing function

(GeneraTramo) with the obtained parameters, namely:

● As Vertices Tramo, the array of the current element TR_Vert

● As Ancho F, the specified width in the current road type
● As Min Coord F, the minimum coordinates established in the
game mode (LLC)
● As Tramo F, the current segment index TR_i
● As Material Tramo, the material instance (MaterialInstancia)
described in the current road type
● As destination Map, the Procedural Mesh component to which
it is intended, in this case, PM_Viarios

The triangle vertices are stored in a local array of positions

(SegVert), and the description of the triangles in another local
array of indices (SegTriang) that point to the generated vertices.
The order of the three vertices of each triangle follows the
right-hand rule to ensure that the normal always points outward.

The function Genera Tramo begins by checking that there are at

least two points in the section. It uses a Last Index node and

12
compares it in a Branch node with an expression >0, proceeding point P2. All measurements are expressed in centimetres and
only if the condition is TRUE. follow the coordinate axis criteria of Unreal Engine.

The next step is to clear the local arrays of vertices and triangles to The next stage is responsible for finding the orthogonal unit
ensure consistency in the generation of each section. This is done vectors that describe the directions of the line connecting point P1
using a Clear function on the SegVert and SegTriang arrays. with point P2. To do this, first, the coordinates of both points are
subtracted and normalised to obtain the forward unit vector. Then,
the pitch and yaw of this vector are obtained, considering that the
roll is assumed to be 0 since it cannot be deduced from a single
vector. This assumption does not alter the drawing process. A
Rotation From X Vector node is used for this purpose. From this
node, it is immediate to obtain all orthogonal unit vectors: the
forward vector, the right vector, and the up vector, each with
corresponding Get nodes from the previous rotation node. These
vectors are stored in corresponding local variables: FVec, RVec,
A main loop is inserted with a For Loop node iterating through the and UVec.
indices of all the points that make up the section, from 0 to the
number of vertices in the section minus one, as it looks forward to
the next point. For each loop index value, an initial point P1
(IndexP1) and the next point P2 (IndexP2) will be associated as
the endpoint. The procedure for both points is always the same:

Next, the process is responsible for finding the 8 vertices of each

segment P1-P2 that will describe the triangles. To do this, it uses
the initial position (P1), the final position (P2), the orthogonal unit
vectors (FVec, RVec, UVec), and the specified line width, which is
the magnitude by which the vertices are separated from the
reference points P1 and P2 along the directions indicated by the
unit vectors. Once the 8 vertices are obtained, they are added in
order to the local array of vertices, SegVert.

● Obtain the X, Y, Z coordinates from the section's vertex array,

discarding the measure (M) value.
● Subtract the minimum coordinates specified as a public
variable in the game mode.
● Multiply the X coordinate by -1 to align with UE's left-hand
rule. Up to this point, we have preserved the vertex
coordinates according to the original orientation of the SHP
file axes (right-hand rule), where +Y is North and +X is East.
At this precise moment, when defining points P1 and P2 for
drawing, we change the sign of the X coordinate to apply UE's
left-hand rule. Therefore, +Y is North, and -X is East.
● Generate a vector with the resulting coordinates using a Make
Vector node.
● Multiply all coordinates by 100 to convert them to
centimetres.
● Add the line thickness to the Z coordinate to ensure the
resulting object sits accurately on the DTM.

The next step is the detailed description of the 4 triangles that

make up the segment between P1 and P2, for which the indices of
In this way, two vectors are obtained: SP1, which describes the
the vertices that constitute them are specified in order. Following
local coordinates of point P1, and SP2, which does the same for
the right-hand rule, these sequences of vertices are:

13
 provides great flexibility for drawing segments with different
● Triangle 1. V0,V1,V2 thicknesses and colours. All the created geometry is stored in the
● Triangle 2. V1,V3,V2 Procedural Mesh component of the Blueprint corresponding to the
● Triangle 3. V4,V5,V6 specified layer. This way, you can work with multiple layers
● Triangle 4. V5,V7;V6 (plots, buildings, etc.) within the same Blueprint, one for each
specified Procedural Mesh component in the Blueprint hierarchy.

Implementation of the Drawing Function

Once the programming for generating the entire geometry and

applying colour based on attributes (in this case, by road type) is
complete, all that remains is to place the Blueprint at the scene's
origin (World Origin), which is at coordinates 0,0,0. Considering
the adjustments already made for the Z coordinate, accounting for
the minimum reference value (Zmin), the base skirt height, and the
width of each section, the position over the DTM will be accurate.

Pressing Play will generate the geometry at runtime.

As seen, in this case, we have enforced the use of specific nominal

minimum coordinates to relate everything to the same local axes.
However, as an alternative, the minimum coordinates from the
SHP file geometry can also be used. Nevertheless, employing
It's important to note that the final index of each vertex in the unique specific nominal coordinates is particularly useful for
vertex array is obtained by adding the previously specified local aligning the drawing with the representation of the digital terrain
index (from 0 to 7) to the index of point P1 multiplied by 8. The model (we use precisely the same coordinates for local axes in
final index result for each vertex of each of the 4 triangles is added both cases). It also serves to align multiple SHP layers in the same
in order to the local triangle array, SegTriang. scenario in case they do not share the same minimum coordinates.
This will be the chosen procedure in this example.
Next, we create the section of the procedural mesh with all the
calculated geometry. To achieve this, we add a Create Mesh As mentioned, the generated geometry can have thousands of
Section node, where the Target is the designated map (Procedural facets, especially for layers with numerous lines, such as contour
Mesh). We specify the section index as the segment index lines, and this can impact the scene drawing performance,
(ensuring coherence), use the array of vertices for the entire particularly in the frames per second (fps) ratio. This aspect can be
created geometry (SegVert), and employ the array of vertex critical for virtual reality experiences, where a refresh rate
indices describing each of the triangles as triangular faces between 60 and 90 fps per eye is required. Additionally, the
(SegTriang). Finally, we include a node that assigns a material geometry remains active as long as the game is running. Once it
instance to the specified segment of the current layer. As seen, this

14
finishes, it is unloaded from memory, and if you want to visualise standard procedures with this type of component, such as
it again, you have to go through the entire process. Also, since transforming, copying, migrating to other projects, or including
procedural geometries are generated at runtime, it's not possible to them as components in other Blueprints, for example.
apply the Nanite technique to improve the drawing efficiency of
so many facets, as Nanite, as argued earlier, is performed as a
pre-processing step before runtime. Furthermore, generated Reading and Drawing of Points
geometries cannot be easily duplicated, moved, or scaled, nor can
they be exported to other projects, requiring them to be
regenerated for each project where they are used. All these factors
Reading of SHP and DBF Files for Points
make procedural geometries less flexible in their use, necessitating
The second exercise will involve loading a SHP file of point
an alternative such as conversion to static meshes.
features, specifically toponymy annotations, whose associated
DBF attribute file will contain information about the type and a
name (descriptor), similar to what was used in the case of
How to Convert Procedural Meshes into Static Meshes polylines. The main difference is that in this case, the file does not
contain sequences of lines (polylines formed by segments) but
When creating a Procedural Mesh with a Blueprint, it can result in
rather X, Y, Z coordinates of points.
thousands of triangles that consume a significant amount of
memory and graphics processing power, thus slowing down the
In this regard, both the LeeSHP function for reading geometry and
scene, especially in virtual reality applications that demand a high
the LeeDBF function for reading attributes remain equally valid,
frame rate. Additionally, it is important to note that Nanite cannot
without the need to adapt any other functions for their reading.
be directly applied to procedural geometries, as Nanite is an
Indeed, just as was done for polylines, a call to the geometry
algorithm implemented in the pre-processing phase (before
reading function and another to the associated attributes are added
runtime), while procedural geometries are generated and rendered
in the same Construction Script of the game mode
in runtime.
(GM_ModoJuego) as used before. In this case, an additional
sequence (Sequence node) is added after reading the polyline files,
To overcome this obstacle, an alternative is proposed: to convert
but specifying the path of the SHP file (PathGeomToponimia) and
the Procedural Mesh generated at runtime into a Static Mesh with
the DBF file of attributes (PathAtribToponimia). The same
the same assigned materials. This way, it can be further nanitized
procedure and criteria for storing files are followed, and the same
and used directly in the scene, significantly increasing drawing
method is used to launch the program from the .uproject file in
efficiency. This is especially useful when generating facets from
edit mode and the .exe file in execution mode of the compiled
an SHP in files that contain thousands of lines (remember that
program. As expected, two arrays of data structures will be
each segment between two points generates 4 facets!).
described, one for storing geometry (GeomToponimia) and another
for storing attributes (AtribToponimia), with the same data
The way to proceed is as follows:
structure as in the case of polylines. As mentioned, only two fields
in the attribute file are considered, the type of point element (Tipo)
● First, make sure the Blueprint is in the scene and has the
and its name (Descriptor).
Procedural Mesh component that will be created, along with
the creation functions triggered at runtime.
● Play the game. This will generate the geometry and materials
of the Procedural Mesh.
● Without exiting the runtime, select the Blueprint that generates
the procedural geometry that has been already placed in the
scene.
● Select the component (GIS layer) of the Blueprint that you Representation of Points
want to save as a static geometry.
● Click the Create Static Mesh button and specify the location in For this case of point elements, procedural geometry will not be
the Content Browser where you want to save it. used. Instead, instances of a basic Blueprint incorporating the
● Stop the game geometry to be drawn will be generated. To simplify, points will
be represented as spheres initially, and each type of point element
Now you have a static object with assigned materials that can be will be associated with a material (colour) for identification.
nanitized (open the Static Mesh and enable the use of Nanite) and Therefore, this Blueprint (BP_Punto_Simple) will have a single
used directly in the scene or incorporated into another Blueprint component of the Static Mesh type called Esferita, associated with
(as a Static Mesh component) much more efficiently. a static geometry of the Sphere type, which is a basic shape
present in the UE engine. Additionally, a variable describing the
This approach avoids: material assigned to the sphere (MaterialInst) will be added to this
Blueprint. Since the intention is to change this material based on
● Having to load an SHP file for each layer every time the the attributes of the point elements, the variable will be made
program starts. public to be accessible from other Blueprints, including the Level
● Generating a Procedural Mesh that cannot be nanitized. Blueprint. The Blueprint's event graph will have a single Set
● Overloading memory and processes, especially when dealing Material node, with the target being the geometry itself (Esferita),
with many GIS layers. and the material being MaterialInst, whose default value is also
specified. The strategy will be to create copies (instances) of this
As seen, it is possible to use UE as a procedural object generation basic Blueprint in the scene at the exact X, Y, Z position of each
program (Procedural Mesh), either from external data (for point element.
example, here SHP files are used) or algorithms, and save them as
standalone objects (Static Mesh), with assigned materials. Using The programming for generating these 3D icons (coloured
assets of static geometry (Static Mesh) also allows applying spheres) will be done in the event graph of the Level Blueprint.

15
This is where the main routine for cloning as many spheres as For this purpose, for each option, a Set node is connected to the
there are point elements in the SHP file will reside. The process local variable MaterialInstancia, specifying its material and colour.
starts from the game start node in the level, meaning from an
EventBeginPlay node.

The first step will be to obtain the information about the geometry
and attributes of the point elements that have been loaded in the
game mode. For this purpose, a Cast To node will be used
pointing to the current game mode (GM_ModoJuego), and its
object type will be precisely the result of a Get Game Mode node.
From the game mode, three pieces of information are extracted:
the minimum reference coordinates, the array of data about the
geometry of the point elements (GeomToponimia), and the array
of data about their attributes (AtribToponimia). For convenience, a
local variable will be defined to store the minimum reference
coordinates (MinCoord) of type Vector3.
The final step is to integrate everything, both geometry and
attributes, into a new instance of the Blueprint representing the
point, in this case, a little sphere, which has been prepared
beforehand (BP_Punto_Simple). For this purpose, a Spawn Actor
of Class node is used, specifying the class BP_Punto_Simple. The
transformation pin is expanded, exposing the position (Spawn
Transform Location) and scale (Spawn Transform Scale). The
former is connected to the result of the calculations for the X, Y, Z
position, referred to the local axes, changed to the left-hand rule,
and scaled according to the desired sphere radius. Finally, to
change the material of the newly created object, a Cast To node is
used, precisely pointing to this Blueprint (BP_Punto_Simple).
The main iteration loop, which will iterate through all the point
From the Cast node, we extract the static geometry component
elements present in the array, will be done with a For Each Loop
(Esferita) and change its material with a Set Material node,
node. The index of each element (TR_I) will ensure coherence
specifying the material assigned based on the type of point
between the geometry and attributes associated with each point.
element (MaterialInstancia).
The loop body begins by obtaining the X, Y, Z coordinates of each
point using a Get node. As in other cases, the value of the M
measure is ignored. These coordinates are then subtracted from
the minimum reference coordinate (MinCoord), and the result of
the X coordinate is multiplied by -1 to adopt the left-hand rule of
the coordinate system in Unreal Engine. With these components, a
vector is assembled using a Make Vector node, and the result is
multiplied by 100 to express it in centimetres.

Finally, two local variables are described, one of the Material

Instance type that stores the material to be used to represent each
point based on its type, and another of the Float type that stores
This procedure will generate as many spheres as there are points,
the radius of the sphere to be drawn. Both values, once the
in their exact location and scale, with the colour associated with
reference Blueprint is compiled, will be given a default value.
each typology.

Labelling

Without a doubt, it is possible to enhance the representation of

points in Unreal Engine scenes by utilising the second attribute
(Descriptor) as text to label each point with its name. To achieve
this, it is necessary first to use the TR_Descriptor pin obtained
from the Get node on the attribute element of each point.
Subsequently, to use it in a label, it is converted to text, and the
result is connected to the Text Label pin of the Spawn Actor of
The other branch of the main loop deals with the extraction and Class node, but this time for the new BP_Punto_Etiqueta class.
use of attributes associated with each point. To do this,
information is extracted from the array of attributes This new Blueprint type will have a few more components,
(AribToponimia) with a Get node, remembering that there are two namely: a Static Mesh component representing the previous
attributes to use: the type (TR_Tipo) and the name sphere (Esferita); another Static Mesh component that will be a
(TR_Descriptor). Precisely, from the type pin (TR_Tipo), a Switch small vertical bar connecting the sphere to the label (Barrita);
on Int node will be connected to allow the use of options, in this finally, a Widget component that will contain the text panel, which
case, to change the material (colour) of the sphere to be drawn. we will call PanelTextoWidget. The first will be associated with a
basic sphere shape, the second with a basic cylinder shape, and the

16
third will have a Widget Class associated with a widget Blueprint (Blueprints) that we have gathered. From here, we extract the root
called WB_Etiqueta. All components will directly depend on the component, which is the one we are going to rotate.
root (DefaultSceneRoot). Additionally, this Blueprint will have an
associated variable, TextoEtiqueta, of type Text, which will also be
made public to be able to modify it from another Blueprint (in this
case, from the Level Blueprint).

For this to be possible, in the event graph, starting from the

EventBeginPlay node, you will first connect a Cast To node
pointing to the Blueprint that contains the panel (WB_Etiqueta),
fed with a Get Widget node whose target object is precisely the
widget component of the Blueprint (PanelTextoWidget). To obtain the rotation angle, a Get Player Camera Manager node
is used, pointing to the current active camera. From here, a Get
Camera Rotation node is connected, and another Break Rotator
node is connected to it in order to obtain the three camera rotation
components (roll, pitch, and yaw). Since we only want the labels
to rotate around their vertical axis and face the camera position,
we extract the Z component (yaw) and connect it to the Z
component of a Make Rotator node. The other two components
are set to zero. Finally, the Blueprint is rotated using a Set World
Rotation node, targeting the root component extracted earlier and
using the calculated rotation.

From this casting, extract the text component of the panel This is a common and straightforward strategy that ensures labels
(TextoPanel), and then perform a Set of this component with the are always facing the camera, meaning the panels remain parallel
TextoEtiqueta variable of the Blueprint. It is also recommended to to the screen plane. Additionally, it could be easily programmed to
disable the shadow of the resulting label by applying a Set Cast apply scaling as the camera gets closer to each label or modify
Shadow node with the New Cast Shadow option set to FALSE. visibility based on distance, etc. These are common techniques for
This will prevent filling the scene with distracting shadows that representing text in three-dimensional space that are easy to
can confuse readability. implement and won't be covered in the current publication. It is
also advisable to adjust the scale of the resulting Blueprints or
each of their components (sphere, bar, text) separately to fit their
size according to the game specifications.

Application and Results

The present methodology has been designed to meet the need for
drawing lines and reference points from SHP files on roads,
Cadastre plots, and contour lines in immersive experiences for
exposing the factors and processes of the initiation and spread of
forest fires in the landscape, as required in the WUICOM-BCN
project.

In this case study, the covered area is 9 Km2 corresponding to the

Rectoret neighbourhood and the Mas Guimbau, Mas Sauró, and
partially Vallvidrera urbanizations, all urban nuclei belonging to
the municipality of Barcelona. As a reference, the digital terrain
model (DTM) of this portion of the landscape has been extracted
and a texture has been applied to its surface, based on the most
recent orthophoto from the ICGC Catalonia service.

The only precaution in the label widget Blueprint WB_Etiqueta is

to mark the text panel TextoPanel as Is Variable, in order to be
able to modify it at runtime.

Finally, to fully implement the labels, in the Level Blueprint event

graph, it is necessary to add functionality that rotates the labels so
that they always face the direction of the camera, making them
easier to read. For this purpose, an Event Tick node is used to
update the rotation on each frame, and it is connected to a Get All
Actors of Class node, targeting the BP_Punto_Etiqueta blueprint
class that we have placed in the scene, one for each point. From
here, a loop is triggered to iterate through all these blueprints, The methodology has been applied to road SHP files, but in a
using a For Each Loop node, iterating over the array of actors simplified version that groups transportation network typologies

17
into just four classes. Additionally, the geometry of contour lines was presented in November 2023, and this method achieved its
has been included, and in this case, it is not necessary to define goal.
any attributes. As a reference, the contour lines of the plots, as
described in the Cadastre, have also been included, without using
any of their attributes. Since only a graphical reference was Discussion
needed, no labelling technique has been applied, as in the case of
toponym points. The methodology presented does not aim to provide a complete
solution for the complex representation of all types of SHP layers,
The materials used have all been generated as material instances, including their iconography. On the contrary, it aims to offer a
with the only change being the colour. The remaining material relatively simple method for drawing lines and points based on the
parameters have been kept the same, considering that a geometry and attributes contained in SIG layers stored in such
non-illuminated mode (Unlit) has been chosen to simplify the files. As seen, there is no universal solution for all cases of
drawing and make it stand out more against the DTM. geographic information layers, but the proposed methodology can
be applied to many cases that do not require that level of
complexity.

In this publication, a highly simplified version of the attribute file

for a type of geographic information layer, specifically
transportation networks, has been used. The original ICGC files
contain much more information according to their specifications,
but the provided simplification is sufficient to demonstrate the
methodology for generating and drawing lines and points in three
dimensions.

The current methodology relies on the use of a third-party plug-in,

but with some effort, native functions could be programmed to
perform the same functionalities, supported by the ESRI SDK for
Unreal Engine. As demonstrated, the plug-in is exclusively used
The toponymy points layer extracted from the ICGC Catalonia
for reading files in SHP and DBF formats, converting them later
service has been simplified to contain only two fields: the type and
into data structures (Struct) for utilisation within the engine.
the descriptor (name). Two representation examples have been
tested—one without labels, using simple coloured spheres
Although there is the limitation that the plug-in only works in
according to the type, and another with labels, displaying the
Unreal Engine versions up to 5.1, you can always use the
name. Applying auto-orientation and scaling techniques to the
generated geometries as Static Mesh and export them to other UE
label panels has made it possible to show this information without
projects in higher versions. This is another advantage of
saturating the space or blocking other elements.
converting procedural mesh geometries into static geometries, as
explained. However, it is recommended to incorporate information
about the reference system and projection used in the original SHP
layers to ensure consistency with other layers and the DTM.

As mentioned, a convenient way to define the DTM is by

converting it into a 3D object and exporting it to an exchange
format such as OBJ or FBX. It is necessary to remember that the
OBJ exchange format, which describes three-dimensional objects,
does not allow saving information about smoothing groups. In this
regard, to give a smoother and visually more realistic appearance
to the DTM (Digital Terrain Model), it will be necessary to use a
3D object editing program (such as Blender or 3D Studio Max) to
select the facets describing the terrain and associate them with the
same smoothing group. If a base skirt and bottom are included to
enhance aesthetics, they will be assigned to different smoothing
groups. Also, taking advantage of the use of a 3D editing program,
UVW texture maps will be added, differentiating the materials of
the terrain surface (to which a material containing a bitmap of an
orthophoto of the area can be associated) and the base. Finally, it
is suggested to export the resulting object in FBX format, which
allows storing smoothing groups, normals, tangents, texture maps,
and materials, thus facilitating its import into Unreal Engine.

In this case study, the DBF file is rigidly read, meaning that the
programming of the DBF reading function is designed to read
exactly the field structure specified in that specific file type. In
future developments, this should be automated so that the field
In the final implementation of the virtual reality experience, some reading process (using the Get Field Info node) and the conversion
functionality has been added to be able to turn off or turn on all of variables (either numeric or string) are dynamic, according to
these geographic components at the user's request. The experience the information returned by this node. This automation will also
require the creation of dynamic data structures (Struct), the

18
number and type of variables of which adapt to the content of the applications. It is hoped that in the future, all these functionalities
DBF file. While in this example, only class attributes (line type) become native to Unreal Engine or, at the very least, a dedicated
and the associated name, which are sufficient for assigning the ESRI plug-in also encompasses the exposed functionalities. The
material (colour) to be drawn, have been read, a broader structure method of drawing triangular facets between two consecutive
incorporating other attributes such as allowed vehicle types or points may serve as inspiration for such developments.
traffic direction can enhance and extend the applicability of the
imported geometries.
Conclusions
As explained, each line segment between two consecutive points
is drawn with two planes intersecting orthogonally, resulting in 4 The rendering of points and lines in space, associated with SHP
triangular facets. This approach proves visually sufficient for files, in Unreal Engine scenarios is undoubtedly a highly
representing three-dimensional curved lines in space at any necessary functionality for applying this magnificent engine to
distance, without the need to generate additional planes at visualisation and modelling applications in engineering,
different angles. One limitation of this approach is that junctions architecture, or Earth sciences, to name a few examples. However,
between segments may not appear continuous for very acute the specific lack of native routines for drawing three-dimensional
angles, although this aspect is imperceptible in most cases and at a lines in Unreal Engine requires seeking alternatives, as outlined in
certain distance from the camera. Future developments, however, this publication.
could enhance this aspect by including extra facets that seamlessly
connect both segments. The chaining of line segments between two consecutive points,
represented by two planes that bisect orthogonally and have a
Culling and level of detail (LOD) techniques, native to the Unreal given width, is a straightforward and reasonably good approach
Engine, are particularly useful since the result of procedural for representing three-dimensional curved lines. Following this
geometry generation is exported as Static Meshes to which these strategy, it is possible to load and draw polylines based on the
methods are applied, enhancing efficiency in visualisation. It is geometry included in ESRI SHP files in Unreal Engine.
particularly interesting to specify the use of Nanite on the
resulting geometry, automatically improving performance in terms Thanks to a third-party developed plug-in (Shapefile Reader), it is
of frames per second, a crucial aspect in virtual reality possible to read SHP files containing geometry and associated
applications. Furthermore, as the lines are generated as Static DBF files with attributes as arrays of data structures in Unreal
Meshes, they seamlessly blend with volumetric effects (such as Engine, enabling their flexible utilisation thereafter.
fog or smoke) and lighting, eliminating the need for specific
procedures for them. The strategy of converting imported data into data structures
(Struct) within Unreal Engine offers great flexibility for its use.
The present study has focused on drawing the geometry of One of the most interesting ways to utilise this is the generation of
polylines included in SHP files with the corresponding colour and procedural geometry for the representation of linear elements.
thickness based on the attributes included in associated DBF files. This approach, in which a set of triangular facets is generated
However, little has been said about the labelling of these between each two consecutive points, forming planes that intersect
polylines, a relevant aspect as in this case, which involves layers at 90º angles, presents itself as a simple and visually effective
of roads and streets. A simple approach would be the association alternative for drawing three-dimensional lines in space.
of labels, similar to those used in the representation of point
elements, to the geometry of each represented segment, whose Additionally, each generated segment is incorporated into a
location could be, for example, the centre of the segment. More specific variable in a dedicated Blueprint, allowing the
complex solutions would involve drawing text panels at the management of GIS layers separately. Furthermore, some basic
position, scale, and orientation appropriate to the location, size, drawing strategies with simple iconography are presented,
and orientation of each segment. allowing the user to specify the colour and width of the drawn
lines.
In this specific case study, a layer of point features has been used,
corresponding to geographical locations with toponymy. That is, Since the generated procedural geometry can be saved as a Static
the type of point element does not vary (toponymy), only the Mesh, the results can be used with much more flexibility as they
content varies (the associated text). Therefore, the symbology become part of the usual workflow in Unreal scenes, including
used in the Unreal Engine scene has been closely linked to this lighting, special effects, interaction with other objects, inclusion as
type of point element (toponymy) and does not change, meaning a components in other Blueprints, or application of Nanite, among
label with a vertical bar indicating the position in the territory, others. Additionally, it allows the results to be duplicated, scaled,
where the distinguishing element is precisely the text describing moved, or exported as independent entities to other levels within
the toponymy. In more complex cases, it is common to have the same game or to other applications.
various types of point elements with associated symbology. Future
developments in this direction should, therefore, aim for the use of The proposed methods and functions also read point features
colours and sizes on simple iconography (e.g., spheres) according without the need for additional programming routines. Thus, point
to the attributes or, better yet, use static mesh icons, as 3D features, such as toponyms, can be loaded into data structures and
representations specific to each typology, adding the components subsequently used in Blueprints, functions, or represented using
of colour and size as well. This way, not only will the appearance various strategies. A straightforward way to draw points is by
of the resulting scene be enriched, but complex information will generating instances of small spheres, whose colour changes based
also be presented intuitively. on the feature type. Additionally, the representation can be
enhanced by adding labels with names that rotate according to
As demonstrated, the methodology fulfils its purpose of drawing their orientation relative to the camera, significantly improving
three-dimensional lines and points in a UE scene, but it also readability.
provides the resulting objects to be used in other Blueprints,
across various levels, and even to be exported to other

19
While this methodology doesn't address the full range of scenarios VIA13 Road: /paved /highway /not applicable /margin
for representing linear and point features from SHP files, it opens /no link or access /connection
up a realm of application that could potentially be further VIA14 Road: /paved /highway /not applicable /margin
developed in dedicated plug-ins, following a similar strategy. This /link or access /generic case
could provide coverage for all possible iconography associated VIA15 Road: /paved /highway /not applicable /margin
with these geographic information elements in the future. /link or access /connection

Tracks:
References VIA16 Road: /unpaved /not applicable /path /axis /not
applicable /generic case
1. Day, M. (2021) Unreal Engine in architecture, engineering and VIA17 Road: /unpaved /not applicable /path /axis /not
construction. AEC Magazine, March. applicable /connection
2. Mottle, J. (2020) The 2020 Architectural Visualization VIA18 Road: /unpaved /not applicable /path /axis /not
Rendering Engine Survey Results. CG Architect Magazine, applicable /covered
September. VIA19 Road: /unpaved /not applicable /path /margin
/not applicable /generic case
VIA20 Road: /unpaved /not applicable /path /margin
/not applicable /connection
Annexes
Trails:
Annex 1. Transportation Network Typologies from VIA21 Road: /unpaved /not applicable /trail /only for
Cartographic and Geological Institute of Catalonia axis /not applicable /generic case
(ICGC) VIA22 Road: /unpaved /not applicable /trail /only for
axis /not applicable /connection
VIA23 Road: /unpaved /not applicable /trail /only for
The values in the CAS field in the road files are 5-character text
axis /not applicable /axis connection
codes:

Railway:
FER01 Railway: /generic case
FER02 Railway: /connection
FER03 Railway: /covered

Funicular:
FUN01 Funicular: /generic case
FUN02 Funicular: /connection
FUN03 Funicular: /covered

Cable car:
TCA01 Cable-suspended transportation (cable car)

Roads and Streets:

VIA01 Road: /paved /generic case /not applicable /axis
/unclassified /generic case
VIA02 Road: /paved /generic case /not applicable /axis
/unclassified /connection
VIA03 Road: /paved /generic case /not applicable /axis
/unclassified /covered
VIA04 Road: /paved /generic case /not applicable
/margin /unclassified /generic case
VIA05 Road: /paved /generic case /not applicable
/margin /unclassified /connection

Highways:
VIA06 Road: /paved /highway /not applicable /axis /no
link or access /generic case
VIA07 Road: /paved /highway /not applicable /axis /no
link or access /connection
VIA08 Road: /paved /highway /not applicable /axis /no
link or access /covered
VIA09 Road: /paved /highway /not applicable /axis /link
or access /generic case
VIA10 Road: /paved /highway /not applicable /axis /link ©2024 David Caballero
or access /connection
VIA11 Road: /paved /highway /not applicable /axis /link Finished in Madrid the 17th of January 2024
or access /covered
VIA12 Road: /paved /highway /not applicable /margin [email protected]
/no link or access /generic case

20