UNIGINE 2.7.2: CAD Models Import, Improved Collaboration, Impostors and Terrain Holes

Notice: UNIGINE 2.7.2 SDK requires SDK Browser version 1.9.7 or later.

Improved File System and Collaboration

We continue improving our File System to make it more reliable and flexible. We know that collaborative development of projects is one of the most important features for you, so your demands and suggestions were taken into account to provide easy and convenient project workflow.

UNIGINE File System now lets you use:

• single content source for several projects (folder, network share, or repository);
• several content folders for a single project (analogue of multiple data paths).

You can combine both to fit your needs, thus re-using content, avoiding unnecessary copying and simplifying collaboration between the members of your team:

• letting several artists work with various content folders independently;
• making programmers and artists independent by splitting code and content.

Mounting External Content Directories

Introducing a new mount point feature - a sort of a symlink enabling you to extend the virtual file system of your project by adding any external folders and packages to the data directory. This feature replaces external packages, *.ulink files and multiple data paths.

A UNIGINE-based project now has a single data directory containing all assets and runtimes of your project. It can also contain mount points created via Asset Browser (Create -> Create Mount Point).

All folders inside a mount point are treated by the file system as ordinary folders with assets inside the data.

Inside each mount point, there is a .runtimes folder that stores runtime files generated for assets of the external directory. Note that they aren’t added to the data/.runtimes folder. If you move an asset from one mount point to another, its runtimes will be moved as well.

When a mount point is used by multiple users, only one of them can modify it, for others the point should be read-only.

A read-only mount point doesn’t allow any changes in the folder or package it refers to. Such folder must contain assets with all .meta files and runtimes generated. Otherwise, they won’t be available in the Asset Browser. The workflow here should be as follows:

• All .meta and runtime files for assets are generated once and saved/committed to the common folder/repository.
• For each project using assets from this folder/repository a read-only mount point referring to it is created.

Please note, that all .meta files and runtimes in the mounted directory/package must be valid and up-to-date. All assets, that were not properly migrated, as well as the ones having outdated .meta or runtime files will be unavailable and won't be displayed.

When working with mount points there are rules to be followed:

• Nested mount points can be used: a folder referenced by a *.umount file can store another *.umount file, etc. However, looped (recursive) mount points are not allowed: you cannot create the 2.umount inside the 1.umount that refers to 1.umount.
• *.umount files cannot be packed, as well as packages cannot store other packages.
• Each *.umount file should have a unique name. If the data folder contains a folder having the same name as the mount point, this mount point will be ignored.
• Automatic resource reloading isn’t available for the mount points. So, you will have to update each of them manually by right-clicking it in the Asset Browser and choosing Refresh Mount Point.

A mount point is represented on the disk as a *.umount file in JSON format.

Optional guids.db File

Collaboration is no longer bound by the one and only guids.db file, now it is optional and can be stored anywhere inside the data folder: the Engine will be able to read it. Each folder of the project, whether it is mounted or not, can have its own guids.db file.

Moreover, the Engine can now read asset .meta files. So if a file wasn’t found in the guids.db for some reason, or guids.db files are missing, the Engine will search among all .meta files inside the data folder and all mounted external directories and packages.

Changed Paths Resolution

An important change is that UNIGINE File System is now “strict” by default. So, the exact file location will now be checked instead of some partial path inside the data directory, as it was before. This approach makes working with project files clear and straightforward.

For example, in UNIGINE 2.7.2, the following code will play the sound only if its full virtual path is 1.oga:

AmbientSourcePtr source;
source = AmbientSource::create("1.oga", 1);
source->setLoop(1);
source->play();

In previous versions, it could be the first found sound source, the virtual path of which contained 1.oga. To perform the exact search, you had to do the following:

source = AmbientSource::create(FileSystem::get()->getRelativeFileName("1.oga",1), 1);

However, there are some exceptions - non-strict search (i.e., specifying partial paths) is available for all cases where user can enter a path manually:

• World loading operations: a world will be found and loaded by its name
• Include operations in the source code
• UI files
• Paths to textures and font files

If you actively used partial paths in your project, you should resolve them via the resolvePartialVirtualPath() method, that converts the given partial path to the virtual one, and then use the resulting path.

