UNIGINE 2.0

[binstream]

UNIGINE 2.0: Fully Deferred Rendering, Data Streaming Improvements, Performance Optimizations

 

The UNIGINE 2 stable release is finally available, incorporating more than 1.5 years of major technology improvements. Please see the details on its features on the renewed unigine.com.

 

Key Changes from 2.0 RC

• Full-deferred renderer by default.
• Performance optimizations.
• Added temporal anti-aliasing (TAA), enabled by default.
• Added high-quality environment probes for dynamic reflections.
• Improved quality of effects: SSAO, motion blur, bloom.
• Unified and improved decals.
• Improved workflow for transparent materials.
• Introduced simulation of optical sensors in the EO or IR passband.
• More artist-friendly materials with easier setup.
• Faster data streaming greatly increasing FPS stability and improving synchronization between IG channels.
• Improved CAVE support.
• Added support for DIS/HLA/C2 standard protocols.
• Improved native support for Oculus DK2.
• Improved Quad Buffered Stereo support.
• Better performance profiling tools.
• Easier graphical debugging.
• Added support for Perception Neuron wireless motion capture system.
• Added support for ARTTRACK motion capture API.
• Extended C++ and C# APIs.
• More consistent console commands.
• UnigineEditor has been migrated to Qt widgets (native look and feel, faster).
• Experimental asset browser.
• Improved FBX format support.
• Introduced Video Grabber tool.
• A lot of bugfixes.

 

Editions

 

There are now 3 different editions of UNIGINE 2 available:

• Starter - the affordable option for games and small-scale projects.
• Professional - the edition for architecture visualization, film and TV production, game development.
• Sim - the ultimate suite for complex high-fidelity simulators and professional VR systems.

Old UNIGINE Game licenses will be upgraded to UNIGINE Professional.

 

 

New Rendering Pipeline

 

Full Deferred Rendering

 

UNIGINE 2 has been switched to the full deferred renderer, so all opaque geometry is now rendered in the deferred pass. Thereby the rasterization process happens only once, which highly increases performance. After the rasterization process, all lights are applied to the necessary buffers to create the final image of the scene.

 

 

Transparent Objects

 

Transparent objects rendered in the deferred pass are grouped to be rendered in one DIP, which is much faster than in forward, but there is a limitation: they overlap other transparent objects rendered in the deferred pass. However, they provide realistic reflections and cover most of the cases.

 

If it is critical to see another transparent object behind the front one, forward rendering is available for transparent objects. In comparison with the deferred pass, transparent objects aren't grouped in this way, which increases the number of DIPs.

 

 

Performance Optimization

 

It is important to understand some facts about performance of the new renderer as it has several features in comparison with the old one. Maximal FPS on empty/simple scenes with the new render is lower (about 200-250 FPS) than the old one (up to 1000 FPS), but anything above 120 FPS (60 Hz in stereo) has no practical difference. The interesting part is when we start adding content into the scene, the new renderer FPS value is almost constant, very slowly decreasing in comparison with the old version.

 

A simple test with a lot of small static meshes:

As for the raw polygon rendering performance, UNIGINE 2.0 demonstrates even better results:

Here is another test on a static scene with 7.3 millions of polygons and multiple LightWorlds without shadows (deferred rendering is better for handling a lot of dynamic light sources by design):

 

So UNIGINE 2.0 performance scales much better and can perfectly do heavy lifting job with CAD data, unoptimized 3D scans or any other extremely complex and detailed scene. A lot of customers chose UNIGINE 1 because it outperformed competitors, and now we pushed the performance of the engine even further.

 

Temporal Anti-Aliasing

 

UNIGINE 2 uses the temporal anti-aliasing (TAA) by default. The old multisample anti-aliasing (MSAA) and all corresponding functions have been removed.

 

In case of full deferred rendering (when the final image is composed of different texture buffers: depth, normal, etc.), TAA applies smoothing to the whole scene, which is much faster comparing to MSAA that is applied to each texture buffer. Besides, TAA improves the whole image (not only the edges of the geometry, like MSAA) including geometry, shadows, etc., thus delivering better visual quality.

 

TAA disabled:

 

 

TAA enabled:

 

 

To enable/disable TAA, use the render_taa console command (or Rendering panel -> Features -> TAA in UnigineEditor). When TAA is disabled, the fast approximate anti-aliasing (FXAA) can be used. However, TAA implementation is very performance-optimized, so it is recommened to keep it always on.

 

 

Environment Probes

 

Added high-quality environment probes (LightEnvironmentProbe) for creating dynamic reflections instead of creating reflection materials. They highly increase performance because they require less materials (i.e. reducing DIPs). Environment probes can use pre-baked static cubemaps or dynamically grab the surrounding environment (thus creating dynamic reflections). This cubemap influences reflections and lighting of all objects that have got into the environment probe's radius.

 

 

