Global Illumination

A new, real-time global illumination based on precomputed spherical harmonics allows to render high-detail diffuse lighting with interreflections and angle-dependent specular highlights. It is fully interactive: soft environment light illuminates both static geometry in the scene and dynamic objects moving around it.

The stunning lightmap-like quality is achieved by using automatically generated LightProbs. With such precomputed lighting approach, you can have full control over general GI settings (via Render -> Parameters -> Global parameters) or fine-tune GI component intensity for each separate location.

Global illumination is available across all APIs and is well scalable performance-wise. Simply generate a necessary number of LightProbs using Tools -> Illumination and specify render_light_prob 1 console command.

As you can see, GI makes a huge difference: it brings a truly photorealistic visual quality to a scene. New samples with sun and local lights can be found under demos/gi/ directory.

Render

• New mesh_wire_base material can be used to create thin objects like wires, ropes, nets, etc. Since a rendered line doesn't get smaller than a pixel wide, it always looks continuous when viewed from a distance.
• Huge speed-up for skinned meshes with a lot of disabled strafes. Now it is possible to create characters with a large number of equipment combinations without compromising performance.
• Added video_renderable console command that enables hardware anti-aliasing for:
  • GUI widgets
  • Flash movie clips
  • iOS mobile devices
  To activate this mode of AA, use the following console commands: video_multisample 4 && video_renderable 1 && render_skip_post_materials 1 && video_restart"
• Procedural textures for custom post-process materials can now be of various formats: RGBA8, R16F, RG16F, RGBA16F, R32F, RG32F, RGBA32F. You can easily choose the required data precision for simulation.
• It is possible to render custom procedural post-process materials assigned to mesh surfaces via engine.render.renderProcedurals() function. (Post-process materials assigned as Render or Post viewport materials are rendered automatically.)
• Fixed a crash when an application window is resized to zero height and width.
• More verbose render_manager_list console command. Now it prints detailed information on textures used in the currently loaded world (information on texture format and used compression, if any, as well as texture dimensions and a file size).
• Added video_fullscreen 2 mode to render an application window without decorations.
• TTF fonts are now handled correctly despite of any font atlas texture issues.
• Fixed a bug with incorrect LightProb lighting calculation.
• On Mac OS X shadows from all types of light sources are correctly rendered.
• Fixed a pixel-size contour artifact for surfaces with parallax mapped material assigned (for example, on decals).
• Fixed a small bug with incorrect DXT1 color and DXT5 alpha compression/decompression.
• Added full support for ETC2 texture compression (with T, H and planar compression modes supported out of the box). The compression quality of ETC2 algorithm is better than DXT, ATC or PVR ones.
• Fixed an aspect ratio bug for horizontal and vertical split stereo modes.
• Added an interlaced lines stereo rendering mode (with custom view frustums support). It is enabled via the following start-up option: main_x* -extern_define STEREO_INTERLACED. Stereo parameters can be tweaked in the main menu -> Stereo tab. In scripts, you can use STEREO_INTERLACED define to wrap mode-related code. (To customize a shader for a specific monitor, you may need to swap color_0 (left eye image) and color_1 (right one) variables in a fragment shader.)

Interlaced stereo is used with interlaced monitors and polarized glasses.

And here is new mesh_wire_base material for thin lines and wires.

Nodes