Moreover, the Engine can resolve paths that are specified as absolute, but actually are virtual.

Example:

There is a project stored in the D:/projects/unigine_project/ folder. In the data folder of this project, there is a test.umount that refers to a D:/content/test/ folder with the 1.tga texture.

The following methods can be used to resolve virtual and absolute paths:

getVirtualPath(“D:/projects/unigine_project/test/1.tga”);
// Result: test/1.tga
getAbsolutePath("D:/projects/unigine_project/test/1.tga");
// Result: D:/content/test/1.tga

Other File System Improvements

• Pre-cached file hierarchy stored in the *.ulist files isn’t available any more. Now the Engine always performs dynamic scanning on its start-up.
• File name modifiers have been removed.
• All *KnownFile() methods have been renamed *VirtualFile().
• Added mount-related API methods, for more information please refer to the API Migration Guide.

CAD Models Import

UNIGINE’s Import System is getting more and more versatile, this time we added a new CadImporter plugin that allows fast importing of heavy CAD models in native formats into UNIGINE: IGES, STEP, STL, BREP. The list of supported formats will be extended in future releases.

_{M-11L aircraft engine by Michael}

As the Import System is utilized by both the Engine and the Editor, you can import your CAD models at run time via C++ and UnigineScript API as well as in the Editor. The plugin is fully customizable, just like the FbxImporter.

UNIGINE ensures correct importing of all details of a CAD assembly model, even the smallest ones. All details of the assembly are available in the World Hierarchy, and each surface can be set up individually.

_{Model of a Jet Engine based on a twin spool gas turbine engine design by Vasileios Thalassinos}

The CadImporter plugin provides a lot of useful options, such as mesh splitting and merging, changing the model’s pivot point, scaling, importing materials, etc. They cover all components that can be imported from a CAD model. You can also modify the plugin to add functionality of processing any custom attributes (user-defined properties) of your CAD models.

For more information on CAD import options please refer to this article.

Importing of CAD models is available only in Engineering and Sim editions of UNIGINE 2 SDK.

_{Classic Volkswagen engine by Juan Arroyave}

Impostor Improvements

Impostors, that are used almost everywhere for performance optimization, now look even better due to improved fading between LODs and perfectly match initial objects, making the whole trick almost unnoticeable while giving a significant boost. Impostors baking became much faster, flexible and convenient: baking performance increased up to several times.

Please note, that after migrating your content all impostors should be rebaked.

Impostors Creator

Generating impostors for Mesh Clutters is easier now, just select the desired MeshClutter object (e.g. a forest) and click Create in the Impostor Creator window - a new Grass object with generated impostors will be added as a child to your selected Mesh Clutter. All you need to do manually is to adjust visibility distances for Grass object’s surfaces, as by default they are set to -inf and inf.

Changes have affected most options of the tool:

• SSAO texture is now baked ignoring global ambient occlusion settings in the Settings window to ensure the correct result.
• You can now choose to how to bake your albedo texture with or without SSAO, the first option is a new one and visually gives more volume, the second one just copies the data from the albedo buffer (like it was before).
• Improved baking of Normal and Translucence textures for vegetation, you can now choose the way your textures are to be baked to fit your needs:
  • for vegetation: normal map will add more volume to the final look of your impostors, while translucence texture will imitate translucence of a real tree crown.
  • for other objects: both textures will simply contain data copied from the corresponding buffers (like it was before).
• Now it is possible to set any supersampling ratio regardless of texture resolution.
• Padding size can now be set for all textures.
• Impostor textures now ensure that when rotating a camera around any tree its trunk will exactly match its geometry original regardless of its shape complexity.
• All grabbed textures use point filtering and have the Unchanged option disabled (i.e. runtime files are created for them and mipmaps are generated).

Impostors Materials

grass_impostor_base and billboards_impostor_base materials have been improved as well:

• Improved billboards rotation.
• Materials have been switched to the Metalness workflow.
• Added support of the following textures:
  • Ambient Occlusion texture
  • Shading map (including Microfiber, Specular maps)
  • Translucent texture.
