Scene composition and entities

A 3D environment in Axis is built out of primitive, initially self-contained building blocks of several different types. In the context of the engine's API, these building blocks are called entities. Everything in the scene is composed by literally arranging such entities in the desired order inside containers. A bit like a sandbox game :) Basically, it's a hierarchical structure and putting an entity in a container makes all sequent and subsequent entities be able to use it. For example, putting a material makes all the following meshes render with that material, until a new material is encountered.

This approach leads to several consequences:

  • The entities are simple because they only have properties which are definitive for their very type
  • The entities can adopt the characteristics of other types of entities, arranged before them - for example, a mesh gains the spacial characteristics of a transform and the visual characteristics of a material, which are arranged before the mesh
  • The above two reasons lead to the ability of the very same entities to be reused in different containers and arrangements, thus gaining different characteristics. This way, concepts like reference materials, reference meshes or reference-whatever come naturally
  • Entities of certain type always behave the same way and because there is a finite number of entity types, this greatly reduces and limits the amount of knowledge required to work with a scene. Like the elements in the periodic table, its just a matter of arranging them in the order which produces the desired result
  • Generally, an entity can be switched at any time with any other entity of the same type

These are the currently available types of entities:

  • Transform - a spacial descriptor. Gives spacial characteristics to other entities. Affects Cameras, Meshes, Lights, SoundEmitters
  • Camera - represents a lens through which the 3D environment is projected onto the rendering surface. Practically, it is a camera's lens. Affected by Transform, which describes a camera's spacial characteristic (position, target direction, up direction). Affects Meshes
  • Material - Currently, defines the visual properties of a mesh. Planned to contain audio properties as well. Affects Meshses
  • Texture - Represents a texture - image which can be used by materials to map onto meshes. When set, used to render onto it
  • Mesh - Represents a single 3D mesh, which can be rendered with a single material at a time. Affected by Material, Transform
  • Light - The properties of a light. Affected by Transform
  • Sound - A sound record. Can be thought as the audio equivalent to texture. Used by SoundEmitters
  • SoundEmitter - An emitter of a Sound. Affected by Transform
  • SoundReceptor - A receptor of SoundEmitters. Affected by Transform
  • Script - A piece of scripting code. Can perform basic operations in a C-like language. Processing engine is operational, but yet to be implemented to manipulate the 3D environment
  • Mechanism - Can perform a specific operation, usually a calculation based on its input properties. The result of its operation can be assigned to a property of any entity, thus creating a form of automation. Mechanisms are meant to handle small usually boring tasks like crating a repeating motion of an entity, or oscilating a parameter value, say on some material property and stuff like that. A mechanism can be set in the place of any entity's property value of a corresponding type, thus giving the ability to link various things in the scene with the same value. See "Properties and mechanism automations"

Creating additional types of entities will probably occur in future, bit it's looked upon with criticism, because new entities mean greater complexity and that is a price to Axis' minimalistic concept.

An interesting quality of Axis is that it doesn't have predetermined rules about achieving specific things. For example, creating post processing effects like bloom, or even more complex ones like shadow mapping is done with the same basic functionality as used for, say, texturing a mesh.
This approach earns more freedom, but its drawback is that it leads to more mingling with details.