UNIGINE 2.20: Optimizations, UI Toolkit, VR/XR Improvements, Gaussian Splatting

Rendering Enhancements

Improved Upscalers & Vulkan Support

This release brings major improvements to our upscaling capabilities, ensuring sharper visuals and better performance across platforms and rendering backends.

• DLSS now supports Vulkan on both Windows and Linux, unlocking high-quality upscaling across even more configurations.
• FSR (FidelityFX Super Resolution) is now fully supported on Windows Vulkan, expanding its reach beyond DirectX.
• FSR has been updated to version 3.1.3, bringing improved image quality, better temporal stability, and reduced ghosting.
• NVIDIA Streamline SDK has been updated to version 2.7.32 now supporting up to DLSS4, offering enhanced visual fidelity, faster performance, and improved support for the latest GPUs.

These updates make it easier than ever to balance performance and image quality, whether you're targeting high-end systems or optimizing for lower-powered hardware.

Enhanced Impostors

This release brings a new Octahedral mode for billboard impostor generation, offering a more efficient and visually accurate alternative to the existing Spherical mode.

Octahedral mapping provides a uniform distribution of view angles, significantly improving the visual fidelity of impostors - especially when viewed from oblique angles. Unlike the traditional spherical layout, which stores views in a simple grid and can suffer from distortion or uneven coverage, Octahedral mode packs view directions into a compact and distortion-minimized format using octahedral projection.

Key advantages of Octahedral mode:

• Improved angular coverage - more consistent detail across all viewing directions
• Better texture space efficiency - reduces redundancy and wasted pixels
• Smoother view transitions - enables higher-quality blending between views
• Optimized for GPU sampling - compatible with view-dependent shading and normal maps
• Ideal for high-fidelity impostors - great for mid-distance objects where detail matters

Whether you prefer the simplicity of Spherical mode or the precision of Octahedral, you can choose the right impostor generation mode based on your project's needs. Both modes are fully supported and integrated into the existing pipeline. To switch between modes, just select your preferred layout in the impostor generation settings.

Voxel Probe Updates

More flexible settings have been added for controlling the influence of the voxel probe on materials with subsurface scattering.

Refined Sharpen Effect

The Sharpen effect, used to enhance edge detail and make visuals appear crisper or more defined, has been improved in this release to produce a more natural look on thin and bright objects.

Indirect Specular Normalization

A new Global Illumination setting has been added to adjust indirect reflection color and brightness to match the indirect diffuse lighting. The setting affects both matte and glossy reflections.

This feature works well for such cases as dark indirect diffuse lighting under a table (set by a lightmap, voxel probe, or in another way) to make the indirect specular reflection in that area also appear dark.

Such an approach is commonly used in many games, especially on consoles, because it's a performance-friendly way to eliminate overly bright reflections in dark areas of the scene.

Agility SDK Integration (Latest DX12 Features For Older Windows 10 Releases)

To facilitate transition to new DirectX 12 features (such as hardware ray tracing, bindless textures, and a lot more) without requiring users to update their operating system, we have integrated the Agility SDK. This means that even if you're running an older version of Windows (or a specific build), you can still have the latest DX12 features implemented in the engine that would otherwise be unavailable without upgrading Windows itself.

This raises the minimum OS requirements to Windows 10 build 19041.804, but this is a fair price to pay for delivering newest DirectX12 features to any Windows 10 (February 2021 update or newer) or Windows 11 machine.

Clouds Rendering Improvements

• Fixed rendering of ObjectSky and ObjectCloudLayer in the Render Before Transparent mode. In Sort Transparent mode, ObjectCloudLayer will now always be rendered in front of ObjectSky, while in Render Before Transparent mode, it will be rendered behind ObjectSky. Incorrect color blending that was noticeable when rendering the Sun behind the ObjectSky has been fixed as well.
• Fixed rendering order of Billboard-based stars relative to clouds. A new Rendering Clouds Order option has been added to transparent materials enabling you to force rendering of these materials in front of or behind the clouds.
• Fixed issues with incorrect depth sorting of ObjectCloudLayer with non-transparent objects for Downsampling, Interleaved, and Panorama rendering modes.
• Fixed incorrect planet shadow casting and visual artefacts on clouds curved using a Geodetic Pivot.
• Fixed visual artefacts (jitter, flickering) at the horizon when rendering Cloud Layers with Interleaved Rendering mode enabled.
• Fixed rendering of shadows from the clouds when the sun is near the horizon (sunrise and sunset).

Other Rendering Improvements

• Fixed rendering of shadows from Projected light sources for transparent objects (in case the Transparent Shadow option is enabled).
• Fixed visual artifacts on Grass-based impostors caused by incorrect depth processing in the Auxiliary buffer.
• Fixed an issue with Decal sorting in the Auxiliary buffer that caused their order to be shuffled when toggling them on and off or reloading the world.
• Specular reflections produced by Raymarching Probes and SSR for zero-roughness surfaces now look correct again.
• Fixed calculation of Bent Normals eliminating excessive noise.
• Resolved an issue with SSGI upscaling ensuring correct functionality across all SSRTGI resolution settings.
• Added support for rendering an Environment Probe in Additive Blend mode on top of a Voxel Probe to simulate the bounce of global illumination (GI) from the sun. An Environment Probe having a higher Order value will be rendered over a Voxel Probe with a lower Order value. To enable this functionality for an Environment Probe, check the new Render Above Voxel Probes option for it.
• Fixed an issue causing a failure to render transparent materials in case SRAA is active.
• Fixed writing to the Auxiliary buffer for graph-based materials assigned to Mesh Clutters.

