Navigation   Recent Headlines
News
Features
Forums
Downloads
Screenshots
Documentation
License

Features

What is XEngine?

XEngine is a platform- and rendering-API-independent 3D engine for real-time visualization with support for programmable graphics pipeline architectures and is implemented in C++. The engine aims at flexible support for many of the shading languages available today, so that existing shaders can easily be re-used. This includes current assembler-like languages as well as high-level languages, such as NVIDIA's Cg. In addition, integration of new shading languages should be easily possible with the engine's design.
In the implementation, emphasis is given to using best practices and modern C++ techniques, including template metaprogramming and expression templates, and re-using existing, excellent open source libraries, in particular wxWidgets, the Boost libraries, the Spirit parser generator framework, and some others.
Another goal of the project is to provide open source parsers and cross-translators for a number of low-level shading languages, developed with the Spirit parser framework.

Basic Features

XEngine has three main components, XEngineMath, XEngineCore, and XEngineUtil. XEngineMath contains all the mathematics routines and classes for handling vectors, matrices, quaternions, and a number of geometric objects. XEngineCore is the core render system and can be seen as a wrapper of an underlying 3D graphics API, such as OpenGL or Direct3D. XEngineUtil offers various utility classes that build on XEngineCore. Examples include classes for rendering height maps and waves tiles, a texture generator class, and a skybox class. XEngineUtil can be seen as a kind of scratchpad for new ideas and for experimenting with new techniques. Some parts of it might eventually become part of an XEngineScene component in the future which will comprise a scene management system with visibility culling and support for programmable shaders.

  • Object-oriented design and implementation
  • The implementation uses modern C++ techniques, design patterns, and tries to adhere to acknowledged best practices.
  • Mathematics library with a large number of easy to use classes (vectors, matrices, quaternions, a number of geometric objects, splines)
  • Support for programmable shaders in various shading languages (see below which languages are currently supported)
  • Automatic state tracking (similar to ARB_vertex_program) for all supported shading languages and shader types
  • 1D, 2D, 3D, and cube map textures
  • Easy to use render to texture feature (1D, 2D, and cube map textures)
  • Easy creation of texture objects from image files. Lots of supported formats: DDS, TIFF, BMP, JPEG, PNG, PNM, XPM, ...
  • Efficient vertex and index buffers (using ARB_vertex_buffer_object in OpenGL and vertex/index buffers in Direct3D)
  • Extensive API reference documentation
  • Numerous useful helper classes in XEngineUtil, such as:
    • Waves tiles for rendering ocean water (Gerstner waves or FFT-based statistical waves model)
    • Texture generator for generating normalization cube maps, noise textures, and other useful textures
    • Skybox class
    • Mesh class that uses hardware vertex and index buffers
    • Model loaders for the following formats:
      • Autodesk 3D Studio (.3ds) files
      • Quake 2 Model (.md2) files

Currently Supported Platforms

In its current (very early alpha) state, XEngine supports the following platforms:

  • All modern Win32-based operating systems
    • Windows 98
    • Windows ME
    • Windows 2000
    • Windows XP
  • Linux
  • Possibly other Unixes as well as long as they have a modern C++ compiler and at least OpenGL 1.3 drivers (Mesa 5.0+ will work)

I'm currently looking for people to maintain the Linux port and somebody interested in porting the engine to Mac OS X. Actually, a lot of the work needed for a Mac port has already been done. However, since I do not own a Mac I need somebody to finish the port, test it, and possibly maintain it in the future.

Currently Supported 3D Graphics APIs

At the moment, XEngine comes with renderer libraries for the following 3D graphics APIs:

  • Direct3D 8.1
  • Direct3D 9.0
  • OpenGL 1.3 and up (plus various extensions)

Currently Supported Shading Languages

XEngine supports a wide range of shading languages, most of them on all renderers using special cross-compilers. All the shading languages in the following list can be used with both the Direct3D and the OpenGL renderer unless otherwise noted. For most of them XEngine provides its own parser to enable better error checking and consistent error messages.

  • NV_vertex_program
  • NV_vertex_program1_1
  • NV_vertex_program2 (currently only with the OpenGL renderer)
  • ARB_vertex_program
  • ARB_fragment_program (currently only with the OpenGL renderer)
  • ATI_text_fragment_shader (currently only with the OpenGL renderer)
  • DirectX vertex shader assembler 1.0 and 1.1
  • DirectX pixel shader assembler 1.0, 1.1, 1.2, and 1.3
  • HLSL (only supported with the Direct3D 9 renderer)
  • Cg vertex programs
    • Using XEngine's internal Cg runtime the vp20 and arbvp1 can be used with the OpenGL renderer, and the vs_1_1 profile with the Direct3D renderers.
    • Using NVIDIA's Cg runtime any OpenGL profile can be used with the OpenGL renderer, and similarly any Direct3D profile can be used with the Direct3D renderers.
  • Cg fragment programs
    • Using XEngine's internal Cg runtime the ps_1_1, ps_1_2, and ps_1_3 profiles can be used with the OpenGL and Direct3D renderers.
    • Using NVIDIA's Cg runtime any OpenGL profile can be used with the OpenGL renderer, and similarly any Direct3D profile can be used with the Direct3D renderers.

Platform Independence

Platform and rendering API independence are two very important paradigms for the design of the engine. Platform independence means that application programs using the engine only need to be re-compiled to run on a different platform. Porting the engine to other operating systems is quite easy and does not require notable modifications to the engine's code base.

Rendering API Independence

Rendering API independence means that the engine is built in a way that allows various rendering APIs to be used to perform the required graphics operations. This API independence is implemented using dynamic shared libraries that can be loaded at run-time. Each library implements a renderer for a specific rendering API. Thereby, the engine can easily be extended for new rendering APIs by simply providing an additional dynamic shared library. This approach also allows for switching between renderers at run-time. An application can even render to one window using, for example, OpenGL and another window using Direct3D.

Requirements

By design, XEngine is meant to be used with programmable 3D graphics hardware. It is especially not intended to be used with older graphics hardware with no shader support whatsoever, even though it will run on those cards. But you're only using about half of the features that XEngine has to offer, if you're not using programmable shaders.
The currently available, recommended graphics cards to be used with XEngine are: NVIDIA GeForce3 or newer, ATI Radeon 8500 or newer, Matrox Parhelia or newer, and cards with the 3dlabs P10 chip.

Dependencies on Other Libraries

XEngine depends and uses the following other open source libraries:

To provide platform independence, XEngine uses the open source, platform-independent windowing toolkit wxWidgets with which it tightly integrates. Thus writing a level editor should be very easy with this combination.
The open source STL implementation STLport is used to have an efficient, thread-safe, and platform-independent implementation of the STL.
The Boost library is used for its various very helpful template classes, such as its smart pointers. Also the Spirit parser generator library that is part of Boost is used in XEngine's shading language parsers.
The image library DevIL is used to load images from files in addition to the image file loaders offered by wxWidgets
lib3ds is used to load mesh data from Autodesk 3DS files.

Note that the use of STLport, DevIL, lib3ds, and FFTW is optional.

April 10, 2006
CVS Migrated to Subversion
 
June 05, 2005
Upgraded to wxWidgets 2.6.1 and Boost 1.33.0
 
December 02, 2004
CVS Stable Again
 
November 25, 2004
CVS Instable for a Few Days
 
November 14, 2004
ARB_fragment_program Parser and Other Changes
 
July 16, 2004
XEngine Announcements Mailing List
 
June 20, 2004
New PixelFormat Class
 
April 25, 2004
Update to wxWidgets 2.5.1 and Point Parameters