Render:

• Added mesh_overlay_base material (useful for creating procedural rust or moss on objects).
• Optimized assigning of materials to object surfaces.
• Fixed video playback in 3D stereo mode under DX11.
• Added 'MaxShadowSplit' option for surfaces to skip rendering of high-detail shadow splits from LightWorld. (It is useful for small objects like stones, etc.)
• Fixed crash on render_manager_reload console command.
• Environment cube map texture is not in SRGB format from now on.
• Added the following modes for terrain detail materials: "skip" (not rendered), "overlay" (the old blended one) and "overlap" (without blending, the spread of such material can be additionally tweaked using "Value" and "Threshold" parameters). Overlap terrain material cannot be used together with triplanar mapping.
• Additional noise transformation parameter for sky volume clouds.
• Improved performance of dynamic vertex/index buffers on open-source drivers in Linux.
• Support of vertical synchronization in Linux.
• Renderer checks for EXT_texture_compression_s3tc extension availability on startup (a Mesa driver doesn't support it due to the legal issues).
• A mask for ObjectGrass, ObjectMeshClutter and WorldClutter is now editable in real-time.
• Fade color for fade post-process is now a normal color that is blended by the alpha component: zero alpha value means no fading, while the alpha value of one results in a solid-color screen.
• Increased the default values for Shadow bias and Slope parameters for all light sources.
• Added separate diffuse and specular color multipliers.
• Improved OpenGL ES initialization on iOS.
• Added support of iPad 3.
• Added support of hardware shadow maps (cast from LightProj and LightWorld sources) on mobile platforms.
• Added a wind direction vector common for all vegetation (grass and trees).
• Implemented OpenGL ES support in Linux.
• New way to generate procedural textures directly on the GPU. It allows for simulation of various visual effects; see new samples in data/samples/shaders: fire_00, water_00, bombing_00.
• Added a separate emission_color multiplier.
• Improved compatibility with a new NVIDIA OpenGL driver.
• Added 1/4, 1/2 and full (relative to the screen height) reflection map sizes for reflective materials.
• Added mesh_lut_base material with baked lighting (highly efficient for mobile devices).
• Added post_filter_wet post-process materials (for the effect of water trickling down the surfaces).

UnigineScript:

• Correct ExternClass variables casting on inter-script calls.
• Added inter-script calls sample: systems/system_00.
• Added more samples on WorldExpression usage: worlds/expression_02, worlds/expression_03.
• Configurable splash screens in core/scripts/system.h.
• "using" keyword searches for a given namespace through all nested namespaces up to the global one instead of searching only in the global scope.
• The number of available namespaces is increased to 65536.
• WorldExpression calls __constructor__() and __destructor__() functions on initialization and shutdown (it can be used for proper creation and deletion of created resources).
• EPSILON and NULL definitions are removed from Unigine::Skinner blocks.
• Widgets::Dialog is created in the external GUI, if it's available.
• Improved interaction of Widgets::Line and Widgets::Track.
• Added Widgets::Time class for time manipulation.
• Added Widgets::DialogMaterial, DialogProperty, DialogNode dialogs.
• Improved implementation of engine.world.isNode() and other similar functions: now they can receive both the object identifier and the object pointer.

GUI:

• ObjectGui and ObjectGuiMesh take into the account asymmetric frustum when calculating mouse coordinates.
• Default iFPS value for WidgetSpriteViewport and WidgetSpriteNode is changed to 0 (so it is updated at the rendering frame rate rather than a lowered one).
• Fixed infinite update of WidgetSpriteViewport when the iFPS value is low.
• Fixed issue with vertical flipping for WidgetSpriteMaterial widget.
• Fixed gradient texture calculation algorithm for Flash movies.
• Added Widget::set[get]MouseCursor() functions for correct switching of the cursor between multiple GUI interfaces.
• Added Widget::getParentGui() function to access a parent GUI object.
• Fixed crashing when the scroll space in WidgetComboBox was very small.
• Fixed texture and text arrangement for WidgetTabBox, WidgetListBox and WidgetTreeBox.

C++ API:

• Fixed crash on multiple Unigine::removeExtern*() invocations with the same argument.
• Added ArrayMap::Iterator class to enumerate all elements.
• Added Variable::getTypeInfo() function which describes variable content in details.

UnigineEditor:

• Added Tracker system (see details below).
• Added mask editor for ObjectGrass, ObjectMeshClutter and WorldClutter.
• Added 'Create mask' button for ObjectGrass, ObjectMeshClutter and WorldClutter objects.
• Added a random seed for WorldCluster generator.
• Added custom terrain brushes.
• Automatic compression of terrain coarse textures when the source textures are placed in the "uncompressed" folder.
• Fixed issue with the terrain lightmap grabber.
• Added PlayerPersecutor node (it is not movable until a target is assigned for it).
• Removed "Activate" button in PlayerDummy node. To test the camera view, open Camera window and switch to the selected player.
• Added basic LUT texture editor (Tools -> LUT) to generate textures with baked lighting.
• Added new icons for different nodes.
• Changed the default world settings.

Other:

• Added new vegetation samples optimized for flight simulators (samples/materials/leaf_02).
• Added a city rendering sample that shows how to use occluders for optimized rendering (samples/stress/occluder_03).
• Node::set[get]Data is renamed into Node::set[get]Variable. Old "data" is a simple string (stored in world and save files) now.
• Changed user data path for Mac OS X projects: home_path + "Library/Application Support/" + project_name.
• ObjectGrass, ObjectParticles, ObjectMeshCluster, ObjectMeshClutter and WorldClutter can be stored inside NodeDummy and still intersect with the parent geometry on the generation stage.
• Fixed wrong bounding space of NavigationMesh after the world is loaded.
• Fixed pathfinding route issues inside of a NavigationMesh.
• Added Maya 2012 plugins.
• Migration to new Xcode and iOS 5.1.
• All empty XML nodes are automatically removed from the world files.

Tracker

Tracker is a keyframe-based tool for creating sequences animated over time. It is used for adding dynamic gameplay elements or making in-game cinematic cutscenes. With Tracker you can:

• Easily create key frames for all nodes in the world, as well as in-game cameras and render settings.
• Set up day-night shift and weather conditions change.
• Switch between the cameras, change field-of-view on the fly and play sounds for creating stunning cinematics.
• Animate interactive objects in the game, for example, lights, doors and platforms.
• Apply post-processing effects such as depth of field, HDR, motion blur and color filtering. All these effects can be fine-tuned for each camera view.
• And much more.

Read more in the documentation: UnigineScript / High-Level Scripts / Unigine::Tracker.

Valley demo preview

Valley is an interactive demo that demonstrates optimized rendering of terrain with landscapes varying from grassy vales to snowy mountains. It comes complete with various vegetation (trees, bushes, different plants, grass) and rocks on mountain sides.

The preview version also features weather animations created with Tracker system:

• Day-night cycle with various weather conditions (cloudiness, wind, rain) is controlled in 'day_cycle_mixed' track. It combines all tracks listed below.
• Positions of sun and moon on the horizon are set in 'sun_rotation' and 'moon_rotation' tracks.
• Change of light conditions to create sunny and cloudy weather (animated light parameters, scattering, fog) are set in 'day_cycle_sunny' and 'day_cycle_cloudy' tracks.
• Rain (rain particles across the screen, splashes on the ground, scattering for a downpour) is controlled in 'rain_control' track.
• Wet surfaces post-process (render_filter_wet material) is controlled in 'rain_wet_surface_control' track.
• Wind (the speed and direction of wind, trees sway animation) is set in 'wind_force_control' track.
• Depth of field effect (focal distance change, different amount of blur) is controlled in 'dof_f2' and 'dof_f8' tracks.

The preview is available for engine licensees only.

First-person shooter prototype

A Shooter project is a single-player first-person shooter that can be used to get your own prototype up and running extremely quickly. If features all aspects essential for this type of core mechanics, so you can focus on implementing and testing of custom features, as well as creating new game levels. A Shooter project can be found under data/prototypes/shooter folder.

• Added ObjectMeshCluster. Mesh Cluster is a highly optimized way to render a great number of identical meshes with the same material in the world. These meshes are baked and managed as one object, which substantially speeds up rendering.
• Added ObjectMeshClutter. Mesh Clutter scatters identical meshes across the world or terrain and speeds up their rendering. Meshes can not only be scaled, but also randomly scaled and oriented (but not moved), if necessary. Mesh Clutter scatters objects procedurally, and renders them only around the camera. It allows to render even a large number of meshes while keeping performance high.
• Added ObjectBillboards object suitable for fast rendering of groups of billboards (stars, clouds and so on).
• Fixed WorldCluster save/restore system.
• Improved GPU detection in Mac OS X.
• Restored gamma value control in Linux.
• Improved support of NVIDIA 3DVision.
• Improved support of Intel HD 3000 GPU.
• Fixed skinned mesh instancing in Direct3D10/11.
• Added a new mesh_layer_base material. It allows for selective blending of two materials: it operates on two sets of textures that show through according to a mask.
• Added a new mesh_triplanar_base material. It allows to texture meshes without using UV texture coordinates. Textures are simply projected onto a mesh along three axes.
• Added an optional material option to animate grass when 'Clutter' shape is used for it.
• Fixed non-square mipmaps compression issue.
• Added 'auto' value for 'video_app' console variable (the engine sets the best of available APIs).
• Fixed disappearing of shadows in stereo 3D mode.
• Better detection of GLX_ARB_create_context extension support (improved MESA compatibility on Linux).
• Added vertical and horizontal flip functions for Image.
• Safer way to restore fullscreen video mode after focus change in Windows.
• Fixed issue with non-attached deflector position for particle systems.
• Added 'Angle fade' option for mesh_leaf_base material to hide polygons wich are currently perpendicular to the screen plane.
• Adjustable number of generated cells for grass and clutter objects.
• Improved fullscreen mode setting in Linux and Mac OS X.
• Added 'Shadow radius' parameter to terrain, grass, cluster nodes. It controls the distance outside the view frustum used to render polygons to avoid disappearing shadows. It is 0 by default ('radius' parameter in WorldCluster is now gone, please set up this one instead).
• More configurable render_composite material: you can render non-blurred objects by mask with DOF or motion blur enabled using the Auxiliary buffer.
• Fixed rendering of two-sided objects into deferred buffer.
• Removed render_use_specular console variable.
• Added 'spherical' flag for sky (the sky is a full sphere mesh instead of a hemi-sphere, if enabled).
• Improved light scattering when used together with a background cubemap.
• Added render_use_shadow_kernel console variable (set it to 0 to improve shadow rendering performance).
• Improved shadows quality on 'high' shaders profile.

Terrain:

• Per-surface control of flatness threshold for terrain.
• Changed format of terrain files (.ter); please use utils/Upgrade/terrain.usc script for conversion (USC interpreter is required, see below).
• Removed tesselated terrain material.
• Optional ambient lighting for terrain which allows to disable a world light pass and render terrain in a single ambient pass. No shadows can be cast on the terrain in this case, though.
• Fixed triplanar shading for terrain.
• Optimized terrain shading.

GUI:

• Added a scroll bar in WidgetComboBox.
• Reduced TTF atlas texture size.
• Added IME support into the Interface plugin.
• Reduced memory consumption by widgets to a small degree.
• Added 'dynamic' flag for WidgetSprite images that are frequently updated in runtime.
• Faster video playback.
• Added 'changed' callback for paned containers and WidgetScrollBox.
• Added setMouseEnable() function to control rendering of the mouse.

Physics:

• Fixed continuous collision response.
• Added CCD for PhysicalTrigger, BodyParticles, BodyCloth and BodyRope.

Sound:

• Fixed seeking on WAV files.
• Fixed bug in libvorbis library for Mac OS X.
• Added 'auto' value for 'sound_app' console variable (the engine sets the best available API).
• Correct playback of short streamed sounds.

UnigineScript:

• Stack size is increased to 2048 elements.
• Added '#pragma no_optimize' support.
• Support of up to 6 arguments for console commands called from a script.

Other:

• Fixed path to cache directory.
• Updated Xcode project for iOS.
• Added clipboard support in Mac OS X.
• Added filesystem_mmap console variable (set to 0 to disable memory-mapped files).
• Added file name modifiers system. Read the original idea.
• Added a new NodeTrigger node type. It fires callbacks when enabled/disabled or moved, which is useful to control objects inside of WorldClutter and WorldCluster).
• Added memory_save console command for dumping memory pools (useful for offline analysis).
• Added 'compaction' flag for meshes that prevents a mesh copy from being stored in system memory (making no intersection or collision possible with it). This option is highly useful for PlayStation 3.

