The leading Open Source 3D game and visualisation engine used in dozens of commercial games and professional visualisation applications released worldwide.

A well-tried and robust C++ game engine
An "Operating System" for games
OpenSource - Itīs free !
Multiplattform (Win, Linux, Irix, Mac, Xbox)
A portability wrapper (unified APIs)
An abstraction layer (simplified APIs)
A DX9 rendering engine
An extensive and most modern feature set
Flexible scripting: TCL, Python, LUA, ...

Features

Tree Of Named Objects
Nebula objects have a string name
Nebula objects are arranged in a hierarchy, similar to a filesystem
An object name can be converted to a C++ pointer, and back
String names for objects are useful for scripting and persistency (you canīt save a pointer)
Safe object access through RefCounting and smart pointers
Class nRoot as common base class

Server Objects
Nebula2 runtime consists of a number of server objects which offer central services
Server objects live under a defined name: Graphics server: /sys/servers/gfx ...

Scripting
Scripting in Nebula2 means: invoking script commands directly on C++ objects
Every nRoot derived class is scriptable
Scripting languages are exchangeable (e.g. Tcl, Lua, Python)
RadonLabs uses a special Tcl version: MicroTCL
Reduced to 36 commands
Only 160 kByte
Portable (good for minimal environments like game consoles)

Object Persistency
Nebula objects can save themselves into a file, and restore themselves from there
This also works for hierarchies of objects
ASCII and binary fileformats
Persistency files are compatible with the used scripting language
Just run a persistency file through the script server, it takes care of constructing the resulting objects
Advantage: no extra loader code needed

Filesystem
A fileserver object encapsulates the host filesystem
Completely removes differences between Windows-, Linux- or Xbox filesystems
OOP concepts: File and Directory as comfortable C++ classes
Under Windows, the Win32 file routines are used, not the ANSI-C file routines (CreateFile(), WriteFile(), ReadFile(), etc...)
Directory assigns -> textures:image.dds instead of C:\Program Files\...\textures\image.dds . Nebula cares about conversion to absolut path.

File Archives
Similar to Quakeīs PAK files
Packs directory hierarchies into a single file
No wasted disk space with many small files
Drastically smaller loading time
Cleaner application directory layout
Integrated with the Nebula file subsystem

Multithreading
Simple wrapper classes for multithreading when necessary: for blocking Socket routines or background loading of resources

Communication
Nebula2 offers low level wrapper classes for Socket functionality
Optional a simple client/server system or a simple peer-to-peer network
Wrapper for TCP/IP address and a port number

Remote Control
Telnet-like functionality for Nebula2 applications useful for game console development, or remote debugging

Built-in command console
All Nebula applications have an integrated command console

Build-in debug tools
All Nebula applications have integrated debug tools
Texture Viewer
Object Viewer
Light Control Tool
Display Adjustment
System Information

Graphics Subsystem
Complete rewrite for DX9
Full support for DX7 and DX9 hardware
D3DXEffects (.fx files)
D3Dīs HLSL (High Level Shader Language)

Audio Subsystem
Hundreds of sound sources in a 3d environment
Static and streamed sounds
Simple usage

Input Subsystem
Mouse, keyboard, gamepads, joysticks and more supported
Simple and comfortable input mapping (via C++ or script interface)

Resource Management
Resources are: meshes, textures, shaders, fonts, sounds, animation data
Loading of resource data from disk
On demand or preload
Automatically restores resources when necessary (for instance after Alt-Tab)
Optional: resource sharing
Optional: asynchronous resource loading in background thread
Class hierarchie designed to be extended easily by new custom resource classes

Animation Subsystem
Animation data optionally completely in memory, or streamed
ASCII or binary file formats (ASCII good for debugging)
Streaming useful for large cutscenes
Animation data compression
Any type of 4-dimensional data, not just translation, rotation, scaling
Rotation animation through quaternions, not Euler angles
Weighted animation blending

Character Subsystem
Vertex skinning with 4 weights per vertex
Any number of bones per character
Any number of skin meshes per character
Skinning running completely in the vertex shader : no per-vertex operations on the CPU

Special Effects
Particle System for smoke, fire, sparkels and more
Moving Trees
Shaders for grass, water, glass, metal and more
Fog
Bumpmaps
Realtime Shadows
Prerendered Lightmaps
HDR Rendering