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

UNIGINE 2.0 Alpha Preview

Main Changes

This is an alpha preview of upcoming UNIGINE 2.0 (which has been in the development for almost a year now), but a lot of important improvements are already done:

  • Refactored renderer focused on DirectX 11+ feature level.
  • Removed support for DirectX 9, OpenGL ES 2.0, PlayStation3, WebGL, WinRT.
  • Support for OpenGL 4.5.
  • Improved terrain with increased number of layers.
  • Unified mesh file format.
  • Support for blend shapes (morph targets).
  • Support for vertex colors.
  • Experimental support for physically-based rendering (PBR) and screen-space reflections (SSR).
  • Improved usability of UnigineEditor.
  • Support for GeoTIFF format.
  • GDAL import plugin for geodata.
  • Support for NVIDIA Tegra K1.
  • Experimental support for WPF .NET C# applications integration.
  • Support helpdesk on the developer portal.

Some features are in the active development at the moment, so this release isn't recommended for production use.

Stable 2.0 release and further updates will bring even more:
  • Rendering performance optimizations.
  • Support for OpenGL ES 3.0.
  • Improved anti-aliasing.
  • Geometric waves, better shorelines and other water improvements.
  • Improved light scattering.
  • Improved volumetric clouds.
  • Night vision mode.
  • Streamlined content pipeline.
  • Easy projects management: creation, upgrading, deployment, publishing.
  • Add-on store for engine plugins and content assets.


  • Refactored renderer focused on DirectX 11+ feature level.
  • Removed support for DirectX 9.
  • Added support for NVIDIA Tegra K1 with full support for OpenGL under Android and Linux platforms.
  • Removed limitation of 32K surfaces per object.
  • An OpenGL 4.5 direct state access (DSA) extension is now available for the source version of the engine. Use the opengl_45 SCons build flag to include OpenGL 4.5 functionality.
  • All mobile shaders have been refactored to OpenGL ES 3.0 version.
  • Removed mesh_terrain_base material.
  • Terrain materials are now operated in the Nodes tab of UnigineEditor.
  • Removed mesh_chain_base material.
  • Added post_deferred_occlusion and post_deferred_light post-materials.
  • Added support for cube array images.
  • System gamma values will not be changed if the gamma has a default value.
  • Added correct parallax mapping orientation for different tangent space orientations.


  • Precision for height maps has been increased to 31 bits, floating point (1 bit is used for holes).
  • Added additional uncompressed index texture that stores a number of a detail material per channel (can have up to 16 channels).
  • Detail materials have been renamed to Layers.
  • Added specular texture to layers.
  • Added ability for flexible mask setting by modifying Value, Width and Threshold parameters.
  • Added parent-children system, which allows you to use the same mask for several materials.
  • Added 8 performance levels for 1, 2, 3, 4, 6, 8, 12, and 16 materials (shaders for other amount of materials are not ready yet).
  • Added diffuse, normal and specular terrain texture arrays. They are recalculated automatically on terrain materials changing while editing.

Unified Mesh Format

Both static and animated meshes are now stored in a .mesh file format. It can store both geometric data (vertices and their weights) and animation (bone transformations and blend shapes). The format also features:

  • Up to 7 active blend shapes (morph targets) per surface for facial animation and object deformations.
  • Different kinds of mesh animation (scaling, morphing, addition, subtraction) before skinning.
  • Support for multiple named animations.
  • Seamless tangent space between different surfaces.
  • Storing of pre-calculated tangent space from 3D editors.
  • Bone rotations stored in quaternions instead of normal vectors for better loading speed.
  • A bind pose for each mesh. The first animation frame shouldn't contain the bind pose as before.
  • Support for 8-bit vertex colors.
  • Increased precision for texture coordinates (controlled by a half_texcoords SCons flag, a half precision is set by default).
  • Added support for unsigned short and double (OpenGL only) vertex formats for dynamic meshes.
  • Removed limitation on vertex count for dynamic meshes.
  • Increased precision of the Z coordinate to 32-bit float.
  • Two sets of per-spatial vertex and per-triangle vertex indices. Such an approach improves the loading speed.
  • Increased precision for skinning to 32-bit float weights.
  • A new .anim format is used to store animation without geometry. Old .smesh and a .sanim formats are removed.
  • Extended animation layers API with all of the animation buffers functionality. Animation buffers are removed.
  • The same set of shaders for static and skinned meshes.