Tools:

• Added toggling of channels in ImageView (R, G, B, A hotkeys).
• Added one-way NodeReference collector into WorldCluster (very useful for final content optimization). See "Collector" tab in WorldCluster node.
• File name for SoundSource is now displayed in UnigineEditor.
• Added standalone UnigineScript interpreter (USC tool, see below).
• Added AlphaMapper tool into ResourceEditor for baking high-quality alpha test textures based on high-poly mesh geometry.
• Fixed mesh overlapping visualization in ResourceEditor.
• Fixed MD5B mesh format import.
• Improved terrain creation in UnigineEditor.
• Support of the normal map import for terrain.
• Added optional Y-axis texture flipping on terrain data import.
• Added baking of objects into diffuse, normal or lightmap textures for terrain. See "Grabber" tab in ObjectTerrain node.
• Tools/Interface tab in UnigineEditor is moved into Tools/Common.
• Backup of a NodeRefence file is now stored in UnigineEditor when edited.
• Added world profiler (shows node, body and joint count), 'show_profiler 3' console command.

Standalone UnigineScript interpreter (USC tool)

The stand-alone interpreter (called USC due to its script file extension) allows for making Unigine scripts into executable programs that are run directly from the environment or from the command-line. As the interpreter works independently, it offers an easy way for developers to extend the functionality and solve the specific or recurring tasks for which it is not necessary to create a separate executable application.

