This page has been translated automatically.
Click here to view the original English version instead.
Getting Started
What's Inside?
Project Workflow
Migrating to Unigine
Migrating to Unigine From Unreal Engine
Migrating to Unigine From Unity
Programming Quick Start
1. Basic Scene Objects and Coordinate System
2. Logging and Printing Messages to Console
3. Saving and Loading a World
4. Closing the Application
5. Working with Smart Pointers
6. Creating and Deleting Nodes at Runtime
7. Creating and Setting Up a Camera
8. Creating and Setting up Light Sources
9. Creating, Applying and Deleting Materials at Runtime
10. Managing Existing Scene Objects
11. Performing Basic Transformations (Move, Rotate, Scale)
12. Making It in Time
13. Managing Intersections
14. Getting and Managing User Inputs
15. Implementing Game Logic and Using Properties
16. Creating User Interface
Getting Started with VR
Classes and Components Overview
System Requirements
Video Tutorials
Interface
Interface Overview
The Scene Viewport
Essentials
Importing 3D Models
Instancing Nodes
Materials
Lighting
Tracker Tool
Global Illumination
Georeferenced Terrain Generation
Arbitrary Terrain Generation
Content Optimization
Decals
Performance Inspection with Microprofile
Textures
Procedural Texturing
Bit Masking
Audio Sources and Sound Effects
Cached Shadows
Advanced
Microprofile for Artists
Principles of Operation
Virtual World Structure
World Management
Properties
Hierarchy and Inheritance
Custom Component System
Rendering
Rendering Sequence
Scattering
Parallel-Split Shadow Mapping
Temporal Anti-Aliasing
Interleaved Lights Rendering
Alpha Blending
Multi-GPU Rendering
Physics
Shapes
Collision Detection
Joints
Simulation of Physics
Bit Masking
Import System
File System
Asynchronous Data Streaming
SDK Browser
Projects
Licenses
Add-Ons
Eastern European Countryside
Road Tool Constructor
Vegetation Add-On
VFX
Arbitrary Terrain Generation
Georeferenced Terrain Generation
UnigineEditor
Interface Overview
Layout Customization
Context Menus
Assets Workflow
Asset Types
Assets and Runtime Files
Organizing Assets
Copying Assets From Other Projects
Project Files
Version Control
Settings and Preferences
Editor Settings and Hotkeys
World Settings
Global Physics Settings
Global Sound Settings
Working With Projects
Managing Worlds
Scene Navigation
Creating and Importing Nodes
Selecting and Positioning Nodes
Organizing Nodes
Exporting Nodes
Instancing Nodes
Adjusting Node Parameters
Transformation and Common Parameters
Visual Representation
Properties
Physics and Sound
Setting Up Materials
Organizing Materials
Forced Shader Compilation
Setting Up Properties
Organizing Properties
Setting Up Cameras
Using Visual Helpers
System Menu
Landscape Tool
Creating a Terrain
Creating a Geo-Referenced Terrain
Generating Detail Masks
Generating Vegetation
Generating Spline Objects
Generating Vector Objects
Generating Point Objects
Generating Buildings
Procedural Refinement
Distributed Computing
Using Editor Tools for Specific Tasks
Capturing Screenshots and Frame Sequences
Adding Variations for a More Realistic Environment
Generating Impostors with Impostors Creator
Manual Terrain Modification
Mask Editor for Grass and Clutters
Bake Lighting
Cleaner
FAQ
Switching From the Previous Version of the Editor
Tools
Plugins for 3D Editors
Plugins for 3ds Max
Plugins for Maya
Performance Profiling Tools
Performance Profiler
Microprofile
ResourceEditor
MeshViewer
NormalCombiner
NormalMapper
AmbientMapper
AlphaMapper
ImageDDS
ImageTTF
USC Interpreter
Tileset File
Archiver
Resource
MeshImport
Upgrade Script
Built-in Node Types
Nodes
Node
Node Reference
Dummy Node
Layer
Pivot
Trigger
Objects
Dummy Object
Static Mesh
Skinned Mesh
Dynamic Mesh
Mesh Cluster
Mesh Clutter
Text Object
Sky
Cloud Layer
Effects
Particle System
Decals
Projected Decal
Orthographic Decal
Mesh Decal
Light Sources
Light Sources Parameters
Omni Light
Projected Light
World Light
Environment Probe
Voxel Probe
Geodetics
Geodetic Pivot
World Objects
World Layer
Sector
Portal
World Trigger
World Cluster
World Clutter
Switcher
World Expression
World Spline Graph
Sound Objects
Sound Source
Sound Reverb
Pathfinding Objects
Navigation Areas
Navigation Sector
Navigation Mesh
Players
Player Actor
Player Dummy
Player Persecutor
Player Spectator
Programming
Fundamentals
Programming Overview
Engine Architecture
Typical Architecture of a Unigine-Based Application
Memory Management
Working with Smart Pointers
Accessing Nodes and Files via Properties
Thread Safety
Matrix Transformations
Camera Matrices
Event Handling Callbacks
Setting Up Development Environment
Windows Development Environment
Linux Development Environment
Usage Examples
Custom Import Plugin
Custom Component System
Customizing Mouse Cursor and Behavior
Basic Object Movements
Creating and Attaching a Cloth
Creating a Car with Suspension Joints
Creating Mirrors Using Viewports (Rendering to Texture) or Materials
A Simple Mechanism Using Joints
Creating Routes
Creating Pylons and Wires Using Ropes
Dynamic Meshes
Enabling Selective Surface-Based Collision
Playing Sounds on Collisions
Intersections
Mesh Class
Working with Console
Sharing Data
Splitting Logic Between Several WorldLogic Classes
UnigineScript
Creating UnigineScript Application
Adding Scripts to the Project
Script Debugging
Cache Files
C++
Creating C++ Application
Creating C++ Plugin
C#
Creating C# Application
C# API Reference
UUSL (Unified UNIGINE Shader Language)
UUSL Keywords
UUSL Common Intrinsic Functions
UUSL GBuffer Structure
UUSL Data Structure
UUSL Parameters
UUSL Textures
UUSL Semantics
UUSL Tessellation
UUSL Compute Shaders
Creating a Custom Shader for Deferred Rendering Pass
Creating a Custom Shader for Forward Rendering Pass
Creating a Custom Shader for Post-Processing
File Formats
Mesh File Formats
Property File Format
Spline File Format
Startup Command-Line Options
Console
Configuration File
Rebuilding the Engine and Tools
Rebuild in Windows via Visual Studio
Semi-automatic Compilation with Build Script
Manual Compilation with SCons
Preprocessor Macros for Rebuilding the Engine
Protecting Your Data with a Password
GUI
RC Files
Skin Layout
Usage Example
Double Precision Coordinates
Usage
Performance Analyzer
API
Containers
Container Functions
ArrayVector Class
Map Class
Set Class
Common Functionality
Async Class
Atomiclock Class
Blob Class
Checksum Class
Compress Class
ConsoleVariableFloat Class
ConsoleVariableInt Class
ConsoleVariableString Class
Expression Class
ExternClass Class
FunctionBase Class
Hash Class
Hasher Class
Image Class
Interpreter Class
Json Class
Log Class
OS Functions
Path Class
Plugin Class
Property Class
PropertyParameter Class
Ptr Class
Reflection Class
RegExp Class
Resource Class
Stream Class
String Class
StringArray Class
StringPtr Class
StringStack Class
System Functions
Thread Class
Timer Class
TypeInfo Class
Unigine Namespace Items
Utils Class
Xml Class
Variable Class
Controls-Related Classes
Controls Class
ControlsApp Class
ControlsDummy Class
ControlsJoystick Class
ControlsSixAxis
ControlsXPad360 Class
Engine-Related Classes
App Class
Config Class
Console Class
Editor Class
Engine Class
EnginePtr Class
engine.system Functions
EnginePlugins Class
Game Class
GameIntersection Class
Memory Class
Profiler Class
Properties Class
Sound Class
Sounds Class
Splash Class
Visualizer Class
World Class
Filesystem Functionality
Dir Class
File Class
FileSystem Class
FileSystemAssets Class
FileSystemMount Class
AsyncQueue Class
File System Functions
Package Class
PackageUng Class
UGUID Class
GUI-Related Classes
Gui Class
UserInterface Class
Widget Class
WidgetButton Class
WidgetCanvas Class
WidgetCheckBox Class
WidgetComboBox Class
WidgetDialog Class
WidgetDialogColor Class
WidgetDialogFile Class
WidgetDialogImage Class
WidgetDialogMessage Class
WidgetEditLine Class
WidgetEditText Class
WidgetExternBase Class
WidgetExtern Class
WidgetGridBox Class
WidgetGroupBox Class
WidgetHBox Class
WidgetHPaned Class
WidgetIcon Class
WidgetLabel Class
WidgetListBox Class
WidgetManipulator Class
WidgetManipulatorRotator Class
WidgetManipulatorScaler Class
WidgetManipulatorTranslator Class
WidgetMenuBar Class
WidgetMenuBox Class
WidgetScroll Class
WidgetScrollBox Class
WidgetSlider Class
WidgetSpacer Class
WidgetSpinBox Class
WidgetSprite Class
WidgetSpriteNode Class
WidgetSpriteShader Class
WidgetSpriteVideo Class
WidgetSpriteViewport Class
WidgetTabBox Class
WidgetTreeBox Class
WidgetVBox Class
WidgetVPaned Class
WidgetWindow Class
Math Functionality
Predefined Constants
Geometry Class
Math Common Functions
Math 2D Functions
Math Exponential Functions
Math Matrix Functions
Math Random Functions
Math Trigonometrical Functions
bvec4 Class
dmat4 Class
dvec2 Class
dvec3 Class
dvec4 Class
half Class
hvec2 Class
hvec3 Class
hvec4 Class
ivec2 Class
ivec3 Class
ivec4 Class
mat2 Class
mat3 Class
mat4 Class
quat Class
vec2 Class
vec3 Class
vec4 Class
Node-Related Classes
Node Class
NodeDummy Class
NodeExtern Class
NodeExternBase Class
NodeLayer Class
NodePivot Class
NodeReference Class
NodeTrigger Class
Networking Functionality
Socket Class
Pathfinding-Related Classes
Navigation Class
NavigationMesh Class
NavigationSector Class
Obstacle Class
ObstacleBox Class
ObstacleCapsule Class
ObstacleSphere Class
PathRoute Class
PathRouteIntersection Class
Physics-Related Classes
Contact Class
Physics Class
PhysicsIntersection Class
PhysicsIntersectionNormal Class
Plugins-Related Classes
AppEasyBlendInterface Class
OpenFlightImport Class
engine.grabber Functions
engine.kinect Functions
engine.oculus Functions
AppProjectionInterface Class
engine.surround Functions
engine.vive Functions
engine.wall Functions
CIGI Client Plugin
CIGI Client interface
IArticulatedPart Class
IComponent Class
IEntity Class
IViewBase Class
IView Class
IViewGroup Class
ICigiHostPacket Class
ICigiArticulatedControl Class
ICigiArticulatedShortControl Class
ICigiAtmosphereControl Class
ICigiCelestialControl Class
ICigiComponentControl Class
ICigiComponentShortControl Class
ICigiEntityControl Class
ICigiEntityClampedControl Class
ICigiEnvironmentControl Class
ICigiEnvironmentRequest Class
ICigiIGControl Class
ICigiMaritimeControl Class
ICigiRateControl Class
ICigiSensorControl Class
ICigiSymbolCircleDef Class
ICigiSymbolClone Class
ICigiSymbolControl Class
ICigiSymbolShortControl Class
ICigiSymbolLineDef Class
ICigiSymbolSurfaceDef Class
ICigiSymbolTextDef Class
ICigiTerrestrialControl Class
ICigiTrackerControl Class
ICigiViewControl Class
ICigiWaveControl Class
ICigiWeatherControl Class
ICigiViewDef Class
ICigiEarthModelDef Class
ICigiSegmentDef Class
ICigiTrajectoryDef Class
ICigiVolumeDef Class
ICigiHatHotRequest Class
ICigiIGPacket Class
ICigiStartOfFrame Class
ICigiAerosolResponse Class
ICigiHatHotResponse Class
ICigiHatHotExtResponse Class
ICigiLosResponse Class
ICigiLosExtResponse Class
ICigiLosSegmentRequest Class
ICigiLosVectorRequest Class
ICigiMaritimeResponse Class
ICigiPositionRequest Class
ICigiPositionResponse Class
ICigiSensorResponse Class
ICigiSensorExtResponse Class
ICigiTerrestrialResponse Class
ICigiWeatherResponse Class
HLA Client Plugin
Rendering-Related Classes
Camera Class
Ffp Class
Material Class
Materials Class
Mesh Class
MeshDynamic Class
Primitives Class
Render Class
RenderEnvironmentPreset Class
Renderer Class
RenderContext Class
RenderState Class
Shader Class
StructuredBuffer Class
Texture Class
TextureRender Class
Viewport Class
Content Creation
3D Models Requirements
Art Assets Conversion
Content Optimization
Lights Optimization
Dynamic Reflections Optimization
Water Optimization
Terrain Optimization
Physics Optimization
VR Best Practices
Materials
Hierarchy and Inheritance
Custom Materials
Samples
Tutorials
Adding Morph Targets
Migrating to UNIGINE 2.8
API Migration
Console Migration
Content Migration
IG Template
Setting Up Properties
IG Configuration
Environment Settings
Creating Custom Components
Table of Contents
Warning! This version of documentation is OUTDATED, as it describes an older SDK version! Please switch to the documentation for the latest SDK version.
Warning! This version of documentation describes an old SDK version which is no longer supported! Please upgrade to the latest SDK version.

