Development Log

Recent changes:

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

What's new:

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

What's new:

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

Recent changes:

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

Unigine is also a heart of another game, which has been developing in our studio for 3 years. We are still making some experiments with the gameplay, so it's hard to name genre of the project yet. However, we can say for sure that the project will have eye-candy graphics. Game world isn't very huge because we have limited resources of our content team, but it's large enough to prove that Unigine is capable to handle detailed worlds.

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.