The tool supports the following:

• Everything from the Core library of UnigineScript (can be used to read/write files, parse XML files, handle images, perform mathematical calculations, etc).
• Meshes. Load and save a mesh, modify or clear all its data. You can add and set transformation to mesh surfaces, as well as change position, normal vectors and texture coordinates for separate vertices.
• Skinned meshes. Just like in case with simple meshes, you can get access and modify surface and vertex data for skinned meshes. Data on bones of the rig is also exposed.
• Support of multiple CLI arguments.

Source code of the stand-alone interpreter can be found under source/tools/Interpreter, it is included into ToolsPack.

PS: Unigine-powered Oil Rush naval strategy game has been released for Windows, Linux and Mac OS X. Its sources are available for Unigine customers as a reference project.

• Optimized SSDO blur filter.
• Improved quality of HDR and glow: now it is possible to fine-tune small, medium and large-sized halos.
• Light scattering falloff can be disabled for performance boost via render_use_scattering_falloff console command.
• Added detection of Intel GPUs.
• Added detection of new AMD HD7xxx GPUs.
• A grass diffuse texture can now have an arbitrary number of columns.
• Added two separate reflection colors (near and far) for water.
• Particle systems are animated using a 2D texture atlas (3D textures are no longer supported). Such approach prevents mipmap artifacts and is compatible with mobile platforms.
• Particles are rendered into the deferred and auxiliary buffers according to their alpha rather than color values.
• No more contour artifacts for objects when against the water with AA enabled.
• No more contour artifacts for objects when against the volumetric clouds in OpenGL and PlayStation 3.
• Fixed AA on Mac OS X.
• Fixed a lot of shaders for mobile platforms.
• On PlayStation 3 skinned meshes can be skinned purely on the GPU instead of the SPU, without back-face culling. This option allows for lower memory consumption at the expense of performance and can be enabled via ps3_render_use_mesh_raw console variable.
• Added white caps for water (an optional state).

