Development Log

Recent changes:

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

What's new:

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

Recent changes:

• 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).

What's new:

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

Changes of this month:

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