Unlike other engines, UNIGINE 2 has unique environment probes: they can also work with transparent objects, rendered in the deferred pass.

 

To add the environment probe to the scene via UnigineEditor, do the following:

1. On the Menu bar, click Create -> Light -> Environment Probe.
2. Place the object somewhere in the world.
3. Grab new cubemap texture for the environment probe (Light -> Grab texture button in the Nodes window) or load the pre-baked one.
4. Adjust the environment probe settings.

 

Effects

 

Improved SSAO (Screen-Space Ambient Occlusion) quality: now it works sub-pixel and supports far objects.

 

 

Improved the bloom effect quality: now it works per-pixel, its radius changes dynamically depending on the pixel brightness, and it can be modulated by the dirt texture. The old glow effect has been removed (it can be simulated with the new bloom).

 

• Improved motion blur quality: now it works per-object and supports objects without physical bodies assigned.
• All HDR effects can now be adjusted independently.
• Added the sharpen post-effect.

 

 

Materials

 

Transparent Materials

 

Simplified setup of transparent materials, added the Common -> Transparency option with simple presets:

 

 

The set of UNIGINE built-in materials has been changed in order to simplify 3D artist's work (less base materials, more features, easier setup).

 

 

Changes in the set of base materials:

 

 

 

Other materials settings were also revised:

• Simplified material options, removed redundant ones (Render group, Post refraction, Glow mask, Parallax mask, Receive shadow and Receive world shadow).
• Removed light prob and light spot passes.
• Removed light passes for opaque materials.
• Added a Decal mask parameter specifying to which objects a decal will be applied.
• Removed all emission settings.
• Removed all ambient light settings.
• Added the Translucent parameter to the mesh_base, billboards_base and grass_base materials modifying the value of translucency. The old Cast translucence and Receive translucence options have been removed.
• mesh_base:
  • Metalness workflow is now set as default.
  • Simplified choosing of the UV map to use (States -> UV settings field). The old Overlay second and Multiply second detail options have been removed.
  • Added the Cutout parallax mapping effect providing hard edges between the opaque and transparent areas.
  • Added new detail textures blending options (the Detail toggle):
    • Lerp by mask - enable a detail blend mask and additional textures and parameters to blend with. (Merged mesh_layer_base functionality.)
    • Overlap (object transform) - overlap the base material by using the object transformation. Detail textures will be rotated with the mesh. (Merged mesh_overlap_base functionality.)
    • Overlap (world transform) - overlap the base textures by using the world transformation. No matter if you rotate the object, the detail textures will always be projected atop. (Merged mesh_overlap_base functionality.)
  • Added the Geometry inflation option for creating an additional visual effect without real geometry changing:
    • Wire - bloats the geometry normals to provide more realistic wires depending on the distance to the mesh.
    • Balloon - bloats the geometry by specified constant creating an effect of a balloon.
    The corresponding parameter is Balloon value.
  • Added the Opacity map option specifying the alpha channel of which texture to use:
    • Main - use the alpha channel of the main (albedo or diffuse) texture.
    • Normal - use the alpha channel of the normal map.
  • Removed the Shadow distortion parameter.
  • Removed the Reflection parameters. Environment probes should be used instead.
• grass_base:
  • Added the Shadow shafts option, simulating visible volumetric shadows, arising when a bright world light source is partially obscured by grass.
  • Added the Occlusion parameter enabling occlusion that sets shading starting from the ground to the top of the grass blade (the corresponding scale slider is Occlusion scale).
  • Added the microfiber effect (the Fibers texture and parameter) set by default.
  • Added the Diffuse multiplier parameter.
  • Removed the base Shadow parameter.
  • Removed all light passes.
• billboards_base:
  • Added support for alpha testing.
  • Added the microfiber effect (the Fibers texture and parameter) set by default.
  • Added the Diffuse multiplier parameter.
  • Removed the base Shadow parameter.
• mesh_leaf_base:
  • Added the spherization (generation of the normals relatively to the center of the sphere) option.
  • Added the microfiber effect (the Fibers texture and parameter) set by default.
  • Removed the Phong shading parameter.

 

Water

 

Now it is possible to adjust engine tessellation for ObjectWater via the following console commands:

• render_water_resolution_low - sets the size of the cell of the water grid that is used when there are no water waves (the amplitude of waves is set to 0) and post refraction is enabled.
• render_water_resolution_high - sets the size of the cell of the water grid that is used when water waves are simulated (the amplitude of waves is nonzero).

Further improvements are scheduled for the 2.1 release.

 

 