GUI:

• External multi-window GUI (load the Interface plugin to enable it).
• Improved WidgetCanvas: it is possible to assign a separate texture to each polygon as well as enable texture wrapping.
• Added new high-level widgets: Track and Line.
• Widgets fire LEAVE and FOCUS_OUT callbacks when they are hidden or disabled.
• Removed Qt wrapper support due to the extremely low 3D performance in its viewports.

Multi-window mode of UnigineEditor:

Physics:

• Added BodyRail for spline-driven railroad simulation.
• Added JointRail for train simulation.
• JointPin is renamed into JointParticles.
• Added several new physical samples: samples/joints/rail_00, samples/physics/train_00, samples/physics/car_03.

UnigineScript:

• Variable scope is now saved by state saving.
• Removed is_extern_class_function() and get_extern_class_function() functions.
• Safe iteration of "foreach" and "foreachkey" cycles; a runtime error will be generated on invalid iterators.
• Optimized script compilation speed.
• Added support of Java-style anonymous class syntax: new Foo() { body };
• Added trim() function for cutting out spaces (or other symbols) at the start and end of a string.

C++ API:

• Added access to Unigine application window handle.
• Added string concatenation functions.
• Added support of network sockets.
• Added App::set() for setting an external handler to the application.
• Added access to DirectX device handlers.
• Added Gui object for external windows.
• Added functions for simulating keys and mouse buttons pressing.
• Added Unicode convertions functions for strings.
• App3DSurround, App3DVision, AppEyeFinity, AppSoft, AppStereo and AppWall became C++ plugins rather than stand-alone applications (and can now be found in source/plugins).
• New C++ plugins loading policy: plugin constructor is called at the very beginning of engine initialization, before App instance is created. Plugin init() is called at the same time as before. This means, it is possible to add filesystem packages or initialize external App in the plugin constructor.