• Added a new Screen Aligned state to the grass_impostor_base material that sets the impostor parallel to the screen plane. The option should be enabled for correct rotation of impostors when they are observed from above. It is not recommended to enable this option when multi-monitor configuration is used: noticeable seams between monitors may occur.
• Added a new Orientation Normals state to the grass_impostor_base material to adjust blending of impostors oriented along the normals of a parent node.
• An extended set of new transform-related parameters (Phi, Theta, Size and Pivot Offset) was added for both impostor materials, they are displayed in the Transform group. These parameters replace the old Impostor Coordinates parameter.

  

New samples illustrating improved impostors can be found in the Samples demo package included in the SDK.

Improved Particle Systems

Particle systems are used almost in every project to create impressive visual effects. So, we made a number of improvements to make the process of adjusting them in the Editor more flexible and convenient. Now you can control re-initialization of the particle system when it is enabled via the Clear on Enable option: when this option is disabled, turning on the particle system will restore the state it had before it was turned off, otherwise it will be re-initialized. Thus, you can easily test and adjust your particle systems directly in the Editor, even the ones that are spawned only once (such as explosions).

You can also control the number of particles to be generated each time according to the spawn rate via the new Number per Spawn option.

The Limit option of the emitter now specifies the total number of emitted particles: the number of particles existing in the world cannot exceed this value.

For example, if the Number per Spawn value is 10, and the Limit value is 5, only 5 particles will be emitted. No new particles will be spawned until the previous ones exist.

Refactored Voxel and Environment Probes

Refactored Voxel and Environment probes resulting in up to 3 times increase in overall performance. The basic workflow now is to use Voxel Probes for lighting, and Environment Probes for reflections. However, you can also enable both lighting and reflections for a Voxel or Environment Probe via the corresponding options.

Texture Streaming

Textures are the most frequently used resources, tons of bytes of high-quality textures must be uploaded to GPU before you’ll be able to see the final image with all the details. This process surely takes time, but spikes and FPS drops are unacceptable. So, we have improved asynchronous loading of textures into GPU memory. Now there is no need to wait until all textures and mipmap levels are loaded and suffer from spikes when camera changes its orientation. To reduce loading and rendering time, mipmaps are loaded sequentially in two stages:

• At the first stage, only mipmap levels lower than 128x128 pixels are loaded and sent for rendering. This makes rendering of the first frame virtually immediate.
• At the second stage, each texture is split into several parts which are transferred to the graphics card starting from the lowest mipmap level to the highest one.

Thus, the quality of textures gradually improves frame-by-frame up to the best state (the highest possible mipmap level at a given moment), reducing spikes regardless of texture size.

This feature is active when the render_manager_create_textures console parameter is set to 0, otherwise all textures are preloaded on start-up or when changing texture rendering settings with no streaming, causing a noticeable lag.

You can control the process of asynchronous texture streaming to GPU (loading rate and chunk size) via the two new console variables:

• render_manager_texture_upload_frametime_part - percentage of the frame that can be used for uploading. Default value is 10. Lower values make gradual loading more noticeable.
• render_manager_texture_upload_chunk - upload chunk size. Default value is 128.

Improved Playback and Simulation Control

Instead of a single Play button, we made three: one for physics simulation, one for application logic, and one for sound playback. You might think it’s redundant and inconvenient, but that’s not so. It’s more about flexibility: sometimes you might just want to check your application logic and you don’t need physics simulation, or you just want to check if sounds are played properly - with separate buttons you can do that!

Physics simulation may bring changes to positions of objects having physical bodies assigned, so as you enable it you will be prompted to save all unsaved changes in your world, which otherwise will be lost.

Note that physics simulation can be enabled only if the Play button is pressed. Both new buttons can be found next to the Play button. After disabling simulation the world returns to its previous state without any extra efforts.

Physically-Based Cameras and Lights

We made another step to make our render even closer to the real world. Introducing physically-based cameras and lights. Now you can use real-world values (light intensity, color temperature, etc.) to create virtual worlds for Computer Vision systems, which require maximum realism of the environment to ensure high machine learning efficiency and accuracy.

UNIGINE now provides 2 modes for the camera and light sources: you can choose whether to specify lighting and camera exposure using real-world values, or using the classic settings.

New Camera Parameters