User Interface

In-Game UI Framework With Visual Editor (Experimental)

Up to 2.20, building user interfaces was not a drag-and-drop experience - it required familiarity with the API and writing a fair amount of code. Thanks to contributions from our talented community, we now have a powerful Toolkit, implemented as a plugin. It currently includes two key components: UI Designer and Runtime Editor.

UI Designer transforms UI development into a visual process, enabling artists and designers to create interfaces without needing extensive coding knowledge.

Built on the flexible Widget API, the UI Designer replaces manual coding with intuitive drag-and-drop editing. You can assemble layouts interactively and see your changes rendered live directly in the viewport.

The following essential interface features are included:

• Rich UI Library: Labels, input fields, checkboxes, progress bars, tables, sliders, windows, and much more ready to customize
• Smart Layout Tools: Pixel-perfect alignment with grid snapping, anchors, and pivot controls
• Seamless Editor Integration: Undo/redo, copy-paste, multi-select, and resolution switching for smooth workflow
• Hierarchy & Organization: Manage complex UI structures with a tree view
• Custom Materials & Shaders: Apply advanced visuals directly to UI elements
• Component-Based Workflow: Works with both C++ and C# Component Systems
• Sample Projects Included: Comes with a set of usage examples to help you get started quickly:
  • Elements displays all available types of UI elements.
  • Epic Menu demonstrates a menu with animations, transitions and sound effects.
  • Glass Material and Custom Materials show how to apply various materials.
  • Radio Buttons and Toggled Buttons illustrate various types of buttons.
  • Rectangle Selection illustrates how to make a UI element selected by highlighting a rectangular area over it.
  • Localization sample demonstrates how to switch UI to a required language version.
  • Show/Hide Animation displays available types of animating a UI element.

Runtime Editor is a lightweight in-game tool for live debugging. Inspect nodes, explore components, run test scripts - all without stopping your application.

The Toolkit add-on is aimed to simplify your workflow and save development time. More modules will be added over time to expand the add-on functionality - all with the same goal: helping creators do more, faster, and with less struggle.You can download it from our Add-On Store for free, it is available for all SDK editions.

Multiple Widget Updates

• Added support for controlling the background texture of widget containers (WidgetVBox, WidgetHBox, and WidgetGridBox), including optional 9-slicing and multiple filtering modes. This simplifies the creation of custom-textured GUI panels. The API has been extended; please refer to the API Migration Guide for details.
• Fixed an issue with applying DPI scaling correction in the fullscreen mode.
• Fixed DPI scaling issues in UnigineScript utils.
• Fixed an issue with the Widget::getTextRenderSize() method in some cases resulting in a wrong size value returned. Use Widget::getTextUnitSize() to get text size in logical units (device-independent pixels). For more information please refer to the DPI Scaling article.
• Gui::setExposeSpeed() can be set to 0 now, meaning no animations (fade in/out) will be applied when widgets appear. This fixes the problem when no widgets were rendered in the first frame.
• Fixed issues with GUI fonts, adjustment of digits in certain fonts, and rich text image scale calculation.

Gaussian Splatting Import (Experimental)

Gaussian Splatting is a modern rendering technique for visualizing point cloud data, widely adopted in real-time applications such as photorealistic reconstruction, AR/VR, and game engines. This release introduces experimental support for importing and rendering Gaussian Splats in UNIGINE via a plugin to be available in Engineering and Sim SDK editions.

To visualize splat data, create a dummy node in your scene, assign the gaussian property to it, and specify the path to a *.ply file.

A new Gaussian Splatting sample has been added to the C++ Sim Samples suite.

VR/XR Improvements

In this update, we've made significant strides in improving the overall VR and XR experience with a number of features and optimizations. Here's a rundown of the latest enhancements:

Eye Tracking Support in OpenXR

We've integrated eye tracking support in OpenXR (including XR_EXT_eye_gaze_interaction, XR_FB_eye_tracking_social, and XR_VARJO_foveated_rendering extensions), allowing more immersive and personalized user interactions. With eye tracking, VR applications can now detect and respond to where users are looking, enabling more intuitive control and providing new opportunities for user interface design, gaze-based navigation, and enhanced realism in virtual worlds.

We've implemented our own composition system for this feature, enabling support for any HMD and OpenXR runtime combination that provides Eye Tracking data through any of the available Eye Tracking extensions.

Dynamic Foveated Rendering for OpenXR

To further optimize performance, we've implemented dynamic foveated rendering for all OpenXR runtimes. This rendering technique intelligently reduces the resolution in peripheral vision areas while maintaining high fidelity in the center of the user's gaze. This not only boosts performance but also reduces GPU workload without compromising visual quality where it matters most, enhancing overall immersion and efficiency.

For this release we've also refined Screen-Space Haze Global Illumination specifically for foveated rendering. This improvement enhances lighting and shading effects, ensuring a more realistic and visually pleasing experience, especially in areas of the scene where foveated rendering is applied.

Mixed Reality Improvements

We've added basic Mixed Reality support for Oculus 3 and Varjo XR-3 via OpenXR. Mixed Reality for Varjo has also received a number of fixes and updates improving stability and ensuring better tracking, rendering, and overall functionality in MR applications using Varjo devices. The following extensions are now supported: XR_FB_passthrough, XR_VARJO_view_offset, XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND, XR_ENVIRONMENT_BLEND_MODE_ADDITIVE. Chroma-keying and some other Varjo features are not yet available but are to be added in the upcoming releases.