Tools:

• Multi-window mode in UnigineEditor due to the Interface plugin.
• Added object selection by frame in UnigineEditor (Ctrl + left mouse button).
• Added FileServer console tool for sharing data directories with engine instances over the network.

Other changes:

• Added support of Linux on ARM platforms with OpenGL ES (scons cross=arm opengl=0 opengles=1).
• Refactored main applications for Android and iOS.
• Upgrade to Android NDK r7.
• Added world_show_transforms console command for visualization of WorldTransform.
• Fixed OpenAL-related crashes on Mac OS X.

Mobile client application

All Unigine mobile applications (both for iOS and Android) come together with a launcher that makes iterative development and testing fast and convenient. Instead of uploading resources onto mobile devices, the data which is stored on the development machine is simply shared over the network. To enable remote access, run the FileServer console tool on the machine and start the Unigine-based mobile application with default settings.

PS: You might also be interested in how and why UNIGINE Engine has enabled Ai3D Pty Ltd to become one of the world’s most capable Realtime Visualisation companies that successfuly completed over 60 projects: read their success story.

Added a new NodeSector object that allows for background streaming of zone-based resources on demand. It is used to control asynchronous loading of all masks images, meshes and textures that are used by child nodes of the NodeSector. It requires the world to be divided into sectors of nodes based on their location. Please refer to the documentation (UnigineScript / Engine Library / Node-Related Classes / NodeSector Class) for more details.

Improved asynchronous resource loading; no more stalls on loading large masks for ObjectGrass and WorldClutter. Added new console commands that list loaded resources: render_manager_list, sound_manager_list and world_manager_list.

Other changes:

• Added access to ObjectMesh vertex data into C++ API.
• Added a custom shader example (data/samples/shaders) with NVIDIA FXAA 3.11 implementation.
• Added rgb2rgbl shader into core materials (it is used together with post_filter_fxaa postprocess material).
• Terrain tool is renamed into TerrainMesh.
• Added new TerrainRelax tool to bake the flattened height map (allows for proper intersection with grass and WorldClutter).
• New lerp() function for vectors for fast interpolation of vector values.
• UnigineScript arrays now copy external arrays passed as constructor arguments instead of assigning them.
• Added a new RPPost counter to the performance profiler to report the postprocess rendering time.
• Hotkeys don't clear button states for disabled widgets and callbacks.
• Fixed handling of '[', ']' and '\' symbols for non-English keybord layout.
• Updated documentation on Skinner and Schemer systems.
• Added the gradient editor draft.

Schemer is a visual scripting system that allows creation of complex sequences of gameplay events without having to script them manually. This way the artists can add interactivity to the world without the help of a programmer. By connecting paths in a flow graph, it is possible to script cutscenes, switches, timers, changes in lighting and much more.

Schemer is written in UnigineScript, its files can be found under data/core/systems/schemer folder. At the moment it's in the alpha stage, which isn't recommended for production use.

Skinner (preview)

Skinner is a visual scripting system for animations. It allows blending different animations together to create complex movements of skinned characters. It also possible to include the physical ragdoll into played animation (for the whole the character or per bone).

The Skinner is based on Unigine::Schemer. Skinner scripts can be found under data/core/systems/skinner folder. The predefined Skinner blocks that are available by default are contained in the data/core/systems/skinner/blocks/skinner.blocks file.

