xaitMap

7f94ccac ba92 4333 bfc7 1e5b10e0fbe4

Website:
http://www.xaitment.com/e...

Developer:
xaitmnent

Launched:
Not specified

Status:
Active

Supported Platforms:
Windows, Linux, Xbox360, PS3

Languages Written In:
C/C++

Rating:
Not reviewed yet

Editor:
00000000000000000000000000000000 TechSchuey

xaitMap is xaitment’s AI software module for NavMesh generation, pathfinding and movement in games and simulations. It comes with runtime libraries with graphical tools that minimize the need for coding. Extra features include sectorized builds, analysis of multi-level 3D maps, geometry tags and support for multiple pathobjects.

Rapid Production

  • Automatically generates path data from your game world. You can use any type of geometry (physical ,graphical) from the game, feed it into xaitMap and produce your path data in no time.
  • Graphical UI for path data generation. xaitMap contains xaitMap Creator, which is a standalone tool for path data generation. xaitMap Creator uses the full functionality of the xaitMap Library for path data generation. (More -> Link to xaitMap Creator Features)
  • Automated path data editing. With automated path data generation it is hard to manually edit your path data. And when rebuilding the path data, you will lose all your manual changes. xaitMap, however, provides you with manual editing objects, which when placed into the world, do directly influence path data generation across multiple builds (like blocking areas to prevent path data in that section).

Efficiency

  • Fast path search. The path search algorithm has been optimized for every supported platform. Multiple path searches can be run on the same path data without memory penalty.
  • Efficient navmesh generation – better memory footprint and fantastic build times. The highly efficient NavMesh generation algorithm tremendously reduces memory size of the NavMesh, therefore the average node count and – in turn – speeds up pathfinding, as well.
  • Enhanced Treatment of Height Fields. xaitMap comes with a NavMesh generation algorithm that delivers a NavMesh of great quality; especially the NavMesh representation of height fields is way more efficient compared to previous versions
  • Incremental path data updates. Providing the same geometry with slight modifications, xaitMap detects changes automatically and updates only the parts of the path data where your geometry has changed. Build speeds increase dramatically.
  • Local path data updates. In modern games where static geometry is no longer static when considering the destruction capabilities of modern physic engines, it is necessary to do local updates to your AI path data. xaitMap can update path data during runtime when provided with the changed geometry.
  • Memory Streaming. When memory footprint is essential, you can use the integrated memory streaming mechanism to manually swap parts in and out of the path data or let xaitMap decide which parts are currently needed.
  • Big world support by using a sector-based path data layout. The game world will be split up in sectors. Sectors can be individually loaded in and out memory, lowering the memory footprint for the path data.

Flexibility

  • Customizable path search. The integrated path search algorithm can be fully customized, so that it can be used for path planning, which might consider hiding places, line of sight, etc.
  • Flexible pathsmoothing algorithms. In addition to three fast and reliable pathsearch functions, xaitMap comes with a funneling based pathsmoothing as well with a raytracer based pathsmoothing mechanism which give you great results.
  • Terrain types. By providing different custom terrain types for you game geometry, such as street, ground, mud, water, etc., the path data generation will take these types into account and uniquely mark path data with the underlying terrain type. This meta information can be used during the path search to favor or avoid certain terrain types.
  • Character shapes. By providing path data generation with character definitions, like the height and width of a character, path data will be only generated in areas where the physical limitations for the character are met.
  • Unit Radius Support. The NavMesh includes info about the radius of the unit which is supposed to use the navigation mesh for navigation, in addition to the multi-character approach which stores various heights of characters etc.
  • Multi-sized characters. One path data set can be used for different sized characters. This lowers the memory footprint for the path data where the level of detail will only be increased where needed.