Sensor Effects

 

Introduced real-time sensor effects simulation of optical sensors in the EO or IR passband. The corresponding material is post_sensor. It comes with 4 built-in synthetic configurations:

• post_sensor_green - enhanced night vision maps.
• post_sensor_white, post_sensor_red, post_sensor_heat - infrared maps.

 

 

 

Decals

 

All decals are simplified and merged into three objects:

• DecalProj is a decal projected onto a surface by means of perspective projection.
• DecalOrtho is a decal projected onto a surface by means of orthographic projection.
• DecalMesh is a decal based on the arbitrary MESH file and projected onto a surface by means of the orthographic projection.

Decals are rendered in the deferred pass and can be applied only to objects that were rendered in the deferred pass.

 

The decal_base material has also been updated:

• Deferred rendering for decals: they are rasterized only once, no matter how many light sources are in the scene.
• Fixed work with post-processes.
• Added a Decal mask parameter allowing to set a bit mask for a decal thus specifying the objects only to which a decal will be applied.
• Added blending options (States -> Blend):
  • Jitter - overwriting of all materials under the decal with gradient.
  • Alpha blend - alpha blending mode.
  • Overlay - overlay blending.
  • Multiply - multiply blending.
• Added the Opacity map option indicating the alpha channel of which texture to use:
  • Main - use the alpha channel of the main (diffuse) texture.
  • Normal - use the alpha channel of the normal map.
• Added the microfiber effect (the Fibers texture and the Fibers visibility parameter) set by default.
• Added the Translucent visibility parameter modifying the value of translucency.
• Added a Normal substitute parameter specifying a rendering mode for normals. By default, normal maps of a base and overlapping material are combined together. With this option enabled, only normals of the overlapping material are used.
• Added the set of fading parameters:
• The Distance power and Distance threshold parameters modify the distance starting from which the projected overlapping decals start to fade (to enable parameters, click the Distance fade option).
• The Angle threshold and Angle power parameters modify the fading angle for projected overlapping decals.
• Renamed shading parameters: Glossiness -> Gloss, Normal -> Normal intensity.
• Removed all light passes.
• Removed parallax effect.
• Removed all ambient light settings.
• Removed all emission settings.
• Removed the Fresnel bias and the Fresnel power parameters.
• Introduced "Visibility" parameters, which controls the effect from the specific decal aspect to the final image.

 

 

Stereoscopy

 

The AppQuadBuffer plugin has been merged into the engine. In order to enable Quad Buffered Stereo mode (works only for Windows and Linux), perform the following:

1. Make sure that you use the graphics card with the support for Quad Buffered Stereo (NVIDIA Quadro),
2. Make sure that Quad Buffered Stereo is enabled in your video driver settings,
3. Set -video_quad_buffer 1 command line option (alternatively, you can run video_quad_buffer 1 && video_restart console command in the running engine instance).

Oculus Integration

 

AppOculus has been migrated to Oculus SDK 0.6, featuring native support for Oculus Rift DK2. Since Oculus VR has stopped supporting Linux and Mac, the plugin is available only for Windows only at the moment.

 

 

Multi-Channel Rendering

• Added the Unigine::Syncker::Master::syncCAVE() method for synchronizing head position in CAVE systems.
• Added the return value to the Unigine::Syncker::Master::createNode() method. 1 - the node will be created on every slave, 0 - the node won't be created.
• Added ability to create NodeDummy, PlayerDummy, PlayerSpectator and PlayerActor on the slaves via the Unigine::Syncker::Master::createNode() method.
• Added ability to set the maximum size of the sent/received UDP packet, the default size has been increased to 4Kb.

 

Graphics Debugging

 

Added ability to create debug context for graphics. It allows you to debug HLSL/GLSL shaders step-by-step, inspect each DIP, see the result of each DIP on the final image, etc. Graphics debugging can be enabled via:

• Setting the -video_debug 1 command line option (alternatively, you can run video_debug 1 && video_restart console command in the running engine instance). Works for both OpenGL and DirectX 11.
• Specifying the USE_OPENGL_DEBUG_OUTPUT macro for extended debug OpenGL output (requires recompilation).

 

Other Renderer Improvements