Navigation Mesh

Chapters:

Warning
This feature is experimental and not recommended for production use.

The navigation mesh is a navigation area which is arranged above the surface of an arbitrary mesh. In fact, the navigation mesh is an area of the specified height above the mesh polygons, which is available for pathfinding.

In contrast to navigation sectors, the navigation mesh enables the following:

  • Only 2D routes can be calculated within the navigation mesh.
  • Pathfinding can be performed within 1 navigation mesh only. Pathfinding within the following areas is not supported:
    • Within several intersecting navigation meshes.
    • Within the intersecting navigation mesh and sector.

See also#

  • The NavigationMesh class to manage navigation meshes via API
  • The article on Creating Routes to learn how to create routes inside the navigation mesh
  • A set of samples located in the <UnigineSDK>/data/samples/paths folder:
    • mesh_00
    • route_03
    • route_04

Creating Navigation Mesh#

Before adding a navigation mesh, you should prepare a mesh, on which this navigation mesh will be based. Such mesh is created separately and should meet the following requirements:

  • Any polygon of the mesh must not share its edge with more than 2 other polygons; otherwise, an error will occur.
  • Mesh polygons should be as wide as possible (ideally, they should be equilateral). Too narrow and high polygons may reduce accuracy of path calculation.
  • The mesh should be optimized: it should not contain a large number of polygons.

