Terrain Improvements

• Terrain data streaming is fully asynchronous now.
• It's also possible to force loading of a specified terrain region via Terrain::loadHeights() function with the specified bounding box.
• Added "progression" parameter for terrain LODs, that affects LOD switching distance: prev_distance + lod_distance * (lod_progression ^ lod_number); default value is 2.0.
• The terrain file format has been changed as well, please use the upgrade script: utils/Upgrade/terrain.usc.

Landscape Plugin for UnigineEditor

Landscape plugin allows to create huge seamless scenes containing virtually unlimited number of terrain objects (each one of them can be up to 16385x16385 units in size).

Each terrain in the landscape is an independent object that has all the terrain features and can be modified in the same way. Besides, there is an opportunity of applying only required tiles of textures and masks right to the whole landscape or to any specific region. The plugin also takes care about optimal compression of textures.

File System Speedup

Added support for pre-cached file hierarchies: if the engine finds .ulist file in a directory, it stops scanning its contents (including nested directories) and use the list of files from the file instead. Thus the engine initialization time can be extremely reduced even with large assets database. There is a .ulist file generator available for your convenience: externs/bin/datalist.py. Don't forget to re-generate .ulist files, if you modify contents of a directory.

Added background loading of images (with unpacking): engine.filesystem.loadImage() function.

Added filesystem_clear console command to remove all loaded, but unused resources.

Rescue Helicopter Simulator

UNIGINE Engine has been using in training and simulation field for several years, so we've decided to make our own simulation demo. At ITEC 2013 in Rome we showcased the preview of a new rescue helicopter simulation.

Features of the demo:

• Huge open space: 262x262 km
• Real geospatial data
• Urban terrain simulation
• Dynamic weather
• Large visibility distance: 40 km
• Supersonic camera speed
• Extremely detailed close-up view
• Advanced light scattering model
• Double precision of coordinates
• Volumetric clouds
• Day/night cycle

We'll publish the video teaser quite soon, so you'll be able to see the details.

Render

• Performance optimization of terrain rendering.
• The number of rendering groups has been increased to 8.
• Improved OpenGL core profile compatibility.
• Added support for PNG and TGA formats in Image::info() function.
• Added "Substitute normal" option for decal_deferred_base material (if enabled, only decal normals will be used, otherwise decal normals will be combined with underlying surface ones).
• Added "First frame" flag: it stops FPS counting and sets unlimited budget for Grass and Clutter generation.
• Added new ObjectDynamic object: it can render any type of geometry, with support for instancing and point/line/triangle rendering modes. This type of object requires custom shaders in order to work.
• Point/line/triangle rendering modes have been removed from ObjectMeshDynamic, use ObjectDynamic instead.
• Begin/end indexes of multi-surface ObjectDynamic and ObjectMeshDynamic objects can be changed.
• Render vegetation animation time can be changed via UnigineScript: engine.render.setAnimationTime().
• Added detection of NVIDIA TITAN and Kepler-based Quadro cards.

World Management

• Performance improvement for all engine resource managers (render, world and sound) on large (100k+) amounts of resources.
• ObjectGrass, ObjectMeshClutter and WorldClutter objects can intersect with the parent node even if they are placed inside a node reference.
• Added generation budget (per-object) for Grass and Clutter objects to avoid performance spikes: engine.world.setBudget() via scripts (in ms) or Render tab in UnigineEditor (in FPS). Objects with lower rendering group ID have higher priority when out of budget.
• Performance info on resource managers is available via EngineAnalyzer now.
• Grass and Clutter objects are checking parent terrain or mesh loading status to avoid lags on generation stage.

UnigineScript

• Added Xml.setChildData() and Xml.getChildData() functions for convenient access to the child node data.
• Fixed bug with incorrect scoping of "new" operator.
• Arrays can be used as a function reference return values.

C++ API

• Added access to ObjectDynamic.
• Access to Node and Object surface boundings can be obtained via getBoundMin|Max|Center|Radius|... functions.
• Added access to Render::FirstFrame and Render::CameraOffset parameters.
• New sample with editor nodes interaction.
• Added access to NodeDummy.
• Added access to Node data.
• Added access to load|saveWorld functions.
• GLAppQt sample supports Linux and MacOS systems now.

GUI

• Fixed incorrect initial Z-order of widgets.
• WidgetDialogImage shows internal format info on ZLC images now.
• Text alignment parameter for text rendering in the visualizer has been flipped in Y direction.
• Support of point image filtration in Flash interface.
• Added Gui.setFocusedPermanent() function: 1 - font color will be overrided with global GUI focused color, if a widget is focused; 0 - font color will be unchanged if focused.
• Fixed bug with incorrect multiple object resizing in Flash.
• Fixed Interface plugin bug: disappearing of the window after video mode change in Mac OS X.
• Interface plugin can work correctly with -video_app null CLI option.

Tools

• Added "Drop down" button in Nodes window of UnigineEditor: once pressed, all selected nodes will fall on the underlying geometry.
• Added support for new postfixes in imagedds.py script for pre-mipmapped images: _dm, _nm, _sm, _pm, _hm, _tm, _am, _em, _lm, _mm.
• It's possible to change mesh file for ObjectMeshClutter and ObjectMeshCluster in UnigineEditor without clearing their parameters.
• Correct resource saving outside the data directory via UnigineEditor.
• Added save() callback on world saving for UnigineEditor plugins.
• Fixed bug in UnigineEditor with incorrect automatic texture compression from "uncompressed" directory.
• Terrain editor can edit ZLC textures.
• Added First frame parameter into Tracker.
• Improved double precision support in Tracker transformations.
• Double-click on a property name field (with file flag set) will open file dialog in UnigineEditor.
• Updated icons in UnigineEditor.
• Added export/import plugins for Maya 2012, 2013 and 2014.

Mobile

• Refactored Android UnigineActivity classes: now it's possible to call system or Java functions with up to three different arguments and get return value of all supported data types (int, float or String).
• Added hardware accelerometer support for Android and iOS devices.
• Added two simple samples for custom iOS applications.

Other

• Added configurable physics simulation budget: engine.physics.setBudget() function.
• Fixed missing application icon in 64-bit Linux.
• Added support for double precision for Image down-scaling.
• Added Image::compare() function to compare regions of two images with the specified threshold.
• Added /largeaddressaware option for 32-bit Windows builds in order to be able to allocate up to 3 GB of memory on 32-bit systems.
• Updated .world and .node file format: please use upgrade.py script to upgrade your data.

Support for Oculus Rift

Integration of Oculus Rift into UNIGINE Engine is completed, now you can navigate virtual worlds with increased immersion by means of AppOculus engine plugin (available for Windows, Linux and Mac). As you see, we are also preparing Oculus-compatible updates of Heaven and Valley benchmarks to be publicly released soon.