• Added the per-object velocity buffer.
• Added ability to render all objects into the auxiliary buffer.
• Improved sRGB, it is always enabled now.
• Fixed impostors without image masks.
• Simplified nodes options, removed redundant ones (Receive shadow, Receive world shadow, Decal, Decal mask).
• Simplified light source options, removed redundant ones (Force deferred, Diffuse scale, Normal scale, Specular scale, Specular power, Deferred distance, Transparent, Transparent size).
• Removed the render_restart console command,
• Removed redundant console commands, added new ones, most of the rendering options are controlled by consistent render_* commands now. The full list of console commands changes is available in the Console Migration article.
• Removed the LightSpot object.
• Removed the ObjectBillboard object. Separate billboards can now be created inside ObjectBillboards via the Billboards tab -> Add. Billboards are now rendered sub-pixel, so they can be visible from far away.
• Added materials reparenting (Materials window -> Change material parent button).
• The default materials library is now created on the new world creation.
• A lot of bugfixes.

 

 

Data Streaming

• Added asynchronous loading of all material textures and meshes for ObjectMeshStatic, ObjectMeshClutter and ObjectMeshCluster objects into memory.
• Added support for streaming of all textures.
• Removed getSpawnRate()/setSpawnRate() methods of ObjectGrass and ObjectMeshClutter.
• Removed memory limitations on loading query of meshes, images, files and blobs in the file system.
• world_log_async and filesystem_log_async console commands have been replaced with async_log_mode and async_log_priority.
• Procedural content of ObjectGrass and ObjectMeshClutter is now generated in a separate thread.

As a result, a lot of annoying micro-freezes were eliminated, greatly increasing FPS stability and improving synchronization between IG channels in multi-channel setups.

 

 

Performance Profiling

 

Integration with Microprofile

 

Added support for microprofile, an external embeddable CPU/GPU profiler with support for per-frame inspection. The profiler serves output as a local web server (works in the Google Chrome web-browser only), the default TCP port is 1337.

 

To build the engine with support for microprofile, use the USE_MICROPROFILE preprocessor macro. It is enabled by default for Mac and Linux operating systems, Visual Studio 2012+ is required for building on Windows (because of some C++11 features).

 

 

Default Profiler

• Fixed profiling for more than one frame.
• Added profiling covering for all engine segments.
• Added integration with microprofile: you can use engine.profiler functions to profile a certain piece of your code via counters.
• Added the extended FPS counter mode (enabled via the show_fps 2 console command): display of minimal/average/maximal FPS values over the last 600 frames.

 

Support for DIS, HLA and C2 Protocols

 

Introducing integration of the Calytrix LVC Game library, which enables communication between components of distributed simulation systems via the standard protocols: DIS, HLA and C2 (mostly used for military projects). Thanks to that now it is possible to connect UNIGINE 2 seamlessly into your training environment.

 

 

Integration works by means of the LVC Game add-on, available only in the UNIGINE 2 Sim edition.

 

 

Motion Capture

 

Introducing integration of the following motion tracking systems:

• ARTTRACK is a tracking software controlling functions of the tracking system. An ARTTracker add-on is used for integration with this technology.
• Perception Neuron is a motion capture technology that includes 9-axis sensor units and allows you to record data received from these sensors in real-time. A Perception Neuron add-on is used for integration with this technology.

 

C++ and C# API

 

Our goal is to match all 3 APIs soon, so we focused on exposing new classes and unification.

• The following nodes were exposed to the API:
  • Decal
  • DecalOrtho
  • DecalProj
  • DecalMesh
  • Field
  • FieldAnimation
  • FieldSpacer
  • LightEnvironmentProbe
  • ObjectMeshClutter
  • ObjectSky
  • Physical
  • PhysicalForce
  • PhysicalNoise
  • PhysicalTrigger
  • PhysicalWater
  • PhysicalWind
  • WorldClutter
  • WorldCluster
  • WorldOccluder
  • WorldOccluderMesh
  • WorldOccluderTerrain
  • WorldTransformPath
  • WorldTransformBone
  • WorldExpression
• Exposed Mesh::Weight structure.
• Added the App::getVideoModeName method to the C# API interface.
• All functions containing "childs" in their names have been renamed "children" and marked deprecated.
• Fixed the String::itoa method: its return value now fully match the similar system function.
• Added the radix argument to the setIntArg(), setIntArrayArg(), setIntData() and setIntArrayData() methods of the Xml class. It allows to specify the scale of notation to save the value. By default is 10 (decimal notation).
• Added the renderSolidObject() and renderSolidObjectSurface() methods to Unigine::Visualizer API. It renders a solid-colored object or a surface of the object.

 

UnigineScript

