This page has been translated automatically.
Video Tutorials
Interface
Essentials
Advanced
How To
Professional (SIM)
UnigineEditor
Interface Overview
Assets Workflow
Settings and Preferences
Working With Projects
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Lighting
Sandworm
Using Editor Tools for Specific Tasks
Extending Editor Functionality
Built-in Node Types
Nodes
Objects
Effects
Decals
Light Sources
Geodetics
World Nodes
Sound Objects
Pathfinding Objects
Players
Programming
Fundamentals
Setting Up Development Environment
Usage Examples
C++
C#
UnigineScript
UUSL (Unified UNIGINE Shader Language)
Plugins
File Formats
Materials and Shaders
Rebuilding the Engine Tools
GUI
Double Precision Coordinates
API
Containers
Common Functionality
Controls-Related Classes
Engine-Related Classes
Filesystem Functionality
GUI-Related Classes
Math Functionality
Node-Related Classes
Objects-Related Classes
Networking Functionality
Pathfinding-Related Classes
Physics-Related Classes
Plugins-Related Classes
IG Plugin
CIGIConnector Plugin
Rendering-Related Classes
Content Creation
Content Optimization
Materials
Material Nodes Library
Miscellaneous
Input
Math
Matrix
Textures
Art Samples
Tutorials
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.

Startup Command-Line Options

Startup command-line options can be specified on the UNIGINE executable file launching. These options control what rendering API to use, what resolution to set for Unigine window, where resources for initializing the engine are stored, etc. The options are either set in UNIGINE SDK Browser or manually via the command line.

Notice
If no command-line options is specified, the options with default values will be used when launching the application.

The syntax of command-line options is as follows: the full name of the binary executable (64-bit development or production version) is specified first and then the start-up options.

Shell commands
main_* -command argument
Shell commands
main_* -command "argument,argument"
Shell commands
main_* -console_command "command argument"

All paths are specified as absolute or relative to the binary executable or the data directory.

If the same command is specified multiple times, only the last command will be taken into account by the engine. For example, in the following case, only the argument3 will be used by the Engine:

Shell commands
-command "argument1" -command "argument2" -command "argument3"
Notice
  • An exception is file system command-line options: they can accumulate all the specified values.
  • The CLI options specified on the application start-up always take precedence over the ones stored in the configuration files. Some of the CLI options can be changed through the console. Such options are automatically stored in the configuration files (this way, after the application is quit, they will be restored on the next start-up). All other CLI options don't change the configuration files.

Video Settings#

Name Description Arguments Default
-main_window_size Size of the main window width height 1600 900
-main_window_resizable Allows changing the size of the main window on the fly, without having to restart the application 0 is a non-resizable mode
1 is a resizable mode
0
-main_window_fullscreen Fullscreen mode of the main window 0 is a windowed mode
1 is a fullscreen mode
0

Graphics Settings#

Name Description Arguments Default
-video_app Graphics API to be used for rendering:
  • No renderer: do not render anything onto the screen (for example, for servers in case of playing over the network)
  • Automatically choose the best option from available ones
  • DirectX
  • OpenGL
  • DirectX12
  • Vulkan
The current value of -video_app can be obtained via the getVideoApp() method of Unigine API.
"null"
"auto"
"direct3d11" or "dx"
"opengl" or "gl"
"direct3d12" or "dx12"
"vulkan" or "vk"
"auto"
-video_adapter In case of several GPUs, allows selecting a GPU to be used.
Notice
Available for DirectX only.
The number of the GPU to be used. 0
-video_debug Enables or disables the debug context of OpenGL or DirectX.
Notice
Enabling the debug context may cause performance drop (~30-40%).
DirectX:
  • 0 to disable
  • 1 to write all DirectX errors (red) and warnings (yellow). If the error occurred, it means that there is a mistake in API.
  • 2 to write all DirectX errors (red) and warnings (yellow). If the error occurred, the engine will crash and the full callstack will be shown.
OpenGL:
  • 0 to disable
  • 1 to write all OpenGL errors (red) and warnings (yellow). If the error occurred, it means that there is a mistake in API.
  • 2 works in the same way as 1 mode.
0
-video_debug_shader Enables or disables debug shaders for the application regardless of its binary type (debug or release). This option should be enabled in case you use graphics debugging tools (e.g., the RenderDoc debugger). 0 to disable debug shaders (release shaders are used)
1 to enable debug shaders
0
-video_quad_buffer Enables or disables quad buffered stereo. 0 to disable quad buffering
1 to enable quad buffering
0
-video_offscreen Enables the offscreen mode for the application, making it possible to run UNIGINE Engine in a cloud and use powerful servers (e.g., to generate photorealistic datasets for deep learning and verification of AI algorithms). All windows in this mode are virtual, just like the display, user input is not available.
-main_window Enables creating a main window during the application start-up. After starting up the application any window can be created and will work normally. For example, this can be useful in a custom editor or any other application, where there should be no main Engine window. 1 to enable creating a main window.
0 to disable creating a main window.
1
-auto_quit Enables force closing of the Engine when all windows are closed. 1 to enable force closing of the Engine. This value should be set when 0 is passed to -main_window.
0 to disable force closing of the Engine.
0

File System#

Name Description Arguments Default
-data_path A path to the data directory with all resources. The path can be specified as an absolute path or relatively to the binary executable. The specified -data_path directory can be obtained via the getDataPath() function. The argument can be passed as follows:
  • ../RELATIVE_PATH/
  • ABSOLUTE_PATH