xaitMap Library Features

  • C++ library. This will be linked to your game runtime for path finding or used in your tool chain to generate path data. C++ provides fast execution code and there are wrapper frameworks available for every modern script or managed language. Wrappers for .NET are available on request (C++/CLI mixed code assembly).
  • NavMesh generator. The path data is generated as a navigation mesh. The NavMesh data structure is fully accessible and comes with a large set of helpful functionality to locate nodes inside the navigation mesh.
  • Full terrain classification. The input geometry provided to the path data generation process can be fully qualified as either being walkable or non-wakable. Additionaly, specific surface types, depending on the actual geometry faces may be applied. The classification can be done programmatically with user defined functions on the geometry batch level.
  • Multiple character shapes per NavMesh. Different sized characters can be combined into one navigation mesh. The NavMesh generation increases the amount of detail for smaller / bigger units in areas where needed. Available navigation space is stored in the navigation mesh and will be used by the provided path search algorithms to search paths that meet the physical constraints of a single character or a group of characters.
  • No copy of geometry data on path data generation. Geometry data fed into the path data generation process is read only. The data layout of the input geometry can be fully described to support a wide range of memory layouts. Geometry instances can be provided to the path data generation. There is no need to duplicate geometry data for the path data generation process.
  • Multi-core support on path data generation. The path data generation process utilizes all available cores during the build. The amount of used threads can be set by the programmer, or the library can take care of the correct amount. The build can be run asynchronously and informs the main thread when it is done. Since geometry data is used in read only purposes, you can run path data generation even during game play in an asynchronous manner.
  • Character based path search. The delivered path search system deals with the different properties of a character. The path search will take into account the physical properties of the character and find a path that suits the character properties. The path search can also take different cost per surface types into account. Thus you can model path searches that keep entities on roads rather than using the shortest path.
  • Multi-sized character path search. The path search can take into account that one game character can have different sized shapes, i.e. standing and crouching models. Each character shape can have different costs, i.e. crouched is more expensive (slower) than standing. The path search will find the fastest path, rather than the shortest one.
  • Character group path search. Sometimes it is necessary to find a path for a group of differently sized characters. The path search system enables you to easily specify a group of characters and let the system find the best path for them, even while utilizing surface costs.
  • Different path search spaces. The library provides different path search spaces on top of the navigation mesh, which you can use to tradeoff between quality (accuracy) of the final path and performance of the path search algorithm. This enables the programmer to optimize the path search, depending on whether he is either doing an RTS game with hundreds of units or an FPS with around 30 units.
  • Fully customizable path search. The path search system can be fully customized by providing your own cost functions. The cost functions used in the preset path search for character based path searches can be reused and extended in these custom cost functions.
  • Thread optimized path search system. The path search system has been designed for use in heavily threaded environments. There is a strict division between constant and runtime data. This reduces the amount of used memory in a threaded environment. The path search functions include locks that are needed to ensure proper working in threaded environments. There is also support for task based path searching, so that the search request and its result are local data provided to the path search system.
  • Pathsmoothing. xaitMap comes with funneling based pathsmoothing as well as raytracer based pathsmoothing mechanisms which give you great results.
  • Slice support. You are able to split a path search computation into predefined steps across several frames so that even bigger path searches do not block render loop execution in non-threaded environments.
  • NavMesh raytracing support. There is a raytracer available, which can trace rays in the domain of the navigation mesh. This can be used to perform collision avoidance or other tests in the walkable areas. This sort of raytracing is much less error prone and faster when doing normal raytracing for navigation purposes. Then, used for collision tests, raytracing in the navigation domain ensures that the AI meets the constraints applied to the navigation mesh generation process, i.e. forbidden areas.
  • Customizable memory streaming of path data. The path data can be streamed in and out of memory. The decision of when to load or unload sectors of the path data can be done automatically by the library, when it has been given the area where navigation should be possible, or it could be done manually, when the streaming should be bound to some existing streaming functionality (i.e. terrain).
  • Custom memory allocator. The library can be initialized to use any custom memory allocator. The library itself uses no direct calls to a C++ memory heap. You can provide your own memory allocation scheme or use one of your favorite game engines.
  • Data serialization from various data sources. The path data can be serialized directly from memory blocks or user provided streams. For faster startup implementations there is also a file based serialization stream.
  • Wide platform and compiler support
    • Win32/64 using VC2005,VC2008,VC2010 (static and dynamic library)
    • Linux32/64 using GCC4.1,GCC4.4 (static and dynamic library)
    • Recent Xbox360 SDK (static library)
    • Recent PS3 SDK, GCC and SN Compiler (static library)
  • Full Documentation. The SDK comes with documentation for the API and high level concepts or the library. There are also source code examples for using the library in different scenarios. 
 ## xaitMap Creator Features

  • Graphical tool to setup and generate path data for your game worlds. The tool is similar to the world editor of most game engines. You can import graphical data in various formats and generate path data for that geometry. The tool provides nearly all features from the C++ library in terms of path data generation.
  • Automated generation of navigation mesh data from imported geometry. The tool uses the C++ library to generate path data. Information needed to build the path data can be specified inside the tool. All information will be serialized and are available during runtime, i.e. characters that have been defined for a certain NavMesh.
  • Automated mesh editing. When you use automated path data generation, there is always the chance that you will get path data that does not exactly suit the needs of your game in certain places, i.e. forbidden areas for the AI. In this case you need to modify the path data that has been generated. The disadvantage of manually editing the path data is that after a rebuild of the path data, your changes will be lost. In order to prevent this, xaitMap has manual editing objects to instruct the path data generation process, rather than directly modifying the path data.
  • Handling of Pathobjects. Spawn points, blockings and the new, dynamic blocking pathobjects for simulating doors, destructible objects and the like, can easily be created, modified and managed within the xaitMap Creator.
  • Optimization of path data. Besides the automated mesh editing, there are ways to reduce the memory footprint of the path data by playing around with the NavMesh granularity or by removing unreachable areas.
  • Multi-user environment. The project structure has been set up for use in multi-user environments. There are per user settings that can influence target paths of path data. The file structure is suitable for file based version control systems, so there is no big monolithic xml file which is hard to merge in a case of conflicts.
  • Wide import format support: VRML 97, Maya 2009, Havok Vision Engine (), Emergent Gamebryo (), Emergent LightSpeed (*), Collada, Biovision BVH, 3D Studio Max 3DS, 3D Studio Max ASE, Wavefront Object, Stanford Polygon Library, AutoCAD DXF, Neutral File Format / Sense8 WorldToolkit, Quake I, Quake II, Quake III, Doom 3, DirectX, Quick3D, Raw Triangles, AC3D, Stereolithography, Irrlicht Mesh, Irrlicht Scene, Object File Format, Terragen Terrain, 3D GameStudio Model, 3D GameStudio Terrain, Milkshape 3D, LightWave Model, LightWave Scene, Modo Model, CharacterStudio Motion, Stanford Ply, TrueSpace
  • Custom import format interface. The tool includes an SDK that allows you to write your own importer plugins. Thus you can import your custom geometry files directly instead of exporting them into a file format that is accepted by xaitMap Creator. This reduces the steps to generate path data if your game uses a file format that is not natively supported by the xaitMap Creator.
  • Project wizard for fast data setup. The tool has a project wizard so that you can easily start your new projects. Batch builds configure batches for several builds to reduce user interaction during build session.
  • Customizable GUI layout. The GUI of the tool can be changed to fit your needs by using the flexible window management. 4GB support. On 64-bit system, the tool can use up to 4GB of memory so that even big mmorg geometry can be loaded and processed.
  • 64Bit version of xaitMap Creator. In addition to the 64Bit libraries we now offer a 64Bit version of the Creator which gives you even bigger flexibility in your off-line build process.

Licensing

License Name Price in $US Source Code Included?
Proprietary Unspecified No

This tool hasn't been reviewed yet. Be the first!

Write a Review

Suggest Edits

Last edited Jan 22, 2012 at 07:41