• Added the core/scripts/underscore.h library providing useful functional programming helpers without extending any built-in objects (inspired by Underscore.js).
• All functions containing "childs" in their names have been renamed "children".
• Fixed crash in setTextureWidth() and setTextureHeight() methods of the WidgetSpriteViewport class when setting the image size.
• Added the radix argument to the setIntArg(), setIntArrayArg(), setIntData() and setIntArrayData() methods of the Xml class. It allows to specify the scale of notation to save the value. By default is 10 (decimal notation).
• Added the renderSolidObject() and renderSolidObjectSurface() methods to engine.visualizer API. It renders a solid-colored object or a surface of the object.
• Renamed engine.render() functions: getShaders() to getShadersQuality(), getTextures() to getTexturesQuality(), set/getOcclusionAmbientRadius() to set/getSSAORadius(), set/getOcclusionAmbientScale() to set/getSSAOScale(), set/getHDRThreshold() to set/getCameraEffectsThreshold(), set/getHDRLensTextureName() to set/getDirtTextureName(), set/getHDRFilmicShoulderScale() to set/getFilmicShoulderScale(), set/getHDRFilmicLinearScale() to set/getFilmicLinearScale(), set/getHDRFilmicLinearAngle() to set/getFilmicLinearAngle(), set/getHDRFilmicToeScale() to set/getFilmicToeScale(), set/getHDRFilmicToeNumerator() to set/getFilmicToeNumerator(), set/getHDRFilmicToeDenominator() to set/getFilmicToeDenominator(), set/getHDRFilmicWhiteLevel() to set/getFilmicWhiteLevel(), set/isHDRCrossEnabled() to set/isCrossEnabled(), set/getHDRCrossColor() to set/getCrossColor(), set/getHDRCrossScale() to set/getCrossScale(), set/getHDRCrossShafts() to set/getCrossShafts(), set/getHDRCrossLengts() to set/getCrossLengts(), set/getHDRCrossAngle() to set/getCrossAngle(), set/getHDRCrossThreshold() to set/getCrossThreshold(), set/isHDRBokehEnabled() to set/getBokehEnabled(), set/getHDRBokehColor() to set/getBokehColor(), set/getHDRBokehScale() to set/getBokehScale(), set/getHDRBokehFarSize() to set/getBokehFarSize(), set/getHDRBokehFarPower() to set/getBokehFarPower(), set/getHDRBokehNearSize() to set/getBokehNearSize(), set/getHDRBokehNearPower() to set/getBokehNearPower(), set/getHDRBokehTextureName() to set/getBokehTextureName(), set/isHDRShaftEnabled() to set/isSunShaftsEnabled(), set/getHDRShaftColor() to set/getSunShaftsColor(), set/getHDRShaftScale() to set/getSunShaftsScale(), set/getHDRShaftLength() to set/getSunShaftsLength(), set/getHDRShaftAttenuation() to set/getSunShaftsAttenuation(), set/getHDRShaftThreshold() to set/getSunShaftsThreshold(), set/isHDRLensEnabled() to set/isLensEnabled(), set/getHDRLensColor() to set/getLensColor(), set/getHDRLensScale() to set/getLensScale(), set/getHDRLensLength() to set/getLensLength(), set/getHDRLensRadius() to set/getLensRadius(), set/getHDRLensThreshold() to set/getLensThreshold(), set/getHDRLensDispersion() to set/getLensDispersion(), set/getVolumetricExposure() to set/getShadowShaftsExposure(), set/getVolumetricLength() to set/getShadowShaftsLength(), set/getVolumetricAttenuation() to set/getShadowShaftsAttenuation().
• Added the getExposureMode() method to the engine.render() interface allowing choosing the exposure mode: small, medium, large, bright.
• Added set/isBloomEnabled methods to the engine.render() interface controlling a bloom effect.
• Removed the getHDR(), set/getHDRSmallExposure(), set/getHDRMediumExposure(), set/getHDRLargeExposure(), setHDRBrightExposure() engine.render() functions.

 

UnigineEditor

 

UnigineEditor has been integrated into a Qt application, providing better usability of Qt widgets (native look and feel, faster) and speed up for the development process (so users will get more polished features faster).

 

• Pivot is a default pivot point option, the settings of the pivot point toggle will be saved after editor reloading.
• The ViewCube flag will be saved after editor reloading.
• Fixed key stuck in the File Dialog while shifting catalogs.
• The Speed field of the ObjectMeshStatic -> MeshSkinned tab has been renamed Playback Speed.
• The default preview model in the Materials window is material ball now.
• Camera lock is no longer required on the track playback.
• Camera effects (adaptive exposure, filmic tone mapping, bloom, lens, etc.) are now globally enabled in the Rendering panel -> Camera Effects. Their parameters are modified in the Rendering settings -> Camera Effects. The old HDR tab has been removed.
• Improved undo/redo system.

Improved FBX Assets Workflow

• Updated Merge static meshes option: only one merged mesh is created.
• Added correct import of the FBX model with several layers.
• Fixed incorrect nodes order after loading the same FBX model.
• Added ability to choose a workflow (Specular or Metalness) on the FBX assets import.
• The FPS option in the FBX import window has been renamed Animation FPS.
• Added correct handling of the FBX models components with the duplicated names.
• Fixed incorrect import of FBX files from 3ds Max (while bones hierarchy is changed).

 

