Getting Started

Going straight to the examples

Those with a hands-on disposition can get a quick idea about how PathEngine works by going straight in and running the prebuilt examples and tutorial applications that come with the SDK.

Once the SDK is installed, you can try out the included example projects by double clicking launcher batch files in 'SDKRoot/launchers_Windows-x86' or 'SDKRoot/launchers_Windows-x64' (with an x64 Windows install required to run the x64 versions).

Refer to Tutorials and Example Projects for explanations and instructions relating to each project.

Visual studio projects for rebuilding the example projects is located in 'SDKRoot/VisualStudio' (for Visual Studio 2008) and 'SDKRoot/VisualStudio2012' so you can modify this and see what happens.

Or read before you leap

Others will profit from reading through at least some of the documentation first, in particular the Ground Meshes and The PathEngine Movement Model topics in the Fundamental Concepts section.

Common controls and information about the PathEngine testbed

Many of the tutorial and example projects run under the PathEngine testbed.
See Working with the TestBed for common information about this run-time environmant, including camera controls for navigating around the world whilst examples are running.

Tutorials

Note that while Tutorial 1 is pretty basic, and can easily be skipped, Tutorial 2 and Tutorial 3 contain some useful example code and discussion relating to the collision and pathfinding functionality.

Tutorial 2 provides an example implementation of direct agent control, with pretty robust (if not particularly well organised) code for sliding against walls.

Tutorial 3 provides a simple demonstration of pathfinding and movement in an environment with dynamic obstacles.
This can help to understand the PathEngine movement model and how agent shape is taken into account for the paths generated.

Other example projects

The 'TestApplication' example project builds on the tutorial projects to combine point and click movement with direct control, and is a good way to get an idea about how PathEngine's collision queries can also be used to help with the implementation of agent collision and agent movement management in general.

Other example projects (of varying complexity!) are then available as well as benchmarks and stress test applications and a small 'playable demo'.

The 3D content processing demo, and the semi-dynamic obstacles example project, in particular demonstrate some important features of the SDK, and are both well worth a look.

If you need to implement formation or group movement, be sure to check out the the 'CollapsibleGroup' and 'SeparatingGroups' example project.

Don't consider the example projects as indicators of SDK performance

It's important to note that many of the example projects are quite old now and in general these should not be considered as indicators of the full capabilities of the SDK (with the exception of the benchmarks project, of course).

While these projects can still be useful to demonstrate different ways of working with the SDK, the SDK has evolved very significantly since some of these example projects have been created, in terms of things like query times.
Don't hesitate, then, to modify examples, to replace the meshes used with more complicated meshes, to increase the number of agents or obstacles placed, and so on.

The fact that all of the example projects included with the initial commercial release of the SDK are still applicable today, with very minor modifications, is a testament to our commitment to consistency and API compatibility!

Understanding runtime integration in more detail

A good way to get a more detailed idea about what exactly is involved in integrating PathEngine with an application, is by looking at the tutorials and examples source code.
Refer to the tutorials and examples documentation.
The API Reference section is also invaluable for understanding what is going on in this example code.
The The Playable Demo source code then provides examples for how more advanced behaviours can be implemented on top of PathEngine.

A powerful tool that may need to be applied in a certain specific way to get the best results

It can be useful to think of PathEngine as a powerful tool, but one that may then need to be applied in a certain specific way in order to get the best results in a given situation.

The SDK has been used in a lot of situations with very demanding requirements, and has been optimised in various ways to address these requirements, but these optimisations may depend on data being set up in a certain way, or on options being supplied to adjust the exact way in which ground meshes are loaded or preprocess is generated.

If you are evaluating PathEngine for a project with demanding requirements then don't hesitate to contact SDK support for advice about the best way to apply the SDK for maximum performance in your specific application situation!

Content creators and content programmers

PathEngine provides two distinct processes for content side automation. A 2D content process is provided, based on minimal markup generation, with extremely lightweight and performant combination of markup for content chunk, and also a 3D content process which operates directly on 3D scene representations.
This page (in the programmer's reference) provides detailed explanations of both processes.

Understanding what's involved in integration with the 2D content process

This page provides a kicking-off point specifically for content creators working with PathEngine's 2D content process, and should also be read by any programmers integrating with this content process.

Playing around with the 3DS Max or Maya exporters and the example geometry are also good ways to get a quick understanding about integration with the 2D process.

Understanding what's involved in integration with the 3D content process

The best way to quickly understand the issues relating to integration with the 3D content process is probably to try out the The 3D Content Processing Demo.