• Added destructible body type: BodyFracture (it supports three destruction patterns).
• Performance boost in spatial subdivision.
• Removed intersection mask from BodyWater, it intersects with parent node now (like grass).
• Support of cylinder collision shape.
• Joints with softness set must be re-adjusted.
• Added full CCD for spheres and capsules.
• 'reflection' parameter of BodyWater is renamed to 'absorption'.
• Fixed assert in GUI on video mode change.
• Fixed sectors/triggers infinite recursion.
• Saving/restoring array iterators in UnigineScript.
• Fixed incorrect UV data of water in DirectX 10/11.
• Children particle systems with shift emitter use parent particles as emitters.
• Added more samples of particle systems.
• Tessellation optimization gives up to 30% performance boost.
• PSSM shadow geometry replication by geometry shader (controlled by the folowing console variables: gl_render_use_geometry_replication, d3d10_render_use_replication, d3d11_render_use_replication).
• Tesselated triangles count can be seen in 'RPrimitives' profiler counter.
• Added 'Reduce Mesh' feature into MeshViewer: it removes invisible inner triangles.
• Screensaver launch and power off blocking with running engine on Windows.
• Fixed wrong UV data in WidgetSpriteShader.
• Even more speed optimizations and minor bugfixes.
• Updated documentation on UnigineScript library.

Physical destruction of objects:
Video demonstrating physical destruction

Another sample (also can be found in update Unigine SDK):

Video demonstrating physical destruction

• Added SpawnThreshold parameter for particle systems (spawn rate for 'random' and 'spark' emitters depends on the speed of parent objects).
• Separate axis flip for particles: 'variation_x' and 'variation_y' parameters (run upgrade.py script for data upgrade).
• Shared 2D reflections (the same way as cube reflections are shared).
• New BodyWater for physical simulation of shallow water with two-way interaction.
• Access to floating objects in PhysicalWater.
• PhysicalWater and BodyWater spawn spark particles on contact, if particle system is made a child node.
• Emitters of child particle systems are synchronously enabled when the parent emitter is enabled.
• Continuous collision detection for spheres vs convex hulls, spheres vs meshes, capsules vs convex hulls and capsules vs meshes.
• Less memory allocations by render.
• Added two more flags for nodes: isVisible (the node was shown in a viewport) and isShadow (the node casted shadow).
• Added camera limitations for PlayerSpectator.
• Per-object freeze speed of physical objects.
• Inverse kinematics for ragdolls.
• Added more physical cloth samples, including ones of attaching the cloth to skinned mesh.
• Added BodyWater samples.
• Added inverse kinematics samples.
• Visualization of full ragdoll hierarchy and bone hierarchy in UnigineEditor.
• Reduced memory consumption by plugins for 3D editors.
• Fixed MeshSkinnedImport plugin for 3ds Max.
• Updated Softimage plugins (usability improvements).
• Added documentation on grass ("Principles of Operation / Objects / Grass" section of the manual).

• engine.world.addVisibleNode() is renamed into engine.world.addUpdateNode().
• engine.world.getNodes() is renamed into engine.world.getIntersectionNodes().
• engine.world.getObjects() is renamed into engine.world.getIntersectionObjects().

Physical cloth on skinned mesh objects:

Video demonstrating physical cloth on skinned mesh objects

Interaction of objects with physical water:

Video demonstrating interaction of objects with physical water

• New PhysicalForce, PhysicalWind and PhysicalWater objects (simulation of viscous medium, buoyancy and resistance forces).
• Fluid buoyancy for all physical shapes.
• Added a set of samples with physical force fields and a rope sample.
• JointPin can attach cloth to ragdolls.
• Physics visualizers are now shown only with the editor loaded.
• Particle systems are now affected by force fields.
• Fixed velocity calculation for ragdolls transformed with setVelocityTransform() function.
• Added 'world_show_physicals' console variable.

• New Chain type of particles for shift emitters to generate a seamless flow.
• Particles reset emitter parameters on disabling/enabling of the node.
• Some renaming in world/node files: 'stretch' -> 'length_stretch' and 'point_force' -> 'force' (run upgrade.py script to convert your data). This affected ObjectParticles API as well.
• Removed 'emitter_velocity' and 'emitter_scale' parameters from the particle systems; added slightly different 'emitter_direction' and 'emitter_spread' instead.

