Design Overview

This document lays out the basic structure of all of Aviatrix3D in one reference. For more details, see the individual description pages linked on the side.

There are 10 main packages that defines the core of Aviatrix3D, of which 7 define the abstract structure and two are purely implementation and utilities. In addition there are another 15 packages that hold optional utility code that expand on the basic functionality. The core classes are contained under the root package org.j3d.aviatrix3d, which the optional classes are contained under the package org.j3d.renderer.aviatrix3d. Only the core packages are described here.

Basic Structure

The core of Aviatrix3D is laid out to separate the public-facing scene graph structure from rendering and picking. The rendering-level code is further broken down into timing management and the rendering infrastructure such as culling and sorting. Each package describes its basic functionality through a collection of interfaces and abstract classes, which are then realised with concrete classes. Due to the amount of classes in the system, we'll limit our descriptions here to just the interfaces.

Figure 1 outlines the structure of these packages and the main interfaces that you will be using and seeing.

Figure 1: Package layout of the core of Aviatrix3D

User-facing Scene Graph

The user-facing scene graph is the part that users will primarily interact with. Here you will find all the basic structures that you would expect to find in a scene graph - nodes for grouping, polygon representation, textures, appearance, lighting etc. The scene graph is described using the modern depth-first directed-acyclic graph traversal style. Attributes from higher in the tree are pushed downwards towards the leaf nodes.

Figure 2: The core of the user-facing scene graph

At the base of all the scene graph is the abstract class SceneGraphObject. The interface NodeUpdateListener is used to communicate between the scene graph nodes and end-user code about the correct time to send updates to the scene graph. The NodeUpdateHandler interface is used to communicate state information back and forth between the internals of the node implementation and the state/timing management system that is implemented by the RenderingManager.

Rendering Pipeline

The rendering pipeline consists of two separate sets of packages. The package org.j3d.aviatrix3d.pipeline contains the basic classes and interfaces that implement the guts of a rendering pipeline: namely culling and sorting (Figure 3). Under this package are two more packages that specialise the interfaces into an output-device specific capability. Right now there are two capabilities here - graphics (Figure 4) and audio (Figure 5), though nothing prevents there being others in the future (eg haptics).

Figure 3: Basic classes in the rendering pipeline

Figure 4: Extensions to the basic pipeline for graphics

Figure 5: Extensions to the basic pipeline for audio

Connecting the rendering pipeline to the user facing scene graph objects are the interfaces in the org.j3d.aviatrix3d.rendering. These interfaces are what the rendering pipeline use to interact with the scene graph in a multithreaded manner. For each node, there will be n of instances of it's corresponding culling interface for the n rendering threads that are being used. This abstraction is in two parts - Cullable interface represents the items that are traversed and used to cull non-visible sections of the scene graph, while Renderable is the leaf-node product that ends up heading down the rendering pipeline to the output device.

Figure 3: The interfaces for connecting the rendering pipeline to the user-facing scene graph nodes.