UNIGINE 2.15: Visual Material Graph Editor, New Water System, Sandworm Tool Upgrade, Advanced Terrain Data Compression, Improved Brushes, Mars Demo
- Node-based material graphs with visual editor.
- New water system with individual control over each wave.
- Advanced data compression for Landscape Terrain.
- Sandworm tool upgrade: online GIS sources, distributed generation.
- Extended Mixed Reality support for Varjo XR-3 headset.
- Editor plugins system.
- UnigineEditor: updated Brush tools, new Asset Browser, and other improvements.
- Improved IG high-level weather system.
- Mars demo 1000x1000 km in size.
Notice: UNIGINE 2.15 SDK requires SDK Browser version 1.9.32 or later.
Visual Material Graph Editor
One of the major features of 2.15 - the new node-based Material Editor enables you to create your own materials visually without writing a single line of code.
We did our best to combine all the benefits from the worlds of code-based and node-based programming.
The key points include:
- Optimum balance between the list of features, performance, and convenience.
- Ability to create your own base materials (.mgraph) and use them as directly assigned to objects or as parent materials for hundreds of other materials to avoid reassembling the material graph over and over again.
- Ability to switch between material types (there are four available at the moment: Opaque PBR, Alpha Test PBR, Transparent PBR, Transparent Unlit).
- Automatic type conversion wherever possible making it simpler for artists.
- Fast graph saving taking no longer than a couple of seconds.
- System robustness and reliability. In case of malfunction of any node or assembling some invalid logic, the graph won't totally break and become unreadable; it will just highlight problems for you to tackle.
- Material Editor UI compactness with part of the functions wrapped into context menus so that you don't have to move the mouse cursor across the screen to use another function.
One of the most important things is the possibility to assemble easy-to-read graphs that do not look like a spaghetti bowl and are easy to support. This is due to overall graph compactness, provided by the minimized number of graph nodes while keeping the same functionality and a number of features, among others including:
- Loops - a complex, but very cool feature enabling you to repeat an arbitrary sequence of actions multiple times. We have analyzed multiple existing implementations of graph loops and invented a new one that is almost on par with loops in code. Why not write loops in code then? Because using a graph makes implementation of complex things inside a loop much easier than doing the same in code.
- Portals enabling you to keep visual clarity even for complex or large graphs, avoiding siuations when your wires are all over the place crisscrossing each other.
- Subgraphs - your custom nodes combining reusable parts of your node graph, that can be used in multiple other material graphs. The best part is, if you change anything in the subgraph, changes will apply to every material using it.
- Connectors - a special "collapsed" mode of a graph node when it occupies less space and can be attached right to an input of another graph node.
- Expression nodes enabling you to write simple arithmetic operations, but the main thing is that you can use it as a swizzle in combination with the ability to change the number or order of data components. Be sure you'll like it!
The Superposition demo, along with the CSharp Third Person Platformer sample, and default C# Project Template were switched to graph-based materials so you can check them out in action.
For your convenience, a pack of material graph samples created using the new Material Editor is included in the SDK to give you a quick overview and demonstrate its features, capabilities, and common use cases. You will find it via the SDK Browser: Samples -> Demos -> Material Graph Samples.
We have also added the following features that are not directly related to the Material Graph Editor but are also very important.
- When importing geometry you can choose whether to create graph-based materials, or use the old workflow and create a child material of the mesh_base.
- You can reparent a material from the mesh_base to a graph-based material, and if the names of parameters are the same even the values will be set for them automatically. That's how we migrate our projects from the mesh_base to graph-based materials. The easiest way to do it is via the Ctrl+P hotkey.
- In case you want any child material of a graph-based material to become unique and unrelated to its current parent, you can right-click it and choose Convert To Unique Graph in the context menu.
Materials System Refactoring
Implementation of the long-awaited Material Graph has required a major refactoring of UNIGINE's Materials system. And we have used this opportunity to make it more flexible, straightforward, and easier to use as well, bringing you even more benefits.
Simpler Materials Customization
We have simplified the process of creating custom user materials or extending the functionality of existing ones. Up to 2.15 in order to tweak the mesh_base material a little bit (e.g., add some UV animation or an additional texture, or otherwise use any custom shader) you had to make a copy of the whole mesh_base and add your custom code to it (which actually is a fork!). In this case, any changes made to this material in each subsequent SDK release associated with adding new functionality or some internal refactoring would require you to track these changes and update your custom material manually.
Well, things have become a lot simpler. Creation of custom user materials is now available in the following ways:
- Using the Material Graph: by assembling what you need in the visual editor
- Using Abstract Materials (see below): by inheriting a base material from an existing abstract prototype (or your own custom prototype) and adding the desired functions to it.
Other undocumented ways of materials customization (e.g. old-way manual copying and modification) are to be supported manually at your own risk.
To simplify shaders programming and to hide the implementation complexity of various features we have added Abstract Materials, like abstract classes in object-oriented programming they serve as a template definition of certain parameters and functionality. An abstract material itself cannot be assigned to objects, it is used to inherit other abstract and base materials from it, extending its functionality, which gives you a lot of flexibility.
When inheriting from an abstract material you can override any values or add some other components to the child material: When the child material implements the shader with the same name, the source code of the parent and the child shader is merged (the parent shader precedes the child one).
You can create your own custom abstract material or use the ones provided "out of the box" Mesh Opaque/Transparent/Unlit with or without tessellation to create a custom base material tweaking the standard mesh_base.
The basic set of abstract materials to inherit from that is currently available in 2.15 covers only Mesh objects, but in the nearest upcoming releases, we plan to cover Decals, Volumetrics, and other types of objects as well.
Updated UUSL API & Rearranged Files
We have separated the Engine's internal shader functionality from shaders API available to customers, restructuring and moving all the related code to separate header files (like constants.h, gbuffer.h, matrix.h, etc.). We've put these files for you to data/core/materials/shaders/api.
This fact enables us to prevent shaders API from changing each release and ensure that all functions will be timely and properly documented. There were a lot of key changes made during the refactoring process, and the new UUSL documentation is planned to be prepared in the nearest future.
You can now create a new shader via the context menu right in the
It is enough to include a single common.h header to use the whole functionality.
Scriptable Post Materials
In 2.15 we've replaced old post materials. They are no longer needed, since you can use Scriptable Materials instead, as they provide extended functionality and flexibility, along with a better structure.
Old post materials from core\materials\default\post were migrated to ULON scriptable base materials and moved to the \core\materials\base\post\ folder.
The process of migration of other XML base materials to ULON base materials is in progress and is planned to be completed in 2.16.
Water System Improvements
Based on the feedback from our simulation industry customers, we have improved wave management for the Global Water object giving you precise control over the wave spectrum. Unique characteristics of each wave system can be set independently through spectral parameters, wave direction, length, and amplitude, and the shape factor of waves at run time via API (as all the data is now available on the CPU side). This functionality is available in a new Manual mode.
The list of features includes:
- realistic real-time water simulation based on fast implementation of Gerstner waves model;
- ability to create and control waves and wave groups (from largest to smallest), with the maximum of 256 simulated waves (recommended - 100);
- ability to control every parameter via API enabling you to apply results of calculations using different hydrodynamic models;
- practically no visible texture tiling effects at close and far distances;
- smooth change of sea states according to Beaufort scale;
- fast intersection detection and fetching water level at an arbitrary point at any moment of time (up to 10x boost);
- three wave-generation modes available, from fully automatic to fully customizable;
- flexible quality settings providing room for optimization.
In the framework of refactoring we have gathered all the parameters of the Global Water object in one place, moving most of the settings that were previously stored in the water_global_base material to the object and adding a number of new ones, and improved naming a bit. Controls in UI were rearranged to make it more intuitive and straightforward.
The important thing here is that new capabilities of the updated Global Water object come without unnecessary overcomplication. So, for those of you who simply want it to look plausible and realistic enough, without having to tweak a lot of sliders and combo boxes, there is an automatic wave generation mode called Beauforts and based on the Beaufort scale (from calm - 0, to hurricane - 12, just like it was before). Please be aware that Beaufort presets for various sea states are now available as separate nodes in the Create menu; old presets based on materials inherited from water_global_base were removed. There is a sort of semi-automatic Layers mode enabling you to create layers (via the Editor or code) for which waves are generated randomly based on a set of parameters.
The Oil Platform demo as well as all Water samples in the Art Samples suite now contain the updated Global Water object.
New implementation of water required a lot of key changes (multiple new settings added, migration of settings from materials to nodes, etc.). Which unfortunately makes automatic migration impossible. So in case you have used custom settings for water in your project, you'll have to recreate them again. If you used standard Beaufort presets, there's almost no migration required, and you can use similar presets implemented as nodes.
For more information please refer to the updated article describing the Global Water object.
Advanced Landscape Terrain Data Compression
Now you can compress landscape map files that you import into your project to significantly reduce their size (with compression ratio exceeding 100:1 in some cases).
The Compression tool allows you to select a lossless or lossy compression profile for your textures as well as to set up your own Custom profile.
We recommend using a UNIGINE-developed lossless compression method that provides better compression results for 2D and 3D textures than LZ4 or Zlib and does not reduce quality.
There is one thing you should be aware of: compressed layer maps cannot be modified fast at run time, so we recommend keeping major terrain data in compressed layers while having certain parts to be modified in uncompressed ones. We also recommend using Lossless compression algorithms (or disable compression) at the development stage to avoid quality deterioration on compress-uncompress operations and apply maximum compression when making the final build.
Sandworm Tool Upgrade
We continue working on Sandworm to make it an ideal terrain generation tool. For this release, we've fixed numerous bugs and introduced distributed computing — a possibility to generate terrains using the united power of your machine crew. So if your terrain takes a long time to be generated (more than an hour), you can speed up the process.
The concept is to use several computers united into a network, one of which is Master and assigns tasks, and the others are Workers that perform portions of work (processing of source data) assigned to them. UNIGINE Editor with the Sandworm tool and a terrain project should be open on Master only, while Workers run a single headless (console) application: no need to run SDK Browser and UnigineEditor, no additional licenses required. Source files (geodata) and common cache shall be stored in a shared folder. If a Worker still has available resources, additional processes may be run on it and participate in terrain generation immediately, i. e., without restarting the generation process. Master creates the asset based on the result.
We are also proud to introduce the updated building generation feature. Various types of roofs (flat, skillion, gabled, and hipped) are generated automatically either according to the GIS vector data provided or randomly using improved algorithms. Materials for roofs and walls (now with more realistic windows) look much better, and can be randomized with a predefined degree of probability.
We plan to improve generation algorithms further and create an add-on containing a rich pack of materials, to simplify creation of environments with a rich diversity of buildings, from bungalows and wooden houses to skyscrapers.
The following new features were added as well:
- Terrain generation in the headless mode (no additional licenses are required).
- Possibility to define the export area per layer for offline sources.
- Automatic 2.14->2.15 migration for .sworm assets.
- A separate set of source layers for objects/assets supporting multi-filtering (one item can contain several filters).
- Export Area mode that allows working with the Export Area only.
- Keyboard-editing of Export Area and Layer coordinates.
- Double-clicking an attribute in the table adds it to the value cell. Rearranged the filtering approach — made AND/OR operations possible within the same filter.
The list of other changes is as follows:
- Fixed an issue with non-responsive behavior at generating vector data if object parameters refer to non-existent GUID.
- Fixed mask naming for ObjectLandscapeTerrain.
- Fixed incorrect density calculation displayed in the layer properties.
- Fixed generation of buildings.
- Fixed issues with adding and deleting the Export Area points.
- Fixed issues with the creation of insets for layers with a higher data density.
We have extended the set of tonemappers Filmic, several Reinhard variations, ACES, and a combination of the last two. So you can choose the one that fits your project's requirements best, giving the desired look. You can control tone mapping via the Render -> Color Correction section of the Settings window.
In case you want to enable ACES tonemapper with commonly used settings simply reset all parameters to default values via the corresponding button next to each of them.
New Diffuse BRDF
Having studied a lot of various diffuse BRDF models we've decided that we need to implement our own, as none of the existing ones provides an acceptable visual result for us.
The main differences of the new BRDF model from the previous one are as follows:
UNIGINE now supports FMOD - a real-time adaptive audio engine enabling you to make music and sound effects that adapt to your application logic creating an even more immersive experience. FMOD simplifies the process of creating sound behaviors, with a comprehensive set of features for dealing with any scenario. It enables you to dynamically decode, mix, and output audio on any device (including custom ones, thanks to extensible outputs) with all major file formats and hardware-optimized formats supported. Dive into creative real-time mixing with 3D audio support and a built-in suite of DSP effects (with an ability to add custom effects and generators via plugins). Unlimited depth, sends, sub-mixes, and sidechaining give complete control over audio routing.
FMOD functionality in UNIGINE is available in C++ and C# via the FMOD plugin (currently for Windows platform only, compatibility is limited to the latest FMOD version 2.02.04). Please note that you need a license from FMOD to use it - refer to their website for available options.
For more information please refer to the FMOD plugin article. And don't forget to check out new FMOD Core and FMOD Studio integration samples in the SDK Browser: Samples -> 3rd Party -> Sounds.
Extended Mixed Reality Support for Varjo XR-3
Image Courtesy of Varjo.
We have made a number of changes to simplify implementation of Mixed Reality applications and improve your experience with human-eye resolution industrial-grade Varjo VR and XR headsets. Now we support Varjo SDK 3.3.0 and we have added support for chroma keying, so you can change environments quickly, along with depth testing enabling you to composite and sort real and virtual worlds together by utilizing the depth-sensing capabilities of XR-3 and XR-1. Tracking of static or dynamic real-world objects using the video pass-through cameras via markers is also available now. With Alpha Blend capabilities you can blend your virtual environment with the real world enabling efficient collaboration in both.
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.
Other Engine Improvements
- Added a new onFileSystemInitialized() callback right after File System initialization, so you can use it, for example, to dynamically add new mounting points during the initialization stage while displaying your boot screen.
- Fixed an issue with World Occuders failing to prevent occluded objects from rendering in case of setting low Distance values.
- Fixed an issue with Video Grabber saving images to HDR formats with the loss of data (.exr).
- Added an ability to change the application icon for your projects.
- Expanded BootConfig class API.
- Added a new getVisibleIntersection() method to the World class both taking into account the distance from the camera, LODs, and other "visual" aspects, the getIntersection() method now ignores the "visual" component enabling you to catch objects hidden by visibility distance (for example if an object LOD is hidden by visibility distance, but the object is within the frustum the intersection shall be detected). For more information, please refer to the API Migration Guide.
- Fixed an issue with an incorrect additional detail mask assignment for details of the Landscape Terrain object using an Additional Mask in case there is at least one detail that does not use an Additional Mask.
- Fixed an issue with Light Planar Probes rendering objects with LODs incorrectly.
- Fixed an issue with finding intersections with static meshes at the edges of polygons.
- Fixed a crash on saving an AppProjection configuration.
- Fixed an issue in clouds shading sometimes leading to shading artefacts in case several World Lights with different scattering types (Moon and Sun) are used.
- Fixed memory leaks in array-of-structure property parameters.
- Fixed an Engine crash on Mesh Clutter regeneration.
- C++ components can now be safely unloaded on the fly while the world is still loaded (e.g. when reloading plugins).
- Fixed a crash on shrinking the size of an array variable in a C++ component via ComponentVariableArray::resize().
- WorldIntersection::getInstance() now returns correct indices of intersected Mesh Cluster instances regardless of the number of meshes in the cluster.
- Marshalling functionality of the Wrapper class is now available, enabling you to use Engine's marshallers instead of writing your own, this can be useful when using C++ libraries in your C# projects.
- Restored the logic of guessing file extension for the FileSystem::LoadPackage() method.
- Changed C++ and C# API for Engine initialization, for more information please refer to the API Migration Guide.
To improve user experience in world building and resolve hotkey conflicts between different tools we have redesigned the UI for existing editor modes (Object, as well as Landscape and Clutter Mask Paint).
Accessing the corresponding tools has become more convenient and intuitive as simply switching between modes (available via hotkeys as well). UI tips and quick-access creators provide guidance to help new users get up and running quickly.
We have also made some restyling to the toolbar and other UI elements making all icons clearly seen at different resolutions, and the elements themselves more intuitive and convenient to use.
New Cluster Brush Editor
We have completed the first iteration of cluster editing mode. The first instrument implemented is the mesh placement brush. Apart from using mask textures, you can now scatter objects anywhere in the world using brushes.
Several meshes/objects can be scattered simultaneously with an ability to enable/disable drawing for each separate object. Each object stores its own scattering settings.
There are several brushes available: increase opacity, decrease opacity, replace opacity, and eraser.
The tool is still under development but a minimum set of functions is already available to be used in your projects.
Improved Clutter Brushes
Brush tool updates make painting on masks for Grass, Clutters, and Clusters more convenient and intuitive with an accurate current brush position. Objects are now generated on the fly while you draw, all objects using the same mask are updated at once. The updated tool becomes available after selecting Clutter Mask Paint Mode in the Modes dropdown.
Asset Browser Improvements
We have redesigned the Asset Browser to make it more flexible and convenient.
The preview panel has been moved to the Parameters window saving space and improving consistency.
New functionality has been added at the top of the window, which has become context-dependent now, unnecessary UI elements are hidden depending on the current Asset Browser layout. Each of the two panels has its own zoom factor for convenience.
A filter for asset types similar to the node types filter in the World Nodes window is now available enabling you to reduce chaos and concentrate on the desired asset types.
Search scope is now limited to the selected folder in the hierarchy. After selecting an asset in the search results and clearing the search query in the field the current folder will automatically change to the one containing the selected asset (similar to the logic of the World Nodes window).
You can quickly expand/collapse folders or show/hide assets in the folder tree via the corresponding buttons at the top. While the two new arrow buttons there make browsing folder history convenient.
Adding assets, folders, and even search results to favorites (per-project) has become available, search scope will be reset to global though.
You can simplify the layout keeping only the folder view and using it as the World Nodes hierarchy, or use the old familiar layout if you prefer.
Advanced Import of Materials from FBX-Assets
When importing an FBX asset, UNIGINE's Import System now detects if a transparency mask is used and automatically creates an Alpha Test material with the Two Sided mode activated. In most cases, when artists import materials with transparency, they actually work with vegetation that requires Alpha Test + Two Sided combination rather than simply Alpha Blend. This feature works with both types of materials graph-based and inherited from the mesh_base.
When importing FBX models, appropriate presets are automatically selected in import parameters for textures used in imported materials based on the slot to which these textures are assigned. For example, if a texture is assigned to the Normal Map slot, the Normal preset shall be selected for it, automatically applying the appropriate compression type. The set of textures that can be imported from FBX-assets now includes emission.
The dictionary of postfixes for texture import presets has been extended now including a number of variations corresponding to each texture type instead of using a single prefix.
Other UnigineEditor Improvements
- You can now check out asset dependencies for materials and properties right from the Materials and Properties hierarchy windows.
- We have rearranged Settings for your convenience with Tonemapper and White Balance controls moved from Camera Effects to the Color Correction section. The Postprocess section of the Settings window has been removed with its parameters moved to the following sections: Wireframe Color (Wireframe Color picker), Transparent (Refraction sliders), Camera Effects (Sharpen Intensity), SSShadows Shafts (Shadow Shafts sliders).
- Fixed an issue with UnigineEditor removing non-component C# files located in the data folder from the .csproj file when opening a project.
- Current resolution of a Landscape asset (.lmap) is now displayed in the Parameters window of the UnigineEditor.
- New tooltips for asset-widgets (like textures, meshes, materials) now contain a preview of an asset.
- When an asset is selected, its name and file size are now displayed in the Parameters window.
- Added an option to automatically load the last active world on opening the Editor. You can control this option via the Auto-Open Last World checkbox in the Settings -> Editor section (the state is stored in the .user config file). This option is disabled by default as in case of a faulty world it may lead to repeated Editor crashes.
- Adjusting curves in UnigineEditor has become even more convenient with new Copy and Paste operations enabling you to quickly set up similar curves. Copying a curve containing n values to the one having more values will replace only the first n ones.
- The Editor can now work in the background mode, when you need this functionality simply check Keep Running In Background in Settings -> Editor.
- Fixed issues with multiple rebuilding of a C# dotnet-project after deleting the .runtimes folder or saving an empty component.
- Adding nodes to the hierarchy has become faster, improving Editor performance and UX for large scenes containing a lot of objects.
- The number of currently selected assets is now displayed in the Asset tab of the Parameters window.
- Fixed an issue on performing Undo operation after assigning a new material to a Landscape Terrain detail leading to empty assignment, now the previous state is restored.
- Fixed an issue with incorrect camera focusing on a node located far away from the origin in double-precision projects.
- The FBXImporter plugin now writes relative paths to meshes in the generated .node files. Support for emission textures has been added as well.
- Fixed an issue with infinite playback of an audio file selected in the Asset Browser.
- Fixed an issue with resetting the size of thumbnails in Open/Save dialogs, now the dialogs use the last selected size.
Image Generator Improvements
High-Level Weather System
Introducing a new high-level weather system enabling you to manage global and regional layered weather both in UnigineEditor and via API. You can create an unlimited number of regions, both rectangular and arbitrary-form, add multiple layers to them and control each of them separately. Configure and adjust visibility, pressure, temperature, humidity, cloud coverage (with all existing types of clouds supported), precipitation, wind and other parameters per layer, set up region positions, thickness, altitude, and transition bands for layers, etc.
Improved simulation of lightnings now enables you to generate as many of them as you need at desired locations at run time via API with an ability to subscribe to related callbacks.
For more information on setting up environment in IG please follow this link.
Convenient Control Via UnigineEditor
A new IG Editor Plugin has been added with a set of windows enabling you to configure geodetic and date-time parameters as well as to control weather right in the UnigineEditor in a convenient way. There is a lot more you can now see and adjust via the UnigineEditor, from creating weather regions with rain and snow to changing aircraft strobe light programs via curves. Other updates are on the way, stay tuned for upcoming releases.
IG functionality is now available for C# developers as well, with some slight insignificant discrepancies. The C# IG template application is also at your disposal, simply select it when creating a new project in SDK Browser.
The list of other improvements includes:
- Fixed warming of particle systems on Slaves ensuring consistent particles behavior across all PCs.
- Fixed Slave crashes on loading a database via the console command on the Master (without a Host application).
A typical additional task for practically any simulation and training software (and actually for games too) that consumes quite a portion of development time budget is the creation of tools - scenario builders, scene editors, content placement tools, etc. Having to write your own implementation of Editor from scratch is hard, costly, and inefficient, especially when a lot of common things are already implemented.
We continue our efforts to simplify this task and help you cut expenses, enabling you to make your own domain-specific tools for user-generated content based on UnigineEditor functionality. This release brings you the first part of the new convenient public API providing access to this functionality.
Creating Editor plugins has become easier in 2.15 with SDK Browser integration and two project templates (Engine GUI Window and Materials) that can be used as a basis.
To start developing your first plugin for UnigineEditor simply check the Editor Plugin Template option when creating a new project in the SDK Browser. This will add all necessary files and create a separate project for the plugin that you can build in your IDE and test right in the Editor.
Some of our ongoing projects already implement Editor extensions using the plugins system and current Editor API including the IG Editor Plugin (described above).
For more information on developing custom Editor plugins please refer to the updated Extending Editor Functionality section.
Not all systems are covered at the moment, but we plan to extend the С++ API to provide access to everything available in the Editor and bring you the production-ready version in 2.16.
Demos, Add-Ons, and Samples
New Mars Demo
Introducing Mars - a new demo project in which 1 million square kilometers of the Mars surface is recreated (available in Sim edition only). You can drive the rover around the planet and view the Gale Crater using a 20x scopes support!
You can compare a real image of Mars surface obtained by the NASA Curiosity rover and a screenshot from the Mars demo (the same location), both given below.
This demo showcases features of the Landscape Terrain system. No static meshes involved, only a terrain object. Features:
- Highest geometry and texture detailing possible (up to 1 millimeter per pixel).
- 1000 x 1000 km area size.
- 8 x 8 km high-detailed zone (0.25 m / pixel mask density, 1 mm / pixel for detailed 4K textures).
- Dynamic craters (100 x 100 x 25 m) can be placed in real-time anywhere.
- Rover tracks as another demonstration of real-time modification of terrain surface.
- Up to 20x scopes.
New Material Graph Samples
Along with releasing the new Visual Material Editor we've added a new set Material Graph Samples to the SDK showcasing the use of Material Graphs for various use cases. Check them out, analyze and assemble your own incredible materials!
Updated CraneRope Sample
The Crane Rope sample was rewritten to use a Rope Body with a set of optimizations to stabilize rope behavior. You can now use real-world masses in kilograms for the load to be lifted. For your convenience, a set of controls was added:
- Keyboard keys for grabbing and dropping the load.
- Rope length Keyboard keys for grabbing and dropping the load.
- Debug Visualizer toggle key.
- Load weight slider.
A new sample demonstrating how to use Tracker to animate objects (change their position, rotation, and scale) via track-files was added to both C++ Samples and C# Samples, along with C++ and C# wrappers for Tracker functionality.
New Water Samples
A pack of new Water Global samples was added to C++ Samples suite demonstrating how to control Global Water via API:
- change Beaufort levels and the use of fetching of the water level at a certain point for simplified simulation of buoyancy without engaging Physics.
- change wave spectrum of Global Water (number of octaves, number of waves per octave, and various other parameters for random waves generation).
- simulate ship wake waves via Orthographic Decals and Height Field nodes
The Vegetation add-on was again extended with a set of small plants and a new pine making the total count of vegetation species in the add-on reach 50 types, most of them offering you from 2 to 20 variations. The following plants were added:
- Small trees (rambutan tree and hevea)
- Small mango tree (2 variations)
- Shorea (Pokok Damar)
- Palm oil tree (2 variations)
- Banana tree
- Coconut tree
- Fern (additional variations)
- Ivy (2 variations)
- Pine (additional variation)
- Small plants (4 variations)
Added a new video tutorial on Volumetric Clouds
Added a set of new ultrashort HowTo quick tip videos in English, Chinese, and Russian:
We have made efforts to resolve problems with indexing old versions of documentation by popular search engines in order to remove outdated information from search results. The current stable release version of the docs now can always be found at https://developer.unigine.com/en/docs/latest (version number is shown in the version selector at the top of the page). Old versions are available via their numbers as it was before.
Other Documentation Changes
- Updated IG documentation.
- Updated the article on Global Water and Water Optimization.
- Added a new tutorial section Vegetation: Authoring Tips.
- Added a new Material Editor section with Nodes Reference.
- Updated Sandworm documentation and added a new Questions & Answers section.
- Updated the section on Extending Editor Functionality.
- Updated Editor API reference.
- 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.15 is available in the Content Migration Guide.
Work In Progress
Round Earth Geo Plugin
The runtime plugin is designed to implement online streaming of terrain portions based on camera position transformed into geocoordinates. Depending on the distance from the surface, data are more or less detailed. The plugin will be available as a part of an experimental build released together with 2.15.
New In-App GUI
Current GUI implementation has a number of weak points and limitations. A new GUI system implemented using the component-based approach is to replace the current one and will be much more flexible and easier to use. Simplified widget transformation and scaling, improved intersection testing with advanced flexible control, stylesheets, better layout based on components (horizontal, vertical, grid, or panel), visual and logic components for widgets for advanced customization to fit the needs of any project. Since releasing an experimental build in mid-September, we have made some changes here.
The most important thing is that SDL is now executed in a separate thread and cannot cause blocking of the Engine's thread. This means dragging and docking windows along with changing their sizes without affecting the update of logic. Another thing done is full support for OpenGL and Linux. Even more extended window customization is now available (only for the Engine's widgets at the moment), including the sizes of the window title and borders, additional custom user elements in window titles. A lot of things can be changed for windows and groups, from icons to window titles and background colors. The main window has become dockable too. And an ability to control sizes of all nested groups and windows via API has been implemented.
We continue to work hard to bring you this exciting GUI update in 2.16.
We continue our efforts on implementing offscreen rendering mode, making it possible to run UNIGINE Engine in a cloud and use powerful servers, for example, to generate photorealistic datasets for deep learning and verification of AI algorithms for UAV, automotive, and other industries. Part of the job is done at the moment, and what you can see below is a demonstration of images generated by the Engine in headless mode and displayed via a web browser.
DirectX 12, Vulkan, and Consoles
We have a DirectX 12 version of the engine working as an internal branch already. The performance is comparable or higher than in DirectX 11, and we keep pushing for this. First we test this version with internal projects, later next year it will be available as a production version for all customers.
The engine is being ported to game consoles as well. The Xbox Series X looks almost feature-complete, the PlayStation 5 version is in the early stages.
Vulkan version is considered for the next versions as well, utilizing the current progress with the low-level graphical APIs.
Thank you for reading, and stay tuned for future updates - many great things are yet to come!
- Your UNIGINE Team