When a mesh is prepared, you can add the navigation mesh to the scene via UnigineEditor:

  1. Run UnigineEditor.
  2. On the Menu bar, click Create -> Navigation -> Navigation Mesh.

  3. In the file dialog window that opens, choose the required mesh to be used as a base for the new navigation area and click Ok.

  4. Click somewhere in the world to place the navigation mesh. A new navigation mesh is added to UnigineEditor and you can edit it via the Parameters window.

Notice
The created navigation mesh only provides an area within which 2D routes are calculated. The routes themselves should be created using the script.

Example#

If you have a scene with different objects and need to calculate a 2D route among them, add the navigation mesh to this scene as follows:

  1. Create a flat mesh with holes in places where the objects are positioned.
    The scene
    The mesh created for the navigation mesh
  2. Specify this mesh as a base for a navigation mesh within which the route is calculated, and add the navigation mesh to the world. It will be highlighted in green:

    A navigation mesh based on the flat mesh
  3. Place the navigation mesh above the scene.

    The navigation mesh positioned above the scene

Notice
In this case, you can also use a navigation sector with obstacles positioned inside it instead of the navigation mesh. However, the navigation mesh is preferred for more complex cases.

Editing Navigation Mesh#

In the Node tab of the Parameters window, you can adjust the following parameters of the navigation mesh:

