PixelLight

Overview

Application framework

The focus of the engine is set on the framework character, which we think is one of the most important ideas for strong and rapid software development. Rather than just providing a set of libraries which have to be adapted or combined differently on specific systems and for every new project, PixelLight gives the user a framework which behaves the same on each supported platform and allows the programmer to "just start" quickly on a specific project. Without having to care about details of a specific system or the components used on that system, a programmer can just work with the framework in the same way on each target platform and use the reflection and component system offered by the framework to control the specific components and backends.

Abstractions for typical use-cases

While everything can be accessed directly, it is often not necessary to do so. To provide an easy start and a smooth learning curve, every part of PixelLight is designed to just work out-of-the-box and implement standard use cases that are often sufficient. This can be used as a starting point to be then adjusted and extended for a specific project. As an example, whole interactive scenes can be created by just using the scene file format, without having to program a single line of code. This is also good for prototyping your ideas before starting off with the development of a new project.

Powerful dynamic type and reflection system

PixelLight provides a modern dynamic type system that allows every component of the system to be inspected and used dynamically at runtime. This makes it easy to work with dynamic components and types provided by the plugin system or even new extensions that have been plugged in dynamically. For example, a new type of scene node added through a plugin could be used by any PixelLight program, even if that program was compiled with a version of PixelLight that did not have this new type of scene node. The application will nonetheless be able to use the new scene node type without even having to be recompiled, just by providing this new plugin in binary form.

Backend based component and plugin architecture

The framework is solely based on a backend principle, which allows it to replace much of it's functionality to work e.g. with another library or on another platform. Unlike other rendering systems, the provided components are therefore not limited to certain APIs or libraries, but can be used with many different backends for each purpose like e.g. rendering, physics or sound. Those backends can also be extended or exchanged easily. This also makes it possible to alter or modify much of the functionality when it is necessary, by providing new implementations. This is combined with a highly flexible plugin system which makes it possible to add or modify functionality from the outside, rather than having to alter the framework itself. It is even possible to exchange a backend at any time and choose another one without having to rewrite big parts of the application.

Rendering API abstraction

PixelLight is not tied to a specific rendering API but provides an own abstraction to the renderer that can be easily adapted, extended or replaced. Currently, OpenGL and OpenGL ES 2.0 backends are provided by the framework as our both fully implemented main backends. But it's easily possible to add other backends, e.g. there is already an experimental DirectX 9 & 11 rendering backend.

Flexible rendering and compositing system

The rendering and compositing system of PixelLight is highly flexible, allowing it to be adjusted just as needed for the specific use case. Currently there are three types of predefined renderer compositions: A shader-based forward renderer for many typical use cases, an also shader-based deferred renderer for high performance game-like projects and even a fixed-function based renderer that can be used to support older hardware. While these standard compositing configurations should be sufficient for most cases, it's also possible to adjust everything and even create completely new compositing steps, if that is needed.

Highly modular scene system

The 3D rendering part of the PixelLight framework offers a highly flexible scene graph based system to create and render virtual 3D scenes. With it's node/modifier based design, the PixelLight scene graph provides a simple yet powerful way to abstract most of the underlying internals of the used components from the user and allows it to choose and combine all the components needed for a certain task. Also the complexity of a scene graph is heavily reduced by allowing combinations of different tasks through the node/modifier system, rather than having a single bloated hierarchy for all tasks together.

XML based file and configuration formats

Nearly all PixelLight file formats and configurations are XML based, which makes them easy to use and quite robust. Many parts of the framework can be accessed through those files, it is even possible to create an entire scene only with a text editor. Because most of the scene functionality is based on the component and reflection system, it is possible to access and control every part of the scene and even it's behaviour (e.g. how the nodes interact with the user) without writing a single line of C++ code.

Wide range of supported file formats

While providing own file formats for best usability and performance, PixelLight also supports a wide range of often-used file formats, e.g. for textures and meshes. We also provide an Open Asset Import Library (ASSIMP) plugin in order to add support for 34 mesh and scene loaders enabling you to use file formats like 3ds, obj, Blender, Collada and so on (see full list). This makes it easy to directly import your data into PixelLight without having to use specific and often complicated importer software first.

Autodesk 3ds Max exporter

PixelLight provides a plugin for the Autodesk 3ds Max modeling software that can be used to export not only models but whole scenes into the engine. It also supports to access the complete scene system of PixelLight, so you can create complete projects including interaction and program logic completely by using Autodesk 3ds Max and running the exported scene. The whole power of the system is of course uncovered by combining this with a little bit of C++ programming using the PixelLight API.

Read more...