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

UNIGINE 2.13: GPU Lightmapper, Volumetric Clouds Upgrade, Better Anti-Aliasing, New Terrain Tools Preview

Key Changes

  • GPU Lightmapper tool
  • Introducing SRAA (Subpixel Reconstruction Anti-Aliasing)
  • Upgraded 3D volumetric clouds
  • Performance optimizations for vast forest rendering
  • New iteration of the terrain generation tool with online GIS sources support (experimental)
  • Adaptive hardware tessellation for the mesh_base material
  • Project Build tool: extended functionality and a standalone console-based version
  • New samples (LiDAR sensor, night city lights, helicopter winch)
  • Introducing 3D scans library


Notice: UNIGINE 2.13 SDK requires SDK Browser version 1.9.28 or later.

GPU Lightmapper Tool

Introducing a new GPU-accelerated lightmapping tool for baking global illumination providing unprecedented quality results out of the box.

Lightmapping is currently the most efficient technology providing the maximum realism of diffuse lighting while keeping the performance high. The number of light bounces is the key aspect of creating realistic lighting in bright scenes. No other technique is capable of giving you such a high-detailed global illumination with so many bounces. When you use lightmapping it doesn’t matter how many rays, bounces, or light sources are there, as everything is calculated once and then baked in textures.

But lightmaps are not an ultimate solution for everything, and they are not intended to replace Voxel Probes.These are two different mechanisms for different cases, each of them having its own advantages and weak points. Voxels will never be as realistic as lightmaps or have similar size, and they cannot provide the same density due to a number of factors. But Voxel GI is suitable for any high-poly or low-poly geometry, does not require UV maps, and can be used for dynamic objects (which obviously falls beyond the scope of lightmapping). Voxel GI in a world is provided by separate nodes - Voxel Probes, which gives you a lot of flexibility. You can toggle them on and off one by one, mix them as you want to achieve the desired result. However, high-density voxels are pretty heavy. The great thing is that you can combine these two techniques as well as choose any of them to fit your project’s requirements (e.g. lightmaps would be the best option for high-quality lighting in a static scene, but if you want some dynamics, add voxels where necessary).

Automatic UV Unwrapping

There is an automatic UV unwrapping tool to save you from preparing UVs for lightmaps manually. It copes well even with complex high-poly geometry taking several minutes, while simple models will be done in seconds.

Bake Lighting Tool

The Bake Lighting window has got a straighter UI. It is now a complete robust tool providing convenient access to all light baking tasks and enabling you to control which types of nodes are to be affected. You can also enable automatic re-baking of shadows and environment probes on changing some of their important parameters via the new Automatic Rebake option.

For detailed instructions on how to use lightmaps please refer to our documentation.

Levels of Detail

You can bake a separate lightmap for each LOD. Moreover, you can save space by sharing already baked lightmaps between different LODs (works for LODs having the same UV maps).

Current Limitations

  • Lightmaps can only be applied to static meshes at the moment, but we plan to extend the scope of supported objects.
  • No directional lightmaps are available at the moment, so normal maps for surfaces currently won’t be taken into account. We’ll surely add directional maps in the future to tackle this important issue.
  • Voxel Probes provide reflections for rough surfaces while lightmaps don’t. We plan to add reflections together with directional lightmaps. Meanwhile, if you use Voxel Probes for dynamic objects, reflections provided by the Probes can be used as well.
  • Lightmaps currently support baking Global Illumination only, no direct lighting is baked. We plan to add this feature soon, meanwhile you can use real light sources with static shadows providing even more details as they work on a per-pixel basis.

SRAA: Better Anti-Aliasing

We've introduced Subpixel Reconstruction Anti-Aliasing (SRAA), an additional anti-aliasing technique that restores small image details providing a net speedup and minimal overhead compared to supersampling.

It is recommended to combine this technique with TAA for better anti-aliasing quality. All related settings can be adjusted via the UnigineEditor or via console commands.

More Advanced Volumetric Clouds

Improved Shading