To control the exposure of the physically-based camera, UNIGINE has the following options: ISO sensitivity, Shutter Speed, and F-stop. Note that the exposure mode for a physically-based camera should be set to Static.

Horizontal FOV of a physically-based camera is adjusted via the Focal Length and Film Gate parameters.

By default, UNIGINE uses values corresponding to shooting on a sunny day. The sky is now brighter to correspond the real-world physical values when setting up the exposure.

New Parameters of Light Sources

Physically-based parameters of light sources include the Temperature used for light color calculation and the Lux option that is used to adjust light color intensity (as perceived by the human eye).

In UNIGINE, all light sources have the intensity of 1 by default, which is equal to 100000 lux. For convenience, changes made to the Intensity value will also affect the Lux parameter, and vice versa.

Multi-Channel Rendering Improvements

The following improvements were made for the multi-channel rendering via Syncker plugin:

• Improved Syncker's camera synchronization, now Slaves always use PlayerDummies avoiding roll-related issues and camera's hierarchy is taken into account.
• Improved implementation of callbacks, now they are made consistent with others throughout the Engine and managed via addCallback(), removeCallback(), clearCallbacks() methods. The following simple migration is required:
  Source code (C++)

  setUDPUserReceiveCallback(...)
  		-> addCallback(Syncker::SlaveInterface::UDP_USER_RECEIVE, ...)
  
  setUDPUserSendCallback(...)
  		-> addCallback(Syncker::MasterInterface::UDP_USER_SEND, ...)
  
  setTCPUserReceiveCallback(...)
  		-> addCallback(Syncker::MasterInterface::TCP_USER_RECEIVE, ...)
  
  setMasterSetupChangedCallback(...)
  		-> addCallback(Syncker::MasterInterface::MASTER_SETUP_CHANGED, ...)
  
  setSlaveSetupChangedCallback(...)
  		-> addCallback(Syncker::MasterInterface::SLAVE_SETUP_CHANGED, ...)

