oZone3D is an extremely powerful, extensible and easy to use 3D engine targeting a wide array of modern platforms including Microsoft Windows, Unix and Linux. Real time means "immediate interactivity" for the user. The included functionalities make it possible to build applications in which the user can interact with the different elements of the 3D scene, handle and modify all type of graphic entities (objects, textures, colors etc.). oZone3D consists in a set of high level functionalities and is delivered as a C++ SDK.

Developed in C++, the oZone3D Engine has been architected from the ground up with the following design principles: It allows fast conception of 3D graphic applications based on a set of powerful graphic instructions which dramatically increases developers’ productivity. Referring to several (about one hundred) progressive tutorials, oZone3D allows developers to build up any application requiring 3D (or 2D) data visualisation.

The oZone3D technology is especially designed for companies willing to develop graphic applications to exploit 2D or 3D data. oZone3D takes efficiently benefits from the tremendous improvement achieved by the new 3D graphic chipset. oZone3D users, considering the recent evolution of the 3D technology , are developers who preferably use the C++ programming language and have good software development skills. Moreover, relying on clear and high technical level tutorials provided with the SDK, oZone3D allows anyone who has basic programming knowledge to build various applications.



Very fast: the oZone3D provides the developer with an incredible amount of functionalities that fit their most demanding needs. The engine ships with everything from basic polygon manipulation and math libraries to pixel and vertex shaders or particle systems. With an unique architecture, oZone3D is one of the most powerful 3D engine that exploits better than ever every new 3D graphic chipset’s features.
Simple to use: built on an original concept, based on very efficient and optimised algorithms that provides an amazing speed for realtime rendering, the oZone3D SDK is indeed very simple to use with a C++ compiler.
Portability: The portability in the Unix and Linux environment is perfectly possible. The oZone3D Engine uses abstract driver layers to shield the developer from the platform and environment, but at the same time, provides the option to control these low level components if so desired. This provides for a simple and smooth porting process while promoting the maximum amount of code reuse.
Opened architecture: an open interface for the integration in specific processes’ development. It is therefore possible to implement additional software components (plugins) and to use them from oZone3D. This allows the developer to control the engine in a virtually infinite amount of ways to suit their specific needs.
Flexibility: Through the use of the oZone3D’s unique system, not only can the developer leverage existing features of the engine, but they can also extend engine functionality and even create brand new objects and behaviors using the oZone3D’s object framework.
Evolutive architecture: this original architecture makes oZone3D a perfectly progressive tool that is devoted to last and to easily adapt to the 3D technological innovations.
Documentations and tutorials: oZone3D is delivered with many progressive tutorials, clearly commented for a quick start.
Continuously released: oZone3D is in constant evolution in order to match the latest improvements regarding 3D technology.


Features:

General:

- Full C++ SDK (currently only available on PC/Win32 platform)
- Oriented object API, easy to use
- Open arhitecture based on plugins (for graphics abstraction layer, scene rendering engine, data loading and so on)
- OpenGL graphics abstraction layer plugin (OpenGL 1.5) with GLSL support (OpenGL Shading Language)
- Plugin d’abstraction graphique OpenGL (OpenGL 1.5) avec support du GLSL (OpenGL Shading Language) to simplify vertex and pixel shader programming
- Mathematical library with vectors, matrices and quaternions

3D files formats management:

- 3D files formats reading and writing is done using plugins
- *.3DS (3D Studio Binary Scene File)
- *.ASE (3D Studio ASCII Scene File)
- *.TXT (MilkShape3D ASCII Object File)
- *.O3MDL (oZone3D Binary Object File)
- *.OBJ (Alias |Wavefront ASCII Object File)
- *.XML: oZone3D Simple Object Desription Format (for developers)
- *.FBX (Alias Kaydara FBX interchange format)

Textures management:

- Texture Manager
- 2D files formats reading and writing is done using plugins
- Main formats supported: *.jpg, *.tga, *.bmp, *.png, *.psd, *.gif, ...
- Hardware-limited texture size. Support of non-power of 2 texture size
- Opacity-maps support by alpha-chanel injection.
- Procedural Perlin noise textures

Camera

- serveral cameras per scene
- Perspective and orthographic view
- Serveral viewports
- All camera parameters are available (field of view (FOV), clipping planes, position, orientation, internal matrices)
- Many ready-to-use functions available to manage camera easily

Lighting:

- Lighting Manager
- control up to 8 dynamic lights of different type: point, directionnal or spot, including each of the light components ambient, diffuse, specular, position, angle and orientation.

Meshes rendering:

- simple and multitexturing up to 8 layers (graphics controller dependent)
- shading mode: flat and gouraud through the fixed functions or any other mode through programmable shaders
- lighting
- back face culling
- solid or wireframe
- automatic texture loading
- vertex scaling
- high performance rendering using VBO
- normals flipping
- seam removing
- FSAA: full scene anti aliasing

Materials:

- ambient, diffuse, specular, opacity componant management.
- possibility to attach directly textures to materials
- possibility to attach directly gpu-shaders to materials

Classic effects:

- Stencil shadow volumes
- Static and dynamic cube mapping
- DOT3 bump mapping using fixed functions
- alpha/opcacty maps by injection into alpha channel
- procedural texture generation based on Perlin noise
- Planar and non-planar reflections using reflection texture
- Skyboxes
- terrain generation from heightmaps
- HUD (Head Up Display) support

Particle System:

- All particle system actors (emitters, actions and obstacles) are plugin-based.
- Emitters: point, disc, sphere, line, mesh, matrix text.
- Obstacles: disc, sphere, plan, mesh.
- Controller/Actions: gravity, size, color, orbit point.

Vertex and Pixel Shaders:

- GLSL (OpenGL Shading Language) support

Sound-system:
- Sound file format reading is done with plugins
- Main formats supported: *.wav, *.mp3, *.xm, *.s3m, *.it, *.mod

Animation:

- Bezier spline based motion paths for almost all objects (cameras, models, meshes, lights, ...)

Divers:

- High performance Delaunay Triangulation
- 3D picking into whole scene using ray-casting
- Transparent objects are automatically managed.
- 3D Lens Flare system (plugin).
- Scripts generation for offline renderers (POVRay, ...) (plugin)
- Many basic geometric primitives (vertex, line, triangle, vector, disc, sphere, box, plane)
- Many basic meshes (cylinder, plane, sphere, torus, terrain, disc, Bézier surface)
- TCP/UDP socket support through a standard interface. Win32 socket plugin available
- Large number of tutorials covering all aspects of engine programming