Render

• Completely new decals system (see details below), all decals must be re-baked via UnigineEditor.
• Added new material option: Group (up to 4 groups available). It affects opacity objects rendering, inside a group all renderable objects will be sorted with respect to Material Order, decals are always rendered after all opacity objects in the group.
• Improved performance on AMD cards in OpenGL mode.
• Added access to CameraOffset parameter via UnigineScript for multi-channel rendering mode.
• Added support for procedural textures that can be used in complex post-processing with chain dependencies via additional filter attribute: <texture name="selection" pass="post" type="filter" materials="post_filter_selection_sample,post_hblur_2d,post_vblur_2d">. See data/samples/shaders/selection as an example.
• Increased speed of billboards bounds recalculation on multiple position updates.
• Added support for GL_EXT_texture_rg OpenGL ES extension (useful on iOS devices to store normal maps in PVR4 format).
• AppStereo plugin has been splitted into AppQuadBuffer (OpenGL mode only, for professional cards: NVIDIA Quadro and AMD FireGL) and AppSeparate (DX9/DX11, creates a separate window for each eye).
• AppSurround, AppPanorama and AppProjection plugins are now available for Mac OS X.
• Added a sample with oblique projection matrices.
• Added a sample with object halo selection sample based on auxiliary buffer.
• Added Angle power parameter for mesh_leaf material.
• Added min/max mask values for all clutter and grass objects: now multiple clutter/grass objects can share the same mask, but use different levels.

Bugfixes

• Fixed trees jittering and water waves in double precision builds (via virtual shader coordinate system).
• Fixed bounding frustum calculation in double precision builds.
• Fixed a bug with adding new surfaces into ObjectMesh, ObjectMeshSkinned and ObjectMeshDynamic nodes.
• Fixed horizontal texture flip in LightProj light sources.
• Fixed a bug with incorrect clutter rendering bug on extremely large visible distances.

Improved Decals

There are several types of decals available now:

• DecalObjectOmni
• DecalObjectProj
• DecalObjectOrtho
• DecalTerrainProj
• DecalTerrainOrtho
• DecalDeferredProj
• DecalDeferredOrtho

DecalObject* are old geometry decals. However, they can't be projected on GUI objects as before. Use rendering groups to hide large polygon offset side effects. These decals support decal_base material only.

DecalTerrain* decals are special decals for efficient projection on terrain with correct LOD transitions of vertices. A node of such type must be a child of an ObjectTerrain. These decals can handle complex material called decal_terrain_base similar to other terrain materials (masks, 4 detail diffuse/normal textures). They support decal_base (with support of parallax occlusion mapping) and decal_terrain_base materials.