Asset Browser (Experimental)

 

Initial version of the asset browser provides the following functionality:

• Navigation through the assets and directories.
• Ability to drag and drop assets (textures, meshes, nodes, FBX files, material libraries) into the window from the system file browser.
• Customization of import settings.
• Ability to drag and drop assets (meshes, nodes, FBX files) from the asset browser directly to the scene.

 

The feature is in the active development and is not recommended for the production use.

 

 

Video Grabber

 

Introduced Video Grabber, a UnigineEditor tool for high-quality capturing of screenshots and frame sequences. Video sequences are captured in a special non-real-time mode, allowing to get any fixed FPS even on a low-end hardware. In comparison with traditional CPU-based offline rendering, this tool allows much faster rendering thanks to GPU acceleration.

 

Features:

• Support for super high resolution (offscreen rendering) - you can take 4K/8K images with a regular monitor.
• Capturing sequences of frames according to the TRACK file.
• Background alpha masking.
• Support for increased color precision (16-bit per channel).
• Scene warmup before capturing.
• Support for professional EXR format, in addition to TGA, JPG, PNG, PSD.

The tool is available only for the Professional and Sim editions.

 

 

 

SDK Browser

 

License Management

 

SDK Browser is now managing licenses for the current machine: in order to use the UnigineEditor or debug builds of the engine, it is required to keep the SDK Browser launched. Release builds of the engine does not require connection to the SDK Browser.

 

If you do not have stable internet connection, SDK Browser can work in offline mode. In this case you will need to perform offline activation (required only once per machine): go to Options -> Manage licenses and follow on-screen instructions.

 

Projects Upgrade

 

Now it is easy to upgrade your project content to the newest version right in the SDK Browser by pressing Upgrade available button. The backup copy of your project will be created before the upgrade process, a migration report will be opened in your browser at the end of the process.

 

 

Automatic upgrade is available for:

• Materials and material libraries
• Objects: decals, terrains, light sources
• Meshes and animation

Migration of your code should be done manually.

 

Other Changes

• More robust work with unstable internet connection.
• Added ability to choose CDN locations (Netherlands or China) on the login.
• Added access to the offline documentation (Knowledge -> Offline Docs). It is a snapshot of online documentation in the CHM format.
• Added ability to run samples with UnigineEditor (the Edit Content button).
• Removed creating of x86 version projects on Mac and Linux.
• Added ability to install SDK to folders with the non-latin names.
• Faster installation of downloaded components.
• Fixed import of relocated to another folder projects.
• A lot of minor bugfixes.

Known issue: El Capitan (Mac OS X 10.11) is not supported at the moment (update will be available shortly).

 

 

Improved VFX Library

 

A new VFX add-on (instead of old SFX one) contains several ready-to-use effects (based on particle systems):

• Fire
• Explosions
• Gun shots
• Smoke
• Jet engine
• Dust
• Rocket launch

 

 

Other Changes

• 32-bit Mac OS X is no longer supported (all of the recent releases are 64-bit already).
• Upgraded GLAppSDL embedding sample, now it works with the SDL version 2.0.1 and higher.
• Fixed setting of PlayerPersecutor targets.
• Improved error messages display on Windows.
• Upgraded AMD Display Library (ADL) SDK to the 8.0 version.
• Fixed sound gain reduction for repeating sounds.
• Fixed engine build on Linux with the x86 binaries for AMD Catalyst 15.5.
• Fixed particles each frame re-rendering after setting the setEnabled() parameter in Tracker.
• Fixed Tracker crash after adding the Animation parameter of ObjectMeshSkinned.
• Added the libarchive into the set of "extern" libraries.
• The zlib compression library upgraded to the 1.2.8 version.
• Added the _f, _met and _alb postfixes for the fiber (microfiber), metalness and albedo textures. They should be used both in projects when creating textures and in the ImageDDS tool.
• Improved error messages on loading incompatible engine plugins.
• Added the _nrgb postfix for the RGB normal maps to the ImageDDS tool.
• Added camera_get and camera_set console commands for quick positioning of the game camera. Editor camera is not supported.
• The Max temperature parameter of the GPUMonitor plugin now shows the maximum temperature value counted from the start of application.
• Added ability to save textures to the OpenEXR format.

 

Documentation

 

Introduced tags system for quick navigating among engine entities.

 