Per-Eye Camera Adjustment

You can now adjust individual per-eye offsets for the virtual cameras to be positioned correctly in your custom setups. Different scriptable materials can also be assigned per-eye now, customizing the view and adding more realism with asymmetric visual processing (e.g., to calibrate lens distortion corrections, add some artistic effects, or even to simulate visual impairments).

FOV for both eyes can be adjusted as well providing even more flexibility.

These features enable you to achieve realistic simulation of headsets with cameras mounted on the side of the head, or having a narrow field of view, like some Night-Vision Goggles.

OpenXR Input System Improvements

The OpenXR Input System has received a number of updates addressing input handling and device compatibility, for smoother interaction across different controllers and input methods, making VR experiences more responsive and intuitive.

OpenXR Hand Tracking

VR Template now provides built-in, native support for hand tracking based on the OpenXR Standard. This feature is integrated into the engine's VR system (no extra plugin needed) and supports any OpenXR-compatible device that offers hand tracking capabilities.

Better OpenVR Device Connection

We've made improvements to the OpenVR device connection system, addressing connectivity issues and ensuring smoother device setup and connection during VR sessions, ensuring proper detection of connected OpenVR-compatible devices, preventing them from being ignored by the Engine.

Optimizations for Adaptive Exposure in VR

We've optimized the Adaptive Exposure feature in VR to create a more natural and consistent visual experience. This adjustment ensures that brightness and contrast automatically adapt to changing lighting conditions in the virtual environment, providing a more comfortable and balanced visual experience in dynamic settings.

New HMDs for VR Emulation

The VR emulation scope has been extended with a set of new HMDs (Head-Mounted Displays) including the most popular ones (HTC, Valve, Oculus, Meta, Varjo, Pico). This allows developers to test their applications with a broader range of devices, ensuring compatibility and performance across different VR platforms and headsets.

Multiple Optimizations

The SDK has undergone a series of optimizations aimed at enhancing overall performance and visual quality. Below is a summary of optimization results across various scenes, compared to 2.19.1.2.

Multithreaded Shadows Rendering (DirectX 12)

Shadows are often among the most performance-intensive parts of real-time rendering especially in content-heavy scenes. The multi-threaded rendering mode (available on DirectX 12) now fully supports shadows. Previously, shadow rendering was done sequentially in a separate thread, but now shadows from multiple light sources and even shadow cascades can be rendered in parallel. This mode provides a significant boost in CPU performance and increases FPS.

Our tests on a complex scene (containing 89 light sources, a total of 176 493 surfaces, and 168 465 surfaces for shadows) performed on various PC configurations have indicated up to x3 (depending on the number of cores) CPU performance boost.

Omni and Projected Lights Optimized

We have optimized rendering of Omni and Projected light sources for better performance. They are now represented as meshes, so depth testing is performed for them. As a result, wasted calculations are eliminated. Sizes of bounding boxes for Projected light sources have been reduced, ensuring more efficient bound-based culling, their boundaries now remain perfectly tight even with a wide FOV.

Occlusion culling accuracy has also been improved for these types of light sources making it more efficient and improving performance for optimized scenes with occluders due to reduced rendering load. The performance gain from this optimization depends on the specific scene setup (lights, occluders, etc.), as for our own test scene containing 198 light sources (Omni and Proj) in 2.19.1 occluders culled only 145 of them, while in 2.20 they cull 182.

Average performance gains on both real and heavy synthetic scenes ranged from 16% to 25%, depending on the specific scene setup.

Optimized Clusters

Large-scale scenes that simulate vast real-world environments, common in professional-grade simulators contain a lot of Mesh Clusters - optimized objects designed to render massive amounts of geometry ensuring high performance even in complex scenes.

In this release, we've significantly improved their performance and reduced both memory and disk space usage. Mesh Cluster data is now stored in a compact binary format, separate from the XML *.world and *.node files, resulting in faster load/save times, making it especially beneficial for worlds with numerous clusters.

For a project with heavy cluster usage:

• RAM consumption during world loading is reduced by 5-10% by skipping XML parsing.
• World loading is 15–20% faster in real projects, and up to 4x faster in synthetic tests.
• Saving is 3x faster (real world) and up to 16x faster (synthetic tests).
• Scene files are significantly smaller, with size reduction proportional to the number of clusters.

Binary cluster data is now saved in a dedicated shadow folder:

mount://.binary_nodes_data/<node_or_world_guid>/clusters

This data is ignored by the Editor and therefore ensures your project directory stays clean, as it won't generate .meta files and clutter up your workspace.

Migration is automatic: saving a world or node with clusters will generate the new binary data. Legacy data will be converted accordingly. But please note that switching to the binary storage format is not backward-compatible.

Optimized RAM Consumption

As a part of our ongoing effort to make the engine more efficient and scalable across a wide range of hardware - from high-end PCs to memory-constrained environments, we have optimized RAM consumption for Particles, Billboards, FFP (Fixed-Function Pipeline), and Visualizer.

Mesh Compression

Geometry data in *.mesh files is now stored in compressed format, along with edges and the spatial tree data (now built automatically during mesh export and saved with the file, if they were not generated beforehand). Previously, generation of edges and the spatial tree was performed at runtime, which could cause performance spikes.

This fact has also improved mesh memory estimation. Having edges and the spatial tree data makes it possible to embed precise RAM requirements to the mesh file header to be used by the streaming system. Earlier, memory usage was estimated based on file size, which was often inaccurate.