Lighting of the clouds has become even more realistic with an updated phase function and improved approximation of light scattering in clouds enabling you to control shadows on clouds by adding a view-dependent effect making the difference between looking at the clouds against the sun and a side-view.

The list of other shading improvements includes:

  • A new Sun Attenuation parameter replacing the old Translucence parameter to control sunlight attenuation.
  • In-scatter probability implementation, which accounts for the dark edges and bases to clouds (Inscatter Intensity parameter).
  • A new Sun Saturation parameter to control saturation of the sunlight to make clouds less yellowish.

Please note, that changes in shading require manual re-adjustment for the best result.

Noise Reduction

Lighting noise, noise from the clouds shape in case of large ray marching distances resulting in incorrect shading, these artefacts no longer spoil the look of clouds. These improvements are noticeable when flying through clouds looking at the horizon. With smooth transition (no popping effect) on leaving a rounded cloud layer and a bit of noise-based blur added to a sharp border at the bottom sphere of such layers the clouds look even more natural. The performance-quality balance of this functionality is controlled via Step Accuracy parameter or via the render_clouds_step_accuracy console command.

Accurate Layers Sorting

Accurate sorting of multiple overlapping cloud layers is now available, you can enable it if necessary via Settings -> Render -> Clouds or via the render_clouds_accurate_layers_sorting console command (works slow on OpenGL).

Better Quality at Lower Cost

Interleaved rendering mode for clouds giving a performance boost was unacceptable for "inside-clouds" cases due to a number of visual artefacts and unavailable depth testing for opaque geometry. Using the Downsampling optimization only engaged depth testing but made the edges of geometry suffer. We have fixed this, so now you can use Interleaved mode with the new Depth-Based Reconstruction option and fly in the clouds without artefacts with a 2x performance boost!

Depth-Based Reconstruction is only available for Downsampling (half) and Interleaved (2x2) modes.

By default we now use simplified depth testing for clouds (objects inside cloud layers are overlapped by the clouds). So, the corresponding parameter was removed from the Settings along with the render_clouds_simplified_depth_test console command.

Other Clouds Improvements

  • The same detail noise can be applied directly for wispy and inversely for billowy forms of the clouds with an ability to control the transition between these forms via the corresponding Gradient parameter (or detail_wispy_billowy_gradient via the console).
  • Depth buffer is now used to reduce ray marching distance for rounded clouds and improve ray marching quality.
  • Added temporal noise accumulation for interleaved clouds rendering mode to improve visual appearance of clouds (works only for 2x2 Interleaved mode). Available via render_clouds_interleaved_rendering_temporal.
  • Improved haze-clouds interaction ensuring correct haze rendering when viewed from inside a cloud layer (earlier there were no haze in the clouds) and proper mixing of the long-distance range haze gradient on the clouds with the background. Interaction of thunderclouds with the haze gradient now looks more natural as well.
  • Removed the deprecated render_clouds_shadow_shafts console command.

Adaptive Mesh Tessellation Everywhere

Tessellation for static meshes is back again (as it was in UNIGINE 1), in addition to the water and terrain systems using adaptive hardware tessellation. The mesh_base material now supports Adaptive Hardware-accelerated Tessellation that subdivides low-poly surfaces into finer meshes, to achieve higher visual quality (add more details) for a lower rendering cost.

There are two alternative tessellation options available:

  • Tessellated Displacement - performed along the local surface normal based on values stored in a special Displacement (height) texture.

  • Tessellated Vector Displacement - using a texture that stores displacement along the X, Y, and Z axes, useful when some complex shapes with overhangs are needed.

To enable the feature just set the desired option in the Displacement dropdown for your material.

Tessellation has flexible settings and a set of optimizations enabling you to do fine-tuning based on the distance and visibility angle.

For more information please refer to the article on the mesh_base material.

Faster Impostors (Up To 10x Boost)