• Sometimes (e.g, in user messages) it may be necessary to make specific modifications to nodes on the Master or any of the Slaves. A Slave does not create an exact copy of a node created on the Master, their IDs do not match. Now, knowing an ID of a local copy of a node on a Slave, you can easily find the ID of its original on the Master, and vice versa via the getMasterNodeId() and getSlaveNodeId() methods.
• Added a new debug window enabling you to monitor the whole hierarchy of objects at run time (all objects, not only the ones registered in the Editor, including objects in cache, an internal structure of node references, etc. Just select a node and you’ll see all necessary debug information. You can also use Search option to find any node by its name or ID (on the Master or on a Slave), so a faulty node can be found quickly. You can open the debug window via System Menu -> Plugins -> Show debug window or use the syncker_debug console command.

  

• Fixed bug with sending UDP messages, which led to loss of synchronization, when positions of interpolated objects (sun, clouds, etc.) changed during callback processing.
• HLAClient plugin now supports Linux. Time management and synchronization points were also implemented.

Arbitrary Plugin Loading Order

Now you don’t have to worry about the order of plugins listed in the -extern_plugin command, they will be automatically loaded and executed properly.

Each plugin now has its execution order ( Plugin::get_order() ) which determines the sequence in which plugin’s functions (update / postUpdate / render / shutdown) will be executed. The only exception is the init function as it is called just after loading the plugin.

Remember, when writing your own plugin, that requires interaction with other ones, you should specify a correct order value to avoid issues and ensure proper execution sequence.

Improved SSAO for Low-Poly Models

Previous SSAO implementation produced too dark occlusion in inappropriate areas. It was especially noticeable on the edges of low-poly models. Now such edges will be less pronounced, making models look much smoother.

A new SSAO Threshold parameter was also added for SSAO calculated without ray tracing, it works the same way as for the ray-traced SSAO.

It is recommended to use SSRTGI in addition to SSAO for better visual quality. But keep in mind that this technique is more resource-consuming.

Decal-Based Terrain Holes

TerrainGlobal object now supports holes! You can cut some area of the terrain surface by simply adding any decal (orthographic, projected or a mesh one) with the new decal_terrain_hole_base material assigned and placing it over the desired location.

To define hole geometry you can use any supported 2D texture.

Decal-based holes support transparency tuning, as well as dithered transparency setup using the Jitter Transparency flag. The Jitter transparency uses a dither pattern for transparency imitation.

Intersection and Physics Simulation

Accurate intersection with decal-based terrain holes is supported, enabling collision detection as well as all corresponding Editor features such as selection, snapping to surface, etc.

Note that intersection and collision accuracy significantly depends on the terrain polygon count. The higher the number of polygons, the higher the accuracy.

Making Caves and Tunnels

Caves and tunnels can be easily made now by just cutting some area of the terrain with a decal and replacing it with a mesh. Here is an example of making a tunnel through a mountain on the terrain using decal-based holes:

Please note, that holes of the ObjectTerrain migrated to the ObjectTerrainGlobal in UNIGINE 2.7 will be rendered in UNIGINE 2.7.2 as is. To replace such a hole with a decal-based one, manually paint over the hole and add the decal-based hole at the same place.

Customizing Terrain Surface

Not satisfied with the quality of a certain terrain area? Not a problem - customize it using a mesh! New Terrain Lerp option added to the mesh_base material allows marking objects to be covered by projected textures of the TerrainGlobal object.

It is an easy way to improve the landscape by integrating complex meshes into it and thus creating more detailed areas than the Global Terrain is able to provide due to limited density.

Please note, that meshes with Terrain Lerp enabled get only visual appearance of the terrain (Albedo, Normal and Detail textures) and are ignored by such CPU-based features as physics simulation and vegetation generation. To enable these features for your mesh, you should adjust physics settings or MeshClutter/MeshCluster/Grass interaction for it manually.

A new sample illustrating decal-based terrain holes can be found in the Samples demo package included in the SDK.

Unigine Editor

• Added an ability to move files from an FBX/CAD container asset to a folder. Now you can copy the contents of a container (.mesh, .anim, and/or .node files) to a folder within the data directory via the Asset Browser and then remove the container, if necessary.
• Added physically-based parameters to UI of light sources and cameras
• Added support of FBX instancing. Now you can enable the Use Instances option on FBX import to avoid importing several identical meshes and use a single one and its instances instead.
• All assets generated when a new world is created now will have the template_ prefix.
• When a new world is created two folders will now appear in your project’s data folder:
  • template_materials - which is actually a renamed materials folder
  • template_render_settings with *.render assets containing settings for low, medium, high and ultra quality presets as well as settings optimized for best performance in VR. You can now simply double-click on any of them in the Asset Browser to apply corresponding settings.

    

• Input fields for numbers became more convenient, you can click an icon with arrows next to a value and drag it to change tenths of decimal values, or use Ctrl while dragging to change hundredths.

  

• Fixed behavior of the Switch between the orthographic and perspective projections icon in the Scene Viewport.
• Fixed the Edit Size manipulator for Mesh Clutter objects: now it always coincides with the bounding box of the object.
• Fixed issue with unresponsive navigation controls in the Scene Viewport.
• Various bugfixes and improvements.

Landscape Tool

• You can now specify visibility and fade distances for 2.5D buildings right in the Landscape tool when setting up their generation parameters.

  

• Optimized baking of 2.5D buildings into static meshes providing performance improvement.
• Fixed color filtering for masks used for details and vegetation generation.
• Other optimizations and fixes.

Custom Players and Other Component System Improvements

Sometimes when developing your project, you may find that the functionality of standard players available out-of-the-box is insufficient for your needs. Not a problem - you can now make your own custom player! And Component System makes it simple and convenient. You’ll find two custom players (PlayerActor and PlayerSpectator) implemented using the Component System in the following updated sample:

• source/samples/Api/Logics/ComponentSystem

C# implementation of these custom players can be found in the following sample:

• source/csharp/samples/Api/Nodes/CustomPlayers

These custom players can be used as templates to implement your own ones with any functionality you need.

Various bugfixes and improvements were introduced to the Component System Sample making it more stable and convenient.

STL Improvements

Improved functionality of the classes that provide compatibility with the standard C++ STL:

• Inserting a key without a value to the Map sets the value to 0. It works for all built-in types (char, int, float, etc.)
  Source code (C++)

  Unigine::Map<int, int> map;
  map.insert(1);
  Unigine::Log::message("Map value: %d\n", map.value(1));

• Inserting an element into a Vector doesn’t require a default constructor. Now the following code can be used:
  Source code (C++)

  struct Foo
   {
    Foo(int a) {}
   };
  
   Unigine::Vector<Foo> a;
   a.append(0, Foo(1));

• Fixed an assertion that occured on calling Vector::erase(end(), end())
• Added the getMemoryUsage() method for Vector, Tree and Hash classes.
• Added the emplaceFast() for the Vector class for fast constructing and appending a new element to the end of the vector.

Custom Debug Visualizer

Sometimes the default view of objects in the Visual Studio debugger is not enough, especially when you work with complex data structures. So we added a custom debug visualizer for UNIGINE STL containers (Vector, Tree, Hash), vectors (Unigine::Math), strings (Unigine::String) and guids (Unigine::UGUID).

For example, debug information on UNIGINE STL Vector looked as follows:

Since 2.7.2, you will be able to check values that the vector stores:

For all materials and properties, the debug visualizer shows a name, an identifier, and a GUID. For all nodes - a name and an identifier.

The debug visualizer is implemented using a .natvis file that is automatically added to projects created via UNIGINE SDK Browser. Available for all versions of MS Visual Studio 2015 and higher. If your version of Visual Studio doesn’t support NatVis, the .natvis file will be ignored.

Other Engine Improvements

• All world, editor and system script files written in Unigine Script changed their extension from *.cpp to *.usc.
• Important!!! Changed constants defining directions in vec3 and dvec3 classes, now RIGHT(1,0,0), FORWARD(0,1,0) have positive directions along the corresponding axes. This requires the following migration:
  Source code (C++)

  vec3::FORWARD    -> vec3::BACK
  vec3::BACK       -> vec3::FORWARD
  vec3::RIGHT      -> vec3::LEFT
  vec3::LEFT       -> vec3::RIGHT

  same for dvec3.
• Added methods for detecting collisions with shapes and a new Contact class to API. So, now you can implement your own custom physics or a custom player.
• Removed deprecated ColladaImport plugin.
• Improved material file format:
  • Parameter of a certain type can be defined by both the parameter element and by an element named after the parameter type. For example:
    Source code (C++)

    <parameter name="my_param" type="slider">1.0</parameter>
    <slider name="my_param">1.0</slider>

    Available for all types of parameters.
  • For parameters of the expression type, elements named after the widget attribute can be used:
    Source code (C++)

    <parameter name="my_param" type="expression" widget="mask24">0xffffffff</parameter>
    <mask24 name="my_param">0xffffffff</mask24>

• FieldHeight, FieldWeather, and FieldShoreline nodes can now be animated with the Tracker tool. The set of light source parameters in the Tracker was extended by adding physically based ones (colorTemperature, colorFilter, colorMode) and the ones for per-light lens flares.
• A new intensity parameter was added for per-light lens flares.
• New parameters were added to the mesh_base material.
  • Triplanar and World Triplanar UV mapping options for base, detail and detail mask textures.
  • Backside Normal option that specifies the direction of normals for the back side of two-sided polygons.
• Parallax shadow effect was removed from the mesh_base material.
• Fixed the alpha intensity option of the grass_base material. Now when the Jitter Transparency is disabled and the Alpha Intensity is lower than 0.5, the grass isn’t rendered.
• Sky object was stripped off all unnecessary features (such as old volumetric clouds etc.) leaving only the sky dome and flat dynamic clouds. To create volumetric clouds please use the CloudLayer object.
• Added new Play On Enable and Restart On Enable parameters to the SoundSource object. They are available in API as well as in the Editor.

  

• Improved logic of the bounds of Grass, MeshClutter, MeshCluster, WorldClutter, WorldCluster objects.
  • Difference in coordinates systems is taken into account when finding intersections of local bounds of Grass, MeshClutter,WorldClutter objects with parent objects.
  • When setting the Intersection flag for Grass, MeshCluster, WorldClutter objects, their bounding boxes are shifted to the parent object.
  • Bounds of Grass, MeshClutter, WorldClutter objects are updated on transformation or reparenting.
  • Sizes of bounding spheres of elements of the Grass, WorldCluster nodes don’t exceed the size of the node’s bounding sphere.
  • Calculation of MeshClutter bounding sphere takes into account the radius of the mesh multiplied by the maximum scale.
  • Calculation of WorldClutter bounding sphere takes into account the maximum scale.
• Fixed behavior of the root node stored inside a Node Reference: now the node is disabled if its possessor is also disabled. Note that if your project contains node references that store disabled nodes, after migration such nodes won’t be rendered: you may need to enable them manually.
• Improved WorldSector object:
  • When observed from the outside, WorldSector culls the surfaces of the object that are entirely inside this sector.
  • Lightning from a WorldLight source never gets inside a WorldSector.
• Improved API for SplineGraph and WorldSplineGraph classes making spline graph management more flexible and easy to use and enabling you to develop custom spline tools for various purposes.
• Fixed texture-related memory leaks.
• Fixed intersections of the Grass and MeshClutter objects with a parent mesh located at a distance exceeding the radius of the mesh bounding sphere.
• Fixed light baking for environment probes when a single light ray bounce is specified.
• Fixed shadows rendering on a Global Water object.
• Fixed incorrect SSS and specular highlight rendering for Global Water when shadows are off.
• Fixed issue with incorrect geometry of a new Skinned Mesh added to the scene.
• Adaptive exposure is rendered now and can be adjusted even when post effects are disabled.
• Fixed behavior of the render_show_queries console command for OpenGL.
• Fixed crash on operating with the Occluder Terrain texture.
• Fixed issue with the albedo color in the billboards_impostor_base material.
• Fixed crash when working with MP3 files.
• Fixed TAA preset for clouds.
• Fixed issue with saving detail layers when creating a Node Reference from a TerrainGlobal object.
• Fixed issue with light baking for an environment probe having a default cubemap, now a new texture will be generated and automatically.
• Fixed grass rendering artefacts appearing on NVIDIA GPUs at boundary values of the Alpha Intensity parameter in the grass_base material.
• Fixed reflections for material with Additive transparency preset, when sky_cutout option is enabled.
• Fixed issue with DecalOrtho rendering at boundary values of the Angle Power parameter.
• Fixed TEXTURE_MIP_OFFSET issues in UUSL when passing complex arguments.
• Various bugfixes and improvements.

Samples and Add-Ons

Vegetation Add-On

Updated Vegetation pack, now it includes 160+ ready-to-use plants. The following ones were added this time:

• maple
• pacific silver fir
• oregon ash
• buckbush
• sword fern

New Content Samples

The following samples were added to the Samples demo package:

• Using decals to create terrain holes, illustrating how to create a tunnel through a mountain
• New impostors samples
• GI sample illustrating additive blending of Voxel Probes

SDK Licenses

License Activation

Licenses are now treated for each product separately. Having just installed an SDK, you should activate your license with one of the following license activation types:

• Floating License
• Fixed License
• USB Key Activation

You can flexibly manage different products activated with various license activation types.

To activate an SDK, click Activate on the SDK panel and choose one of the available activation types. License information will be available via the corresponding button after activation.

License Management

The company administrator panel was updated to improve company management. A company administrator can manage licenses via the License Manager section.

Available licenses and information are listed in the Licenses area.

Detailed license information is described in the License #number table:

If you purchased a license by using the Payment Portal, you can prolong it automatically any time via the Renew button. Clicking it will redirect you to the Payment Portal for automatic renewal.

Managing Allocated Seats for each product has become easy and convenient. In the corresponding section all seats are listed by purchased products. Here you can see the number of Free seats and Available activation methods depending on your license. Each allocated seat can be released via the button.

For more information on managing licenses please refer to the Managing Licenses article.

Documentation

• Added a new video tutorial on Arbitrary Terrain Generation.

  A new Arbitrary Terrain Generation Add-On containing a set of ready-to-use assets required for accomplishing this tutorial was added to SDK. All you need is just install the add-on and use the assets according to instructions given in the tutorial.

• 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.
• Added an article on VR Best Practices.
• Added a new CAD Import Guide article.
• Added an article on Impostors Creator tool.
• Added an article on Multi-GPU rendering.
• Updated articles on materials in the Materials section.
• Updated the article on Setting Up Object LODs.
• Updated the AppVive plugin article.