../
-plugin_path Path to a directory that contains plugins. All of the plugins in this directory will be loaded automatically on the start-up. The path can be specified relatively to the binary executable or as an absolute path. The list of the specified -plugin_path directories can be obtained via the getNumPluginPaths() and getPluginPath(int num) methods. The arguments can be passed as follows:
  • ../RELATIVE_PATH/
  • ABSOLUTE_PATH
plugins/
Notice
Unlike other command-line options, the plugin_path option can accumulate all specified values. It allows specifying multiple paths, each of which will be used by the Engine.

For several directories or packages you should specify each item separately without commas, for example:

Source code
-plugin_path ../RELATIVE_PATH_1/ -plugin_path ../RELATIVE_PATH_2/ -plugin_path ABSOLUTE_PATH

Other Data#

Name Description Arguments Default
-boot_config Path to Startup Configuration File containing the engine start-up options. The path can be specified as an absolute path or relative to the -data_path or <project_name> folder if the -project_name is set. The arguments can be passed as follows:
  • ../RELATIVE_PATH/
  • ABSOLUTE_PATH
configs/default.boot
-cache_path A path to store system and editor cache files (specified by system_cache and editor_cache respectively). The path can be specified as an absolute path or relatively to the -data_path.
Notice
For this parameter to take effect you should either delete existing system and editor cache files or move them to the new specified location.
data/
-editor_cache A path to a cache file to be used by the UnigineEditor. The path can be specified as an absolute path or relatively to the -data_path, or to the -cache_path (if any). editor.cache
-system_cache A path to a cache file to be used by the Engine. The path can be specified as an absolute path or relatively to the -data_path, or to the -cache_path (if any). unigine.cache
-engine_log The log file to be created and used. The path can be specified as an absolute path or relatively to the binary executable. For relative paths, if the -project_name is set, the log file with the specified name will be created in the corresponding directory in the User profile (only the name will be used, the remaining part of the relative path will be discarded). log.txt
-editor_script Path to the editor script (specified relative to the data directory)
-gui_path A path to a GUI skin to be used for the engine interface. The path can be specified as an absolute path or relatively to the -data_path. core/gui/
-project_name Forces the engine to store all changing data (a log file, cache files and configuration files) in the User profile rather than in a directory with binaries. For that, a directory will be created with a specified PROJECT_NAME or a path to the project directory relative to the User profile (for example, unigine_projects/my_project). PROJECT_NAME, namely:
  • A name of the project directory. For example, -project_name my_project will create the following directory:

    Windows:

    C:/Users/<username>/my_project/

    Linux:

    /home/<username>/.my_project/

  • A path to the project directory relative to the User profile. For example, -project_name unigine_projects/my_project will create my_project directory in the following directory:

    Windows:

    C:/Users/<username>/unigine_projects/

    Linux:

    /home/<username>/.unigine_projects/

    Notice
    The specified unigine_projects folder must exist in the User profile.
-system_script Path to the system script (specified relative to the data directory). core/unigine.usc
-skip_guidsdb The Engine ignores the guids.db file and searches for GUIDs among all .meta files inside the data folder and all mounted external directories and packages.
Notice
UnigineEditor uses this argument by default to avoid errors, and always re-generates the guids.db file to ensure its validity.

Engine-Related Settings#

Name Description Arguments
-console_command Console command to be used at the engine start-up. Several commands can be separated using the && sequence. command <arguments>
-console_history

Sets the path to the file that stores the console command input history. The path to the file and its name should be specified.

If the path to the file is not specified, the file will be searched in directories the following sequence:

  1. Directory set by the parameter -project_name (if specified)
  2. Directory where binary executable file is stored
  3. Directory set by the parameter -data_path (if specified)

If the file name is also not specified, the file with the default name console_history will be searched in the above-mentioned order.

<path_to_file/console_history_file_name>

(the default is "bin/console_history")

-extern_plugin Load a plugin library (the path is specified relative to the binary executable).
  • The library name should go without any prefixes and postfixes.
    (For example, libNetwork_x64d.so should be passed as "Network".)
  • Several plugins are comma separated (no whitespace).
  • If you want to clear the list of plugins (they are automatically loaded by the engine once specified on the start-up), simply pass "" as an argument to this command.
The arguments can be specified as follows:
  • PLUGIN_NAME
  • PLUGIN_NAME_1,PLUGIN_NAME_2,...,PLUGIN_NAME_N
-extern_define External definition to be used.
  • Several definitions are comma separated (no whitespace).
  • You can also use the following syntax: -extern_define "A=B,C=D".
    (For example, -extern_define  "TEST=42" .)
  • If you want to clear all definitions, simply pass "" as an argument to this command.

The current value of -extern_define can be obtained via the getExternDefine() method of Unigine API.

The arguments can be specified as follows:
  • DEFINITION_NAME
  • DEFINITION_NAME=VALUE
  • DEFINITION_NAME_1,DEFINITION_NAME_2,
    DEFINITION_NAME_3=VALUE,...,DEFINITION_NAME_N
-microprofile_enabled Enables the Microprofile tool. 1 to enable the Microprofile tool.
0 to disable the Microprofile tool.

Sound Settings#

Name Description Arguments Default
-sound_app Sound API to be used:
  • No sound
  • Automatically choose the best sound library option from available ones (OpenAL)
  • OpenAL sound library
The current value of -sound_app can be obtained via the getSoundApp() method of Unigine API.
null
auto
openal
auto
Last update: 2023-04-19
Build: ()