Procedural Mesh Modification Optimizations

Previous implementation of procedural mesh modification looked rather simple: switch to procedural mode -> set a new mesh -> apply. But it had its pitfalls and usage restrictions that could potentially cause serious issues. E.g., streaming for meshes in procedural mode was not available, so they had to be constantly kept in memory. In large-scale procedural generation scenarios, this could lead to excessive RAM and VRAM usage - sometimes even resulting in crashes.

This update extends API and offers multiple procedural modes, each optimized for different usage scenarios and performance levels to tailor your solution to any specific case, giving you more flexibility and supporting everything from superfast minor runtime tweaks of several small meshes like a mesh-based arrow pointer to large-scale procedural runtime generation, either with streaming from RAM or disk, either in asynchronous or forced mode.

For more details please refer to API Migration Guide, we have also added new Mesh Modification samples to both C++ and C# suites.

DX12 Memory Allocation Improvements

Unigine 2.19.1 was the last release to support DirectX11. Transition to DirectX12 as the primary graphics API provides more control to developers, allowing them to optimize performance more effectively. This "freedom" translates to the potential for greater performance gains and more efficient resource utilization on capable hardware, but it also requires more careful management from the developers. DX12 unlike DX11 does not try to handle optimizations automatically, but it is less tolerant to unoptimized user's code and lack of understanding, and it does not forgive errors. This transition has exposed a number of issues potentially causing spikes, performance degradation, excessive memory consumption due to incorrect API usage, and misconfiguration of the previous implementation of memory allocator.

In this release we've optimized memory management under DirectX 12, addressing a number critical issues and aiming to make it more developer-friendly and forgiving while keeping performance equal to or better than DX11. The new memory allocator implementation, based on advanced smart heap pool management, significantly improves stability, reduces peak VRAM load, removes memory leaks, spikes, and crashes, and compensates for unoptimized or imperfect code. All this comes at the cost of about 128Mb of additional memory consumption, but that's a fair price.

We have also implemented dynamic texture memory pooling optimized for high-dynamic texture usage patterns, smoothing performance during creation, use, and destruction of texture resources. This optimization also takes about 128MB of memory.

Average memory usage reduction on our test scenes comprised about 50% depending on the degree of content and code optimization in the project, with significant gains for unoptimized memory-wasting code.

Highly-qualified developers having enough skills and confidence in their fully optimized pipelines and code, who don't need any assistance and smart-type behavior, can reduce heap pool sizes or even set them to 0 taking all the responsibility for managing memory resources.

Frame Allocator has also been optimized to reduce peak memory consumption and make the whole process smoother now allocating RAM in smaller chunks and reusing memory across frames. A shared index buffer is used for particles, grass, and billboards - reducing memory usage across object types. These optimizations ensure elimination of spikes and prevent crashes caused by excessive memory consumption.

C# Component System

Designed to work natively with UnigineEditor, the C# Component System supports clean architecture and smooth workflows - now featuring a number of quality-of-life improvements focused on developer comfort and efficiency.

Quick Blank C# File Creation

Not all application logic should be implemented inside components - sometimes you need to define an interface, create a utility class, split logic into partial classes, or add a helper class that supports your architecture.

Now you can quickly create blank C# files directly from the Asset Browser without switching to your IDE.

Interface and Abstract Class Support

C# Component System now supports interfaces and abstract classes, empowering programmers to create more modular, testable and maintainable architectures with loose coupling and seamless integration of Dependency Injection.

You can expose interface or abstract class types as component parameters, defining behaviour contracts, and assign concrete implementations directly via the Editor.

For more details, please refer to this article.

Component Access by Name

Managing components via API has become simpler. You can easily add, access, or remove components using AddComponent(), GetComponent(), and RemoveComponent() methods by names.

 AddComponent(player, "HealthComponent");
 ...
 if (health < 0)
 {
    RemoveComponent("HealthComponent");
 }

The list of other C# improvements includes the following:

• Added a set of C# marshallers for Widgets, Textures, and Materials.
• You can now use third-party libraries in your C# components - just add a reference to a library to the *.csproj file manually or via IDE.

CPU Multithreading Improvements

As the engine continues to leverage the power of multithreading internally, it would be unfair not to extend those capabilities to developers as well. The updated threading API enables tighter integration with custom workloads, exposing fine-grained control over task execution while maintaining deterministic behavior across all engine systems.

The updated AsyncQueue class lets you schedule operations across multiple threads, setting priorities, and creating clear, deterministic execution pipelines, whether you are handling intensive CPU-bound logic or low-latency tasks. So, you can now organize your own task system and implement CPU shaders for custom data processing using both the C++ and C# APIs - simply and efficiently, with minimal complexity and programming overhead.

A broad set of atomic operations and synchronization primitives has also become available in C++ API, including mutexes, spinlocks, and lock-free types. You can choose between automatic context-aware behavior or full manual control, making it easy to scale from lightweight coordination to complex multithreaded workloads. For more details please refer to API Migration Guide.

File System Improvements

Long File Path Support in API

Large projects often involve deeply nested directory structures and long, descriptive file names - resulting in extremely long file paths. Starting with this release, the Engine's File System API fully supports extended path lengths, eliminating previous limitations and ensuring reliable access to any resource.

Absolute Path Support for FileSystem::addVirtualFile

The Engine now supports absolute paths in the FileSystem::addVirtualFile(), making it easier to work with files located outside the project directory. This allows you to mount external assets directly, without copying them into the data folder. The Engine automatically normalizes paths, and converts them into virtual paths.

