UNIGINE 2.9: C# Component System, Better Shadows, SSSSS, Dome Screens Support, Weather Add-On

Notice: UNIGINE 2.9 SDK requires SDK Browser version 1.9.18 or later.

C# Component System

There have been many new-coming users with C# background recently (mostly migrating to UNIGINE from other engines). We’d like to make the transition process for them as simple as possible. So we decided to put our efforts into an integrated C# Component System and verify a new workflow enabling you to implement your application's logic via a set of building blocks — components — out of the box. Once this workflow is proven, we will implement the same system for C++, which remains the first class API for us (so we tend not to break it too often).

Components represented by C# classes (inherited from the base Component class) can be assigned to nodes extending their functionality and enabling you to create a very sophisticated logic system. Each component can have an arbitrary set of parameters that are automatically displayed and can be adjusted in the Editor’s Parameters window.

The C# Component System supports .NET Core versions 2.2.x+ (according to Microsoft: “.NET Core is the future of .NET”) and is available by default for all projects based on the C# (.NET Core) API. The new workflow is fully integrated into the Editor (with on-the-fly project recompilation, displaying all C# compilation and run-time errors in the Console, etc.).

Before you start coding make sure you’ve installed all the required software.

For more details on implementing your application’s logic using C# components please refer to the C# Component System article.

Improved C# API

The C# API has been drastically refactored for the sake of consistency with Microsoft API design guidelines, from properties and enums to capitalization conventions – everything it takes to make C# programmers, a growing part of our community, feel comfortable. Engine’s singletons (such as World, Game, Physics, etc.) and useful parameters (such as ifps) are now available as properties of the Engine class, making modification of node’s transform as easy as:

node.WorldPosition += node.GetWorldDirection(MathLib.AXIS.Y) * speed * Engine.ifps;

C# API documentation as well as all related code snippets and usage examples were updated to provide full compliance.

Better Shadows: Realistic Penumbra, Smoother Edges

Improved shadows represent one of the most noticeable and exciting features of this release. In real life, most shadows have soft, fuzzy edges – the so-called penumbra. This is due to a combination of factors, including diffuse light from surrounding surfaces, the presence of multiple light sources, and the fact that they are usually not infinitesimally small points. For example, during a solar eclipse, the places on Earth where the Sun is only partially occluded are in penumbra.

Combined with better filtering procedures for smoother shadows, the new penumbra effect is going to make your environments even more realistic. Rendering of penumbra is supported for all light sources, providing sharp contact shadows closer to the base and softening the farther the shadow stretches away just like in real life.

Improved Materials and Shaders Customization

We’ve boosted materials loading speed up to 4-5 times, of course performance is one of our top priorities, and we never stop honing it, but we also did not forget to add some more flexibility. Customization of materials has evolved and became much more flexible with support for scripting. Introducing scriptable materials - base materials with expressions (fragments of code written in UnigineScript) executed at certain stages of rendering sequence, offering you an exceptional flexibility. Such materials represent an ideal instrument for fast prototyping of your own custom post effects such as DoF, Bloom, or any other, as they allow you to:

• write any logic in UnigineScript,
• apply them globally or per-camera,
• have all necessary parameters added to UI automatically.

Scriptable materials can be applied globally and per-camera. As base materials, they are created and edited manually. For more details please refer to the documentation.

Other features extending the base for customization include:

• Custom render passes and textures.
• Temporary textures and render targets.
• New material parameters: FLOAT, FLOAT2, FLOAT3, FLOAT4, INT, INT2, INT3, INT4.
• Additional material format with ULON (Unigine Language Object Notation).

Physically-Correct Light Attenuation

In the real world lighting intensity depends on the distance from the light source, in UNIGINE too. From now on, to ensure physically-correct visualization, we use the formula describing real-life behavior of light: if the distance between the light source and the surface increases by 3 times, the light becomes 9 times less intense.

Revamped Screen-Space Subsurface Scattering

The problem of creating believable translucent materials such as marble, wax, leaves, or skin is associated with subsurface scattering simulation and is very important for creating realistic environments. To make it even better we have significantly improved its implementation with an extended set of parameters providing the following:

• Modification of only the diffuse component leaving specular highlights unaffected.
• Color gradients simulating color changes when the light passes through the matter.
• Interleaved rendering mode for optimum performance.
• Temporal filtering for better image quality.