Both Schemer and Skinner systems are parts of upcoming UnigineEditor 2.0, they can work with internal Unigine GUI and external one (Qt-based).

Scratch project

A Scratch project will help you get started with your own Unigine-based game in no time. Tweak and play all using the same application: change settings on-the-fly, see the coded behavior in effect or quit the Editor to go into in-game mode and test how your game feels like. No compilation is required: simply add your models, replace the GUI interface and run the launcher.

A Scratch project can be found in UnigineSDK/scratch folder, read more in the documentation. It is available only for Windows and Linux platforms.

Render:

• Added AppEyeFinity application for enabling AMD Eyefinity technology (multi-monitor rendering with arbitrary projections for each monitor).
• Added NVIDIA FXAA post-processing material (changed implementation of post_filter_antialiasing material).
• Decals can set texture coordinates (so it's possible to use texture atlases for them).
• Changed texture transformations for billboards: sx,sy,tx,ty instead of old x0,y0-x1,y1.
• Increased terrain loading speed.
• Fixed wrong number of emitted particles for "spark" emitters.
• Fixed alpha-test issue on iOS 5.
• Color-fading (can be used as a simple alpha-fading also) instead of decreasing particle count by distance.

Work in progress, upcoming Unigine-powered demo:

UnigineScript:

• Support of script caching for faster load (cache file name is the second argument of world_load command, no caching by default).
• Added "using" keyword for extending current scope to other namespaces.
• Support of #if preprocessor instruction.
• Added extern class member call by ID (useful for faster callbacks).
• Added functions support to Expression.
• Added new base functions: is_variable(), set_variable(), get_variable(), is_extern_class_function() and get_extern_class_function().
• Removed Expression::runFunction() methods, use call(getFunction()) instead.
• Added left() and right() methods for vectors.
• Added new constructors for matrices: mat4(quat,vec3) and dmat4(quat,dvec3).
• More verbose error messages for extern classes.
• Adde npot() (nearest power of two) and udiv() (integer division with rounding up) functions.
• Updated function library documentation.

GUI:

• Fixed callback processing order on mobile platforms.
• Refactored WidgetCanvas.
• Added hide/show methods for virtual keyboard on mobile platforms.
• Added RELEASED callback.
• Wide mask for PRESSED callback of Button and Icon (includes 4 auxiliary buttons).
• Fixed TabBox expanding.
• Reduced texture fonts (non-TTF ones) to 128 characters (latin only).
• Added ImageTTF tool for conversion of TTF font into a texture for FontTexture.
• 32 bit TTF symbols for better support of Chineese.
• Improved integration with Qt widgets.
• Added a set of Unigine::Widget* classes, which can be switched between internal (Unigine widgets) and external (Qt-based) implementations (they can be found in data/core/systems/widgets folder).

Physics:

• Added Exclusion masks for collision shapes and PhysicalTrigger.
• Fixed inertia tensor calculation bug for small objects.
• Fixed sliding of non-physical PlayerActor on slope surfaces.
• Particles with "length" emitter are collided as capsules.

Other:

• Added FileSystem C++ plugin: it can handle up to 16 external directories (they must be specified by multiple "-file_path PATH" CLI options; they are saved into the engine config after that).
• Increased speed of XML parser.
• Added support of iOS 5 (no more NEON support due to llvm restrictions).
• Added vec3 and vec4 Property types.
• Added functions for creation of buffers and files out of streams into C++ API.
• Implemented correct yuv2rgb color space tranformation for video playback via Ogg Theora.
• Command line parameters and engine config are now accessible via C++ API.
• Fixed "HeapChunk"-related crashes.
• Fixed bug with saving multi-surface ObjectMeshDynamic into a file.
• Correct handling of ;/+-,. symbols on non-English keyboard layout.
• New policy for Node ID: old IDs aren't changed, NodeReference contents get random IDs.
• Fixed binding clutter objects to parent ones.
• Updated documentation on custom GUI skin.
• Updated documentation on particle systems.
• Added "Tools / Performance Profiler" article.

PS: Here is a new pre-release gameplay video from Unigine-powered Oil Rush naval strategy game:

PPS: We have expanded to Europe, new Unigine office is opened in Prague, Czech Republic. Anton Ravin joins the company as the head of European branch after seven years at NVIDIA, welcome aboard!