Impostors, that are used instead of real geometry to gain performance (trees in forests, buildings in towns, etc.), have got their own performance faster along with a better look. Optimized depth calculation for impostors has brought a 10x performance boost. Improved linear interpolation of sprites when the camera rotates around the object is now available (in two modes full and horizontal). It makes transitions between sprites smoother avoiding abrupt switching and also offers a special Fix Blur option that helps making details of sprites look sharper and less blurred reducing the negative effect of linear interpolation. The interpolation itself has become 3x faster due to depth prepass optimization.

New settings are available in the Impostors Creator tool and in impostor materials as well.

Adjustable Fisheye Projections

Fisheye projection now has adjustable FOV and supports various mapping types: equidistant, equisolid, stereographic, and orthographic (only for FOV < 180). This is especially useful for training Neural Networks (NNs) for autopilot applications as it is crucial to simulate real cameras installed on aircrafts, and characteristics of these cameras may vary depending on manufacturers.

Panorama and Stereo modes are now controlled via the single Viewport Mode option available in the same Screen section of Render Settings window (see related updates of console commands and API).

IES Profiles for Lights

Light's distribution for omni and projected light sources can now be defined by an IES profile, a lighting industry standard of describing light’s distribution from the light source based on real-world measured light fixtures (see the updated Lights sample in the Art Samples suite).

SSGI Intensity Boost

Screen-Space Global Illumination as a screen-space effect has a number of weak spots which may cause incorrect brightness of rays. We have added a new Intensity Boost option to fix this by increasing SSGI brightness while keeping it in accordance with the physical law of conservation of energy.

Advanced Color Correction

Color correction is now more convenient with the curve-based workflow. You can control tonal range, tone response, as well as luminance of the scene, by adjusting Curves. A new Saturation Correction curve enables you to control saturation of the final image based on the input luminance.

Fine-adjustment of saturation and hue for major components of the color spectre is available as well.

For more information please refer to the Color Correction article. Please note that the Color section of the Settings window has changed its name to Color Correction, all related API methods and console commands were renamed as well, so please be sure to check out API Migration and Console Migration guides for details.

Emissive Decals

Emission feature is now available for decals enabling you to simulate huge amounts of lights at far distances, like cities in the night viewed from an aircraft, without affecting performance much. The Emission state with Color and Scale parameters were added to the decal_base material.

Other Rendering Improvements

  • Added new options to control SSR bias (View Bias and Normal Bias) fixing artefacts caused by incorrect offset for ray marching used in SSR calculation.
  • Fixed internal TAA ghosting of geometry pinned to the camera.
  • Refractive objects in front of water and clouds are now rendered correctly except for the case when render_clouds_transparent_order = 1.
  • Renamed the Sun Shafts effect as Shadow Shafts, all related settings in corresponding materials are renamed as well.
  • Optimized Mesh Decals rendering providing a minor performance gain.
  • Fixed shadows rendering issues (e.g., missing shadows from grass) taking place in some cases on a TerrainGlobal with Decal-based holes.
  • GBuffer Velocity is now rendered correctly when displaying texture buffers used by the renderer (render_show_textures).
  • The Use Voxel Probe state for Object Particles now works properly on OpenGL.
  • Removed shaders reload functionality please use materials reload instead.
  • Fixed Terrain Lerp functionality for meshes having a material with the Alpha Blend preset assigned.
  • Restored Terrain Lerp functionality for ObjectTerrainGlobal.
  • Fixed an issue with blending ObjectTerrainGlobal masks having a fully black albedo color.

Export to FBX

Models from your UNIGINE scenes can now be exported to FBX format to be used or edited elsewhere. Each mesh surface is exported as a separate node (so you can combine them back into a single mesh on re-importing) all object names are kept as per the World Nodes Hierarchy. You can choose whether to preserve or reset node transformation when exporting it. The functionality is implemented as a separate FbxExporter plugin and is available at runtime via API for Engineering and Sim SDK editions.

C# Component System Improvements

In your C# components you can now use external classes and structures (declared outside the component). Sometimes the logic of your application may require using structures to pass data between the components and methods, definitions of such structures are declared at the logics layer so they can be passed to the methods themselves.