This effect can also be enabled for directional light sources and ambient lighting (voxel and environment probes and global environment) separately giving you more control flexibility and enabling you to save performance (e.g. when the effect should be rendered for diffuse lighting only).

For more information on Screen-Space Subsurface Scattering settings please refer to this article.

Smoother and More Stable Screen-Space Effects

Real-time ray tracing produces quite a lot of noise due to insufficient sampling. Increasing the number of rays would solve the problem, but it severely affects performance. Introducing our improved denoiser for ray-traced screen-space effects (SSAO, Bent Normal, SSGI, SSR) making it possible to obtain smoother images using reduced number of rays, even for reduced resolutions, thus saving a great deal of performance.

For more detailed information on new noise reduction settings please refer to the corresponding articles in the render settings section.

Various ray-traced screen-space effects often suffer from flickering artifacts, especially when rendered at low resolutions. In this release we improved temporal filtering for some effects (SSR, SSGI) to ensure better image stabilization. Decreasing the Color Clamping Intensity parameter enables you to create a more stable scene with less flickering but ghosting effect caused by accumulation of color information from previous frames becomes more noticeable. Ghosting can be reduced by increasing the Color Clamping Velocity parameter.

For more information on temporal filtering parameters for SSR and SSGI effects please refer to articles describing the corresponding rendering settings sections.

Improved Tone Mapping

Filmic tonemapper desaturates image colors in bright areas making them look grayish or washed out. A new Saturation Recovery parameter we added to the Filmic section of the Camera Effects settings will help you get rid of this problem and restore your colors.

Correct Roughness for Dynamic Reflections

We’ve significantly improved quality of dynamic reflections rendered on rough reflective surfaces making the final result look realistic. The new Correct Roughness parameter does the job! It controls the quality of mipmaps calculated at run time for reflection cubemaps, and is available for both global dynamic reflections from the environment, and dynamic reflections from environment probes. Moverover, enabling this feature makes shadows look less bluish and more natural as we’ve implemented improved ambient lighting calculation.

You can check out this feature in the updated Environment HDRI sample included in the Samples suite.

Other Rendering Improvements

• Speedup of voxel-based light baking (8x for internal volume, +20% for other space).
• Faster SSRTGI when SSGI is not used.
• Added fade for shadows from Mesh Clutter elements for materials with the Opaque preset selected.
• Added a new Fix Overlit Areas parameter to remove artifacts of ray-traced bent normals calculation.
  
• Improved rendering of cached shadows from omni, projected, and world light sources when dynamic objects are located within the area and render_textures_max_resolution is lower than cubemap resolution.
• Fixed rendering of reflections when the scene contains several dynamic environment probes.
• Fixed issues with incorrect sorting of voxel probes.
• Fixed an issue with both settings of the Backside Normal option rendered similarly for two-sided materials with Triplanar World UV mapping selected.
• Fixed Shadow Offset for the grass_impostor_base material.
• Fixed an issue with occluders ignoring MeshCluster objects having fade distances greater than 0.
• Similar MeshClutter and MeshCluster objects having the same fade distances set will have the same distance-dependent fading.
• Fixed issues with rendering materials having Ambient light pass disabled (AMD + Linux + Mesa).
• Fixed an issue with ObjectWaterMesh ignoring disabled water rendering option.
• Shadow rendering now takes terrain holes into account.
• Added 1x2 interleaved lights rendering mode.

Multi-Threaded Mesh Clutter and Mesh Cluster

Virtual worlds, especially if we talk about outdoor scenes, often contain a lot of identical meshes scattered across a certain area, such as trees in the forest, stones or debris, electricity pylons, tubes, etc. UNIGINE’s optimizations used for such cases to reduce rendering load and simplify object management are called Mesh Clutters and Mesh Clusters. We have significantly improved their performance in 2.9 due to extended use of multithreading resulting in a real boost.

If your world contains multiple mesh clusters or clutters, each of them shall be calculated in a separate thread, so the more separate clutters/clusters you have the better is load distribution between the cores and the more profit you get.

Geodetics Plugin for Geo-Coordinates Conversion