Streaming for Password-Protected and Compressed Archives

In final builds of UNIGINE-based applications, content is typically packaged into UNG archives, often with password protection. Advanced streaming of packages introduced in 2.19 had a limitation - it didn't work with compressed and password-protected archives. In this release we have removed this limitation. Fast data reading from such UNG-packages has been implemented, with zlib-compression removed, as it is rather slow for runtime. The content of the package is now selectively compressed based on file extension: .json, .xml, .txt, .node, .world, .prop, .track, .mat, and .basemat files are compressed by default (as they do not require streaming), while .lmap, .texture,.mesh and other binary files are packed as is, as they have their internal compression. Applying compression to these files is not recommended, it won't provide significant size reduction but will surely cause performance drops due to streaming limitations (however, even with compression enabled, such files are loaded faster than in 2.19.1, especially on Windows).

The ung_x64 archiver tool now interprets the -c flag as the list of file extensions to be compressed (e.g., -с "json xml txt node world prop track mat basemat"). A new -s flag has been added for your convenience, it displays compression stats for all extensions, showing you the profit of using compression for your content.

Other Engine Improvements

• Implemented batch calculation of intersections with Landscape Terrain for Clutters and Grass providing up to 10x loading boost.
• The Fast Shutdown option has been removed and the Engine now behaves as if Fast Shutdown is always set to 1. Please note that re-initializing the Engine again after shutting it down (call init() after shutdown()) without restarting the application is no longer possible!
• Fixed a crash caused by recursive DPI scaling when dragging a window between displays with different DPI scale settings (Windows 10).
• Added an ability to control the VSync swap interval for DirectX 12 (e.g., swap buffers every n-th refresh interval of the monitor) via the d3d12_vsync_interval console command.
• Fixed a crash on deleting a texture that was created by the user via API and assigned to a material.
• Fixed a number of force feedback issues ensuring stable support of major functions on most widely used devices. API has been extended (for more details please refer to the API Migration Guide).
• Fixed issues with calculating mouse delta when receiving raw mouse input in Absolute mode. Added emulation of mouse events for touchpad input on Linux to ensure consistent behavior with Windows, allowing camera control and widget interaction via the touchpad.
• Removed texture formats not supported by the hardware: RGB8, RGB16, RGB32, RGB16U, RGB32U, RGB16F, RGB32F, R24B8, and D24. The Engine has always internally replaced 3-channel textures (e.g., RGB8, RGB16, RGB32) with their 4-channel equivalents: RGBA8, RGBA16, RGBA32.
• Replaced D24S8 with D32S8 on Vulkan. RGB565 and RGB5A1 now have real native format instead of RGBA8. Use of RGBA4 as a render target is forbidden.
• Fixed a crash on changing a base material parameter in case the base material of the material's parent differs from its own base material. Such issues will be automatically resolved by taking the base material of the parent.
• Fixed memory leaks in ObjectMeshStatic on reloading the world.
• Fixed an issue with a possible use of uninitialized resources sometimes causing a crash when creating windows during plugin initialization.
• Fixed a crash on rendering a preview after importing some USD assets containing empty surfaces (Vulkan only).
• Fixed a crash on saving a world when displaying texture buffers used by the renderer (render_show_textures = 1).
• Fixed a crash on creating a Skinned Mesh object with an unnamed surface.
• Fixed a crash on changing the position of an object with a physical body using setWorldPosition() inside a Contact event handler triggered for this body.
• Fixed an issue with baking lighting for sources referring to a missing target texture (an invalid target texture GUID).
• Fixed a crash on resizing surfaces of Static Meshes with a modified value of the Bound Scale parameters.
• Fixed an issue with mask-based object placement when using Geodetic Pivot, which caused a noticeable offset between objects and their corresponding mask.
• Fixed behavior of windows in Modal mode. Modal mode is now available for separate windows only. These windows cannot be docked to others or used to create new groups. Window modality cannot be changed while in fullscreen mode. Switching a modal window to fullscreen automatically clears all modal associations.
• Fixed issues with clearing cutout intersection data for Grass and Clutters (World and Mesh) causing a crash in some cases.
• Fixed incorrect compression of Landscape Layer Maps using lossy algorithms on Vulkan.
• Fixed a crash on changing Shadow Cascade parameters of the World Light.
• Fixed a crash caused by the presence of a subdirectory named data within the data directory.
• Fixed the logic for copying nodes with the Always Update flag enabled, which previously could lead to crashes.
• Fixed an issue with water patch culling that caused parts of the water surface to be skipped during rendering when using certain combinations of Water Visibility Distance and camera Far Clipping distance.
• Fixed a crash that occurred on Vulkan when selecting multiple objects with many surfaces while the Selected Surface TBN visualizer was enabled.
• Improved water rendering sequence resolving various issues and visual artefacts (including rectangular artefacts on fast camera panning, opaque objects rendered in black in the first frame and others).
• Fixed active GPU detection on Linux, resolving issues when running two Engine instances simultaneously on separate X servers with identical GPUs.
• Fixed a crash on editing the terrain in the Landscape Paint Mode.
• Added the ability to compress heightmap textures of the Landscape Layer Maps both via API and UnigineEditor (see API Migration Guide for details).
• Fixed a crash in some cases occurring when loading large 16K EXR images, issues with thumbnails generation for 16K textures have been fixed as well.
• Fixed an issue that caused overwriting the value of the Near Attenuation parameter of the Omni light source with the value of its Near Attenuation Gradient Length parameter.
• Fixed an issue with node loading recursion resulting in a stack overflow crash when saving a Node Layer containing a single Node Reference.
• Fixed an issue where the Bound Scale parameter was not properly reset after being changed, causing the last value to persist even when the parameter was no longer available.
• Added support for OpenXR 1.1.47.

