Auran Jet is a development engine that can be used to create a variety of 3D applications including, games, simulation and training software.

Architecture:

Modular and Layered Architecture
Jet’s architecture is modular and layered. Each system is enclosed in a separate module and communicates with other Jet systems via standard abstract interfaces. Each module or system is also internally layered. The most generic components of a given system reside in the core layer which is progressively built upon in successive layers. Dependencies between systems and components only ever refer to lower layers, never higher.

JIVE
Jet Integrated Visual Environment, JIVE, provides the developer with an integrated development environment framework for building custom resource editors that are dynamically added via plugins.

JRally

Overview
JRally is a sci-fi themed racing game developed by Auran using Auran Jet technologies. Its goals are to provide the following:
an example of what can be achieved using Auran Jet in a short time frame, and
a demonstration integrating Auran Jet features to create a fully playable demo game.
JRally was conceived and completed over a total of seven weeks. Due to the limited time frame, the number and types of features included were carefully selected. This helped avoid “feature creep”.

The dev team was as follows:

Asset creation/game design-
one full-time 3D artist/designer
one full-time 3D artist
one part-time 2D artist
one 2D concept artist
Software development team-
one lead programmer
one additional full time programmer
short-term assistance with network, interface and sound code from one other full-time programmer


Full Source Code
The JRally release features full source code. Source code may be used entirely for educational purposes and familiarization with Auran Jet. Alternatively it may be used, in full or in part, to assist in the completion of other projects using Auran Jet technologies.

Integration of Jet Systems
JRally makes use of many Jet systems. More importantly, it integrates disparate systems to create a full-featured game. In particular JRally demonstrates the integration of the following systems:
Render system – Jet’s rendering classes are used for display and management of 3D objects. Specifically: indexed mesh support, particle attachment and the Particle hierarchy.
Dynamic lights – Jet’s dynamic lighting support is used, including ambient, parallel, omni and spotlights.
Particle effects – Jet’s particle effects system is used extensively for added visual impact.
Sound – Jet’s basic sound support is used including environmental effects. JRally also demonstrates the on the fly manipulation of sounds already playing.
Interface Kit – all of JRally’s interface screens are built using Auran Jet’s Interface Kit and supporting classes. Buttons, static controls, edit boxes, scrollers and progress bars are all used to create JRally’s 2D user interface.
Network System – the client-server architecture used in JRally is built wholly on classes provided by Auran Jet’s network system. JRally manages the high level connection of client and server while Jet manages the transmission and processing of data packets and ensures that guaranteed messages arrive in the same order in which they were sent.

Extension of Jet Systems
JRally tailors several Jet systems by extending key classes. In particular JRally provides the following extensions:
Materials – Several additional material types have been included and used by various JRally meshes and special effects. Additional materials are:
Additive material – uses additive blending to render geometry.
Corona material – used by JRally’s corona effects.
Max lit material – always rendered at full brightness.
Scrolling texture material – supports scrolling texture coordinates.
Dynamic lights – JRally extends the dynamic lighting support by allowing for key frame animated lights.
Particle effects – Several particle effects have been extended for additional visual effect. Extensions include animated textures, improved particle position calculations and textured ribbon effects.
Interface components – JRally extends and adds several Interface Kit components. These may be loaded and used in the Interface Kit in the same way as the standard Jet components.
Resources – Many JRally features require the use of on disk resources. These features extend the resource classes provided by Auran Jet, allowing Jet to perform JRally specific resource management including background loading and data caching and the release of unused resources.


Game Systems
JRally features several key game systems that may be adapted for any project. These systems are:
Client-server communication - JRally supports a client-server architecture for network play. Up to four players may simultaneously battle for the finish line. Messages may be sent as system messages for high level processing or between network instances of the same object.
Object System - JRally provides an object management system allowing object data to be loaded from configurable data files. Additionally the object system is tailored towards a network architecture simplifying the creation, reflection and communication of objects.
Collision BSP – JRally uses a Binary Space Partition (BSP) tree collision model for processing collisions between a client vehicle and the edges of the racing track. JRally’s collision system also supports collisions between game objects for handling by game logic code.

Render:

DirectX 8.0 and OpenGL Support
Jet’s rendering architecture abstracts the hardware and API to include support for Microsoft DirectX 8.0 and OpenGL 1.2. This allows applications to be written to Jet’s rendering API without concern for the underlying hardware API ultimately used.