• Added a step-by-step tutorial showing how to add the FBX model to the world.
• Updated articles on the Field Spacer and Field Animation objects.
• Updated articles on the Player Actor/Persecutor/Spectator.
• Updated article on the World Expression object.
• Updated article on the GUI Launcher.
• Added article on the Video Grabber.
• Updated articles on the Decals.
• Added articles on the Environment Probes.
• Updated article on the Particle System.
• Added article on the TAA.

Starting from this release, further updates will have 2.x version format.

[silent]

* this place is reserved *

[cinetec_tech]

is the editor source released too? if yes. could you let me know where is it?

also why editor only in debug mode?

thanks

[binstream]

is the editor source released too? if yes. could you let me know where is it?

also why editor only in debug mode?

thanks

 

No, editor sources are not released. We are still in the transitional mode with it, later there will be an API for modifications.

[ulf.schroeter]

I just started PBR sample on Intel HD5500 GPU to evaluate new temporal anti-aliasing. Unfortunately this gives temporal shimmering of fine text structures in the background even in case camera is not moving  (see image difference between to 2 different frames). Also in the foreground certain parts show heavy stair-step effects. Also when starting the Tropics demo overall image quality is quite bad, as whole image looks far too blurred (especially all vegetation edges/hut roofs). Same is true for city demo

 

Is this low image quality related to creepy Intel GPU or caused by new TAA ? If the latter new TAA anti-aliasing (and drop of high-quality hardware MSAA support) would be fore sure an issue :huh:          

 

 

[ulf.schroeter]

 

Support for DIS, HLA and C2 Protocols

 

Introducing integration of the Calytrix LVC Game library,

 

Just had a short look on the Calytrix home page. Unigine not yet listed as integration partner, maybe this should be requested for some advertising for newly supported capability. 

[binstream]

I just started PBR sample on Intel HD5500 GPU to evaluate new temporal anti-aliasing. Unfortunately this gives temporal shimmering of fine text structures in the background even in case camera is not moving  (see image difference between to 2 different frames). Also in the foreground certain parts show heavy stair-step effects. Also when starting the Tropics demo overall image quality is quite bad, as whole image looks far too blurred (especially all vegetation edges/hut roofs). Same is true for city demo

 

Is this low image quality related to creepy Intel GPU or caused by new TAA ? If the latter new TAA anti-aliasing (and drop of high-quality hardware MSAA support) would be fore sure an issue :huh:          

 

Anti-Aliasing-Artifacts.png

 

TAA works better on more capable GPUs, where at least 30 FPS is achievable. Frankly speaking Intel GPUs were not the main priority for this release.

[binstream]

Just had a short look on the Calytrix home page. Unigine not yet listed as integration partner, maybe this should be requested for some advertising for newly supported capability. 

 

Good point, thank you - we'll do.

[sergey.pozhidaev]

how start editor from Qt-Based app (console command "editor_load" is no more)?

[binstream]

Editor is a standalone application from now on, so in order to edit a world you need to open it with the editor binary.

Unfortunately it is a tradeoff for better usability and faster progress of the toolset.

[ulf.schroeter]

Editor is a standalone application from now on, so in order to edit a world you need to open it with the editor binary.

Unfortunately it is a tradeoff for better usability and faster progress of the toolset.

Drop of integrated editor mode is very bad news for simulation customers :blink: This feature was one of the strongest Unigine features (compared to other engines) for large world scene debugging...you could run scene in 'real-world' engine simulation mode, switch at a problematic scene to editor mode, analyse nodes, issue some console commands for state dump etc. and then once again switch back to 'real-world' engine simulation mode....now this is gone ? Not good from my point of view.

 

Same might be true for simple drop of hardware MSAA support in 2.0. Just based on some simple scene tests (see above post) the image quality of TAA might be far to bad for simulation purposes were especially crisp and non-shimmering rendering of fine structures is paramount. I might be wrong, but I don't think that the bad image quality is mainly caused by Intel GPU quality, but is related to the TAA algorithm itself . If so - wIth MSAA now gone - how to handle this situation without fallback alternative ? (BTW would be great if other community members could judge achievable TAA anti-aliasing quality on higher-end NV/AMD GPU hardware in the context of their specific application requirements. It would be VERY GOOD news, if I am totally wrong with my quick testing only on low-end Intel GPU)

 

In general I think it would be a much better approach for Unigine development to have regular upfront discussions of such kind of fundamental changes or planned other features here in the forum for gathering upfront feedback regarding pros and cons or real-world customer feature requirements. Unfortunately this has never really been a big tradition, which is bad, as the community could provide very powerful design input prior to implemenation based on their in-depth experience and real-world requirements knowledge...just my two cents B)

[binstream]

Editor loading on the fly had three aspects:

1) (positive) ability to load editor ad hoc for debugging.

