Introduction

Welcome to Visualization Library!

Visualization Library is a C++ middleware for high-performance 2D and 3D graphics applications based on the industry standard OpenGL 1.x-4.x, designed to develop portable applications for the Windows, Linux and Mac OS X operating systems.

Visualization Library is currently used by professionals, researchers and students to develop all sorts of 2D and 3D applications.

Visualization Libray has been designed to be a fine-grained platform upon which a wide variety of highly-specialized 3D graphics applications can be effectively developed. Instead of abstracting the user from the underlying OpenGL API, Visualization Library stays as close as possible to it and defines a thin high-performance layer on top of it. Thus, many OpenGL functions and features have an intuitive 1 to 1 mapping to Visualization Library's classes.

You can think of Visualization Library as a toolkit that provides you with the power and flexibility of OpenGL within a light and user friendly C++ object oriented framework.

Visualization Library has been developed by Michele Bosi with the help of several contributors (see the Credits page).

Contacts

• michele <at> visualizationlibrary <dot> org
• https://michelebosi.com

Community Resources

• Google Group - The right place to ask for help, ask feedback on your projects and check for news regarding VL, such as releases, bug fixes etc.
• http://twitter.com/VizLibrary - Quick info regarding the latest VL news.

Visualization Library Design Key Features and Goals

• Code developed in standard C++/STL.
• Portable across Windows, Linux and Mac OS X operating systems (32 and 64 bits).
• Friendly API using OpenGL wording and conventions.
• Minimalistic, efficient and reliable design.
• Debug-friendly behaviour.
• Designed to be a sensible, high-performance, thin layer on top of OpenGL:
  • Being a thin wrapper around OpenGL, Visualization Library not only provides the developer with a generic, fast and light 2-3D framework suitable for multiple purposes but also exposes the programmer to a familiar framework. In fact, most of the OpenGL mechanisms are mapped in an intuitive way to Visualization Library's API, maximizing the value of the OpenGL developer's experience and know-how. See OpenGL vs VL Feature Mapping page for more information.

• Developed for today's and tomorrow's hardware:
  
  • Visualization Library's core architecture is based on technologies such as OpenGL Shading Language, Framebuffer Objects, Multiple Render Targets, Geometry Shaders, Tessellation Shaders, Pixel and Vertex Buffer Objects etc. while at the same time retains full compatibility with OpenGL 1.1 class hardware.

• Compatible with OpenGL 1.x, designed for OpenGL 2.x, 3.x and 4.x:
  • Many legacy features like accumulation buffer, edge flags, indexed rendering, immediate mode, feedback mode, picking mode etc. have been removed in order to keep Visualization Library as simple as possible and to guarantee that only the optimal rendering paths are used. Special attention has been paid in order to make Visualization Library's design neater and closer to OpenGL ES 2.0 and OpenGL 4.x principles.

• GUI independent:
  • Like OpenGL, Visualization Library does not depend or rely on any GUI library. It is the user's responsibility to provide an adequate OpenGL context on which Visualization Library operates. However, several utility GUI bindings (Qt4, MFC, Win32...) are provided to further simplify the development process.

• Non direct multithreading support but multithreading-aware:
  • Like OpenGL, Visualization Library does not provide any special multithreading commands/classes or a multithreading library. It is the user's responsibility to take care of the various aspects involved in the development of a multithreaded or distributed application. However, Visualization Library have been designed to minimize multithreading-related issues as much as possible. See Multi-Threading with VL for more VL specific info on the topic. You might also want to use Visualization Library in conjunction with the following: Intel® Threading Building Blocks, VR Juggler, Chromium.

Quick Feature Overview

• Support to OpenGL 1.x, 2.x, 3.x and 4.1.
• Experimental support to OpenGL ES 1.1, OpenGL ES 2.0.
• 3D file formats: VLT and VLB proprietary formats, COLLADA, 3DS, OBJ, PLY (binary and ascii), STL (binary and ascii), AC3D, MD2.
• 2D Image file formats: JPG, PNG, TGA, TIFF, BMP, DDS, DICOM, RAW.
• VLX serialization framework to load/save VL classes to/from VLT and VLB files.
• GUI bindings: Win32, MFC, Qt4, wxWidgets, SDL, GLUT, EGL (experimental).
• Volume rendering facilities: direct volume rendering via screen aligned slices, ray casting (transfer functions, isosurface, MIP etc.) and marching cubes for isosurface extraction.
• Virtual File System: read/write disk files and directories, read .ZIP files and directories, read/write memory files and directories, read/write .GZ files.
• Texturing: all texture formats and techniques supported by OpenGL 1.x, 2.x, 3.x, 4.1: 1D, 2D, 3D textures, cube map textures, 1D and 2D texture arrays, texture rectangles, multisampled textures, texture buffer objects, multi-texturing, render to texture, texture coordinate generation, texture combiners, mipmapping and hw mipmaps generation, anisotropic filtering, compressed textures, depth textures, integer textures, float and half float texture formats, 2 components textures etc.
• OpenGL Shading Language.
• C++ vector/matrix library based on GLSL specs.
• Geometry Shaders.
• Tessellation Shaders.
• Framebuffer Objects.
• FBO multiple render targets.
• Vertex Buffer Objects.
• Pixel Buffer Objects.
• Display Lists.
• Configurable to use single or double precision math by default.
• OpenGL accelerated 2D vector graphics facilities.
• Multisampling.
• High quality unicode text rendering and text manipulation functions and classes.
• Billboards.
• Clipping planes.
• All standard OpenGL lighting models: point lights, directional lights, spot lights.
• Hierachical frustum culling against boxes and spheres.
• Hierachical bounding volume scene managers.
• Kd-Tree hierachical scene manager.
• Portal/sector scene manager.
• Kd-Tree based terrain scene manager (with GPU acceleration if available).
• Multiple scene managers in one rendering.
• Hierarchical matrix transformations.
• GPU geometry instancing.
• Geometry Level of Detail.
• Shader Level of Deatil.
• Multipassing effects.
• Fully configurable rendering pipeline.
• Multiple cameras and multiple renderings.
• Automatic render state sorting and lazy setup.
• Automatic transparency management and optional sorting at the polygon level.
• Fully configurable object rendering order.
• Resource sharing design: render states, textures, geometry data, shaders etc. almost anything can be shared and reused in different places.
• Smart memory management via reference counting.
• Extensible resource system to support new resource types.
• Fast triangle reduction based on the "Quadric Error Metrics Surface Simplification" algorithm to generate multiple resolutions of the same mesh.
• Image type and format conversion functions.
• Trackball manipulator.
• Several functions to manipulate and optimize 3d objects such as triangle stripping, draw call merging, index optimization etc.
• Fast high quality random number generation based on Mersenne Twister.
• RFC4122 UUID Version 4 generator.
• Molecular visualization.
• Extrusion generation.
• Linear and Catmull-Rom path interpolation.
• Bicubic Bézier surfaces.
• Edge and silhouette enhancement.
• GPU accelerated occlusion culling.
• Interactive object picking.
• ... and much more, see All Classes and Features Overview for a more in-depth overview of Visualization Library's features.