Chain particle systems affected by force fields:

• Export plugins for Softimage 2010 (static geometry, skinned mesh animation).
• Fixed AppWindow in Linux: it provides the same keycodes regardless of the current key layout.
• Fixed node type filter in UnigineEditor.
• Refactored tessellation shaders; there is some performance improvement.
• Added 'post_filter_rgb2yuv' post-process filter that is useful for TV broadcasting.
• Improved Unigine::Image C++ API: added more functions for image processing.
• Added WidgetSpriteShader object, which can be used with a custom shader for post-process material.
• Added Unigine::ObjectMeshDynamic::updateIndices() function.
• Shadow objects force node update, there will be no shadow stalls.
• Timestamps in log files.
• WorldTransformExpression is renamed to WorldExpression.
• Refactored stereo 3D launchers, now they can are not limited to dual view mode.
• Adding array of visible nodes into the world is possible via UnigineScript.
• Swizzling is now available in UnigineScript for functions; foo().x and foo()[2] is acceptable now.
• Added EngineAnalyzer system, output can be seen via 'engine_analyze' console command.
• Fixed occluders rasterizator.
• All GUI fonts have anisotropy enabled now.
• Updated documentation on particle systems ("Principles of Operation / Objects / Particle systems" section of the manual).
• Updated article on blending in materials ("Content Creation / Materials Overview / Blending Options").

Softimage export plugin GUI (see documentation for more information on options):

• Added support of physical cloth.
• Added JointPin for pinning cloth to BodyRigid and BodyDummy.
• Added PhysicalWind for setting wind areas affecting cloth.
• Fixed saving of instanced materials.
• Access to contact time in physical contacts.
• Access to more verbose info from JointWheel.
• "Frozenable" flag for rigid bodies.
• Correct handling of setVelocityTransform() by BodyRagDoll.
• Fixed Unicode issue with log file names in Windows.
• Added plugins for Maya 2009 Linux 64 bit.
• Fixed issue with particles inside sectors.
• Added a bunch of new physical samples.
• Updated documentation on common object options ("Principles of Operation / Objects" section of the manual).

Cloth-based propellers drive airplanes in the field of PhysicalWind:

Video demonstrating interaction of physical cloth with wind

Cloth tearing:

Video demonstrating cloth tearing

Cloth-based leaves:

Video demonstrating cloth-based leaves

You can find more videos with new features in Unigine crew's blog.

PS: By the way, here is another blog entry regarding Unigine in AMD Underground Blog: 11 Days of DirectX® 11, Day Eight: Unigine "Heaven".