UNIGINE is known for its support for double-precision coordinates and an extended range of applications including flight simulation, transportation, urban planning in metropolis, distributed industrial enterprises, defense systems, where simulation of large-scale real-world locations is required. The Engine uses a built-in 3D geoid model (WGS84, etc.) with objects positioning available via geo-coordinates.

Coordinates conversion between the Cartesian and geographic systems is a frequently used operation. To make it even simpler to perform it in your custom applications we’ve added an additional instrument implemented as a plugin - the Geodetics plugin.

For more information please refer to the Geodetics Plugin article. And check out a new sample demonstrating how to use it: data/samples/geodetics/geodetics_transformer_00.

glTF Support (Experimental)

A new extension for UNIGINE’s Import System is now available enabling you to import Static Meshes, Material, and Texture assets from the glTF 2.0 format, an API-neutral runtime asset delivery format developed by the Khronos Group.This is an open format for 3D scenes and models using the JSON standard and it is intended to be efficient, interoperable and provide minimum file size and runtime processing by apps. As such, its creators have described it as the "JPEG of 3D." The cool point about glTF is that the same file holds a full scene, with multiple 3d objects, with animations, materials, and textures.

This feature is available only in Engineering and Sim editions of UNIGINE SDK.

Improved Spline Tool

The Spline Tool represented by the WorldSplineGraph object progresses with increased overall stability, smoother editing process, improved visibility and fade management as well as better OpenGL rendering.

The list of other improvements includes the following:

• Any point or set of points can now be deleted regardless of belonging to segments. The corresponding segments that have the deleted points will be automatically deleted as well.
• On OpenGL: junctions are rendered seamlessly and cases with sometimes disappearing spline segments are fixed.
• Fixed issues with incorrect positioning of meshes for a WorldSplineGraph inside a NodeReference.
• Stretching is restricted to ObjectMeshStatic source nodes only, while skinned meshes and decals are rendered in tiling mode.
• A new SplinePoint::getLinkWorldPosition() method enables you to get the current link (bone) position of the junction source node.

Main Player Concept

Up to 2.9 the main player (camera) for the world was created and set in the default world-script file (*.usc) implementing world’s logic in UnigineScript (some users were not aware of this). Now you can clearly indicate which camera is to be used as the main one directly in the Editor via the Parameters window or at run time via API (the setMainPlayer() method), regardless of whether it is C#, C++, or UnigineScript.

Players with the Main Player flag enabled are treated as default cameras when running the project (if there are multiple such players, the last one in the node hierarchy will be used).

Integration of Varjo VR-1 Headset with Eye-Tracking

World's first human eye-resolution industrial grade VR headset Varjo VR-1, an enterprise product for training and simulation, AEC (architecture, engineering, and construction), industrial design, virtual production, healthcare, and other industries, that features integrated 20/20 eye tracking and a high-resolution Bionic Display, is now available in UNIGINE projects.

For more information please refer to the AppVarjo Plugin article.

Other Engine Improvements

• Improved intersection detection - getIntersection() now returns the number of intersected instance for complex objects (clutters, clusters, etc.).
• Fixed issues with skipping transforms of some clutter objects when calling ObjectMeshClutter::getClutterTransforms() with an ObjectTerrainGlobal present in the scene. ObjectMeshClutter::getTransform() in the force mode always returns all transformations.
• Fixed memory leaks related to ObjectMeshClutter and ObjectGrass as well as a set of other both Engine- and Editor-related memory leaks.
• A set of property-related fixes is included in this release:
  • Fixed a crash on loading a property file having a parameter of a structured type defined in another property file.
  • Fixed property conditions used inside structures.
  • Fixed issues with adding a new property with a duplicate GUID. The same issues were fixed for materials as well.
  • Element type information in arrays of structures defined in a non-manual property is now preserved on reimporting.
