Introduction to Axis

Axis is a free, stand-alone, built from scratch 3d engine with original architecture and intelligent approach in the wide range of technological fields it involves.

Contents

Elegance in simplicity
Architecture
Features
Editor
Shading model
Scene structure
Properties and automation
File formats
Software rasterizer
Script

Elegance in simplicity

Axis is built with the premise that the perfect tool, no matter in which field, is one which the user can instantly start using.
This is why a central pivot in designing each aspect of Axis is and has been to be free of redundant material and have only relevant elements with the fewest dependencies, in order to keep it simple and straightforward.

Being an idealistic goal, some compromises are inevitable along the way, especially with a product which aims to be fluid, multi-platform, multi-language and which encompasses so many fields of the computing technologies.
Anyway, we believe that striving towards the highest goal delivers the best results.

Architecture

Axis relies heavily on its modular architecture, which defines a few major subsystems - graphics, sound, file system and serialization, which are independent from each other, with device and platform agnostic interface

Each module can provide one or more subsystem and each is separate from the core. Modules can either be embedded in the core, or be separate files. For example, in terms of the Windows implementation of Axis, a module is a .dll file, which can be "installed" by simply copy-pasting it in Axis' folder.

This modular design allows for a couple of advantages
  • A stand alone core, free from third parties - Axis is a fully self-dependant core with its own framework. All the vendor-reliant functionalities are implemented through modules, which are separate from the system and can be included by choice
  • Customizable - Axis provides a number of modules, any or all of which can be used at will. Modules can also easily be created by users, in accordance to their specific needs, thus being able to add native support for custom file formats, graphics, sound or input/output devices. In addition, any module should generally be applicable to any Axis-driven system (*provided they are version and platform compatible), thus giving the ability for one party to use modules created by another party.
  • Licensing freedom - Axis itself and all its code is subject to the permissive and compatible MIT license. Any functionalities, provided by third party libraries and these libraries' respective licenses, are incorporated via Axis modules, which can be added at will, thus giving the ability to "configure" the licensing as required.
  • Solid API - Axis's programming interface and design can't be influenced by third parties, as it depends on none in its core. In the same time, there's the ability for quick and seamless reaction to the upcoming technologies, by having new or updated modules, without touching the core. From users' point of view, this means seamless transition to newer tech and no troubles with frequent API changes.
  • Future-ready - An application, created with Axis can, in future, be fed with modules, which incorporate more advanced technologies than the presently available, thus modernizing the application without even the need for the developer to intervene. For example, see shading model
Learn more about the modular architecture

Features

Because different platforms, such as Web and Desktop, may have their own specific features and lack of some others, Axis inherently provides support for such features only in the implementation of the respective platform.

For example, this means that the Web implementation can't have a Direct3D rendering device, because there just isn't access to one for web pages.

However, the core features are supported in any case, each implementation has at least the minimum required features to open and display a 3D scene and as for the various media formats, simply using popular formats should be sufficient, plus that the AXS file format supports embedding decoded resources

Desktop Web
3D formats
AXS
3DS
OBJ
MTL
FBX
DAE
Image formats
AXI
JPG
PNG
BMP
DDS
TGA
Sound formats
WAV
OGG Vorbis
Graphics devices
OpenGL 4
Direct3D 11
Soras
WebGL
Sound devices
OpenAL
Input devices
Mouse
Keyboard
Gamepad

Editor

Axis has its own application for editing its scenes, for importing models, textures, sounds and other resources from different file formats and overall, for composing the virtual environments which Axis displays. This is the Axis Editor.

It is a visual tool in which the components of a scene can be arranged in real time, have their properties set and create different kinds of animations and automations.

Learn more abot Axis Editor

Shading model

Being a 3D engine, a very important part of Axis is its graphics subsystem. A central point in this aspect is another smart design, the layered shading model. It's an approach which is intuitive and simple, yet capable of producing diverse results.

The layered shading model has the simple premise that the material of a 3D rendered object is to be composed by laying up multiple simple effects, each blending with the previous, much like layers in a typical graphics editing software. These effects can be selected from a set and each has its respective parameters.

To comply with this architecture, Axis' graphics devices dynamically create and compile the shading programs which are fed to the graphics device, all of which remains transparent for the user.

This leads to some neat features

  • Easy and intuitive - A material, or rather, a shader, is composed simply by iterations of selecting an effect from a set and choosing its blending operation
  • User friendly - no need for writing programs in shading languages such as GLSL or HLSL
  • Unified shading - regardless of device or platform, the shading technique and input are the same and work everywhere
  • Upgradeable - the high level of the shading model allows for the effects to be implemented more sophisticatedly by future graphics devices
Learn more about the shading model

Scene structure

The scene is the whole 3D environment which Axis displays at given time - it's the virtual world, the map which is being rendered.

It consists of a hierarchical structure of objects, each applying its effect when being traversed by the engine and thus, each creating context for the next object to come.
This way there are relatively few different classes of objects in the scene and each one has only relevant properties

For example, a mesh doesn't need to have a material or a transformation bound to it - it's simply rendered with the ones encountered in the scene hierarchy before it, thus being context to the mesh.
This way, instancing, for example, comes naturally so code and architecture are clean and elegant.

Learn more about the scene structure

Properties and automation

Each object in the scene has certain properties. Besides having a simple value, these properties can be linked to a certain type of scene object, called Mechanism, which can produce a value for the linked properties.
This gives the ability for multiple objects to share a single centralized value and what's even better - to have the value automatically animated by the Mechanism.

This simple approach can literally move mountains, as it's used for all kinds of visual animations - positional, like keyframe and skeletal animation, shading parameters animation and practically to animate any property of any object.

Learn more about the properties and automation

File formats

Axis uses the same universal scene file format in both desktop and web, so generally there shouldn't be need for different versions of a scene for each platform.

The native scene file format, AXS, is backward compatible and customization friendly. It can hold custom user data for specific applications, at all levels of serialization, and in the same time be perfectly valid and readable by the standard Axis apps.

Axis also has a native image format, AXI, which can store multiple frames of different size and pixel format, if required. It is also ready to support different encodings in future.

Learn more about the file formats

Software rasterizer

Axis has its own software rasterizer, which supports some basic features and can be used for rendering of simpler scenes, for example in cases where relying on a hardware graphics device is not desirable

Learn more about the software rasterizer

Script

*Not available in the current beta release
The Axis Script is a C-like language which can be used to program more complex logic for a scene, activate triggered actions and etc.
The major advantage of the script is that it allows for a scene-specific programming, embedded in the scene itself, which also minimizes the need for writing code in the host application.