• Fixed crashes on OpenGL / NVIDIA.
• Fixed wrong collisions of a mesh with a convex hull.
• Fixed higlighting of sliders in GUI.
• No more stalls during grass generation.
• Clusters speedup.
• Optional warm start for particle systems.
• Multi-threaded update of world nodes.
• Reduced memory consumption by meshes (32 bytes for static mesh vertex, 48 bytes for skinned mesh one).
• Two-pass preprocessing of scripts for full collection of data on classes and prototypes.
• Added a new sample of selecting objects by mouse (data/samples/systems/selection_00).
• Added experimental Cg shaders for NVIDIA GPUs, that translate GLSL code into NVIDIA OpenGL assembler instructions (this approach provides 5-10% performance boost in OpenGL in comparison with high-level GLSL code).
• Added OpenCL wrapper.
• Saving of unique IDs of nodes into world/node files.
• Correct work of isVisible flag in nodes, besides that the list of visible nodes of a world is accessible now (engine.world.getVisibleNode(index)).
• Fixed a heap of minor bugs.

Also we have two more people in the team: Nadezhda Ovchinnikova (technical writer) and Kuat Eshengazin (lead QA engineer).

PS: No pictures today, sorry.

• World layers support via new NodeLayer: they are stored in separate files, which is more convenient way for collaborative work on a project.
• In-place editing of NodeReference from the editor.
• Reduced memory consumption by NormalMapper and AmbientMapper.
• Fixed WorldCluster crashes.
• Fixed wrong texture coordinates in volumetric clouds.
• New flag for ImageDDS: -a allows to downsample a large source image into smaller one with preserving alpha-testing accuracy (don't use this for alpha-blending).
• Fixed buffer overflow in dynamic meshes.
• Correct playback of skinned mesh animation with negative speed.
• Optimized performance of sectors and portals.
• Added engine.editor.releaseNode() function, which removes a node from the editor list, but doesn't delete it.
• Aspect ratio for grass instead of separate width/height settings.
• Material of multi-layer paint (mesh_paint_base).
• Fixed editing of shapes and joints in UnigineEditor.
• Adjustable shadow offset for billboard leaves.

Here you can see the difference in alpha-testing with enhanced downsampling via ImageDDS:

Multi-layer paint material is good for car paint:

Some additional landscape improvements in our game in development (grass everywhere, massive tree arrays):

PS: We are also to announce the next major step forward, which we made recently, so stay tuned.

• Performance analyzer for UnigineScript (in GProf style).
• Refactored grass (significantly improved performance, support of different shapes, more adjustable parameters).
• Improved render precision for distant areas.
• Postprocesses don't affect wireframe visualization now.
• Performance optimization of LightWorld.
• Recursive preprocessing of namespaces in UnigineScript, no more forward declarations.
• Warnings on wrong arguments for functions with arbitrary number of arguments in UnigineScript.
• Added billboard flag in ObjectGui.
• Support of OGA and OGV file extensions for audio and video files in OGG format.

To see the performance analyzer output, type "world_analyze" (world script) or "system_analyze" (system script) or "editor_analyze" (editor script) in the console:

If you want to dump this output into a file, pass its name as an argument: "world_analyze logfile". The perfomance analyzer works only with debug builds. The following counters are available:

• total seconds (this is the total number of seconds the interpreter spent executing this function)
• self seconds (this is the number of seconds accounted for by this function alone, without internal calls of other functions)
• calls (this is the total number of times the function was called)
• total ms/call (this represents the average number of milliseconds spent in this function and its descendants per call)
• self ms/call (this represents the average number of milliseconds spent in this function per call)

Updated grass can be seen in "Forest" demo, which is included into the Unigine SDK:

PS: There is also a component-based game framework almost ready, it will be soon delivered to our customers.

PPS: We have updated our public demos, Tropics 1.2 and Sanctuary 2.2 can be downloaded from our website.

PPPS: We are hiring talented people in Tomsk, Russia.

• New type of lights: LightProb, which is suitable for simulation of global illumination for dynamic objects.
• Access to command line arguments from UnigineScript.
• Rendering of screenshots into HDR images.
• Fixed ObjectVolumeBox rasterization.
• Fixed ObjectMeshDynamic crashes.
• Spatial subdivision optimization.
• Faster world loading.
• Range of material priority has been extended to [-8;8].
• Easy registration of 3rd-party C++ functions as script class members via C++ API.
• Unique IDs for nodes, bodies, shapes and joints (repetitiveness is guaranteed for the same world on different machines).
• Eliminated position lag between world and visualizer.
• Dedicated spatial tree for clutter objects ("clutter" flag in nodes).
• Reduced memory consumption on scenes with large amount of objects.
• Additional impostor configuration parameters.
• WorldTransformExpression gained access to a parent node.
• Two-argument version of check() method for containers.
• Performance boost of UnigineScript with external classes.
• Added WorldCluster object.
• Added accumulation of profiler counters' values.
• Support of anti-aliasing in image grabber.
• NodeRef renamed into NodeReference (use scripts/Upgrade/upgrade.py to upgrade your data).
• New NodeDummy type of nodes for grouping (ObjectDummy is to be used for physical purposes now).
• Support of new postfixes by imagedds.py: dr, sr, nr, hr, ar, lr (raw textures).
• Specular reflection is modulated by Fresnel effect on all meshes.
• Transition to ATI1 format for all single-component textures (ambient and height maps require regeneration by means of imagedds).
• Enter/leave callbacks for WorldTriggers can be set via UnigineEditor now.
• NodeReferences store references to all required material and properties libraries.
• Support of public/private access level modifiers in UnigineScript's classes.
• Automatic inline of getSomething() functions in UnigineScript.
• Support of << and >> bitwise operators in UnigineScript.
• Two-pass compilation of scripts, function and class prototypes aren't required now.
• Support of additional text for WidgetIcon.
• Switch and toggle types of parameters in properties.
• Support of multiple materials per shape in Maya plugins.
• Correct rendering of visualizer with HDR and other postprocesses.
• Group set of parameters for nodes in UnigineEditor.
• Group rename of nodes by a mask ("%d" and "%1d" formats are supported).
• Camera moved out of high-level Character system.
• Externs package has been integrated into the SDK.
• Fixed corruption of %PATH% on MS Vista in the installer.
• Updated reference manual.

Some notes regarding LightProb: it's a special type of light source, which is based on baked spherical harmonics. They are intended to be used in large groups, providing some kind of global illumination. LightProb can have ellipsoid shape. Due to compact format (9 vec3 values per light) it's possible to bake series of presets for a light and interpolate between them, simulating dynamic change of environmental lighting. Objects are rendered without instancing in LightProb rendering pass.

Here is an example of different types of lighting baked into LightProb:

WorldCluster is a smart container for a baked heap of NodeReferences. Only visible NodeReferences from a WorldCluster are added to the world, so it's really fast. To group some NodeReferences into a WorldCluster, you have to make it their parent in node hierarchy and press "create" button in the editor. See new "Forest" demo as an example.

Due to severe changes in structure of the SDK, please uninstall previous version before switching to the current one. Don't forget to run new version of upgrade.py also to upgrade your data (see documentation for more details).

Eating our own dog food is a good idea, because we understand needs of our clients better by doing this. The game is a great sandbox for the engine and tools, a lot of performance and scalability issues have been solved during the development.

The world has 64 km² (8x8 km) terrain (it lacks plants at the moment, we are working on that):

Atrium in the city:

Fountain in the courtyard:

One of the characters:

Tuning physics of a car:

The same car wheeling through parking:

Nice hallway with sculptures:

All of the scenes from this screenshots run smoothly on ATI HD4850 / NVIDIA 8800GT, however we are still working on optimizations, so hardware requirements will be lower.

This is an independent project of our company developing without a publisher. It seems that it would be the right time to make official announce of the project in May. Release is planned for this year.

PS: We plan to provide access to working materials of the game for our clients in 2 weeks.

• Various render performance optimizations.
• Improved rasterizing occluders.
• Decals from particles.
• ObjectMeshDynamic can be created from a mesh file.
• New type of occluders: WorldOccluderMesh, which can have arbitrary geometry.
• Added WorldTransform, WorldTransformBone and WorldTransformExpression node types for transformation of nodes by a spline, an animation and an expression.
• Added set of functions for easy manipulations with node transformations.
• Binary format of spline files.
• Callbacks for physics, triggers and GUI are moved to the appropriate classes.
• Inheritance of parent object's animation in skinned meshes (useful for attaching clothes to a character body).
• Added field for arbitrary user data in each node.
• Added reflection masks for lights.
• Updated spline exporter for 3dsMax.
• System profiler now accumulates values from counters with the same name.
• Optimization of shadow rendering for LightWorld.
• Fixed screenshot grabbing under Direct3D9.
• Heavily refactored players, now they are full-featured world nodes.
• NodeRef caching on load, it leads to faster world loading.
• Additional sorting of equidistant from the camera transparent surfaces by blend function.
• Improved camera for high-level Character system.
• New high-level controls system in UnigineScript (see data/scripts/input).
• Updated reference manual, added "Programming / High-Level Scripts / Character System" article.

Here is an animation tree scheme for new character sample, which is included in the SDK:

PS: We have updated Unigine development roadmap for this year, now you can see status of scheduled features.

• Support of Linux on PlayStation 3 (with null render).
• New SPUShader class for work with SPU-based programs (works via libspe2 in Linux).
• Added Altivec optimizations for PowerPC CPUs.
• Full support of little and big endian platforms.
• CUDA framework.
• Added compact profiler mode ("show_profiler 1" console command, full view is "show_profiler 2").
• World spatial subdivision optimizations.
• Mesh intersection speedup.
• Fixed engine crashes, which were caused by memory corruption.
• Added set()/get() functions for indexed access to all containers in UnigineScript.
• Billboard-based material for foliage (an option of mesh_leaf_base material).
• Plugins for Maya 2008 (9.0).
• Fixed texture path issue in UnigineExport script for 3dsMax.
• Fixed plugins for 3dsMax (mesh export with applied modifier).
• Simple framework for software rendering.
• Updated shadow biases for all supported hardware.
• Mesh-based water use UV coordinates for waves (keep it in mind for old content).
• UnigineScript: call() and thread() functions can accept an array as second argument.
• Changed format of decals storing (run upgrade.py script to upgrade data, see more in the documentation).
• Improved high-level character system with full-featured animation tree (see "character" demo in the SDK).
• New detailed tutorial in documentation: Content Creation -> How to... -> Setup Sky and Water.

Unigine seems to be running fine on PS3 in home-brew mode (with Linux), however there is no access to GPU, so it supports only null render or simple software render for physics debug. Due to well-designed Unigine's framework the porting to this point was quite easy.

This is a screenshot from new "character" demo:

Since March, 13 a new great book of ShaderX series is available: "ShaderX7: Advanced Rendering Techniques", edited by Wolfgang Engel. Section 4 (Shadows) of the book contains an article "Practical Cascaded Shadow Maps" by Fan Zhang, Alexander Zaprjagaev (CTO of Unigine Corp.), Allan Bentham. The described shadowing technique is used in the Unigine engine, providing fine shadows with arbitrary scene geometry.

PS: Networking module is slightly delayed due to some unsolved issues with physics synchronization.

PPS: There is also a non-official Unigine crew blog started recently, where you can find some more info about our social life.

• New memory allocator, which can show memory fragmentation.
• New memory_dump console command for displaying memory fragmentation (numbers means allocations count in some point, 'x' means more than 16 allocations).
• New garbage collector (ref-counter based) which eliminates stalls (old one was called only each 32nd frame).
• Fixed bug in animation export plugins, which occured with large number of weights per point.
• New global "light distance" parameter in render settings.
• Added support of Object and ObjectMeshDynamic into C++ API (see API examples).
• GL_vertex_array_object extension is required now, please update your video drivers.
• Support of binary XML files for release version (they loads faster, consumes less memory and causes less fragmentation).
• New "xmltree" tool for compilation/decompilation XML files into/from binary format.
• Fixed Fresnel refraction on NV40 / OpenGL.
• Fixed streaming-related crashes under OpenGL.
• New global "light distance" parameter in render settings.
• "render_manager_reload mesh" reloads only meshes, "render_manager_reload texture" reloads all textures.
• Support of inplace array creation inside foreach structure of UnigineScript: foreach(int i; (0,1,2,3)).
• Added system of animation buffers.
• Correct font wrapping for RichText.
• Force set of WidgetGridBox proportion, columns are of fixed size.
• Added sample of integration RakNet (a high-level networking library) into Unigine (see source/samples/Network/RakNet), which is still in the development.

New allocation policy: by default there are two memory pools (128Mb each), one of them is used for allocations less than 32Kb, another one is for the rest (so by default the engine requires 300+Mb). If these pools are already full, the engine allocates additional 128Mb pool. Plus there are fixed allocators for 2ⁿ memory pieces, up to 128Kb. Memory manager also performs bound checking for allocated memory. Use memory_dump to see current fragmentation map:

Skinned mesh animation system now operates by tempararily buffers of bone transformations. One can apply different operations to them (copy, invertion, interpolation, multiplication). So these buffers allow creation of complex animation trees. Animation layer can be treated as a CPU ALU and buffers are like CPU registers.

PS: There is a new interview with our customers, who is creating an "Afterfall" post-apocalyptic cRPG basing on Unigine (Polish only, sorry).

• Smart data streaming: textures shows 64x64 mipmap (those miniatures are always loaded in memory) before fully loaded, meshes are rendered when loaded.
• Separate thread for data loading, which allows smoother data loading in the background without stalls.
• Loading queue can be controlled by a set of filesystem_* console variables.
• Improved warming up of shaders on world loading.
• manager_preload_* console variables renamed to render_manager_load_*.
• New formats of meshes: static meshes store their boundings for faster preload, plus there is a more effective data compression for both static and skinned meshes (warning: you must convert your data in order to work with this version, see notes about upgrade system below).
• meshupgrade console tool for converting all meshes into new formats.
• Fixed light masks for LightSpot sources.
• Refactoring of mathlib, some Fast* functions removed.
• Correct interpolation for negative frames in MeshSkinned (also added getFrameCurrent() function).
• Per-bone weight normalization for animation.
• New framework for plugins.
• MeshSkinned import plugins for 3dsMax and Maya.
• Contact toggle for WorldTrigger.
• Added array.find() function with two arguments in UnigineScript, returns second argument if nothing found.
• engine.splash.renderSplash() function renamed to engine.splash.renderInterface().
• Added addLayer() function for MeshSkinned without flushing data on other layers.
• Added engine.memory.* set of functions in UnigineScript library.
• Static 2D reflections (reflection_dynamic state in water_base and mesh_reflection_2d materials, static by default).
• MeshViewer shows basis and name for bones.
• Removed support of Intel compiler and MinGW.
• Quadratic exposure mode for HDR (set render_hdr console variable to "2").
• Improved class casting in UnigineScript, Foo(input).function() syntax is supported now.
• Support of Linux 64 bit with cross-compilation (use "scons cross=x86" or "scons cross=x64" depending on base platform).
• Versions of XML data (world, node, mat, prop, ui) can be different from this moment.
• New data upgrade system.
• New KeyLine system for key sequences, see "Programming / UnigineScript / Scripts / KeyLine Script" section of the manual for more information.
• Updated C++ API documentation and reference manual.

KeyLine system handles arbitrary key sequences and takes care of interpolation between key values, providing GUI for data manipulation as well. It is a somewhat data-driven system, meta-information is stored in the XML format. Licensees can see how this system is used in new version of Tropics demo for dynamic environment control.

We also introduce a new one-button upgrade system, see 'scripts/Upgrade' directory in the SDK. Please note that it requires updated Unigine_Externs package installed and 'Unigine_Externs/bin' in your system's PATH variable. To perform batch meshes upgrade you should simply run "upgrade.py --target=PATH-TO-YOUR-PROJECT" from the command line.

PS: Don't forget to update your video drivers to recent ones (but be aware about some bugs in OpenGL with ATI), previous version from NVIDIA was very buggy.

• External GUI via wxWidgets (for new editor) through C++ API in progress.
• Physical contacts are accessible from PlayerSpectator and PlayerPersecutor.
• StreamRead and StreamWrite are merged into Stream class, which can be used to transfer File and Stream objects into C++ part.
• Image class added to C++ API.
• Controls are now accessible via C++ API.
• setUpdate()/setUpdate functions in C++ API, which controls whether the application will be updating when the window is hidden.
• User-defined classes can be used as keys of maps in UnigineScript.
• Alpha testing is available for mesh materials with detail.
• C++ like scoping for derived classes in UnigineScript (search inside itself, search inside parent class, search its own namespace, search inside parent namespace).
• Reduced number of allocations in call() operator of UnigineScript.
• Simple ImageView tool for viewing of all supported texture formats.
• Improved new() operator now supports the following statements: new("Foo"), new("File","file.txt","wb") in UnigineScript for objects construction of user-defined and extern classes.
• Support of dual quaternion skinning with uniform bone scaling (optional, controlled by render_use_dual_quaternions console variable, disabled by default).
• setFrameBoneTransform() / getFrameBoneTransform() members of ObjectMeshSkinned work in local space.
• Increase of bones per surface limit to 96 (non-uniform scaling isn't supported anymore, be aware).
• New format of skinned meshes (use ResourceEditor for upgrading; don't forget to update plugins), which treats all bone transformations in local space.
• Heavily refactored WidgetListBox and WidgetTreeBox widgets.
• Added multiple re-parenting for nodes in the editor.
• WorldTrigger can be activated by a contact.
• Access to a parent widget in GUI.
• Fixed FOV in camera export script for 3dsMax.
• Animation export plugin for 3dsMax supports compact sanim format.
• High-level scripts are moved into data/scripts directory.
• No more seams on splatting terrain with DX9.0 hardware.
• MeshViewer shows bones hierarchy.
• Optional support of dual quaternions in MeshViewer.
• Shaders performance optimization.
• Support of warming shaders after loading of the world (render_manager_warm_shaders console variable, disabled by default).
• SCons 1.2.0 is supported, it's highly recommended to upgrade to this version.

Here is an example of external GUI for Unigine (it will be used for new version of UnigineEditor, which is scheduled for this year):

Compare results of ordinary animation (note skinning distortion due to large twist angle):

...with dual quaternions one, which provides better quality:

PS: Unigine has celebrated 5th anniversary recently, it's quite a long run, wow.