UnigineEditor

Search Improvement

Imagine creating and editing a digital twin of a real megacity - millions of objects, complex hierarchies, and countless parameters. Searching for objects in the Editor even in a well-organized structure would be an overwhelming task without the World Nodes Hierarchy search that every artist uses multiple times a day. But what about managing complex structures of parameters, or browsing extensive menus like Render Debug? Quickly locating what you need in these areas can be just as crucial.

UnigineEditor in 2.20 offers a significantly improved search experience across context menus, the Parameters tab, and drop-down comboboxes like Helpers or Rendering Debug (the search box appears when a menu contains more than five items).

Search results are more intuitive: you can use full or partial names, abbreviations, or combinations of word beginnings, regardless of case.

Sub-items in menus are displayed together with their parent group name for better clarity.

In the Parameters tab, matching elements are highlighted while others are dimmed but remain interactive. The matching drop-down element is outlined with a green dotted line for quicker navigation.

Faster Shadows Baking

Baking lighting for large, complex scenes with a lot of light sources can be quite time-consuming. Moreover, you need to re-bake lighting each time after moving light sources or changing their parameters, spending even more time that could be better spent on more productive tasks.

In this release, we have greatly sped up the shadows baking process, especially when caching shadows from many light sources. The speedup affects both the initial bake and subsequent updates to the depth texture.

Baking times were measured on a dense urban scene with daylight illumination (1K+ light sources) showing a 7.5x boost of the initial bake along with a 17x boost of subsequent re-baking.

Property UI Optimization

Modeling real-world scenarios involve complex logic and operate with a vast number of adjustable parameters stored inside properties. As property files grow in size and complexity they can become rather heavy to handle. We've significantly optimized property loading delivering up to a 5x boost for large files and ensuring smooth interaction with no UI freezes for faster, uninterrupted workflow.

Improved UI for Physical Shapes and Joints

The UI for configuring physical Shapes and Joints has been redesigned in line with the list of Surfaces, making it more intuitive and convenient, with quick navigation and copy/paste functionality, simplifying management of complex physical setups.

Multiple Material Graph Editor Updates

Material Graph Editor has got a lot of updates and QoL improvements making it more stable and convenient to use, focusing on many aspects from polishing simple operations to simplifying management of huge graphs with complex structure and numerous parameters.

You can now add parameters right via the Create menu, which is especially convenient for materials having a complex hierarchy of parameters.

On selecting a parameter in the list the corresponding node(s) in the graph will be highlighted as well, focusing your attention and making it easier to find the ones you need.

One of the most convenient things saving you a lot of time on creating complex graphs is that you can now clone a graph node retaining all its connections (Ctrl+Shift+D). In case you don't need to keep the connections, simply clone the node using Ctrl+D.

The list of other improvements includes the following:

• You can now add existing Portals by name via the Create menu.
• For each parameter you can specify a condition (Activity Condition) required for this parameter to be active, providing flexibility to implement complex conditional structures (show/hide certain parameters depending on selected options).
• On dragging a texture to the graph the Texture node will be added along with the corresponding sampler (SampleTexture) automatically.
• You can reconnect edges to other inputs by simply dragging the corresponding connectors.
• Multiple selected nodes are now disconnected together.
• Fixed a crash on removing words in WidgetEditText via Ctrl + Backspace that particularly occurred in Material Editor as well.
• Fixed a crash on adding a subgraph with an invalid Texture node to the material graph.
• Changing the type of a material parameter now preserves its current value or adapts it to the new type when possible.
• Added a new graph-based material option Bound Mode that allows choosing an alternative way of expanding bounds of objects using this material by specifying Min and Max points.

Tracker Updates

In parallel with a major overhaul of the Animation System, we've also made some updates to the currently used Tracker and fixed a number of issues to keep the tool functional and improve its reliability. Here's a list of fixes:

• Tracker now correctly displays all stored parameters. If the target node, material, or property is missing or deleted, the parameter is highlighted in red, and the track loads without errors.
• Error logging is now more concise.
• Fixed a node removal processing issue that caused a node to remain visible in the viewport after removal during the looped playback, in case a track for the node's Enabled parameter was added.
• Fixed a crash that occurred when double-clicking the manipulator plane while adjusting a node's position.
• The Select Node button now works correctly for tracks.
• Node icons in Tracker have been updated to match those in the Editor for a consistent experience.
• Fixed an issue where the selection visualizer remained active even after the node was deselected.
• Node Reference handling improvements:
  • Track files now properly store parameters that modify the content of Node References.
  • Editing and applying changes to Node Reference parameters no longer causes unexpected behavior.
  • Fixed issues with processing of Node References converted from other node types (not originally created as Node References).
  • The content of a Node Reference selected in Tracker is now displayed as expected.

Other UnigineEditor Improvements

