UNIGINE 2.16: Asset Store, Vulkan & DirectX 12, ROS Integration, Double Precision in Community, .NET 6, New Window Manager
- DirectX 12 and Vulkan API support (experimental).
- Double precision in Community edition.
- Completely revamped window manager.
- Integration of .NET 6 (C# 10).
- Material graph editor: support for post effects and water decals, other improvements.
- Renderer improvements: screen-space reflections, bloom, motion blur, camera effects, etc.
- Better streaming and other Landscape Terrain updates.
- Sandworm tool UX/UI upgrade.
- Editor API: Assets.
- New brush-based Texture Editor.
- ROS (Robot Operating System) integration.
- Varjo XR hand-tracking.
- IG improvements for helicopters.
- SDK Browser 2.
- Asset Store.
- Mars demo in Community edition.
UNIGINE 2.16 is intended for use with the new SDK Browser v2 (not supported in the old SDK Browser).
If you don't have the new SDK Browser v2, please download it and install.
This release brings you long-awaited double precision in Community edition, Vulkan and DX12 support (experimental), a new Texture Editor along with a huge pack of Editor improvements including API for assets management, as well as IG updates, rendering improvements, and a lot more.
DirectX 12 and Vulkan (Experimental)
Another couple of things that you have waited for and requested many times - experimental DirectX 12 and Vulkan versions of the engine are available for everyone starting from 2.16. One might ask: why waiting for so long, DX12 is there since 2015 and Vulkan came out in 2016? Well, there were reasons for that:
- Low quality of drivers - it's no secret that it is the driver that defines performance and reliability of any graphics API for the end user. Poor support from vendors at early stages, half-baked drivers were ranged from very unstable to almost non-functional (sometimes Vulkan drivers were calling OpenGL commands inside).
- Negative experience of porting AAA games, that suffered from driver problems (occasional freezes, application crashes, unstable behavior, etc.).
- No new libraries, technologies, and tools for DX12 and Vulkan at the beginning.
- Unclear profit regarding performance - neither of these APIs offered any significant performance gain at first (resulting in low motivation to support them).
- Windows 7 that we had to support as a lot of our enterprise customers have stuck to using it, and were not so eager to switch (meaning no DX12, as it requires at least Win10).
So, unclear profit along with high risks and costs (including time) made the whole task impractical back then. Now things changed, both APIs matured along with drivers, and the time has come along with motivation:
- Support for new platforms including consoles (e.g. XBox uses DX12), mobile, etc.
- Both Vulkan and DX12 are low-level APIs that give developers more control, interfere less, and provide direct hardware access with minimum overhead. These APIs offer a significant CPU gain which is critical for many applications as they usually have a CPU bottleneck (managing huge numbers of objects especially complex ones requires a lot of CPU resources).
- Hardware-accelerated raytracing DXR/VKRay (should be noted, that software raytracing was used in UNIGINE long before Vulkan and DX12 appeared) along with other new technologies not available for DX11/OpenGL, like VRS, Mesh Shaders, Async Compute, Wave Intrinsics, etc.
- Vulkan is a lot faster than OpenGL which is the only option for Linux (used by many of our enterprise customers). Apart from being slow, OpenGL requires a lot more time and effort to implement the same Engine features developed for DirectX and make them work, which slows down development process.
What We Have Now
Vulkan can bring you up to 100-200% CPU and 30% GPU boost, as compared to OpenGL implementation.
DirectX 12 - doesn't offer that much, but it's still a good plus - up to 15-60% CPU, as compared to DirectX 11. First we test new versions in our internal projects.
Vulkan and DX12 versions of the Engine are not production-ready yet, and some features will be missing in 2.16 (like both terrains, SRAA, occlusion queries, and support for multiple windows).
Missing functionality is currently being added and is to become available in future releases along with bugfixes and improvements. We keep pushing to make the performance even higher or at least keep it comparable.
The Engine is also being ported to game consoles. The Xbox Series X/S as well as the PlayStation 5 version both look almost feature-complete.
We have significantly improved the look of screen-space reflections (SSR). Sky and clouds are now rendered in reflections further improving visual consistency of the final image along with significant noise reduction and clear reflections of small objects. Old Blinn-Phong BRDF has been replaced with GGX making the look of reflections on rough surfaces more natural.
SSR settings are rather sophisticated therefore it is strongly recommended to use standard presets, especially in case you had used a Custom preset earlier.
Screen-Space Shadow Shafts
Added volumetric screen-space shadow shafts. Shadow shafts (aka light shafts) can be generated in screen space for the Sun and the Moon to simulate the real world effect of crepuscular rays, or atmospheric shadowing of atmospheric in-scattering. These rays can add depth and realism to your scenes. The new screen-space shadow shafts replace the previous implementation, as they affect haze and environment, do not cause excessive darkening of the final image, and work for both the Sun and the Moon.
There are certain limitations for this feature - it doesn't work with water and transparent objects, and there are known issues on multi-display systems as well.
Better Motion Blur
Implementation of the Motion Blur effect has been revamped. The main change is that there are no distinct sharp silhouettes between moving objects and the ones that remain static making the effect look more realistic. In order to achieve this, the implementation has become more sophisticated with several new parameters added (blur radius and number of samples to be used as well as depth thresholds). So, now you can fine-tune the effect for your scene in case default settings do not provide the desired result.
There are certain limitations for this feature - it doesn't work with water and transparent objects, and there are known issues on multi-display systems as well.
Screen-Space Shadows Updated
Screen-space shadows have also improved with reduced noise, ability to control perspective compensation of translucent depth (based on the depth buffer data), making the look of vegetation even more lifelike. The effect of fuzziness for vegetation (e.g. leaves of saintpaulia) adds more realism to that.
The new implementation uses the frame data before TAA application. Brighter areas will now be more affected by the effect while darker ones will be affected less, exactly as it should be. The effect produces a 100% correct result when Temporal Filtering is disabled, but even when it is enabled the loss of brightness is insignificant.
Temporal filtering for the Bloom effect has evolved and can now be called anti-aliasing as it uses an accumulation buffer with jittering. Specular highlights from the Sun on metal have become as bright as they should, while having a correct antialiasing. The Bloom effect may appear with a small delay controlled by a set of color and velocity clamping parameters.
New Camera Effects
Chromatic Aberration, Noise, and Vignette Mask post-effects are now available for your convenience with the corresponding settings added to the Camera Effects section of the Settings window.
You can also control these effects via the corresponding console commands (render_vignette_mask, render_chromatic_aberration, render_noise) or via API. Related samples are added to the Art Samples suite.
Post-Effects and Water Decals in Material Graph
You can now create your own graph-based post-materials in the Material Editor
You can specify when your material should be rendered by choosing the desired stage at the Render Sequence Order dropdown. For your convenience we have made two user modes: Artist Friendly (simplified with unnecessary stages hidden) and Technical Artist Friendly (with all available stages listed).
A new Custom Post Effect sample has been added to the Art Samples suite included in the SDK.
Starting from 2.16 you can also use visual Material Editor to create graph-based materials for Water Decals (the ones projected on the top of the water surface). This type of decals can be used to create effects like ship wake waves or rotor downwash on the water surface from a helicopter, foam, oil stains, and a lot more. Just choose the Decal Water in the Type dropdown in Common Settings.
Revamped Window Manager and Engine Integration
UNIGINE Engine supports a large variety of outputs including multi-monitor configurations, panorama, stereo, VR, and so on. Apart from that it supports embedding into various third-party applications (SDL, WPF, Qt, etc.), meaning that we create a lot of windows to draw on, often with GUI, along with events processing.
There were multiple unresolved problems with window management, events processing, and graphics context initialization due to multiple integration options and complexity of implementation with functionality duplication. The problems ranged from missing support for specific keyboard layouts (e.g. accents/umlauts) to unmanageable UI input in multi-window applications or inability to use VR in Qt applications, including platform-related and fullscreen issues, etc.
Our roadmap contains a number of large-scale and important features like Node-based scripting, Visual UI editor, Sequencer, and Character animation editor. All of them need a new GUI system, which in turn requires a new Window Manager as basis (free from the imperfections mentioned above). So the main motivation was to create an advanced and reliable toolkit to simplify development of various advanced visual tools for growing number of platforms, with a large palette of widgets and extended capabilities, increasing productivity of our customers, and give this toolkit to them, so they could develop such tools for their purposes themselves.
So, we have completely revamped window management and integration workflow (see details in the sections below).
The basis is completed, but some related changes are yet to be made in the upcoming releases - we are currently working on making a combination of multi-monitor and projection plugins (Wall, Projection) and combining all VR plugins into a single one along with adding OpenXR support to simplify adding new devices.
Unfortunately, the amount of related API changes is significant, meaning that in case your project uses your own custom implementation of Syncker or some custom multi-display/projection solution, it will have to be rewritten. But this is to be made once and will let you get rid of all imperfections of the old window management system and give you a firm basis in case you plan future development of your tool.
We have replaced the old CustomApp-based workflow with a new one. A new CustomSystemProxy concept to be used instead of the CustomApp incorporates definition of available functions (windows creation and management, input management, additional functionality like dialogs, clipboard, etc.) along with all necessary overrides. The functionality of some Engine subsystems is to be defined depending on the set of functions made available by the user. This class forms the basis for the operation of WindowManager, Input, GUI, Displays, etc. A separate proxy implementation is required for each integration environment (SystemProxySDL, SystemProxyQt, SystemProxyWPF, etc.).
The new CustomSystemProxy-based workflow has resolved the following issues:
- inability to create a window without using platform-dependent code;
- inability to create a separate rendering window without any plugins;
- code duplication (the same window creation functionality in all applications);
- only a part of functionality of the main window is available for other windows (GUI, Input, …);
- inability to obtain information on physical configuration of displays (monitor resolution, main monitor, etc.);
- missing "window" concept and unclear API as a result;
We have simplified our own App* plugins moving similar functionality out and eliminating problems related to integration into applications created on the basis of third-party frameworks (such as inability to use VR in Qt or WPF applications).
To unify processing of the mouse and keyboard inputs we have extended the Input class. New functionality covers methods that were used for input in the App class. All keyboard keys and mouse buttons have been moved to this class. Input buffer is now used to avoid missing input events at low framerates. Input events can be received as a buffer, you can create user events and dispatch them to the Engine via Input::sendEvent(). Input event filter is also available enabling you to reject certain input events for the Engine and get necessary information on all input events. This filter is configured via Input::setEventsFilter(). Event filter is also available for WindowManager (see WindowManager::setEventsFilter()) enabling you to receive all events for windows coming from the SystemProxy and filter them out.
Extended Set of Callbacks
From now on, access to a wide range of input event callbacks is available: MOUSE, KEY, TEXT, TOUCH, and IMMEDIATE_INPUT. Text input callback allows getting a symbol in Unicode format. The user is getting an unsigned char, then it is translated into a proper code (for example: If Shift+q is pressed, then we get “Q”, and not just a key symbol).
New Keys and Physical Codes
The KEY enumeration now contains scan codes of buttons according to the QWERTY layout (indicating physical positions on the keyboard). This ensures standardization of controls to the same layout for every keyboard type, with the same button opening the console everywhere. You can obtain a symbol corresponding to the key taking into account current keyboard layout (QWERTY, QWERTZ, AZERTY), modifiers, etc. via the keyToUnicode() method, or use unicodeToKey() to get a scan code for a certain unicode symbol. To work with keys use isKeyDown(), isKeyPressed(), and isKeyUp().
Moreover, paired keys (Ctrl, Alt, Shift, etc) are now separated (LEFT_SHIFT, RIGHT_SHIFT, LEFT_ALT, etc.) making it easy to determine any pressed key on QWERTY, QWERTZ, and AZERTY keyboards.
Working with Multiple Displays
The new Displays class allows getting information about connected displays. You can get the number of screen displays and the index of the main one. With those indices, you can identify their position and size in pixels. Also, there is access to the name and current dpi. Apart from that, there are functions for obtaining available modes for displays. You can get the number of modes and by their index get resolution and refresh rate.
For windows creation, we have added a new EngineWindow class. All window management operations are performed via this manager enabling you to access any window of the application, group or stack windows, create various dialogs, etc.
A set of samples has been added to Sim SDK to demonstrate various aspects of use (samples/Api/WindowManager).
Interface Plugin Removed
We have removed the Interface plugin as its functionality has been covered by the updates described above.
Make your environment unique in a literally one stroke with a rich set of brushes giving flexible control over the look of your props. The new Texture Editor enables you to paint textures of the materials applied to objects directly in the viewport, saving you a lot of time and effort to fine tune every prop to fit the scene and make it look natural, consistent, and exactly as you want it too. The tool is mainly used for painting masks that can be used to blend various materials together, but also helps editing the existing textures: adding details or fixing mistakes.GPU acceleration ensures high performance even when working with 4K textures.
Real-time flowmap painting in the Editor
Real-time curvature painting
Texture Editor is available when the Texture Paint Mode is selected on the toolbar:
Surface Custom Texture
We have added an ability to assign a custom texture for any surface of a static mesh giving you a wide range of opportunities for customization, and enabling you to optimize the number of materials while extending visual diversity. For example, instead of tweaking a set of similar materials for different surfaces, you can assign a unique custom texture to each surface and use a single material with the final look depending on the custom texture. You can either assign a unique texture to each surface or use the custom texture from other surfaces. This option is intended for use with LODs having the same UV maps.
A custom texture can be specified for any Static Mesh surface via the Parameters window (see the Surface Custom Texture group). You can paint it with a new Texture Editor and use it in the Material Graph Editor via the Surface Custom Texture node.
Same material with a unique custom texture assigned for each box
New Runtime Format for Textures
DDS for UNIGINE is an external format, therefore it does not allow us to use our own compression and store additional data for textures. To get rid of limitations and optimize texture management we have developed our own format for texture assets (.texture). The .texture format will be used as the default runtime format for texture assets instead of .dds. All runtimes shall be regenerated automatically by the Editor. You can still use DDS if you want (simply set the Unchanged flag for your dds-textures).
You can convert any image asset to the .texture format via the context menu right in the Editor. Conversion to TIFF format (.tiff) has also become available.
Landscape Terrain Improvements
Sophisticated systems with a lot of features require extra attention to be paid to optimization. We have prepared some more for this release to make Landscape Terrain even better.
Culling of Landscape Terrain polygons has become more efficient with batching on CPU, support for occluders (culling of patches without polycount reduction), depth buffer utilization (skipping polygons overlapped by geometry or terrain itself), revision and optimization of terrain parameters significantly reducing the number of polygons.
A set of new advanced culling parameters enables you to fine-tune the process for each particular project and camera You can control load distribution between CPU and GPU defining patches (tiles) to be processed on CPU and GPU, culling distance for small layer maps, ensure more efficient division of LODs without any gaps in geometry, and a lot more.
The list of other culling updates includes:
- Improved calculation of tile bounds and fixed culling issues for terrain areas with negative height values as well as issues observed in case of narrow FOV (<10dg).
- Batched culling of patches enables skipping large areas (sets of patches) at once making it possible to reduce patch size.
- Frustum padding has been removed as displacement for frustum culling is now taken into account.
- Backface culling has been removed as well due to low efficiency.
We have significantly improved streaming of landscape data making it faster, more stable, and giving you more control and flexibility with an extended set of advanced options. Including accuracy of detection of visible tiles and the ones to be loaded (like Sampler Feedback options) and ability to disable streaming by levels of detail when it is not needed to progressively load mip-levels of terrain tiles, making them load faster but less smoothly.
Streaming is now performed in separate threads with an ability to control their number. Compression of Landscape Terrain details enables you to improve memory usage efficiency, here you can choose between Faster Compression and High Quality. Reduced number of megatexture reallocations makes the whole process faster and more stable.
The list of other improvements includes:
- Narrow FOV values (less than 1 degree) no longer increase density of Landscape Terrain geometry, this ensures an acceptable frame rate even in extreme conditions.
- Fixed various issues with cyclic “endless” streaming of the Landscape Terrain data due to different reasons (moving layer maps, narrow FOV, large terrain size) along with CPU and GPU cache utilization.
- Tiles are now asynchronously loaded in a predefined order according to their distance from the camera (instead of random order that was used previously).
- Limitless black plain at zero-level is removed and it no longer affects streaming to virtual texture or causes z-fighting artefacts.
- Improved geomorphing with correct and smooth blending of levels of detail is now available instead of less efficient Fade LODs functionality.
- Layer maps having no underlying layers shall now ignore opacity values as there is nothing to blend them with.
- Exposed a new Detail Max Height parameter (was initially internal) limiting height displacement of details and making it possible to efficiently distribute 8 bits of data to avoid stair-step effect in case of bitness insufficiency (geometry is clamped by height, while keeping normals).
The documentation has been updated, and you can find more information on new advanced settings in the following article.
Improvements for Binoculars
In this release we have also improved the functionality of binoculars and narrow-FOV sensors by making Landscape Terrain visibility completely independent from the global Distance Scale parameter that affects all other objects, preventing issues with Landscape Terrain's scale being affected twice. There are some more improvements in this aspect planned to be added in upcoming releases.
ROS (Robot Operating System) Integration
(Available for Sim SDK edition only)
There are multiple types of robots from vacuum cleaners to autonomous combine harvesters, drones etc. Most of them are made of actuators (things that move), sensors (things that read the world), and control systems (robot's brain) There is a way to simplify the complex process of making these components work together - Robot Operating System (ROS). It is a set of free and open-source software libraries and tools to help you build robot applications. ROS enables you to build components quick and easily connect them via messages. These messages can be sent to various visualization or teleoperation tools so you can work with a simulated robot instead of the real thing (digital twin). So, with ROS you can build complex distributed systems with multiple nodes for different tasks (controls, image generation, etc.), it supports hardware interfaces for many common robot components like motor controllers, LiDARS, and cameras. The whole framework enables you to focus on implementing your logic, not reinventing the wheel. The list of tasks that can be effectively solved using ROS includes logging and diagnostics, fleet management, deep learning data collection (training), testing & quality assurance, and a lot more.
UNIGINE actively moves towards the automotive industry and the world of autonomous systems where ROS is a de-facto standard, so we made ROS integration (ROS2) to simplify processes of building, training, and testing such systems.
For your convenience we have added a new ROS Demo to showcase simulation of the automotive vehicle control via ROS and simulation of sensors (cameras and LiDARs) mounted on the car. The demo is available for SIM edition only and includes several modules (ROS nodes):
- Simulator - renders the simulation and simulates physics (UNIGINE can also be used as Image Generator with physics and vehicle model calculated on separate nodes)
- Teleop - processes the input (control keys pressed) from the user and transmits it to other ROS nodes. To control two vehicles simultaneously you can run two Teleop applications on the same PC or on different PCs in the local network. Another control application (e.g. your own implementation of control system of an autonomous vehicle) can be used instead of Teleop to control vehicles in the Simulator.
The Simulator application sends data from cameras and LiDARs to RViz 3D visualization tool for ROS (included in the original ROS2 package) that renders point cloud visualization based on the sensor data received.
The simplified workflow of implementing a robot system using new ROS integration in UNIGINE is as follows:
- Design your robot, define all sensors and actuators.
- Implement your robot's control system.
- Create a 3D model and implement an entity for your robot in UNIGINE (and other entities if necessary).
- Connect your control system instead of the Teleop node.
- Connect RViz 3D or other visualization tools to process and display the data from robot's sensors.
In this case you just concentrate on your task - development of control system and implementation of a digital twin for your robot, without having to think about data transmission or write other utility code.
We also plan future development of ROS integration in UNIGINE.
Integration of .NET 6 (C# 10)
We have implemented support for .NET 6 released in November 2021 (new major .NET versions are planned annually, so we keep the pace). .NET 6 will be supported for three years as a long-term support (LTS) release. This update brings you many fixes and new features as well:
- Better performance: .NET 6 is the fastest full stack web framework, which lowers compute costs if you're running in the cloud.
- Ultimate productivity: .NET 6 and Visual Studio 2022 provide hot reload, new git tooling, intelligent code editing, robust diagnostics and testing tools, and better team collaboration.
- C# 10.0 support offering language improvements such as record structs, implicit using, and new lambda capabilities, while the compiler adds incremental source generators. (for details please follow this link).
- Simplified development: Getting started is easy. New language features in C# 10 reduce the amount of code you need to write. And investments in the web stack and minimal APIs make it easy to quickly write smaller, faster microservices.
- Numerous bugs fixed and much more.
For more details refer to the official .NET 6 Release Notes. Please note that the minimum required Visual Studio version is 2022 (only for C# projects using the Component System).
Varjo XR Hand-Tracking
Advanced hand-tracking in VR is now available for human-eye resolution industrial-grade Varjo VR and XR headsets. Enabling you to build XR applications realizing their potential to the full extent by using hands naturally instead of some sophisticated controllers. New functionality is available via our new Ultraleap integration plugin supporting the fifth generation of hand-tracking software (SDK v5.0) with better finger fidelity, two-hand performance, higher tracking robustness and a lot of other improvements.
Image courtesy of Varjo
The C++ VR Sample has been updated to showcase new functionality.
For more information about the related API changes please refer to the API Migration Guide.
Double Precision in Community Edition
You've asked for it so many times that we decided to make 64-bit double-precision floating-point coordinates (aka Doubles) available for everyone - without any limitations literally! We've been using double precision in the Engine for 10 years already. All this time the use of doubles was limited to our enterprise customers, but now everyone can create highly detailed virtually unlimited worlds even with the Community SDK edition! The maximum coordinate values are effectively 536,870,912 times larger than for the 32-bit float precision opening the scale of the whole Solar System and beyond.
Other Engine Improvements
- FMOD plugin is now available for Linux.
- Environment lookup tables were updated to make the sky a bit less bright to make it look consistent with clouds as well as to make the Sun look less yellowish when it is at its zenith. A too bright spot on the base texture corresponding to the Sun's zenith was corrected as well.
- Starting from 2.16 the System window that was earlier displayed on hitting Esc on the keyboard shall now be displayed only when Wall, Projection, or Syncker plugin is loaded and shall only contain settings for these plugins.
- Fixed an issue with applying angular velocity to the wheel's rigid body in the Wheel Joint resulting in disrupted extrapolation of wheel rotation. Certain improvements were also made to avoid losing precision of the wheel rotation angle.
- Fixed an issue causing noticeable spikes at cpu_shader_wait stage mostly observed on Linux.
- Fixed issues with parallel update of dependent and independent nodes sometimes leading to Engine crashes.
- Fixed issues with incorrect overriding Voxel Probes by Environment Probes resulting in inconsistency of ambient lighting in certain cases.
- Added dynamic update for the shadow map used for the Cutout by Shadow feature of dynamic Environment Probes.
- Added a new Distance Scale parameter for Environment Probes to control reflection LODs visibility distance (similar to the Distance Scale parameter of Light Planar Probes).
- Added a separate option to disable far-plane clipping for clouds, as controlling clouds visibility by increasing the far plane distance significantly affects performance (dynamic Environment Probes etc.). This option is available via the render_clouds_far_clipping console command or via the Cutout By Far Clipping toggle in Settings->Render->Clouds->Common.
- Moved calculation of clouds baked z displacement to CPU eliminating issues with clouds rendering on AMD 6xxx GPUs.
- Fixed Cast Global Illumination and Bake To Environment Probes options for Object Cloud Layer.
- Fixed issues with rendering of planar reflections in stereo modes (VR), reflections can now be rendered for each camera separately instead of rendering them once for the point between the cameras.
- Fixed a crash on deleting materials created dynamically after loading a world due to incorrect result of checking (whether material belongs to the Engine/Editor core).
- Offscreen mode implementation has been ported from a sample to the Engine and is now available via the video_offscreen startup command-line option.
- Fixed memory leaks in ObjectParticles on OpenGL.
- Fixed depth testing for ObjectGUI, stencils now work as expected.
- Fixed issues with incorrect intersection detection for the Global Water object.
- Fixed issues with incorrect application of changes made to parameters of the Global Water object.
- Fixed an issue with Water Decals being projected onto mesh geometry when the Emission state is enabled.
- Fixed an issue with incorrect shadows rendering for impostors on OpenGL.
- When unmounting/mounting a mount point all materials, properties and other resources it contains are properly removed and reloaded.
- Fixed an issue with incorrect displaying of Microprofile dumps in latest versions of Google Chrome.
- Fixed an issue with dmat4.Scale (C#) - now it works as expected.
- TextureCurve has been renamed as TextureRamp for consistency, for more information please refer to the API Migration Guide.
- C++ Component System Improvements
- More macros are now available for declaration of your C++ components enabling you to specify description for your component, as well as a tooltip, title, and group for the corresponding property: COMPONENT_DESCRIPTION, PROP_TITLE, PROP_TOOLTIP, PROP_GROUP.
- Added an ability to force initialization of all components without waiting for the next frame (WorldLogic::Update() execution).
- Added an ability to toggle execution of the update(), postUpdate(), updatePhysics(), swap(), updateSync(), updateAsync() methods on and off for all components simultaneously (can be useful for performance evaluation and debugging purposes).
- Fixed issues with referencing arrays of external structs or classes in components, now everything works as expected.
- Fixed issues with C++ components shutdown (ComponentBase class) sometimes resulting in Engine crashes.
Automatic Assets Migration
According to the standard workflow, content of the project is migrated to the newest version automatically via UNIGINE SDK Browser or manually using the upgrade script.
Starting from 2.16, you can also add outdated assets to the upgraded project right in the Editor (when importing a package of assets, dragging an asset to the Asset Browser, or copying an asset directly to the project's data folder), as it allows upgrading them automatically to the current version of UNIGINE SDK. This functionality is also a part of the Asset Store infrastructure support, ensuring that assets and asset packages you download (which can be outdated) will be updated when you add them to your project via the Editor.
You can control automatic migration settings via the Settings window:
For more information please refer to the related article.
Editor API: Assets
Most likely your custom tools that you develop on the basis of UnigineEditor's functionality will somehow manage assets. For this release we've made a convenient asset management API. A new AssetManager class that extends the functionality of the UNIGINE's FileSystem. enables you to check availability of a resource with a specific GUID, get its path, subscribe for the signals to perform certain actions when an asset is added, moved, updated, or deleted, and track assets changes in real time.
For your convenience we have also a sample plugin demonstrating implementation of basic asset management operations using the AssetManager class. It is called Assets Plugin and can be used as a template for your tool. A new article will help you get up and running quick. Information on new classes was added to Editor API Reference.
Evolution of Editor API goes on, so stay tuned.
Improved Curve Editing
Editing curve parameters in properties and components as well as all other curves in UnigineEditor has become more convenient. New points are now added exactly at the mouse cursor's position, no need to drag them to the desired point after creation.
Zooming and panning ranges of the camera have been extended for convenience, as for curve-parameters in properties/components they are no longer bound to the normalized range of the standard Curve Editor [0; 1], so panning is virtually unlimited along both axes, as well as zooming.
You can now quickly focus on selected points or tangents by pressing F on the keyboard, pressing F when nothing is selected will show you the whole curve.
Material Graph Editor Updates
Ramps are now available in Material Editor, both as a constant and as a parameter. You can edit ramps via the Curve Editor. The output is a texture to be passed to a texture sampler. We have also added two useful ramp-based subgraphs for your convenience (Color Correction By Ramp and Float Correction By Ramp).
Better Input Handling
Input processing has significantly improved ensuring smoothness and responsiveness while you build your graphs even at low frame rates leaving various annoying issues with selecting, moving, and connecting nodes behind.
You can now quickly focus on currently selected nodes (just press F on the keyboard), or zoom to fit the whole material graph to the window by pressing F when nothing is selected.
Help Always at Hand
The number of nodes available in the Material Graph Editor grows unleashing your creative potential. There are already over 200 nodes at your disposal, and it's hard to remember all of them, while some might be unknown at all, especially for newcomers. For your convenience we have added tooltips with clickable quick-access links to documentation for these nodes. And we plan to develop this system adding more information and usage examples to the docs, just a click away from the node in the Editor.
All UI elements in the right panel of the Editor are provided with tooltips as well.
The list of other Material Editor improvements includes:
- Added SRAA support to the Mesh material (mesh.abstmat).
- Added a new Cast Global Illumination option for transparent materials to control whether the surface is to be taken into account or ignored when baking Global Illumination (similar to the per-surface Cast Global Illumination option). Can be used to ignore all transparent surfaces having the same material at once when baking GI, instead of switching them one by one.
- Updated node colors in the Material Editor for better visual differentiation of certain node types.
- Fixed an issue with creating child materials for graph-based materials via the Asset Browser or the Parameters window.
- Fixed an issue with parameters of graph-based materials resulting in changing the look of material after rearranging parameters in the Material Editor.
- Fixed an issue with adding a new parameter to a selected group.
- Fixed an issue with incorrect operation of the Refraction Screen UV Offset For Thin Objects node.
- The following new subgraphs were added:
Anisotropic Specular Brdf
Bits Shift Left
Bits Shift Right
Blend By Height Simple
Color Correction By Ramp
Compose Matrix2 By Column
Compose Matrix2 By Row
Fast Position To Screen UV
Float Correction By Ramp
Flowmap Panner Simple
Ggx Brdf Importance Sampling
Screen Space Subsurface Scattering
Specular Ambient Occlusion
Surface Custom Texture
Texture 2D Int
Texture Buffer Clouds Screen
Texture Ramp (R)
Texture Ramp (RG)
Texture Ramp (RGB)
Texture Ramp (RGBA)
See Content Migration Guide for more details on changes in graph-based materials.
Other UnigineEditor Improvements
- Editor settings are now divided into 2 groups: User and Project settings, the latter ones are applied per-project and stored in a separate file (UNIGINE_PROJECT/data/editor2/settings/unigineeditor.generic.cfg).
- In case there are no active clusters selected when you start drawing with Cluster Editor, you'll be prompted to select the first one in the list of available ones.
- Added an ability to reset current animation or playback time for certain nodes (SoundSource, ObjectWaterGlobal, WorldTransformPath, ObjectMeshSkinned, ObjectCloudLayer) to zero when saving a world (current values are restored after saving). This eliminates the problem with large diffs generated by version control systems in case of saving a world after opening it in the Editor and simply playing skinned mesh animations, sounds, or just having particles, water, and clouds simulation enabled (see the corresponding checkbox in Settings -> Editor -> User Settings). By default this option is enabled.
- Added an ability to import a source 2D texture as a 2D Texture Array by splitting it into equal square slices vertically (e.g. you can create a 256x1024 texture containing 4 blocks 256x256 placed next to each other vertically, each of them will be imported as an element of the 2D texture array).
- Updated UI layout for Color Correction settings with Sharpness parameters moved from Camera Effects.
- Fixed an issue with displaying incorrect runtime-file size for textures in the preview.
- Fixed issues with copying .mgraph files resulting in GUID duplication.
- Fixed issues with refreshing parameter conditions for C# components in case a new ParameterCondition is set via code after modifying the parameter in the Editor.
- Fixed issues with helpers in the preview.
- Fixed an issue with masks resulting in incorrect grass painting in Clutter Mask Paint Mode.
- Fixed a crash on an attempt to open camera settings after moving a viewport to another display.
- Fixed a crash on importing a package (.upackage) containing .obj and .mtl files.
- Fixed an issue with dependencies when exporting data to a package resulting in ignoring some dependent assets (e.g. ignoring a subgraph used in a graph-based material assigned to an object when exporting a world containing this object to a package.
- Fixed FBX exporting to locations outside the data path.
- Configuration parameters for UnigineEditor are now stored in a separate file in the data/configs folder (editor.boot).
- Editor's internal materials are no longer displayed in the Materials Hierarchy window.
Sandworm Tool UX/UI Upgrade
Up to 2.16 there were two terrain generation tools in UNIGINE - "In the end, there can be only one!"(c)
The main problem when designing a multi-purpose terrain generation tool is that it is intended to be used by different people, not just GIS-professionals. The previous Landscape tool had a lot of problems in this aspect, with numerous non-trivial tasks, sophisticated workflow, unclear procedures and mixed naming resulting in many features, functions, and options lost in the UI and never found by some users. The previous iteration of Sandworm had an objective of absorbing Landscape Tool's functionality and therefore had the same weaknesses. Now with most of the functions covered, the time has come to redesign the tool with a huge UI/UX upgrade. We have looked at it through the eyes of an average customer, simplified the workflow, reduced complexity of operations, ensured that all necessary things are always at hand, overall making the interface simpler, much more intuitive, and much easier to use.
In addition to redesigning the interface we've made grid division available for Vegetation objects (ObjectGrass \ ObjectMeshClutter \ WorldClutter) generated for landcover masks, splitting large areas of vegetation into smaller grid cells to eliminate artefacts associated with internal precision of mesh-objects, similar to splitting vector objects.
The list of other improvements includes:
- TMS sources are now supported for masks and vector data.
- Added an ability to split generated vegetation (Grass object) into a grid of smaller separate objects to optimize performance. Simply specify Split Length for grid in meters in Vegetation generation settings
- The tool now supports graph-based materials (.mgraph) as well.
- Layers can now be removed via the Del hotkey.
Starting from 2.16 Sandworm completely replaces the old Landscape Tool.
Image Generator Improvements
IG Aviation Add-On
To simplify creation of realistic aircrafts in your IG-applications we have added a new IG Aviation add-on with a set of ready-to-use aircraft components creating such effects as engine and landing gear fire, smoke, contrail, landing gears, helicopter rotor blade settings with the blurring effect and rotor downwash effect. The add-on also shows implementation of the wheel trace.
The new add-on is available for Sim SDK edition only. You can download it from the Asset Store!
Custom Network Components
Usually, if you need to render a world across several computers synchronized over LAN, you use Syncker. It sends a lot of data each frame from Master to all Slaves. Using Syncker allows for precise image synchronization, however, it is not always necessary. IG Template now provides functionality enabling you to reduce the amount of data to be sent and, therefore, network load. For example, to rotate an object, you can simply send rotation velocity from Master to Slaves once. When implementing the network component, you define data to be transferred over the network and send it only when necessary: you specify methods that can be invoked over a network (i.e. on Slaves) and then call them on Master passing the required data. These methods will be called on Slaves as well.
To create a network component with custom application logic using the IG Template functionality, simply inherit it from the Unigine::Plugins::IG::NetworkComponentBase class. For more information please refer to the Creating Custom Components article.
The list of other improvements includes:
- Added support for CIGI Symbols in IG applications.
- Added support for DIS entity marking.
- Added types of lights for ground vehicles as per DIS specification.
- Fixed an issue with disabling entity interpolation (smoothing) when activating CIGI entity ground clamping (conformal and non-conformal).
- Fixed an issue with detaching a camera from the entity after CIGI reset.
- Fixed an issue resulting in an application crash on receiving a CIGI Reset in case of receiving a DIS entity as well.
You've asked, we delivered: the Asset Store is finally here. For now, it's an experimental version available for our most devoted users: you. We've been working hard to create the asset store and are now ready to grant you early access. UNIGINE Asset Store is used together with SDK Browser 2. For now, only free assets are available in the Asset Store.
Further development of the Asset Store is in progress and will continue. The next stage expected in November this year is the ability to publish free assets for all users, with monetization functionality for all users (ability to get money for your assets) expected by the end of the year. If you'd like to publish your assets for free use, please contact our support team.
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.
Introducing a new SDK Browser 2, completely reworked from scratch, supporting the complete set of features of the previous version with improved safety, robustness, and extended functionality to support additional features. And the cherry on the cake is the ability to minimize SDK Browser to the System Tray.
New SDK Browser 2 is considered production-ready and should be used to work with your UNIGINE projects starting from version 2.9 and higher. A set of new features is yet to be added (next stages of Asset Store integration, simplified user registration and a lot more) along with further UX improvements, so stay tuned for future updates.
You can download SDK Browser 2 here.
Here is a quick video guide about working with the new SDK Browser 2:
More details on the roadmap for upcoming releases can be found on the official forum.
UNIGINE 2.16 SDK is intended for use with the new SDK Browser v2 (some features are not supported in the old SDK Browser). If you don't have the new version, please download it and install. UNIGINE 2.15.1 release was the last for the old SDK Browser.
This table below gives you a quick tip, which SDK Browser can be used to work with certain SDK versions.
Demos and Samples
Mars Demo in Community
Everybody can drive a rover across the Martian surface and view the Gale Crater using scopes starting from 2.16 as the demo has become available in the Community and Engineering editions as well. Explore a large open world that is hard to tell from real images of the Martian landscape taken by the NASA Curiosity rover!
A set of new samples was added to the Art Samples suite.
This new content sample demonstrates two custom post-effects: imitation of screen distortion and an object highlighter effect using the data from the auxiliary buffer.
Camera Effects and Color Correction
This new content sample demonstrates various camera effects such as noise, vignette, and chromatic aberration, as well as color correction settings (color correction by curves, per-color correction of saturation and hue, and sharpness).
River Flow and Lava Flow
Two samples showcasing creation of rivers, vortexes, and lava flows using flow maps that can be created and edited in Texture Editor.
An example of car visualization with UNIGINE for various promotional or informational purposes showcasing car interior and exterior materials, quickly switchable environments with baked lighting and reflections.
Demonstration of realistic hair and fur rendering in UNIGINE using the functionality of the new Hair Shading node.
The File sample (Samples->API->Systems->File) has been renamed as FileSample (Samples->API->Systems->FileSample) to avoid issues with antivirus systems.
Added two new Quick Tour videos describing the contents of the Art Samples suite included in the SDK:
More such videos about demos and samples available in the SDK are to be available soon.
Along with a set of new ultrashort HowTo quick tip videos in English, Chinese, and Russian:
Other Documentation Changes
- Updated IG documentation.
- Added a new Texture Editor section.
- Improved and restructured Sandworm documentation.
- Added a new article on Managing Assets in Editor Plugins and updated Editor API Reference.
- Added more descriptions to Material Graph Nodes Reference and Material Graph samples.
- Added articles on Engine integration with other frameworks for C++ and C#.
- Fixed a number of issues in the docs based on your feedback.
- 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.
- The complete list of instructions on upgrading your content to UNIGINE 2.16 is available in the Content Migration Guide.
Thank you for reading, and don't miss the updates as we keep working to make UNIGINE even greater!
- Your UNIGINE Team