Philosophy

Delegates to existing libraries: The goal is not to re-invent things. PVLE uses (when possible) libraries that already do what we want, and integrates them together without hiding them. For instance, physics and scene graph libraries are used to create objects ('entities') that have 3D and physics properties.

As they are not hidden under a layer, you may thus have to know these libraries; but in return you have fewer to learn about PVLE.

PVLE easily takes advantage of new features added to the libraries. Almost nothing has to be done except linking against a newer version.

PVLE can have many dependencies. See dependencies page.

Performant: The engine uses the power of tested and well-known libraries. PVLE itself does the maximum to keep performance while adding features over those libraries.

Modern: Source code is clean, documented, reuseable, object-oriented and designed with a modern C++ style. Those who develop PVLE should not be afraid of templates, design patterns (singleton, visitor...), callbacks, modularity and more... However, the users of PVLE can use features without knowing much of these, as described below.

Portable: PVLE itself and its dependencies are written in standard C/C++ and are cross-platform.

Easy: The engine is meant to leave to the user (ie. game developer) few things to do. By default, values are set so that if fits the most common goals.

Small and simple: Applications may stay rather simple. You may not be able to produce amazing games nor cutting-edge effects if dependencies don't offer them. PVLE does not intend to challenge the last huge game engines written with hundred of programmers and million tons of money.

Pro: Though small and simple, PVLE is written to support high-grade applications. Thus you can find features like "Check online for updates" (with proxy support) that not all applications actually have (even expensive ones!).

Generic: PVLE is a generic engine, in the sense that it does not fit one particular application type. It is simply an engine for real-time applications and simulations. Of course, it may more fit games with classes such as 'Ammo' and 'Team', but these are just additional features.

Open: Project is open source (GPL), cross-platform (Windows, linux, Mac and maybe more) and opened to any developper. Just contact Sukender.

Features

3D / display

[OSG] Structured scene graph, able of optimizations (such as culling).
[OSG] Level Of Detail (LOD) objects.
[OSG] OpenGL Shader Language support.
[OSG] Loaders for various images and meshes file formats (gif, jpg, png, 3ds, lwo, obj...).
[OSG] Visitor support (traversal of node objects).
[PVLE] Dynamic OpenGL light sources assignment.
[PVLE] Particle life-time manager.
[PVLE] Utility classes and functions (HUD, standard sky sphere...).

Physics

[ODE] Physics simulation of articulated rigid body structures.
[ODE] Highly stable physics simulation.
[ODE] Hard contacts (not spring-like contacts).
[ODE] Collision detection for basic shapes (box, sphere, capsule, cylinder...), and for complex meshes.
[PVLE] Collide geometry callbacks that allow a class to be aware of physics changes.
[PVLE] Visitor support (traversal of physics objects)
[PVLE] Debug visuals of collsision geometries (Adds 3D shapes to 'see' physics objects).
[PVLE] Surface parameters merging (Automatically computes the kind of contact of two different surfaces: rubber-concrete, rubber-grass, concrete-ice, concrete-concrete...).

Entities

Entity is "what you see in the game": an object with 3D, physics and networking properties.

[PVLE] Physics-display binding (ability to tie a graphical representation to a physics object).
[PVLE] Entities manager (to add and destroy entities without causing simulation errors).
[PVLE] Utility methods for handling collisions and energy transfers (Cinetik energy of course, but also weapon properties).
[PVLE] Ammunition class, with perforation behavior support (Does a collision but also goes through other solids).
[PVLE] Explosion class.
[PVLE] Some basic elements, such as clouds, and sky sphere.
[PVLE] (Much more to come!).

Inputs

[PVLE] Ability to control the camera (OSG) using any 'matrix getter', that is to say potentially any object of the scene (such as a character, a car...).
[PVLE] Control mapping (Maps keys, mouse axis and buttons to actions).
[PVLE] Special manipulators (FPS-like camera for instance).

Networking

This part is at the moment less-than-alpha. But it should include:

[TNL] Low bandwith (only sends what's needed), bullet-proof (latency, attacks...) UDP networking.
[PVLE / TNL] Ability to transparently clone/send objects and control life-time. Only few methods are to be added to an existing class.

Sound

[PVLE / osgAudio] Spatialized sound.
[osgAudio] Support for ogg/Vorbis streams (via underlying libraries).

Utilities

[PVLE] Traced exception mechanism.
[PVLE / boost] Application options (Unified command line arguments and config file).
[PVLE] Various utilities functions (math, log, strings, app version handling...).

Other

[PVLE] CMake build system (generates project files and makefiles for your compiler).
[PVLE / cURL] "Check online for updates"-type function (with proxy support).
[PVLE / gettext] Internationalisation support with easy translation files.