DecalDeferred* nodes calculate decal position based on depth value from the deferred buffer. So there is no real geometry rendered at all, therefore from performance standpoint DecalDeferred* nodes are the best choice (though they don't support instancing, thus each decal costs at least a DIP). Moreover, these decals are compatible with hardware tessellation and terrain LOD transition. However, the scene must be divided into the rendering groups (up to four groups for opacity object and decals available) to prevent unnecessary deferred decals projection on geometry. These decals support decal_deferred_base material only.

Each decal has unique visible and fade distances for optimizations. Take a look into samples: data/samples/decals.

Unigine GUI

• Speedup of font rendering.
• User interface (*.ui) files can refer to their blocks with text: declare reference="1" attribute for an element, after that you can use <reference name="ELEMENT_NAME"/> tag (see data/core/editor/editor_decals.ui file as an example).
• Visuaizer doesn't scale object handles on object scaling.
• Added Order property for Widget classes: multiple Z-orders are now available.

Flash GUI

• Correct MovieClip scaling and rotating.
• MovieClip class has all base functions from base Flash Object.
• Correct resizing of scaled MovieClip objects.
• Added support for textColor property of ObjectEdit.

UnigineScript

• New way to set per-function breakpoints: system_breakpoint, world_breakpoint and editor_breakpoint console commands (syntax: world_breakpoint set/remove function_name number_of_arguments). Note that if you want to step forward, you need to remove the current breakpoint via system console ('b' in the debugger mode).
• Now it's possible to use engine.system|world|editor.call() functions with integer function ID.
• An issue with incorrect class declaration when the name is written without space delimiter to the base class has been fixed.
• preprocessor() function can work with file names and source code strings as well.
• foreach operator will not fail after removing of the last element.
• Expressions print a file name and a line number on compilation errors.
• Added is_thread() function that checks if a thread is still active.
• Added Async core script class for asynchronious operations.
• Updated documentation on language features and syntax.

Asynchronous operations in scripts

All calls of extern C++ functions or C++ object methods can be performed in asynchronious way via Async UnigineScript class now. For example, asynchronious network socket handling can be done this way: async.run(socket,"connect"); After that you can check status of the running function and get the return value somewhere else in the code.

Multiple asynchronious calls can be submitted into the same Async object instance. Each Async instance creates a working thread, so if you want to utilize all available CPU cores you need to create the same number of Async objects.

Take a look into the corresponding samples: data/samples/systems/async*

C++ API

• Added access to ObjectTerrain with basic import/export interface.
• ObjectMeshDynamic now has functions for multiple vertex/index data adding/seting by a single call.
• Added ObjectMeshSkinned::getNumAnimations() function.
• Added StreamBase class that allows to create custom data stream objects.
• GLAppSDL sample has been fixed.
• Added empty() method for String, Vector and Tree containers.
• Added setArgName() and setArgValue() methods into Xml class.
• All vectors, matrices and quaternions have a get(Type*) method to fill an array with their values now.

Tools

• Multi-threaded image compression/decompression in UnigineEditor.
• ImageDDS can flip images in both directions now (-fx and -fy options).
• Added "Fold all nodes" button into Nodes window of UnigineEditor.
• Added new "Tools -> Node materials" option in UnigineEditor: all nodes will save their references on material libraries, if enabled (by default, as before).
• Improved COLLADA format support.
• Added support for multi-decal editing in UnigineEditor.
• Correct loading of OBJ geometry files with polygons containing more than four vertices.
• Improved terrain painting tool visualization in UnigineEditor.

Network

• Added SSLSocket engine plugin via StreamBase API and axTLS library (it allows to initialize secure TLS connection over sockets).
• Restructured SConstruct files for 3rd-party libraries.
• RakNet integration plugin is moved to plugins/network/RakNet.
• Added ssl_socket server/client samples.

WebGL

Added support for WebGL platform (early alpha stage) via Emscripten cross-compiler into JavaScript. WebGL binaries can be created via "scons platform=webgl" command.

Due to incoplete support of WebGL standard by browsers at the moment, support of this platform is in the early alpha stage - you can use it on your own risk. Supported browsers are recent Chrome and Firefox only.

Other Changes

• Buffer class can be encoded/decoded into/from base64 strings.
• Added a sample with fixed physics FPS.
• Added support of mouse wheel counter on all operational systems.
• Fixed a bug with broken cloning of Body's frozen and gravity flags.
• engine_threaded console variable can globally disable or enable all *_threaded console variables.
• Terrain format has been changed to more compact one, please use utils/Upgrade/terrain.usc script to compress old data.

P.S.: We are working on a new extremely large tech demo, a preview will be available at ITEC Rome 2013 (in our booth #B160).

AppProjection plugin

AppProjection is used to create multi-projector setups, that are commonly-used for virtual training and simulation systems. Due to edge blending and non-linear image mapping support, it is possible to create large curved displays covering 360 degrees, if required.

Settings for each projection (via Main menu -> Wall -> Projection) include:

• Geometry distortion correction
• Soft-edge blending
• Color correction

Adjustable field of view and bezel compensation are also available.

The number of displays in a row is controlled via -width CLI option. Set up configuration can be saved into a preset file (*.projection) to be loaded at any time.

Here is a three-projector setup in our studio. The size of this screen is 6x2 meters (suddenly there's not so much space left in the conference room).

Huge spaces of Valley benchmark (64 000 000 square meters) projected onto a screen:

Panoramic Rendering and Fisheye

With a new AppPanorama plugin, it is possible to render impressive 180 degree panoramas in case extra-wide field of view is required. Unlike AppProjection, it is used across one screen only. It has three modes available via -mode CLI option passed on the start-up:

• panorama - panoramic projection with curved edges (by default)
• linear - linear panorama without distortion at the edges
• fisheye - spherical panorama (requires a square aspect ratio)

Curved panoramas of Valley and Heaven (be informed, can cause dizziness):

Linear panorama:

Fisheye:

AppPanorama stitches four viewports into one (due to a very high degree of curvature for edges). The overlapping area between viewports is controlled via -border CLI option. It takes arguments from 0 (no overlapping, visible seams) to 1 (half-screen overlapping area). Here are these four viewports:

Render

• Improved the quality of HDR shaft flares. They are now rendered into a half-screen buffer (rather than quarter of the screen size). Additional blurring and noise eliminate any banding artifacts.
• Added additional Attenuation parameter for HDR shaft flares (Render -> HDR -> Shaft -> Attenuation) to control fading of flares along their length.
• Added similar Attenuation parameter for Volumetric shadows (Render -> Postprocess -> Shaft -> Volumetric attenuation).
• Now it is possible to have up to 4 types of impostors rendered fast and efficiently (in one DIP) via a single ObjectGrass with grass_impostor_base assigned. For that, bake impostors into a diffuse texture row by row. Height, probability of spreading and other parameters of such impostors are set up per type (row). Check a new sample samples/materials/impostor_03.
• New sample to stress-test hardware occlusion query functionality: samples/stress/query_00.
• Small performance optimization for Tracker: it checks if render textures (for example, LUT texture, Environment cube map or any other set via engine.render.set*TextureName()) are already used before updating them each frame.
• Correct detection of the video memory size on Windows in case it is higher then 4GB.
• AMD GPUs under Linux are now correctly detected.
• Windows 8 OS name is now correctly logged into the console and a log file.
• FPS counter filtration can be set up via engine.app.setFilter() (for example, disable it completely and always show the current value by setting it to 0).
• Added getter functions to return modelview and projection matrices for all multi-viewport plugins: AppWall, AppSurround, App3DSurround or AppProjection.
• In utils.h, Unigine::getPlayerMouseDirection() function works for all viewports when multi-viewport plugins are loaded (AppWall, AppSurround, App3DSurround or AppProjection). This allows for testing mouse intersection across all screens.
• For Windows XP, the application will be rendered black when the window is out of focus. It is also valid if any multi-viewport plugin is loaded.
• When AppWall plugin is used, monitor bezel compensation sliders (Main menu -> Wall -> Bezel X and Bezel Y) are disabled if they are not available for the current configuration of a monitor wall.
• All C++ engine App* plugins (such as AppWall, AppSurround, etc.) use core profile if run in OpenGL API.
• For all App* engine plugins, device remove event under DirectX 11 is now correctly handled.
• In case of a multi-monitor configuration, full-windowed applications without decorations (with video_fullscreen set to 2) automatically choose the best display from available ones based on the resolution on Windows and Linux. If a resolution is set to cover all available displays, the application is automatically spanned across them. It works both for horizontal and vertical setups.

ZLIB Image Compression

Now image resources can have smaller memory footprint due to ZLIB image compression. It is useful for images that cannot be compressed using quality-loss algorithms (DXT, JPG, etc.): e.g. GUI textures with thin lines that need to be rendered with pixel precision.

Two new compressed image formats are available:

• ZLC1 for faster compression (for example, in run-time)
• ZLC2 for compression that enables a smaller file size

Both formats are supported in the ImageDDS tool.

Node-related Features

• Now it is possible to create mesh-based particle systems. If ObjectMeshCluster is added as a child node of ObjectParticles, meshes are automatically spawned (due to new getParticleTransforms() and getParticleVelocity() functions). Check a new sample samples/objects/cluster_01.
• A mesh-based mask can be set for ObjectGrass, ObjectMeshClutter or WorldClutter (Nodes -> Mesh -> Mask mesh). For example, this option can be used to create roads, rivers and in other cases when vector mask precision is required. A mesh for masking should be a simple planar mesh. Inverse option toggles if objects are placed inside or outside the mesh contour. Check new samples samples/objects/clutter_01, grass_01 and grass_03.
• Volumetric clouds of ObjectSky can be simulated in the background - when a volume surface is disabled or no material is assigned to it - via the Simulation option (Nodes -> Parameters -> Simulation). When weather is controlled by Tracker, clouds are enabled and rendered much faster, since all required calculations are already done.
• Added setDensityOffset() and getDensityOffset() functions for volumetric clouds of ObjectSky. They allow to set/get the current offset of a 3D mask and reposition the clouds, if necessary.
• WorldClutter, ObjectMeshClutter and ObjectGrass check for intersections with ObjectTerrain, ObjectMesh and ObjectMeshDynamic even if they are much higher up in the hierarchy and there are some other nodes between them.
• Now more issues when ObjectVolumeSphere scaled uniformly is rendered with volume_light_base material.

An example of mesh-based particles:

Mesh-based vector masking for grass with high precision:

Bugfixes

• Antialiasing works correctly on Mac OS X systems running on AMD graphics cards.
• Fixed issues on disabling light scattering.
• Fixed a bug with shadows not rendered in reflections (when Materials -> States -> Shadow option is enabled).
• Flipped buffers for the interlaced stereo mode; now a left buffer goes to the left eye and the right buffer to the right one.

Network

• Multi-channel rendering system (Syncker) now runs on Windows nodes smooth and fast. The size of UDP packets sent over the network has been reduced, while socket buffers were increased in size for better performance.
• New send() and recv() functions in Socket class give control over the internal socket buffer size.

UnigineScript

• Added Reflection class for the user/extern class and namespace reflection. It allows to get names and custom attribute string for all variables, arrays, user classes and namespaces within it. Such attributes can be used for smart, automatic code generation for GUI or game logic. For example, it is possible to get attributes, parse them in the required way, and feed them to Expression which will compile the resulting code.
• Script performance is increased due to a heap of new mnemonics.
• Added two-element swizzles for vectors (in addition to already implemented one-, three- and four-element ones): vec3.xz.
• Added engine.world.callv(), engine.system.callv() and enigne.editor.callv() functions that execute any world, system or editor script function and receive an array of arguments (up to 8 arguments in the array are supported).
• Fixed incorrect scoping of private class functions.

Vectors

• New allocate() method for vectors that pre-allocates memory for a given number of elements.
• Added + and - operators to add or subtract a scalar value from a vector (a vector should go first, before a scalar).
• Added support for scatter/gather operations for four-component vectors. Only ivec4 type is supported for array indexing. After an array is created (for example, float array[4]), the accessor function (array[ivec4(0,1,2,3)]) returns four values as ivec4 (if the array type is int or long), vec4 (if float) or dvec4 (if double).

GUI

• Now Unigine engine comes with a new GUI skin.
• All imaged-based GUI resources are compressed into the ZLC1 format for smaller memory footprint.
• Performance gain by 10-15 per cent for all GUI fonts and WidgetFlash due to fixed-function pipeline (FFP) optimizations. Check new samples samples/widgets/font_07 (with a texture-based font) and flash_07.
• Added convenient snap-to-grid options (Tools -> Common) to position and rotate nodes. The grid can be rendered with depth testing; per-axis alignment or a grid mode are also available.
• Console and the profiler are now always rendered on top (first, the console and then the profiler).
• Messages rendered via engine.visualizer.renderMessage2D() and engine.visualizer.renderMessage3D() can be aligned by passing a second element of the vector as an align argument (see more details in the function library).
• Added fixed width and hight attributes for tables in all widgets with rich-text formatting support. The syntax is as follows: <tr height="x"> and <td width="x">.
• Added setFontPermanent() function into Widget class. It prevents the text color from being changed when an option is not available, the widget loses focus and so on.
• Added new modes for hiding scrollbox sliders via setHScrollHidden() and setVScrollHidden() (see more details in the function library).
• Fixed a bug when after a click on the disabled field, the window lost focus.
• Fixed an issue with WidgetIcon translation.
• Tracker window is automatically closed when no world is loaded.
• New Widgets::Deform high-level widget allows for projection distortion correction in AppProjection plugin. (It can be found in data/core/systems/widgets/widget_deform.h.) Check it on a new sample samples/interface/deform_00.
• Each viewport of AppWall, AppSurround or App3DSurround plugins now has a dedicated GUI instance for interface rendering. It is accessed via engine.wall.getGui() and engine.surround.getGui() functions. Check samples samples/plugins/app_wall_00 and app_surround_00.

New minimalistic look of the engine interface:

Snap to grid option for positioning (Tools -> Common in UnigineEditor):

WidgetFlash

• Decreased WidgetFlash memory footprint due to an optimized texture atlas handling. Now it is regenerated when required (for example, on video_restart) rather than stored in the system memory.
• Flash bitmap images are now compressed into ZLC1 format by default for smaller memory footprint.
• Fixed a bug with non-freed memory. Now when a movie clip loads a movie and is deleted afterwards, the memory is properly deallocated.

C++ API

C++ API is extended to allow low-level, graphics API independent access to textures, shaders and states. Any post-process effect can now be implemented purely on C++ side.

• Added Unigine::Texture class to create texture resources on any API and handle them on the low level.
• Added Unigine::Shader class with support for parameter setting, which allows for low-level shader implementation access.
• Added Unigine::State class for handling render states for all APIs.
• Added Unigine::TextureRender class to create and manage a render target/framebuffer. If allows for access to render textures of different types (depth, screen color, cube textures, etc.), as well as render texture layers.

Other C++ API changes are:

• Added Unigine::Player class for managing base parameters of cameras. The current in-game or editor player can be get via Unigine::Game::getPlayer() or Unigine::Editor::getPlayer() functions.
• Added a bunch of useful functions to work with triangles (including calculation of barycentric coordinates, normal vectors and triangle planes), lines, points, as well as handle orthographic transformations. Check UngineGeometry.h file.
• Added a number of functions into Unigine::Node class to check if a node is an object, light source, decal, sound source, and so on (isObject(), etc. functions).
• Added methods for fast binary searching into Unigine::Vector class: left() (finds a previous value in the vector) and right() (finds the next value). Similar functions as available in UnigineScript.
• Added new functions for fast rendering of primitives into Unigine::Ffp class: addVertex() that accepts a vertex array, and addIndices() that accepts two, three arguments or an array of indices.

Mobile Platforms

• Double-click event is now available on all tablet devices via APP_BUTTON_DCLICK. This event is correctly handled even by low FPS.
• For iOS platform, _PAD, _IPHONE and _IPOD defines with versions are now available. For example, you can use the following syntax: #if defined(_IPAD) && (_IPAD >= 3) ... #endif. (Please note that iPod devices are detected by the system with _IPOD and _IPHONE defines at the same time, hence iPod-specific code should always go before iPhone-specific one.)
• Added support for mouse wheel scroll events for Windows RT via APP_BUTTON_UP and APP_BUTTON_DOWN.
• Android applications running on the foreground are now correctly restored after the shutdown event.
• Samples in the Unigine SDK for Android now set the targetSdkVersion to 14.
• Fixed an issue with non-compiling shaders on PowerVR GPUs for Android.
• Updated OpenAL sound library version on Android now goes with OpenSL ES support.
• Fixed OpenAL errors on iOS.
• Added a new APP_IDENTIFIER environment variable into the iospack script. Now developers have full control over a name of the signed application.
• Added detection of Qualcomm Adreno 205 and 305 graphics chips.

File System

• In *.ulink files absolute path names can be used on all supported platforms. It is possible to access resources from another disk on Windows (for example, E:\resources\) or use paths from root level on Linux or Mac OS X (for example, /username/resources/).
• Console command memory_info now prints information on heap memory as well.

Physics

Added set/isFixed() flag to synchronize rendering FPS to the physics' one. Such FPS limitation allows to calculate physics each rendered frame (rather than interpolate it when this flag is set to 0). In this mode, there is no twitching of physical objects if they have non-linear velocities. (If the rendering FPS is lower than the physics one, this flag has no effect.)

Other

• Improved XML file compression; now compressed files are around two times smaller than before.
• Added show and hide console commands to open and close the console. For example, on mobile devices they allow for checking console messages via Telnet connection.
• date() function can receive a second integer argument with Unix timestamp to be converted into a readable format.
• Fixed a bug with slowing down of sound when video and sound were played from separate files.
• During compilation, plugins check if all required dependencies are found. If libraries are not found, the current plugin is skipped and all other modules are still built.
• Fixed issues with Visual Studio 2008 projects.
• GPUMonitor plugin now correctly detects chip frequencies for NVIDIA GPUs due to the extended NVApi library.
• Now it is easier to create custom App* engine plugins based on the existing ones (such as AppWall, AppSurround, etc.), since they are initialized in the base virtual classes.

New Project Generator

From an SDK browser, it is now possible to conveniently create a new project. To start developing your Unigine-based application, choose a path to store files, project settings and hit Create new project button.

PS: The Android version of Oil Rush is finally available on Google Play! (For now, exclusively for Qualcomm chips: Adreno 225 or 320 GPU is required.)

PPS: Oculus Rift support is on the way, it is already implemented and will be available for customers in the next SDK update in April.

OpenFlight Import Plugin

Now it is possible to import assets from OpenFlight format, the simulation and training industry standard for geometry data. Added support for SGI texture format usually used together with OpenFlight.

The plugin imports polygonal geometry, including groups, loads and integrates Level of detail nodes into Unigine LOD system, and converts Degree of freedom nodes into NodePivot nodes for full control over mesh rotation. Due to smart management of external reference nodes, they are loaded only once and instanced. The model is added together with an assigned material and the whole set of textures, converted and compressed into real-time ready formats. Alpha blending for textures and polygon offsets (based on Subface nodes) for materials are also automatically supported. Moreover, the plugin imports infinite, local and spot lights with correct parameters read from the OpenFlight asset.

FBX Import Plugin

New FBX plugin allows for easy FBX import from any digital content creation applications that support this format. Given a FBX file, it loads all scene elements with their full hierarchy. That includes converting meshes into Unigine-native formats and optimizing them on the fly, automatic creation of materials, compression and optimization of textures for real-time rendering, as well as import of skinned animations, lights and cameras.

Make sure to put your FBX assets into the data folder so that they can be converted on-the-fly.

Both OpenFlight and FBX plugins, as well as the Collada plugin introduced previously, work with double precision coordinate builds.

Urban Driving Demo

Urban Driving demo is an example of player-controlled, physics-based vehicle demo in the urban environment, optimized for rendering via occluders. It also goes together with weather presets and a day-night cycle.

Render

• GLSL shaders are now fully compliant with the OpenGL 3.2 core profile specification (instead of the compatibility one), improving compatibility with Intel and Apple OpenGL drivers.
• Added Bokeh flares (Render -> HDR -> Bokeh) available when both HDR and DOF are enabled. With them, bright areas out of focus are rendered with the bokeh effect (you can also set a custom texture for it).
• Improved the quality of HDR flares; a limitation on their length is lifted.
• Added a scattering direction vector (Render -> Scattering -> Direction) for a completely custom direction of scattering. Downward direction is also supported.
• Areal perspective correction for light scattering can be disabled by setting Render -> Scattering -> Areal from 0 (no correction) to 1 (height correction in full effect).
• Added alpha support for all primitives in the visualizer.
• Visualizer checks objects for visibility within the screen before rendering.
• Motion blur effect is available with double coordinate precision builds on huge distances from the world's origin.
• Motion blur flickering is fixed, no more issues in samples.
• Fixed issues with the motion blur effect when DOF is enabled: it is no longer rendered across the blurred areas.
• Billboard clouds (with billboards_cloud_base material) now automatically disappear when the camera is close to them to avoid any possible clipping artifacts.
• Removed UpSample and UpScale options in Materials. Instead, a new Downsize drop-down option allows for a fillrate optimization for transparent materials. It can downscale and filter them, and even render scaled and filtered material on the scene background (can be used for volumetric clouds).
• Fixed random flickering of the scene when multi-threaded physics is enabled.
• No more random sparkles with HDR and anti-aliasing enabled.
• Fixed a rare bug with incorrect lighting of grass, terrain and leaves with Ambient light option enabled in Materials.
• Fixed a bug with Receive shadow flag in Nodes -> Surfaces not working correctly.
• Correct handling of device remove event under DirectX 11 without crashes.
• Issues with DirectX 9 fullscreen mode are gone, handling of device lost event is completely safe.
• A debugging mode can be enabled for AppLevel plugin via the -debug CLI option.
• AppWall plugin safely handles invalid command line parameters.
• Removed iZ3D stereo support.
• Increased performance of LUT color correction when default render settings (such as Gamma, Contrast, etc.) are used.
• Changed the order of video modes: now resolutions with 16x9 aspect ratio come first.
• Added support for 2560x1440 and 2560x1600 resolutions.
• Added support for anti-aliasing for Mac OS X.
• Added full support for SGI image file format.
• Now all GPUs available in the system are detected. If GPUs are the same, they are listed, for example, as GPU name x2.

Node-related Features:

• Added X and Y flipping options for ObjectGrass, ObjectMeshClutter and WorldClutter to flip masks (if textures are flipped, lightmaps are influenced as well).
• Removed Compaction flag from ObjectMesh and ObjectSkinnedMesh.
• Decals with a new Dynamic flag checked are automatically updated in the non-editor mode. They are reprojected onto a surface when the decal node (or its parent) has been moved, or if they are enabled/disabled. It can be used, for example, to cast a decal-based shadow from a moving car.
• Added Distribute parameter for volumetric clouds of ObjectSky. It controls the density of clouds in the distance for better visual quality (use lower values for that).

Render Console Commands:

• Added a console command d3d9_render_use_alpha_to_coverage for disabling alpha-to-coverage under DirectX 9, if required. Now light scattering and all depth-based effects work impeccably when anti-aliasing is enabled.
• Removed a console command d3d11_render_use_geometry_shader, now it is always on.
• Console commands render_manager_load_* are renamed into render_manager_create_*.
• Console command render_manager_warm_shaders is renamed into render_manager_create_shaders.
• Console command render_manager_load_shaders is renamed into render_manager_check_shaders. This console variable should be used only for shader debugging purposes; its execution can be stopped by ESC key.
• Console command render_force_no_translucent is renamed into skip_translucent.
• If render options are skipped via render_skip_* console commands, they are automatically disabled in the interface.

Bokeh flares in action:

A new sample with a custom shader that calculates world coordinates based on depth buffer values: samples/shaders/coordinate_00.

File System

• Arbitrary directories from outside the data directory can now be added to the file system via *.ulink files (much like mount --bind command in Linux). This link file contains a directory path relative to data and is stored anywhere inside of it. A slash symbol in the end is required, for example ../../my_project/. If a link file is added during engine runtime, filesystem_reload should be run.
• Added a console command filesystem_ignore. It takes a full directory name as a value and ignores all folders found within data with such names. It can be used to ignore version control systems (by default, .svn folders are ignored). Multiple values are comma-separated. This option comes into effect only after filesystem_reload is run.
• Removed FileSystem plugin as no longer necessary one.
• Script functions mkdir() and rmdir() can receive a second optional flag to create/remove all specified directories recursively (for example, a/b/c/d) at once.
• Console command data_icase is renamed into filesystem_icase.

Nodes

• New NodePivot allows for easy control over node rotation. (It has two matrices inside: one sets the basis of rotation, and another one transforms children nodes.)
• Added Orientation flag for WorldTransform node. If unchecked, the child node preserves its initial orientation rather than being oriented along the spline.
• Fixed issues with large-sized WorldOccluder and WorldOccluderMesh.
• In *.world and *.node files a hidden attribute has been renamed into folded.

Make sure to run the utils/Upgrade/upgrade.py script to update node files format in your projects!

Physics

• Collisions with ObjectMeshCluster and ObjectMeshClutter objects are available now. (It can be either collisions with polygons or with simplified collision surfaces.)
• Fixed a bug with ragdoll bodies on saving and restoring the world state.
• Physical objects now interact with geometrical waves on water meshes with BodyWater assigned.

Interaction between water waves and physics:

GUI

• For a system GUI a custom font, skin and even a resource file can be loaded in run-time. This allows to change the default look of the engine interface.
• Added padding support (for top, bottom, left and right sides) for all box and window containers.
• New align tag can be used in UI files. Unless overridden in child widgets, it specifies a default align option.
• Added support for tables in all widgets with rich-text formatting (such as labels, buttons, etc.). Use <table/>, <tr/>; and <td/> tags; spacing and border color attributes are supported.
• No more need to use <text/> tags for any of leaf widgets (that cannot have children). For example, now it can be simply <label>text</label>.
• Added setBorder() function for WidgetScrollBox to disable or enable a border around it.
• Fixed memory leaking issue for WidgetCanvas.
• Added a bold font fontb.ttf into data/>core/gui/ to be used for interfaces.
• Fixed a bug with non-rendered space in some fonts.
• Fixed a bug with incorrect scaling of a WidgetWindow title.
• When a fixed framerate is set, WidgetSpriteViewport, WidgetSpriteNode and WidgetSpriteVideo are also rendered with the specified FPS.
• Fixed a bug with incorrect focus on overlapping sprite widgets.
• Added a UnigineScript callback systemSetLanguageCallback() into the system script.
• It is possible to hide text in WidgetDialogMessage and embed any Unigine widget instead of it.

Flash

• Improved rendering of alpha-blended objects with textures.
• Fixed a bug with rendering scaled objects.
• Fixed issues with incorrect addressing to movie clips.

Mobiles

• Multi-touch events are now correctly handled on Android when one of the fingers was lifted.
• For iOS, iPhoneOS 6.1 SDK is required.

Scripts

• Added an extended set of swizzles for matrices. row0...row3 or col0...col3 return the full row/column. row03...row33 or col03...col33 return the first three elements of the row/column as vec3. Plus an underscore symbol is now supported (for example, my_matrix.col33_1).
• Added kill_thread() function to terminate a thread (a thread ID is returned by thread()). Do not call this function from the terminated thread.
• Now in the assertion the full name of the function that caused a crash is output (due to added __FUNC__ predefined constant variables).
• New set/getParameter() functions work with variables that are automatically converted to a property type. getParameter() can also return a custom value (it is an optional second argument) if no value is found to be returned.
• Improved set/getState() and set/getParameter() in Material and Property classes, they can either receive an index or a name.
• Added a new function into system.h to receive multiple localization languages on the system script initialization.
• New dedicated Settings namespace in the system script, in case main settings need to be accessed from it.
• Function engine.config.get() can receive a second optional argument returned if a value is not found in the config.
• Added merge() function that adds one array to another.

C++ API

Now you can create and manage nodes, as well as load them, directly from C++ code due to a set of new functions.

• New functions grab() and release() in each class specify whether the node is deleted by C++ code (when the reference count goes to 0), or is handled by Unigine scripts. Check a new sample source/samples/Api/Constructors.
• Added a set of functions into UnigineWorld to load nodes from C++ side.
• New UnigineEditor allows for working with editor nodes.

Other C++ API changes are as follows.

• Added Unigine::Callbacks class to handle script callbacks conveniently.
• Added Unigine::Console class to work with available console commands, as well as create new commands and variables.
• Inherited classes can be easily casted to base ones via getNode(), getObject() and getStream() functions.
• Unigine::Stream class can now work with big- and little-endian file formats.
• New UnigineUtils.h comes with a number of useful functions, such as min(), max(), etc.
• Added gui() callback into Unigine::Plugin that can be used to render a custom GUI.
• Function App::needDestroy() is now to be used instead of removed App::destroy(). This method is called when all render resources must be destroyed.
• Added a reverse iterator for UnigineTree container.
• Added comparison operators between vector and matrices into UnigineMathLib.
• Added a reverse iterator for map arrays in Unigine::ArrayMap.
• Added Unigine::Map::append(Map) and Unigine::Set::append(Set) functions to copy a map into another map and a vector into another vector.
• Added support for vec2, dvec2 and ivec2 data types.

Editor

• Added Tools -> Plugins -> Core button to select editor plugins available in the data/core directory.
• Increased the number of digits for Density field in ObjectMeshClutter and WorldClutter. Now it's possible to set such values as 0.0001 for it.
• Fixed Tracker layout for Load, Save and Clear buttons.
• The maximum track weight in Tracker can be higher than 1.
• No more resetting of the interpolation type to a default one when Tracker keys are cloned.
• Dimensions of file dialogs are now saved for the next time they are reopened.
• Interface plugin windows restore their positions within available monitors (for example, in case if one of the monitors was turned off).
• No more stalls on node selection when there is a huge number of child nodes in the world.

Tools

• Added 3ds Max 2013 import and export plugins.
• Improvements of Collada plugin include Import joints option (not to import the hierarchy of bones), optional texture compression and the animation drop-drop down list.
• Fixed a bug with memory consumption by the Collada import plugin for some meshes.

GPUMonitor Plugin

Added GPUMonitor plugin for Windows, Linux and Mac OS X. If in the main menu Interface -> GPU monitor option is checked, it shows the graphics card temperature, as well as the available, per-frame information on the chip frequency. For NVIDIA GPUs, it is graphics, memory and processor clocks. For AMD GPUs, it is core and memory clocks. On Mac OS X, only temperature information is available.

Check also a new samples/plugins/gpu_monitor_00 sample.

Other

• Versions of plugins, as well as a version Unigine dynamic library (double precision libraries included) are now checked against the binary version on the engine start-up.
• Warning messages regarding sound and video app selection on the engine start-up are now written into the console instead of being shown in a dialog window.
• Added HAS_XAUDIO2 define to be used in scripts.
• Fixed rare crashes on Mac OS X when ALT was pressed concurrently with an alphabetical key.
• The minimum required Mac OS X version is now 10.7.
• SDK browser has been updated to Qt version 4.8.4.

P.S. Good news, everyone! Finally, the Valley demo, improved and polished, is released as a benchmark this week.

Seamless Forest Rendering

Forests are now seamlessly rendered even from a bird's eye view for flight simulators, especially together with the increased depth buffer precision.

Trees, vegetation or other objects are scattered via WorldClutter and ObjectMeshClutter, while ObjectGrass is used as a far LOD, with their positions fully matching. This is done via a new Subdivision parameter for ObjectGrass that subdivides big grass cells so that they match smaller clutter ones.

To create a grass-based LOD, a model is baked into an atlas at different angles using a new Impostor grabber: Tools -> Grabber -> Mode: Impostor. (You can control the aspect ratio of the baked images; alpha noise to smoothly fade between different angles is available as well.) This atlas is used with a new grass_impostor_base material for ObjectGrass. It supports Phong shading with normal maps.

Check a new forest system with seamless transitions from a high-detail LOD to distant impostors on new samples/materials/impostor_* samples.

Render

• Drastic improvement of the Gaussian DOF: higher-quality blurring and smoothly dissolving contours from objects on the foreground. The full control over a blur radius is granted separately for the distance before and after the focal point.
• Removed a full-screen mode for Glow and DOF effects. Bokeh DOF is also removed as a trade-off for better DOF performance.
• Added render_use_d32f console command to toggle a depth buffer with 32 bit floating point precision. (For example, for rendering more then 100 km within the visibile range).
• New Angularity parameter (Render settings -> Scattering tab) allows to compensate for physically-correct light scattering. Set it to 0 for the whole sky to have a uniform Rayleigh scattering independent of the sun position.
• Added Attenuation parameter for AO and LO that compensates for the falloff of these effects and makes them more prominent in the distance.
• Improved shader caching algorithm allows shaders to be loaded faster from a cache.
• In OpenGL ARB_sample_shading extension is now enabled by default to provide a higher-quality alpha test with enabled anti-aliasing.
• Removed render_use_scattering_falloff console command.
• Fixed a bug with occasional and random flickering of the rendered scene.
• New sample samples/shaders/lines_01 draws different kinds of lines using a geometry shader.
• Particles can now be lit by LightProb light sources.
• Visualizer can render objects' wireframe while respecting the alpha value.

Materials

• Added grass_impostor_base material to render impostors.
• A separate Phong shading option is added for mesh_leaf_base material (for all light sources at once, switch them to Default for leaves to be rendered). Now normals are written into the deferred buffer providing a higher quality for deferred lighting.
• Fixed incorrect attenuation for non-uniform volumetric objects with volume_cloud_base material assigned.
• Fixed a bug with incorrect rendering of the volume fog for water_base material.
• Increased the speed of grass_base and mesh_leaf_base rendering with the Ambient state option checked.
• New Multisample state for volume_fog_base material for it to work with anti-aliasing (if it's enabled on the hardware level).
• ObjectMeshCluster and ObjectMeshClutter can now be rendered with mesh_terrain_base material.

Nodes

• No more scale floating point precission issues when matrices are composed and decomposed via Node::set/getWorldRotation() and Node::set/getWorldDirection(). It is in effect only for the scale of 1.
• Added Node::set/isLatest() functions to update a node after all other nodes. For example, this flag is useful to draw nodes strictly in front of the camera (i.e. to make sure that drawn nodes are updated only after the Player was updated to a new position). WorldExpression::set/isPostUpdate() function with the same functionality is removed.
• Surfaces are correctly enabled and disabled inside NodeReference.
• Cache of NodeReference can be cleared on demand via engine.world.clearNode() function.

Objects

• Added Sync option for ObjectParticles that disables automatic synchronization of a child particle system with a parent one.
• Added getNormal() function for ObjectWater and ObjectWaterMesh. It returns the normal vector of any point of water waves.
• Fixed a bug with ObjectMeshDynamic not restoring its bounding box when state_restore console command is called.
• Improved detection of particles spawning for shift emitters; fixed precision issues for them.
• Improved intersection speed with ObjectTerrain.

World Nodes

• New WorldSwitcher node can disable all of its children with the distance. It is used for simultaneous switching off big parts of the world. The point to which a distance from the camera is measured to can either be the bounding sphere or its center point.
• New WorldSpacer node cuts out parts of ObjectGrass, ObjectWater or ObjectWaterMesh (in a form of a square or ellipse). It allows to dynamically adapt grass or water surface (with Materials -> States -> Spacer Interaction flag) to the added objects. Up to 8 spacers for one grass or water node are supported. Check it on new samples: samples/worlds/spacer_*.
• Fixed a bug of WorldSector: if it is disabled, its children now become visible.
• Now logic of environment objects can be scripted via WorldExpression without a single code line added into a world script. WorldExpression automatically receives callbacks from WorldTrigger, PhysicalTrigger and NodeTrigger when these nodes are made its children. Check samples/worlds/expression_04 to see it in action.

WorldSpacer procedurally modifies a water mesh (for example, to render the space inside a ship's hull):

Grass and Clutters

• Improved performance of ObjectGrass, ObjectMeshClutter and WorldClutter.
• Added Min scale and Max scale parameters for WorldClutter and ObjectMeshClutter. They regulate the size of nodes they scatter according to the mask density: for example, to have small objects at the edges (areas with low density), while having full-sized ones in the middle (areas with high density).
• The Scale and Height parameters of ObjectGrass are gone; instead, the grass height always varies within the specified height range (according to the mask density), no matter what Threshold value is chosen for masking. Please, set up your assets accordingly.
• Added Subdivision parameter for ObjectGrass to subdivide cells into smaller ones (to match with WorldClutter and ObjectMeshClutter).
• Added Orientation option for ObjectGrass. It orients the grass along the normal of its parent object, for example, a terrain. By default, the grass is not oriented.
• New per-column Probability parameter for ObjectGrass. It determines how often one of four grass types (columns) is rendered across the field.

Grass is now even faster and there are new parameters for fine tuning: can be easily fine-tuned with new parameters:

Editor

• Improved search on Materials and Properties panels. On pressing Enter, the next found item is shown.
• Improved a text search in the text editor. On pressing Enter, the next found item is shown. Text highlighting is also added.
• On Material and Property panels, base and materials/properties with children are now color coded.
• Clear option in Nodes -> Surfaces -> Material/Property ('x' icon) has changed its functionality: it removes changes made in the material/property instance rather than removing the material/property itself.
• Terrain can be safely edited even when double precision builds are used.
• Fixed memory leaking when ObjectGrass, WorldClutter or ObjectMeshClutter masks are edited.
• Changes made for a mask of ObjectGrass, WorldClutter or ObjectMeshClutter are not reset if the node is deselected. Instead, a dialog to save changes is shown.
• Improved brush precision when masks are edited. Crashes on mask editing are fixed as well.
• NodeReference no longer crashes if a *.node file it refers to cannot be found.
• Deleting an uncompressed texture (that is checked for modifications in run-time) no longer causes an error message in the console.
• Added Copy and Paste buttons onto Nodes panel -> Surfaces. They can be used to copy all parameters of all surfaces at once and apply them to an identical mesh (or ObjectMeshClutter/Cluster).
• Added an impostor grabber (Tools -> Grabber -> Mode: Impostor).
• Added a button to generate a default LUT texture (Render settings -> Color -> LUT texture -> '+' icon).
• Added Tools -> Plugins -> Core button to easily access plugins stored inside a core.ung archive.
• File dialogs now have Open system file browser button (with a folder icon).
• Added support of the undo operation on removal and renaming of materials and properties.

New color highlighting in the editor:

GUI

• Added console variables to change appearance of GUI: gui_path (specifies a path to a new GUI skin), console_font (console's font to be used), console_size (console's font size), profiler_font (profiler's font to be used) and profiler_size (profiler's font size). For changes to take effect, restart the application (gui_path can be passed as a start-up option).
• WidgetListBox and WidgetTreeBox can render their items in custom colors via setItemColor() function.
• When widgets are rendered as disabled, custom colors set via Widget::setFontColor() or WidgetListBox/WidgetTreeBox::setItemColor() are not greyed out as in case with default ones.
• Added access to all WidgetTreeBox items via getItems() function.
• Complex GUI widgets (for example, with thousands of items in the tree) work correctly and do not cause a vertex buffer overflow.
• TTF font textures are cached before rendering.
• Fixed a minor bug with incorrect layout inside WidgetV/HBox in some cases.
• Images are now correctly flipped in DirectX APIs for WidgetSprite/Material/Node/Viewport widgets via renderImage() function.
• New Gui::isFocused() function checks if the current GUI instance contains a focused widget.
• No more shaking artifact when manipulators are used in double-precision builds.
• All editor dialogs are refactored to have only Yes/No or Ok options.

Scripts

• Files can now be buffered in the memory via engine.filesystem.addBufferFile(). If they need to be frequently modified in run-time (for example, images), they can be loaded from a disk and kept in the memory for faster access. For examples, see samples/systems/socket_01 sample that saves a screen image into a buffered file and sends it to a web browser. (Do not forget to check Tools -> Always update option).
• Added preprocessor() function that allows to preproceces source files, such as unigine scripts or shaders.
• Added crc32() system function that returns a control sum for a given string.
• Improved greyscale alpha support in Image::extrude() function.
• Function bezier() can receive vec4 and dvec4 for float and double precision coordinates.
• Function system() (from Core library -> OS functions) that executes shell commands is now available on Mac OS X.

High-Level Scripts

• Tracker perfectly works on very far distances with double-precision builds.
• In Tracker, getParameterNext/PrevTime() functions are renamed into getNext/PrevParameterTime().
• If NodeReference contains a node with an identical name inside, such node cannot be handled by the Tracker.
• Fixed a bug in Skinner's block skinned.difference.
• When Syncker is used, multiple slaves can safely connect to a master (server) running on a Windows PC due to increased connection timeouts.

Mobile Platforms

• Added a number of samples into the Android platform SDK (such as app initilaization, running callbacks between Java code and the script, simple joystick handling). They can be found under source/samples/Android directory.
• Menu bar is not shown in Android samples any more. For it to disapper in your Android project, change the target device to target-14 in the manifest.
• Materials -> Common -> Offset for polygons is not availble on feature levels 9_1, 9_2 and 9_3 of DirectX 11.
• Function UnigineActivity::runFunction() that executes functions from a system script is renamed to UnigineActivity::runSystemFunction() and made public.
• On Android, up to 2 argument now can be passed from a system script to Java code, and vice versa (both arguments should be of the same type). Integer, float and string arguments are supported.
• Fixed a bug when callbacks from world and physical triggers were not handled on iOS.

Flash

• User classes can be inherited from a base MovieClip due to the added support of instanceOf operator.
• Added support of addProperty() method of Object to create custom properties for objects. User classes can now contain set and get keywords.
• Added support of getInstanceAtDepth() method of MovieClip.
• Added support of set/clearTimeout() and set/clearInterval() functions.
• Fixed a bug with WidgetFlash performing an incorrect stencil test for its elemets under DirectX 11.

Other

• Added extern_package console command to be passed on the start-up. It loads UNG archive from the specified location.
• Added editor_plugin console command to load any editor plugin (comma-separated, if there are several of them) via start-up options.
• Improved detection of the available CPU cores number for Windows (hyper-threading is ignored).
• OpenAL Sound system support is automatically disabled for WindowsRT builds.
• No more file queueing stalls. Queued requests on loading are automatically cleared if files are no longer required.
• Fixed a bug with random crashes on calling state_save console command.
• Added nocompiler build option for SCons. It disables compilation of shaders in run-time for WindowsRT and PlayStation3, to conform with these platforms' requirements. Instead, shaders need to be precompiled offline; the resulting cache is placed into the data root directory.
• Added an additional system button App::KEY_CMD (for a command key on Mac OS X). Some keyboard codes (including a Scroll Lock, Caps, Num Lock and F1-F12 keys) must be reset because of that.

Plugins

• AppStereo, AppSurround and AppWall plugins are now available on Linux. They can also be run in the OpenGL API on Windows.
• AppSoft is renamed into AppLevel. Now it is possible to select different rendering devices on its start-up via -type CLI option: hw (for the hardware GPU), ref (a reference rasterizer), null (no renderer), soft (a software rasterizer), warp (a WARP device) and feature levels of DirectX (91, 92, 93, 10, 101, 11).

Stand-alone Tools

• New Terrain console tool creates a Unigine-native terrain and a normal map for it from a hight map, and vice versa. It can be used to automate terrain creation, if necessary.
• Added an shader compiler for Direct3D11 and PlayStation3 (it is found under source/tools/Interpreter/scripts/render folder). For offline compilation of shaders into a cache, the effect-compiler tool (fxc.exe) is required.

P.S.: Happy New Year to everyone! We have a full pack of new amazing developments in progress, soon to be released in further updates of Ungine SDK.