Navigation Mask The navigation mask of the navigation mesh must match the navigation mask of the route that is calculated within it. Otherwise, the navigation mesh does not participate in pathfinding.
Quality Quality of optimization of the route that has already been calculated. This value specifies the number of iterations that are used for taking the short cut. The higher the value, the longer the route calculation takes.
Velocity Scaling factor for velocity of the point that moves inside the navigation mesh.
Dangerous Danger factor that indicates if the moving point should try to avoid the navigation mesh.
Notice
If the danger factor exceeds the maximum danger factor set for the route, the navigation mesh is excluded from pathfinding calculations.
Depth Depth value. This value affects the quality of the route that is currently calculated. The more the depth value, the better control over accuracy and speed of route calculation is provided. The depth can take integer value in range [0;4]. By default, the depth is set to 0 for a new navigation mesh. The 2, 3, 4 values are used for deeper heuristics.
Height Distance above the mesh polygons available for pathfinding. By default, the height is set to 1 for a new navigation mesh.

Loading a New Mesh#

To load a new mesh on which the navigation area is based:

  1. On the Navigation tab, press .
  2. In the file dialog window that opens, choose the required mesh and press Ok.

Saving the Current Mesh#

To save the current mesh on which the navigation area is based:

  1. On the Navigation tab, press .
  2. In the file dialog window that opens, specify a name for the mesh and press Ok.
Last update: 2020-01-14
Build: ()