• Added WorldExpression::setPostUpdate() function. It indicates that WorldExpression is updated after all other nodes. For example, this flag is useful to draw nodes strictly in front of the camera (since this way WorldExpression always receives the updated Player's transformations). Check new samples/worlds/expression_04 sample.
• Fixed a bug on incorrect cloning of NavigationMesh. Now NodeReference with NavigationMesh can be safely loaded.
• Added add/removeExcludeNavigation() and add/removeExcludeObstacle() functions into PathRoute class, not to take the specified navigation areas and obstacles into account when finding a path.
• NodeDummy is smart enough to calculate its bounding box (that is comprised of all its children BBs) each call.
• Per-node properties are now stored in the node file.

Objects

• Added a coarse mask texture for ObjectTerrain. This option allows to boost terrain rendering performance by using only 3 coarse textures: a diffuse texture, a normal map and a mask. With a coarse mask only, up to four detail materials are supported for the whole terrain. (You can additionally assign a per-surface mask to use another set of detail materials in a given location.)
• Added Cast shadow option for terrain surfaces. It enables shadows from all light sources on selected surfaces.
• Fixed a float precision issue when a terrain object is saved/loaded (this bug sometimes caused cracks between surfaces).
• Added Route type for particles. Route particles can be used to create tracks from moving objects (for example, foam after a ship). They are similar to the previous implementation of Flat particles.

Dynamic Meshes

• Improved internal render buffers usage for ObjectMeshDynamic. You can set dynamic flag in the constructor if a mesh is going to be changed every frame. Now you can even create a particle system based on it, and it will still be very fast.
• In addition to triangles, ObjectMeshDynanic can now be used to render lines and points. The rendering mode is specified on the per-surface level via setSurfaceMode(). Check it with new samples/objects/dynamic_03 and dynamic_04 samples.
• Added ObjectMeshDynamic::addLineStrip() method to create a sequence of connected line segments.
• Per-surface collisions with ObjectMeshDynamic are now always correctly calculated (be careful, since they are expensive). There is no collision detection for point and line modes.
• ObjectMeshDynamic methods getSurfaceBegin() and getSurfaceEnd() now return an index number of the element (a triangle, point or line) instead of a triangle number.
• Added samples/shaders/particles_00 example based on ObjectMeshDynanic. There, particles are created using ObjectMeshDynanic points and are converted into polygons using a geometry shader at a very high speed.
• Added samples/shaders/particles_01 for extremely efficient GPU particle simulation.

More than 65500 of animated particles simulated on GPU using dynamic meshes:

UnigineScript

• Now call() can be used for calling virtual user class functions.
• A call stack size is increased to 1024 calls. Assertions on stack overflow are added.
• Added set_extern() function to inherit a custom user class from an arbitrary C++ base class.
• Fixed a bug when accessing private variables from derived classes.
• All queued console commands can be executed immediately via new engine.console.flush() function. Be careful, since forced execution of some console commands (world_load, world_quit or state_restore that reload a currently executed script) can lead to a crash.
• A function that sets GUI callbacks can now be safely called from a different Unigine script (for example, a system script function called from a world script).
• engine.filesystem.loadPackage()/removePackage() can be used to load/unload UNG and ZIP archives on demand. These archives can be located outside data directory if an absolute path is specified.
• Fixed a bug with mouse cursor flickering in MOUSE_SOFT mode: a system script doesn't handle the mouse when the editor is loaded.
• A node state can now be safely saved/restored via save/restoreNode() in run-time using the same object instance identifier for the restored node.
• Script exceptions are now properly handled on Android and PlayStation3.

High-Level Systems

• Added tracks to control materials and properties for each node instance in Tracker (node -> object -> material/property).
• If complex track tracks with a huge number of parameters inside are used, they can be optimized by setting Discrete mode. With this mode enabled, a track is applied to a scene only if its parameters change (that is, calculations are performed only in case track-controlled parameters need to be reset). A Continuous mode is the same default mode as was used by the engine before.
• Syncker server can now be run on Mac OS X machines.

C++ API

• Added support of point and line per-surface rendering modes into Unigine::ObjectMeshDynamic class.
• When initializing the engine instance, application path and home path can be specified. application path specifies a directory where all engine resources are stored, while home path is added to project path (home/project) to store rewritable cache files, log and configuration files.
• Fixed a bug with incorrect display of UTF-8 encoded window titles under Linux.

C++ plugins

• EyeFinity plugin is renamed into AppSurround. Now it can render Unigine application across three monitors both on AMD and NVIDIA graphics cards.
• Interface plugin windows, when their location is restored on application start-up, always appear within available screen space.
• Interface windows can now have correct UTF-8 encoded titles under Linux.
• Fixed a hang-up of Interface windows when they are closed via a system button on a titlebar.
• Interface plugin no longer causes a crash when a null rendering API (not to render the application, for example, for servers) is set.
• FileServer prints "Socket is closed" when the connection to a client is lost.
• Main menu settings of AppWall and stereo plugins (such as Separation, Angle, etc.) are now saved into the configuration file to be automatically used on the next engine start-ip.
• Source files of all App* plugins were moved into source/plugins/App directory.
• Now the full source code of App3DVision and App3DSurround stereo plugins is available in source SDK, since NVIDIA granted public access to 3DVision-specific NVApi functions.

Mobile Platforms

• Added full support for iPhone 5.
• Added support for the retina resolution for iPad 3.
• It is possible to get a native screen resolution of an iOS device (for example, for device type identification) via engine.tablet.getWidth() and engine.tablet.getHeight(). These functions take an aspect ratio into account to return correct screen dimensions.
• Java functions on Android can be called directly from Unigine script via engine.tablet.call("com/unigine/crypt/class_name","function_name") (where com.unigine.crypt is a package that contains a class class_name with a method function_name). No arguments can be passed for a called Java function and it should not return any value.
• And vice versa, functions a from a system script can be safely called from Java via runFunction("system_script_func").
• Home path on iOS devices is now set correctly by default. Resources and cache are now saved into it without any problems.
• Fixed a bug with an upside-down screen orientation on the first run of the application on iOS devices.
• A Simple water shader for mobile devices does not take into the account water node orientation when rendering waves.
• Fixed precision problems for a water object on iOS devices when it is far from the origin of coordinates.
• An external screen for iOS devices can be enabled by setting EXTERNAL_SCREEN define in GLESAppTablet.mm.
• New Xcode with iOS 6.0 SDK is now required to create iOS builds.

Flash

• Added full support of custom ActionScript classes (class inheritance is also supported). With this option it is easy to create a custom set of Flash widgets for your projects. Check this feature on samples/widgets/flash_06 sample.
• Great performance speed-up of the ActionScript virtual machine. A value of the variable is now accessed at run-time extremely fast.
• Big amount of data can now be passed from ActionScript side to UnigineScript as Array. setArray(), getArray() and isArray() functions are now available for WidgetFlash. Check it on samples/widgets/flash_05 sample.
• Frame rate of Flash movies is automatically decreased if FPS of the scene is lower than it.
• gotoFrame() function correctly stops a movie clip in all cases.
• WidgetFlash can now load fonts without predefined glyphs.
• Fixed a bug with incorrect wrapping of scaled text.
• Fixed a bug with incorrect atlas texture wrapping.
• Added support for getDepth() and swapDepths() methods of MovieClip to manage movie clip depths. Check it on samples/widgets/flash_03 sample.
• Added support for Number object and its methods valueOf() and toString() (both implementations, with and without arguments).
• Strings are now automatically converted into String objects, numbers into Number ones.
• No more memory leaking issues on shutdown, the engine deletes all allocated resources.

A custom set of reusable buttons can be created with ActionScript classes support.

GUI

• Fixed a bug when WidgetSprite is loaded from UI file (Z-axis offset was incorrectly added to the widget).
• Fixed a fast navigation option (via Tab/Shift+Tab) between the fields for WidgetEditLine in external interfaces.

ResourceEditor

Collada import is improved with the following features:

• Speed-up of DAE files loading.
• Normals are now automatically calculated for imported models, if necessary.
• Skinned models are converted into static geometry with the correct pose transformation.

And there is more to come: Collada plugin will soon support import of materials, node hierarchy and animation.

Tools

• Added multi-selection for surfaces of terrain object. Now you can easily remove or enable/disable options for all surfaces at once.
• Added support of PlayerSpectator and PlayerActor into the editor.
• Decals are saved as additional surfaces when a mesh they are projected onto is exported in the editor.
• Fixed printing of invalid Validator errors when meshes are used only in ObjectMeshCluster or ObjectMeshClutter objects.
• Textures automatically compressed by the editor are now updated when a file is modified at once, without the engine restart.
• Editor pathfinding icons are disabled if a world is not loaded.
• Fixed a bug with incorrect location of NodeReference editing panel after the main application window is resized.
• Filesystem modifiers are correctly handled when using editor automatic texture compression feature.
• ImageView console tool now shows alpha channel on the black background.

Sound

• Added support for XAudio2 sound system. It is available both for Windows and WinRT out of the box.
• All sound settings can be applied immediately via engine.sound.renderWorld() with force argument set to 1. A sound system has its own fixed frame rate (30 fps), while a script update rate can be much higher, which sometimes cause commands being skipped, unless a forced update is used. As another example, this function can be called to pause the sound from a system script callback when the app is minimized on Android devices.

PlayStation 3

• Added full support for triplanar, terrain and grass materials.
• Fixed a bug with incorrect bounding frustum culling.
• Fixed threads hang-ups.
• Tracker and LUT-generation tools are not available in the editor mode due to strict memory limitations.
• System mouse option is not functional on PlayStation3.

Other

• Engine configuration file can be saved/loaded at any time via config_save and config_load console commands.
• Added noscreenshot argument for state_save console command that prevents the screenshot creation when a world state is saved. To use it, type in the console: state_save my_save_name noscreenshot.
• Small memory allocations no longer cause memory corruption errors.
• Fixed a bug with incorrect normalization of very small vectors.
• Debug builds for WinRT are not supported due to compiler issues; only asserts and world/system/editor_analyze console commands are available for debugging.

PS: This update is surely rich on new features. So many changes in just a single month!

Network cluster system

A new Syncker is a scalable multi-node rendering system that makes it easy to create highly immersive CAVE systems or large-scale visualization walls on a computer cluster synchronised over the network in real-time.

Simply connect multiple computers over LAN and turn your monitors into one high-resolution seamless display with a Unigine application running on it at lightning speed. It does not matter if these computers are running on Windows, Linux and Mac OS X at the same time, as Syncker works even across different platforms. Moreover, virtual environments can be of any monitor configuration, since all viewports are fully configurable.

Here the main application is run on Linux and connected to it are computers with Windows 7, Windows 8 and Mac OS X:

Be sure to check the documentation on how to run Syncker and new samples/syncker samples in SDK!

Render

• Added Ambient light material option for highly optimized rendering of grass, water, leaf and terrain objects. When checked, the world light pass is automatically disabled and objects are rendered only once during the Ambient pass. One rendering pass spared can give a good performance boost in case an object in question has many polygons. Unlike in the previous implementation, shadows are supported. For grass this option also allows to get rid of any light flickering on the edges.
• Light probes are now faster and do not decrease performance even if there is a bunch of them.
• Flat now do not change their orientation with Emitter based flag unchecked.
• Fixed incorrect orientation of environment cube maps.
• Now it's possible to use any blending options for ObjectWater and ObjectWaterMesh or even create non-transparent water. By default, Scr: one and Dest: src alpha flags are currently used. If you use water nodes in your projects and its blending does not look right, please check its blending options: go to Nodes panel -> Surfaces tab, click Material edit icon and set a proper default value. (Or you can go to *.world file or *.node file and delete <blend> tag for a water node).
• Decal distance in Render settings now works correctly.
• Optimized view frustum culling for decals results in performance increase. Check it on a new stress test sample samples/stress/decals_00.
• Derived materials can override texture options for any custom materials (like wrapping, anisotropy, texture filtering).
• ObjectWater and ObjectWaterMesh wave parameters can now be controlled via four simple functions: setWaveAngle(), setWaveSpeed(), setWaveLength(), setWaveHeight().
• No more issues when setting a texture image in run-time for inherited materials via Material::setImageTextureImage() with dynamic flag set to 1. Base materials are not affected in this case.
• ObjectMeshSkinned can now access bones and vertex weights by a vertex number (ObjectMeshSkinned::getWeights and ObjectMeshSkinned::getBones()).
• Added support of OpenGL compute shaders. This functionality can be used in custom shaders, if necessary.

Physics

• 2D or even 1D physics is now easily possible. Added BodyRigid::setLinearScale()/setAngularScale() functions that set a multiplier for linear and angular velocities per axis. If one of vec3 values is set to 0, movement along this axis will be restricted. For example, for 2D physics with movement restricted to a X axis, set the body's linear scale to (0,1,1) and the angular scale to (1,0,0). See a modified sample samples/physics/reverse_01.
• Body can be easily moved and oriented via setPosition(), setRotation() and setDirection() without having to deal with a transformation matrix. (These functions are similar to node's ones.)
• Fixed an issue with incorrect default joint axis created for cylindrical, prismatic and hinge joints.

GUI

• Added functions for all WidgetSprite* widgets to change the internal render buffer size (and accordingly, widget size) in real-time. Previously this option was available only in constructors.
• Fixed a crash in WidgetDialogFile when attempting to browse files up the disk root folder level.
• Added support of 3d coordinates for vertices in WidgetCanvas. See a new sample samples/widgets/canvas_02.

Flash

• Improved automatic texture atlas generation (now it's smaller in size).
• Ensured correct rendering of nine-slice grid on rectangular shapes with a texture in all cases.
• Fixed an issue with onEnterFrame() actions: now they are called immediately after MovieClip is created.
• MovieClip can be safely deleted, if necessary.
• Fixed incorrect creation of single-element arrays.
• Mouse is correctly handled inside areas hidden by a clipping mask.
• Texts are now always correctly scaled and resized.

Network

• Now it's even posiible create a FPS network game only using UnigineScript. Socket class can be created for TCP and UDP protocols (added type flag in the constructor: SOCKET_STREAM and SOCKET_DGRAM respectively).
• Added Buffer::compress()/decompress() functions to compress and decompress buffer data in run-time using gzip.
• Added Stream::readStream()/writeStream() functions to copy files, buffers and sockets directly into one byte stream. These functions are more memory efficient than Stream::read()/write().

UnigineScript

• Fixed an over-optimization issue for floating point values. Now even values that differ by less than EPSILON are correctly handled as two different values.

C++ API

• Added UnigineWorld class to access engine.world functionality from C++ side.
• Added UnigineWorld::getNodes() function to get all nodes in the world (as well as created via scripts).
• Added UnigineBuffer::compress()/decompress() functions to compress and decompress buffer data in run-time using gzip.
• Added UnigineStream::readStream()/writeStream() functions to conveniently copy files, buffers and sockets directly into one byte stream.
• UnigineSocket class can be created for TCP and UDP protocols (added type flag in the constructor).
• When constructed, the engine correctly changes a data directory if an external path is specified.
• C++ API functions return smart Ptr pointers instead of raw ones.

Mobile platforms

• Added new texture compression formats for OpenGL ES 3.0-compatible hardware:
  • ETC2 (better color compression quality than ETC1, but no alpha)
  • ETC5 (the same, but with alpha stored in EAC1 format)
  • EAC1 (single channel texture compression for storing gray-scale values)
  • EAC2 (two channel texture compression, for example, for normal maps)
• iOS application now creates a depth stencil texture for the depth buffer (it's used for correct handling of Flash movie masks in WidgetFlash and WidgetVBox instances with stencil flag).
• Removed artifacts with texture filtering and precision issues on mobile GPUs that support for different precision on the hardware level.
• Telnet terminal can now be available in release Android and iOS builds if they are created via scons or build.py with terminal flag set to 1.

Tools

• Added MeshSkinned functions to control weights and bones into USC Interpreter (setter function MeshSkinned::setBones() to set bones for a vertex and MeshSkinned::setWeights() to set weights for a given vertex and corresponding getters: MeshSkinned::getBones() and MeshSkinned::getWeights()).
• In Archiver backslashes are automatically replaced by forward slashes to avoid any issues when working under Linux with UNG achieves created in Windows.
• Fixed a bug with MeshViewer panels (Surfaces, Materials, Bones) in ResourceEditor.
• Fixed a bug with ImageView tool running on a new Mac OS X 10.8 version.
• Validator generates no unused resource error if a NodeReference is used only in WorldCluster and WorldClutter.
• Improved the quality of DXT5 alpha compression (though the speed of compression has decreased).
• Added VCXProj generator for WindowsRT.

High-Level Systems

• Tracker is now fully compatible with double precision builds.
• ObjectWater wave parameters are now available in Tracker.
• New Unigine::Widgets::Widget::isChild() function checks if a given widget is a child of the widget that called this function.
• Added Unigine::Widgets::Widget::setCallbackAccel() function to handle hot key combinations.
• Added Unigine::Widgets::Widget::setPosition() function that correctly sets positions for widgets both in internal and external (created via Interface plugin) GUIs.
• Fixed a small bug with hiding of Interface plugin windows in Linux. Now the window state changes to hidden immediately.
• Vertical synchronization is disabled for Interface plugin in Linux which fixes an issue with a performance drop on NVIDIA drivers.
• Added a new core/scripts/projection.h script to divide the view frustum into multiple viewports. Additional compensation for monitor angle and bezel is supported. See samples/render/viewport_01 and samples/render/viewport_02 for examples. This script is also used for monitor walls (AppWall), 3D stereo rendered across several monitors (NVIDIA 3D Surround) and new Syncker.

Other

• Object::getIntersection() now returns an intersected triangle (a triangle number is the last value in the return array).
• Node::getNodeReference() function renamed to Node::getPossessor(). Now this function can return NodeReference, WorldCluster or WorldClutter if they are a container for the given node.
• Added engine.filesystem.isPackageFile() function to check if a file is present in a package and engine.filesystem.getPackageFileName() to get its name.
• Added Thread profiler that shows information on pathfinding and sound usage. It can be enabled via show_profiler 5 console command.
• Fixed incorrect abbreviation used for megabytes (Mb changed to MB).
• Fixed incorrect parsing of backslashes in XML (now slashes can be safely used for all resources stored into XML files, such as node names and data, material names, properties, etc.)
• Fixed a bug occurring after deleting and adding a new root node for NodeReference. Now the position of the new root can be safely reset to zero and this does not affect the position of the node reference itself.

Render:

• Added Overlap and Overlay modes for detail materials into mesh_terrain_base material. Now caves, cliffs and other meshes can have the same detail texturing as a terrain does.
• Improved support of geometry shaders on Mac OS X. Now wireframe mode and bokeh DOF are supported on this platform.
• Added SHADER_LANGUAGE definition to define a version of OpenGL and OpenGL ES shaders.
• Engine profiler and engine messages are now always rendered on top.
• Fixed incorrect rendering of static reflections for water.
• WorldOccluderTerrain now properly works with reflections (for example, on the water).
• Increased the number of HDR cross flares up to 32 (beware, high number of flares can cause a FPS drop on low-performance hardware).
• Fixed an issue with normal map orientation for one of the projection faces for mesh_triplanar_base material.
• Fixed an issue with triplanar projection for mesh_triplanar_base and terrain_base materials.
• Added an option to change normals rendering mode for mesh_overlap_base material (States -> Substitute option). Normal maps of an underlying and overlapping material are either combined together (by default), or only the overlapping material normals are used.
• Added support of two background cube map textures for sky_base material.

Mobile Platforms:

• Added Retina display support for iPhone 4 and 4S.
• The loading time of Android applications with a large number of files in assets folder is dramatically improved.
• On Android, custom project data can be stored into a folder on a SD card (specified via project_name start-up option).
• On Android, configuration file (unigine.cfg) can now be stored under assets folder.
• Lifted a limitation on screen resolution for Android applications. Now you can set any screen width and height, no matter what the physical screen resolution is.
• Improved exception handling and RTTI support on Android.
• Eliminated an issue with random crashes on Android.
• Added d3d119_render_use_rgba8 console command to use RGBA8 format (instead of R5G6B5) for all color buffers. It is applicable for OpenGLES and DirectX 11 renderer of DirectX 9 feature level. This option increases rendering speed, decreases memory usage (up to 2 times lower) at the cost of small quality degradation (artifacts are possible when rendering transparent objects). It is enabled by default.
• Status bar on iOS devices is now automatically hidden.
• Added detection of Qualcomm Adreno 320 graphics chips.

UnigineScript:

• Scrips are now faster by 10-20 per cent. This speed-up is especially noticeable on platforms with small cache memory (mobile tablets and devices).
• Improved performance of all callbacks: world, physics and GUI callbacks, as well as calls from Flash (ActionScript) to script are much more robust.
• Fixed a file size bug by saving and restoring the world state multiple times when the editor is loaded.
• Added a function to clear a loaded GUI dictionary with a localized interface (engine.gui.clearDictionary()).
• No lags when pausing/resuming playback of Theora video files.
• Fixed a crash on deletion of ObjectBillboards and WorldCluster nodes.
• Any of high-level Unigine::Widgets can be used to create an interface for editor plugins. There is no need to explicitly include them via #include directive.
• Fixed a bug with non-updated messages in Unigine::Widgets Dialog widgets.
• Small speed-up of all GUI widgets, faster rendering of fonts.
• Huge memory deallocation speed increase. On Unigine stress test samples with heaps of objects, world shutdown is now 15x faster.

Flash:

• Increased performance of WidgetFlash: for example, interfaces in samples/widgets/flash_* now work 2 times faster.
• The number of draw calls for Flash is significantly decreased. Polygons and lines are batched when rendered. A texture atlas is automatically created for all textures smaller than 256x256 pixels in size (only non-tiled textures) to increase the rendering speed.
• Fixed a bug with incorrect scaling of rich text set via WidgetFlash::setFontScale().
• Added functions to get information on the number of triangles, lines and draw calls required to render a Flash movie widget: getNumTriangles(), getNumDips(), getNumLines().

Other:

• Improved detection of the number of available CPU cores for all Linux-based platform (Android included). This allows for more efficient load balancing.
• Added a new Interface color chart into the performance profiler that shows statistics on rendering time of GUI.
• Start-up option project is renamed into project_name.
• Added a new sample with mesh_triplanar_base material: samples/materials/triplanar_01.
• Fixed a minor bug with incorrect parsing of hspacing and vspacing arguments for text in UI files.
• Fixed a bug with crashes on multiple successive calls for engine initialization/shutdown.
• Added an additional implementation of Engine::init() function with a custom application path argument. Pass NULL value to skip this argument.

Documentation:

• Added an article on custom plugins for Editor (Tools -> Unigine Editor -> Custom Editor Plugins).
• Added information on LUT shading material: LUT generation tool (Tools -> Tools Panel -> LUT Generation Tool) and mesh_lut_base (Materials -> mesh_lut_base).

Windows 8: Full Support for Metro-Style Apps

We are glad to announce that Unigine engine is now fully compatible with Windows 8 Release Candidate SDK. To add a new Metro-style look and feel to your Unigine-powered application, all you need is to launch it. It just works.

Moreover, you can get support of upcoming tablets and other ARM-based mobile devices with Windows RT at zero development cost. Unigine already provides it out of the box - you simply take advantage.

Find the following features supported:

• Added full compatibility with Windows 8 Release Candidate SDK.
• Added support of Windows RT for ARM devices.
• Windows RT comes with NEON optimization support on the ARM platform.
• Added D3D11AppTablet class to initialize the video mode in Metro-style applications for Windows RT.
• Added support of DirectX 11 of feature level DirectX 9.1, 9.2, 9.3 to cover the whole range of next-generation Windows RT mobile devices.
• It is possible to set DirectX 11 renderer of DirectX 9 feature level (direct3d119) via video_app start-up option. With this feature, you can check how the application will be rendered on upcoming ARM mobile devices with Windows RT.
• Added detection of available CPUs for Windows 8, as well as a processor name.
• Added remote debugging support: connect to Windows RT application via Telnet application on port 8888 (telnet:8888).
• Added support of FileClient plugin for faster development iterations on Windows RT.

Render:

• Added billboards_cloud_base material for ObjectBillboards to create scattered clouds that interact with the environment and lighting (see a picture below).
• Improved volumetric clouds turbulence and added a Z-axis noise mask transformation to create higher-detailed, swirly volumetric clouds.
• Added hardware support of a custom mouse cursor for Windows, Linux and Mac OS X.
• Improved performance of DirectX 11 shaders.
• Removed Direct3D10 support.
• Added DirectX 11 renderer of DirectX 9 feature level (Direct3D119). This mode is set by engine if a graphics card is compatible only with DirectX 9. It will be mostly used for next-generation mobile devices, i.e. with Windows 8 on ARM processors. Shadows are not supported due to hardware limitations.
• OpenGL ES is no longer supported for default shaders (it's still supported for simplified shaders though).
• Simple shaders are automatically loaded if OpenGL ES or Direct3D119 renderers are used.
• Impostors were completely removed.
• Added separate Scale parameters for all HDR flares to avoid overexposure.
• Added render_manager_create_dummy_textures/meshes console commands. If set to 1 (by default), downsized textures and dummy meshes (without any vertex data, only surfaces are listed) are pre-loaded first at high speed. Full-sized textures and meshes with all geometry data are loaded only on demand, when they get into the view. This makes the world start-up much faster.
• Console command render_manager_list now prints a texture format name (it's useful for debugging).
• Added orthographic projection support for Widget manipulators.
• ObjectMeshClutter and ObjectMeshCluster are even faster for meshes with multiple surfaces.

ObjectBillboards with billboards_cloud_base material can be used to create foggy clouds that interact with environment and hide mountain peaks. As the sun changes it position, clouds are lit differently.

Mobile Platforms:

• Added full support of more mobile GPUs:
  • Qualcomm Adreno 220 and 225
  • Imagination Technologies SGX530, SGX531, SGX535, SGX540, SGX545
  • ARM Mali 400
• Added access to the hardware depth buffer and screen buffers.
• Added full support of Qualcomm compressed image formats: ATC1, ATC3 and ATC5.
• Added support of GL_NV_depth_nonlinear extension (a depth texture format supported on NVIDIA Tegra).
• Added a simple and fast water material into a set of simplified shaders for mobile devices.
• Improved Android application lifecycle: when Home button is pressed and the application goes into the sleep state, there is no battery consumption.
• Added support of Android lifetime functions into the system script: you can call resume(), pause() and stop() to control application when activity state changes.
• Added gles_render_flush_transparent console command for OpenGL ES renderer. It forces to flush GPU depth buffer between rendering opaque and transparent objects for synchronization purposes. For example, it is used to render water on some mobile devices.
• The system script sets filesystem modifiers for hardware-specific texture compression formats (PVR, ETC or ATC) based on the detected mobile GPU. It means the engine will automatically select a texture with hardware-supported compression, if appropriate files are found. For example, on Qualcomm devices, texture.atc.dds will be used rather than texture.dds (with regular DXT compression); while on Imagination Technologies devices, it will be texture.pvr.dds.
• Added Horizontal and Vertical stereo modes used for glass-free MasterImage 3D displays on mobile devices. They are enabled via extern defines RENDER_STEREO_HORIZONTAL and RENDER_STEREO_VERTICAL without any performance decrease. The same mode is selected in the graphics chip driver.

UnigineScript:

• Engine controls are now cleared on every world reload.
• Keyword using is now in the global namespace.
• Added save/restore state functions for Materials and Properties.
• Added a function to set a namespace name for Expression, making it possible to call Expression methods from the outside.
• Splash screens can use an image instance, making it possible to create and change splashes dynamically.
• Added full access to Unigine::Widgets font parameters.
• Added functions to get information on ObjectMeshSkinned vertices and indices.
• Added functions to preallocate vertex and index buffers for ObjectMeshDynamic and ObjectBillboards (see allocateVertex() and allocateIndices functions), which make object creation faster.
• Added color clamping for visualizer primitives (see engine.visualizer.render*() functions with color argument).
• New parser option: it is possible to use assignment operator for #define (DEFINE1=DEFINE2) and set it via include directive (#include DEFINE1, by which DEFINE2 will be actually used).

C++ API:

• Fixed a compilation bug in C++ API samples.
• Added Unigine::ObjectBillboards interface.
• Added an option to force reload of filesystem packages via FileSystem::reloadPackage().

UnigineEditor:

• Added Stars generator based on ObjectBillboards (ObjectBillboards node -> Stars tab). It uses FK5 stars catalog format; see a new billboards_03 sample.
• Fixed a bug with canceling of NodeReference changes in the editing mode.
• Added an option to change the root of the NodeReference.
• Added ObjectSky tracks into Tracker.
• Added shadow map size and translucent map size tracks for light sources into Tracker.
• Added a new track that allows for modifying a NodeReference root node in Tracker.
• Fixed issues with nested tracks in Tracker.
• Added an option to grab a screenshot of the scene only (no GUI, messages or the profiler) via F11 button.
• Removed SpeedTree plugin support.
• The application main window position is saved and restored after relaunching.
• Fixed an issue with restored Interface plugin windows on the engine startup.
• Fixed an issue with environment cube map calculation. Environment lighting coefficients are now normalized. Because of this, LightProb sources need to be re-baked (you can use Tools -> Batch option for that). If environment cubemaps are used in Tracker, they need to be reopened.
• Added seamless filtering for cube images in Tools -> Grabber.

New stars generator in action:

Tools:

• ImageDDS utilizes all available CPUs in a batch mode for faster texture compression (when multiple images are specified or imagedds.py is used).
• ImageDDS can scale images while preserving the minimum possible texture size (-ms option). It can be used for batch processing of images.
• Removed OpenCL and alpha-tested textures support from ImageDDS.
• FileServer can receive directory names as arguments to work only with selected folders (-d option).
• TerrainMesh generates a correct hight map even if there are overlapping polygons.

Other:

• Added support of Visual Studio version 11.0.
• Added a fast batch mode for Visual Studio (it is enabled by default; to disable it use scons batch=0 option).
• All console log messages are now shown in the VisualStudio debugger.
• Improved stability of file queries (archived and non-archived files are read in the same order).
• Much faster loading of resources over the network.
• File system modifiers can be used for directories. For example, you can create textures.atc and textures.pvr folders to store textures for different mobile devices (depending on the hardware-supported compression); or localization.en and localization.fr folders to store English and French localized files. After that, in scripts a directory can be specified simply as textures or localization and the engine will automatically select the one with an appropriate modifier.
• Added systems/socket_00 sample to test Socket class functionality: an HTTP request is sent to google.com and an answer is received.
• Fixed a bug with parsing of command line parameters in AppWall plugin.
• ObjectGrass, ObjectMeshClutter and WorldClutter can now intersect with a root node of the parent NodeReference.
• It's easy to add custom shaders now: every base vertex shader can include an external file set via VERTEX_SHADER definition.

Documentation:

• Added a separate article on Class Inheritance (UnigineScript -> Class System -> Class Inheritance).
• Added an article on post_filter_wet post-process material (Materials -> Postprocess Materials -> post_filter_wet).
• Added an article on Stars generator for Billboards (Principles of Operation -> Objects -> Billboards -> Stars Generator for Billboards).
• Updated information on Network plugin (C++ API -> C++ Plugins -> Network Plugin).
• Updated an article on ImageDDS tool (Tools -> ImageDDS).
• Updated an article on Using ActionScript (Programming -> Using ActionScript).

Flash:

Flash implementation is now at least two times faster! As tested on Oil Rush, the engine can easily handle even complex interfaces at higher speed. Moreover, you will find:

• Massive memory management refactoring for optimized performance.
• Extended support of ActionScript 2.0 functionality (see below).
• Built-in garbage collector for Flash objects: if unused, objects will be removed automatically.
• New function for WidgetFlash to set/get bitmap images to/from a Flash file.
• Fixed incorrect mouse intersection with movie clips.
• Added 9-slice grid scaling support for MovieClips and buttons. (See widgets/flash_03 sample.)

In detail, ActionScript 2.0 support has been extended to access:

• Stage object and its width and height properties.
• MovieClip methods loadMovie(), createEmptyMovieClip(), duplicateMovieClip(), removeMovieClip(), attachMovie(), hitTest(), getNextHighestDepth().
• Array method splice() and property length.
• String property length.
• Engine functions systemSet(), worldSet(), editorSet().

An example of Flash-based GUI:

Editor plugin system:

From now on, customizing the Unigine editor for project-specific needs is very easy. After a script with custom functionality is coded, adding new tabs into the default windows or new editor modules, as well as changing a set of editor features for different projects is just a few clicks away.
Editor plugins are loaded via Tools -> Plugins -> Add option. They are saved and automatically loaded on the next application start-up.

• A plugin is any *.cpp file in UnigineScript language.
• It should contain getName() function that returns a namespace name for the plugin (use this namespace for created GUI elements and callbacks).
• If necessary, you can also implement init(), shutdown() and update() functions for your editor plugin.

PS: Wow, that was quite an impressive list of changes. Stay tuned, there are a couple of big announcements to come later this summer!

Render:

• Added mesh_overlay_base material (useful for creating procedural rust or moss on objects).
• Optimized assigning of materials to object surfaces.
• Fixed video playback in 3D stereo mode under DX11.
• Added 'MaxShadowSplit' option for surfaces to skip rendering of high-detail shadow splits from LightWorld. (It is useful for small objects like stones, etc.)
• Fixed crash on render_manager_reload console command.
• Environment cube map texture is not in SRGB format from now on.
• Added the following modes for terrain detail materials: "skip" (not rendered), "overlay" (the old blended one) and "overlap" (without blending, the spread of such material can be additionally tweaked using "Value" and "Threshold" parameters). Overlap terrain material cannot be used together with triplanar mapping.
• Additional noise transformation parameter for sky volume clouds.
• Improved performance of dynamic vertex/index buffers on open-source drivers in Linux.
• Support of vertical synchronization in Linux.
• Renderer checks for EXT_texture_compression_s3tc extension availability on startup (a Mesa driver doesn't support it due to the legal issues).
• A mask for ObjectGrass, ObjectMeshClutter and WorldClutter is now editable in real-time.
• Fade color for fade post-process is now a normal color that is blended by the alpha component: zero alpha value means no fading, while the alpha value of one results in a solid-color screen.
• Increased the default values for Shadow bias and Slope parameters for all light sources.
• Added separate diffuse and specular color multipliers.
• Improved OpenGL ES initialization on iOS.
• Added support of iPad 3.
• Added support of hardware shadow maps (cast from LightProj and LightWorld sources) on mobile platforms.
• Added a wind direction vector common for all vegetation (grass and trees).
• Implemented OpenGL ES support in Linux.
• New way to generate procedural textures directly on the GPU. It allows for simulation of various visual effects; see new samples in data/samples/shaders: fire_00, water_00, bombing_00.
• Added a separate emission_color multiplier.
• Improved compatibility with a new NVIDIA OpenGL driver.
• Added 1/4, 1/2 and full (relative to the screen height) reflection map sizes for reflective materials.
• Added mesh_lut_base material with baked lighting (highly efficient for mobile devices).
• Added post_filter_wet post-process materials (for the effect of water trickling down the surfaces).

UnigineScript:

• Correct ExternClass variables casting on inter-script calls.
• Added inter-script calls sample: systems/system_00.
• Added more samples on WorldExpression usage: worlds/expression_02, worlds/expression_03.
• Configurable splash screens in core/scripts/system.h.
• "using" keyword searches for a given namespace through all nested namespaces up to the global one instead of searching only in the global scope.
• The number of available namespaces is increased to 65536.
• WorldExpression calls __constructor__() and __destructor__() functions on initialization and shutdown (it can be used for proper creation and deletion of created resources).
• EPSILON and NULL definitions are removed from Unigine::Skinner blocks.
• Widgets::Dialog is created in the external GUI, if it's available.
• Improved interaction of Widgets::Line and Widgets::Track.
• Added Widgets::Time class for time manipulation.
• Added Widgets::DialogMaterial, DialogProperty, DialogNode dialogs.
• Improved implementation of engine.world.isNode() and other similar functions: now they can receive both the object identifier and the object pointer.

GUI:

• ObjectGui and ObjectGuiMesh take into the account asymmetric frustum when calculating mouse coordinates.
• Default iFPS value for WidgetSpriteViewport and WidgetSpriteNode is changed to 0 (so it is updated at the rendering frame rate rather than a lowered one).
• Fixed infinite update of WidgetSpriteViewport when the iFPS value is low.
• Fixed issue with vertical flipping for WidgetSpriteMaterial widget.
• Fixed gradient texture calculation algorithm for Flash movies.
• Added Widget::set[get]MouseCursor() functions for correct switching of the cursor between multiple GUI interfaces.
• Added Widget::getParentGui() function to access a parent GUI object.
• Fixed crashing when the scroll space in WidgetComboBox was very small.
• Fixed texture and text arrangement for WidgetTabBox, WidgetListBox and WidgetTreeBox.

C++ API:

• Fixed crash on multiple Unigine::removeExtern*() invocations with the same argument.
• Added ArrayMap::Iterator class to enumerate all elements.
• Added Variable::getTypeInfo() function which describes variable content in details.

UnigineEditor:

• Added Tracker system (see details below).
• Added mask editor for ObjectGrass, ObjectMeshClutter and WorldClutter.
• Added 'Create mask' button for ObjectGrass, ObjectMeshClutter and WorldClutter objects.
• Added a random seed for WorldCluster generator.
• Added custom terrain brushes.
• Automatic compression of terrain coarse textures when the source textures are placed in the "uncompressed" folder.
• Fixed issue with the terrain lightmap grabber.
• Added PlayerPersecutor node (it is not movable until a target is assigned for it).
• Removed "Activate" button in PlayerDummy node. To test the camera view, open Camera window and switch to the selected player.
• Added basic LUT texture editor (Tools -> LUT) to generate textures with baked lighting.
• Added new icons for different nodes.
• Changed the default world settings.

Other:

• Added new vegetation samples optimized for flight simulators (samples/materials/leaf_02).
• Added a city rendering sample that shows how to use occluders for optimized rendering (samples/stress/occluder_03).
• Node::set[get]Data is renamed into Node::set[get]Variable. Old "data" is a simple string (stored in world and save files) now.
• Changed user data path for Mac OS X projects: home_path + "Library/Application Support/" + project_name.
• ObjectGrass, ObjectParticles, ObjectMeshCluster, ObjectMeshClutter and WorldClutter can be stored inside NodeDummy and still intersect with the parent geometry on the generation stage.
• Fixed wrong bounding space of NavigationMesh after the world is loaded.
• Fixed pathfinding route issues inside of a NavigationMesh.
• Added Maya 2012 plugins.
• Migration to new Xcode and iOS 5.1.
• All empty XML nodes are automatically removed from the world files.

Tracker

Tracker is a keyframe-based tool for creating sequences animated over time. It is used for adding dynamic gameplay elements or making in-game cinematic cutscenes. With Tracker you can:

• Easily create key frames for all nodes in the world, as well as in-game cameras and render settings.
• Set up day-night shift and weather conditions change.
• Switch between the cameras, change field-of-view on the fly and play sounds for creating stunning cinematics.
• Animate interactive objects in the game, for example, lights, doors and platforms.
• Apply post-processing effects such as depth of field, HDR, motion blur and color filtering. All these effects can be fine-tuned for each camera view.
• And much more.

Read more in the documentation: UnigineScript / High-Level Scripts / Unigine::Tracker.

Valley demo preview

Valley is an interactive demo that demonstrates optimized rendering of terrain with landscapes varying from grassy vales to snowy mountains. It comes complete with various vegetation (trees, bushes, different plants, grass) and rocks on mountain sides.

The preview version also features weather animations created with Tracker system:

• Day-night cycle with various weather conditions (cloudiness, wind, rain) is controlled in 'day_cycle_mixed' track. It combines all tracks listed below.
• Positions of sun and moon on the horizon are set in 'sun_rotation' and 'moon_rotation' tracks.
• Change of light conditions to create sunny and cloudy weather (animated light parameters, scattering, fog) are set in 'day_cycle_sunny' and 'day_cycle_cloudy' tracks.
• Rain (rain particles across the screen, splashes on the ground, scattering for a downpour) is controlled in 'rain_control' track.
• Wet surfaces post-process (render_filter_wet material) is controlled in 'rain_wet_surface_control' track.
• Wind (the speed and direction of wind, trees sway animation) is set in 'wind_force_control' track.
• Depth of field effect (focal distance change, different amount of blur) is controlled in 'dof_f2' and 'dof_f8' tracks.

The preview is available for engine licensees only.

First-person shooter prototype

A Shooter project is a single-player first-person shooter that can be used to get your own prototype up and running extremely quickly. If features all aspects essential for this type of core mechanics, so you can focus on implementing and testing of custom features, as well as creating new game levels. A Shooter project can be found under data/prototypes/shooter folder.