• Released the first DirectX 11 benchmark on the basis of Unigine.
• '-Os' replaced by '-O3' in GCC flags, which gave a 20% speed boost in Linux.
• Fixed water artifacts produced by overlaping waves.
• Line intersection functions for all physics shapes.
• Fixed detail textures with SRGB enabled.
• Added access to image pixels via C++ API.
• Vertex cache optimization is now optional (see export plugins settings).
• Optional axes flip on import in ResourceEditor.
• Added "frame based" flag for every bone of the ragdoll to mix physics-driven and skinned mesh animations.
• New Body::setVelocityTransform() function that calculates linear and angular velocities based on the body transformation.
• Fixed a rare startup crash caused by multi-threading access to archived files.
• More verbose XML parser.
• Fixed saving of materials into nodes.
• 'restitution' and 'softness' joint parameters splitted into linear_restitution / angular_restitution and linear_softness / angular_softness (don't forget to run the upgrade script).
• Optimized tessellation shaders for DirectX 11.
• Added documentation on sky ("Principles of Operation / Objects / Sky" section of the manual).

Here are some technical details on how tessellation works under the hood:

Video demonstrating hardware tessellation in action (based on Heaven DX11 benchmark content)

Release of the Heaven benchmark attracted a lot of attention in the Net (our webserver has had a near-death experience several times) since there are no DX11 benchmarks so far: news item on Tom's Hardware. Wow, we made it.

• Support of OpenGL 3.2 (MSAA on scattering and SSAO; support of signed textures for normal maps).
• Added new mesh_tessellation_paint_base base material.
• Granted access to ObjectMeshSkinned via C++ API.
• Updated C++ API documentation.
• Fixed bug with parsing '#' symbol inside define-disabled blocks in scripts.
• Memory allocator is more verbose now.
• Decreased CPU cache miss count.
• Replacing the 'inline' statement by '__forceinline' provided a huge performance speedup under Windows.
• Refactoring of XML parser.
• Less system memory consumption on DirectX 9.
• Empty maps can be declared as (:) in UnigineScript.
• Refactored KeyLine system, please refer to the documentation for more info.
• Fixed crash of import plugins on surfaces with zero vertex count.
• Fixed batch changing of light options in UnigineEditor.
• Improved seams removing algorithm for ResourceEditor.
• ObjectGrass intersects with the parent object with the use of intersection mask.
• Updated documentation on lighting ("Principles of Operation / Lighting and Shadows" section of the manual).

Here is a preliminary screenshot from the upcoming DirectX 11 benchmark based on Unigine:

The demonstration of the benchmark will be held on the major forthcoming event, stay tuned for more news.

• Tessellation support under DirectX 11.
• Tessellation support under OpenGL on ATI DirectX 10 level cards.
• Added hull and domain shaders for tessellation.
• Added "render_profiler" console variable that turns on/off performance profiling of render postprocesses.
• Fixed OpenCL initialization (headers were silently updated by Khronos Group).
• Detail textures can use the second UV channel (it can be selected in the "States / Options / Detail" drop-down menu).
• Added mesh_tessellation_base material for objects with hardware tessellation, it supports tessellation masks and height textures.
• Fixed UnigineScript bug with disappearing of "this" by complex inheritance.
• Reloading of meshes with different surfaces in MeshViewer; minor usability improvements.
• Added EXT_texture_snorm extension support.
• Added the distance for disabling occluders.
• Simplified SSAO for low shader profile.
• CUDA headers updated to version 2.30.
• Updated documentation on sound ("Principles of Operation / Sound" section of the manual).

No tesselation, simple normal mapping:

Tesselation:

No tessellation, wireframe:

Tessellation, wireframe:

By the way, this art asset will be used in our upcoming real-time demo, which is to be released in October.

PS: Here are some numbers considering performance of CUDA and DirectCompute: Unigine Crew blog.

• DirectX 11 render is almost ready (tessellation feature still needs to be implemented).
• Shader Model 5.0 is supported now, i.e. the following six types of shaders are available: vertex, hull, domain, geometry, pixel, compute.
• Switch to August 2009 DirectX SDK (don't forget to update your DirectX installation).
• HDR, glow and SSAO are implemented via DirectCompute in DirectX 11.
• Improved performance of DirectX 10 render.
• Textures can be binded to any type of shaders now.
• Renamed d3d10_render_use_*_level_1 console variables to d3d10_render_use_*_level_101.
• Increased maximal shadow map dimension to 8192 in the editor.
• Added cage feature to AmbientMapper (works similar to the NormalMapper one).
• Fixed ambient occlusion bug with enabled impostors.
• Improved SSAO that takes into account normal map data and provides better quality and reasonable performance (requires re-adjusting parameters).
• GUI rendering speedup.
• Updated HDR post-processes (refactoring, improved performance).
• Added HDR shaft flare effect.
• Detail textures can use 1st or 2nd UV channels for all meshes.
• Plugins for Maya 10.0 (2009).
• Fixed bug with physique modifier in 3dsMax skinned mesh export plugin.
• ObjectGUI without background isn't blurred by the DoF filter.
• Warm start of physical joints.
• Improved freezing of physical objects with joints.
• Added "softness" joint parameter to be used along with "restitution" for fine tuning (use with care, it can affect joint stability).
• Reduced memory consumption by physical contacts data.
• Collision detection speedup.
• Fixed bug with referencing to deleted objects in UnigineScript.
• Garbage collection for objects of extern C++ classes in UnigineScript, use class_manage(obj) function in scripts to register an object for automatic memory management, or use additional arguments of setExternClassObject() or Variable constructor; refer to the documentation for more details.
• Added functional constructors (Unigine::ExternClass::addConstructor() with two arguments) and destructors (Unigine::MakeExternClassDestructor()) of external classes to be exported in UnigineScript via C++ API.
• Faster interconnection between C++ API and scripts.
• Added integration sample for RakNet high-level networking library (source/samples/Network), see "Programming / Application Samples / Network Sample" section of the manual.
• Added network chat sample (data/demos/chat).
• Updated C++ API documentation.
• Completed documentation on UnigineScript library.

By the way, it seems that mesh skinning via compute shaders is faster than stream out under DirectX 11.

Improved SSAO in action:

HDR shaft flare post-effect:

PS: Massive reinforcements of our team has arrived: Pavel Kurinnoy (tools developer), Evgeniy Yundin (QA engineer) and Alexey Maslennikov (sales manager).

• Huge physics performance boost.
• Full repeatability of physical simulation even on different CPUs.
• Time snapshots of physics (time rollback is required for networking).
• Joint limits visualization.
• Removed "accuracy" flag for joints.
• Added "collider" flag in nodes; when it is set to off the object doesn't participate in physical simulation (enabled by default).
• Radius of physics simulation can be decreased without causing problems.
• Multi-threaded simulation of physics; it can be distributed among several CPU cores now. Change of physics_num_threads console variable doesn't require engine restart, it's applied on the fly.
• Added continuous collision detection (CCD) for spheres and capsules.
• Added PhysicalForce object for simulation of point forces (attracting and repelling).
• Added new physics samples.
• Improved wind formula for vegetaion.
• Added math and comparison operators for Variable class in C++ API.
• Updated Ogg Theora loader that supports multi-stream video.
• Added WidgetCanvas widget for drawing text, lines and polygones.
• Access to properties and materials by index.
• Refactored ObjectMeshDynamic with support of several surfaces.
• Added File class into C++ API for working with internal virtual filesystem.
• Added engine.profiler.isEnabled() and engine.profiler.getValue(string name) functions into UnigineScript.
• Removed the lightmap support from vegetation shaders.
• fade_power parameter is renamed into fade_attenuation for ObjectGrass, ObjectParticles and WorldCluster (don't forget to run scripts/Upgrade/upgrade.py script).
• Added support of Maya 10.0.
• Added description of node layers, node references and properties to the "Principles of Operation / Virtual Worlds" chapter of the reference manual.
• Updated C++ API documentation.
• Updated UnigineScript library documentation.

Physics module improvement is still in progress, there will be more updates on that later this month.

Here is the mesmerizing example of time reverse feature in physics:


Video demonstrating physics time reverse feature

PS: We have also started developing visual flow graph editor that will be used for both game framework and animation tree.

PPS: Creators of the Unigine-based "Syndicate-online" MMORPG has opened doors for participants of the second stage of the Closed Beta Testing. Read more on the official website of the game.

• Full transformations of point forces in particle systems, added 'rotator' and 'attractor' features.
• Unicode names of joysticks.
• Dedicated tree for objects with collision detection enabled.
• All fonts and textures can be shared between GUIs.
• Performance optimization for multiple ObjectGUIs.
• Added Qt-based integration sample with multiple windows.
• Deffered buffer is decreased in size for low shader profile.
• Transfer of user-specified classes between C++ API and UnigineScript.
• Billboards speedup.
• More compact variables in UnigineScript.
• Added new Expression class in UnigineScript, that can compile and execute arbitrary code in runtime.
• Minor performance improvement of clouds.
• Plugins for 3dsMax 12 (2010).
• Correct replication of NodeReferences during assignment of properties and materials.
• Added support of Cage mesh in NormalMapper, that allows to select a desired high-poly object.
• Height textures are renamed into parallax ones, use '_h' postfix instead of '_p'.
• Improved documentation on UnigineEditor and ResourceEditor.
• Support of AMD hardware tessellator in ResourceEditor via AMD_vertex_shader_tessellator.

Hardware tessellation is a very attractive technology, artists can waste hours looking at real-time change of low-poly models tessellation. Unfortunatelly now it is available in OpenGL with AMD cards only. However, later this year Windows 7 is to be released, that introduces DirectX 11 with support of hardware tessellation.

Short video on YouTube demonstrating tessellation

PS: We also work very closely with AMD video driver team now, these guys provide really useful help with fast driver bugfixes for both Windows and Linux versions.

PPS: Our CEO (Denis Shergin) and CTO (Alexander Zaprjagaev) will attend GDC Europe, which will take place in Cologne, Germany this August. Please contact us via info@unigine.com to make an appointment if you would like to meet.