• Fixed a crash on enabling the Terrain Lerp option for a MeshSkinned object.
• Fixed a crash upon completion of baking lighting to a Voxel Probe.
• Removed false error messages displayed in the Console when adding a second cloud layer to a world containing a global water and a cloud layer.
• Fixed an issue with deleting OpenAL buffers that are still in use.
• Vive/Oculus/Varjo HMD and controllers positions can now be safely set inside the init() method.
• BLOB files are now taken into account in the FileSystem::isFileExist() method.
• Added set() and expand() methods for BoundBox and WorldBoundBox classes enabling you to build a bounding box for a group of points.
• Parameters of soft shadows are now available in the Tracker tool.
• All changes made to Controls via the Engine's System menu are now saved and applied correctly after restarting.
• Fixed marshalling for Vector<String> type function parameters (C# API).
• Added a new FfpDepth C++ sample (source/samples/Api/Render/FfpDepth) demonstrating how to draw visualizer elements using FFP and taking the depth buffer into account.

Editor

UnigineEditor application has become more stable, got better performance, along with UI improvements, a new tool for Clutter-to-Cluster conversion and more.

New Template World Structure

Template world structure has been changed with the Main camera added (PlayerSpectator node), node hierarchy of the scene split to content and lighting, and all template assets (template_materials and template_render_settings folders) moved to the template_assets folder to separate the template content.

We added a LightVoxelProbe and a LightEnvironmentProbe to demonstrate how to create realistic lighting using these probes for global illumination and reflections respectively.

Clutter-to-Cluster Converter

Very often when building your worlds it is necessary to scatter meshes across a certain area randomly and then reposition some of them manually (e.g. when creating forests), now it is possible with a new Clutter-to-Cluster Converter! Scatter meshes using a Mesh Clutter (or several Mesh Clutters), right-click it in the World Hierarchy and choose Convert Mesh Clusters from Mesh Clutters in the context menu.

A Mesh Cluster will be created for each selected Mesh Clutter, and you’ll be able to manually reposition any particular mesh you want. Original Mesh Clutters shall be disabled, so you can remove them later.

Improved Node Filter

Node filter in the World Hierarchy window now has two modes and can display all found nodes as a Hierarchy or as a Flat List. The flat list view is used by default as in most cases users would expect to see exactly the nodes they’re looking for regardless of their ancestors. If for some reason the hierarchy matters to you, you can switch to the Hierarchy mode.

In-Editor Array Parameters Management

Managing arrays in properties and components in the Editor became much easier now. You can create new elements, rearrange and remove existing ones. Many programmers looked forward to see this feature as it simplifies the process of making modifications to already configured properties and components (e.g. remove some unnecessary element, or insert a new one between the third and the fourth ones). Multi-selection is also supported.

Other Editor Improvements

• The Physics tab is now available for all Objects.
• Old Play button now controls only animations and particles.
• USC-assets (files with UnigineScript code) can now be created via the Asset Browser and assigned to worlds.
• Improved layout of labels and widgets along with a pack of new tooltips.
• Added new asset icons (C# Component, Bitmasks, Launcher, Animation).
• Fixed issues with applying post-process materials to a camera.
• Fixed an issue with incorrect generation of impostors by the Impostors Creator tool in certain cases for a MeshClutter having non-zero Spread parameters.
• Fixed an issue with incorrect behavior of a WorldTransformBone added to scene via the Create menu.
• Fixed a crash on reimporting a large number of FBX assets (over 5000) as well as on importing an FBX-model with both Import Tangent Space and Merge Surfaces by Materials options enabled.
• Fixed an issue with importing an FBX-model with animation to a static mesh instead of a skinned mesh, for a case when the Merge Surfaces by Materials option is enabled.
• Fixed an issue with incorrect texture assignment for an imported FBX-model that occurred sometimes.
• Fixed "on-the-fly" UI update for base material files (*.basemat).
• Improved Snapping Toggle behavior when changing window focus.
• Fixed behavior of Intensity and Lux sliders for Omni light sources.
• Fixed unresponsive sliders in the Base group of material parameters.
• Multiple node selection causes no lags anymore.
• Fixed an issue with re-generating a new GUID for a nested node reference inside a node reference being transferred to another project via the UnigineEditor resulting in broken GUID-links.
• Textures from MTL-files are now correctly applied when importing an OBJ-model.
• Fixed an issue with changing mesh for a cloned WaterMesh object affecting the mesh of an original WaterMesh as well.
• Objects selected in the World Hierarchy window shall remain selected after applying new filters, if they’re not filtered out by the latter.
• Changed default Attenuation value for a new created Field Spacer to 10.
• Restored rendering of the Performance profiler in the Engine viewport.
• Now there is a separate creator for each of the two types of environment probes (box and sphere).

IG Progress

Our plug-n-play component for professional distributed simulation systems - the IG (Image Generator) Application template - has got a pack of updates and improvements in this release including advanced lights control, more convenient projections configuration, along with implementation of thermal and night vision, water Beaufort levels control and much more.

City/Airport/runway/runway_1/PAPI/approach_indicators
City/Airport/runway/runway_2/PAPI/landing_direction_indication
City/Airport/runway/slope_indicator/set_1/light_1
City/Downtown/street_lights/lamppost_1
City/District_2/buildings

You can toggle each light source in the hierarchy on and off, or change its brightness. Strobe lights are also supported. Light source control via API is as simple as:

ig_manager->getLightController()->setEnable("City/Airport/*", 1);
ig_manager->getLightController()->setBright("City/Airport/*", 0.2);
ig_manager->getLightController()->setStrobed("City/Airport/*", 1);

The LightSourceComponent represents a light source — an entity to control. It can be a switchable node (e.g. a voxel or an environment probe), as well as an emissive surface or material.

For more detailed information on managing lights in IG please refer to the Light Settings article.

AppProjection Updates

The AppProjection tool enabling you to create multi-projector setups and adjust projections for various screen configurations including spherical and complex-shaped curved ones has got more convenient and easier to use with a pack of UI improvements.

Blend and Mask adjustment has been completely reworked: Blends and Masks are configured in separate tabs now.

We have also added support for groups of projectors and configurable sphere and box calibration patterns.

The new Calibration Grid Setup window will help you fine-tune calibration grid pattern to fit the shape of your projection. For more information please refer to the Configuring Screens and Projections article

Other IG Updates

• Night and thermal vision can now be implemented using ViewType parameter of the view definition packet to control camera’s post_materials.
• Improved support for dome screens.
• Highlighting active points and blend zone borders on the screen when configuring projections.
• Saving projection configuration settings to an XML file.
• Optimized HAT/HOT requests above water surface, as well as the ability to ignore water level.
• Fixed LOS requests (now returns all intersections instead of the first one).
• Fixed crashes on invalid requests.
• Added new SynckerSlave methods: addSyncNode(), removeSyncNode(), and removeSyncNodeID().
• You can now change water Beaufort levels (wave height).
• Default time and time zone can be set in ig_config.xml file.
• Fixed Moon position.
• Now you can use DIS-style entity type id declaration in ig_config.xml file:
  Source code (XML)

  <entity id="1.2.222.4.14.0.0" name="be-200">

• Both entity_type and entity_id are now represented in int64 format.
• Added callbacks for various types of DIS packets.
• Added a callback on Syncker initialization within the IG.
• More informative error reports in the Console will help find missing or faulty resources quickly and detect migration issues (if any).
• Entities to be added to simulations at the initialization stage (pre-spawned entities) can now be created via the Editor. The only restriction is that their type cannot be changed during the simulation.

Breaking Changes

We always think about our customers and put a lot of efforts to ensure reasonable balance between backward compatibility and forward progress, but sometimes we really have to pay the price for progress. To offer your more safety and convenience in managing nodes we had to significantly reconsider the Memory Management system in UNIGINE 2.9. Now the Editor class automatically owns all pointers to nodes created in the Main loop via one of the following ways:

C++ API:

// creating a new node
NodeDummyPtr nodeDummy = NodeDummy::create();
NodeReferencePtr nodeReference = NodeReference::create("object.node");
ObjectMeshStaticPtr mesh = ObjectMeshStatic::create("material_ball.mesh");

// loading a node
NodePtr node = World::get()->loadNode("object.node");

// cloning a node
node->clone();

Or the same using C# API:

// creating a new node
NodeDummy nodeDummy = new NodeDummy();
NodeReference nodeReference = new NodeReference("object.node");
ObjectMeshStatic mesh = new ObjectMeshStatic("material_ball.mesh");

// loading a node
Node node = World.get().loadNode("object.node");

// cloning a node
node.clone();

This results in decreasing number of unexpected crashes and memory leaks. As an example, the following code used to cause a crash due to referring to a null pointer:

PlayerPtr createPlayer()
{
    PlayerDummyPtr player = PlayerDummy::create();
    return player->getPlayer();
    // the player variable used to delete the node it referred to on exiting the createPlayer function
}

int init()
{
    // setPlayer used a null pointer causing a crash
    Game::get()->setPlayer(createPlayer());
    return 1;
}

Now it works as expected.

You don't have to use grab() and release() methods to handle ownership of a node anymore — it will be automatically removed on the world shutdown.

However, the changes to the Ownership System will result in multiple crashes and run-time errors in almost any project based on previous SDKs. For more information please see migration recommendations in the API Migration Guide.

Node removal should be performed only via the following code:

World::get()->removeNode(node);

You can release a node from auto ownership by calling the release() method:

Editor::get()->releaseNode(node);

Such an orphan pointer stays in memory even after the world shutdown which may lead to memory leaks, so you should handle ownership manually.

Nodes that are loaded or created not in the Main loop, as well as the ones loaded by using the AsyncQueue, are not handled by the Editor class. You should define their ownership manually via the following:

node->release();
Editor::get()->addNode(node);

Other Important Changes

• Raised minimum spec for compilers:
  • Visual Studio 2015
  • gcc 4.9 (Astra Linux 1.6)
• Removed support for old 32-bit operating systems.
• Removed deprecated tools: Terrain, ImageDDS, ImageTTF, ImageView, MeshImport, ResourceEditor, TilesetFile.
• Removed support for obsolete NVIDIA 3D Vision and NVIDIA 3D Surround technologies.

Fox Hole Demo Preview

Introducing a new Fox Hole demo with an interactive VR mode to showcase capabilities of the Engine for real-time architectural visualization and BIM (Building Information Model) applications. Top-notch visuals with realistiс lighting, reflections and true-to-life materials together with audio effects creating a fully immersive environment in VR can bring presentation of architectural design to a whole new level.

You can examine all architectural elements of the house as well as engineering systems (ventilation and heating), view object-specific BIM data tagged to these elements, look at the floor plan, make measurements to see if a particular piece of furniture fits well in a room, change flooring or use another wall paint, and check out every corner of the house like you live in it. But beware of thinking about making yourself comfortable in the hanging chair by the fireplace - it’s not real!

The demo is currently available in VR mode for HTC Vive/Vive Pro and Varjo VR-1 HMDs only. We'll add desktop mode and support for more headsets in future releases.

C# Component System Sample

To showcase the capabilities of the new C# Component System we added a new demo to the SDK (SDK Browser -> Samples -> Demos -> Csharp Component Sample). It is a simple third-person game that demonstrates performance and flexibility of the logic system, featuring the following:

• C# Component System.
• Interaction between components.
• User inputs handled using the Input class.
• Custom third-person player controller.
• Visual effects, animations, particles, sounds and navigation.

Samples and Add-Ons

Weather Add-On

Added a new Weather add-on containing a set of ready-to-use realistic sample weather effects to bring even more life to your projects:

• Precipitation: rain and snow.
• Raindrops, splashes in puddles and water streaks on the camera lens.
• Windshield wiper effect.
• Lightning strikes.
• Snowfall effect with wet flakes landing on the camera lens.
• 3 types of the screen frost effect with adjustable intensity.
• Volume fog.

New Content Samples

The Samples demo package was updated with a new nice-looking sample selection page redesigned to help you quickly find the one you need, and the following samples added and updated:

• Penumbra sample illustrating soft shadows.
• Omni Light and Projected Light samples were updated to include penumbra feature.
• Environment HDRI sample was updated to illustrate the new Correct Roughness feature.

Upcoming Planet Object

The Planet Object already looks good with all run-time functionality completed and the toolset being polished. The last iteration, implementing all useful feedback we’ve gathered from some of our customers, is currently in progress. So, we plan to release it shortly in 2.10.

Documentation

Being always focused on our customers’ needs we want our documentation to be useful. So, along with a set of quality of life enhancements we added a new feedback channel - now you can rate articles, send us error reports and your requests regarding incorrect or missing information from any page directly.

Added the following video tutorials:

• Updated the Syncker and AppProjection articles.
• Added a set of articles on the C# Component System.
• Updated C# API documentation as well as all related code snippets and usage examples.
• Updated IG plugin API.
• Added an article on Configuring Lights in the IG Application.
• 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.