2) (negative) running editor with world logic executing at the same time was a huge problem for artists all these years.

3) (negative) it forces developers to use only native Unigine GUI, which is not enough for a rich GUI application easy to use for non-programmers.

So the decision was painful, but required. However we still think that it might be possible to restore ad hoc debugging feature in some form.

 

Regarding TAA: it works fine in the range of 30-60+ FPS (simulation projects aims 60 Hz most of the time anyway). Unfortunately MSAA is not compatible with full deferred rendering (which, in its turn, allowed to achieve better performance scalability and is more preferable for modern GPU design). Moreover, MSAA was working only for parts of the scene, while TAA covers it better. Please give TAA a try on regular NVIDIA/AMD hardware.

 

As for upfront discussions - you are welcome to participate in the releases plan, we will continue posting our detailed roadmap upfront. Opinions of expert customers (and Ulf is definitely the most active here) is very important to us - a lot of improvements were already delivered based on this kind of feedback. And we are changing our approach for more customer-oriented one now. As for the collaboration format, it is a good idea to discuss some large features upfront - we'll do this right next week for 2.1 plan, starting with this thread, for example: https://developer.unigine.com/forum/topic/3527-sky-clouds-scattering-improvements/

[yang.zhang]

i hope unigine could release the editor source code + api(even it's in a hybrid state) so we can customize our own ui too. otherwise it's difficult for us upgrading to the 2.0

[ulf.schroeter]

 

As for the collaboration format, it is a good idea to discuss some large features upfront - we'll do this right next week for 2.1 plan, starting with this thread, for example: https://developer.un...g-improvements/

 

Very good !

[ulf.schroeter]

Editor loading on the fly had three aspects:

 

1) (positive) ability to load editor ad hoc for debugging.

Exactly, this was a big advantage. Maybe having some socket-based live state sync between running engine instance and running editor instance (in a way similar to Visual Studio remote process debugging) could be a solution? I know that at least CryEngine has some kind of such live remote editing capability with auto-sync between e.g development PC and attached consoles.

[suyang]

Great job!  :)

[sergey.pozhidaev]

we have two Qt-based Unigine projects, builtin editor was very comfortable for debug, exploring scene, tune materials, etc, now with external editor we can only load world file without an logic, because all login in C++ API. may be editor will be more flexible? to load from current runtime project.

[binstream]

we have two Qt-based Unigine projects, builtin editor was very comfortable for debug, exploring scene, tune materials, etc, now with external editor we can only load world file without an logic, because all login in C++ API. may be editor will be more flexible? to load from current runtime project.

 

Please post your use cases on the editor extension here: https://developer.unigine.com/forum/topic/3528-editor-extension-api/

[binstream]

Exactly, this was a big advantage. Maybe having some socket-based live state sync between running engine instance and running editor instance (in a way similar to Visual Studio remote process debugging) could be a solution? I know that at least CryEngine has some kind of such live remote editing capability with auto-sync between e.g development PC and attached consoles.

 

That's one of the ideas internally - may be we can utilize multi-channel rendering features for that as well.

[helmut.bressler]

Hello,

 

a standalone editor is quite problematic for people who are using c++/c# to build their own .exe file.

Our projects typically call c++ code from unigine script, which is embedded into a custom executable.

We also need the editor running alongside with our custom executable.

 

Cheers

 Helmut

[ulf.schroeter]

Houston...we have a problem...

 

Unfortunately I just can support Helmut's point. We also used Unigine in a mixed script/c++ master-slave multi-channel IG setup. Switching to editor mode for dynamic world state debugging within the production environment was extremely helpful. When we were forced to switch to another engine without this capability world debugging simply became a mess...huge productivity killer

[aargh]

I totally agree with Helmut.

 

Maybe solution is to develop editor as dynamically loadable library.

[ivan.cuevas]

First congratulations for the new release. Impressive.

 

I agree, editor is a scene debugging tool. It is like a runtime snapshot and can save a lot of time debugging the code.

In addition we need to supply edition capabilities in our final application.

 

I'm intereseted in new water capabilities. I found some problems computing waves height, and also I want to know:

 - Will there be water displacement? (ships moving over the water surface)

 - Will there be particles projected over water surface? (foam trail)

[binstream]

First congratulations for the new release. Impressive.

 

Thank you!

 

I'm intereseted in new water capabilities. I found some problems computing waves height, and also I want to know:

 - Will there be water displacement? (ships moving over the water surface)

 - Will there be particles projected over water surface? (foam trail)

 

Please list your requirements here: https://developer.unigine.com/forum/topic/3537-water-improvements/

[alexey.egorov]

• All functions containing "childs" in their names have been renamed "children".

   

  RAMPAGE!!!