Support for .3ds, .lwo, .ase, .bsp, .map and .md5 legacy file formats is removed.

Improved Geodata Support

Integrated support for GDAL (Geospatial Data Abstraction Library) as GDALImport geo data import plugin (available only in UNIGINE Sim edition) that:

  • Supports almost all geodetic formats.
  • Provides automatic conversion of the input image pixels to WGS84 latitude/longitude coordinates.
At the moment the plugin provides only basic functionality, please check the corresponding UnigineEditor plugin as a sample: data/editor/plugins/import/gdal.

Also the direct support for loading GeoTIFF files (with a float precision) as a regular image has been added into the engine.

Experimental PBR and SSR Support

PBR (physically-based rendering) materials are still in the experimental phase, but they are already fully-featured and have very good performance.

The material uses the following texture set: diffuse, specular, glossiness (the alpha channel of a specular), ambient occlusion. Besides, a lightmap, parallax occlusion map and emission map can be used optionally. The PBR material has the following features:

  • A Fresnel coefficient that provides stronger reflections for big surface slopes.
  • An intensity of specularity that allows you to adjust the metallic settings. Energy conservation provides diffuse overlapping, which allows you to create a physically correct material.

    Specular: 22-255 for metal; 0-22 for plastic

  • A gloss influencing the blurring cubemap intensity.
  • A Disney GGX BRDF (bidirectional reflectance distribution function) model that is used for specularity. It was modified in order to create a ability to vary the fluffiness degree, which is required to create fabric. The dynamic reflections for this method are also supported.

    Gloss: 201-255 for glossy plastic; 70-200 for rough leather or plastic; 0-50 for fabric

Leather material

Fabric material

Besides the physically based material, there are screen-space reflections (SSR) we are working on. They have the following features:

  • Correct work with any geometric forms by means of a screen-space raytracing method.
  • Blurriness regulated by the gloss intensity.
  • A very high performance comparing with other methods providing the similar quality.

Because these features are still in the experimental stage, these materials aren't included into the current SDK builds.


Huge changes are going on with UnigineEditor: now we have a dedicated team working on its improvements. Main focus is better usability for both new and experienced users.

  • Added main menu and a lot of new dockable panels.
  • Industry-standard controls schema.
  • Better default settings for built-in nodes.
  • Improved overall editor performance.
  • Migrated all features from the old main panel.
  • Added Create -> Primitive item (box, sphere, plane).
  • Removed most of the object creation dialogs.
  • Reworked terrain creators.
  • Added File -> Save world as... item.
  • Added File -> Recent worlds list.
  • Added Plugins section.

Scene Navigation

  • Implemented customizable controls system with 3 built-in presets (UNIGINE 2, UNIGINE 1, 3ds Max): Windows -> Controls.
  • Default controls schema has been aligned with industry standards (Maya-like).
  • Implemented smooth focusing on selected object.
  • Added camera speed and position panel with 3 speed presets (migrated from Tools -> Camera).

Selection of Objects

  • Selection of objects by single click or by dragging a frame.
  • All surfaces are selected on multiple object selection.
  • Fixed lights visualization on multiple selection.
  • Added deselection from multiple selection by frame.
  • Added Edit -> Select All feature.
  • Revived Edit -> Group selected feature.
  • Huge performance speedup of working with complex scenes (>10000 objects).


  • New user interface for Terrain Editor.
  • Improved brush performance.
  • Index texture support.
  • Real-time normals update while painting.
  • Auto-refresh for terrain textures and arrays.
  • Smart algorithm for terrain index generation.
  • Revisited Nodes -> Terrain tabs.
  • Multiple bugfixes on corner cases in Landspace plugin.
  • Removed seams between terrains created with Landscape plugin.

Placement Tools Panel

  • Migrated snapping settings from Tools window.
  • Added Pivot/Center button to control pivot point.
  • Added axis lock support.
  • Removed 1-frame lag of manipulators.