3D Studio Max v2.5-4.0 Mesh and Animation Exporter Plugin
Provided with Jet are 3D Studio Max plugins for exporting meshes and animations into Jet’s native format. The mesh exporter supports exporting standard indexed meshes and progressively reducing meshes. Separate plugin versions are provided to support 3D Studio Max versions 2.5 through 4.0.

Alias | Wavefront Maya v3.0-4.0 Mesh and Animation Exporter Plugin
Provided with Jet are Alias | Wavefront plugins for exporting meshes and animations into Jet’s native format. The mesh exporter supports exporting standard indexed meshes and progressively reducing meshes. Separate plugin versions are provided to support Alias | Wavefront Maya versions 3.0 through 4.0.

Extensive Animation System
Jet provides a skeletal key-framed animation system supporting additional features such as:

Queueing - Animations may be buffered for playing one after another;
Interpolation - Bone positions and orientations are interpolated between keyframes to ensure the animation is smooth, regardless of the framerate;
Blending - Two or more animations may be blended together, either to transition from one animation to another, or simply to create a new animation;
Sub-bone Animation - Animations may be selectively applied to specific bones (and their children) enabling, for example, a character to wave while walking, running or riding a horse; and
Event Syncronization - A variety of event types may be attached to selected animation frames to synchronize attachments, sound effects, code, and similar.
The Animation example, as seen here, demonstrates the sub-bone animation where the arm crosses the chest whilst the character is running, these animations seemlessly blended together at run time.

Object Attachment Support
Objects in a 3D scene may be attached to other objects at pre-determined attachment points. For rendering and animation purposes, attached objects are considered child objects. Thus, the movement of a sword attached to a character’s hand is relative to the movement and animation of the character and its hand.

Hardware Transform and Lighting
Jet’s renderer makes full use of any hardware texture and lighting (T&L) support detected.

Bump Mapping Support
Jet’s renderer provides support for bump mapped materials on appropriate hardware. The Bump Mapping example demonstrates the Auran Jet logo protruding from a blue sphere. In this example the effects of a parallel light or omni light, as shown to the right, can be observed.

Cubic Environment Mapping Support
Cubic environment mapping is supported by Jet on appropriate hardware. The Cubic Envrionment Mapping example, as shown to the right, demonstrates a sphere that reflects its environment inside a textured box.

Dynamic Lighting Support
Jet’s scene management provides support for dynamic lighting. Numerous types of light; including ambient, omni, parallel, and spot; may be added to a 3D scene. Optimized routines are used to determine and calculate the dynamic effects of these lights on objects in the scene.

Particle Effects System
Jet’s particle effects system provides classes for managing particle emitters and dynamic modifiers. Individual emitters and modifiers are implemented as plugins promoting extensibility and reuse. The point, disc, rectangle, and ribbon emitters are provided as defaults, each of which may be modified using the color, field, swirl, or custom modifiers.

Multi-Texturing Support
Jet supports and abstracts multi-texturing extensions to DirectX and OpenGL. The Multi-texture example shows an object which is made up of two chunks. One chunk, the red end, is a simple NoTextureMaterial. The rest of the capsule uses a gloss material, which has three textures. A base diffuse texture, an alpha map texture and a reflective (in this case a spherical map) texture. The alpha texture is used to mask where the reflective texture will be applied. In this example, half of the alpha texture is full value and half is zero, therefore creating the appearence of the reflective texture only being on half of the chunk.

Progressive Mesh Reduction Support
Jet uses progressive mesh reduction to provide level of detail (LOD) support. Appropriate meshes can have their detail dynamically reduced in code. Progressive reduction can be setup to occur according to a mesh’s distance from the camera, as a result of dynamically balancing an entire scene, or directly in code.

Projected Texture Support
Projected textures are supported by Jet on appropriate hardware. The Projected Texture example demonstrates the Auran Jet logo projected onto a teapot. Projected textures could also be used to cast "light" of an arbitrary shape, for example, dynamically casting light from a stained glass window onto other objects.

Vertex Program Support
Jet supports the use of vertex programs (a.k.a. vertex shaders) on appropriate hardware. Vertex programs enable custom ’programs’ to be executed on vertices in the graphics hardware. The Vertex Program example demonstrates some animated grass and a flag in simulated wind.