• The window layout of UnigineEditor is now automatically saved after any changes, so you won't need to re-arrange everything in case of an unexpected shutdown or crash. An issue with resetting the layout has been resolved as well.
• Fixed an issue with generating an extra skeleton copy (Rigid bodies and collision shapes) at the origin (0,0,0) on creating or loading bones hierarchy for a RagDoll body.
• Fixed an issue with reloading property files after changing a C# script file, sometimes resulting in a failure to update components after making changes to classes they inherit from.
• Fixed a crash that occurred in some cases on loading a world with the Settings window opened.
• Fixed a crash that occurred on refreshing the Content Profiler via the Refresh button.
• Fixed a crash on removing a collision shape in case it was selected in a locked Parameters window.
• Fixed a crash on using a brush to paint a Mesh Cluster opened for editing. In this case a dialog now appears prompting the user to save changes before painting.
• Axis visualization is now available in Animation preview.
• Fixed an issue with cloning Node References that in some cases reset property parameters storing paths to nodes inside these Node References.
• Fixed an issue with incorrect baking of normal and translucency maps for vegetation in the Impostors Creator tool.
• Fixed an issue with removing properties and materials assigned to nodes via absolute paths on saving. However, please be aware that using absolute paths is strongly not recommended, as moving or renaming files will break all references to them. It is safer to use assets instead, ensuring stable referencing via GUIDs that are unaffected by file renaming or moving.
• Improved thumbnail generation process fixing a number of issues and eliminating crashes.
• Fixed focusing on selected nodes in the viewport with the 'Center' pivot point selected.
• Fixed a number of issues associated with importing of textures (embedded into FBX containers), as well as with decompression of NPOT textures.
• The Randomizer tool no longer changes the order of selected nodes in the World Nodes hierarchy after clicking Replace.
• Fixed an issue with DPI scaling that prevented the Editor from opening on a secondary display after startup, leaving only the system tray icon and background processes visible. A set of issues associated with different DPI scaling settings on primary and secondary displays.
• Fixed an issue causing the Edit option to become unavailable in the context menu for a Node Reference while another Node Reference is being edited.
• Fixed an issue with exporting selected hierarchy of scene geometry to a .mesh file sometimes resulting in a crash.
• Fixed issues with incorrect application of lightmaps after reimporting FBX models.
• Fixed a crash that occurred when creating a Node Reference by dragging a brush-editable object into the Asset Browser while Texture Paint Mode was active.
• Fixed a crash on reloading a world after reloading the File System.
• Fixed a crash on importing USD scenes with textures for these scenes provided as separate files via the Asset Browser.
• Fixed an issue that caused spikes when generating material previews.
• Fixed a crash on refreshing the list of Similar Assets in the Cleaner tool.
• Cube maps are now imported with a single texture face size (instead of separate Width and Height dimensions) eliminating crashes caused by incorrect dimensions.
• Migration to 2.20 will automatically fix incorrect links to runtimes for non-native texture formats (.tga, .png, etc.) resolving issues preventing mipmaps from being used for high-resolution textures.
• Removed unnecessary automatic re-baking of textures for Environment Probes in Realtime Update mode during light baking.
• Fixed a crash on reimporting a *.upackage file, in case an object contained in this package is selected in the World Nodes hierarchy window.
• Fixed a crash on reverting changes of Curve parameters of properties.
• Fixed an issue that caused resetting the current selection in the Parameters window if a material or property search returned no results or when the search filter was changed.
• Material and property names containing numbers are now sorted correctly in their respective hierarchies.
• Fixed synchronization between mount filters and Editor filters to prevent reading files that should be excluded, eliminating related error message spam in the console.
• Fixed an issue that caused warmup settings to be ignored by the Video Grabber tool. World preview thumbnail is now also saved correctly with a proper warmup.
• Fixed an issue with incorrect UV unwrapping introduced in 2.19.1.2 release. A new compatibility option named Unwrap UV Version has been added to FBX import settings enabling you to fix UVs when upgrading your project: select Xatlas V1 in case you've performed UV unwrapping and re-baked lightmaps in 2.19.1.2, otherwise (if your lightmaps were last baked before 2.19.1.2) - select Xatlas V0.

  

• Fixed an issue with importing tangent space data.

Sandworm

The Sandworm tool keeps maturing with numerous optimizations and bug fixes. Optimizations provided a significant reduction of the total generation time: up to 35% for LandscapeTerrain output, and up to 10% for Global Terrain output (measured for a large 90GB source on the following hardware configuration: AMD Ryzen 9 7950X, 128 GB RAM, 4070 TI Super, SSD 870 EVO 4TB).

The list of the most noticeable improvements includes:

• More informative progress bars (showing percentage of downloaded TMS data)
• Improved cache system:
  • Now it's less memory-hungry (taking up to 14 GB instead of 100+ GB).
  • ID computation for each cache element has been optimized.
  • More stability in case of abrupt shutdown.
  • Reduction of the number of downloaded tiles in specific cases.
• Fixed an issue where the Vegetation Layer was misaligned with the Vegetation Mask when positioned far from the origin.
• Fixed a bug where layers with unavailable data were missing from the Sources list.
• Fixed various bugs connected with regeneration of manually deleted nodes.

SpiderVision

• Improved rendering of curved lines: straight lines that become curved when rendered via SpiderVision look smooth now.
• Improved interpretation of EasyBlend data.
• Improved overall stability, including minor UI fixes.

IG Updates

We continue enhancing our High-Level Image Generator (IG) and here are the main improvements:

• RateCtrl and TrajectoryDefinition CIGI packets are now supported.
• Mask type parameter can be set for CIGI components.
• Added the ability to override the day-night time control.
• The interpolation buffer can now be resized manually.
• Resolved the issues on deleting an entity via CIGI Destroyed State.
• Fixed the issue with the ArticulatedPart rotation being reset when its position was offset.
• Fixed the incorrect wind direction calculation for both ParticlesWind and the windsock.