Source code (C#)
// External structure declaration
public struct ExternStruct
    public int i;

// ...
// first component declaring the NestedStruct structure
public class SomeComponent : Component
    public struct NestedStruct
        public float f;

// ...

// second component using the NestedStruct and ExternStruct structures
public class TestComponent : Component
    public ExternStruct extern_struct;
    public SomeComponent.NestedStruct nested_struct;

Other C# Component System Improvements

  • You can now use the F5 hotkey in the Editor to launch an instance of your C# application instead of clicking the Play button (available for C# projects only).
  • Parameters of a C# component are now properly displayed in the UnigineEditor right after importing the component.
  • Fixed a PropertyParameter-related memory leak.
  • More MathLib methods are now available in C# API with a number of minor inconsistencies fixed.
  • Fixed an issue with detection of .Net SDK versions sometimes occurred on Linux in case of multiple versions installed.
  • Fixed a garbage collected delegate crash.

Console Improvements

The extended Console API makes the appearance and behavior of the application’s console and messages printed on the screen fully customizable. It becomes easier to control text output and formatting. Moreover, you can now choose whether to display your messages, errors, or warnings on the screen, print them to the console, or perform both operations at the same time along with filtering written messages by type. All of these improvements enable you to monitor events in the application logic as you see fit.

For more details please refer to the API Migration Guide.

Other Engine Improvements

  • World Switcher now works properly for huge (tens of thousands) numbers of managed nodes in its hierarchy.
  • The plugin_quit console command will now unload the library from memory enabling you to reload plugins at run time (i.e. shutdown the plugin, recompile it, reload it).
  • Added an ability to make a mesh used by a Dynamic Mesh object unique (changes made to this mesh won't affect other Dynamic Meshes on the scene). The functionality is available via API.
  • Framerate of a QML application can now be restricted to a desired value.
  • Fixed an issue with ignoring *_config startup command-line arguments.
  • You can now use both the data_path and project_name CLI-parameters together (e.g., to separate shaders cache, log files and so on from the actual data).
  • Fixed an issue with invalid plugin paths sometimes saved to the boot configuration file, when autosave option is enabled.
  • ObjectParticles shall now update properly when Update Distance Limit is set to infinity.
  • Fixed an issue with deleting the whole WorldSplineGraph object on removing a single point/segment.
  • Sound Source now takes into account the time interval when it wasn't heard (its update distance was exceeded) when resumes playing.
  • Fixed an issue with collision detection for objects having a body with the Immovable option enabled.
  • Fixed a crash on deleting an FBX-model from the Asset Browser after generating a ragdoll body for it.
  • Fixed an issue with ignoring mouse events when changing window focus.
  • ObjectGui updates are now bound to engine.ifps instead of game.ifps making it update every frame even when the application is paused (game.ifps = 0).
  • Bound box of a Decal Mesh is now updated after reimporting a source mesh/FBX asset.
  • Fixed a crash on adding an empty surface to an ObjectMeshStatic.
  • Added a new WidgetSpinboxDouble widget to ensure proper management for double values.
  • Fixed an NVIDIA GPU driver crash on loading a material with an EXR texture used as a parallax displacement map.
  • Fixed an issue with a mask failing to be applied correctly after changing image format from ATI/DXT to any other format (R/RG/RGB/RGBA).
  • Fixed a memory corruption issue in the Interpreter.
  • Fixed an issue with the setMeshTransform() method of the ObjectMeshCluster setting incorrect bounds for cluster elements.
  • There are no texture atlas size limitations for particles anymore, you can specify the desired size via the corresponding parameter.
  • Fixed an issue with particles moving along with the emitter after being spawned.
  • Removed a deadlock between CPUShaders-related sync and async threads sometimes causing the Engine to freeze during a sequence of restarts.
  • Fixed a crash on the WPF sample application shutdown.

API Improvements

  • Added the following new API functions for gathering information about lights at rendering time:
  • You can check if vertex data of an ObjectMeshStatic was flushed (created/uploaded) to video memory via API using the MeshDynamic::isFlushed() method.
  • Added an ability to evaluate a value of the 2D curve at the specified point in time via the Curve2d::evaluate() method.
  • The Viewport::renderTextureCube() method is now available in API.
  • Added an ability to identify an input device via a unique ID implemented via getGuidProduct() and getGuidInstance() methods (available for Windows only). This can be very useful in case your application uses non-standard custom input devices to ensure proper configuration (dead zones, inverse flags, correction curves, etc.).
  • Fixed a casting-related issue with the InterfaceWindow::setWidget() function when a WidgetDialog is passed as the parameter.
  • It is now possible to access the number of constants in a namespace, and obtain the type and value of each constant by its index via Interpreter’s Reflection.
  • The convertible check in the checked_ptr_cast() method now processes complex inheritance hierarchies properly instead of simply checking for a direct inheritance.
  • Added a new getLastStreamingFrame() method for the ObjectLandscapeTerrain class enabling you to check if the Landscape Terrain data is loaded completely at the moment (the Virtual Texture is created and the last commit to it is already applied).
  • Now it is possible to find node(s) in the world by type, ignoring hidden and system nodes. The functionality is available via the getNodeByType()/getNodesByType() methods.
  • Added a new ownership flag for the texture. If the flag is set the Engine takes care of the texture as if it was created by the Engine, otherwise the user should manage the texture manually (destroy the object, do all necessary memory cleanup).
  • The getColor() method of ObjectMeshStatic/ObjectMeshSkinned now returns a color vector with components in the [0...1] range for consistency.
  • For more details on API changes please refer to the API Migration Guide.


New Manipulators for Shapes

You can now adjust transformations of collision shapes just like you normally do it for nodes with multi-selection, cloning (Shift + translate), etc. Please note that the Scale manipulator actually controls size parameters of the shape (like radius for the sphere, height and radius for capsule and so on), it doesn’t affect convex shapes, as they have no such parameters.

Scriptable Materials Integration

Scriptable Materials represent, an ideal instrument for fast prototyping of your own custom post effects (DoF, Bloom, or any other), are now fully integrated into the UnigineEditor, you can add as many of them as you want globally via the Scriptable Materials section of the Settings window, or just for selected camera(s) via the Parameters window. Scriptable material lists are pretty much like the lists of components assigned to nodes, enabling you to adjust all available parameters and control which materials to apply.

A set of ULON-based scriptable materials implementing various post-effects (radial blur, vignette, chromatic aberration, AO modification, etc.) illustrating the concept is included in the SDK (data/samples/shaders/scriptable_00).

Other Editor Improvements

  • Dragging a property to a node shall now apply it to the node, not to a surface.
  • Fixed multi-selection behavior for curve-based parameters.
  • Fixed curving of static meshes used with ObjectTerrainGlobal via Make Curved.
  • Added a new button to the Help window with a direct link to our Discord channel.

  • Internal names of material's textures and parameters are now displayed in tooltips, clicking on the name of the parameter/texture shall copy an internal name for it to the clipboard, so you can then paste it to your code.

  • Fixed restrictions for unsupported node types when trying to export them to FBX.
  • UnigineEditor no longer freezes on baking shadows in case the scene contains a large number of MeshClutter and Grass objects with materials having the Cast World Shadow option enabled.
  • Albedo Color clamping by Max Value in the Curve Editor for Particles now works properly.
  • Fixed a track loading issue leading to a failure to grab a video sequence based on a track using the Video Grabber tool.
  • Added a callback to handle logging out message, warning, error, and fatal messages to the Log class.
  • Fixed an issue with duplicate folders created by the Video Grabber or FBX-importer when importing FBX-assets with textures.
  • On hovering a mouse cursor over a material or property in the Materials/Properties hierarchy a path to the corresponding asset shall be displayed.

  • All textures in an FBX asset are now imported properly with correct paths on Linux.
  • Smooth Landscape Terrain brush now works properly at the edges of Landscape Layer Maps.
  • Fixed a crash on picking a Landscape Terrain color via Alt + Click.
  • Names of missing properties assigned to nodes or surfaces shall now be displayed in red in the UnigineEditor.
  • All keys are now mapped correctly for the French keyboard layout.
  • Fixed an issue with resetting the controls_mouse_handle parameter in the configuration on closing the UnigineEditor.
  • Fixed an issue with inverting a Ctrl hotkey preset for a Landscape Terrain brush after saving a world via Ctrl + S.

Standalone Project Build Tool

The Build Tool introduced in 2.10 has become more mature now offering you advanced dependency tracking and control flexibility. Moreover, it is now available as a standalone console-based application simplifying continuous integration (CI) and batch processing. You can configure all necessary build options via a dedicated file and override some of them via CLI-options when launching the tool.

For more information please refer to the updated Build Tool article.

Standalone Runtimes Generator

Normally the .runtimes folder content is updated automatically when you open the Editor. Imagine you have a VCS managing only your assets, and you’d like to trigger generation of the .runtimes folder content right after checking out the latest version from the repository and then run your application, without the Editor. Introducing a new Runtimes Generator command-line tool enabling you to generate runtimes, right from the command line.

Image Generator and Multi-Channel Rendering Updates


Syncker, our multi-channel rendering plugin, has got a number of improvements ensuring even more accurate frame-to-frame synchronization.

  • The Synchronous mode was removed with a part of its functionality taken by the Asynchronous one.
  • Improved support for NVIDIA Quadro G-Sync. The Syncker now uses NVIDIA API to set synchronization groups and barriers. When running in NVIDIA mode (-sync_swap nvidia) detailed information on the current synchronization state is printed to the console. Works only for NVIDIA Quadro GPUs.
  • Changed the way the Master's getTime() and Slave's getMasterTime() work. Now there is a universal getTime() method of the base Syncker class now returning the time of the last buffer swap (beginning of the current frame, not some current moment of time on the Master). A new getIFps() method was also added enabling you to get the last frame time. Differences between Syncker::getTime() / Syncker::getIFps() and Game::getTime() / Game::getIFps() are as follows:
    • Syncker returns double values instead of floats.
    • Syncker::getIFps() implements a more accurate frame time calculation method (right after swapping buffers).
    • getTime() returns the current Master’s frame time (even when called from a Slave).
    • You can check a new Syncker IFps line in the Performance Profiler, the chart looks much more stable than the Total Time.
  • Significantly improved synchronization accuracy (image, timing, network interaction, and overall perception).
  • Added support for vertex animation synchronization (Grass, etc.).

Debug Mode

The debug mode for IG (ig_debug 1) has been added to visualize the following information:

  • Where LOS/HAT/HOT requests are sent to
  • Tracing of the entity path - position between frames and data sent over the network
  • Segments of every entity
  • Volumes of every entity
  • Basis of every entity with the ID and type specified
  • Time period of visualization

In the Debug mode it is now possible to switch to the free-flying camera (F) and back (G).

Changes in IGConfig Class

The IGConfig class introduced in 2.10 to let you manage IG configuration (ig_config.xml) via API has become more convenient now enabling you to get data of various types (from int, float, and string to entities, views, etc.) from the configuration, make modifications and save them to a file.

IG Host (Experimental)

IG interacts with hosts via network, it receives requests and sends responses. So, to check out IG features or do some debugging you need a host. Introducing IG Host — a cross-platform and cross-protocol solution you can use to establish test-communication with IG.

Currently the host represents a simplified version of CIGI HEMU but it shall evolve and already offers a number of useful advantages:

  • Simplified entity control.
  • Transparent packet transfer (requests and responses can be viewed in the console).
  • CIGI Debug mode.
  • Improved LOS responses.

Further evolution includes adding support for HLA and DIS protocols. IG Host is a part of CIGI demo. For more information please refer to the IG Host article.

Other IG Changes

  • Now all IG components should be inherited from the ComponentBaseInterface class just like all other C++ components.
  • New console commands have been added to enable and disable interpolation, and set interpolation and extrapolation time periods.
  • Fixed an issue with incorrect Azimuth and Elevation sent to the LOS Vector request.
  • Particles in the world (Weather=>Rain/Snow/Fog) now won't be rendered atop of the Projections Configurator.
  • Fixed an issue with collision volumes ignoring non-entity contacts.

Demos and Samples

LiDAR Demo

LiDAR is a method used in self-driving cars, drones, robot vacuum cleaners, etc. for optical scanning of surroundings. This demo contains the LiDAR emulation that can be used for training autopilots and AI. A quick and accurate scanner is implemented using the depth buffer.

You can configure your LiDAR (set the desired range, FOV, resolution, and other parameters) via API. The demo is available for Sim SDK edition only.

CraneRope Demo

Rope physics can be extremely difficult. That's why we created a demo that features a simple and elegant way of creating a winch or hoist using a combination of dynamically added JointBalls and geometry. This type of winch is suitable for simulation of helicopter operations or heavy duty equipment towing. The rope is implemented as a C++ component that you can use in your project.

The demo is available for Sim SDK edition only.

Earthworks Demo Updated

Terrain in the Earthworks demo resists digging now, and bucket filling affects backhoe handling. Grading operations are now available with a differentiation of the degree of soil compaction between the initial (untouched) ground and piles of excavated soil. With simulation of material flow and crumbling of piles while unloading a bucket the whole process is becoming closer and closer to reality. We have also improved overall performance and added gamepad support.

New Scans Add-On

New Scans content add-on has been added to SDK. It contains a set of ready-to-use assets created on the basis of real-world photogrammetry (scans of stones, wooden debris, etc. to add more diversity to your outdoor environments. We plan to keep updating it with new objects in further releases.


The following updates were introduced to the Art Samples suite:
  • Updated Global Illumination samples with usage examples for lightmaps, combining lightmaps and voxel probes. To demonstrate global illumination, a new Interior scene with a simple interior has been created.
  • Updated Lights samples: demonstration of IES profiles and imitation of baked light from light posts using lightmaps.
  • Updated Landscape sample with a new Decal Emission option used to create a scene imitating night lights.
  • Added a new Tessellation sample.

New Sandworm Tool (Experimental)

Introducing our new landscape generation tool rewritten from scratch with a lot of UI/UX improvements enabling you to generate the new Landscape Terrain based on georeferenced data (support for non-georeferenced data sources is to be added). You can use raster (elevation, imagery, and masks) and vector data sources from your local storage device, or connect to both, open services (such as OpenStreetMap or various state/municipal databases) or private tile servers created and supported by users on the basis of services similar to QGIS (currently supported data from online sources: imagery and elevation). To generate a terrain using the data from the OpenStreetMap TMS-service simply mark the desired area on the world map, enter service URL and desired zoom value - that’s it!

Most of the widely used projections are supported, moreover, you can combine sources with different projection types within the same project.

A basic set of tools is also implemented including mask-based generation of vegetation and 2.5D buildings generation.

Please note that this is an experimental tool with limited functionality and it surely has imperfections. Your feedback regarding the tool, its functions and issues is very much appreciated and will help us make it better. Please note, that the Sandworm tool currently does not generate ObjectTerrainGlobal, use Landscape Tool for this purpose.


More Languages (Chinese And Russian)

Our community grows uniting 3D enthusiasts and experts of different nations. But some of them get frustrated, not always being able to understand English, therefore we’re working on making our Docs available in multiple languages. By this release our localization efforts have brought us the majority of up-to-date articles in Chinese and Russian. And we will continue adding more articles and languages for you!

Please note that automatic translation always has imperfections, for your convenience you can check out the original text to eliminate ambiguity - simply hover the mouse cursor over the sentence while holding the Shift key.

Learning Materials

Several Technical Livestreams With Experts were recorded with additional subtitles available in Chinese and Russian:

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

Other Documentation Changes

The up-to-date list of learning materials can be found in the new Learning Support section of the website.

Build: ()