Volumetric Shadow Support
Jet’s lighting manager supports the generation of volumetric shadows. Thus, objects can cast their own shadow onto other objects. This can be seen in the Dynamic Lighting Manager example, where the green ball’s shadow falls onto the white box.

Physics and Collision System Extension
This extension system provides an implementation of a functional physics and collision system. It will not be suitable for all applications as efficient physics and collision handling is very application dependent. The source code provided with this implementation illustrates how such a system might be built onto Jet when custom handling is required. The Collision example uses this system to create a box containing spheres which collide with one another and the box’s walls.

Primitive Objects
A range of primitive objects are provided for rendering geometric shapes; line, plane, box, cone, cylinder, ellipse, ellipsoid, circle, sphere, etc. These are very useful for visual debugging. The Primitive Objects example demonstrates some of these classes which can be displayed in wireframe or solid and with different colors. The Primitive Objects example also demonstrates how to create custom geometric objects that are textured and lit.

Sprite System
The sprite system allows developers to create custom interfaces, overlays and other 2D elements. The Sprite example uses the Auran Jet logo to demonstrate the movement, rotation, sizing, and priority ordering of individual sprites.

Multiple Viewports
Multiple viewports can be created and positioned, sized and ordered by the developer to create, for example, a split screen for multi-player games or windows-on-windows. Simultaneously, each viewport can render from different camera perspectives or from cameras in different worlds.

Network

Native and DirectPlay Support
Jet’s network transport layer is accessed via a plugin interface. Two plugin drivers are provided with the default distribution of Jet; native and DirectPlay.

TCP/IP, IPX, Serial and Modem Support
Jet’s networking supports the TCP/IP and IPX protocols, and LAN, Internet, direct serial, and modem network topographies. It also supports both client-server and peer-to-peer sessions.

Message Management System
Jet’s network system provides numerous message management services giving the user control over message order preservation, guaranteed delivery, and similar features.

Send and Receive Statistics Gathering
The network system can be directed to gather sent and received data statistics. These statistics can be used to analyze network traffic to aid with structural code changes and/or to dynamically respond to traffic changes.

WAVE Remote Manipulation System
Jet’s Wide Area Virtual Environment, WAVE, allows remote consoles to monitor and/or issue commands to a running Jet application. This powerful system has many potential uses including performance monitoring, data collection and analysis, and control over remote applications.

Network Simulation Environment
Jet’s network system provides a simulated TCP/IP network environment for debugging purposes. Programmers can set the latency, packet loss, and bandwidth in both send and receive channels. This tool is invaluable for determining the performance and stability of an application in a poor network environment.

Host Migration Support for Peer-to-Peer Sessions
Jet’s network system supports dynamic host migration in peer-to-peer sessions. If an existing host fails, the network system automatically selects and appoints a new host. Sessions can therefore proceed uninterrupted when a host collapses.

Message Compression and Encryption Support
Network messages may be encrypted and/or compressed. This support is provided via Jet’s plugin management system so any available encryption or compression plugin may be used.

Network Lobby Support via DirectPlay Driver
Network lobby support is provided via the DirectPlay driver plugin. Programmers can therefore setup and manage lobbies within their Jet applications.

Remote Session Query Support
Jet network sessions can have their properties queried remotely without needing to actively join the session. This enables programmers to access details of active sessions and allows users to issue join requests based on that information.

Interface

WYSIWYG Interface Construction Tool
Jet’s Interface Kit is a what-you-see-is-what-you-get (WYSIWYG) 2D interface construction kit. Users construct interfaces by placing components and adjusting properties such as text, images, behavior, etc. All of the standard 2D user interface components are available to the interface designer including buttons, windows, scrollbars, edit-boxes, menus, etc.

Plugin Interface Components
Jet’s interface components are implemented as plugins. Programmers can extend existing components or create new ones by creating and registering new plugin components. Thus, for example, the edit-box component could be extended to act as a simple password entry box only displaying *** characters. New plugin components are immediately accessible to Jet’s Interface Kit.

Immediate and Buffered User Input Support
Jet’s input system supports both immediate (or direct) and buffered user input handling. Immediate mode input handling enables the programmer to query the current input state. Alternately, buffered input handling forwards input events to registered observers.

Bitmap and TrueType Font Support
Jet’s interface system supports the use of pre-created bitmap fonts. It also has the ability to dynamically create bitmap fonts from TrueType fonts.

