This page has been translated automatically.
Recent news:
Table of contents:

UNIGINE 2.14: Cumulonimbus Clouds, C# 9, Water Wave Spectrum Control, New Landscape Generator

Key Changes

  • Full set of cloud types, including Cumulonimbus.
  • New Landscape Generator: Sandworm Tool (production-ready).
  • Integration of .NET Core 5 (C# 9).
  • Water system upgrade: precise control of waves spectrum.
  • Planar reflection probes.
  • Light Meter tool for physically-correct visualization.
  • Safer execution sequence in the engine and physics system.
  • Per-effect quality presets system.
  • Asset packages system.

Notice: UNIGINE 2.14 SDK requires SDK Browser version 1.9.30 or later.

Full Set Of Cloud Types

UNIGINE’s 3D volumetric multilayer cloud system is designed specifically for enterprise flight simulators and meets the strict requirements applicable to them, offering true-to-life skies.

There are ten types of clouds in nature: Altocumulus, Altostratus, Cirrocumulus, Cirrostratus, Cirrus, Cumulonimbus, Cumulus, Nimbostratus, Stratocumulus, Stratus.

Now all of them are available right out-of-the-box as configurable presets with a pack of performance optimizations.


You can find a nice summary on the UNIGINE atmosphere system in our blog.

Advanced Cloud Formation

Cloud formation has improved significantly giving you even more flexibility and room for variation bringing the look of the clouds to a new level. In addition to the built-in coverage texture, the shape of the clouds can now be defined by a custom 3D texture as well. So, you can create a cloud of any specific predefined shape and even define a custom shape for the shadows. With an additional extra noise you can extend the diversity of details.

On top of that we have added an ability to use curves to control variation of certain parameters (like density, threshold, detail intensity, etc.) along the layer height, which is also available now for a set of 3D noises that define the shape of clouds down to the smallest details. So you can fine-tune large clouds to create any form you like.

Custom 3D Texture
Custom 3D Texture
Custom 3D Texture

As for distortion of clouds, you can now control it globally for the whole layer, including the distortion in a certain direction caused by the wind.

Improved Sorting

Improved sorting when rendering transparent objects (Alpha Blend) and volumetric clouds has become available, so it is clearly seen now whether a transparent object is below the lowest cloud layer base, inside the clouds, or above the highest cloud layer top.

You can enable this feature via the UnigineEditor (Settings -> Render -> Clouds -> Transparent Order) or via the new render_clouds_transparent_order console command (setting the value of 2).

Other Clouds Improvements

  • Up to 2.14 all cloud layers were global (infinitely spread), now they can be limited to a certain area, which is useful for regional weather implementation.
  • Fixed an issue with changing the form of thin rounded (Settings -> Render -> Clouds -> Rounded) cloud layers on entering and leaving them.
  • Improved reduction of tiling, including the one caused by 3D noise, making clouds look natural regardless of their density even in large-scale worlds.

New Landscape Generator: Sandworm Tool

Our new landscape generation tool (Sandworm) introduced in the previous release as experimental has evolved to the production-ready stage. With a lot of UI/UX improvements and a set of new features added, it enables you to generate the new Landscape Terrain based on the data from georeferenced data sources. You can use raster (elevation, imagery, and masks) and vector data sources from your local storage device, or connect to open services (such as OpenStreetMap or various state/municipal databases) or private tile servers created and supported by users on the basis of services similar to QGIS (currently supported data from online sources: imagery and elevation).

Most of the widely used projections are supported, moreover, you can combine sources with different projection types within the same project. Output settings have evolved to make the landscape generation process more clear.

A basic set of tools is available including:

  • Mask-based generation of vegetation and 2.5D buildings generation.
  • Creating details for more detailed landscape surfaces based on landcover data.
  • Generation of roads based on vector data.
  • Generation of pipelines, fences, powerlines, and whatever necessary based on vector data.

For more information on generating landscapes with the new tool please refer to the Sandworm Tool section of the documentation.

We have also added the possibility to export the created landscape to ObjectTerrainGlobal, but it's mainly for backward compatibility.

The list of Sandworm features currently includes the following:

  • Support for multiple georeferenced sources raster (elevation, imagery, and masks) and vector (roads, buildings, etc.).
  • Advanced data filtering options: via attributes (vector sources), via indexed, color and channel masks (raster sources).
  • Support for online TMS (Mapbox, OSM) and offline data sources.
  • Mask-based generation of vegetation.
  • Generation of additional details (sand, rocks, etc.) based on landcover data for more realistic landscape surfaces.
  • Procedural generation of objects (roads, powerlines, buildings, landmarks, etc.).
  • Advanced control and fine-tuning of placement parameters.
  • Support for most of the widely used Coordinate Reference Systems (CRS) for input as well as output projections.
  • Ability to combine sources with different projection types within a single project.
  • Export to Landscape Terrain and Terrain Global.
  • Coherent and user-friendly interface with dockable windows.

We plan to keep adding new features into Sandworm (including procedural content refinement). In the future the tool shall also be used for generation of the Round Planet object as well. Distributed generation and partial re-generation of the landscape functionality is on the way and is likely to be available with the next SDK release (2.15).

Water System Upgrade (Beta)

New implementation of waves is now available offering you precise control of waves spectrum. Unique characteristics of each wave system can be set independently through spectral parameters, wave direction and speed, and the shape factor of waves (as all the data is now available on the CPU side). You can create multiple waves and wave groups (from largest to smallest) with convenient access to every parameter and an ability to control them via API at run time (e.g. processing Weather Control packets from an instructor station, etc.).

Source code (C++)
ObjectWaterGlobal water = NULL;

int init() {
    Node water_node ="ObjectWaterGlobal");
    if(water_node == NULL) {
        log.warning("can't find water node with name \"ObjectWaterGlobal\"\n");

    water = node_cast(water_node);
    if(water == NULL) {
        log.warning("water node is not ObjectWaterGlobal\n");
    // switch to manual mode to enable setting up waves via code
    // add waves one by one.
    // addWave(wave length, amplitude, steepness, direction angle[0.0; 360.0], phase offset[0.0; 2*PI])
    water.addWave(8.0, 0.05, 2.0, 270.0, 0.0);
    water.addWave(8.0, 0.015, 1.0, 150.0, 1.0);
    water.addWave(8.0, 0.02, 6.0, 75.0, 0.0);
    water.addWave(16.0, 0.05, 2.0, 270.0, 3.0);
    water.addWave(16.0, 0.05, 7.0, 45.0, 0.5);
    water.addWave(32.0, 0.1, 2.0, 120.0, 2.0);
    water.addWave(64.0, 0.2, 1.0, -90.0, 0.1);
    // change amplitude and length for the second wave
    water.setWaveAmplitude(1, 0.015);
    water.setWaveLength(1, 10);
    // ...

    return 1;

New procedurally-generated foam now looks more natural than the one provided by the previous texture-based implementation.

This feature is currently in the beta stage; by default the SDK provides old implementation. In order to use the new system, download the experimental build from the developer portal.

Further Water System upgrades to be expected shall include refactoring of the Global Water object with a set of performance optimizations and visual improvements, as well as improvements of local water, rivers and streams.

Integration of .NET 5 (C# 9)

Having started with .NET Core 2.2 and 3.1 support, we have now implemented support for .NET 5 released in November 2020 (new major .NET versions are planned annually, so we keep the pace). This update brings you many fixes and new features as well:

  • Better performance.
  • Garbage collection improvements (reduced memory consumption).
  • C# 9.0 support with improved performance & native interop and more (for details please follow this link).
  • Container size optimizations.
  • Numerous bugs fixed and much more.

For more details refer to the official .NET 5 Release Notes. Please note that the minimum required Visual Studio version is 2019 (only for C# projects using the Component System).

End of .NET Framework Support

Since UNIGINE 2.14 the .NET Framework is considered obsolete and no longer supported, as 5.0 is the main implementation of .NET going forward, and the preferred C# workflow is based on using the integrated C# Component System. All related demos, samples and project templates have been migrated to .NET5.

For details on migrating your .NET Framework projects to .NET5 please refer to the dedicated article.

Planar Reflection Probes

Working with planar reflections has become more convenient with a new Light Planar Probe. You’re no longer bound to a certain mesh, surface, and material, as it is a separate object for grabbing and projecting reflections onto flat surfaces (mirrors, water surface, etc.) - a single probe can be used for multiple surfaces it covers. Improved rough reflections and an extended set of control parameters offer you even more flexibility.

Similar functionality has been removed from the mesh_base material. Unfortunately, proper automatic migration of planar reflections is not possible as new implementation differs a lot. So you will have to manually set up planar reflections in your scenes once.

For more information on planar reflections please check out our online documentation.

Better Refraction

If you’d looked at transparent objects through a refractive object (e.g. a rippled glass) in 2.13, you’d have noticed that these objects remain unaffected by refraction distortion. We have improved refraction sorting and now the effect takes into account all transparent objects in the background (behind the farthest refractive surface) and warps them properly.

You can enable this functionality via the dedicated dropdown in the Refraction group of the rendering settings for transparent objects (Settings -> Render -> Transparent)

Light Meter

We’ve added Light Meter - a new visual debugging tool to simplify lighting adjustment. Open it via the Rendering Debug -> Light Meter and you’ll see illuminance distribution for all surfaces in the scene as a color gradient from zero to the maximum level. So, to set up lighting for a room with a maximum light level of 350 lux, set the corresponding value with the slider and simply adjust light sources, so that most of the surfaces become painted red-to-white. Recommended lighting levels are given above.

We strongly recommend using this tool for lighting adjustment in your scenes. Physically correct lighting is a key to photorealistic graphics. This is especially important for computer vision learning in virtual environments.

For more information on planar reflections please check out our online documentation.

Better SSAO And Bent Normals

We have added temporal filtering for SSAO and Bent Normals giving you an ability to control how many frames are to be accumulated making the result smoother and reducing noise flickering, accumulating too many frames, however, may cause ghosting.

Another improvement is a denoiser for SSAO and Bent Normals offering you full control over intensity and threshold. It is a very efficient noise reduction option, but use it wisely as it may result in loss of details.

Other Rendering Improvements

  • Fixed TAA issues on Skinned Meshes with Alpha Blend surfaces and reduced TAA ghosting.
  • Added support of vertex_id input to UUSL.
  • Fixed an issue that caused spikes on DX11 with Vsync enabled.
  • Fixed incorrect Motion Blur rendering when grabbing frame sequences via the Video Grabber.
  • Fixed an issue with the Soft Interaction feature disabled for particle systems having the Emission state enabled.
  • Fixed sRGB when blending samples for the DoF (Depth of Field) effect.
  • Fixed issues when creating RenderSurface in async thread sometimes leading to crashes.
  • Fixed lighting of alpha-blend objects by LightOmni sources with disabled shadows.
  • Fixed an issue with Supersampling for dynamic reflections of static environment probes sometimes leading to visible seams.
  • MeshDynamic improvements: renderInstancedSurface is allowed when the vertex buffer is empty.

Safer Execution Sequence

We have made changes to the Engine's execution sequence to optimize the order and ensure overall stability and timeliness of execution of all operations, avoiding possible conflicts and crashes (e.g. when calling Plugin::swap() you can be sure that all physics calculations are completed).

You can now add callbacks to execute your code at any stage of the Engine's main loop (e.g. after the SystemLogic::postUpdate() execution) via the Engine::addCallback() method.

The following diagram (clickable) represents the main stages of the UNIGINE execution sequence.

World Management

As for world management we have unified and improved loading and unloading operations for maximum safety and stability: a world shall not be unloaded until all methods of the main loop are executed. You can also force-load a world instantly via the new loadWorldForce() method, if necessary (can be useful for custom Unigine-based Editors). World initialization will now begin only after all system managers are updated and before executing plugins update.

New methods of the World class are now available for more convenient management via API (saveWorld, reloadWorld, quitWorld). And new World callbacks enable you to perform necessary actions right before and just after all world logic initialization and shutdown methods.

For more information on the updated execution sequence please refer to the updated Execution Sequence section of the Documentation.

Improved Physics Update Logic

We have changed the logic of updating physics, making it safer and more stable.

All user code is now executed in the Main thread - a great plus to safety. No more restrictions on actions to be performed in your physicsUpdate() and physics callbacks - just do anything you did in update()!

Since 2.14 there will be two update modes for physics (each having its advantages and use cases):

  • Asynchronous - faster (execution in parallel with rendering), but with a one-frame lag (results of physics calculations are applied in the next frame). In this mode Physics works the same as it was in 2.13.
  • Before Rendering - more straightforward with calculation results applied in the current frame, but with no async speed-up bonus.

So, you can now choose which mode fits your project's requirements best.

For more information on new update modes please refer to the Physics Simulation article.

Catching Up

Instead of simply dropping frames when the physics budget is exceeded, making the simulation look like a "slow-mo", now there is a catch-up system. This system keeps such frames in a queue for a short time interval and tries to use any opportunity (growing Engine framerate or CPU idle periods while waiting for GPU) to execute these frames. Fewer dropped frames mean smoother simulation and more predictable behavior.

Frame Time Stabilization

In case the current Engine framerate is much higher than the fixed physics framerate, the physics won't be updated each rendering frame (e.g. it may update during every second frame), so the resulting frame time becomes pulsating. This new feature ensures stable frame time for smoother user experience removing unwanted "hiccups" (however, the average frame rate is decreased).

This feature is on by default, but you can switch it off in case your application is used for machine learning or for grabbing frame sequences (video grabber), when smoothness is not important.

Quality Presets

As the functionality of the Engine evolves, each release adds more and more settings and parameters for you to control. Flexibility is good, but sometimes you might just want to switch between some abstract levels like Ultra for high-end hardware or Medium for the mid-to-low segment. Well, we've analyzed typical cases, did a huge deal of testing, and finally made all necessary adjustments for you. So, now you can quickly make your application fit any supported configuration by simply switching presets, which is also available at run time via API.

The quality presets are available for Render, Sound, and Physics systems.

Of course you still can adjust every single parameter manually - just switch to Custom and they're at your disposal.

API Improvements

  • Methods of the AppOculus that were available for UnigineScript only can now be used from C++/C# as well.
  • Added useful methods Vector::operator+= and Vector::operator+.
  • Added HashSet::fromKeys() method.
  • Added inverseLerp functions to MathLib.
  • Added an ability to set minimum and maximum (clamp) values for a TextureCurve (ValueMin/ValueMax).
  • Added an ability to get and remove components by their interface:
    Source code (C#)
    List<HeliRotor> rotors;
    rotors = GetComponentsInChildren<HeliRotor>(node).ToList<HeliRotor>();
  • Fixed inverted input in VScrollHidden / HScrollHidden C# methods.
  • Fixed race conditions in thread handling.
  • Node class (and all derived ones) no longer implement the IDisposable interface to avoid ambiguity.
  • Added support for delegate keyword in C#, so the following code won’t raise any errors:
    Source code (C#)
    public class Test : Component
        public delegate void TestDelegate();
        public delegate void TestDelegate2();
        public delegate bool TestDelegate3(int i);
        public event TestDelegate2 onFinished = delegate { };
        public event TestDelegate onChanged = delegate { };
  • Added an overload for Unigine::Xml::load()/save() functions taking Unigine::Stream as a parameter enabling you to transfer XML data (including binary format) via streams.
  • Unigine meshes now support array-type arguments, so you can add multiple vertices, tangents, normals, etc. at once simplifying mesh management via code. You can also get all vertices, normals, tangents, and other data for the whole mesh in a single function call (getNormals(), getTangents(), etc.).
  • You can now use lambda expressions when defining callbacks in C++:
    Source code (C++)
    // create a callback from lambda
    int value = 5;
    CallbackBase* callback = MakeCallback([value](){ /* .. */ });
    // or std function
    std::function<void()> callable_obj = [value]() { /* .. */ };
    CallbackBase* callback = MakeCallback(callable_obj);
    // or any other type of callable
    struct Callable
      void operator()() const { /* .. */ }
      int value;
    } callable_obj = { /* .. */ };
    CallbackBase* callback = MakeCallback(callable_obj);
    // ---------------------------------------------------------
    // create a callback with parameters from lambda
    CallbackBase2<NodePtr, int>* callback = MakeCallback([](NodePtr node, int value) { /* .. */ });
    // create a callback with parameters from generic lambda
    CallbackBase2<NodePtr, int>* callback = MakeCallback([](auto node, auto value) { /* .. */ });
  • For more details on API changes please refer to the API Migration Guide.

Other Engine Improvements

  • Fixed LOD switching on moving objects with a stationary camera.
  • Upgraded the WPF Multiple Windows C# sample with an individual GUI for each viewport and mouse input handling.
  • Fixed an issue with Blob compression when calling the Blob::compress() method.
  • Fixed an issue with incorrect runtime FBX file import path containing uppercase letters causing an import failure on Linux.
  • File GUID stored in a .meta file for an existing file shall not be overwritten, the corresponding GUID in the guids.db file will be updated instead.
  • Improved behavior of frozen rigid bodies (BodyRigid), so they no longer ignore torques, forces, and impulses applied.
  • Fixed PhysicsIntersection for WorldSplineGraph segments.
  • Fixed handling of physical contacts for PlayerActor.
  • Fixed an issue with disappearing meshes related to physics update.
  • Fixed handling of physical masks for Water Mesh with a Body Water assigned.
  • Fixed intersection testing for the WaterGlobal object curved with a GeodeticPivot.
  • Changed the default Height value for details of ObjectLandscapeTerrain to 0, to avoid intersection issues resulting in incorrect placement of objects relative to the landscape surface.
  • You can now perform multiple Landscape texture draw operations (asyncTextureDraw) during a single frame.
  • Fixed an issue with resetting Texture Atlas Size values when saving a Particle System to a Node Reference or reloading a world.
  • Fixed smooth fading out for Environment Probes.
  • Switching a player now updates the current listener as well, so the sound will play from the right source (current player).
  • Fixed a crash on calling the Render::renderImageCube() method.
  • Fixed issues with memory deallocation when calling the shrink() method of Vector and String classes.
  • Fixed a crash on loading a mesh by an absolute path.
  • The Tracker tool now supports haze physical parameters.
  • Fixed minor boot screen flickering on loading.
  • Fixed a crash on the Engine re-initialization.
  • Fixed a crash on calling the SetMaterialParameterFloat4() method.
  • Fixed a crash on the Engine shutdown with OpenAL enabled, caused by the ALSoundManager destructor.
  • Fixed PgUp and PgDn keys in the Console as well as an issue with the Console::setActive() method, everything works as expected again.
  • C# components are now automatically saved to a *.node file when calling the World.SaveNode() method.
  • Fixed an issue with managing C++ components assigned to nodes having the LIFETIME_ENGINE option set resulting in deleting components on reloading a world with a subsequent failure to add a component to the node.
  • Fixed an issue with log messages still being printed to the stdout, when printing is disabled via the console command (log_stdout = 0).
  • Fixed issues with QWERTZ/AZERTY keyboard layouts in the AppVive plugin.
  • ZIP-archives can now be used as extern packages and loaded at run time.
  • Improved the default first_person_controller in the C# projects template. It now has a BodyDummy with a capsule shape assigned (Triggers Interaction is enabled by default). You can control whether to use the default body via the Use Object Body toggle in the Body section of the FirstPersonController parameters.
  • Upgraded Steam integration plugin to support Steamworks SDK 1.46.
  • Upgraded CUDA sample to support version 11.2.
  • Upgraded EasyBlend integration plugin to support Scalable SDK 7.0

End of Debian 8 Support

UNIGINE 2.14 is the last release with Debian 8 support (with the end-of-life reached on June 30, 2020). The new build environment is Debian 9 (GCC 6.3, GLIBC 2.24), which is backward incompatible with the outdated Debian 8 (GCC 4.9.2, GLIBC 2.19) and Astra Linux 1.5 (also based on Debian 8).

Raising the minimal spec enables us to upgrade some 3rd party libraries (such as Qt) which is required for further Editor and SDK Browser improvements and simplifies development and further upgrades.

The end-of-life date for Debian 9 is June 30, 2022. So, this build environment is planned to be supported for at least 2 years (unless critical bugs in the compiler behavior are found forcing us to raise the spec once again).


Asset Packages

UNIGINE’s community grows with a lot of new projects appearing, and so grows the demand for sharing or selling assets (from textures, models, and animations to whole project examples, and so on) as well as for re-using content from your other projects.

Introducing a mechanism of packages - collections of files and data from UNIGINE projects, or elements of projects, compressed and stored in a single file with the .upackage extension.

When unpacked, a package (like a ZIP file) maintains its original directory structure, as well as metadata about assets (links to other assets). So, the process of transferring content between your projects has become simpler and more convenient. Consider it as a step to the long-awaited Asset Store that is currently being developed actively. Meanwhile, you can already pack your assets, send them to other developers, as well as receive packages, and easily unpack their contents to use in your projects.

All dependencies for exported assets are resolved and added automatically, just check Include Dependencies. You can click on any exported asset in the list to check it out (each asset has its size displayed next to its name).

Light Baking Improvements

Precalculated (baked) lighting is an essential part of optimization for almost any project providing best balance between performance and visuals. To make the process of baking simpler and more convenient we have made a number of improvements for this release.

You can now set Lighting Mode for each surface to define its contribution to lighting: simply set Static or Dynamic for the corresponding types of objects (all related settings shall be auto-adjusted for you) or choose Advanced to configure everything manually.

All controls are always at hand now, baking process can now be launched right from the toolbar via the dedicated button with a quick access to settings just next to it:

The following progress bars are now shown in the viewport during the process of light baking enabling you to stop it if necessary:

The list of other light baking improvements includes:

  • Optimized light baking for static lights, now it takes less time preserving the quality.
  • Fixed VoxelProbe baking with the Use Sun Color option enabled.
  • Fixed baking of dynamic shadows for Voxel and Environment Probes as well as the first bounce of reflections for Environment Probes.
  • Fixed an issue with baking progress calculation sometimes leading to crashes on baking Environment Probes with the Сutout By Shadow option enabled.
  • Fixed OpenGL errors on baking lighting.

Voxel Probe Visualizer

Added a visualizer for voxel probes enabling you to quickly check lighting baked for each voxel as cubemaps projected onto spheres.

Filter Surfaces By Name

Any surface in your project can now be found in a snap! Searching for nodes in the UnigineEditor by name is handy, but what about surfaces? Imagine you have a CAD model with a hundred surfaces and you want to find that very one - this could be tricky before the new surface filter was added.

Moreover, you can now copy surface names via the corresponding context menu item.

Improved 2D Curves Support

2D curves a convenient instrument used to control various parameters changing over time now supports undo/redo operations and has become available for properties and C# components.

Other Editor Improvements

  • Improved browsing through folders with a keyboard in the Asset Browser window: current folder selection shall be restored after returning back to the previous level of the folder hierarchy.
  • Links to deleted nodes are highlighted red in the UI to help you find problems quickly.
  • Auto-correction of the decimal delimiter in the numeric fields (, -> .)
  • Asset dependencies are now resolved for script files (*.usc) as well when selecting the Show Assets Using This One context menu action.
  • Added an ability to quickly find nodes in the Editor by ID (full match only) to the World Hierarchy window.
  • Improved animation name handling when importing from FBX files: animations shall keep their names.
  • Fixed an issue with deleting keys in the Tracker tool on dragging them beyond the timeline (to the left or to the right).
  • You can now animate shadow distance visibility for lights via the Tracker tool.
  • Now you can import a pack of FBX assets with materials having the same name but unique textures (e.g., terrain tiles exported from a 3rd party software), avoiding name collisions and keeping all materials without any additional manual renaming (Add Asset Name as Prefixoption on import).
  • Relative paths specified for imported/exported assets shall be considered relative to the data folder.
  • Fixed re-generation of Landscape Layer Maps (lmap) with high-resolution masks (~8/16k) sometimes leading to artefacts due to corruption of mask data.
  • The Video Grabber shall no longer overwrite existing files that were grabbed during the previous session of the UnigineEditor.
  • The debug_direct_light material is now handled properly in UnigineEditor.
  • Fixed a crash on failing to load a property after building a C# project.
  • Fixed displaying the initial set of options for the Create Build tool.
  • Fixed black preview for textures with empty MIP levels.
  • Fixed target node parameter for PlayerPersecutor objects.
  • Fixed Editor hanging on material_reload console command.
  • Fixed issues with undo/redo operations in the Settings window.
  • Fixed camera control via expressions/tracks in the Editor viewport.
  • Fixed incorrect node selection when displaying asset dependencies via Show Assets Using This One.
  • Fixed an issue with deleting files having the same name as a folder or a mount point deleted just before the file deletion.
  • Fixed hotkeys in Curve Editor.
  • Fixed step calculation for 2D curves in the Curve Editor, sometimes leading to a crash when setting the maximum LifeTime value.
  • Fixed issues with axis selection for the translator manipulator used with the orthographic view.
  • Added a tooltip with internal texture name (from .basemat file) on hovering over a texture slot.
  • Rendering of the GlobalWater object shall now be toggled off when debugging of diffuse lighting is enabled (Rendering Debug → Diffuse Lighting) ensuring that the feature works properly.
  • Fixed applying wildcards to get a correct list of used assets for the Project Build tool.

Image Generator Updates


Syncker, our multi-channel rendering plugin, has got a number of improvements making it even faster, more reliable, and convenient.

We have optimized searching methods for synchronized nodes significantly improving performance of all operations that require scanning through the whole list (adding nodes, setting sync masks, checking if nodes are synchronized, etc. Processing of synchronized nodes was optimized as well with an extended use of multithreading. Displaying debug information for synchronized nodes has become faster and smoother as well. The list of other improvements includes the following:

  • Added synchronization of Viewport Masks for objects enabling you to display objects selectively across all slaves.
  • Added synchronization for physically based haze.
  • Fixed synchronization of Color Correction settings.
  • Selecting nodes in the Syncker Debug window will now highlight them with the visualizer in the viewport for your convenience.
  • Nested NodeReference nodes are now synchronized correctly.
  • Node’s scale is now taken into account by the Syncker when Interpolation mode is enabled.

CIGI Callbacks

The CIGIConnector now enables you to set callbacks to be fired right before sending a response to a request. This can be used to send additional data required by a host (e.g., velocities of the point of intersection for LOS/HAT queries which is useful in case of landing on a moving platform). A callback function has the following signature:
(bool &ret, IG::CIGI::CigiIGPacket *response, IG::CIGI::CigiHostPacket *request, IG::IGIntersection *intersection)

  • ret - boolean value indicating if the packet is to be sent or not;
  • response - the packet to be sent;
  • request - request for which a packet is to be sent as a response (can be nullptr);
  • intersection - additional info on intersection (if necessary).

Here is an example:

Source code (C++)
void AppSystemLogic::init_cigi()
    int index = Engine::get()->findPlugin("CIGIConnector");
    // check CIGIConnector plugin load
    if (index < 0)
    // get CIGI interface
    cigi = IG::CIGI::Connector::get();
    cigi->setSendPacketCallback(Plugins::IG::CIGI::CIGI_OPCODE_LOS_EXT_RESPONSE, MakeCallback(this, &AppSystemLogic::on_los_ext_send));
    cigi->setSendPacketCallback(Plugins::IG::CIGI::CIGI_OPCODE_LOS_RESPONSE, MakeCallback(this, &AppSystemLogic::on_los_ext_send));
void AppSystemLogic::on_los_ext_send(bool &ret, IG::CIGI::CigiIGPacket *response, IG::CIGI::CigiHostPacket *request, IG::IGIntersection *intersection)
    ret = false;
    Log::message("reject packet %d\n", response->getType());
    if (request)
        Log::message("request was %d\n", request->getType());
    if (intersection)
        Log::message("intersection was\n");
        if (intersection->object)
            Log::message("intersection object %s\n", intersection->object->getName());

The list of other IG improvements includes the following:

  • IG state is now saved and restored after reloading a database (database_reload command), so the current settings (entities, cameras, weather conditions, etc.) won’t be lost on resetting a world or loading another one.
  • Information on the current version of each IG plugin (and Syncker as well) is now available in the Engine’s log.
  • View_Definition packets are now processed and applied correctly on Slaves.
  • Extended the list of commands for the IG Debug mode (ig_state_save/load, ig_debug_switch_entity, ig_debug_visualizer_dephtest/screenspace/scale/duration). For more information please refer to the dedicated article.
  • Fixed incorrect range values returned by LOS Vector responses (extended and basic) if a request was made with a non zero min_range.
  • Added an ability to skip processing for certain CIGI packets and DIS PDUs via the following methods:
    Source code (C++)
    IG::CIGI::Connector::setProcessPacket(int cigi_opcode, bool enabled);
    IG::DIS::Connector::setProcessPacket(int pdu_type, bool enabled);

Demos and Samples

LiDAR sample has been improved with optimized rendering discarding unnecessary buffers and some performance boost. More comments were added to the source code for your convenience.

The following updates were introduced to the Art Samples suite:

  • Updated all Clouds samples and added a set of new ones illustrating the use of custom 3D textures for cloud shape formation.
  • Added Changing Time Of Day sample demonstrating the Use Sun Color option of the Voxel Probe.
  • Added an Animated Character sample demonstrating bone-based animation of a skinned mesh and replacing the Soldier demo.
  • Planar reflections were updated with the new Planar Reflection Probe implementation in various scenes (e.g., Interior sample).

Vegetation Add-On

The Vegetation add-on was updated with a set of trees and small plants, including various types of palms (queen, fan, nypa), asplenium, rambutan, decorative bushes and flowers, etc. Total count of vegetation species in the add-on has reached 37 types, most of them having from 2 to 20 variations.


Made additional Chinese and Russian subtitles to the English version of Technical Livestreams With Experts:

There is a set of new ultrashort HowTo quick tip videos in English, Chinese, and Russian:

Other Documentation Changes

Work In Progress 2021

We have focused on improving some legacy features (like GUI, splines, tracker, etc.) to make them shine the same way as other modules of UNIGINE do. And we keep on adding new functionality, as we have expanded our R&D team recently. There is a set of major and long-awaited features and improvements in development branches currently, and they are progressing fast (most of these features will be production-ready for you in 2.15 and 2.16) some of them are currently polished based on user feedback gathered.

Node-Based Material Editor

Earlier this February we have released an experimental build demonstrating a prototype of the new Material Editor enabling you to create your own materials visually without writing a single line of code by simply creating and connecting nodes building a graph! The prototype is advancing to the production-ready stage with a lot of improvements and useful features added, and polished to ensure smooth user experience.

ETA: 2.15.

DirectX 12 / Vulkan Renderer

Transition from DirectX 11 / OpenGL to DirectX 12 / Vulkan is very challenging in terms of backwards compatibility, and it is a paradigm shift as well. We are working on supporting this graphical APIs, however, the first experimental release is not to be expected earlier than the end of this year.

New Universal Animations System

It is hard to imagine a 3D application not using animations at all (character movement, camera control for cinematic cutscenes, dynamically changing materials, you name it).

We are currently focused on system design and internal API improvements to implement an advanced Animator tool in the future. Just a quick look at what we have done so far.

First, we have added a new file format (.animation) to store animations - unlike the current .anim format, it is xml-based and user-friendly (you can modify any key value you want). We have made animations independent, they are not bound to certain nodes, properties, or materials (no file names, guids, or anything), instead our new animations operate with abstract entities (like placeholders), enabling you to assign any existing node/material/property via the UnigineEditor or via code. This also makes transferring animations between projects simple (no migration required).

Multiple entities and hierarchies can be driven by the same animation, with an ability to change what exactly is to be animated in a snap - just by dragging nodes or materials to the corresponding fields in the UnigineEditor. With an advanced API, animations can be procedurally generated, configured, and managed at run time, as well they can be saved as assets to be used later. Another important thing is that you will be able to animate virtually any parameter available via API, even new ones that will be added with each new release, automatically! Interpolation and advanced blending functionality will also be at your disposal offering you unprecedented flexibility and capabilities.

Old .anim and .track files are to be completely replaced by the new universal .animation format. The new Tracker tool will support this format enabling you to animate your objects right in the UnigineEditor with an ability to manage animations imported from FBX assets.

Here is an example of simplified control over animations via code (the final version may differ):

And a video demonstration of the current state of research:

ETA: 2.16.

New In-App GUI

Current GUI implementation has a number of weak points and limitations. A new GUI system implemented using the component-based approach is to replace the current one and make it much more flexible and easier to use. Simplified widget transformation and scaling, improved intersection testing with advanced flexible control, stylesheets, better layout based on components (horizontal, vertical, grid, or panel), visual and logic components for widgets for advanced customization to fit the needs of any project.

ETA: experimental release in 2.15, production version in 2.16.

Editor Plugins

The ability to extend functionality of the UnigineEditor was added in 2.10. We’re now upgrading the UnigineEditor Plugin System and improving public API, to make this instrument simple and more convenient so that you could create your own plugins to customize the Editor for your project-specific needs, e.g., add new menus, windows, toolbar commands, sub-modes, define how properties are displayed, etc.

ETA: beta release in 2.15, production version in 2.16.

Full-Planet Solution

Full round Earth solution for flight simulation and similar tasks (continent-wide road network planning, precise weapon simulation, etc). The power of UNIGINE's 64-bit coordinates precision is utilized here to its full extent.

ETA: beta release in 2.15, production version in 2.16.

New SDK Browser

UNIGINE is made to help bring your projects to life. Most of your activities revolve around projects, you create, configure, and upgrade them, you also need to have all necessary templates, samples, demos, and additional content at hand. SDK Browser is a hub that connects you to the world of UNIGINE and streamlines all the processes. We’re putting a lot of effort into making all processes as smooth and intuitive as possible and switching to a new technology stack to make the product even more robust and secure.

ETA: 2.15.

More details on the roadmap for upcoming releases can be found on the official forum.

Build: ()