Camera Selection Panel

  • Quick jumping through world cameras.
  • Per-camera settings: name, FOV (including setting of lens size), clipping planes, bit masks.
  • Lock camera position feature (when locked, a view movement doesn't affect the camera position; when unlocked the camera remembers the view position).
  • Quick camera creation from the current view.

Rendering Mode Panel

  • Switching between pre-defined view modes.
  • Internal buffers visualization.
  • Control for renderer passes.
  • Control for renderer features.

Editor Plugins

Every UnigineEditor plugin has a .plugin file with meta-info, they are automatically loaded from data/editor/plugins folder. A plugin can be enabled/disabled via Plugins -> Manage window. Once the plugin is loaded, its window can be accessed via Plugins section in the menu.

Other Improvements

  • Multiple viewport windows.
  • Confirmation for saving changes on closing the application.
  • Saving panels layout.
  • Added hotkey values into tooltips.
  • Last used folder is remembered for each file type.
  • Explicit edit button for binary masks editing.
  • Limited disk space for image and node previews.
  • A lot of old known bugs fixed.


  • Added support for user-defined colors for diffuse and specular textures.
  • Added intensity scales for diffuse and normal textures.
  • Added surface morph targets visualization.
  • Added optional seamless tangent basis calculation for different surfaces.
  • Added flipping of a tangent space orientation.
  • Camera is locked when dialog windows are active.
  • Added dedicated buttons for animation loading and saving.
  • Added support of passing .proj file names via command line argument.
  • Added vertex color mapping into NormalMapper.
  • Fixed a bunch of bugs.

Other Tools

  • 3ds Max Plugins:
    • Added support for a new .mesh format.
    • Fixed export of hierarchical nodes.
    • Fixed incorrect tangent binormal orientation.
    • All plugins are bundled into a single UnigineMesh.dle file.
  • Maya Plugins:
    • Added support for a new .mesh format.
    • Added support for UTF8 strings.
  • Added scaling and translating of input meshes into MeshImport.
  • Different scale filtration modes can be switched by the "L" key in the ImageView tool.
  • USC interpreter returns the first command line argument (file path and name) as the -1 command line argument.
  • Added support for writing .obj files into USC tool.
  • To upgrade meshes, terrains, worlds and splines to new formats under Windows do the following:
    1. Put an USC script to the folder which subsidiary folders and files should be upgraded.
    2. Put upgrade.usc, mesh.usc, path.usc, terrain.usc and world.usc scripts to the same folder with the USC script.
    3. Run USC.
    4. Specify upgrade.usc script.

    As a result you will get you resources upgraded. Old files are kept by default with the "-" prefix. If you want them to be deleted, pass the -c parameter.

    As .mesh and .smesh files used to have the same names, you need to rename files manually before upgrading to avoid errors.


There are a lot of changes in UnigineScript API, please refer to the detailed migration guide.

Language Improvements

  • Added templates.
  • Added four-component swizzles for three-component vectors.
  • Added recursive classes function calls. The functions can be called in the following way: mesh.getBoundBox().getMin(). The type of a return variable is equal to return type of a user function or return type of an external C++ function. Because of that advanced detection of reference returning classes have been added.
  • Added call() function for vectors and maps.
  • Added swap() container function.
  • Added quat method for vector and map types to the quat type conversion.
  • The ";" symbol after a namespace block is now redundant.

New Mesh Classes Structure

Logical manipulations with a mesh have been moved to the new Mesh class. The old Mesh class has been renamed to ObjectMeshStatic. So, mesh handling classes are now organized in the following way:

  • A base Mesh class is used for manipulations with meshes, their loading and saving.
  • An ObjectMeshStatic class is used for static meshes rendering and their collision detection.
  • An ObjectMeshSkinned class is used for skinned meshes rendering and their collision detection.
  • An ObjectMeshDynamic class is used for procedurally-generated geometry.

Updated Bounds

Bounds have been refactored. New BoundBox, BoundFrustum and BoundSphere classes have been added to the script library. So, now you can operate with instances of these classes rather than with dimensions of bounding box/sphere/frustum.

When working with double precision coordinates, use a WorldBoundBox/Frustum/Sphere classes.

Updated Intersections

Intersections have been refactored. Now there are several classes that are used to manage intersections:

Temporary object of one of this classes should be constructed and passed into the getIntersection() method instead of a return array.

Other Changes

  • stack_dump() and call_stack() functions have been renamed into get_stack_dump() and get_call_stack().
  • Platform-native message and file dialogs have been exported into the script.
  • Added load/saveWorld(), save/restoreState() script functions to the script library for all engine systems.
  • Class:
    • Added support for multi-touch functionality for Windows, iOS and Android platforms.
    • Added support for window positioning, so the Interface plugin is no longer required.
    • Fixed getKeyName() function. It will never fail on Unicode characters.
    • Added dialogMessage() function.
  • Math functionality:
    • Added methods for the tangent space calculations.
    • Added matrix and quaternion constructors which receive column vectors.
  • System functions:
  • File System:
  • Fixed inheritance of classes with multiple base interface classes.
  • Added new SingletonPtr<> template. It allows you to create a single instance of class.
  • BodyRail and JointRail classes have been renamed to BodyPath and JointPath.
  • run() methods of the Async class can receive a function ID for an external class method. The ID can be obtained by functionid(Foo::bar) function.
  • Added setSampleName() function for AmbientSource and SoundSource classes.


  • Added Stream::read / writeUChar / UShort() functions for advanced numbers manipulations.
  • Improved automatic type conversion between script and corresponding *Ptr objects. Constant *Ptr references are supported now.
  • Added support for window position and multi-touch to the Unigine::App class.
  • UnigineInterpreter.h file has been split to two files: UnigineInterpreter.h and UnigineInterface.h.
  • Added automatic detection of type*, type&, const type* and const type& types.
  • Updated Mesh and Path classes.
  • Improved isExternClassObject / getExternClassObject() functions of the Unigine::Variable class.
  • Added method for allocating vertex and index arrays. Texture coordinates, tangent basis, weights and color arrays must be allocated manually.
  • Added Image / Texture::getNumChannels() functions.
  • Added Mesh::set / getBoneTransforms() functions to control world-space bone transformation on bind pose or any of animation frames.
  • Added Unicode version of the Unigine::init() function (receives a wchar_t type for argv pointer). This allows you to use "wmain" entry point under Windows and handle non-ASCII symbols correctly.
  • load / saveSettings() functions have been added into all systems.
  • Added setCallback0/1/2/3 functions to Unigine::UserInterface and Unigine::Widget classes.


  • Cut/copy/paste operations under MacOS can be done using Cmd+X/C/V hotkeys.
  • Fixed numerical issue with WidgetSpinBox.
  • The internal precision of WidgetDialogColor sliders have been reduced to 255 levels.
  • Added the third Close button to all file dialogs. It is disabled by default.
  • All buttons that have no text will be automatically hidden.
  • A dialog_close.png GUI resource file has been renamed to window_close.png.
  • Platform specific dialogs are available without using plugins except for Linux.
  • Removed sRGB support for WidgetDialogColor.
  • WidgetSpinBox and WidgetSlider attach Up/Down/PgUp/PgDown keyboard keys and mouse wheel for better handling.
  • WidgetMenuBox tooltips can be loaded from the menu section of .ui files.
  • Added support for WidgetTreeBox reparenting inside .ui files to UserInterface.
  • Added getIntersection() function to the Widget class.
  • Added per-item tooltips to MenuBox.
  • Added GUI_DRAG_MOVE callback. It is used when a focused widget is moved.
  • Added GUI_DRAG_DROP callback. It is used when a drag-and-drop operation is performed with a widget.
  • Added support for items disabling for WidgetMenuBar.
  • Added configurable spaces to WidgetMenuBar and WidgetMenuBox classes.
  • Added support for inherited menus WidgetMenuBox.
  • Added <left> and <right> tags. A <right> tag aligns the text to the right border.
  • Added <xy x= y=> tag. It sets the fixed text coordinates positions.
  • Fixed incorrect numerical validation for Unicode symbols.
  • Added visible region clipping for WidgetCanvas.
  • Changed ESC button behavior for WidgetDialog. If the Close button is active, the application will be closed.
  • Changed WidgetDialogColor sliders precision. Now it has 255 levels.

Platforms and Builds

  • Removed support for the following platforms: PlayStation3, WinRT, WebGL.
  • Added support for OpenGL ES on Linux systems with EGL library installed (Mesa and NVIDIA drivers).
  • Linux ARM default platform is gnueabihf (hardware float).
  • Added support for CPPPATH, LIBPATH, CPPFLAGS and LINKFLAGS environment variables to SCons build scripts.
  • Mac OS X builds require XCode 6.0 now.
  • All Windows-specific compilation warnings have been removed.
  • Added GCC-specific validation.


  • Added global pointers to asset_manager, native_activity and native_window for Android.
  • Added Android NativeActivity API to access file system via C++ without using Java interface.
  • Initialization of OpenGL ES under Android can be done without using Java.
  • Removed support for PVR, ATC and ETC1 texture compression formats.
  • Added multi-touch support for iOS.
  • An script has been removed, script should be used instead with second argument as a file target.

Engine Plugins

  • AppProjection:
    • Added getMeshProjection() function to the projection.h script file.
    • Added SpinBox and all column/row resetting buttons to AppProjection.
    • An AppProjection plugin now has getter functions for its parameters. save|restoreState functions have been added as well.
  • AppWall:
    • Added PROJECTION_USER definition for wall.h system script. It removes any kinds of player or plugin matrices modifications. The user is responsible for viewport modifications when this definition is declared.
    • Correct handling of additional GUIs with Interface plugin loaded.
  • FBX Plugin:
    • Migrated to FBX SDK 2015.1.
    • Added support for vertex colors.
    • Added support for built-in tangent space.
    • Fixed import of models with empty or colliding UV names.
  • Collada Plugin:
    • Added support for vertex colors.
    • Added support for built-in tangent space.
    • Added support for blend shapes.
  • OpenFlight Plugin:
    • Added support for vertex colors.
    • Fixed support for folders created after loading of the plugin.
  • Fixed clipboard buffer for all App* plugins.
  • Fixed multiple App* plugins loading.
  • Fixed collisions of multiple App* plugins loaded at the same time.
  • Added plugin_path console variable, multiple directories can be specified with comma delimiter. The default value is "plugins/", all plugins found in this directory will be loaded automatically.


  • Qt integration sample (GLAppQt) has been migrated to Qt 5.3.1.
  • Fixed wrong window handle for AppQt samples.
  • Added experimental sample of integration into WPF .NET application with minimal C# interface.
  • Added new high-quality sample with animated character: Soldier demo.



  • Increased CPU-side sorting performance for ObjectParticles and ObjectBillboards.
  • Removed 16384 grass blades limit for ObjectGrass.
  • Removed 16384 billboards limit for ObjectBillboards.
  • Added methods for setting the arbitrary number of forces, noises and deflectors for ObjectParticles.
  • ObjectGuiMesh class has the same mesh loading behavior as all other mesh-related classes.
  • Added support for mesh reloading into ObjectMeshClutter and ObjectMeshCluster.
  • WorldTransform node has been renamed into WorldTransformPath.
  • Added support for changing a thread priority (requires root privileges under Linux). Available priority levels are: -3,-2,-1,0,1,2,3 (0 is the default value).
  • GLESAppWindow class can be used for the OpenGL ES initialization without deriving the Unigine::App code. It also supports an arbitrary video mode.
  • Wireframe color can be changed and saved inside of the .world file.
  • Added addKnownFile() function that registers a file name in the internal fast lookup map.
  • Multiple-node saving functions save all material and property dependencies in the same way a as single-node function (see and Unigine::saveNodes() functions).
  • Added conversion of floating point images into the corresponding integer images.
  • Added Unigine::remapCVertex and remapCVertex() functions.
  • XML parser:
    • Correct loading of UTF16 files for all loaders and parsers: Xml, Interpreter, Shader and OBJ.
    • Minor size optimization for binary XML format.
    • Fixed parsing of &#ddd; Unicode symbol format for XML files.
  • Fixed vector transformation functions: now they are safe for the same source and destination argument addresses.
  • Added support of direct FBX file loading inside of the Mesh class (requires the engine built with USE_MESH_FILE and HAS_FBXSDK definitions).
  • Added the USE_HALF_TABLE compilation flag for the half to float type conversion.
  • Added quickOptimize2() function to Utils.h. It removes equal elements from the array and generate corresponding indices from the old to new conversion.
  • Increased performance of radixSort() function of Utils.h.
  • Added double precision configurations for Mac OS X sample projects.
  • Unigine::Syncker:
    • Stream syncker calls allow you to pass any kind of data to remote slave functions via Buffer class.
    • Each slave remove call must contain the slave bit-field mask (each bit indicates the corresponding slave).
  • Added support for skinned animation files to .dae file format.

P.S.: Stable release of UNIGINE 2.0 is planned for the end of this year, stay tuned for more improvements!

Build: ()