• 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!

• Added binary SDKs for iOS and Android.
• Added XCode projects for Apple platforms:
  • Mac OS X (source/app/main/main_x64.xcodeproj and source/engine/libUnigine_x64.xcodeproj)
  • iOS (source/app/iOS/main_arm.xcodeproj and source/engine/libUnigine_arm.xcodeproj)
• Added Visual Studio C++ 2010 project files in VCXProj format (source/app/main/main_vc2010.vcxproj and source/engine/unigine_vc2010.vcxproj).
• Updated Visual Studio C++ 2008 project files.
• Improved Unigine SDK browser UI.

GUI:

• Added samples of Direct3D9/10/11 context initialization with Qt wrapper (see source/samples/App directory).
• Added "video_resizable" console option (disabled by default; if enabled, a window size can be changed on the fly, without having to restart).
• Console activation key can now be re-defined via "console_key" config option (the default value is 96, an ASCII code for '`' character).
• Fixed special character input with Alt/Ctrl buttons pressed.
• Fixed ObjectGui intersection.

Other:

• Fixed fog rendering in ortho projections.
• Fixed visual artifacts on physical objects with motion blur enabled.
• Added 'simd' SCons flag, possible values are 'none', 'sse', 'sse2', 'altivec', 'neon' and 'default' (stands for the default platform-specific setting).
• Added isInt()...isControls() methods for Variable class into C++ API.
• Fixed CPU count detection on Android.
• Removed Description field from materials and properties.
• Ogg Theora library is upgraded to ARM-optimized version (1.2.0alpha1) for mobile devices.
• Project name can be passed via '-project' CLI option (if set, it forces the engine to store all changing data, such as a log file, cache files and the config, in the user profile rather than in a directory with binaries).
• Added documentation on inheritance of UnigineScript user classes from base engine and extern C++ classes.
• Added documentation on 'post_filter_reflection' post-processing material:

Editor in progress:

If you have not yet heard of it, a new version of UnigineEditor is fully underway. As the plan goes, its main features are:

• Multi-window interface with standard widgets based on Qt library
• Asset database with platform-specific settings
• Live edit on target platforms (mobile, PS3...)
• Sequence editor (for cut-scenes)
• Flowgraph editor (for "visual scripting")
• Animation tree editor
• Automated deployment to target platforms
• Plug-in system

Indie deal:

Time-limited indie licensing options are available until November 30, starting from $1299. Read more in the press-release.

UnigineScript:

• Huge speed-up of the virtual machine.
• Added inheritance from external classes.
• Base constructor can be called in C++ syntax.
• Added typeid() function for quick type checking.
• Added step-by-step debugging mode ('n' command in the built-in debugger).

Here is the performance comparison chart for UnigineScript 2.46, Lua 5.1.4, Perl 5.10.1 and Python 2.6.6 (higher values stand for higher performance).

All tests were performed on Intel Core2 Duo E6750 @ 2.66 GHz / Ubuntu Linux 10.10 (64-bit).

The following tests were made:

• Array - simple math operations and array elements access
• Branching - conditional branching
• Loop - a loop with variable increment inside
• Loops - six nested loops with 16 iterations per each loop, variable increment inside
• Matrix - 128x128 matrices multiplication
• Random - simple random number generator, a loop with a function call running 20,000,000 iterations
• Sort - quick sort and buble sort algorithms (no external C functions, only pure bytecode)
• Statistics - simple Gaussian random number generator and Gaussian distribution calculation
• Vectors - simple math operations with 3D vectors and 4x4 matrices

According to these tests, UnigineScript has proven to be the fastest scripting language, especially optimized for 3D-specific tasks with its built-in support of 3D math. It is a mature object-oriented solution with zero learning time syntax (similar to C++/C#) featuring a rich function library available out-of-the box.

Render:

• Fixed rendering artifacts on Mac OS X (10.7+ required).
• New App3DSurround application for 3-monitor stereo rendering atop of NVIDIA 3D Vision Surround technology. (It is a completely native solution that gives full control over cameras configuration).
• AppWall automatically detects the display configuration and creates a corresponding number of windows. (The default number can be overridden with console arguments).
• Added a lot of automatically supported display configurations (1x1, 1x2, 2x1, 2x2, 3x1, 3x2, 4x1, 5x1) for AppWall into the wall.h script.
• Fixed bug with incorrect vertical asymmetric projections distortion in DirectX.
• Correct planar reflections with asymmetric frustum projections.
• Correct near LOD fade distance for volume objects.
• ObjectClutter and ObjectGrass prevent their mask from being unloaded (allows to avoid rendering stalls).
• Fixed crashing on simultaneously changing both the video mode mode and render settings.
• OpenGL ES render now supports Render::renderImage2D() and Render::renderImageCube() functions.
• Stereo 3D settings are available by default when one of stereo defines (STEREO_SEPARATE, STEREO_ANAGLYPH, STEREO_3D_VISION, STEREO_3D_SURROUND, STEREO_IZ3D) is passed (stereo.h is included into the default system script).
• Fixed texture coordinates problem with billboards in Direct3D10/11.
• Added two viewport rendering samples: data/samples/render/image_00 and data/samples/render/viewport_00.
• Added stereo viewport rendering functions into C++ API.

Other:

• Added NavigationMesh object.
• SSE2 is required by default now (use "scons simd=sse" to build without this requirement).
• Support of additional control keys by Telnet server.
• Once loaded, material/property libraries are not unloaded from the set of world libraries (huge loading speed-up for worlds with shared resources).
• Multi-threaded culling of ObjectSurface.
• Fixed cone sound errors (caused by incorrect OpenAL implementation) on iOS.
• Added al_sound_skip_errors console variable to skip error messages from OpenAL library.
• Improved detection of CPU cores.
• Added support of icons for tab boxes in GUI.
• Fixed calculation of PhysicalTrigger bounds.
• ImageDDS can now utilize multiple CPUs running in parallel.
• Updated "Stereo rendering" article, now it includes the information on 3D Surround mode customization.
• Added "Multi-Monitor Rendering with AppWall" article.
• Updated documentaion on sky object and its material.