Samples and Templates

Understanding a 3D engine isn't just about reading documentation - it's about seeing things in action. That's why along with a huge pack of content samples demonstrating workflows, effects, and systems in a hands-on way we've expanded our SDK with a wide range of new API samples, covering key aspects of the engine in C++, C#, and UnigineScript.

But we didn't stop at quantity. We've completely reorganized the sample library to make it more structured and intuitive, added clear descriptions to each sample available in both the SDK Browser and revamped Runtime Samples Browser, the latter having a new in-place search feature. Now it's faster and easier to find exactly what you're looking for - whether you're exploring rendering pipelines, physics, sounds, or optimization.

For your convenience, we have also made all C++ and C# Component samples, along with Photon and Dear ImGui integration samples, available on GitHub. You can check out the following repositories:

• github.com/unigine-engine/cpp-api-samples
• github.com/unigine-engine/csharp-component-samples
• github.com/unigine-engine/unigine-photon-cpp-integration-sample
• github.com/unigine-engine/unigine-photon-csharp-integration-sample
• github.com/unigine-engine/unigine-imgui-cpp-integration-sample
• github.com/unigine-engine/unigine-imgui-csharp-integration-sample

The following samples were added to the C++ Samples suite:

• Fire Hose - A basic firefighting simulation involving interactive fire suppression with a controllable hose.
• Dynamic Field Height - Creation of a dynamic Height Field with dynamic sine function texture using the C++ API.
• Player Persecutor - Creation of a custom target-following camera using PlayerDummy, replicating PlayerPersecutor logic with adjustable offset, collision handling, and multiple follow modes.
• Visualizer - Demonstration of the full range of features provided by the Visualizer class for visual debugging.
• Update Physics - Demonstration of the difference between implementation of physics-driven movement within the update() and updatePhysics() methods.
• Day-Night Switching - Implementation of an automated day-night system with light and material switching.

  

• Camera Zoom - Creation of an interactive camera system with adjustable zoom and focus on selectable scene targets.
• IFps Usage - Using Game::getIFps() to implement movement logic independent of the frame rate.
• Spectator Controller - Implementation of a customizable first-person spectator camera with configurable movement and physical collision detection.
• Observer Controller - Implementation of a free-flying camera similar to the one used in the UnigineEditor (with zooming, panning, focusing and speed control).
• Mount Points - create and use mount points in the file system for accessing external folders and package files (e.g., *.zip, *.ung).
• Ray Intersection - Using raycasting for selective (mask-based) detection of intersections.
• Bound Intersection - Finding intersections between certain volumes (frustum, sphere, and box) and the bounding boxes of nodes.
• BodyFracture Explosion - Simulating a radial explosion that triggers a BodyFracture to crack and applies forces to its pieces.
• BodyFracture Falling Spheres - Continuously falling objects fracturing upon collision implemented using the BodyFracture class.
• BodyFracture Shooting Gallery - Implementation of a basic physics-driven shooting gallery using BodyFracture objects.
• Microprofiler - Using Microprofile, an advanced CPU/GPU profiler, to track performance and estimate the time spent on different sections of code.
• Boids - Simulation and control of flocking behavior (Boids algorithm) for different types of entities.

  

• Events - Demonstration of four different patterns of subscribing to UNIGINE's Events via the C++ API, highlighting how event handler lifetime and management can vary depending on the approach.
• Events Advanced - Advanced ways of subscribing to events in UNIGINE: using extra arguments, discarding parameters, and storing connection handles for disconnection.
• JSON - Generation of a structured JSON document containing objects, arrays, and various data types such as strings, numbers, booleans, and null values, followed by traversal and pretty-printed output.
• UDP Sockets - Using the sockets API to send and receive UDP messages between two peers in the network.
• TCP Sockets - Establishing and managing TCP socket connections between a server and multiple clients each represented by a UNIGINE-application.

The following samples were added to the C# Samples suite:

• Visualizer
• IFps Usage
• Update Physics
• Day-Night Switching
• Camera Zoom
• Spectator Controller
• Observer Controller
• Body Fracture Explosion
• Body Fracture Falling Spheres
• Body Fracture Shooting Gallery
• Microprofiler
• Events Advanced
• GUI to Texture
• Abstract Components

Documentation

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

• Updated the Getting Started with VR article.
• Updated the article on C++ and C# VR Templates.
• Added a new article on Hand Tracking.
• Updated the Editor API reference.
• Added a new article on DPI Scaling.
• Added information on the new procedural mesh modification workflow.
• Added a set of multithreading-related classes to API reference, the AsyncQueue article has also been updated to describe approaches to organizing task systems operating across multiple threads and offloading calculations to CPU shaders.
• Updated the article on Thread Safety.
• Updated the article on the Profiler.
• Added a new article on C# Interfaces and Abstract Classes.
• Added a new article on GaussianSplatting plugin.
• Updated the article on Impostors Generation along with a set of related articles.
• Added a new article on the new In-Editor Search System.
• Updated articles on the Project Build Tool and Archiver.
• Updated articles on Property and Mesh file formats.
• Extended info on all samples included in the SDK.
• The Free Learning Course on UNIGINE has become available in Chinese as well.
• Added more descriptions and examples to Material Graph Nodes Reference.
• The complete list of API changes is available in the API Migration Guide.
• The complete list of Console command changes is available in the Console Migration Guide.

Thank you for reading, and don't miss the updates as we keep working to make UNIGINE even greater!

- Your UNIGINE Team