Drag and Drop Support
The Jet interface system provides full-featured drag and drop support. Programmers and designers can configure the precise behavior of draggable objects. For example, what they look like while being dragged, their appearance while being dragged over an object that can receive them, their behavior when dropped, etc.

Sound

DirectX 8.0 Sound Driver
Jet’s sound system abstracts the specific sound hardware via a plugin interface. A full-featured DirectX 8.0 driver plugin is provided with the standard Jet distribution.

DirectSound 8.0 Sound Effects
Jet supports all of the sound effects available to DirectSound 8.0. These include: chorus, flange, echo, distortion, compression, parametric equalization, gargle, waves reverberation, and environmental reverberation.

MP3, WAV and ADPCM Music Support
Jet’s sound system handles music files in the MP3, WAV, and MS ADPCM formats. Music can be looped, faded in, faded out, and cross-faded.

2D and 3D Sound Support
Jet’s sound system includes support for both 2D and 3D sounds. 2D sounds are played directly and their volume is determined from the gain setting only. 3D sounds may be placed in the world or attached to objects. They are played when they collide with a microphone, which also exists in the 3D world.

Polyline Sound Support
Jet’s sound system supports the insertion of polyline sounds into the 3D world. Polyline sounds represent sounds emanating from a continuous line source, rather than a point source, such as a river.

Kernel

Plug-in Management System
The plug-in management system provides Jet applications with the ability to be customized and extended during and after an application has been distributed. Many Jet systems use plug-ins to allow customization however developers can also use this system to create specific plug-in interfaces for their applications.

Background Resource Loading
Jet’s resource system allows resources to be loaded from fixed media on a separate background thread. It can therefore take advantage of idle time to pre-cache resources for future use. This potentially eliminates the need to halt an application when loading new textures, sounds, geometry, and similar resources.

Resource Aliasing
Jet’s resource system supports the concept of resource aliases. A resource alias is simply a file that redirects the resource system to load another file in its place. This feature has many potential uses, particularly in the area of product localization.

Comprehensive Library of Utilities
Jet comes complete with a comprehensive suite of utility classes including, but not limited to: time, color, crc validation, debug logging, options processing, random number generation, reference counting, container classes, 3D math, file handling, string processing, image manipulation, memory allocation, and exception handling.

Thread-Safe Utilities & Systems
All of Jet’s systems and utility classes have been designed and developed for use in multi-threaded applications. It is therefore safe to use them in a multi-threaded code environment.

Memory Allocation Tracking
In development builds, Jet’s kernel tracks memory allocations and deletions. Memory blocks still allocated at shutdown are reported via the log file and include the file and line number where the allocation occurred.

Compression Support
Jet provides data stream and block compression via a plugin interface. Users can implement their own compression plugin(s) or use the included LZSS compression plugin. Jet’s network system can be instructed to compress messages using any of the available compression plugins.

Encryption Support
Support for block encryption in Jet is available via a plugin interface. Programmers can develop their own custom encryption plugins or use the one provided, which implements Blow Fish encryption.

Multibyte Character Support
Jet’s systems and utilities; the resource and interface systems and string classes in particular; all support the use of multibyte characters and strings. This allows Jet applications to be localized for languages that use extended character sets.

File Handling and Abstraction
Jet includes a special file handling class providing standard file functionality and also abstracts directories so they may be accessed from archive files transparently. Directories and/or archives may be linked together to create virtual collections of files. Other file functions, such as wildcard searching, are also supported. A utility for creating and extracting from archives is included with Jet.

AI

Core AI Infrastructure Components
Artificial Intelligence, AI, implementations are very application specific. Jet’s AI infrastructure therefore provides generic base-level components for implementing intelligent agents. An agent is simply an entity capable of making decisions and may or may not correspond to a physical entity in the world.

Persistent Memory Support
Jet agents support persistent memory via world models. Each agent has its own world model, which is a database containing a representation of that agent’s view of the world. All forms of data can be added to the database, including custom data structures. World model data can be consulted by artificial decision units when making decisions.

Data Gathering and Filtering
Agents gather raw data from their environment using sensors. This raw data is broadcast to registered filters for selective processing and/or insertion into the agent’s world model.

Built-In Finite State Machine (FSM) Support
Agent’s make decisions by coordinating their Artificial Decision Units, ADUs, with data gathered by sensors and placed in their world model. Programmers can create custom ADUs (based on genetic algorithms, neural networks, and the like) or use the built-in Finite State Machine ADU provided with Jet.